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