drivers/net/usb/smsc75xx.c

   1  /***************************************************************************
   2  *
   3  * Copyright (C) 2007-2010 SMSC
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  *****************************************************************************/
  19
  20 #include <linux/module.h>
  21 #include <linux/kmod.h>
  22 #include <linux/netdevice.h>
  23 #include <linux/etherdevice.h>
  24 #include <linux/ethtool.h>
  25 #include <linux/mii.h>
  26 #include <linux/usb.h>
  27 #include <linux/bitrev.h>
  28 #include <linux/crc16.h>
  29 #include <linux/crc32.h>
  30 #include <linux/usb/usbnet.h>
  31 #include <linux/slab.h>
  32 #include <linux/of_net.h>
  33 #include "smsc75xx.h"
  34
  35 #define SMSC_CHIPNAME                   "smsc75xx"
  36 #define SMSC_DRIVER_VERSION             "1.0.0"
  37 #define HS_USB_PKT_SIZE                 (512)
  38 #define FS_USB_PKT_SIZE                 (64)
  39 #define DEFAULT_HS_BURST_CAP_SIZE       (16 * 1024 + 5 * HS_USB_PKT_SIZE)
  40 #define DEFAULT_FS_BURST_CAP_SIZE       (6 * 1024 + 33 * FS_USB_PKT_SIZE)
  41 #define DEFAULT_BULK_IN_DELAY           (0x00002000)
  42 #define MAX_SINGLE_PACKET_SIZE          (9000)
  43 #define LAN75XX_EEPROM_MAGIC            (0x7500)
  44 #define EEPROM_MAC_OFFSET               (0x01)
  45 #define DEFAULT_TX_CSUM_ENABLE          (true)
  46 #define DEFAULT_RX_CSUM_ENABLE          (true)
  47 #define SMSC75XX_INTERNAL_PHY_ID        (1)
  48 #define SMSC75XX_TX_OVERHEAD            (8)
  49 #define MAX_RX_FIFO_SIZE                (20 * 1024)
  50 #define MAX_TX_FIFO_SIZE                (12 * 1024)
  51 #define USB_VENDOR_ID_SMSC              (0x0424)
  52 #define USB_PRODUCT_ID_LAN7500          (0x7500)
  53 #define USB_PRODUCT_ID_LAN7505          (0x7505)
  54 #define RXW_PADDING                     2
  55 #define SUPPORTED_WAKE                  (WAKE_PHY | WAKE_UCAST | WAKE_BCAST | \
  56                                          WAKE_MCAST | WAKE_ARP | WAKE_MAGIC)
  57
  58 #define SUSPEND_SUSPEND0                (0x01)
  59 #define SUSPEND_SUSPEND1                (0x02)
  60 #define SUSPEND_SUSPEND2                (0x04)
  61 #define SUSPEND_SUSPEND3                (0x08)
  62 #define SUSPEND_ALLMODES                (SUSPEND_SUSPEND0 | SUSPEND_SUSPEND1 | \
  63                                          SUSPEND_SUSPEND2 | SUSPEND_SUSPEND3)
  64
  65 struct smsc75xx_priv {
  66         struct usbnet *dev;
  67         u32 rfe_ctl;
  68         u32 wolopts;
  69         u32 multicast_hash_table[DP_SEL_VHF_HASH_LEN];
  70         struct mutex dataport_mutex;
  71         spinlock_t rfe_ctl_lock;
  72         struct work_struct set_multicast;
  73         u8 suspend_flags;
  74 };
  75
  76 struct usb_context {
  77         struct usb_ctrlrequest req;
  78         struct usbnet *dev;
  79 };
  80
  81 static bool turbo_mode = true;
  82 module_param(turbo_mode, bool, 0644);
  83 MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");
  84
  85 static int smsc75xx_link_ok_nopm(struct usbnet *dev);
  86 static int smsc75xx_phy_gig_workaround(struct usbnet *dev);
  87
  88 static int __must_check __smsc75xx_read_reg(struct usbnet *dev, u32 index,
  89                                             u32 *data, int in_pm)
  90 {
  91         u32 buf;
  92         int ret;
  93         int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
  94
  95         BUG_ON(!dev);
  96
  97         if (!in_pm)
  98                 fn = usbnet_read_cmd;
  99         else
 100                 fn = usbnet_read_cmd_nopm;
 101
 102         ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN
 103                  | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 104                  0, index, &buf, 4);
 105         if (unlikely(ret < 4)) {
 106                 ret = ret < 0 ? ret : -ENODATA;
 107
 108                 netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n",
 109                             index, ret);
 110                 return ret;
 111         }
 112
 113         le32_to_cpus(&buf);
 114         *data = buf;
 115
 116         return ret;
 117 }
 118
 119 static int __must_check __smsc75xx_write_reg(struct usbnet *dev, u32 index,
 120                                              u32 data, int in_pm)
 121 {
 122         u32 buf;
 123         int ret;
 124         int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
 125
 126         BUG_ON(!dev);
 127
 128         if (!in_pm)
 129                 fn = usbnet_write_cmd;
 130         else
 131                 fn = usbnet_write_cmd_nopm;
 132
 133         buf = data;
 134         cpu_to_le32s(&buf);
 135
 136         ret = fn(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, USB_DIR_OUT
 137                  | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 138                  0, index, &buf, 4);
 139         if (unlikely(ret < 0))
 140                 netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n",
 141                             index, ret);
 142
 143         return ret;
 144 }
 145
 146 static int __must_check smsc75xx_read_reg_nopm(struct usbnet *dev, u32 index,
 147                                                u32 *data)
 148 {
 149         return __smsc75xx_read_reg(dev, index, data, 1);
 150 }
 151
 152 static int __must_check smsc75xx_write_reg_nopm(struct usbnet *dev, u32 index,
 153                                                 u32 data)
 154 {
 155         return __smsc75xx_write_reg(dev, index, data, 1);
 156 }
 157
 158 static int __must_check smsc75xx_read_reg(struct usbnet *dev, u32 index,
 159                                           u32 *data)
 160 {
 161         return __smsc75xx_read_reg(dev, index, data, 0);
 162 }
 163
 164 static int __must_check smsc75xx_write_reg(struct usbnet *dev, u32 index,
 165                                            u32 data)
 166 {
 167         return __smsc75xx_write_reg(dev, index, data, 0);
 168 }
 169
 170 /* Loop until the read is completed with timeout
 171  * called with phy_mutex held */
 172 static __must_check int __smsc75xx_phy_wait_not_busy(struct usbnet *dev,
 173                                                      int in_pm)
 174 {
 175         unsigned long start_time = jiffies;
 176         u32 val;
 177         int ret;
 178
 179         do {
 180                 ret = __smsc75xx_read_reg(dev, MII_ACCESS, &val, in_pm);
 181                 if (ret < 0) {
 182                         netdev_warn(dev->net, "Error reading MII_ACCESS\n");
 183                         return ret;
 184                 }
 185
 186                 if (!(val & MII_ACCESS_BUSY))
 187                         return 0;
 188         } while (!time_after(jiffies, start_time + HZ));
 189
 190         return -EIO;
 191 }
 192
 193 static int __smsc75xx_mdio_read(struct net_device *netdev, int phy_id, int idx,
 194                                 int in_pm)
 195 {
 196         struct usbnet *dev = netdev_priv(netdev);
 197         u32 val, addr;
 198         int ret;
 199
 200         mutex_lock(&dev->phy_mutex);
 201
 202         /* confirm MII not busy */
 203         ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
 204         if (ret < 0) {
 205                 netdev_warn(dev->net, "MII is busy in smsc75xx_mdio_read\n");
 206                 goto done;
 207         }
 208
 209         /* set the address, index & direction (read from PHY) */
 210         phy_id &= dev->mii.phy_id_mask;
 211         idx &= dev->mii.reg_num_mask;
 212         addr = ((phy_id << MII_ACCESS_PHY_ADDR_SHIFT) & MII_ACCESS_PHY_ADDR)
 213                 | ((idx << MII_ACCESS_REG_ADDR_SHIFT) & MII_ACCESS_REG_ADDR)
 214                 | MII_ACCESS_READ | MII_ACCESS_BUSY;
 215         ret = __smsc75xx_write_reg(dev, MII_ACCESS, addr, in_pm);
 216         if (ret < 0) {
 217                 netdev_warn(dev->net, "Error writing MII_ACCESS\n");
 218                 goto done;
 219         }
 220
 221         ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
 222         if (ret < 0) {
 223                 netdev_warn(dev->net, "Timed out reading MII reg %02X\n", idx);
 224                 goto done;
 225         }
 226
 227         ret = __smsc75xx_read_reg(dev, MII_DATA, &val, in_pm);
 228         if (ret < 0) {
 229                 netdev_warn(dev->net, "Error reading MII_DATA\n");
 230                 goto done;
 231         }
 232
 233         ret = (u16)(val & 0xFFFF);
 234
 235 done:
 236         mutex_unlock(&dev->phy_mutex);
 237         return ret;
 238 }
 239
 240 static void __smsc75xx_mdio_write(struct net_device *netdev, int phy_id,
 241                                   int idx, int regval, int in_pm)
 242 {
 243         struct usbnet *dev = netdev_priv(netdev);
 244         u32 val, addr;
 245         int ret;
 246
 247         mutex_lock(&dev->phy_mutex);
 248
 249         /* confirm MII not busy */
 250         ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
 251         if (ret < 0) {
 252                 netdev_warn(dev->net, "MII is busy in smsc75xx_mdio_write\n");
 253                 goto done;
 254         }
 255
 256         val = regval;
 257         ret = __smsc75xx_write_reg(dev, MII_DATA, val, in_pm);
 258         if (ret < 0) {
 259                 netdev_warn(dev->net, "Error writing MII_DATA\n");
 260                 goto done;
 261         }
 262
 263         /* set the address, index & direction (write to PHY) */
 264         phy_id &= dev->mii.phy_id_mask;
 265         idx &= dev->mii.reg_num_mask;
 266         addr = ((phy_id << MII_ACCESS_PHY_ADDR_SHIFT) & MII_ACCESS_PHY_ADDR)
 267                 | ((idx << MII_ACCESS_REG_ADDR_SHIFT) & MII_ACCESS_REG_ADDR)
 268                 | MII_ACCESS_WRITE | MII_ACCESS_BUSY;
 269         ret = __smsc75xx_write_reg(dev, MII_ACCESS, addr, in_pm);
 270         if (ret < 0) {
 271                 netdev_warn(dev->net, "Error writing MII_ACCESS\n");
 272                 goto done;
 273         }
 274
 275         ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
 276         if (ret < 0) {
 277                 netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx);
 278                 goto done;
 279         }
 280
 281 done:
 282         mutex_unlock(&dev->phy_mutex);
 283 }
 284
 285 static int smsc75xx_mdio_read_nopm(struct net_device *netdev, int phy_id,
 286                                    int idx)
 287 {
 288         return __smsc75xx_mdio_read(netdev, phy_id, idx, 1);
 289 }
 290
 291 static void smsc75xx_mdio_write_nopm(struct net_device *netdev, int phy_id,
 292                                      int idx, int regval)
 293 {
 294         __smsc75xx_mdio_write(netdev, phy_id, idx, regval, 1);
 295 }
 296
 297 static int smsc75xx_mdio_read(struct net_device *netdev, int phy_id, int idx)
 298 {
 299         return __smsc75xx_mdio_read(netdev, phy_id, idx, 0);
 300 }
 301
 302 static void smsc75xx_mdio_write(struct net_device *netdev, int phy_id, int idx,
 303                                 int regval)
 304 {
 305         __smsc75xx_mdio_write(netdev, phy_id, idx, regval, 0);
 306 }
 307
 308 static int smsc75xx_wait_eeprom(struct usbnet *dev)
 309 {
 310         unsigned long start_time = jiffies;
 311         u32 val;
 312         int ret;
 313
 314         do {
 315                 ret = smsc75xx_read_reg(dev, E2P_CMD, &val);
 316                 if (ret < 0) {
 317                         netdev_warn(dev->net, "Error reading E2P_CMD\n");
 318                         return ret;
 319                 }
 320
 321                 if (!(val & E2P_CMD_BUSY) || (val & E2P_CMD_TIMEOUT))
 322                         break;
 323                 udelay(40);
 324         } while (!time_after(jiffies, start_time + HZ));
 325
 326         if (val & (E2P_CMD_TIMEOUT | E2P_CMD_BUSY)) {
 327                 netdev_warn(dev->net, "EEPROM read operation timeout\n");
 328                 return -EIO;
 329         }
 330
 331         return 0;
 332 }
 333
 334 static int smsc75xx_eeprom_confirm_not_busy(struct usbnet *dev)
 335 {
 336         unsigned long start_time = jiffies;
 337         u32 val;
 338         int ret;
 339
 340         do {
 341                 ret = smsc75xx_read_reg(dev, E2P_CMD, &val);
 342                 if (ret < 0) {
 343                         netdev_warn(dev->net, "Error reading E2P_CMD\n");
 344                         return ret;
 345                 }
 346
 347                 if (!(val & E2P_CMD_BUSY))
 348                         return 0;
 349
 350                 udelay(40);
 351         } while (!time_after(jiffies, start_time + HZ));
 352
 353         netdev_warn(dev->net, "EEPROM is busy\n");
 354         return -EIO;
 355 }
 356
 357 static int smsc75xx_read_eeprom(struct usbnet *dev, u32 offset, u32 length,
 358                                 u8 *data)
 359 {
 360         u32 val;
 361         int i, ret;
 362
 363         BUG_ON(!dev);
 364         BUG_ON(!data);
 365
 366         ret = smsc75xx_eeprom_confirm_not_busy(dev);
 367         if (ret)
 368                 return ret;
 369
 370         for (i = 0; i < length; i++) {
 371                 val = E2P_CMD_BUSY | E2P_CMD_READ | (offset & E2P_CMD_ADDR);
 372                 ret = smsc75xx_write_reg(dev, E2P_CMD, val);
 373                 if (ret < 0) {
 374                         netdev_warn(dev->net, "Error writing E2P_CMD\n");
 375                         return ret;
 376                 }
 377
 378                 ret = smsc75xx_wait_eeprom(dev);
 379                 if (ret < 0)
 380                         return ret;
 381
 382                 ret = smsc75xx_read_reg(dev, E2P_DATA, &val);
 383                 if (ret < 0) {
 384                         netdev_warn(dev->net, "Error reading E2P_DATA\n");
 385                         return ret;
 386                 }
 387
 388                 data[i] = val & 0xFF;
 389                 offset++;
 390         }
 391
 392         return 0;
 393 }
 394
 395 static int smsc75xx_write_eeprom(struct usbnet *dev, u32 offset, u32 length,
 396                                  u8 *data)
 397 {
 398         u32 val;
 399         int i, ret;
 400
 401         BUG_ON(!dev);
 402         BUG_ON(!data);
 403
 404         ret = smsc75xx_eeprom_confirm_not_busy(dev);
 405         if (ret)
 406                 return ret;
 407
 408         /* Issue write/erase enable command */
 409         val = E2P_CMD_BUSY | E2P_CMD_EWEN;
 410         ret = smsc75xx_write_reg(dev, E2P_CMD, val);
 411         if (ret < 0) {
 412                 netdev_warn(dev->net, "Error writing E2P_CMD\n");
 413                 return ret;
 414         }
 415
 416         ret = smsc75xx_wait_eeprom(dev);
 417         if (ret < 0)
 418                 return ret;
 419
 420         for (i = 0; i < length; i++) {
 421
 422                 /* Fill data register */
 423                 val = data[i];
 424                 ret = smsc75xx_write_reg(dev, E2P_DATA, val);
 425                 if (ret < 0) {
 426                         netdev_warn(dev->net, "Error writing E2P_DATA\n");
 427                         return ret;
 428                 }
 429
 430                 /* Send "write" command */
 431                 val = E2P_CMD_BUSY | E2P_CMD_WRITE | (offset & E2P_CMD_ADDR);
 432                 ret = smsc75xx_write_reg(dev, E2P_CMD, val);
 433                 if (ret < 0) {
 434                         netdev_warn(dev->net, "Error writing E2P_CMD\n");
 435                         return ret;
 436                 }
 437
 438                 ret = smsc75xx_wait_eeprom(dev);
 439                 if (ret < 0)
 440                         return ret;
 441
 442                 offset++;
 443         }
 444
 445         return 0;
 446 }
 447
 448 static int smsc75xx_dataport_wait_not_busy(struct usbnet *dev)
 449 {
 450         int i, ret;
 451
 452         for (i = 0; i < 100; i++) {
 453                 u32 dp_sel;
 454                 ret = smsc75xx_read_reg(dev, DP_SEL, &dp_sel);
 455                 if (ret < 0) {
 456                         netdev_warn(dev->net, "Error reading DP_SEL\n");
 457                         return ret;
 458                 }
 459
 460                 if (dp_sel & DP_SEL_DPRDY)
 461                         return 0;
 462
 463                 udelay(40);
 464         }
 465
 466         netdev_warn(dev->net, "smsc75xx_dataport_wait_not_busy timed out\n");
 467
 468         return -EIO;
 469 }
 470
 471 static int smsc75xx_dataport_write(struct usbnet *dev, u32 ram_select, u32 addr,
 472                                    u32 length, u32 *buf)
 473 {
 474         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
 475         u32 dp_sel;
 476         int i, ret;
 477
 478         mutex_lock(&pdata->dataport_mutex);
 479
 480         ret = smsc75xx_dataport_wait_not_busy(dev);
 481         if (ret < 0) {
 482                 netdev_warn(dev->net, "smsc75xx_dataport_write busy on entry\n");
 483                 goto done;
 484         }
 485
 486         ret = smsc75xx_read_reg(dev, DP_SEL, &dp_sel);
 487         if (ret < 0) {
 488                 netdev_warn(dev->net, "Error reading DP_SEL\n");
 489                 goto done;
 490         }
 491
 492         dp_sel &= ~DP_SEL_RSEL;
 493         dp_sel |= ram_select;
 494         ret = smsc75xx_write_reg(dev, DP_SEL, dp_sel);
 495         if (ret < 0) {
 496                 netdev_warn(dev->net, "Error writing DP_SEL\n");
 497                 goto done;
 498         }
 499
 500         for (i = 0; i < length; i++) {
 501                 ret = smsc75xx_write_reg(dev, DP_ADDR, addr + i);
 502                 if (ret < 0) {
 503                         netdev_warn(dev->net, "Error writing DP_ADDR\n");
 504                         goto done;
 505                 }
 506
 507                 ret = smsc75xx_write_reg(dev, DP_DATA, buf[i]);
 508                 if (ret < 0) {
 509                         netdev_warn(dev->net, "Error writing DP_DATA\n");
 510                         goto done;
 511                 }
 512
 513                 ret = smsc75xx_write_reg(dev, DP_CMD, DP_CMD_WRITE);
 514                 if (ret < 0) {
 515                         netdev_warn(dev->net, "Error writing DP_CMD\n");
 516                         goto done;
 517                 }
 518
 519                 ret = smsc75xx_dataport_wait_not_busy(dev);
 520                 if (ret < 0) {
 521                         netdev_warn(dev->net, "smsc75xx_dataport_write timeout\n");
 522                         goto done;
 523                 }
 524         }
 525
 526 done:
 527         mutex_unlock(&pdata->dataport_mutex);
 528         return ret;
 529 }
 530
 531 /* returns hash bit number for given MAC address */
 532 static u32 smsc75xx_hash(char addr[ETH_ALEN])
 533 {
 534         return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
 535 }
 536
 537 static void smsc75xx_deferred_multicast_write(struct work_struct *param)
 538 {
 539         struct smsc75xx_priv *pdata =
 540                 container_of(param, struct smsc75xx_priv, set_multicast);
 541         struct usbnet *dev = pdata->dev;
 542         int ret;
 543
 544         netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
 545                   pdata->rfe_ctl);
 546
 547         smsc75xx_dataport_write(dev, DP_SEL_VHF, DP_SEL_VHF_VLAN_LEN,
 548                 DP_SEL_VHF_HASH_LEN, pdata->multicast_hash_table);
 549
 550         ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
 551         if (ret < 0)
 552                 netdev_warn(dev->net, "Error writing RFE_CRL\n");
 553 }
 554
 555 static void smsc75xx_set_multicast(struct net_device *netdev)
 556 {
 557         struct usbnet *dev = netdev_priv(netdev);
 558         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
 559         unsigned long flags;
 560         int i;
 561
 562         spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
 563
 564         pdata->rfe_ctl &=
 565                 ~(RFE_CTL_AU | RFE_CTL_AM | RFE_CTL_DPF | RFE_CTL_MHF);
 566         pdata->rfe_ctl |= RFE_CTL_AB;
 567
 568         for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
 569                 pdata->multicast_hash_table[i] = 0;
 570
 571         if (dev->net->flags & IFF_PROMISC) {
 572                 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled\n");
 573                 pdata->rfe_ctl |= RFE_CTL_AM | RFE_CTL_AU;
 574         } else if (dev->net->flags & IFF_ALLMULTI) {
 575                 netif_dbg(dev, drv, dev->net, "receive all multicast enabled\n");
 576                 pdata->rfe_ctl |= RFE_CTL_AM | RFE_CTL_DPF;
 577         } else if (!netdev_mc_empty(dev->net)) {
 578                 struct netdev_hw_addr *ha;
 579
 580                 netif_dbg(dev, drv, dev->net, "receive multicast hash filter\n");
 581
 582                 pdata->rfe_ctl |= RFE_CTL_MHF | RFE_CTL_DPF;
 583
 584                 netdev_for_each_mc_addr(ha, netdev) {
 585                         u32 bitnum = smsc75xx_hash(ha->addr);
 586                         pdata->multicast_hash_table[bitnum / 32] |=
 587                                 (1 << (bitnum % 32));
 588                 }
 589         } else {
 590                 netif_dbg(dev, drv, dev->net, "receive own packets only\n");
 591                 pdata->rfe_ctl |= RFE_CTL_DPF;
 592         }
 593
 594         spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
 595
 596         /* defer register writes to a sleepable context */
 597         schedule_work(&pdata->set_multicast);
 598 }
 599
 600 static int smsc75xx_update_flowcontrol(struct usbnet *dev, u8 duplex,
 601                                             u16 lcladv, u16 rmtadv)
 602 {
 603         u32 flow = 0, fct_flow = 0;
 604         int ret;
 605
 606         if (duplex == DUPLEX_FULL) {
 607                 u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
 608
 609                 if (cap & FLOW_CTRL_TX) {
 610                         flow = (FLOW_TX_FCEN | 0xFFFF);
 611                         /* set fct_flow thresholds to 20% and 80% */
 612                         fct_flow = (8 << 8) | 32;
 613                 }
 614
 615                 if (cap & FLOW_CTRL_RX)
 616                         flow |= FLOW_RX_FCEN;
 617
 618                 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s\n",
 619                           (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
 620                           (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
 621         } else {
 622                 netif_dbg(dev, link, dev->net, "half duplex\n");
 623         }
 624
 625         ret = smsc75xx_write_reg(dev, FLOW, flow);
 626         if (ret < 0) {
 627                 netdev_warn(dev->net, "Error writing FLOW\n");
 628                 return ret;
 629         }
 630
 631         ret = smsc75xx_write_reg(dev, FCT_FLOW, fct_flow);
 632         if (ret < 0) {
 633                 netdev_warn(dev->net, "Error writing FCT_FLOW\n");
 634                 return ret;
 635         }
 636
 637         return 0;
 638 }
 639
 640 static int smsc75xx_link_reset(struct usbnet *dev)
 641 {
 642         struct mii_if_info *mii = &dev->mii;
 643         struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
 644         u16 lcladv, rmtadv;
 645         int ret;
 646
 647         /* write to clear phy interrupt status */
 648         smsc75xx_mdio_write(dev->net, mii->phy_id, PHY_INT_SRC,
 649                 PHY_INT_SRC_CLEAR_ALL);
 650
 651         ret = smsc75xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL);
 652         if (ret < 0) {
 653                 netdev_warn(dev->net, "Error writing INT_STS\n");
 654                 return ret;
 655         }
 656
 657         mii_check_media(mii, 1, 1);
 658         mii_ethtool_gset(&dev->mii, &ecmd);
 659         lcladv = smsc75xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE);
 660         rmtadv = smsc75xx_mdio_read(dev->net, mii->phy_id, MII_LPA);
 661
 662         netif_dbg(dev, link, dev->net, "speed: %u duplex: %d lcladv: %04x rmtadv: %04x\n",
 663                   ethtool_cmd_speed(&ecmd), ecmd.duplex, lcladv, rmtadv);
 664
 665         return smsc75xx_update_flowcontrol(dev, ecmd.duplex, lcladv, rmtadv);
 666 }
 667
 668 static void smsc75xx_status(struct usbnet *dev, struct urb *urb)
 669 {
 670         u32 intdata;
 671
 672         if (urb->actual_length != 4) {
 673                 netdev_warn(dev->net, "unexpected urb length %d\n",
 674                             urb->actual_length);
 675                 return;
 676         }
 677
 678         memcpy(&intdata, urb->transfer_buffer, 4);
 679         le32_to_cpus(&intdata);
 680
 681         netif_dbg(dev, link, dev->net, "intdata: 0x%08X\n", intdata);
 682
 683         if (intdata & INT_ENP_PHY_INT)
 684                 usbnet_defer_kevent(dev, EVENT_LINK_RESET);
 685         else
 686                 netdev_warn(dev->net, "unexpected interrupt, intdata=0x%08X\n",
 687                             intdata);
 688 }
 689
 690 static int smsc75xx_ethtool_get_eeprom_len(struct net_device *net)
 691 {
 692         return MAX_EEPROM_SIZE;
 693 }
 694
 695 static int smsc75xx_ethtool_get_eeprom(struct net_device *netdev,
 696                                        struct ethtool_eeprom *ee, u8 *data)
 697 {
 698         struct usbnet *dev = netdev_priv(netdev);
 699
 700         ee->magic = LAN75XX_EEPROM_MAGIC;
 701
 702         return smsc75xx_read_eeprom(dev, ee->offset, ee->len, data);
 703 }
 704
 705 static int smsc75xx_ethtool_set_eeprom(struct net_device *netdev,
 706                                        struct ethtool_eeprom *ee, u8 *data)
 707 {
 708         struct usbnet *dev = netdev_priv(netdev);
 709
 710         if (ee->magic != LAN75XX_EEPROM_MAGIC) {
 711                 netdev_warn(dev->net, "EEPROM: magic value mismatch: 0x%x\n",
 712                             ee->magic);
 713                 return -EINVAL;
 714         }
 715
 716         return smsc75xx_write_eeprom(dev, ee->offset, ee->len, data);
 717 }
 718
 719 static void smsc75xx_ethtool_get_wol(struct net_device *net,
 720                                      struct ethtool_wolinfo *wolinfo)
 721 {
 722         struct usbnet *dev = netdev_priv(net);
 723         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
 724
 725         wolinfo->supported = SUPPORTED_WAKE;
 726         wolinfo->wolopts = pdata->wolopts;
 727 }
 728
 729 static int smsc75xx_ethtool_set_wol(struct net_device *net,
 730                                     struct ethtool_wolinfo *wolinfo)
 731 {
 732         struct usbnet *dev = netdev_priv(net);
 733         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
 734         int ret;
 735
 736         if (wolinfo->wolopts & ~SUPPORTED_WAKE)
 737                 return -EINVAL;
 738
 739         pdata->wolopts = wolinfo->wolopts & SUPPORTED_WAKE;
 740
 741         ret = device_set_wakeup_enable(&dev->udev->dev, pdata->wolopts);
 742         if (ret < 0)
 743                 netdev_warn(dev->net, "device_set_wakeup_enable error %d\n", ret);
 744
 745         return ret;
 746 }
 747
 748 static const struct ethtool_ops smsc75xx_ethtool_ops = {
 749         .get_link       = usbnet_get_link,
 750         .nway_reset     = usbnet_nway_reset,
 751         .get_drvinfo    = usbnet_get_drvinfo,
 752         .get_msglevel   = usbnet_get_msglevel,
 753         .set_msglevel   = usbnet_set_msglevel,
 754         .get_eeprom_len = smsc75xx_ethtool_get_eeprom_len,
 755         .get_eeprom     = smsc75xx_ethtool_get_eeprom,
 756         .set_eeprom     = smsc75xx_ethtool_set_eeprom,
 757         .get_wol        = smsc75xx_ethtool_get_wol,
 758         .set_wol        = smsc75xx_ethtool_set_wol,
 759         .get_link_ksettings     = usbnet_get_link_ksettings,
 760         .set_link_ksettings     = usbnet_set_link_ksettings,
 761 };
 762
 763 static int smsc75xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
 764 {
 765         struct usbnet *dev = netdev_priv(netdev);
 766
 767         if (!netif_running(netdev))
 768                 return -EINVAL;
 769
 770         return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
 771 }
 772
 773 static void smsc75xx_init_mac_address(struct usbnet *dev)
 774 {
 775         const u8 *mac_addr;
 776
 777         /* maybe the boot loader passed the MAC address in devicetree */
 778         mac_addr = of_get_mac_address(dev->udev->dev.of_node);
 779         if (mac_addr) {
 780                 memcpy(dev->net->dev_addr, mac_addr, ETH_ALEN);
 781                 return;
 782         }
 783
 784         /* try reading mac address from EEPROM */
 785         if (smsc75xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
 786                         dev->net->dev_addr) == 0) {
 787                 if (is_valid_ether_addr(dev->net->dev_addr)) {
 788                         /* eeprom values are valid so use them */
 789                         netif_dbg(dev, ifup, dev->net,
 790                                   "MAC address read from EEPROM\n");
 791                         return;
 792                 }
 793         }
 794
 795         /* no useful static MAC address found. generate a random one */
 796         eth_hw_addr_random(dev->net);
 797         netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
 798 }
 799
 800 static int smsc75xx_set_mac_address(struct usbnet *dev)
 801 {
 802         u32 addr_lo = dev->net->dev_addr[0] | dev->net->dev_addr[1] << 8 |
 803                 dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3] << 24;
 804         u32 addr_hi = dev->net->dev_addr[4] | dev->net->dev_addr[5] << 8;
 805
 806         int ret = smsc75xx_write_reg(dev, RX_ADDRH, addr_hi);
 807         if (ret < 0) {
 808                 netdev_warn(dev->net, "Failed to write RX_ADDRH: %d\n", ret);
 809                 return ret;
 810         }
 811
 812         ret = smsc75xx_write_reg(dev, RX_ADDRL, addr_lo);
 813         if (ret < 0) {
 814                 netdev_warn(dev->net, "Failed to write RX_ADDRL: %d\n", ret);
 815                 return ret;
 816         }
 817
 818         addr_hi |= ADDR_FILTX_FB_VALID;
 819         ret = smsc75xx_write_reg(dev, ADDR_FILTX, addr_hi);
 820         if (ret < 0) {
 821                 netdev_warn(dev->net, "Failed to write ADDR_FILTX: %d\n", ret);
 822                 return ret;
 823         }
 824
 825         ret = smsc75xx_write_reg(dev, ADDR_FILTX + 4, addr_lo);
 826         if (ret < 0)
 827                 netdev_warn(dev->net, "Failed to write ADDR_FILTX+4: %d\n", ret);
 828
 829         return ret;
 830 }
 831
 832 static int smsc75xx_phy_initialize(struct usbnet *dev)
 833 {
 834         int bmcr, ret, timeout = 0;
 835
 836         /* Initialize MII structure */
 837         dev->mii.dev = dev->net;
 838         dev->mii.mdio_read = smsc75xx_mdio_read;
 839         dev->mii.mdio_write = smsc75xx_mdio_write;
 840         dev->mii.phy_id_mask = 0x1f;
 841         dev->mii.reg_num_mask = 0x1f;
 842         dev->mii.supports_gmii = 1;
 843         dev->mii.phy_id = SMSC75XX_INTERNAL_PHY_ID;
 844
 845         /* reset phy and wait for reset to complete */
 846         smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
 847
 848         do {
 849                 msleep(10);
 850                 bmcr = smsc75xx_mdio_read(dev->net, dev->mii.phy_id, MII_BMCR);
 851                 if (bmcr < 0) {
 852                         netdev_warn(dev->net, "Error reading MII_BMCR\n");
 853                         return bmcr;
 854                 }
 855                 timeout++;
 856         } while ((bmcr & BMCR_RESET) && (timeout < 100));
 857
 858         if (timeout >= 100) {
 859                 netdev_warn(dev->net, "timeout on PHY Reset\n");
 860                 return -EIO;
 861         }
 862
 863         /* phy workaround for gig link */
 864         smsc75xx_phy_gig_workaround(dev);
 865
 866         smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
 867                 ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP |
 868                 ADVERTISE_PAUSE_ASYM);
 869         smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_CTRL1000,
 870                 ADVERTISE_1000FULL);
 871
 872         /* read and write to clear phy interrupt status */
 873         ret = smsc75xx_mdio_read(dev->net, dev->mii.phy_id, PHY_INT_SRC);
 874         if (ret < 0) {
 875                 netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
 876                 return ret;
 877         }
 878
 879         smsc75xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_SRC, 0xffff);
 880
 881         smsc75xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_MASK,
 882                 PHY_INT_MASK_DEFAULT);
 883         mii_nway_restart(&dev->mii);
 884
 885         netif_dbg(dev, ifup, dev->net, "phy initialised successfully\n");
 886         return 0;
 887 }
 888
 889 static int smsc75xx_set_rx_max_frame_length(struct usbnet *dev, int size)
 890 {
 891         int ret = 0;
 892         u32 buf;
 893         bool rxenabled;
 894
 895         ret = smsc75xx_read_reg(dev, MAC_RX, &buf);
 896         if (ret < 0) {
 897                 netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
 898                 return ret;
 899         }
 900
 901         rxenabled = ((buf & MAC_RX_RXEN) != 0);
 902
 903         if (rxenabled) {
 904                 buf &= ~MAC_RX_RXEN;
 905                 ret = smsc75xx_write_reg(dev, MAC_RX, buf);
 906                 if (ret < 0) {
 907                         netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
 908                         return ret;
 909                 }
 910         }
 911
 912         /* add 4 to size for FCS */
 913         buf &= ~MAC_RX_MAX_SIZE;
 914         buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT) & MAC_RX_MAX_SIZE);
 915
 916         ret = smsc75xx_write_reg(dev, MAC_RX, buf);
 917         if (ret < 0) {
 918                 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
 919                 return ret;
 920         }
 921
 922         if (rxenabled) {
 923                 buf |= MAC_RX_RXEN;
 924                 ret = smsc75xx_write_reg(dev, MAC_RX, buf);
 925                 if (ret < 0) {
 926                         netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
 927                         return ret;
 928                 }
 929         }
 930
 931         return 0;
 932 }
 933
 934 static int smsc75xx_change_mtu(struct net_device *netdev, int new_mtu)
 935 {
 936         struct usbnet *dev = netdev_priv(netdev);
 937         int ret;
 938
 939         ret = smsc75xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
 940         if (ret < 0) {
 941                 netdev_warn(dev->net, "Failed to set mac rx frame length\n");
 942                 return ret;
 943         }
 944
 945         return usbnet_change_mtu(netdev, new_mtu);
 946 }
 947
 948 /* Enable or disable Rx checksum offload engine */
 949 static int smsc75xx_set_features(struct net_device *netdev,
 950         netdev_features_t features)
 951 {
 952         struct usbnet *dev = netdev_priv(netdev);
 953         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
 954         unsigned long flags;
 955         int ret;
 956
 957         spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
 958
 959         if (features & NETIF_F_RXCSUM)
 960                 pdata->rfe_ctl |= RFE_CTL_TCPUDP_CKM | RFE_CTL_IP_CKM;
 961         else
 962                 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_CKM | RFE_CTL_IP_CKM);
 963
 964         spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
 965         /* it's racing here! */
 966
 967         ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
 968         if (ret < 0) {
 969                 netdev_warn(dev->net, "Error writing RFE_CTL\n");
 970                 return ret;
 971         }
 972         return 0;
 973 }
 974
 975 static int smsc75xx_wait_ready(struct usbnet *dev, int in_pm)
 976 {
 977         int timeout = 0;
 978
 979         do {
 980                 u32 buf;
 981                 int ret;
 982
 983                 ret = __smsc75xx_read_reg(dev, PMT_CTL, &buf, in_pm);
 984
 985                 if (ret < 0) {
 986                         netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
 987                         return ret;
 988                 }
 989
 990                 if (buf & PMT_CTL_DEV_RDY)
 991                         return 0;
 992
 993                 msleep(10);
 994                 timeout++;
 995         } while (timeout < 100);
 996
 997         netdev_warn(dev->net, "timeout waiting for device ready\n");
 998         return -EIO;
 999 }
