drivers/net/usb/lan78xx.c

   1 /*
   2  * Copyright (C) 2015 Microchip Technology
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17 #include <linux/version.h>
  18 #include <linux/module.h>
  19 #include <linux/netdevice.h>
  20 #include <linux/etherdevice.h>
  21 #include <linux/ethtool.h>
  22 #include <linux/mii.h>
  23 #include <linux/usb.h>
  24 #include <linux/crc32.h>
  25 #include <linux/signal.h>
  26 #include <linux/slab.h>
  27 #include <linux/if_vlan.h>
  28 #include <linux/uaccess.h>
  29 #include <linux/list.h>
  30 #include <linux/ip.h>
  31 #include <linux/ipv6.h>
  32 #include <linux/mdio.h>
  33 #include <net/ip6_checksum.h>
  34 #include "lan78xx.h"
  35
  36 #define DRIVER_AUTHOR   "WOOJUNG HUH <woojung.huh@microchip.com>"
  37 #define DRIVER_DESC     "LAN78XX USB 3.0 Gigabit Ethernet Devices"
  38 #define DRIVER_NAME     "lan78xx"
  39 #define DRIVER_VERSION  "1.0.0"
  40
  41 #define TX_TIMEOUT_JIFFIES              (5 * HZ)
  42 #define THROTTLE_JIFFIES                (HZ / 8)
  43 #define UNLINK_TIMEOUT_MS               3
  44
  45 #define RX_MAX_QUEUE_MEMORY             (60 * 1518)
  46
  47 #define SS_USB_PKT_SIZE                 (1024)
  48 #define HS_USB_PKT_SIZE                 (512)
  49 #define FS_USB_PKT_SIZE                 (64)
  50
  51 #define MAX_RX_FIFO_SIZE                (12 * 1024)
  52 #define MAX_TX_FIFO_SIZE                (12 * 1024)
  53 #define DEFAULT_BURST_CAP_SIZE          (MAX_TX_FIFO_SIZE)
  54 #define DEFAULT_BULK_IN_DELAY           (0x0800)
  55 #define MAX_SINGLE_PACKET_SIZE          (9000)
  56 #define DEFAULT_TX_CSUM_ENABLE          (true)
  57 #define DEFAULT_RX_CSUM_ENABLE          (true)
  58 #define DEFAULT_TSO_CSUM_ENABLE         (true)
  59 #define DEFAULT_VLAN_FILTER_ENABLE      (true)
  60 #define INTERNAL_PHY_ID                 (2)     /* 2: GMII */
  61 #define TX_OVERHEAD                     (8)
  62 #define RXW_PADDING                     2
  63
  64 #define LAN78XX_USB_VENDOR_ID           (0x0424)
  65 #define LAN7800_USB_PRODUCT_ID          (0x7800)
  66 #define LAN7850_USB_PRODUCT_ID          (0x7850)
  67 #define LAN78XX_EEPROM_MAGIC            (0x78A5)
  68 #define LAN78XX_OTP_MAGIC               (0x78F3)
  69
  70 #define MII_READ                        1
  71 #define MII_WRITE                       0
  72
  73 #define EEPROM_INDICATOR                (0xA5)
  74 #define EEPROM_MAC_OFFSET               (0x01)
  75 #define MAX_EEPROM_SIZE                 512
  76 #define OTP_INDICATOR_1                 (0xF3)
  77 #define OTP_INDICATOR_2                 (0xF7)
  78
  79 #define WAKE_ALL                        (WAKE_PHY | WAKE_UCAST | \
  80                                          WAKE_MCAST | WAKE_BCAST | \
  81                                          WAKE_ARP | WAKE_MAGIC)
  82
  83 /* USB related defines */
  84 #define BULK_IN_PIPE                    1
  85 #define BULK_OUT_PIPE                   2
  86
  87 /* default autosuspend delay (mSec)*/
  88 #define DEFAULT_AUTOSUSPEND_DELAY       (10 * 1000)
  89
  90 static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
  91         "RX FCS Errors",
  92         "RX Alignment Errors",
  93         "Rx Fragment Errors",
  94         "RX Jabber Errors",
  95         "RX Undersize Frame Errors",
  96         "RX Oversize Frame Errors",
  97         "RX Dropped Frames",
  98         "RX Unicast Byte Count",
  99         "RX Broadcast Byte Count",
 100         "RX Multicast Byte Count",
 101         "RX Unicast Frames",
 102         "RX Broadcast Frames",
 103         "RX Multicast Frames",
 104         "RX Pause Frames",
 105         "RX 64 Byte Frames",
 106         "RX 65 - 127 Byte Frames",
 107         "RX 128 - 255 Byte Frames",
 108         "RX 256 - 511 Bytes Frames",
 109         "RX 512 - 1023 Byte Frames",
 110         "RX 1024 - 1518 Byte Frames",
 111         "RX Greater 1518 Byte Frames",
 112         "EEE RX LPI Transitions",
 113         "EEE RX LPI Time",
 114         "TX FCS Errors",
 115         "TX Excess Deferral Errors",
 116         "TX Carrier Errors",
 117         "TX Bad Byte Count",
 118         "TX Single Collisions",
 119         "TX Multiple Collisions",
 120         "TX Excessive Collision",
 121         "TX Late Collisions",
 122         "TX Unicast Byte Count",
 123         "TX Broadcast Byte Count",
 124         "TX Multicast Byte Count",
 125         "TX Unicast Frames",
 126         "TX Broadcast Frames",
 127         "TX Multicast Frames",
 128         "TX Pause Frames",
 129         "TX 64 Byte Frames",
 130         "TX 65 - 127 Byte Frames",
 131         "TX 128 - 255 Byte Frames",
 132         "TX 256 - 511 Bytes Frames",
 133         "TX 512 - 1023 Byte Frames",
 134         "TX 1024 - 1518 Byte Frames",
 135         "TX Greater 1518 Byte Frames",
 136         "EEE TX LPI Transitions",
 137         "EEE TX LPI Time",
 138 };
 139
 140 struct lan78xx_statstage {
 141         u32 rx_fcs_errors;
 142         u32 rx_alignment_errors;
 143         u32 rx_fragment_errors;
 144         u32 rx_jabber_errors;
 145         u32 rx_undersize_frame_errors;
 146         u32 rx_oversize_frame_errors;
 147         u32 rx_dropped_frames;
 148         u32 rx_unicast_byte_count;
 149         u32 rx_broadcast_byte_count;
 150         u32 rx_multicast_byte_count;
 151         u32 rx_unicast_frames;
 152         u32 rx_broadcast_frames;
 153         u32 rx_multicast_frames;
 154         u32 rx_pause_frames;
 155         u32 rx_64_byte_frames;
 156         u32 rx_65_127_byte_frames;
 157         u32 rx_128_255_byte_frames;
 158         u32 rx_256_511_bytes_frames;
 159         u32 rx_512_1023_byte_frames;
 160         u32 rx_1024_1518_byte_frames;
 161         u32 rx_greater_1518_byte_frames;
 162         u32 eee_rx_lpi_transitions;
 163         u32 eee_rx_lpi_time;
 164         u32 tx_fcs_errors;
 165         u32 tx_excess_deferral_errors;
 166         u32 tx_carrier_errors;
 167         u32 tx_bad_byte_count;
 168         u32 tx_single_collisions;
 169         u32 tx_multiple_collisions;
 170         u32 tx_excessive_collision;
 171         u32 tx_late_collisions;
 172         u32 tx_unicast_byte_count;
 173         u32 tx_broadcast_byte_count;
 174         u32 tx_multicast_byte_count;
 175         u32 tx_unicast_frames;
 176         u32 tx_broadcast_frames;
 177         u32 tx_multicast_frames;
 178         u32 tx_pause_frames;
 179         u32 tx_64_byte_frames;
 180         u32 tx_65_127_byte_frames;
 181         u32 tx_128_255_byte_frames;
 182         u32 tx_256_511_bytes_frames;
 183         u32 tx_512_1023_byte_frames;
 184         u32 tx_1024_1518_byte_frames;
 185         u32 tx_greater_1518_byte_frames;
 186         u32 eee_tx_lpi_transitions;
 187         u32 eee_tx_lpi_time;
 188 };
 189
 190 struct lan78xx_net;
 191
 192 struct lan78xx_priv {
 193         struct lan78xx_net *dev;
 194         u32 rfe_ctl;
 195         u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicat hash table */
 196         u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
 197         u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
 198         struct mutex dataport_mutex; /* for dataport access */
 199         spinlock_t rfe_ctl_lock; /* for rfe register access */
 200         struct work_struct set_multicast;
 201         struct work_struct set_vlan;
 202         u32 wol;
 203 };
 204
 205 enum skb_state {
 206         illegal = 0,
 207         tx_start,
 208         tx_done,
 209         rx_start,
 210         rx_done,
 211         rx_cleanup,
 212         unlink_start
 213 };
 214
 215 struct skb_data {               /* skb->cb is one of these */
 216         struct urb *urb;
 217         struct lan78xx_net *dev;
 218         enum skb_state state;
 219         size_t length;
 220 };
 221
 222 struct usb_context {
 223         struct usb_ctrlrequest req;
 224         struct lan78xx_net *dev;
 225 };
 226
 227 #define EVENT_TX_HALT                   0
 228 #define EVENT_RX_HALT                   1
 229 #define EVENT_RX_MEMORY                 2
 230 #define EVENT_STS_SPLIT                 3
 231 #define EVENT_LINK_RESET                4
 232 #define EVENT_RX_PAUSED                 5
 233 #define EVENT_DEV_WAKING                6
 234 #define EVENT_DEV_ASLEEP                7
 235 #define EVENT_DEV_OPEN                  8
 236
 237 struct lan78xx_net {
 238         struct net_device       *net;
 239         struct usb_device       *udev;
 240         struct usb_interface    *intf;
 241         void                    *driver_priv;
 242
 243         int                     rx_qlen;
 244         int                     tx_qlen;
 245         struct sk_buff_head     rxq;
 246         struct sk_buff_head     txq;
 247         struct sk_buff_head     done;
 248         struct sk_buff_head     rxq_pause;
 249         struct sk_buff_head     txq_pend;
 250
 251         struct tasklet_struct   bh;
 252         struct delayed_work     wq;
 253
 254         struct usb_host_endpoint *ep_blkin;
 255         struct usb_host_endpoint *ep_blkout;
 256         struct usb_host_endpoint *ep_intr;
 257
 258         int                     msg_enable;
 259
 260         struct urb              *urb_intr;
 261         struct usb_anchor       deferred;
 262
 263         struct mutex            phy_mutex; /* for phy access */
 264         unsigned                pipe_in, pipe_out, pipe_intr;
 265
 266         u32                     hard_mtu;       /* count any extra framing */
 267         size_t                  rx_urb_size;    /* size for rx urbs */
 268
 269         unsigned long           flags;
 270
 271         wait_queue_head_t       *wait;
 272         unsigned char           suspend_count;
 273
 274         unsigned                maxpacket;
 275         struct timer_list       delay;
 276
 277         unsigned long           data[5];
 278         struct mii_if_info      mii;
 279
 280         int                     link_on;
 281         u8                      mdix_ctrl;
 282 };
 283
 284 /* use ethtool to change the level for any given device */
 285 static int msg_level = -1;
 286 module_param(msg_level, int, 0);
 287 MODULE_PARM_DESC(msg_level, "Override default message level");
 288
 289 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
 290 {
 291         u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
 292         int ret;
 293
 294         if (!buf)
 295                 return -ENOMEM;
 296
 297         ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
 298                               USB_VENDOR_REQUEST_READ_REGISTER,
 299                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 300                               0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
 301         if (likely(ret >= 0)) {
 302                 le32_to_cpus(buf);
 303                 *data = *buf;
 304         } else {
 305                 netdev_warn(dev->net,
 306                             "Failed to read register index 0x%08x. ret = %d",
 307                             index, ret);
 308         }
 309
 310         kfree(buf);
 311
 312         return ret;
 313 }
 314
 315 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
 316 {
 317         u32 *buf = kmalloc(sizeof(u32), GFP_KERNEL);
 318         int ret;
 319
 320         if (!buf)
 321                 return -ENOMEM;
 322
 323         *buf = data;
 324         cpu_to_le32s(buf);
 325
 326         ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
 327                               USB_VENDOR_REQUEST_WRITE_REGISTER,
 328                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 329                               0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
 330         if (unlikely(ret < 0)) {
 331                 netdev_warn(dev->net,
 332                             "Failed to write register index 0x%08x. ret = %d",
 333                             index, ret);
 334         }
 335
 336         kfree(buf);
 337
 338         return ret;
 339 }
 340
 341 static int lan78xx_read_stats(struct lan78xx_net *dev,
 342                               struct lan78xx_statstage *data)
 343 {
 344         int ret = 0;
 345         int i;
 346         struct lan78xx_statstage *stats;
 347         u32 *src;
 348         u32 *dst;
 349
 350         stats = kmalloc(sizeof(*stats), GFP_KERNEL);
 351         if (!stats)
 352                 return -ENOMEM;
 353
 354         ret = usb_control_msg(dev->udev,
 355                               usb_rcvctrlpipe(dev->udev, 0),
 356                               USB_VENDOR_REQUEST_GET_STATS,
 357                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 358                               0,
 359                               0,
 360                               (void *)stats,
 361                               sizeof(*stats),
 362                               USB_CTRL_SET_TIMEOUT);
 363         if (likely(ret >= 0)) {
 364                 src = (u32 *)stats;
 365                 dst = (u32 *)data;
 366                 for (i = 0; i < sizeof(*stats)/sizeof(u32); i++) {
 367                         le32_to_cpus(&src[i]);
 368                         dst[i] = src[i];
 369                 }
 370         } else {
 371                 netdev_warn(dev->net,
 372                             "Failed to read stat ret = 0x%x", ret);
 373         }
 374
 375         kfree(stats);
 376
 377         return ret;
 378 }
 379
 380 /* Loop until the read is completed with timeout called with phy_mutex held */
 381 static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
 382 {
 383         unsigned long start_time = jiffies;
 384         u32 val;
 385         int ret;
 386
 387         do {
 388                 ret = lan78xx_read_reg(dev, MII_ACC, &val);
 389                 if (unlikely(ret < 0))
 390                         return -EIO;
 391
 392                 if (!(val & MII_ACC_MII_BUSY_))
 393                         return 0;
 394         } while (!time_after(jiffies, start_time + HZ));
 395
 396         return -EIO;
 397 }
 398
 399 static inline u32 mii_access(int id, int index, int read)
 400 {
 401         u32 ret;
 402
 403         ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
 404         ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
 405         if (read)
 406                 ret |= MII_ACC_MII_READ_;
 407         else
 408                 ret |= MII_ACC_MII_WRITE_;
 409         ret |= MII_ACC_MII_BUSY_;
 410
 411         return ret;
 412 }
 413
 414 static int lan78xx_mdio_read(struct net_device *netdev, int phy_id, int idx)
 415 {
 416         struct lan78xx_net *dev = netdev_priv(netdev);
 417         u32 val, addr;
 418         int ret;
 419
 420         ret = usb_autopm_get_interface(dev->intf);
 421         if (ret < 0)
 422                 return ret;
 423
 424         mutex_lock(&dev->phy_mutex);
 425
 426         /* confirm MII not busy */
 427         ret = lan78xx_phy_wait_not_busy(dev);
 428         if (ret < 0)
 429                 goto done;
 430
 431         /* set the address, index & direction (read from PHY) */
 432         phy_id &= dev->mii.phy_id_mask;
 433         idx &= dev->mii.reg_num_mask;
 434         addr = mii_access(phy_id, idx, MII_READ);
 435         ret = lan78xx_write_reg(dev, MII_ACC, addr);
 436
 437         ret = lan78xx_phy_wait_not_busy(dev);
 438         if (ret < 0)
 439                 goto done;
 440
 441         ret = lan78xx_read_reg(dev, MII_DATA, &val);
 442
 443         ret = (int)(val & 0xFFFF);
 444
 445 done:
 446         mutex_unlock(&dev->phy_mutex);
 447         usb_autopm_put_interface(dev->intf);
 448         return ret;
 449 }
 450
 451 static void lan78xx_mdio_write(struct net_device *netdev, int phy_id,
 452                                int idx, int regval)
 453 {
 454         struct lan78xx_net *dev = netdev_priv(netdev);
 455         u32 val, addr;
 456         int ret;
 457
 458         if (usb_autopm_get_interface(dev->intf) < 0)
 459                 return;
 460
 461         mutex_lock(&dev->phy_mutex);
 462
 463         /* confirm MII not busy */
 464         ret = lan78xx_phy_wait_not_busy(dev);
 465         if (ret < 0)
 466                 goto done;
 467
 468         val = regval;
 469         ret = lan78xx_write_reg(dev, MII_DATA, val);
 470
 471         /* set the address, index & direction (write to PHY) */
 472         phy_id &= dev->mii.phy_id_mask;
 473         idx &= dev->mii.reg_num_mask;
 474         addr = mii_access(phy_id, idx, MII_WRITE);
 475         ret = lan78xx_write_reg(dev, MII_ACC, addr);
 476
 477         ret = lan78xx_phy_wait_not_busy(dev);
 478         if (ret < 0)
 479                 goto done;
 480
 481 done:
 482         mutex_unlock(&dev->phy_mutex);
 483         usb_autopm_put_interface(dev->intf);
 484 }
 485
 486 static void lan78xx_mmd_write(struct net_device *netdev, int phy_id,
 487                               int mmddev, int mmdidx, int regval)
 488 {
 489         struct lan78xx_net *dev = netdev_priv(netdev);
 490         u32 val, addr;
 491         int ret;
 492
 493         if (usb_autopm_get_interface(dev->intf) < 0)
 494                 return;
 495
 496         mutex_lock(&dev->phy_mutex);
 497
 498         /* confirm MII not busy */
 499         ret = lan78xx_phy_wait_not_busy(dev);
 500         if (ret < 0)
 501                 goto done;
 502
 503         mmddev &= 0x1F;
 504
 505         /* set up device address for MMD */
 506         ret = lan78xx_write_reg(dev, MII_DATA, mmddev);
 507
 508         phy_id &= dev->mii.phy_id_mask;
 509         addr = mii_access(phy_id, PHY_MMD_CTL, MII_WRITE);
 510         ret = lan78xx_write_reg(dev, MII_ACC, addr);
 511
 512         ret = lan78xx_phy_wait_not_busy(dev);
 513         if (ret < 0)
 514                 goto done;
 515
 516         /* select register of MMD */
 517         val = mmdidx;
 518         ret = lan78xx_write_reg(dev, MII_DATA, val);
 519
 520         phy_id &= dev->mii.phy_id_mask;
 521         addr = mii_access(phy_id, PHY_MMD_REG_DATA, MII_WRITE);
 522         ret = lan78xx_write_reg(dev, MII_ACC, addr);
 523
 524         ret = lan78xx_phy_wait_not_busy(dev);
 525         if (ret < 0)
 526                 goto done;
 527
 528         /* select register data for MMD */
 529         val = PHY_MMD_CTRL_OP_DNI_ | mmddev;
 530         ret = lan78xx_write_reg(dev, MII_DATA, val);
 531
 532         phy_id &= dev->mii.phy_id_mask;
 533         addr = mii_access(phy_id, PHY_MMD_CTL, MII_WRITE);
 534         ret = lan78xx_write_reg(dev, MII_ACC, addr);
 535
 536         ret = lan78xx_phy_wait_not_busy(dev);
 537         if (ret < 0)
 538                 goto done;
 539
 540         /* write to MMD */
 541         val = regval;
 542         ret = lan78xx_write_reg(dev, MII_DATA, val);
 543
 544         phy_id &= dev->mii.phy_id_mask;
 545         addr = mii_access(phy_id, PHY_MMD_REG_DATA, MII_WRITE);
 546         ret = lan78xx_write_reg(dev, MII_ACC, addr);
 547
 548         ret = lan78xx_phy_wait_not_busy(dev);
 549         if (ret < 0)
 550                 goto done;
 551
 552 done:
 553         mutex_unlock(&dev->phy_mutex);
 554         usb_autopm_put_interface(dev->intf);
 555 }
 556
 557 static int lan78xx_mmd_read(struct net_device *netdev, int phy_id,
 558                             int mmddev, int mmdidx)
 559 {
 560         struct lan78xx_net *dev = netdev_priv(netdev);
 561         u32 val, addr;
 562         int ret;
 563
 564         ret = usb_autopm_get_interface(dev->intf);
 565         if (ret < 0)
 566                 return ret;
 567
 568         mutex_lock(&dev->phy_mutex);
 569
 570         /* confirm MII not busy */
 571         ret = lan78xx_phy_wait_not_busy(dev);
 572         if (ret < 0)
 573                 goto done;
 574
 575         /* set up device address for MMD */
 576         ret = lan78xx_write_reg(dev, MII_DATA, mmddev);
 577
 578         phy_id &= dev->mii.phy_id_mask;
 579         addr = mii_access(phy_id, PHY_MMD_CTL, MII_WRITE);
 580         ret = lan78xx_write_reg(dev, MII_ACC, addr);
 581
 582         ret = lan78xx_phy_wait_not_busy(dev);
 583         if (ret < 0)
 584                 goto done;
 585
 586         /* select register of MMD */
 587         val = mmdidx;
 588         ret = lan78xx_write_reg(dev, MII_DATA, val);
 589
 590         phy_id &= dev->mii.phy_id_mask;
 591         addr = mii_access(phy_id, PHY_MMD_REG_DATA, MII_WRITE);
 592         ret = lan78xx_write_reg(dev, MII_ACC, addr);
 593
 594         ret = lan78xx_phy_wait_not_busy(dev);
 595         if (ret < 0)
 596                 goto done;
 597
 598         /* select register data for MMD */
 599         val = PHY_MMD_CTRL_OP_DNI_ | mmddev;
 600         ret = lan78xx_write_reg(dev, MII_DATA, val);
 601
 602         phy_id &= dev->mii.phy_id_mask;
 603         addr = mii_access(phy_id, PHY_MMD_CTL, MII_WRITE);
 604         ret = lan78xx_write_reg(dev, MII_ACC, addr);
 605
 606         ret = lan78xx_phy_wait_not_busy(dev);
 607         if (ret < 0)
 608                 goto done;
 609
 610         /* set the address, index & direction (read from PHY) */
 611         phy_id &= dev->mii.phy_id_mask;
 612         addr = mii_access(phy_id, PHY_MMD_REG_DATA, MII_READ);
 613         ret = lan78xx_write_reg(dev, MII_ACC, addr);
 614
 615         ret = lan78xx_phy_wait_not_busy(dev);
 616         if (ret < 0)
 617                 goto done;
 618
 619         /* read from MMD */
 620         ret = lan78xx_read_reg(dev, MII_DATA, &val);
 621
 622         ret = (int)(val & 0xFFFF);
 623
 624 done:
 625         mutex_unlock(&dev->phy_mutex);
 626         usb_autopm_put_interface(dev->intf);
 627         return ret;
 628 }
 629
 630 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
 631 {
 632         unsigned long start_time = jiffies;
 633         u32 val;
 634         int ret;
 635
 636         do {
 637                 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
 638                 if (unlikely(ret < 0))
 639                         return -EIO;
 640
 641                 if (!(val & E2P_CMD_EPC_BUSY_) ||
 642                     (val & E2P_CMD_EPC_TIMEOUT_))
 643                         break;
 644                 usleep_range(40, 100);
 645         } while (!time_after(jiffies, start_time + HZ));
 646
 647         if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
 648                 netdev_warn(dev->net, "EEPROM read operation timeout");
 649                 return -EIO;
 650         }
 651
 652         return 0;
 653 }
 654
 655 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
 656 {
 657         unsigned long start_time = jiffies;
 658         u32 val;
 659         int ret;
 660
 661         do {
 662                 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
 663                 if (unlikely(ret < 0))
 664                         return -EIO;
 665
 666                 if (!(val & E2P_CMD_EPC_BUSY_))
 667                         return 0;
 668
 669                 usleep_range(40, 100);
 670         } while (!time_after(jiffies, start_time + HZ));
 671
 672         netdev_warn(dev->net, "EEPROM is busy");
 673         return -EIO;
 674 }
 675
 676 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
 677                                    u32 length, u8 *data)
 678 {
 679         u32 val;
 680         int i, ret;
 681
 682         ret = lan78xx_eeprom_confirm_not_busy(dev);
 683         if (ret)
 684                 return ret;
 685
 686         for (i = 0; i < length; i++) {
 687                 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
 688                 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
 689                 ret = lan78xx_write_reg(dev, E2P_CMD, val);
 690                 if (unlikely(ret < 0))
 691                         return -EIO;
 692
 693                 ret = lan78xx_wait_eeprom(dev);
 694                 if (ret < 0)
 695                         return ret;
 696
 697                 ret = lan78xx_read_reg(dev, E2P_DATA, &val);
 698                 if (unlikely(ret < 0))
 699                         return -EIO;
 700
 701                 data[i] = val & 0xFF;
 702                 offset++;
 703         }
 704
 705         return 0;
 706 }
 707
 708 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
 709                                u32 length, u8 *data)
 710 {
 711         u8 sig;
 712         int ret;
 713
 714         ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
 715         if ((ret == 0) && (sig == EEPROM_INDICATOR))
 716                 ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
 717         else
 718                 ret = -EINVAL;
 719
 720         return ret;
 721 }
 722
 723 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
 724                                     u32 length, u8 *data)
 725 {
 726         u32 val;
 727         int i, ret;
 728
 729         ret = lan78xx_eeprom_confirm_not_busy(dev);
 730         if (ret)
 731                 return ret;
 732
 733         /* Issue write/erase enable command */
 734         val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
 735         ret = lan78xx_write_reg(dev, E2P_CMD, val);
 736         if (unlikely(ret < 0))
 737                 return -EIO;
 738
 739         ret = lan78xx_wait_eeprom(dev);
 740         if (ret < 0)
 741                 return ret;
 742
 743         for (i = 0; i < length; i++) {
 744                 /* Fill data register */
 745                 val = data[i];
 746                 ret = lan78xx_write_reg(dev, E2P_DATA, val);
 747                 if (ret < 0)
 748                         return ret;
 749
 750                 /* Send "write" command */
 751                 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
 752                 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
 753                 ret = lan78xx_write_reg(dev, E2P_CMD, val);
 754                 if (ret < 0)
 755                         return ret;
 756
 757                 ret = lan78xx_wait_eeprom(dev);
 758                 if (ret < 0)
 759                         return ret;
 760
 761                 offset++;
 762         }
 763
 764         return 0;
 765 }
 766
 767 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
 768                                 u32 length, u8 *data)
 769 {
 770         int i;
 771         int ret;
 772         u32 buf;
 773         unsigned long timeout;
 774
 775         ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
 776
 777         if (buf & OTP_PWR_DN_PWRDN_N_) {
 778                 /* clear it and wait to be cleared */
 779                 ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0);
 780
 781                 timeout = jiffies + HZ;
 782                 do {
 783                         usleep_range(1, 10);
 784                         ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
 785                         if (time_after(jiffies, timeout)) {
 786                                 netdev_warn(dev->net,
 787                                             "timeout on OTP_PWR_DN");
 788                                 return -EIO;
 789                         }
 790                 } while (buf & OTP_PWR_DN_PWRDN_N_);
 791         }
 792
 793         for (i = 0; i < length; i++) {
 794                 ret = lan78xx_write_reg(dev, OTP_ADDR1,
 795                                         ((offset + i) >> 8) & OTP_ADDR1_15_11);
 796                 ret = lan78xx_write_reg(dev, OTP_ADDR2,
 797                                         ((offset + i) & OTP_ADDR2_10_3));
 798
 799                 ret = lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
 800                 ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
 801
 802                 timeout = jiffies + HZ;
 803                 do {
 804                         udelay(1);
 805                         ret = lan78xx_read_reg(dev, OTP_STATUS, &buf);
 806                         if (time_after(jiffies, timeout)) {
 807                                 netdev_warn(dev->net,
 808                                             "timeout on OTP_STATUS");
 809                                 return -EIO;
 810                         }
 811                 } while (buf & OTP_STATUS_BUSY_);
 812
 813                 ret = lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
 814
 815                 data[i] = (u8)(buf & 0xFF);
 816         }
 817
 818         return 0;
 819 }
 820
 821 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
 822                             u32 length, u8 *data)
 823 {
 824         u8 sig;
 825         int ret;
 826
 827         ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
 828
 829         if (ret == 0) {
 830                 if (sig == OTP_INDICATOR_1)
 831                         offset = offset;
 832                 else if (sig == OTP_INDICATOR_2)
 833                         offset += 0x100;
 834                 else
 835                         ret = -EINVAL;
 836                 ret = lan78xx_read_raw_otp(dev, offset, length, data);
 837         }
 838
 839         return ret;
 840 }
 841
 842 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
 843 {
 844         int i, ret;
 845
 846         for (i = 0; i < 100; i++) {
 847                 u32 dp_sel;
 848
 849                 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
 850                 if (unlikely(ret < 0))
 851                         return -EIO;
 852
 853                 if (dp_sel & DP_SEL_DPRDY_)
 854                         return 0;
 855
 856                 usleep_range(40, 100);
 857         }
 858
 859         netdev_warn(dev->net, "lan78xx_dataport_wait_not_busy timed out");
 860
 861         return -EIO;
 862 }
 863
 864 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
 865                                   u32 addr, u32 length, u32 *buf)
 866 {
 867         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
 868         u32 dp_sel;
 869         int i, ret;
 870
 871         if (usb_autopm_get_interface(dev->intf) < 0)
 872                         return 0;
 873
 874         mutex_lock(&pdata->dataport_mutex);
 875
 876         ret = lan78xx_dataport_wait_not_busy(dev);
 877         if (ret < 0)
 878                 goto done;
 879
 880         ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
 881
 882         dp_sel &= ~DP_SEL_RSEL_MASK_;
 883         dp_sel |= ram_select;
 884         ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
 885
 886         for (i = 0; i < length; i++) {
 887                 ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
 888
 889                 ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
 890
 891                 ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
 892
 893                 ret = lan78xx_dataport_wait_not_busy(dev);
 894                 if (ret < 0)
 895                         goto done;
 896         }
 897
 898 done:
 899         mutex_unlock(&pdata->dataport_mutex);
 900         usb_autopm_put_interface(dev->intf);
 901
 902         return ret;
 903 }
 904
 905 static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
 906                                     int index, u8 addr[ETH_ALEN])
 907 {
 908         u32     temp;
 909
 910         if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
 911                 temp = addr[3];
 912                 temp = addr[2] | (temp << 8);
 913                 temp = addr[1] | (temp << 8);
 914                 temp = addr[0] | (temp << 8);
 915                 pdata->pfilter_table[index][1] = temp;
 916                 temp = addr[5];
 917                 temp = addr[4] | (temp << 8);
 918                 temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
 919                 pdata->pfilter_table[index][0] = temp;
 920         }
 921 }
 922
 923 /* returns hash bit number for given MAC address */
 924 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
 925 {
 926         return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
 927 }
 928
 929 static void lan78xx_deferred_multicast_write(struct work_struct *param)
 930 {
 931         struct lan78xx_priv *pdata =
 932                         container_of(param, struct lan78xx_priv, set_multicast);
 933         struct lan78xx_net *dev = pdata->dev;
 934         int i;
 935         int ret;
 936
 937         netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
 938                   pdata->rfe_ctl);
 939
 940         lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
 941                                DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
 942
 943         for (i = 1; i < NUM_OF_MAF; i++) {
 944                 ret = lan78xx_write_reg(dev, MAF_HI(i), 0);
 945                 ret = lan78xx_write_reg(dev, MAF_LO(i),
 946                                         pdata->pfilter_table[i][1]);
 947                 ret = lan78xx_write_reg(dev, MAF_HI(i),
 948                                         pdata->pfilter_table[i][0]);
 949         }
 950
 951         ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
 952 }
 953
 954 static void lan78xx_set_multicast(struct net_device *netdev)
 955 {
 956         struct lan78xx_net *dev = netdev_priv(netdev);
 957         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
 958         unsigned long flags;
 959         int i;
 960
 961         spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
 962
 963         pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
 964                             RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
 965
 966         for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
 967                         pdata->mchash_table[i] = 0;
 968         /* pfilter_table[0] has own HW address */
 969         for (i = 1; i < NUM_OF_MAF; i++) {
 970                         pdata->pfilter_table[i][0] =
 971                         pdata->pfilter_table[i][1] = 0;
 972         }
 973
 974         pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
 975
 976         if (dev->net->flags & IFF_PROMISC) {
 977                 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
 978                 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
 979         } else {
 980                 if (dev->net->flags & IFF_ALLMULTI) {
 981                         netif_dbg(dev, drv, dev->net,
 982                                   "receive all multicast enabled");
 983                         pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
 984                 }
 985         }
 986
 987         if (netdev_mc_count(dev->net)) {
 988                 struct netdev_hw_addr *ha;
 989                 int i;
 990
 991                 netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
 992
 993                 pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
 994
 995                 i = 1;
 996                 netdev_for_each_mc_addr(ha, netdev) {
 997                         /* set first 32 into Perfect Filter */
 998                         if (i < 33) {
 999                                 lan78xx_set_addr_filter(pdata, i, ha->addr);
1000                         } else {
1001                                 u32 bitnum = lan78xx_hash(ha->addr);
1002
1003                                 pdata->mchash_table[bitnum / 32] |=
1004                                                         (1 << (bitnum % 32));
1005                                 pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1006                         }
1007                         i++;
1008                 }
1009         }
1010
1011         spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1012
1013         /* defer register writes to a sleepable context */
1014         schedule_work(&pdata->set_multicast);
1015 }
1016
1017 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1018                                       u16 lcladv, u16 rmtadv)
1019 {
1020         u32 flow = 0, fct_flow = 0;
1021         int ret;
1022
1023         u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1024
1025         if (cap & FLOW_CTRL_TX)
1026                 flow = (FLOW_CR_TX_FCEN_ | 0xFFFF);
1027
1028         if (cap & FLOW_CTRL_RX)
1029                 flow |= FLOW_CR_RX_FCEN_;
1030
1031         if (dev->udev->speed == USB_SPEED_SUPER)
1032                 fct_flow = 0x817;
1033         else if (dev->udev->speed == USB_SPEED_HIGH)
1034                 fct_flow = 0x211;
1035
1036         netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1037                   (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1038                   (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1039
1040         ret = lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1041
1042         /* threshold value should be set before enabling flow */
1043         ret = lan78xx_write_reg(dev, FLOW, flow);
1044
1045         return 0;
1046 }
1047
1048 static int lan78xx_link_reset(struct lan78xx_net *dev)
1049 {
1050         struct mii_if_info *mii = &dev->mii;
1051         struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
1052         u16 ladv, radv;
1053         int ret;
1054         u32 buf;
1055
1056         /* clear PHY interrupt status */
1057         /* VTSE PHY */
1058         ret = lan78xx_mdio_read(dev->net, mii->phy_id, PHY_VTSE_INT_STS);
1059         if (unlikely(ret < 0))
1060                 return -EIO;
1061
1062         /* clear LAN78xx interrupt status */
1063         ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1064         if (unlikely(ret < 0))
1065                 return -EIO;
1066
1067         if (!mii_link_ok(mii) && dev->link_on) {
1068                 dev->link_on = false;
1069                 netif_carrier_off(dev->net);
1070
1071                 /* reset MAC */
1072                 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1073                 if (unlikely(ret < 0))
1074                         return -EIO;
1075                 buf |= MAC_CR_RST_;
1076                 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1077                 if (unlikely(ret < 0))
1078                         return -EIO;
1079         } else if (mii_link_ok(mii) && !dev->link_on) {
1080                 dev->link_on = true;
1081
1082                 mii_check_media(mii, 1, 1);
1083                 mii_ethtool_gset(&dev->mii, &ecmd);
1084
1085                 mii->mdio_read(mii->dev, mii->phy_id, PHY_VTSE_INT_STS);
1086
1087                 if (dev->udev->speed == USB_SPEED_SUPER) {
1088                         if (ethtool_cmd_speed(&ecmd) == 1000) {
1089                                 /* disable U2 */
1090                                 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1091                                 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1092                                 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1093                                 /* enable U1 */
1094                                 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1095                                 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1096                                 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1097                         } else {
1098                                 /* enable U1 & U2 */
1099                                 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1100                                 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1101                                 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1102                                 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1103                         }
1104                 }
1105
1106                 ladv = lan78xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE);
1107                 if (unlikely(ladv < 0))
1108                         return -EIO;
1109
1110                 radv = lan78xx_mdio_read(dev->net, mii->phy_id, MII_LPA);
1111                 if (unlikely(radv < 0))
1112                         return -EIO;
1113
1114                 netif_dbg(dev, link, dev->net,
1115                           "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1116                           ethtool_cmd_speed(&ecmd), ecmd.duplex, ladv, radv);
1117
1118                 ret = lan78xx_update_flowcontrol(dev, ecmd.duplex, ladv, radv);
1119                 netif_carrier_on(dev->net);
1120         }
1121
1122         return ret;
1123 }
1124
1125 /* some work can't be done in tasklets, so we use keventd
1126  *
1127  * NOTE:  annoying asymmetry:  if it's active, schedule_work() fails,
1128  * but tasklet_schedule() doesn't.      hope the failure is rare.
1129  */
1130 void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1131 {
1132         set_bit(work, &dev->flags);
1133         if (!schedule_delayed_work(&dev->wq, 0))
1134                 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1135 }
1136
1137 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1138 {
1139         u32 intdata;
1140
1141         if (urb->actual_length != 4) {
1142                 netdev_warn(dev->net,
1143                             "unexpected urb length %d", urb->actual_length);
1144                 return;
1145         }
1146
1147         memcpy(&intdata, urb->transfer_buffer, 4);
1148         le32_to_cpus(&intdata);
1149
1150         if (intdata & INT_ENP_PHY_INT) {
1151                 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1152                           lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1153         } else
1154                 netdev_warn(dev->net,
1155                             "unexpected interrupt: 0x%08x\n", intdata);
1156 }
1157
1158 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1159 {
1160         return MAX_EEPROM_SIZE;
1161 }
1162
1163 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1164                                       struct ethtool_eeprom *ee, u8 *data)
1165 {
1166         struct lan78xx_net *dev = netdev_priv(netdev);
1167
1168         ee->magic = LAN78XX_EEPROM_MAGIC;
1169
1170         return lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1171 }
1172
1173 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1174                                       struct ethtool_eeprom *ee, u8 *data)
1175 {
1176         struct lan78xx_net *dev = netdev_priv(netdev);
1177
1178         /* Allow entire eeprom update only */
1179         if ((ee->magic == LAN78XX_EEPROM_MAGIC) &&
1180             (ee->offset == 0) &&
1181             (ee->len == 512) &&
1182             (data[0] == EEPROM_INDICATOR))
1183                 return lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1184         else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1185                  (ee->offset == 0) &&
1186                  (ee->len == 512) &&
1187                  (data[0] == OTP_INDICATOR_1))
1188                 return lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1189
1190         return -EINVAL;
1191 }
1192
1193 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1194                                 u8 *data)
1195 {
1196         if (stringset == ETH_SS_STATS)
1197                 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1198 }
1199
1200 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1201 {
1202         if (sset == ETH_SS_STATS)
1203                 return ARRAY_SIZE(lan78xx_gstrings);
1204         else
1205                 return -EOPNOTSUPP;
1206 }
1207
1208 static void lan78xx_get_stats(struct net_device *netdev,
1209                               struct ethtool_stats *stats, u64 *data)
1210 {
1211         struct lan78xx_net *dev = netdev_priv(netdev);
1212         struct lan78xx_statstage lan78xx_stat;
1213         u32 *p;
1214         int i;
1215
1216         if (usb_autopm_get_interface(dev->intf) < 0)
1217                 return;
1218
1219         if (lan78xx_read_stats(dev, &lan78xx_stat) > 0) {
1220                 p = (u32 *)&lan78xx_stat;
1221                 for (i = 0; i < (sizeof(lan78xx_stat) / (sizeof(u32))); i++)
1222                         data[i] = p[i];
1223         }
1224
1225         usb_autopm_put_interface(dev->intf);
1226 }
1227
1228 static void lan78xx_get_wol(struct net_device *netdev,
1229                             struct ethtool_wolinfo *wol)
1230 {
1231         struct lan78xx_net *dev = netdev_priv(netdev);
1232         int ret;
1233         u32 buf;
1234         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1235
1236         if (usb_autopm_get_interface(dev->intf) < 0)
1237                         return;
1238
1239         ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1240         if (unlikely(ret < 0)) {
1241                 wol->supported = 0;
1242                 wol->wolopts = 0;
1243         } else {
1244                 if (buf & USB_CFG_RMT_WKP_) {
1245                         wol->supported = WAKE_ALL;
1246                         wol->wolopts = pdata->wol;
1247                 } else {
1248                         wol->supported = 0;
1249                         wol->wolopts = 0;
1250                 }
1251         }
1252
1253         usb_autopm_put_interface(dev->intf);
1254 }
1255
1256 static int lan78xx_set_wol(struct net_device *netdev,
1257                            struct ethtool_wolinfo *wol)
1258 {
1259         struct lan78xx_net *dev = netdev_priv(netdev);
1260         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1261         int ret;
1262
1263         ret = usb_autopm_get_interface(dev->intf);
1264         if (ret < 0)
1265                 return ret;
1266
1267         pdata->wol = 0;
1268         if (wol->wolopts & WAKE_UCAST)
1269                 pdata->wol |= WAKE_UCAST;
1270         if (wol->wolopts & WAKE_MCAST)
1271                 pdata->wol |= WAKE_MCAST;
1272         if (wol->wolopts & WAKE_BCAST)
1273                 pdata->wol |= WAKE_BCAST;
1274         if (wol->wolopts & WAKE_MAGIC)
1275                 pdata->wol |= WAKE_MAGIC;
1276         if (wol->wolopts & WAKE_PHY)
1277                 pdata->wol |= WAKE_PHY;
1278         if (wol->wolopts & WAKE_ARP)
1279                 pdata->wol |= WAKE_ARP;
1280
1281         device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1282
1283         usb_autopm_put_interface(dev->intf);
1284
1285         return ret;
1286 }
1287
1288 static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1289 {
1290         struct lan78xx_net *dev = netdev_priv(net);
1291         int ret;
1292         u32 buf;
1293         u32 adv, lpadv;
1294
1295         ret = usb_autopm_get_interface(dev->intf);
1296         if (ret < 0)
1297                 return ret;
1298
1299         ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1300         if (buf & MAC_CR_EEE_EN_) {
1301                 buf = lan78xx_mmd_read(dev->net, dev->mii.phy_id,
1302                                        PHY_MMD_DEV_7, PHY_EEE_ADVERTISEMENT);
1303                 adv = mmd_eee_adv_to_ethtool_adv_t(buf);
1304                 buf = lan78xx_mmd_read(dev->net, dev->mii.phy_id,
1305                                        PHY_MMD_DEV_7, PHY_EEE_LP_ADVERTISEMENT);
1306                 lpadv = mmd_eee_adv_to_ethtool_adv_t(buf);
1307
1308                 edata->eee_enabled = true;
1309                 edata->supported = true;
1310                 edata->eee_active = !!(adv & lpadv);
1311                 edata->advertised = adv;
1312                 edata->lp_advertised = lpadv;
1313                 edata->tx_lpi_enabled = true;
1314                 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1315                 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1316                 edata->tx_lpi_timer = buf;
1317         } else {
1318                 buf = lan78xx_mmd_read(dev->net, dev->mii.phy_id,
1319                                        PHY_MMD_DEV_7, PHY_EEE_LP_ADVERTISEMENT);
1320                 lpadv = mmd_eee_adv_to_ethtool_adv_t(buf);
1321
1322                 edata->eee_enabled = false;
1323                 edata->eee_active = false;
1324                 edata->supported = false;
1325                 edata->advertised = 0;
1326                 edata->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(lpadv);
1327                 edata->tx_lpi_enabled = false;
1328                 edata->tx_lpi_timer = 0;
1329         }
1330
1331         usb_autopm_put_interface(dev->intf);
1332
1333         return 0;
1334 }
1335
1336 static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1337 {
1338         struct lan78xx_net *dev = netdev_priv(net);
1339         int ret;
1340         u32 buf;
1341
1342         ret = usb_autopm_get_interface(dev->intf);
1343         if (ret < 0)
1344                 return ret;
1345
1346         if (edata->eee_enabled) {
1347                 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1348                 buf |= MAC_CR_EEE_EN_;
1349                 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1350
1351                 buf = ethtool_adv_to_mmd_eee_adv_t(edata->advertised);
1352                 lan78xx_mmd_write(dev->net, dev->mii.phy_id,
1353                                   PHY_MMD_DEV_7, PHY_EEE_ADVERTISEMENT, buf);
1354         } else {
1355                 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1356                 buf &= ~MAC_CR_EEE_EN_;
1357                 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1358         }
1359
1360         usb_autopm_put_interface(dev->intf);
1361
1362         return 0;
1363 }
1364
1365 static u32 lan78xx_get_link(struct net_device *net)
1366 {
1367         struct lan78xx_net *dev = netdev_priv(net);
1368
1369         return mii_link_ok(&dev->mii);
1370 }
1371
1372 int lan78xx_nway_reset(struct net_device *net)
1373 {
1374         struct lan78xx_net *dev = netdev_priv(net);
1375
1376         if ((!dev->mii.mdio_read) || (!dev->mii.mdio_write))
1377                 return -EOPNOTSUPP;
1378
1379         return mii_nway_restart(&dev->mii);
1380 }
1381
1382 static void lan78xx_get_drvinfo(struct net_device *net,
1383                                 struct ethtool_drvinfo *info)
1384 {
1385         struct lan78xx_net *dev = netdev_priv(net);
1386
1387         strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1388         strncpy(info->version, DRIVER_VERSION, sizeof(info->version));
1389         usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1390 }
1391
1392 static u32 lan78xx_get_msglevel(struct net_device *net)
1393 {
1394         struct lan78xx_net *dev = netdev_priv(net);
1395
1396         return dev->msg_enable;
1397 }
1398
1399 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1400 {
1401         struct lan78xx_net *dev = netdev_priv(net);
1402
1403         dev->msg_enable = level;
1404 }
1405
1406 static int lan78xx_get_settings(struct net_device *net, struct ethtool_cmd *cmd)
1407 {
1408         struct lan78xx_net *dev = netdev_priv(net);
1409         struct mii_if_info *mii = &dev->mii;
1410         int ret;
1411         int buf;
1412
1413         if ((!dev->mii.mdio_read) || (!dev->mii.mdio_write))
1414                 return -EOPNOTSUPP;
1415
1416         ret = usb_autopm_get_interface(dev->intf);
1417         if (ret < 0)
1418                 return ret;
1419
1420         ret = mii_ethtool_gset(&dev->mii, cmd);
1421
1422         mii->mdio_write(mii->dev, mii->phy_id,
1423                         PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_1);
1424         buf = mii->mdio_read(mii->dev, mii->phy_id, PHY_EXT_MODE_CTRL);
1425         mii->mdio_write(mii->dev, mii->phy_id,
1426                         PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_0);
1427
1428         buf &= PHY_EXT_MODE_CTRL_MDIX_MASK_;
1429         if (buf == PHY_EXT_MODE_CTRL_AUTO_MDIX_) {
1430                 cmd->eth_tp_mdix = ETH_TP_MDI_AUTO;
1431                 cmd->eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
1432         } else if (buf == PHY_EXT_MODE_CTRL_MDI_) {
1433                 cmd->eth_tp_mdix = ETH_TP_MDI;
1434                 cmd->eth_tp_mdix_ctrl = ETH_TP_MDI;
1435         } else if (buf == PHY_EXT_MODE_CTRL_MDI_X_) {
1436                 cmd->eth_tp_mdix = ETH_TP_MDI_X;
1437                 cmd->eth_tp_mdix_ctrl = ETH_TP_MDI_X;
1438         }
1439
1440         usb_autopm_put_interface(dev->intf);
1441
1442         return ret;
1443 }
1444
1445 static int lan78xx_set_settings(struct net_device *net, struct ethtool_cmd *cmd)
1446 {
1447         struct lan78xx_net *dev = netdev_priv(net);
1448         struct mii_if_info *mii = &dev->mii;
1449         int ret = 0;
1450         int temp;
1451
1452         if ((!dev->mii.mdio_read) || (!dev->mii.mdio_write))
1453                 return -EOPNOTSUPP;
1454
1455         ret = usb_autopm_get_interface(dev->intf);
1456         if (ret < 0)
1457                 return ret;
1458
1459         if (dev->mdix_ctrl != cmd->eth_tp_mdix_ctrl) {
1460                 if (cmd->eth_tp_mdix_ctrl == ETH_TP_MDI) {
1461                         mii->mdio_write(mii->dev, mii->phy_id,
1462                                         PHY_EXT_GPIO_PAGE,
1463                                         PHY_EXT_GPIO_PAGE_SPACE_1);
1464                         temp = mii->mdio_read(mii->dev, mii->phy_id,
1465                                         PHY_EXT_MODE_CTRL);
1466                         temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1467                         mii->mdio_write(mii->dev, mii->phy_id,
1468                                         PHY_EXT_MODE_CTRL,
1469                                         temp | PHY_EXT_MODE_CTRL_MDI_);
1470                         mii->mdio_write(mii->dev, mii->phy_id,
1471                                         PHY_EXT_GPIO_PAGE,
1472                                         PHY_EXT_GPIO_PAGE_SPACE_0);
1473                 } else if (cmd->eth_tp_mdix_ctrl == ETH_TP_MDI_X) {
1474                         mii->mdio_write(mii->dev, mii->phy_id,
1475                                         PHY_EXT_GPIO_PAGE,
1476                                         PHY_EXT_GPIO_PAGE_SPACE_1);
1477                         temp = mii->mdio_read(mii->dev, mii->phy_id,
1478                                         PHY_EXT_MODE_CTRL);
1479                         temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1480                         mii->mdio_write(mii->dev, mii->phy_id,
1481                                         PHY_EXT_MODE_CTRL,
1482                                         temp | PHY_EXT_MODE_CTRL_MDI_X_);
1483                         mii->mdio_write(mii->dev, mii->phy_id,
1484                                         PHY_EXT_GPIO_PAGE,
1485                                         PHY_EXT_GPIO_PAGE_SPACE_0);
1486                 } else if (cmd->eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO) {
1487                         mii->mdio_write(mii->dev, mii->phy_id,
1488                                         PHY_EXT_GPIO_PAGE,
1489                                         PHY_EXT_GPIO_PAGE_SPACE_1);
1490                         temp = mii->mdio_read(mii->dev, mii->phy_id,
1491                                                         PHY_EXT_MODE_CTRL);
1492                         temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1493                         mii->mdio_write(mii->dev, mii->phy_id,
1494                                         PHY_EXT_MODE_CTRL,
1495                                         temp | PHY_EXT_MODE_CTRL_AUTO_MDIX_);
1496                         mii->mdio_write(mii->dev, mii->phy_id,
1497                                         PHY_EXT_GPIO_PAGE,
1498                                         PHY_EXT_GPIO_PAGE_SPACE_0);
1499                 }
1500         }
1501
1502         /* change speed & duplex */
1503         ret = mii_ethtool_sset(&dev->mii, cmd);
1504
1505         if (!cmd->autoneg) {
1506                 /* force link down */
1507                 temp = mii->mdio_read(mii->dev, mii->phy_id, MII_BMCR);
1508                 mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR,
1509                                 temp | BMCR_LOOPBACK);
1510                 mdelay(1);
1511                 mii->mdio_write(mii->dev, mii->phy_id, MII_BMCR, temp);
1512         }
1513
1514         usb_autopm_put_interface(dev->intf);
1515
1516         return ret;
1517 }
1518
1519 static const struct ethtool_ops lan78xx_ethtool_ops = {
1520         .get_link       = lan78xx_get_link,
1521         .nway_reset     = lan78xx_nway_reset,
1522         .get_drvinfo    = lan78xx_get_drvinfo,
1523         .get_msglevel   = lan78xx_get_msglevel,
1524         .set_msglevel   = lan78xx_set_msglevel,
1525         .get_settings   = lan78xx_get_settings,
1526         .set_settings   = lan78xx_set_settings,
1527         .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1528         .get_eeprom     = lan78xx_ethtool_get_eeprom,
1529         .set_eeprom     = lan78xx_ethtool_set_eeprom,
1530         .get_ethtool_stats = lan78xx_get_stats,
1531         .get_sset_count = lan78xx_get_sset_count,
1532         .get_strings    = lan78xx_get_strings,
1533         .get_wol        = lan78xx_get_wol,
1534         .set_wol        = lan78xx_set_wol,
1535         .get_eee        = lan78xx_get_eee,
1536         .set_eee        = lan78xx_set_eee,
1537 };
1538
1539 static int lan78xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
1540 {
1541         struct lan78xx_net *dev = netdev_priv(netdev);
1542
1543         if (!netif_running(netdev))
1544                 return -EINVAL;
1545
1546         return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
1547 }
1548
1549 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1550 {
1551         u32 addr_lo, addr_hi;
1552         int ret;
1553         u8 addr[6];
1554
1555         ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1556         ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1557
1558         addr[0] = addr_lo & 0xFF;
1559         addr[1] = (addr_lo >> 8) & 0xFF;
1560         addr[2] = (addr_lo >> 16) & 0xFF;
1561         addr[3] = (addr_lo >> 24) & 0xFF;
1562         addr[4] = addr_hi & 0xFF;
1563         addr[5] = (addr_hi >> 8) & 0xFF;
1564
1565         if (!is_valid_ether_addr(addr)) {
1566                 /* reading mac address from EEPROM or OTP */
1567                 if ((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1568                                          addr) == 0) ||
1569                     (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
1570                                       addr) == 0)) {
1571                         if (is_valid_ether_addr(addr)) {
1572                                 /* eeprom values are valid so use them */
1573                                 netif_dbg(dev, ifup, dev->net,
1574                                           "MAC address read from EEPROM");
1575                         } else {
1576                                 /* generate random MAC */
1577                                 random_ether_addr(addr);
1578                                 netif_dbg(dev, ifup, dev->net,
1579                                           "MAC address set to random addr");
1580                         }
1581
1582                         addr_lo = addr[0] | (addr[1] << 8) |
1583                                   (addr[2] << 16) | (addr[3] << 24);
1584                         addr_hi = addr[4] | (addr[5] << 8);
1585
1586                         ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1587                         ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1588                 } else {
1589                         /* generate random MAC */
1590                         random_ether_addr(addr);
1591                         netif_dbg(dev, ifup, dev->net,
1592                                   "MAC address set to random addr");
1593                 }
1594         }
1595
1596         ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1597         ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1598
1599         ether_addr_copy(dev->net->dev_addr, addr);
1600 }
1601
1602 static void lan78xx_mii_init(struct lan78xx_net *dev)
1603 {
1604         /* Initialize MII structure */
1605         dev->mii.dev = dev->net;
1606         dev->mii.mdio_read = lan78xx_mdio_read;
1607         dev->mii.mdio_write = lan78xx_mdio_write;
1608         dev->mii.phy_id_mask = 0x1f;
1609         dev->mii.reg_num_mask = 0x1f;
1610         dev->mii.phy_id = INTERNAL_PHY_ID;
1611         dev->mii.supports_gmii = true;
1612 }
1613
1614 static int lan78xx_phy_init(struct lan78xx_net *dev)
1615 {
1616         int temp;
1617         struct mii_if_info *mii = &dev->mii;
1618
1619         if ((!mii->mdio_write) || (!mii->mdio_read))
1620                 return -EOPNOTSUPP;
1621
1622         temp = mii->mdio_read(mii->dev, mii->phy_id, MII_ADVERTISE);
1623         temp |= ADVERTISE_ALL;
1624         mii->mdio_write(mii->dev, mii->phy_id, MII_ADVERTISE,
1625                         temp | ADVERTISE_CSMA |
1626                         ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM);
1627
1628         /* set to AUTOMDIX */
1629         mii->mdio_write(mii->dev, mii->phy_id,
1630                         PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_1);
1631         temp = mii->mdio_read(mii->dev, mii->phy_id, PHY_EXT_MODE_CTRL);
1632         temp &= ~PHY_EXT_MODE_CTRL_MDIX_MASK_;
1633         mii->mdio_write(mii->dev, mii->phy_id, PHY_EXT_MODE_CTRL,
1634                         temp | PHY_EXT_MODE_CTRL_AUTO_MDIX_);
1635         mii->mdio_write(mii->dev, mii->phy_id,
1636                         PHY_EXT_GPIO_PAGE, PHY_EXT_GPIO_PAGE_SPACE_0);
1637         dev->mdix_ctrl = ETH_TP_MDI_AUTO;
1638
1639         /* MAC doesn't support 1000HD */
1640         temp = mii->mdio_read(mii->dev, mii->phy_id, MII_CTRL1000);
1641         mii->mdio_write(mii->dev, mii->phy_id, MII_CTRL1000,
1642                         temp & ~ADVERTISE_1000HALF);
1643
1644         /* clear interrupt */
1645         mii->mdio_read(mii->dev, mii->phy_id, PHY_VTSE_INT_STS);
1646         mii->mdio_write(mii->dev, mii->phy_id, PHY_VTSE_INT_MASK,
1647                         PHY_VTSE_INT_MASK_MDINTPIN_EN_ |
1648                         PHY_VTSE_INT_MASK_LINK_CHANGE_);
1649
1650         netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
1651
1652         return 0;
1653 }
1654
1655 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
1656 {
1657         int ret = 0;
1658         u32 buf;
1659         bool rxenabled;
1660
1661         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
1662
1663         rxenabled = ((buf & MAC_RX_RXEN_) != 0);
1664
1665         if (rxenabled) {
1666                 buf &= ~MAC_RX_RXEN_;
1667                 ret = lan78xx_write_reg(dev, MAC_RX, buf);
1668         }
1669
1670         /* add 4 to size for FCS */
1671         buf &= ~MAC_RX_MAX_SIZE_MASK_;
1672         buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
1673
1674         ret = lan78xx_write_reg(dev, MAC_RX, buf);
1675
1676         if (rxenabled) {
1677                 buf |= MAC_RX_RXEN_;
1678                 ret = lan78xx_write_reg(dev, MAC_RX, buf);
1679         }
1680
1681         return 0;
1682 }
1683
1684 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
1685 {
1686         struct sk_buff *skb;
1687         unsigned long flags;
1688         int count = 0;
1689
1690         spin_lock_irqsave(&q->lock, flags);
1691         while (!skb_queue_empty(q)) {
1692                 struct skb_data *entry;
1693                 struct urb *urb;
1694                 int ret;
1695
1696                 skb_queue_walk(q, skb) {
1697                         entry = (struct skb_data *)skb->cb;
1698                         if (entry->state != unlink_start)
1699                                 goto found;
1700                 }
1701                 break;
1702 found:
1703                 entry->state = unlink_start;
1704                 urb = entry->urb;
1705
1706                 /* Get reference count of the URB to avoid it to be
1707                  * freed during usb_unlink_urb, which may trigger
1708                  * use-after-free problem inside usb_unlink_urb since
1709                  * usb_unlink_urb is always racing with .complete
1710                  * handler(include defer_bh).
1711                  */
1712                 usb_get_urb(urb);
1713                 spin_unlock_irqrestore(&q->lock, flags);
1714                 /* during some PM-driven resume scenarios,
1715                  * these (async) unlinks complete immediately
1716                  */
1717                 ret = usb_unlink_urb(urb);
1718                 if (ret != -EINPROGRESS && ret != 0)
1719                         netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
1720                 else
1721                         count++;
1722                 usb_put_urb(urb);
1723                 spin_lock_irqsave(&q->lock, flags);
1724         }
1725         spin_unlock_irqrestore(&q->lock, flags);
1726         return count;
1727 }
1728
1729 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
1730 {
1731         struct lan78xx_net *dev = netdev_priv(netdev);
1732         int ll_mtu = new_mtu + netdev->hard_header_len;
1733         int old_hard_mtu = dev->hard_mtu;
1734         int old_rx_urb_size = dev->rx_urb_size;
1735         int ret;
1736
1737         if (new_mtu > MAX_SINGLE_PACKET_SIZE)
1738                 return -EINVAL;
1739
1740         if (new_mtu <= 0)
1741                 return -EINVAL;
1742         /* no second zero-length packet read wanted after mtu-sized packets */
1743         if ((ll_mtu % dev->maxpacket) == 0)
1744                 return -EDOM;
1745
1746         ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
1747
1748         netdev->mtu = new_mtu;
1749
1750         dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
1751         if (dev->rx_urb_size == old_hard_mtu) {
1752                 dev->rx_urb_size = dev->hard_mtu;
1753                 if (dev->rx_urb_size > old_rx_urb_size) {
1754                         if (netif_running(dev->net)) {
1755                                 unlink_urbs(dev, &dev->rxq);
1756                                 tasklet_schedule(&dev->bh);
1757                         }
1758                 }
1759         }
1760
1761         return 0;
1762 }
1763
1764 int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
1765 {
1766         struct lan78xx_net *dev = netdev_priv(netdev);
1767         struct sockaddr *addr = p;
1768         u32 addr_lo, addr_hi;
1769         int ret;
1770
1771         if (netif_running(netdev))
1772                 return -EBUSY;
1773
1774         if (!is_valid_ether_addr(addr->sa_data))
1775                 return -EADDRNOTAVAIL;
1776
1777         ether_addr_copy(netdev->dev_addr, addr->sa_data);
1778
1779         addr_lo = netdev->dev_addr[0] |
1780                   netdev->dev_addr[1] << 8 |
1781                   netdev->dev_addr[2] << 16 |
1782                   netdev->dev_addr[3] << 24;
1783         addr_hi = netdev->dev_addr[4] |
1784                   netdev->dev_addr[5] << 8;
1785
1786         ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1787         ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1788
1789         return 0;
1790 }
1791
1792 /* Enable or disable Rx checksum offload engine */
1793 static int lan78xx_set_features(struct net_device *netdev,
1794                                 netdev_features_t features)
1795 {
1796         struct lan78xx_net *dev = netdev_priv(netdev);
1797         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1798         unsigned long flags;
1799         int ret;
1800
1801         spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1802
1803         if (features & NETIF_F_RXCSUM) {
1804                 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
1805                 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
1806         } else {
1807                 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
1808                 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
1809         }
1810
1811         if (features & NETIF_F_HW_VLAN_CTAG_RX)
1812                 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
1813         else
1814                 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
1815
1816         spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1817
1818         ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1819
1820         return 0;
1821 }
1822
1823 static void lan78xx_deferred_vlan_write(struct work_struct *param)
1824 {
1825         struct lan78xx_priv *pdata =
1826                         container_of(param, struct lan78xx_priv, set_vlan);
1827         struct lan78xx_net *dev = pdata->dev;
1828
1829         lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
1830                                DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
1831 }
1832
1833 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
1834                                    __be16 proto, u16 vid)
1835 {
1836         struct lan78xx_net *dev = netdev_priv(netdev);
1837         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1838         u16 vid_bit_index;
1839         u16 vid_dword_index;
1840
1841         vid_dword_index = (vid >> 5) & 0x7F;
1842         vid_bit_index = vid & 0x1F;
1843
1844         pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
1845
1846         /* defer register writes to a sleepable context */
1847         schedule_work(&pdata->set_vlan);
1848
1849         return 0;
1850 }
1851
1852 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
1853                                     __be16 proto, u16 vid)
1854 {
1855         struct lan78xx_net *dev = netdev_priv(netdev);
1856         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1857         u16 vid_bit_index;
1858         u16 vid_dword_index;
1859
1860         vid_dword_index = (vid >> 5) & 0x7F;
1861         vid_bit_index = vid & 0x1F;
1862
1863         pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
1864
1865         /* defer register writes to a sleepable context */
1866         schedule_work(&pdata->set_vlan);
1867
1868         return 0;
1869 }
1870
1871 static void lan78xx_init_ltm(struct lan78xx_net *dev)
1872 {
1873         int ret;
1874         u32 buf;
1875         u32 regs[6] = { 0 };
1876
1877         ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1878         if (buf & USB_CFG1_LTM_ENABLE_) {
1879                 u8 temp[2];
1880                 /* Get values from EEPROM first */
1881                 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
1882                         if (temp[0] == 24) {
1883                                 ret = lan78xx_read_raw_eeprom(dev,
1884                                                               temp[1] * 2,
1885                                                               24,
1886                                                               (u8 *)regs);
1887                                 if (ret < 0)
1888                                         return;
1889                         }
1890                 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
1891                         if (temp[0] == 24) {
1892                                 ret = lan78xx_read_raw_otp(dev,
1893                                                            temp[1] * 2,
1894                                                            24,
1895                                                            (u8 *)regs);
1896                                 if (ret < 0)
1897                                         return;
1898                         }
1899                 }
1900         }
1901
1902         lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
1903         lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
1904         lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
1905         lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
1906         lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
1907         lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
1908 }
1909
1910 static int lan78xx_reset(struct lan78xx_net *dev)
1911 {
1912         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1913         u32 buf;
1914         int ret = 0;
1915         unsigned long timeout;
1916
1917         ret = lan78xx_read_reg(dev, HW_CFG, &buf);
1918         buf |= HW_CFG_LRST_;
1919         ret = lan78xx_write_reg(dev, HW_CFG, buf);
1920
1921         timeout = jiffies + HZ;
1922         do {
1923                 mdelay(1);
1924                 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
1925                 if (time_after(jiffies, timeout)) {
1926                         netdev_warn(dev->net,
1927                                     "timeout on completion of LiteReset");
1928                         return -EIO;
1929                 }
1930         } while (buf & HW_CFG_LRST_);
1931
1932         lan78xx_init_mac_address(dev);
1933
1934         /* Respond to the IN token with a NAK */
1935         ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1936         buf |= USB_CFG_BIR_;
1937         ret = lan78xx_write_reg(dev, USB_CFG0, buf);
1938
1939         /* Init LTM */
1940         lan78xx_init_ltm(dev);
1941
1942         dev->net->hard_header_len += TX_OVERHEAD;
1943         dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
1944
1945         if (dev->udev->speed == USB_SPEED_SUPER) {
1946                 buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
1947                 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
1948                 dev->rx_qlen = 4;
1949                 dev->tx_qlen = 4;
1950         } else if (dev->udev->speed == USB_SPEED_HIGH) {
1951                 buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
1952                 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
1953                 dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
1954                 dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
1955         } else {
1956                 buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
1957                 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
1958                 dev->rx_qlen = 4;
1959         }
1960
1961         ret = lan78xx_write_reg(dev, BURST_CAP, buf);
1962         ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
1963
1964         ret = lan78xx_read_reg(dev, HW_CFG, &buf);
1965         buf |= HW_CFG_MEF_;
1966         ret = lan78xx_write_reg(dev, HW_CFG, buf);
1967
1968         ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1969         buf |= USB_CFG_BCE_;
1970         ret = lan78xx_write_reg(dev, USB_CFG0, buf);
1971
1972         /* set FIFO sizes */
1973         buf = (MAX_RX_FIFO_SIZE - 512) / 512;
1974         ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
1975
1976         buf = (MAX_TX_FIFO_SIZE - 512) / 512;
1977         ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
1978
1979         ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
1980         ret = lan78xx_write_reg(dev, FLOW, 0);
1981         ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
1982
1983         /* Don't need rfe_ctl_lock during initialisation */
1984         ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
1985         pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
1986         ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1987
1988         /* Enable or disable checksum offload engines */
1989         lan78xx_set_features(dev->net, dev->net->features);
1990
1991         lan78xx_set_multicast(dev->net);
1992
1993         /* reset PHY */
1994         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
1995         buf |= PMT_CTL_PHY_RST_;
1996         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
1997
1998         timeout = jiffies + HZ;
1999         do {
2000                 mdelay(1);
2001                 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2002                 if (time_after(jiffies, timeout)) {
2003                         netdev_warn(dev->net, "timeout waiting for PHY Reset");
2004                         return -EIO;
2005                 }
2006         } while (buf & PMT_CTL_PHY_RST_);
2007
2008         lan78xx_mii_init(dev);
2009
2010         ret = lan78xx_phy_init(dev);
2011
2012         ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2013
2014         buf |= MAC_CR_GMII_EN_;
2015         buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
2016
2017         ret = lan78xx_write_reg(dev, MAC_CR, buf);
2018
2019         /* enable on PHY */
2020         if (buf & MAC_CR_EEE_EN_)
2021                 lan78xx_mmd_write(dev->net, dev->mii.phy_id, 0x07, 0x3C, 0x06);
2022
2023         /* enable PHY interrupts */
2024         ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
2025         buf |= INT_ENP_PHY_INT;
2026         ret = lan78xx_write_reg(dev, INT_EP_CTL, buf);
2027
2028         ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2029         buf |= MAC_TX_TXEN_;
2030         ret = lan78xx_write_reg(dev, MAC_TX, buf);
2031
2032         ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2033         buf |= FCT_TX_CTL_EN_;
2034         ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2035
2036         ret = lan78xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
2037
2038         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2039         buf |= MAC_RX_RXEN_;
2040         ret = lan78xx_write_reg(dev, MAC_RX, buf);
2041
2042         ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2043         buf |= FCT_RX_CTL_EN_;
2044         ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2045
2046         if (!mii_nway_restart(&dev->mii))
2047                 netif_dbg(dev, link, dev->net, "autoneg initiated");
2048
2049         return 0;
2050 }
2051
2052 static int lan78xx_open(struct net_device *net)
2053 {
2054         struct lan78xx_net *dev = netdev_priv(net);
2055         int ret;
2056
2057         ret = usb_autopm_get_interface(dev->intf);
2058         if (ret < 0)
2059                 goto out;
2060
2061         ret = lan78xx_reset(dev);
2062         if (ret < 0)
2063                 goto done;
2064
2065         /* for Link Check */
2066         if (dev->urb_intr) {
2067                 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2068                 if (ret < 0) {
2069                         netif_err(dev, ifup, dev->net,
2070                                   "intr submit %d\n", ret);
2071                         goto done;
2072                 }
2073         }
2074
2075         set_bit(EVENT_DEV_OPEN, &dev->flags);
2076
2077         netif_start_queue(net);
2078
2079         dev->link_on = false;
2080
2081         lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2082 done:
2083         usb_autopm_put_interface(dev->intf);
2084
2085 out:
2086         return ret;
2087 }
2088
2089 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2090 {
2091         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2092         DECLARE_WAITQUEUE(wait, current);
2093         int temp;
2094
2095         /* ensure there are no more active urbs */
2096         add_wait_queue(&unlink_wakeup, &wait);
2097         set_current_state(TASK_UNINTERRUPTIBLE);
2098         dev->wait = &unlink_wakeup;
2099         temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2100
2101         /* maybe wait for deletions to finish. */
2102         while (!skb_queue_empty(&dev->rxq) &&
2103                !skb_queue_empty(&dev->txq) &&
2104                !skb_queue_empty(&dev->done)) {
2105                 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2106                 set_current_state(TASK_UNINTERRUPTIBLE);
2107                 netif_dbg(dev, ifdown, dev->net,
2108                           "waited for %d urb completions\n", temp);
2109         }
2110         set_current_state(TASK_RUNNING);
2111         dev->wait = NULL;
2112         remove_wait_queue(&unlink_wakeup, &wait);
2113 }
2114
2115 int lan78xx_stop(struct net_device *net)
2116 {
2117         struct lan78xx_net              *dev = netdev_priv(net);
2118
2119         clear_bit(EVENT_DEV_OPEN, &dev->flags);
2120         netif_stop_queue(net);
2121
2122         netif_info(dev, ifdown, dev->net,
2123                    "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2124                    net->stats.rx_packets, net->stats.tx_packets,
2125                    net->stats.rx_errors, net->stats.tx_errors);
2126
2127         lan78xx_terminate_urbs(dev);
2128
2129         usb_kill_urb(dev->urb_intr);
2130
2131         skb_queue_purge(&dev->rxq_pause);
2132
2133         /* deferred work (task, timer, softirq) must also stop.
2134          * can't flush_scheduled_work() until we drop rtnl (later),
2135          * else workers could deadlock; so make workers a NOP.
2136          */
2137         dev->flags = 0;
2138         cancel_delayed_work_sync(&dev->wq);
2139         tasklet_kill(&dev->bh);
2140
2141         usb_autopm_put_interface(dev->intf);
2142
2143         return 0;
2144 }
2145
2146 static int lan78xx_linearize(struct sk_buff *skb)
2147 {
2148         return skb_linearize(skb);
2149 }
2150
2151 static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2152                                        struct sk_buff *skb, gfp_t flags)
2153 {
2154         u32 tx_cmd_a, tx_cmd_b;
2155
2156         if (skb_headroom(skb) < TX_OVERHEAD) {
2157                 struct sk_buff *skb2;
2158
2159                 skb2 = skb_copy_expand(skb, TX_OVERHEAD, 0, flags);
2160                 dev_kfree_skb_any(skb);
2161                 skb = skb2;
2162                 if (!skb)
2163                         return NULL;
2164         }
2165
2166         if (lan78xx_linearize(skb) < 0)
2167                 return NULL;
2168
2169         tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2170
2171         if (skb->ip_summed == CHECKSUM_PARTIAL)
2172                 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2173
2174         tx_cmd_b = 0;
2175         if (skb_is_gso(skb)) {
2176                 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2177
2178                 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2179
2180                 tx_cmd_a |= TX_CMD_A_LSO_;
2181         }
2182
2183         if (skb_vlan_tag_present(skb)) {
2184                 tx_cmd_a |= TX_CMD_A_IVTG_;
2185                 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2186         }
2187
2188         skb_push(skb, 4);
2189         cpu_to_le32s(&tx_cmd_b);
2190         memcpy(skb->data, &tx_cmd_b, 4);
2191
2192         skb_push(skb, 4);
2193         cpu_to_le32s(&tx_cmd_a);
2194         memcpy(skb->data, &tx_cmd_a, 4);
2195
2196         return skb;
2197 }
2198
2199 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
2200                                struct sk_buff_head *list, enum skb_state state)
2201 {
2202         unsigned long flags;
2203         enum skb_state old_state;
2204         struct skb_data *entry = (struct skb_data *)skb->cb;
2205
2206         spin_lock_irqsave(&list->lock, flags);
2207         old_state = entry->state;
2208         entry->state = state;
2209
2210         __skb_unlink(skb, list);
2211         spin_unlock(&list->lock);
2212         spin_lock(&dev->done.lock);
2213
2214         __skb_queue_tail(&dev->done, skb);
2215         if (skb_queue_len(&dev->done) == 1)
2216                 tasklet_schedule(&dev->bh);
2217         spin_unlock_irqrestore(&dev->done.lock, flags);
2218
2219         return old_state;
2220 }
2221
2222 static void tx_complete(struct urb *urb)
2223 {
2224         struct sk_buff *skb = (struct sk_buff *)urb->context;
2225         struct skb_data *entry = (struct skb_data *)skb->cb;
2226         struct lan78xx_net *dev = entry->dev;
2227
2228         if (urb->status == 0) {
2229                 dev->net->stats.tx_packets++;
2230                 dev->net->stats.tx_bytes += entry->length;
2231         } else {
2232                 dev->net->stats.tx_errors++;
2233
2234                 switch (urb->status) {
2235                 case -EPIPE:
2236                         lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2237                         break;
2238
2239                 /* software-driven interface shutdown */
2240                 case -ECONNRESET:
2241                 case -ESHUTDOWN:
2242                         break;
2243
2244                 case -EPROTO:
2245                 case -ETIME:
2246                 case -EILSEQ:
2247                         netif_stop_queue(dev->net);
2248                         break;
2249                 default:
2250                         netif_dbg(dev, tx_err, dev->net,
2251                                   "tx err %d\n", entry->urb->status);
2252                         break;
2253                 }
2254         }
2255
2256         usb_autopm_put_interface_async(dev->intf);
2257
2258         defer_bh(dev, skb, &dev->txq, tx_done);
2259 }
2260
2261 static void lan78xx_queue_skb(struct sk_buff_head *list,
2262                               struct sk_buff *newsk, enum skb_state state)
2263 {
2264         struct skb_data *entry = (struct skb_data *)newsk->cb;
2265
2266         __skb_queue_tail(list, newsk);
2267         entry->state = state;
2268 }
2269
2270 netdev_tx_t lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
2271 {
2272         struct lan78xx_net *dev = netdev_priv(net);
2273         struct sk_buff *skb2 = NULL;
2274
2275         if (skb) {
2276                 skb_tx_timestamp(skb);
2277                 skb2 = lan78xx_tx_prep(dev, skb, GFP_ATOMIC);
2278         }
2279
2280         if (skb2) {
2281                 skb_queue_tail(&dev->txq_pend, skb2);
2282
2283                 if (skb_queue_len(&dev->txq_pend) > 10)
2284                         netif_stop_queue(net);
2285         } else {
2286                 netif_dbg(dev, tx_err, dev->net,
2287                           "lan78xx_tx_prep return NULL\n");
2288                 dev->net->stats.tx_errors++;
2289                 dev->net->stats.tx_dropped++;
2290         }
2291
2292         tasklet_schedule(&dev->bh);
2293
2294         return NETDEV_TX_OK;
2295 }
2296
2297 int lan78xx_get_endpoints(struct lan78xx_net *dev, struct usb_interface *intf)
2298 {
2299         int tmp;
2300         struct usb_host_interface *alt = NULL;
2301         struct usb_host_endpoint *in = NULL, *out = NULL;
2302         struct usb_host_endpoint *status = NULL;
2303
2304         for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
2305                 unsigned ep;
2306
2307                 in = NULL;
2308                 out = NULL;
2309                 status = NULL;
2310                 alt = intf->altsetting + tmp;
2311
2312                 for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
2313                         struct usb_host_endpoint *e;
2314                         int intr = 0;
2315
2316                         e = alt->endpoint + ep;
2317                         switch (e->desc.bmAttributes) {
2318                         case USB_ENDPOINT_XFER_INT:
2319                                 if (!usb_endpoint_dir_in(&e->desc))
2320                                         continue;
2321                                 intr = 1;
2322                                 /* FALLTHROUGH */
2323                         case USB_ENDPOINT_XFER_BULK:
2324                                 break;
2325                         default:
2326                                 continue;
2327                         }
2328                         if (usb_endpoint_dir_in(&e->desc)) {
2329                                 if (!intr && !in)
2330                                         in = e;
2331                                 else if (intr && !status)
2332                                         status = e;
2333                         } else {
2334                                 if (!out)
2335                                         out = e;
2336                         }
2337                 }
2338                 if (in && out)
2339                         break;
2340         }
2341         if (!alt || !in || !out)
2342                 return -EINVAL;
2343
2344         dev->pipe_in = usb_rcvbulkpipe(dev->udev,
2345                                        in->desc.bEndpointAddress &
2346                                        USB_ENDPOINT_NUMBER_MASK);
2347         dev->pipe_out = usb_sndbulkpipe(dev->udev,
2348                                         out->desc.bEndpointAddress &
2349                                         USB_ENDPOINT_NUMBER_MASK);
2350         dev->ep_intr = status;
2351
2352         return 0;
2353 }
2354
2355 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
2356 {
2357         struct lan78xx_priv *pdata = NULL;
2358         int ret;
2359         int i;
2360
2361         ret = lan78xx_get_endpoints(dev, intf);
2362
2363         dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
2364
2365         pdata = (struct lan78xx_priv *)(dev->data[0]);
2366         if (!pdata) {
2367                 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
2368                 return -ENOMEM;
2369         }
2370
2371         pdata->dev = dev;
2372
2373         spin_lock_init(&pdata->rfe_ctl_lock);
2374         mutex_init(&pdata->dataport_mutex);
2375
2376         INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
2377
2378         for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
2379                 pdata->vlan_table[i] = 0;
2380
2381         INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
2382
2383         dev->net->features = 0;
2384
2385         if (DEFAULT_TX_CSUM_ENABLE)
2386                 dev->net->features |= NETIF_F_HW_CSUM;
2387
2388         if (DEFAULT_RX_CSUM_ENABLE)
2389                 dev->net->features |= NETIF_F_RXCSUM;
2390
2391         if (DEFAULT_TSO_CSUM_ENABLE)
2392                 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
2393
2394         dev->net->hw_features = dev->net->features;
2395
2396         /* Init all registers */
2397         ret = lan78xx_reset(dev);
2398
2399         dev->net->flags |= IFF_MULTICAST;
2400
2401         pdata->wol = WAKE_MAGIC;
2402
2403         return 0;
2404 }
2405
2406 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
2407 {
2408         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2409
2410         if (pdata) {
2411                 netif_dbg(dev, ifdown, dev->net, "free pdata");
2412                 kfree(pdata);
2413                 pdata = NULL;
2414                 dev->data[0] = 0;
2415         }
2416 }
2417
2418 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
2419                                     struct sk_buff *skb,
2420                                     u32 rx_cmd_a, u32 rx_cmd_b)
2421 {
2422         if (!(dev->net->features & NETIF_F_RXCSUM) ||
2423             unlikely(rx_cmd_a & RX_CMD_A_ICSM_)) {
2424                 skb->ip_summed = CHECKSUM_NONE;
2425         } else {
2426                 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
2427                 skb->ip_summed = CHECKSUM_COMPLETE;
2428         }
2429 }
2430
2431 void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
2432 {
2433         int             status;
2434
2435         if (test_bit(EVENT_RX_PAUSED, &dev->flags)) {
2436                 skb_queue_tail(&dev->rxq_pause, skb);
2437                 return;
2438         }
2439
2440         skb->protocol = eth_type_trans(skb, dev->net);
2441         dev->net->stats.rx_packets++;
2442         dev->net->stats.rx_bytes += skb->len;
2443
2444         netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
2445                   skb->len + sizeof(struct ethhdr), skb->protocol);
2446         memset(skb->cb, 0, sizeof(struct skb_data));
2447
2448         if (skb_defer_rx_timestamp(skb))
2449                 return;
2450
2451         status = netif_rx(skb);
2452         if (status != NET_RX_SUCCESS)
2453                 netif_dbg(dev, rx_err, dev->net,
2454                           "netif_rx status %d\n", status);
2455 }
2456
2457 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb)
2458 {
2459         if (skb->len < dev->net->hard_header_len)
2460                 return 0;
2461
2462         while (skb->len > 0) {
2463                 u32 rx_cmd_a, rx_cmd_b, align_count, size;
2464                 u16 rx_cmd_c;
2465                 struct sk_buff *skb2;
2466                 unsigned char *packet;
2467
2468                 memcpy(&rx_cmd_a, skb->data, sizeof(rx_cmd_a));
2469                 le32_to_cpus(&rx_cmd_a);
2470                 skb_pull(skb, sizeof(rx_cmd_a));
2471
2472                 memcpy(&rx_cmd_b, skb->data, sizeof(rx_cmd_b));
2473                 le32_to_cpus(&rx_cmd_b);
2474                 skb_pull(skb, sizeof(rx_cmd_b));
2475
2476                 memcpy(&rx_cmd_c, skb->data, sizeof(rx_cmd_c));
2477                 le16_to_cpus(&rx_cmd_c);
2478                 skb_pull(skb, sizeof(rx_cmd_c));
2479
2480                 packet = skb->data;
2481
2482                 /* get the packet length */
2483                 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
2484                 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
2485
2486                 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
2487                         netif_dbg(dev, rx_err, dev->net,
2488                                   "Error rx_cmd_a=0x%08x", rx_cmd_a);
2489                 } else {
2490                         /* last frame in this batch */
2491                         if (skb->len == size) {
2492                                 lan78xx_rx_csum_offload(dev, skb,
2493                                                         rx_cmd_a, rx_cmd_b);
2494
2495                                 skb_trim(skb, skb->len - 4); /* remove fcs */
2496                                 skb->truesize = size + sizeof(struct sk_buff);
2497
2498                                 return 1;
2499                         }
2500
2501                         skb2 = skb_clone(skb, GFP_ATOMIC);
2502                         if (unlikely(!skb2)) {
2503                                 netdev_warn(dev->net, "Error allocating skb");
2504                                 return 0;
2505                         }
2506
2507                         skb2->len = size;
2508                         skb2->data = packet;
2509                         skb_set_tail_pointer(skb2, size);
2510
2511                         lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
2512
2513                         skb_trim(skb2, skb2->len - 4); /* remove fcs */
2514                         skb2->truesize = size + sizeof(struct sk_buff);
2515
2516                         lan78xx_skb_return(dev, skb2);
2517                 }
2518
2519                 skb_pull(skb, size);
2520
2521                 /* padding bytes before the next frame starts */
2522                 if (skb->len)
2523                         skb_pull(skb, align_count);
2524         }
2525
2526         if (unlikely(skb->len < 0)) {
2527                 netdev_warn(dev->net, "invalid rx length<0 %d", skb->len);
2528                 return 0;
2529         }
2530
2531         return 1;
2532 }
2533
2534 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
2535 {
2536         if (!lan78xx_rx(dev, skb)) {
2537                 dev->net->stats.rx_errors++;
2538                 goto done;
2539         }
2540
2541         if (skb->len) {
2542                 lan78xx_skb_return(dev, skb);
2543                 return;
2544         }
2545
2546         netif_dbg(dev, rx_err, dev->net, "drop\n");
2547         dev->net->stats.rx_errors++;
2548 done:
2549         skb_queue_tail(&dev->done, skb);
2550 }
2551
2552 static void rx_complete(struct urb *urb);
2553
2554 static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
2555 {
2556         struct sk_buff *skb;
2557         struct skb_data *entry;
2558         unsigned long lockflags;
2559         size_t size = dev->rx_urb_size;
2560         int ret = 0;
2561
2562         skb = netdev_alloc_skb_ip_align(dev->net, size);
2563         if (!skb) {
2564                 usb_free_urb(urb);
2565                 return -ENOMEM;
2566         }
2567
2568         entry = (struct skb_data *)skb->cb;
2569         entry->urb = urb;
2570         entry->dev = dev;
2571         entry->length = 0;
2572
2573         usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
2574                           skb->data, size, rx_complete, skb);
2575
2576         spin_lock_irqsave(&dev->rxq.lock, lockflags);
2577
2578         if (netif_device_present(dev->net) &&
2579             netif_running(dev->net) &&
2580             !test_bit(EVENT_RX_HALT, &dev->flags) &&
2581             !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
2582                 ret = usb_submit_urb(urb, GFP_ATOMIC);
2583                 switch (ret) {
2584                 case 0:
2585                         lan78xx_queue_skb(&dev->rxq, skb, rx_start);
2586                         break;
2587                 case -EPIPE:
2588                         lan78xx_defer_kevent(dev, EVENT_RX_HALT);
2589                         break;
2590                 case -ENODEV:
2591                         netif_dbg(dev, ifdown, dev->net, "device gone\n");
2592                         netif_device_detach(dev->net);
2593                         break;
2594                 case -EHOSTUNREACH:
2595                         ret = -ENOLINK;
2596                         break;
2597                 default:
2598                         netif_dbg(dev, rx_err, dev->net,
2599                                   "rx submit, %d\n", ret);
2600                         tasklet_schedule(&dev->bh);
2601                 }
2602         } else {
2603                 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
2604                 ret = -ENOLINK;
2605         }
2606         spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
2607         if (ret) {
2608                 dev_kfree_skb_any(skb);
2609                 usb_free_urb(urb);
2610         }
2611         return ret;
2612 }
2613
2614 static void rx_complete(struct urb *urb)
2615 {
2616         struct sk_buff  *skb = (struct sk_buff *)urb->context;
2617         struct skb_data *entry = (struct skb_data *)skb->cb;
2618         struct lan78xx_net *dev = entry->dev;
2619         int urb_status = urb->status;
2620         enum skb_state state;
2621
2622         skb_put(skb, urb->actual_length);
2623         state = rx_done;
2624         entry->urb = NULL;
2625
2626         switch (urb_status) {
2627         case 0:
2628                 if (skb->len < dev->net->hard_header_len) {
2629                         state = rx_cleanup;
2630                         dev->net->stats.rx_errors++;
2631                         dev->net->stats.rx_length_errors++;
2632                         netif_dbg(dev, rx_err, dev->net,
2633                                   "rx length %d\n", skb->len);
2634                 }
2635                 usb_mark_last_busy(dev->udev);
2636                 break;
2637         case -EPIPE:
2638                 dev->net->stats.rx_errors++;
2639                 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
2640                 /* FALLTHROUGH */
2641         case -ECONNRESET:                               /* async unlink */
2642         case -ESHUTDOWN:                                /* hardware gone */
2643                 netif_dbg(dev, ifdown, dev->net,
2644                           "rx shutdown, code %d\n", urb_status);
2645                 state = rx_cleanup;
2646                 entry->urb = urb;
2647                 urb = NULL;
2648                 break;
2649         case -EPROTO:
2650         case -ETIME:
2651         case -EILSEQ:
2652                 dev->net->stats.rx_errors++;
2653                 state = rx_cleanup;
2654                 entry->urb = urb;
2655                 urb = NULL;
2656                 break;
2657
2658         /* data overrun ... flush fifo? */
2659         case -EOVERFLOW:
2660                 dev->net->stats.rx_over_errors++;
2661                 /* FALLTHROUGH */
2662
2663         default:
2664                 state = rx_cleanup;
2665                 dev->net->stats.rx_errors++;
2666                 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
2667                 break;
2668         }
2669
2670         state = defer_bh(dev, skb, &dev->rxq, state);
2671
2672         if (urb) {
2673                 if (netif_running(dev->net) &&
2674                     !test_bit(EVENT_RX_HALT, &dev->flags) &&
2675                     state != unlink_start) {
2676                         rx_submit(dev, urb, GFP_ATOMIC);
2677                         return;
2678                 }
2679                 usb_free_urb(urb);
2680         }
2681         netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
2682 }
2683
2684 static void lan78xx_tx_bh(struct lan78xx_net *dev)
2685 {
2686         int length;
2687         struct urb *urb = NULL;
2688         struct skb_data *entry;
2689         unsigned long flags;
2690         struct sk_buff_head *tqp = &dev->txq_pend;
2691         struct sk_buff *skb, *skb2;
2692         int ret;
2693         int count, pos;
2694         int skb_totallen, pkt_cnt;
2695
2696         skb_totallen = 0;
2697         pkt_cnt = 0;
2698         for (skb = tqp->next; pkt_cnt < tqp->qlen; skb = skb->next) {
2699                 if (skb_is_gso(skb)) {
2700                         if (pkt_cnt) {
2701                                 /* handle previous packets first */
2702                                 break;
2703                         }
2704                         length = skb->len;
2705                         skb2 = skb_dequeue(tqp);
2706                         goto gso_skb;
2707                 }
2708
2709                 if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
2710                         break;
2711                 skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
2712                 pkt_cnt++;
2713         }
2714
2715         /* copy to a single skb */
2716         skb = alloc_skb(skb_totallen, GFP_ATOMIC);
2717         if (!skb)
2718                 goto drop;
2719
2720         skb_put(skb, skb_totallen);
2721
2722         for (count = pos = 0; count < pkt_cnt; count++) {
2723                 skb2 = skb_dequeue(tqp);
2724                 if (skb2) {
2725                         memcpy(skb->data + pos, skb2->data, skb2->len);
2726                         pos += roundup(skb2->len, sizeof(u32));
2727                         dev_kfree_skb(skb2);
2728                 }
2729         }
2730
2731         length = skb_totallen;
2732
2733 gso_skb:
2734         urb = usb_alloc_urb(0, GFP_ATOMIC);
2735         if (!urb) {
2736                 netif_dbg(dev, tx_err, dev->net, "no urb\n");
2737                 goto drop;
2738         }
2739
2740         entry = (struct skb_data *)skb->cb;
2741         entry->urb = urb;
2742         entry->dev = dev;
2743         entry->length = length;
2744
2745         spin_lock_irqsave(&dev->txq.lock, flags);
2746         ret = usb_autopm_get_interface_async(dev->intf);
2747         if (ret < 0) {
2748                 spin_unlock_irqrestore(&dev->txq.lock, flags);
2749                 goto drop;
2750         }
2751
2752         usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
2753                           skb->data, skb->len, tx_complete, skb);
2754
2755         if (length % dev->maxpacket == 0) {
2756                 /* send USB_ZERO_PACKET */
2757                 urb->transfer_flags |= URB_ZERO_PACKET;
2758         }
2759
2760 #ifdef CONFIG_PM
2761         /* if this triggers the device is still a sleep */
2762         if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
2763                 /* transmission will be done in resume */
2764                 usb_anchor_urb(urb, &dev->deferred);
2765                 /* no use to process more packets */
2766                 netif_stop_queue(dev->net);
2767                 usb_put_urb(urb);
2768                 spin_unlock_irqrestore(&dev->txq.lock, flags);
2769                 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
2770                 return;
2771         }
2772 #endif
2773
2774         ret = usb_submit_urb(urb, GFP_ATOMIC);
2775         switch (ret) {
2776         case 0:
2777                 dev->net->trans_start = jiffies;
2778                 lan78xx_queue_skb(&dev->txq, skb, tx_start);
2779                 if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
2780                         netif_stop_queue(dev->net);
2781                 break;
2782         case -EPIPE:
2783                 netif_stop_queue(dev->net);
2784                 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
2785                 usb_autopm_put_interface_async(dev->intf);
2786                 break;
2787         default:
2788                 usb_autopm_put_interface_async(dev->intf);
2789                 netif_dbg(dev, tx_err, dev->net,
2790                           "tx: submit urb err %d\n", ret);
2791                 break;
2792         }
2793
2794         spin_unlock_irqrestore(&dev->txq.lock, flags);
2795
2796         if (ret) {
2797                 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
2798 drop:
2799                 dev->net->stats.tx_dropped++;
2800                 if (skb)
2801                         dev_kfree_skb_any(skb);
2802                 usb_free_urb(urb);
2803         } else
2804                 netif_dbg(dev, tx_queued, dev->net,
2805                           "> tx, len %d, type 0x%x\n", length, skb->protocol);
2806 }
2807
2808 static void lan78xx_rx_bh(struct lan78xx_net *dev)
2809 {
2810         struct urb *urb;
2811         int i;
2812
2813         if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
2814                 for (i = 0; i < 10; i++) {
2815                         if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
2816                                 break;
2817                         urb = usb_alloc_urb(0, GFP_ATOMIC);
2818                         if (urb)
2819                                 if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
2820                                         return;
2821                 }
2822
2823                 if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
2824                         tasklet_schedule(&dev->bh);
2825         }
2826         if (skb_queue_len(&dev->txq) < dev->tx_qlen)
2827                 netif_wake_queue(dev->net);
2828 }
2829
2830 static void lan78xx_bh(unsigned long param)
2831 {
2832         struct lan78xx_net *dev = (struct lan78xx_net *)param;
2833         struct sk_buff *skb;
2834         struct skb_data *entry;
2835
2836         while ((skb = skb_dequeue(&dev->done))) {
2837                 entry = (struct skb_data *)(skb->cb);
2838                 switch (entry->state) {
2839                 case rx_done:
2840                         entry->state = rx_cleanup;
2841                         rx_process(dev, skb);
2842                         continue;
2843                 case tx_done:
2844                         usb_free_urb(entry->urb);
2845                         dev_kfree_skb(skb);
2846                         continue;
2847                 case rx_cleanup:
2848                         usb_free_urb(entry->urb);
2849                         dev_kfree_skb(skb);
2850                         continue;
2851                 default:
2852                         netdev_dbg(dev->net, "skb state %d\n", entry->state);
2853                         return;
2854                 }
2855         }
2856
2857         if (netif_device_present(dev->net) && netif_running(dev->net)) {
2858                 if (!skb_queue_empty(&dev->txq_pend))
2859                         lan78xx_tx_bh(dev);
2860
2861                 if (!timer_pending(&dev->delay) &&
2862                     !test_bit(EVENT_RX_HALT, &dev->flags))
2863                         lan78xx_rx_bh(dev);
2864         }
2865 }
2866
2867 static void lan78xx_delayedwork(struct work_struct *work)
2868 {
2869         int status;
2870         struct lan78xx_net *dev;
2871
2872         dev = container_of(work, struct lan78xx_net, wq.work);
2873
2874         if (test_bit(EVENT_TX_HALT, &dev->flags)) {
2875                 unlink_urbs(dev, &dev->txq);
2876                 status = usb_autopm_get_interface(dev->intf);
2877                 if (status < 0)
2878                         goto fail_pipe;
2879                 status = usb_clear_halt(dev->udev, dev->pipe_out);
2880                 usb_autopm_put_interface(dev->intf);
2881                 if (status < 0 &&
2882                     status != -EPIPE &&
2883                     status != -ESHUTDOWN) {
2884                         if (netif_msg_tx_err(dev))
2885 fail_pipe:
2886                                 netdev_err(dev->net,
2887                                            "can't clear tx halt, status %d\n",
2888                                            status);
2889                 } else {
2890                         clear_bit(EVENT_TX_HALT, &dev->flags);
2891                         if (status != -ESHUTDOWN)
2892                                 netif_wake_queue(dev->net);
2893                 }
2894         }
2895         if (test_bit(EVENT_RX_HALT, &dev->flags)) {
2896                 unlink_urbs(dev, &dev->rxq);
2897                 status = usb_autopm_get_interface(dev->intf);
2898                 if (status < 0)
2899                                 goto fail_halt;
2900                 status = usb_clear_halt(dev->udev, dev->pipe_in);
2901                 usb_autopm_put_interface(dev->intf);
2902                 if (status < 0 &&
2903                     status != -EPIPE &&
2904                     status != -ESHUTDOWN) {
2905                         if (netif_msg_rx_err(dev))
2906 fail_halt:
2907                                 netdev_err(dev->net,
2908                                            "can't clear rx halt, status %d\n",
2909                                            status);
2910                 } else {
2911                         clear_bit(EVENT_RX_HALT, &dev->flags);
2912                         tasklet_schedule(&dev->bh);
2913                 }
2914         }
2915
2916         if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
2917                 int ret = 0;
2918
2919                 clear_bit(EVENT_LINK_RESET, &dev->flags);
2920                 status = usb_autopm_get_interface(dev->intf);
2921                 if (status < 0)
2922                         goto skip_reset;
2923                 if (lan78xx_link_reset(dev) < 0) {
2924                         usb_autopm_put_interface(dev->intf);
2925 skip_reset:
2926                         netdev_info(dev->net, "link reset failed (%d)\n",
2927                                     ret);
2928                 } else {
2929                         usb_autopm_put_interface(dev->intf);
2930                 }
2931         }
2932 }
2933
2934 static void intr_complete(struct urb *urb)
2935 {
2936         struct lan78xx_net *dev = urb->context;
2937         int status = urb->status;
2938
2939         switch (status) {
2940         /* success */
2941         case 0:
2942                 lan78xx_status(dev, urb);
2943                 break;
2944
2945         /* software-driven interface shutdown */
2946         case -ENOENT:                   /* urb killed */
2947         case -ESHUTDOWN:                /* hardware gone */
2948                 netif_dbg(dev, ifdown, dev->net,
2949                           "intr shutdown, code %d\n", status);
2950                 return;
2951
2952         /* NOTE:  not throttling like RX/TX, since this endpoint
2953          * already polls infrequently
2954          */
2955         default:
2956                 netdev_dbg(dev->net, "intr status %d\n", status);
2957                 break;
2958         }
2959
2960         if (!netif_running(dev->net))
2961                 return;
2962
2963         memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
2964         status = usb_submit_urb(urb, GFP_ATOMIC);
2965         if (status != 0)
2966                 netif_err(dev, timer, dev->net,
2967                           "intr resubmit --> %d\n", status);
2968 }
2969
2970 static void lan78xx_disconnect(struct usb_interface *intf)
2971 {
2972         struct lan78xx_net              *dev;
2973         struct usb_device               *udev;
2974         struct net_device               *net;
2975
2976         dev = usb_get_intfdata(intf);
2977         usb_set_intfdata(intf, NULL);
2978         if (!dev)
2979                 return;
2980
2981         udev = interface_to_usbdev(intf);
2982
2983         net = dev->net;
2984         unregister_netdev(net);
2985
2986         cancel_delayed_work_sync(&dev->wq);
2987
2988         usb_scuttle_anchored_urbs(&dev->deferred);
2989
2990         lan78xx_unbind(dev, intf);
2991
2992         usb_kill_urb(dev->urb_intr);
2993         usb_free_urb(dev->urb_intr);
2994
2995         free_netdev(net);
2996         usb_put_dev(udev);
2997 }
2998
2999 void lan78xx_tx_timeout(struct net_device *net)
3000 {
3001         struct lan78xx_net *dev = netdev_priv(net);
3002
3003         unlink_urbs(dev, &dev->txq);
3004         tasklet_schedule(&dev->bh);
3005 }
3006
3007 static const struct net_device_ops lan78xx_netdev_ops = {
3008         .ndo_open               = lan78xx_open,
3009         .ndo_stop               = lan78xx_stop,
3010         .ndo_start_xmit         = lan78xx_start_xmit,
3011         .ndo_tx_timeout         = lan78xx_tx_timeout,
3012         .ndo_change_mtu         = lan78xx_change_mtu,
3013         .ndo_set_mac_address    = lan78xx_set_mac_addr,
3014         .ndo_validate_addr      = eth_validate_addr,
3015         .ndo_do_ioctl           = lan78xx_ioctl,
3016         .ndo_set_rx_mode        = lan78xx_set_multicast,
3017         .ndo_set_features       = lan78xx_set_features,
3018         .ndo_vlan_rx_add_vid    = lan78xx_vlan_rx_add_vid,
3019         .ndo_vlan_rx_kill_vid   = lan78xx_vlan_rx_kill_vid,
3020 };
3021
3022 static int lan78xx_probe(struct usb_interface *intf,
3023                          const struct usb_device_id *id)
3024 {
3025         struct lan78xx_net *dev;
3026         struct net_device *netdev;
3027         struct usb_device *udev;
3028         int ret;
3029         unsigned maxp;
3030         unsigned period;
3031         u8 *buf = NULL;
3032
3033         udev = interface_to_usbdev(intf);
3034         udev = usb_get_dev(udev);
3035
3036         ret = -ENOMEM;
3037         netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3038         if (!netdev) {
3039                         dev_err(&intf->dev, "Error: OOM\n");
3040                         goto out1;
3041         }
3042
3043         /* netdev_printk() needs this */
3044         SET_NETDEV_DEV(netdev, &intf->dev);
3045
3046         dev = netdev_priv(netdev);
3047         dev->udev = udev;
3048         dev->intf = intf;
3049         dev->net = netdev;
3050         dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3051                                         | NETIF_MSG_PROBE | NETIF_MSG_LINK);
3052
3053         skb_queue_head_init(&dev->rxq);
3054         skb_queue_head_init(&dev->txq);
3055         skb_queue_head_init(&dev->done);
3056         skb_queue_head_init(&dev->rxq_pause);
3057         skb_queue_head_init(&dev->txq_pend);
3058         mutex_init(&dev->phy_mutex);
3059
3060         tasklet_init(&dev->bh, lan78xx_bh, (unsigned long)dev);
3061         INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3062         init_usb_anchor(&dev->deferred);
3063
3064         netdev->netdev_ops = &lan78xx_netdev_ops;
3065         netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3066         netdev->ethtool_ops = &lan78xx_ethtool_ops;
3067
3068         ret = lan78xx_bind(dev, intf);
3069         if (ret < 0)
3070                 goto out2;
3071         strcpy(netdev->name, "eth%d");
3072
3073         if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3074                 netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3075
3076         dev->ep_blkin = (intf->cur_altsetting)->endpoint + 0;
3077         dev->ep_blkout = (intf->cur_altsetting)->endpoint + 1;
3078         dev->ep_intr = (intf->cur_altsetting)->endpoint + 2;
3079
3080         dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3081         dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3082
3083         dev->pipe_intr = usb_rcvintpipe(dev->udev,
3084                                         dev->ep_intr->desc.bEndpointAddress &
3085                                         USB_ENDPOINT_NUMBER_MASK);
3086         period = dev->ep_intr->desc.bInterval;
3087
3088         maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3089         buf = kmalloc(maxp, GFP_KERNEL);
3090         if (buf) {
3091                 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3092                 if (!dev->urb_intr) {
3093                         kfree(buf);
3094                         goto out3;
3095                 } else {
3096                         usb_fill_int_urb(dev->urb_intr, dev->udev,
3097                                          dev->pipe_intr, buf, maxp,
3098                                          intr_complete, dev, period);
3099                 }
3100         }
3101
3102         dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3103
3104         /* driver requires remote-wakeup capability during autosuspend. */
3105         intf->needs_remote_wakeup = 1;
3106
3107         ret = register_netdev(netdev);
3108         if (ret != 0) {
3109                 netif_err(dev, probe, netdev, "couldn't register the device\n");
3110                 goto out2;
3111         }
3112
3113         usb_set_intfdata(intf, dev);
3114
3115         ret = device_set_wakeup_enable(&udev->dev, true);
3116
3117          /* Default delay of 2sec has more overhead than advantage.
3118           * Set to 10sec as default.
3119           */
3120         pm_runtime_set_autosuspend_delay(&udev->dev,
3121                                          DEFAULT_AUTOSUSPEND_DELAY);
3122
3123         return 0;
3124
3125 out3:
3126         lan78xx_unbind(dev, intf);
3127 out2:
3128         free_netdev(netdev);
3129 out1:
3130         usb_put_dev(udev);
3131
3132         return ret;
3133 }
3134
3135 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3136 {
3137         const u16 crc16poly = 0x8005;
3138         int i;
3139         u16 bit, crc, msb;
3140         u8 data;
3141
3142         crc = 0xFFFF;
3143         for (i = 0; i < len; i++) {
3144                 data = *buf++;
3145                 for (bit = 0; bit < 8; bit++) {
3146                         msb = crc >> 15;
3147                         crc <<= 1;
3148
3149                         if (msb ^ (u16)(data & 1)) {
3150                                 crc ^= crc16poly;
3151                                 crc |= (u16)0x0001U;
3152                         }
3153                         data >>= 1;
3154                 }
3155         }
3156
3157         return crc;
3158 }
3159
3160 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3161 {
3162         u32 buf;
3163         int ret;
3164         int mask_index;
3165         u16 crc;
3166         u32 temp_wucsr;
3167         u32 temp_pmt_ctl;
3168         const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3169         const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3170         const u8 arp_type[2] = { 0x08, 0x06 };
3171
3172         ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3173         buf &= ~MAC_TX_TXEN_;
3174         ret = lan78xx_write_reg(dev, MAC_TX, buf);
3175         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3176         buf &= ~MAC_RX_RXEN_;
3177         ret = lan78xx_write_reg(dev, MAC_RX, buf);
3178
3179         ret = lan78xx_write_reg(dev, WUCSR, 0);
3180         ret = lan78xx_write_reg(dev, WUCSR2, 0);
3181         ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3182
3183         temp_wucsr = 0;
3184
3185         temp_pmt_ctl = 0;
3186         ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3187         temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3188         temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3189
3190         for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3191                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3192
3193         mask_index = 0;
3194         if (wol & WAKE_PHY) {
3195                 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3196
3197                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3198                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3199                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3200         }
3201         if (wol & WAKE_MAGIC) {
3202                 temp_wucsr |= WUCSR_MPEN_;
3203
3204                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3205                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3206                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3207         }
3208         if (wol & WAKE_BCAST) {
3209                 temp_wucsr |= WUCSR_BCST_EN_;
3210
3211                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3212                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3213                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3214         }
3215         if (wol & WAKE_MCAST) {
3216                 temp_wucsr |= WUCSR_WAKE_EN_;
3217
3218                 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3219                 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3220                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3221                                         WUF_CFGX_EN_ |
3222                                         WUF_CFGX_TYPE_MCAST_ |
3223                                         (0 << WUF_CFGX_OFFSET_SHIFT_) |
3224                                         (crc & WUF_CFGX_CRC16_MASK_));
3225
3226                 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3227                 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3228                 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3229                 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3230                 mask_index++;
3231
3232                 /* for IPv6 Multicast */
3233                 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
3234                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3235                                         WUF_CFGX_EN_ |
3236                                         WUF_CFGX_TYPE_MCAST_ |
3237                                         (0 << WUF_CFGX_OFFSET_SHIFT_) |
3238                                         (crc & WUF_CFGX_CRC16_MASK_));
3239
3240                 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
3241                 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3242                 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3243                 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3244                 mask_index++;
3245
3246                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3247                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3248                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3249         }
3250         if (wol & WAKE_UCAST) {
3251                 temp_wucsr |= WUCSR_PFDA_EN_;
3252
3253                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3254                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3255                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3256         }
3257         if (wol & WAKE_ARP) {
3258                 temp_wucsr |= WUCSR_WAKE_EN_;
3259
3260                 /* set WUF_CFG & WUF_MASK
3261                  * for packettype (offset 12,13) = ARP (0x0806)
3262                  */
3263                 crc = lan78xx_wakeframe_crc16(arp_type, 2);
3264                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3265                                         WUF_CFGX_EN_ |
3266                                         WUF_CFGX_TYPE_ALL_ |
3267                                         (0 << WUF_CFGX_OFFSET_SHIFT_) |
3268                                         (crc & WUF_CFGX_CRC16_MASK_));
3269
3270                 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3271                 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3272                 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3273                 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3274                 mask_index++;
3275
3276                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3277                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3278                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3279         }
3280
3281         ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3282
3283         /* when multiple WOL bits are set */
3284         if (hweight_long((unsigned long)wol) > 1) {
3285                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3286                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3287                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3288         }
3289         ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3290
3291         /* clear WUPS */
3292         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3293         buf |= PMT_CTL_WUPS_MASK_;
3294         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3295
3296         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3297         buf |= MAC_RX_RXEN_;
3298         ret = lan78xx_write_reg(dev, MAC_RX, buf);
3299
3300         return 0;
3301 }
3302
3303 int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3304 {
3305         struct lan78xx_net *dev = usb_get_intfdata(intf);
3306         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3307         u32 buf;
3308         int ret;
3309         int event;
3310
3311         ret = 0;
3312         event = message.event;
3313
3314         if (!dev->suspend_count++) {
3315                 spin_lock_irq(&dev->txq.lock);
3316                 /* don't autosuspend while transmitting */
3317                 if ((skb_queue_len(&dev->txq) ||
3318                      skb_queue_len(&dev->txq_pend)) &&
3319                         PMSG_IS_AUTO(message)) {
3320                         spin_unlock_irq(&dev->txq.lock);
3321                         ret = -EBUSY;
3322                         goto out;
3323                 } else {
3324                         set_bit(EVENT_DEV_ASLEEP, &dev->flags);
3325                         spin_unlock_irq(&dev->txq.lock);
3326                 }
3327
3328                 /* stop TX & RX */
3329                 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3330                 buf &= ~MAC_TX_TXEN_;
3331                 ret = lan78xx_write_reg(dev, MAC_TX, buf);
3332                 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3333                 buf &= ~MAC_RX_RXEN_;
3334                 ret = lan78xx_write_reg(dev, MAC_RX, buf);
3335
3336                 /* empty out the rx and queues */
3337                 netif_device_detach(dev->net);
3338                 lan78xx_terminate_urbs(dev);
3339                 usb_kill_urb(dev->urb_intr);
3340
3341                 /* reattach */
3342                 netif_device_attach(dev->net);
3343         }
3344
3345         if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3346                 if (PMSG_IS_AUTO(message)) {
3347                         /* auto suspend (selective suspend) */
3348                         ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3349                         buf &= ~MAC_TX_TXEN_;
3350                         ret = lan78xx_write_reg(dev, MAC_TX, buf);
3351                         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3352                         buf &= ~MAC_RX_RXEN_;
3353                         ret = lan78xx_write_reg(dev, MAC_RX, buf);
3354
3355                         ret = lan78xx_write_reg(dev, WUCSR, 0);
3356                         ret = lan78xx_write_reg(dev, WUCSR2, 0);
3357                         ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3358
3359                         /* set goodframe wakeup */
3360                         ret = lan78xx_read_reg(dev, WUCSR, &buf);
3361
3362                         buf |= WUCSR_RFE_WAKE_EN_;
3363                         buf |= WUCSR_STORE_WAKE_;
3364
3365                         ret = lan78xx_write_reg(dev, WUCSR, buf);
3366
3367                         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3368
3369                         buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
3370                         buf |= PMT_CTL_RES_CLR_WKP_STS_;
3371
3372                         buf |= PMT_CTL_PHY_WAKE_EN_;
3373                         buf |= PMT_CTL_WOL_EN_;
3374                         buf &= ~PMT_CTL_SUS_MODE_MASK_;
3375                         buf |= PMT_CTL_SUS_MODE_3_;
3376
3377                         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3378
3379                         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3380
3381                         buf |= PMT_CTL_WUPS_MASK_;
3382
3383                         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3384
3385                         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3386                         buf |= MAC_RX_RXEN_;
3387                         ret = lan78xx_write_reg(dev, MAC_RX, buf);
3388                 } else {
3389                         lan78xx_set_suspend(dev, pdata->wol);
3390                 }
3391         }
3392
3393 out:
3394         return ret;
3395 }
3396
3397 int lan78xx_resume(struct usb_interface *intf)
3398 {
3399         struct lan78xx_net *dev = usb_get_intfdata(intf);
3400         struct sk_buff *skb;
3401         struct urb *res;
3402         int ret;
3403         u32 buf;
3404
3405         if (!--dev->suspend_count) {
3406                 /* resume interrupt URBs */
3407                 if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
3408                                 usb_submit_urb(dev->urb_intr, GFP_NOIO);
3409
3410                 spin_lock_irq(&dev->txq.lock);
3411                 while ((res = usb_get_from_anchor(&dev->deferred))) {
3412                         skb = (struct sk_buff *)res->context;
3413                         ret = usb_submit_urb(res, GFP_ATOMIC);
3414                         if (ret < 0) {
3415                                 dev_kfree_skb_any(skb);
3416                                 usb_free_urb(res);
3417                                 usb_autopm_put_interface_async(dev->intf);
3418                         } else {
3419                                 dev->net->trans_start = jiffies;
3420                                 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3421                         }
3422                 }
3423
3424                 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
3425                 spin_unlock_irq(&dev->txq.lock);
3426
3427                 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
3428                         if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
3429                                 netif_start_queue(dev->net);
3430                         tasklet_schedule(&dev->bh);
3431                 }
3432         }
3433
3434         ret = lan78xx_write_reg(dev, WUCSR2, 0);
3435         ret = lan78xx_write_reg(dev, WUCSR, 0);
3436         ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3437
3438         ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
3439                                              WUCSR2_ARP_RCD_ |
3440                                              WUCSR2_IPV6_TCPSYN_RCD_ |
3441                                              WUCSR2_IPV4_TCPSYN_RCD_);
3442
3443         ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
3444                                             WUCSR_EEE_RX_WAKE_ |
3445                                             WUCSR_PFDA_FR_ |
3446                                             WUCSR_RFE_WAKE_FR_ |
3447                                             WUCSR_WUFR_ |
3448                                             WUCSR_MPR_ |
3449                                             WUCSR_BCST_FR_);
3450
3451         ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3452         buf |= MAC_TX_TXEN_;
3453         ret = lan78xx_write_reg(dev, MAC_TX, buf);
3454
3455         return 0;
3456 }
3457
3458 int lan78xx_reset_resume(struct usb_interface *intf)
3459 {
3460         struct lan78xx_net *dev = usb_get_intfdata(intf);
3461
3462         lan78xx_reset(dev);
3463         return lan78xx_resume(intf);
3464 }
3465
3466 static const struct usb_device_id products[] = {
3467         {
3468         /* LAN7800 USB Gigabit Ethernet Device */
3469         USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
3470         },
3471         {
3472         /* LAN7850 USB Gigabit Ethernet Device */
3473         USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
3474         },
3475         {},
3476 };
3477 MODULE_DEVICE_TABLE(usb, products);
3478
3479 static struct usb_driver lan78xx_driver = {
3480         .name                   = DRIVER_NAME,
3481         .id_table               = products,
3482         .probe                  = lan78xx_probe,
3483         .disconnect             = lan78xx_disconnect,
3484         .suspend                = lan78xx_suspend,
3485         .resume                 = lan78xx_resume,
3486         .reset_resume           = lan78xx_reset_resume,
3487         .supports_autosuspend   = 1,
3488         .disable_hub_initiated_lpm = 1,
3489 };
3490
3491 module_usb_driver(lan78xx_driver);
3492
3493 MODULE_AUTHOR(DRIVER_AUTHOR);
3494 MODULE_DESCRIPTION(DRIVER_DESC);
3495 MODULE_LICENSE("GPL");