1000
1001 static int smsc75xx_phy_gig_workaround(struct usbnet *dev)
1002 {
1003         struct mii_if_info *mii = &dev->mii;
1004         int ret = 0, timeout = 0;
1005         u32 buf, link_up = 0;
1006
1007         /* Set the phy in Gig loopback */
1008         smsc75xx_mdio_write(dev->net, mii->phy_id, MII_BMCR, 0x4040);
1009
1010         /* Wait for the link up */
1011         do {
1012                 link_up = smsc75xx_link_ok_nopm(dev);
1013                 usleep_range(10000, 20000);
1014                 timeout++;
1015         } while ((!link_up) && (timeout < 1000));
1016
1017         if (timeout >= 1000) {
1018                 netdev_warn(dev->net, "Timeout waiting for PHY link up\n");
1019                 return -EIO;
1020         }
1021
1022         /* phy reset */
1023         ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1024         if (ret < 0) {
1025                 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
1026                 return ret;
1027         }
1028
1029         buf |= PMT_CTL_PHY_RST;
1030
1031         ret = smsc75xx_write_reg(dev, PMT_CTL, buf);
1032         if (ret < 0) {
1033                 netdev_warn(dev->net, "Failed to write PMT_CTL: %d\n", ret);
1034                 return ret;
1035         }
1036
1037         timeout = 0;
1038         do {
1039                 usleep_range(10000, 20000);
1040                 ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1041                 if (ret < 0) {
1042                         netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n",
1043                                     ret);
1044                         return ret;
1045                 }
1046                 timeout++;
1047         } while ((buf & PMT_CTL_PHY_RST) && (timeout < 100));
1048
1049         if (timeout >= 100) {
1050                 netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
1051                 return -EIO;
1052         }
1053
1054         return 0;
1055 }
1056
1057 static int smsc75xx_reset(struct usbnet *dev)
1058 {
1059         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1060         u32 buf;
1061         int ret = 0, timeout;
1062
1063         netif_dbg(dev, ifup, dev->net, "entering smsc75xx_reset\n");
1064
1065         ret = smsc75xx_wait_ready(dev, 0);
1066         if (ret < 0) {
1067                 netdev_warn(dev->net, "device not ready in smsc75xx_reset\n");
1068                 return ret;
1069         }
1070
1071         ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1072         if (ret < 0) {
1073                 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1074                 return ret;
1075         }
1076
1077         buf |= HW_CFG_LRST;
1078
1079         ret = smsc75xx_write_reg(dev, HW_CFG, buf);
1080         if (ret < 0) {
1081                 netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
1082                 return ret;
1083         }
1084
1085         timeout = 0;
1086         do {
1087                 msleep(10);
1088                 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1089                 if (ret < 0) {
1090                         netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1091                         return ret;
1092                 }
1093                 timeout++;
1094         } while ((buf & HW_CFG_LRST) && (timeout < 100));
1095
1096         if (timeout >= 100) {
1097                 netdev_warn(dev->net, "timeout on completion of Lite Reset\n");
1098                 return -EIO;
1099         }
1100
1101         netif_dbg(dev, ifup, dev->net, "Lite reset complete, resetting PHY\n");
1102
1103         ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1104         if (ret < 0) {
1105                 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
1106                 return ret;
1107         }
1108
1109         buf |= PMT_CTL_PHY_RST;
1110
1111         ret = smsc75xx_write_reg(dev, PMT_CTL, buf);
1112         if (ret < 0) {
1113                 netdev_warn(dev->net, "Failed to write PMT_CTL: %d\n", ret);
1114                 return ret;
1115         }
1116
1117         timeout = 0;
1118         do {
1119                 msleep(10);
1120                 ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1121                 if (ret < 0) {
1122                         netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
1123                         return ret;
1124                 }
1125                 timeout++;
1126         } while ((buf & PMT_CTL_PHY_RST) && (timeout < 100));
1127
1128         if (timeout >= 100) {
1129                 netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
1130                 return -EIO;
1131         }
1132
1133         netif_dbg(dev, ifup, dev->net, "PHY reset complete\n");
1134
1135         ret = smsc75xx_set_mac_address(dev);
1136         if (ret < 0) {
1137                 netdev_warn(dev->net, "Failed to set mac address\n");
1138                 return ret;
1139         }
1140
1141         netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n",
1142                   dev->net->dev_addr);
1143
1144         ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1145         if (ret < 0) {
1146                 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1147                 return ret;
1148         }
1149
1150         netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n",
1151                   buf);
1152
1153         buf |= HW_CFG_BIR;
1154
1155         ret = smsc75xx_write_reg(dev, HW_CFG, buf);
1156         if (ret < 0) {
1157                 netdev_warn(dev->net,  "Failed to write HW_CFG: %d\n", ret);
1158                 return ret;
1159         }
1160
1161         ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1162         if (ret < 0) {
1163                 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1164                 return ret;
1165         }
1166
1167         netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG after writing HW_CFG_BIR: 0x%08x\n",
1168                   buf);
1169
1170         if (!turbo_mode) {
1171                 buf = 0;
1172                 dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;
1173         } else if (dev->udev->speed == USB_SPEED_HIGH) {
1174                 buf = DEFAULT_HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
1175                 dev->rx_urb_size = DEFAULT_HS_BURST_CAP_SIZE;
1176         } else {
1177                 buf = DEFAULT_FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
1178                 dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
1179         }
1180
1181         netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
1182                   (ulong)dev->rx_urb_size);
1183
1184         ret = smsc75xx_write_reg(dev, BURST_CAP, buf);
1185         if (ret < 0) {
1186                 netdev_warn(dev->net, "Failed to write BURST_CAP: %d\n", ret);
1187                 return ret;
1188         }
1189
1190         ret = smsc75xx_read_reg(dev, BURST_CAP, &buf);
1191         if (ret < 0) {
1192                 netdev_warn(dev->net, "Failed to read BURST_CAP: %d\n", ret);
1193                 return ret;
1194         }
1195
1196         netif_dbg(dev, ifup, dev->net,
1197                   "Read Value from BURST_CAP after writing: 0x%08x\n", buf);
1198
1199         ret = smsc75xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
1200         if (ret < 0) {
1201                 netdev_warn(dev->net, "Failed to write BULK_IN_DLY: %d\n", ret);
1202                 return ret;
1203         }
1204
1205         ret = smsc75xx_read_reg(dev, BULK_IN_DLY, &buf);
1206         if (ret < 0) {
1207                 netdev_warn(dev->net, "Failed to read BULK_IN_DLY: %d\n", ret);
1208                 return ret;
1209         }
1210
1211         netif_dbg(dev, ifup, dev->net,
1212                   "Read Value from BULK_IN_DLY after writing: 0x%08x\n", buf);
1213
1214         if (turbo_mode) {
1215                 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1216                 if (ret < 0) {
1217                         netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1218                         return ret;
1219                 }
1220
1221                 netif_dbg(dev, ifup, dev->net, "HW_CFG: 0x%08x\n", buf);
1222
1223                 buf |= (HW_CFG_MEF | HW_CFG_BCE);
1224
1225                 ret = smsc75xx_write_reg(dev, HW_CFG, buf);
1226                 if (ret < 0) {
1227                         netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
1228                         return ret;
1229                 }
1230
1231                 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1232                 if (ret < 0) {
1233                         netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1234                         return ret;
1235                 }
1236
1237                 netif_dbg(dev, ifup, dev->net, "HW_CFG: 0x%08x\n", buf);
1238         }
1239
1240         /* set FIFO sizes */
1241         buf = (MAX_RX_FIFO_SIZE - 512) / 512;
1242         ret = smsc75xx_write_reg(dev, FCT_RX_FIFO_END, buf);
1243         if (ret < 0) {
1244                 netdev_warn(dev->net, "Failed to write FCT_RX_FIFO_END: %d\n", ret);
1245                 return ret;
1246         }
1247
1248         netif_dbg(dev, ifup, dev->net, "FCT_RX_FIFO_END set to 0x%08x\n", buf);
1249
1250         buf = (MAX_TX_FIFO_SIZE - 512) / 512;
1251         ret = smsc75xx_write_reg(dev, FCT_TX_FIFO_END, buf);
1252         if (ret < 0) {
1253                 netdev_warn(dev->net, "Failed to write FCT_TX_FIFO_END: %d\n", ret);
1254                 return ret;
1255         }
1256
1257         netif_dbg(dev, ifup, dev->net, "FCT_TX_FIFO_END set to 0x%08x\n", buf);
1258
1259         ret = smsc75xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL);
1260         if (ret < 0) {
1261                 netdev_warn(dev->net, "Failed to write INT_STS: %d\n", ret);
1262                 return ret;
1263         }
1264
1265         ret = smsc75xx_read_reg(dev, ID_REV, &buf);
1266         if (ret < 0) {
1267                 netdev_warn(dev->net, "Failed to read ID_REV: %d\n", ret);
1268                 return ret;
1269         }
1270
1271         netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", buf);
1272
1273         ret = smsc75xx_read_reg(dev, E2P_CMD, &buf);
1274         if (ret < 0) {
1275                 netdev_warn(dev->net, "Failed to read E2P_CMD: %d\n", ret);
1276                 return ret;
1277         }
1278
1279         /* only set default GPIO/LED settings if no EEPROM is detected */
1280         if (!(buf & E2P_CMD_LOADED)) {
1281                 ret = smsc75xx_read_reg(dev, LED_GPIO_CFG, &buf);
1282                 if (ret < 0) {
1283                         netdev_warn(dev->net, "Failed to read LED_GPIO_CFG: %d\n", ret);
1284                         return ret;
1285                 }
1286
1287                 buf &= ~(LED_GPIO_CFG_LED2_FUN_SEL | LED_GPIO_CFG_LED10_FUN_SEL);
1288                 buf |= LED_GPIO_CFG_LEDGPIO_EN | LED_GPIO_CFG_LED2_FUN_SEL;
1289
1290                 ret = smsc75xx_write_reg(dev, LED_GPIO_CFG, buf);
1291                 if (ret < 0) {
1292                         netdev_warn(dev->net, "Failed to write LED_GPIO_CFG: %d\n", ret);
1293                         return ret;
1294                 }
1295         }
1296
1297         ret = smsc75xx_write_reg(dev, FLOW, 0);
1298         if (ret < 0) {
1299                 netdev_warn(dev->net, "Failed to write FLOW: %d\n", ret);
1300                 return ret;
1301         }
1302
1303         ret = smsc75xx_write_reg(dev, FCT_FLOW, 0);
1304         if (ret < 0) {
1305                 netdev_warn(dev->net, "Failed to write FCT_FLOW: %d\n", ret);
1306                 return ret;
1307         }
1308
1309         /* Don't need rfe_ctl_lock during initialisation */
1310         ret = smsc75xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
1311         if (ret < 0) {
1312                 netdev_warn(dev->net, "Failed to read RFE_CTL: %d\n", ret);
1313                 return ret;
1314         }
1315
1316         pdata->rfe_ctl |= RFE_CTL_AB | RFE_CTL_DPF;
1317
1318         ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1319         if (ret < 0) {
1320                 netdev_warn(dev->net, "Failed to write RFE_CTL: %d\n", ret);
1321                 return ret;
1322         }
1323
1324         ret = smsc75xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
1325         if (ret < 0) {
1326                 netdev_warn(dev->net, "Failed to read RFE_CTL: %d\n", ret);
1327                 return ret;
1328         }
1329
1330         netif_dbg(dev, ifup, dev->net, "RFE_CTL set to 0x%08x\n",
1331                   pdata->rfe_ctl);
1332
1333         /* Enable or disable checksum offload engines */
1334         smsc75xx_set_features(dev->net, dev->net->features);
1335
1336         smsc75xx_set_multicast(dev->net);
1337
1338         ret = smsc75xx_phy_initialize(dev);
1339         if (ret < 0) {
1340                 netdev_warn(dev->net, "Failed to initialize PHY: %d\n", ret);
1341                 return ret;
1342         }
1343
1344         ret = smsc75xx_read_reg(dev, INT_EP_CTL, &buf);
1345         if (ret < 0) {
1346                 netdev_warn(dev->net, "Failed to read INT_EP_CTL: %d\n", ret);
1347                 return ret;
1348         }
1349
1350         /* enable PHY interrupts */
1351         buf |= INT_ENP_PHY_INT;
1352
1353         ret = smsc75xx_write_reg(dev, INT_EP_CTL, buf);
1354         if (ret < 0) {
1355                 netdev_warn(dev->net, "Failed to write INT_EP_CTL: %d\n", ret);
1356                 return ret;
1357         }
1358
1359         /* allow mac to detect speed and duplex from phy */
1360         ret = smsc75xx_read_reg(dev, MAC_CR, &buf);
1361         if (ret < 0) {
1362                 netdev_warn(dev->net, "Failed to read MAC_CR: %d\n", ret);
1363                 return ret;
1364         }
1365
1366         buf |= (MAC_CR_ADD | MAC_CR_ASD);
1367         ret = smsc75xx_write_reg(dev, MAC_CR, buf);
1368         if (ret < 0) {
1369                 netdev_warn(dev->net, "Failed to write MAC_CR: %d\n", ret);
1370                 return ret;
1371         }
1372
1373         ret = smsc75xx_read_reg(dev, MAC_TX, &buf);
1374         if (ret < 0) {
1375                 netdev_warn(dev->net, "Failed to read MAC_TX: %d\n", ret);
1376                 return ret;
1377         }
1378
1379         buf |= MAC_TX_TXEN;
1380
1381         ret = smsc75xx_write_reg(dev, MAC_TX, buf);
1382         if (ret < 0) {
1383                 netdev_warn(dev->net, "Failed to write MAC_TX: %d\n", ret);
1384                 return ret;
1385         }
1386
1387         netif_dbg(dev, ifup, dev->net, "MAC_TX set to 0x%08x\n", buf);
1388
1389         ret = smsc75xx_read_reg(dev, FCT_TX_CTL, &buf);
1390         if (ret < 0) {
1391                 netdev_warn(dev->net, "Failed to read FCT_TX_CTL: %d\n", ret);
1392                 return ret;
1393         }
1394
1395         buf |= FCT_TX_CTL_EN;
1396
1397         ret = smsc75xx_write_reg(dev, FCT_TX_CTL, buf);
1398         if (ret < 0) {
1399                 netdev_warn(dev->net, "Failed to write FCT_TX_CTL: %d\n", ret);
1400                 return ret;
1401         }
1402
1403         netif_dbg(dev, ifup, dev->net, "FCT_TX_CTL set to 0x%08x\n", buf);
1404
1405         ret = smsc75xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
1406         if (ret < 0) {
1407                 netdev_warn(dev->net, "Failed to set max rx frame length\n");
1408                 return ret;
1409         }
1410
1411         ret = smsc75xx_read_reg(dev, MAC_RX, &buf);
1412         if (ret < 0) {
1413                 netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
1414                 return ret;
1415         }
1416
1417         buf |= MAC_RX_RXEN;
1418
1419         ret = smsc75xx_write_reg(dev, MAC_RX, buf);
1420         if (ret < 0) {
1421                 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
1422                 return ret;
1423         }
1424
1425         netif_dbg(dev, ifup, dev->net, "MAC_RX set to 0x%08x\n", buf);
1426
1427         ret = smsc75xx_read_reg(dev, FCT_RX_CTL, &buf);
1428         if (ret < 0) {
1429                 netdev_warn(dev->net, "Failed to read FCT_RX_CTL: %d\n", ret);
1430                 return ret;
1431         }
1432
1433         buf |= FCT_RX_CTL_EN;
1434
1435         ret = smsc75xx_write_reg(dev, FCT_RX_CTL, buf);
1436         if (ret < 0) {
1437                 netdev_warn(dev->net, "Failed to write FCT_RX_CTL: %d\n", ret);
1438                 return ret;
1439         }
1440
1441         netif_dbg(dev, ifup, dev->net, "FCT_RX_CTL set to 0x%08x\n", buf);
1442
1443         netif_dbg(dev, ifup, dev->net, "smsc75xx_reset, return 0\n");
1444         return 0;
1445 }
1446
1447 static const struct net_device_ops smsc75xx_netdev_ops = {
1448         .ndo_open               = usbnet_open,
1449         .ndo_stop               = usbnet_stop,
1450         .ndo_start_xmit         = usbnet_start_xmit,
1451         .ndo_tx_timeout         = usbnet_tx_timeout,
1452         .ndo_get_stats64        = usbnet_get_stats64,
1453         .ndo_change_mtu         = smsc75xx_change_mtu,
1454         .ndo_set_mac_address    = eth_mac_addr,
1455         .ndo_validate_addr      = eth_validate_addr,
1456         .ndo_do_ioctl           = smsc75xx_ioctl,
1457         .ndo_set_rx_mode        = smsc75xx_set_multicast,
1458         .ndo_set_features       = smsc75xx_set_features,
1459 };
1460
1461 static int smsc75xx_bind(struct usbnet *dev, struct usb_interface *intf)
1462 {
1463         struct smsc75xx_priv *pdata = NULL;
1464         int ret;
1465
1466         printk(KERN_INFO SMSC_CHIPNAME " v" SMSC_DRIVER_VERSION "\n");
1467
1468         ret = usbnet_get_endpoints(dev, intf);
1469         if (ret < 0) {
1470                 netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret);
1471                 return ret;
1472         }
1473
1474         dev->data[0] = (unsigned long)kzalloc(sizeof(struct smsc75xx_priv),
1475                                               GFP_KERNEL);
1476
1477         pdata = (struct smsc75xx_priv *)(dev->data[0]);
1478         if (!pdata)
1479                 return -ENOMEM;
1480
1481         pdata->dev = dev;
1482
1483         spin_lock_init(&pdata->rfe_ctl_lock);
1484         mutex_init(&pdata->dataport_mutex);
1485
1486         INIT_WORK(&pdata->set_multicast, smsc75xx_deferred_multicast_write);
1487
1488         if (DEFAULT_TX_CSUM_ENABLE)
1489                 dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
1490
1491         if (DEFAULT_RX_CSUM_ENABLE)
1492                 dev->net->features |= NETIF_F_RXCSUM;
1493
1494         dev->net->hw_features = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
1495                                 NETIF_F_RXCSUM;
1496
1497         ret = smsc75xx_wait_ready(dev, 0);
1498         if (ret < 0) {
1499                 netdev_warn(dev->net, "device not ready in smsc75xx_bind\n");
1500                 goto free_pdata;
1501         }
1502
1503         smsc75xx_init_mac_address(dev);
1504
1505         /* Init all registers */
1506         ret = smsc75xx_reset(dev);
1507         if (ret < 0) {
1508                 netdev_warn(dev->net, "smsc75xx_reset error %d\n", ret);
1509                 goto cancel_work;
1510         }
1511
1512         dev->net->netdev_ops = &smsc75xx_netdev_ops;
1513         dev->net->ethtool_ops = &smsc75xx_ethtool_ops;
1514         dev->net->flags |= IFF_MULTICAST;
1515         dev->net->hard_header_len += SMSC75XX_TX_OVERHEAD;
1516         dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
1517         dev->net->max_mtu = MAX_SINGLE_PACKET_SIZE;
1518         return 0;
1519
1520 cancel_work:
1521         cancel_work_sync(&pdata->set_multicast);
1522 free_pdata:
1523         kfree(pdata);
1524         dev->data[0] = 0;
1525         return ret;
1526 }
1527
1528 static void smsc75xx_unbind(struct usbnet *dev, struct usb_interface *intf)
1529 {
1530         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1531         if (pdata) {
1532                 cancel_work_sync(&pdata->set_multicast);
1533                 netif_dbg(dev, ifdown, dev->net, "free pdata\n");
1534                 kfree(pdata);
1535                 dev->data[0] = 0;
1536         }
1537 }
1538
1539 static u16 smsc_crc(const u8 *buffer, size_t len)
1540 {
1541         return bitrev16(crc16(0xFFFF, buffer, len));
1542 }
1543
1544 static int smsc75xx_write_wuff(struct usbnet *dev, int filter, u32 wuf_cfg,
1545                                u32 wuf_mask1)
1546 {
1547         int cfg_base = WUF_CFGX + filter * 4;
1548         int mask_base = WUF_MASKX + filter * 16;
1549         int ret;
1550
1551         ret = smsc75xx_write_reg(dev, cfg_base, wuf_cfg);
1552         if (ret < 0) {
1553                 netdev_warn(dev->net, "Error writing WUF_CFGX\n");
1554                 return ret;
1555         }
1556
1557         ret = smsc75xx_write_reg(dev, mask_base, wuf_mask1);
1558         if (ret < 0) {
1559                 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1560                 return ret;
1561         }
1562
1563         ret = smsc75xx_write_reg(dev, mask_base + 4, 0);
1564         if (ret < 0) {
1565                 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1566                 return ret;
1567         }
1568
1569         ret = smsc75xx_write_reg(dev, mask_base + 8, 0);
1570         if (ret < 0) {
1571                 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1572                 return ret;
1573         }
1574
1575         ret = smsc75xx_write_reg(dev, mask_base + 12, 0);
1576         if (ret < 0) {
1577                 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1578                 return ret;
1579         }
1580
1581         return 0;
1582 }
1583
1584 static int smsc75xx_enter_suspend0(struct usbnet *dev)
1585 {
1586         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1587         u32 val;
1588         int ret;
1589
1590         ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1591         if (ret < 0) {
1592                 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1593                 return ret;
1594         }
1595
1596         val &= (~(PMT_CTL_SUS_MODE | PMT_CTL_PHY_RST));
1597         val |= PMT_CTL_SUS_MODE_0 | PMT_CTL_WOL_EN | PMT_CTL_WUPS;
1598
1599         ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1600         if (ret < 0) {
1601                 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1602                 return ret;
1603         }
1604
1605         pdata->suspend_flags |= SUSPEND_SUSPEND0;
1606
1607         return 0;
1608 }
1609
1610 static int smsc75xx_enter_suspend1(struct usbnet *dev)
1611 {
1612         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1613         u32 val;
1614         int ret;
1615
1616         ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1617         if (ret < 0) {
1618                 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1619                 return ret;
1620         }
1621
1622         val &= ~(PMT_CTL_SUS_MODE | PMT_CTL_WUPS | PMT_CTL_PHY_RST);
1623         val |= PMT_CTL_SUS_MODE_1;
1624
1625         ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1626         if (ret < 0) {
1627                 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1628                 return ret;
1629         }
1630
1631         /* clear wol status, enable energy detection */
1632         val &= ~PMT_CTL_WUPS;
1633         val |= (PMT_CTL_WUPS_ED | PMT_CTL_ED_EN);
1634
1635         ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1636         if (ret < 0) {
1637                 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1638                 return ret;
1639         }
1640
1641         pdata->suspend_flags |= SUSPEND_SUSPEND1;
1642
1643         return 0;
1644 }
1645
1646 static int smsc75xx_enter_suspend2(struct usbnet *dev)
1647 {
1648         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1649         u32 val;
1650         int ret;
1651
1652         ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1653         if (ret < 0) {
1654                 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1655                 return ret;
1656         }
1657
1658         val &= ~(PMT_CTL_SUS_MODE | PMT_CTL_WUPS | PMT_CTL_PHY_RST);
1659         val |= PMT_CTL_SUS_MODE_2;
1660
1661         ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1662         if (ret < 0) {
1663                 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1664                 return ret;
1665         }
1666
1667         pdata->suspend_flags |= SUSPEND_SUSPEND2;
1668
1669         return 0;
1670 }
1671
1672 static int smsc75xx_enter_suspend3(struct usbnet *dev)
1673 {
1674         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1675         u32 val;
1676         int ret;
1677
1678         ret = smsc75xx_read_reg_nopm(dev, FCT_RX_CTL, &val);
1679         if (ret < 0) {
1680                 netdev_warn(dev->net, "Error reading FCT_RX_CTL\n");
1681                 return ret;
1682         }
1683
1684         if (val & FCT_RX_CTL_RXUSED) {
1685                 netdev_dbg(dev->net, "rx fifo not empty in autosuspend\n");
1686                 return -EBUSY;
1687         }
1688
1689         ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1690         if (ret < 0) {
1691                 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1692                 return ret;
1693         }
1694
1695         val &= ~(PMT_CTL_SUS_MODE | PMT_CTL_WUPS | PMT_CTL_PHY_RST);
1696         val |= PMT_CTL_SUS_MODE_3 | PMT_CTL_RES_CLR_WKP_EN;
1697
1698         ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1699         if (ret < 0) {
1700                 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1701                 return ret;
1702         }
1703
1704         /* clear wol status */
1705         val &= ~PMT_CTL_WUPS;
1706         val |= PMT_CTL_WUPS_WOL;
1707
1708         ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1709         if (ret < 0) {
1710                 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1711                 return ret;
1712         }
1713
1714         pdata->suspend_flags |= SUSPEND_SUSPEND3;
1715
1716         return 0;
1717 }
1718
1719 static int smsc75xx_enable_phy_wakeup_interrupts(struct usbnet *dev, u16 mask)
1720 {
1721         struct mii_if_info *mii = &dev->mii;
1722         int ret;
1723
1724         netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
1725
1726         /* read to clear */
1727         ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_SRC);
1728         if (ret < 0) {
1729                 netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
1730                 return ret;
1731         }
1732
1733         /* enable interrupt source */
1734         ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_MASK);
1735         if (ret < 0) {
1736                 netdev_warn(dev->net, "Error reading PHY_INT_MASK\n");
1737                 return ret;
1738         }
1739
1740         ret |= mask;
1741
1742         smsc75xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret);
1743
1744         return 0;
1745 }
1746
1747 static int smsc75xx_link_ok_nopm(struct usbnet *dev)
1748 {
1749         struct mii_if_info *mii = &dev->mii;
1750         int ret;
1751
1752         /* first, a dummy read, needed to latch some MII phys */
1753         ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1754         if (ret < 0) {
1755                 netdev_warn(dev->net, "Error reading MII_BMSR\n");
1756                 return ret;
1757         }
1758
1759         ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1760         if (ret < 0) {
1761                 netdev_warn(dev->net, "Error reading MII_BMSR\n");
1762                 return ret;
1763         }
1764
1765         return !!(ret & BMSR_LSTATUS);
1766 }
1767
1768 static int smsc75xx_autosuspend(struct usbnet *dev, u32 link_up)
1769 {
1770         int ret;
1771
1772         if (!netif_running(dev->net)) {
1773                 /* interface is ifconfig down so fully power down hw */
1774                 netdev_dbg(dev->net, "autosuspend entering SUSPEND2\n");
1775                 return smsc75xx_enter_suspend2(dev);
1776         }
1777
1778         if (!link_up) {
1779                 /* link is down so enter EDPD mode */
1780                 netdev_dbg(dev->net, "autosuspend entering SUSPEND1\n");
1781
1782                 /* enable PHY wakeup events for if cable is attached */
1783                 ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
1784                         PHY_INT_MASK_ANEG_COMP);
1785                 if (ret < 0) {
1786                         netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1787                         return ret;
1788                 }
1789
1790                 netdev_info(dev->net, "entering SUSPEND1 mode\n");
1791                 return smsc75xx_enter_suspend1(dev);
1792         }
1793
1794         /* enable PHY wakeup events so we remote wakeup if cable is pulled */
1795         ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
1796                 PHY_INT_MASK_LINK_DOWN);
1797         if (ret < 0) {
1798                 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1799                 return ret;
1800         }
1801
1802         netdev_dbg(dev->net, "autosuspend entering SUSPEND3\n");
1803         return smsc75xx_enter_suspend3(dev);
1804 }
1805
1806 static int smsc75xx_suspend(struct usb_interface *intf, pm_message_t message)
1807 {
1808         struct usbnet *dev = usb_get_intfdata(intf);
1809         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1810         u32 val, link_up;
1811         int ret;
1812
1813         ret = usbnet_suspend(intf, message);
1814         if (ret < 0) {
1815                 netdev_warn(dev->net, "usbnet_suspend error\n");
1816                 return ret;
1817         }
1818
1819         if (pdata->suspend_flags) {
1820                 netdev_warn(dev->net, "error during last resume\n");
1821                 pdata->suspend_flags = 0;
1822         }
1823
1824         /* determine if link is up using only _nopm functions */
1825         link_up = smsc75xx_link_ok_nopm(dev);
1826
1827         if (message.event == PM_EVENT_AUTO_SUSPEND) {
1828                 ret = smsc75xx_autosuspend(dev, link_up);
1829                 goto done;
1830         }
1831
1832         /* if we get this far we're not autosuspending */
1833         /* if no wol options set, or if link is down and we're not waking on
1834          * PHY activity, enter lowest power SUSPEND2 mode
1835          */
1836         if (!(pdata->wolopts & SUPPORTED_WAKE) ||
1837                 !(link_up || (pdata->wolopts & WAKE_PHY))) {
1838                 netdev_info(dev->net, "entering SUSPEND2 mode\n");
1839
1840                 /* disable energy detect (link up) & wake up events */
1841                 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1842                 if (ret < 0) {
1843                         netdev_warn(dev->net, "Error reading WUCSR\n");
1844                         goto done;
1845                 }
1846
1847                 val &= ~(WUCSR_MPEN | WUCSR_WUEN);
1848
1849                 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1850                 if (ret < 0) {
1851                         netdev_warn(dev->net, "Error writing WUCSR\n");
1852                         goto done;
1853                 }
1854
1855                 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1856                 if (ret < 0) {
1857                         netdev_warn(dev->net, "Error reading PMT_CTL\n");
1858                         goto done;
1859                 }
1860
1861                 val &= ~(PMT_CTL_ED_EN | PMT_CTL_WOL_EN);
1862
1863                 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1864                 if (ret < 0) {
1865                         netdev_warn(dev->net, "Error writing PMT_CTL\n");
1866                         goto done;
1867                 }
1868
1869                 ret = smsc75xx_enter_suspend2(dev);
1870                 goto done;
1871         }
1872
1873         if (pdata->wolopts & WAKE_PHY) {
1874                 ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
1875                         (PHY_INT_MASK_ANEG_COMP | PHY_INT_MASK_LINK_DOWN));
1876                 if (ret < 0) {
1877                         netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1878                         goto done;
1879                 }
1880
1881                 /* if link is down then configure EDPD and enter SUSPEND1,
1882                  * otherwise enter SUSPEND0 below
1883                  */
1884                 if (!link_up) {
1885                         struct mii_if_info *mii = &dev->mii;
1886                         netdev_info(dev->net, "entering SUSPEND1 mode\n");
1887
1888                         /* enable energy detect power-down mode */
1889                         ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id,
1890                                 PHY_MODE_CTRL_STS);
1891                         if (ret < 0) {
1892                                 netdev_warn(dev->net, "Error reading PHY_MODE_CTRL_STS\n");
1893                                 goto done;
1894                         }
1895
1896                         ret |= MODE_CTRL_STS_EDPWRDOWN;
1897
1898                         smsc75xx_mdio_write_nopm(dev->net, mii->phy_id,
1899                                 PHY_MODE_CTRL_STS, ret);
1900
1901                         /* enter SUSPEND1 mode */
1902                         ret = smsc75xx_enter_suspend1(dev);
1903                         goto done;
1904                 }
1905         }
1906
1907         if (pdata->wolopts & (WAKE_MCAST | WAKE_ARP)) {
1908                 int i, filter = 0;
1909
1910                 /* disable all filters */
1911                 for (i = 0; i < WUF_NUM; i++) {
1912                         ret = smsc75xx_write_reg_nopm(dev, WUF_CFGX + i * 4, 0);
1913                         if (ret < 0) {
1914                                 netdev_warn(dev->net, "Error writing WUF_CFGX\n");
1915                                 goto done;
1916                         }
1917                 }
1918
1919                 if (pdata->wolopts & WAKE_MCAST) {
1920                         const u8 mcast[] = {0x01, 0x00, 0x5E};
1921                         netdev_info(dev->net, "enabling multicast detection\n");
1922
1923                         val = WUF_CFGX_EN | WUF_CFGX_ATYPE_MULTICAST
1924                                 | smsc_crc(mcast, 3);
1925                         ret = smsc75xx_write_wuff(dev, filter++, val, 0x0007);
1926                         if (ret < 0) {
1927                                 netdev_warn(dev->net, "Error writing wakeup filter\n");
1928                                 goto done;
1929                         }
1930                 }
1931
1932                 if (pdata->wolopts & WAKE_ARP) {
1933                         const u8 arp[] = {0x08, 0x06};
1934                         netdev_info(dev->net, "enabling ARP detection\n");
1935
1936                         val = WUF_CFGX_EN | WUF_CFGX_ATYPE_ALL | (0x0C << 16)
1937                                 | smsc_crc(arp, 2);
1938                         ret = smsc75xx_write_wuff(dev, filter++, val, 0x0003);
1939                         if (ret < 0) {
1940                                 netdev_warn(dev->net, "Error writing wakeup filter\n");
1941                                 goto done;
1942                         }
1943                 }
1944
1945                 /* clear any pending pattern match packet status */
1946                 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1947                 if (ret < 0) {
1948                         netdev_warn(dev->net, "Error reading WUCSR\n");
1949                         goto done;
1950                 }
1951
1952                 val |= WUCSR_WUFR;
1953
1954                 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1955                 if (ret < 0) {
1956                         netdev_warn(dev->net, "Error writing WUCSR\n");
1957                         goto done;
1958                 }
1959
1960                 netdev_info(dev->net, "enabling packet match detection\n");
1961                 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1962                 if (ret < 0) {
1963                         netdev_warn(dev->net, "Error reading WUCSR\n");
1964                         goto done;
1965                 }
1966
1967                 val |= WUCSR_WUEN;
1968
1969                 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1970                 if (ret < 0) {
1971                         netdev_warn(dev->net, "Error writing WUCSR\n");
1972                         goto done;
1973                 }
1974         } else {
1975                 netdev_info(dev->net, "disabling packet match detection\n");
1976                 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1977                 if (ret < 0) {
1978                         netdev_warn(dev->net, "Error reading WUCSR\n");
1979                         goto done;
1980                 }
1981
1982                 val &= ~WUCSR_WUEN;
1983
1984                 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1985                 if (ret < 0) {
1986                         netdev_warn(dev->net, "Error writing WUCSR\n");
1987                         goto done;
1988                 }
1989         }
1990
1991         /* disable magic, bcast & unicast wakeup sources */
1992         ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1993         if (ret < 0) {
1994                 netdev_warn(dev->net, "Error reading WUCSR\n");
1995                 goto done;
1996         }
1997
1998         val &= ~(WUCSR_MPEN | WUCSR_BCST_EN | WUCSR_PFDA_EN);
1999
2000         ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2001         if (ret < 0) {
2002                 netdev_warn(dev->net, "Error writing WUCSR\n");
2003                 goto done;
2004         }
2005
2006         if (pdata->wolopts & WAKE_PHY) {
2007                 netdev_info(dev->net, "enabling PHY wakeup\n");
2008
2009                 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
2010                 if (ret < 0) {
2011                         netdev_warn(dev->net, "Error reading PMT_CTL\n");
2012                         goto done;
2013                 }
2014
2015                 /* clear wol status, enable energy detection */
2016                 val &= ~PMT_CTL_WUPS;
2017                 val |= (PMT_CTL_WUPS_ED | PMT_CTL_ED_EN);
2018
2019                 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
2020                 if (ret < 0) {
2021                         netdev_warn(dev->net, "Error writing PMT_CTL\n");
2022                         goto done;
2023                 }
2024         }
2025
2026         if (pdata->wolopts & WAKE_MAGIC) {
2027                 netdev_info(dev->net, "enabling magic packet wakeup\n");
2028                 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2029                 if (ret < 0) {
2030                         netdev_warn(dev->net, "Error reading WUCSR\n");
2031                         goto done;
2032                 }
2033
2034                 /* clear any pending magic packet status */
2035                 val |= WUCSR_MPR | WUCSR_MPEN;
2036
2037                 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2038                 if (ret < 0) {
2039                         netdev_warn(dev->net, "Error writing WUCSR\n");
2040                         goto done;
2041                 }
2042         }
2043
2044         if (pdata->wolopts & WAKE_BCAST) {
2045                 netdev_info(dev->net, "enabling broadcast detection\n");
2046                 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2047                 if (ret < 0) {
2048                         netdev_warn(dev->net, "Error reading WUCSR\n");
2049                         goto done;
2050                 }
2051
2052                 val |= WUCSR_BCAST_FR | WUCSR_BCST_EN;
2053
2054                 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2055                 if (ret < 0) {
2056                         netdev_warn(dev->net, "Error writing WUCSR\n");
2057                         goto done;
2058                 }
2059         }
2060
2061         if (pdata->wolopts & WAKE_UCAST) {
2062                 netdev_info(dev->net, "enabling unicast detection\n");
2063                 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2064                 if (ret < 0) {
2065                         netdev_warn(dev->net, "Error reading WUCSR\n");
2066                         goto done;
2067                 }
2068
2069                 val |= WUCSR_WUFR | WUCSR_PFDA_EN;
2070
2071                 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2072                 if (ret < 0) {
2073                         netdev_warn(dev->net, "Error writing WUCSR\n");
2074                         goto done;
2075                 }
2076         }
2077
2078         /* enable receiver to enable frame reception */
2079         ret = smsc75xx_read_reg_nopm(dev, MAC_RX, &val);
2080         if (ret < 0) {
2081                 netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
2082                 goto done;
2083         }
2084
2085         val |= MAC_RX_RXEN;
2086
2087         ret = smsc75xx_write_reg_nopm(dev, MAC_RX, val);
2088         if (ret < 0) {
2089                 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
2090                 goto done;
2091         }
2092
2093         /* some wol options are enabled, so enter SUSPEND0 */
2094         netdev_info(dev->net, "entering SUSPEND0 mode\n");
2095         ret = smsc75xx_enter_suspend0(dev);
2096
2097 done:
2098         /*
2099          * TODO: resume() might need to handle the suspend failure
2100          * in system sleep
2101          */
2102         if (ret && PMSG_IS_AUTO(message))
2103                 usbnet_resume(intf);
2104         return ret;
2105 }
2106
2107 static int smsc75xx_resume(struct usb_interface *intf)
2108 {
2109         struct usbnet *dev = usb_get_intfdata(intf);
2110         struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
2111         u8 suspend_flags = pdata->suspend_flags;
2112         int ret;
2113         u32 val;
2114
2115         netdev_dbg(dev->net, "resume suspend_flags=0x%02x\n", suspend_flags);
2116
2117         /* do this first to ensure it's cleared even in error case */
2118         pdata->suspend_flags = 0;
2119
2120         if (suspend_flags & SUSPEND_ALLMODES) {
2121                 /* Disable wakeup sources */
2122                 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2123                 if (ret < 0) {
2124                         netdev_warn(dev->net, "Error reading WUCSR\n");
2125                         return ret;
2126                 }
2127
2128                 val &= ~(WUCSR_WUEN | WUCSR_MPEN | WUCSR_PFDA_EN
2129                         | WUCSR_BCST_EN);
2130
2131                 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2132                 if (ret < 0) {
2133                         netdev_warn(dev->net, "Error writing WUCSR\n");
2134                         return ret;
2135                 }
2136
2137                 /* clear wake-up status */
2138                 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
2139                 if (ret < 0) {
2140                         netdev_warn(dev->net, "Error reading PMT_CTL\n");
2141                         return ret;
2142                 }
2143
2144                 val &= ~PMT_CTL_WOL_EN;
2145                 val |= PMT_CTL_WUPS;
2146
2147                 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
2148                 if (ret < 0) {
2149                         netdev_warn(dev->net, "Error writing PMT_CTL\n");
2150                         return ret;
2151                 }
2152         }
2153
2154         if (suspend_flags & SUSPEND_SUSPEND2) {
2155                 netdev_info(dev->net, "resuming from SUSPEND2\n");
2156
2157                 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
2158                 if (ret < 0) {
2159                         netdev_warn(dev->net, "Error reading PMT_CTL\n");
2160                         return ret;
2161                 }
2162
2163                 val |= PMT_CTL_PHY_PWRUP;
2164
2165                 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
2166                 if (ret < 0) {
2167                         netdev_warn(dev->net, "Error writing PMT_CTL\n");
2168                         return ret;
2169                 }
2170         }
2171
2172         ret = smsc75xx_wait_ready(dev, 1);
2173         if (ret < 0) {
2174                 netdev_warn(dev->net, "device not ready in smsc75xx_resume\n");
2175                 return ret;
2176         }
2177
2178         return usbnet_resume(intf);
2179 }
2180
2181 static void smsc75xx_rx_csum_offload(struct usbnet *dev, struct sk_buff *skb,
2182                                      u32 rx_cmd_a, u32 rx_cmd_b)
2183 {
2184         if (!(dev->net->features & NETIF_F_RXCSUM) ||
2185             unlikely(rx_cmd_a & RX_CMD_A_LCSM)) {
2186                 skb->ip_summed = CHECKSUM_NONE;
2187         } else {
2188                 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT));
2189                 skb->ip_summed = CHECKSUM_COMPLETE;
2190         }
2191 }
2192
2193 static int smsc75xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
2194 {
2195         /* This check is no longer done by usbnet */
2196         if (skb->len < dev->net->hard_header_len)
2197                 return 0;
2198
2199         while (skb->len > 0) {
2200                 u32 rx_cmd_a, rx_cmd_b, align_count, size;
2201                 struct sk_buff *ax_skb;
2202                 unsigned char *packet;
2203
2204                 memcpy(&rx_cmd_a, skb->data, sizeof(rx_cmd_a));
2205                 le32_to_cpus(&rx_cmd_a);
2206                 skb_pull(skb, 4);
2207
2208                 memcpy(&rx_cmd_b, skb->data, sizeof(rx_cmd_b));
2209                 le32_to_cpus(&rx_cmd_b);
2210                 skb_pull(skb, 4 + RXW_PADDING);
2211
2212                 packet = skb->data;
2213
2214                 /* get the packet length */
2215                 size = (rx_cmd_a & RX_CMD_A_LEN) - RXW_PADDING;
2216                 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
2217
2218                 if (unlikely(size > skb->len)) {
2219                         netif_dbg(dev, rx_err, dev->net,
2220                                   "size err rx_cmd_a=0x%08x\n",
2221                                   rx_cmd_a);
2222                         return 0;
2223                 }
2224
2225                 if (unlikely(rx_cmd_a & RX_CMD_A_RED)) {
2226                         netif_dbg(dev, rx_err, dev->net,
2227                                   "Error rx_cmd_a=0x%08x\n", rx_cmd_a);
2228                         dev->net->stats.rx_errors++;
2229                         dev->net->stats.rx_dropped++;
2230
2231                         if (rx_cmd_a & RX_CMD_A_FCS)
2232                                 dev->net->stats.rx_crc_errors++;
2233                         else if (rx_cmd_a & (RX_CMD_A_LONG | RX_CMD_A_RUNT))
2234                                 dev->net->stats.rx_frame_errors++;
2235                 } else {
2236                         /* MAX_SINGLE_PACKET_SIZE + 4(CRC) + 2(COE) + 4(Vlan) */
2237                         if (unlikely(size > (MAX_SINGLE_PACKET_SIZE + ETH_HLEN + 12))) {
2238                                 netif_dbg(dev, rx_err, dev->net,
2239                                           "size err rx_cmd_a=0x%08x\n",
2240                                           rx_cmd_a);
2241                                 return 0;
2242                         }
2243
2244                         /* last frame in this batch */
2245                         if (skb->len == size) {
2246                                 smsc75xx_rx_csum_offload(dev, skb, rx_cmd_a,
2247                                         rx_cmd_b);
2248
2249                                 skb_trim(skb, skb->len - 4); /* remove fcs */
2250                                 skb->truesize = size + sizeof(struct sk_buff);
2251
2252                                 return 1;
2253                         }
2254
2255                         ax_skb = skb_clone(skb, GFP_ATOMIC);
2256                         if (unlikely(!ax_skb)) {
2257                                 netdev_warn(dev->net, "Error allocating skb\n");
2258                                 return 0;
2259                         }
2260
2261                         ax_skb->len = size;
2262                         ax_skb->data = packet;
2263                         skb_set_tail_pointer(ax_skb, size);
2264
2265                         smsc75xx_rx_csum_offload(dev, ax_skb, rx_cmd_a,
2266                                 rx_cmd_b);
2267
2268                         skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */
2269                         ax_skb->truesize = size + sizeof(struct sk_buff);
2270
2271                         usbnet_skb_return(dev, ax_skb);
2272                 }
2273
2274                 skb_pull(skb, size);
2275
2276                 /* padding bytes before the next frame starts */
2277                 if (skb->len)
2278                         skb_pull(skb, align_count);
2279         }
2280
2281         return 1;
2282 }
2283
2284 static struct sk_buff *smsc75xx_tx_fixup(struct usbnet *dev,
2285                                          struct sk_buff *skb, gfp_t flags)
2286 {
2287         u32 tx_cmd_a, tx_cmd_b;
2288
2289         if (skb_cow_head(skb, SMSC75XX_TX_OVERHEAD)) {
2290                 dev_kfree_skb_any(skb);
2291                 return NULL;
2292         }
2293
2294         tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN) | TX_CMD_A_FCS;
2295
2296         if (skb->ip_summed == CHECKSUM_PARTIAL)
2297                 tx_cmd_a |= TX_CMD_A_IPE | TX_CMD_A_TPE;
2298
2299         if (skb_is_gso(skb)) {
2300                 u16 mss = max(skb_shinfo(skb)->gso_size, TX_MSS_MIN);
2301                 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT) & TX_CMD_B_MSS;
2302
2303                 tx_cmd_a |= TX_CMD_A_LSO;
2304         } else {
2305                 tx_cmd_b = 0;
2306         }
2307
2308         skb_push(skb, 4);
2309         cpu_to_le32s(&tx_cmd_b);
2310         memcpy(skb->data, &tx_cmd_b, 4);
2311
2312         skb_push(skb, 4);
2313         cpu_to_le32s(&tx_cmd_a);
2314         memcpy(skb->data, &tx_cmd_a, 4);
2315
2316         return skb;
2317 }
2318
2319 static int smsc75xx_manage_power(struct usbnet *dev, int on)
2320 {
2321         dev->intf->needs_remote_wakeup = on;
2322         return 0;
2323 }
2324
2325 static const struct driver_info smsc75xx_info = {
2326         .description    = "smsc75xx USB 2.0 Gigabit Ethernet",
2327         .bind           = smsc75xx_bind,
2328         .unbind         = smsc75xx_unbind,
2329         .link_reset     = smsc75xx_link_reset,
2330         .reset          = smsc75xx_reset,
2331         .rx_fixup       = smsc75xx_rx_fixup,
2332         .tx_fixup       = smsc75xx_tx_fixup,
2333         .status         = smsc75xx_status,
2334         .manage_power   = smsc75xx_manage_power,
2335         .flags          = FLAG_ETHER | FLAG_SEND_ZLP | FLAG_LINK_INTR,
2336 };
2337
2338 static const struct usb_device_id products[] = {
2339         {
2340                 /* SMSC7500 USB Gigabit Ethernet Device */
2341                 USB_DEVICE(USB_VENDOR_ID_SMSC, USB_PRODUCT_ID_LAN7500),
2342                 .driver_info = (unsigned long) &smsc75xx_info,
2343         },
2344         {
2345                 /* SMSC7500 USB Gigabit Ethernet Device */
2346                 USB_DEVICE(USB_VENDOR_ID_SMSC, USB_PRODUCT_ID_LAN7505),
2347                 .driver_info = (unsigned long) &smsc75xx_info,
2348         },
2349         { },            /* END */
2350 };
2351 MODULE_DEVICE_TABLE(usb, products);
2352
2353 static struct usb_driver smsc75xx_driver = {
2354         .name           = SMSC_CHIPNAME,
2355         .id_table       = products,
2356         .probe          = usbnet_probe,
2357         .suspend        = smsc75xx_suspend,
2358         .resume         = smsc75xx_resume,
2359         .reset_resume   = smsc75xx_resume,
2360         .disconnect     = usbnet_disconnect,
2361         .disable_hub_initiated_lpm = 1,
2362         .supports_autosuspend = 1,
2363 };
2364
2365 module_usb_driver(smsc75xx_driver);
2366
2367 MODULE_AUTHOR("Nancy Lin");
2368 MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>");
2369 MODULE_DESCRIPTION("SMSC75XX USB 2.0 Gigabit Ethernet Devices");
2370 MODULE_LICENSE("GPL");