drivers/net/usb/lan78xx.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2015 Microchip Technology
   4  */
   5 #include <linux/module.h>
   6 #include <linux/netdevice.h>
   7 #include <linux/etherdevice.h>
   8 #include <linux/ethtool.h>
   9 #include <linux/usb.h>
  10 #include <linux/crc32.h>
  11 #include <linux/signal.h>
  12 #include <linux/slab.h>
  13 #include <linux/if_vlan.h>
  14 #include <linux/uaccess.h>
  15 #include <linux/linkmode.h>
  16 #include <linux/list.h>
  17 #include <linux/ip.h>
  18 #include <linux/ipv6.h>
  19 #include <linux/mdio.h>
  20 #include <linux/phy.h>
  21 #include <net/ip6_checksum.h>
  22 #include <net/vxlan.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/irqdomain.h>
  25 #include <linux/irq.h>
  26 #include <linux/irqchip/chained_irq.h>
  27 #include <linux/microchipphy.h>
  28 #include <linux/phy_fixed.h>
  29 #include <linux/of_mdio.h>
  30 #include <linux/of_net.h>
  31 #include "lan78xx.h"
  32
  33 #define DRIVER_AUTHOR   "WOOJUNG HUH <[email protected]>"
  34 #define DRIVER_DESC     "LAN78XX USB 3.0 Gigabit Ethernet Devices"
  35 #define DRIVER_NAME     "lan78xx"
  36
  37 #define TX_TIMEOUT_JIFFIES              (5 * HZ)
  38 #define THROTTLE_JIFFIES                (HZ / 8)
  39 #define UNLINK_TIMEOUT_MS               3
  40
  41 #define RX_MAX_QUEUE_MEMORY             (60 * 1518)
  42
  43 #define SS_USB_PKT_SIZE                 (1024)
  44 #define HS_USB_PKT_SIZE                 (512)
  45 #define FS_USB_PKT_SIZE                 (64)
  46
  47 #define MAX_RX_FIFO_SIZE                (12 * 1024)
  48 #define MAX_TX_FIFO_SIZE                (12 * 1024)
  49
  50 #define FLOW_THRESHOLD(n)               ((((n) + 511) / 512) & 0x7F)
  51 #define FLOW_CTRL_THRESHOLD(on, off)    ((FLOW_THRESHOLD(on)  << 0) | \
  52                                          (FLOW_THRESHOLD(off) << 8))
  53
  54 /* Flow control turned on when Rx FIFO level rises above this level (bytes) */
  55 #define FLOW_ON_SS                      9216
  56 #define FLOW_ON_HS                      8704
  57
  58 /* Flow control turned off when Rx FIFO level falls below this level (bytes) */
  59 #define FLOW_OFF_SS                     4096
  60 #define FLOW_OFF_HS                     1024
  61
  62 #define DEFAULT_BURST_CAP_SIZE          (MAX_TX_FIFO_SIZE)
  63 #define DEFAULT_BULK_IN_DELAY           (0x0800)
  64 #define MAX_SINGLE_PACKET_SIZE          (9000)
  65 #define DEFAULT_TX_CSUM_ENABLE          (true)
  66 #define DEFAULT_RX_CSUM_ENABLE          (true)
  67 #define DEFAULT_TSO_CSUM_ENABLE         (true)
  68 #define DEFAULT_VLAN_FILTER_ENABLE      (true)
  69 #define DEFAULT_VLAN_RX_OFFLOAD         (true)
  70 #define TX_ALIGNMENT                    (4)
  71 #define RXW_PADDING                     2
  72
  73 #define LAN78XX_USB_VENDOR_ID           (0x0424)
  74 #define LAN7800_USB_PRODUCT_ID          (0x7800)
  75 #define LAN7850_USB_PRODUCT_ID          (0x7850)
  76 #define LAN7801_USB_PRODUCT_ID          (0x7801)
  77 #define LAN78XX_EEPROM_MAGIC            (0x78A5)
  78 #define LAN78XX_OTP_MAGIC               (0x78F3)
  79 #define AT29M2AF_USB_VENDOR_ID          (0x07C9)
  80 #define AT29M2AF_USB_PRODUCT_ID (0x0012)
  81
  82 #define MII_READ                        1
  83 #define MII_WRITE                       0
  84
  85 #define EEPROM_INDICATOR                (0xA5)
  86 #define EEPROM_MAC_OFFSET               (0x01)
  87 #define MAX_EEPROM_SIZE                 512
  88 #define OTP_INDICATOR_1                 (0xF3)
  89 #define OTP_INDICATOR_2                 (0xF7)
  90
  91 #define WAKE_ALL                        (WAKE_PHY | WAKE_UCAST | \
  92                                          WAKE_MCAST | WAKE_BCAST | \
  93                                          WAKE_ARP | WAKE_MAGIC)
  94
  95 #define TX_URB_NUM                      10
  96 #define TX_SS_URB_NUM                   TX_URB_NUM
  97 #define TX_HS_URB_NUM                   TX_URB_NUM
  98 #define TX_FS_URB_NUM                   TX_URB_NUM
  99
 100 /* A single URB buffer must be large enough to hold a complete jumbo packet
 101  */
 102 #define TX_SS_URB_SIZE                  (32 * 1024)
 103 #define TX_HS_URB_SIZE                  (16 * 1024)
 104 #define TX_FS_URB_SIZE                  (10 * 1024)
 105
 106 #define RX_SS_URB_NUM                   30
 107 #define RX_HS_URB_NUM                   10
 108 #define RX_FS_URB_NUM                   10
 109 #define RX_SS_URB_SIZE                  TX_SS_URB_SIZE
 110 #define RX_HS_URB_SIZE                  TX_HS_URB_SIZE
 111 #define RX_FS_URB_SIZE                  TX_FS_URB_SIZE
 112
 113 #define SS_BURST_CAP_SIZE               RX_SS_URB_SIZE
 114 #define SS_BULK_IN_DELAY                0x2000
 115 #define HS_BURST_CAP_SIZE               RX_HS_URB_SIZE
 116 #define HS_BULK_IN_DELAY                0x2000
 117 #define FS_BURST_CAP_SIZE               RX_FS_URB_SIZE
 118 #define FS_BULK_IN_DELAY                0x2000
 119
 120 #define TX_CMD_LEN                      8
 121 #define TX_SKB_MIN_LEN                  (TX_CMD_LEN + ETH_HLEN)
 122 #define LAN78XX_TSO_SIZE(dev)           ((dev)->tx_urb_size - TX_SKB_MIN_LEN)
 123
 124 #define RX_CMD_LEN                      10
 125 #define RX_SKB_MIN_LEN                  (RX_CMD_LEN + ETH_HLEN)
 126 #define RX_MAX_FRAME_LEN(mtu)           ((mtu) + ETH_HLEN + VLAN_HLEN)
 127
 128 /* USB related defines */
 129 #define BULK_IN_PIPE                    1
 130 #define BULK_OUT_PIPE                   2
 131
 132 /* default autosuspend delay (mSec)*/
 133 #define DEFAULT_AUTOSUSPEND_DELAY       (10 * 1000)
 134
 135 /* statistic update interval (mSec) */
 136 #define STAT_UPDATE_TIMER               (1 * 1000)
 137
 138 /* time to wait for MAC or FCT to stop (jiffies) */
 139 #define HW_DISABLE_TIMEOUT              (HZ / 10)
 140
 141 /* time to wait between polling MAC or FCT state (ms) */
 142 #define HW_DISABLE_DELAY_MS             1
 143
 144 /* defines interrupts from interrupt EP */
 145 #define MAX_INT_EP                      (32)
 146 #define INT_EP_INTEP                    (31)
 147 #define INT_EP_OTP_WR_DONE              (28)
 148 #define INT_EP_EEE_TX_LPI_START         (26)
 149 #define INT_EP_EEE_TX_LPI_STOP          (25)
 150 #define INT_EP_EEE_RX_LPI               (24)
 151 #define INT_EP_MAC_RESET_TIMEOUT        (23)
 152 #define INT_EP_RDFO                     (22)
 153 #define INT_EP_TXE                      (21)
 154 #define INT_EP_USB_STATUS               (20)
 155 #define INT_EP_TX_DIS                   (19)
 156 #define INT_EP_RX_DIS                   (18)
 157 #define INT_EP_PHY                      (17)
 158 #define INT_EP_DP                       (16)
 159 #define INT_EP_MAC_ERR                  (15)
 160 #define INT_EP_TDFU                     (14)
 161 #define INT_EP_TDFO                     (13)
 162 #define INT_EP_UTX                      (12)
 163 #define INT_EP_GPIO_11                  (11)
 164 #define INT_EP_GPIO_10                  (10)
 165 #define INT_EP_GPIO_9                   (9)
 166 #define INT_EP_GPIO_8                   (8)
 167 #define INT_EP_GPIO_7                   (7)
 168 #define INT_EP_GPIO_6                   (6)
 169 #define INT_EP_GPIO_5                   (5)
 170 #define INT_EP_GPIO_4                   (4)
 171 #define INT_EP_GPIO_3                   (3)
 172 #define INT_EP_GPIO_2                   (2)
 173 #define INT_EP_GPIO_1                   (1)
 174 #define INT_EP_GPIO_0                   (0)
 175
 176 static const char lan78xx_gstrings[][ETH_GSTRING_LEN] = {
 177         "RX FCS Errors",
 178         "RX Alignment Errors",
 179         "Rx Fragment Errors",
 180         "RX Jabber Errors",
 181         "RX Undersize Frame Errors",
 182         "RX Oversize Frame Errors",
 183         "RX Dropped Frames",
 184         "RX Unicast Byte Count",
 185         "RX Broadcast Byte Count",
 186         "RX Multicast Byte Count",
 187         "RX Unicast Frames",
 188         "RX Broadcast Frames",
 189         "RX Multicast Frames",
 190         "RX Pause Frames",
 191         "RX 64 Byte Frames",
 192         "RX 65 - 127 Byte Frames",
 193         "RX 128 - 255 Byte Frames",
 194         "RX 256 - 511 Bytes Frames",
 195         "RX 512 - 1023 Byte Frames",
 196         "RX 1024 - 1518 Byte Frames",
 197         "RX Greater 1518 Byte Frames",
 198         "EEE RX LPI Transitions",
 199         "EEE RX LPI Time",
 200         "TX FCS Errors",
 201         "TX Excess Deferral Errors",
 202         "TX Carrier Errors",
 203         "TX Bad Byte Count",
 204         "TX Single Collisions",
 205         "TX Multiple Collisions",
 206         "TX Excessive Collision",
 207         "TX Late Collisions",
 208         "TX Unicast Byte Count",
 209         "TX Broadcast Byte Count",
 210         "TX Multicast Byte Count",
 211         "TX Unicast Frames",
 212         "TX Broadcast Frames",
 213         "TX Multicast Frames",
 214         "TX Pause Frames",
 215         "TX 64 Byte Frames",
 216         "TX 65 - 127 Byte Frames",
 217         "TX 128 - 255 Byte Frames",
 218         "TX 256 - 511 Bytes Frames",
 219         "TX 512 - 1023 Byte Frames",
 220         "TX 1024 - 1518 Byte Frames",
 221         "TX Greater 1518 Byte Frames",
 222         "EEE TX LPI Transitions",
 223         "EEE TX LPI Time",
 224 };
 225
 226 struct lan78xx_statstage {
 227         u32 rx_fcs_errors;
 228         u32 rx_alignment_errors;
 229         u32 rx_fragment_errors;
 230         u32 rx_jabber_errors;
 231         u32 rx_undersize_frame_errors;
 232         u32 rx_oversize_frame_errors;
 233         u32 rx_dropped_frames;
 234         u32 rx_unicast_byte_count;
 235         u32 rx_broadcast_byte_count;
 236         u32 rx_multicast_byte_count;
 237         u32 rx_unicast_frames;
 238         u32 rx_broadcast_frames;
 239         u32 rx_multicast_frames;
 240         u32 rx_pause_frames;
 241         u32 rx_64_byte_frames;
 242         u32 rx_65_127_byte_frames;
 243         u32 rx_128_255_byte_frames;
 244         u32 rx_256_511_bytes_frames;
 245         u32 rx_512_1023_byte_frames;
 246         u32 rx_1024_1518_byte_frames;
 247         u32 rx_greater_1518_byte_frames;
 248         u32 eee_rx_lpi_transitions;
 249         u32 eee_rx_lpi_time;
 250         u32 tx_fcs_errors;
 251         u32 tx_excess_deferral_errors;
 252         u32 tx_carrier_errors;
 253         u32 tx_bad_byte_count;
 254         u32 tx_single_collisions;
 255         u32 tx_multiple_collisions;
 256         u32 tx_excessive_collision;
 257         u32 tx_late_collisions;
 258         u32 tx_unicast_byte_count;
 259         u32 tx_broadcast_byte_count;
 260         u32 tx_multicast_byte_count;
 261         u32 tx_unicast_frames;
 262         u32 tx_broadcast_frames;
 263         u32 tx_multicast_frames;
 264         u32 tx_pause_frames;
 265         u32 tx_64_byte_frames;
 266         u32 tx_65_127_byte_frames;
 267         u32 tx_128_255_byte_frames;
 268         u32 tx_256_511_bytes_frames;
 269         u32 tx_512_1023_byte_frames;
 270         u32 tx_1024_1518_byte_frames;
 271         u32 tx_greater_1518_byte_frames;
 272         u32 eee_tx_lpi_transitions;
 273         u32 eee_tx_lpi_time;
 274 };
 275
 276 struct lan78xx_statstage64 {
 277         u64 rx_fcs_errors;
 278         u64 rx_alignment_errors;
 279         u64 rx_fragment_errors;
 280         u64 rx_jabber_errors;
 281         u64 rx_undersize_frame_errors;
 282         u64 rx_oversize_frame_errors;
 283         u64 rx_dropped_frames;
 284         u64 rx_unicast_byte_count;
 285         u64 rx_broadcast_byte_count;
 286         u64 rx_multicast_byte_count;
 287         u64 rx_unicast_frames;
 288         u64 rx_broadcast_frames;
 289         u64 rx_multicast_frames;
 290         u64 rx_pause_frames;
 291         u64 rx_64_byte_frames;
 292         u64 rx_65_127_byte_frames;
 293         u64 rx_128_255_byte_frames;
 294         u64 rx_256_511_bytes_frames;
 295         u64 rx_512_1023_byte_frames;
 296         u64 rx_1024_1518_byte_frames;
 297         u64 rx_greater_1518_byte_frames;
 298         u64 eee_rx_lpi_transitions;
 299         u64 eee_rx_lpi_time;
 300         u64 tx_fcs_errors;
 301         u64 tx_excess_deferral_errors;
 302         u64 tx_carrier_errors;
 303         u64 tx_bad_byte_count;
 304         u64 tx_single_collisions;
 305         u64 tx_multiple_collisions;
 306         u64 tx_excessive_collision;
 307         u64 tx_late_collisions;
 308         u64 tx_unicast_byte_count;
 309         u64 tx_broadcast_byte_count;
 310         u64 tx_multicast_byte_count;
 311         u64 tx_unicast_frames;
 312         u64 tx_broadcast_frames;
 313         u64 tx_multicast_frames;
 314         u64 tx_pause_frames;
 315         u64 tx_64_byte_frames;
 316         u64 tx_65_127_byte_frames;
 317         u64 tx_128_255_byte_frames;
 318         u64 tx_256_511_bytes_frames;
 319         u64 tx_512_1023_byte_frames;
 320         u64 tx_1024_1518_byte_frames;
 321         u64 tx_greater_1518_byte_frames;
 322         u64 eee_tx_lpi_transitions;
 323         u64 eee_tx_lpi_time;
 324 };
 325
 326 static u32 lan78xx_regs[] = {
 327         ID_REV,
 328         INT_STS,
 329         HW_CFG,
 330         PMT_CTL,
 331         E2P_CMD,
 332         E2P_DATA,
 333         USB_STATUS,
 334         VLAN_TYPE,
 335         MAC_CR,
 336         MAC_RX,
 337         MAC_TX,
 338         FLOW,
 339         ERR_STS,
 340         MII_ACC,
 341         MII_DATA,
 342         EEE_TX_LPI_REQ_DLY,
 343         EEE_TW_TX_SYS,
 344         EEE_TX_LPI_REM_DLY,
 345         WUCSR
 346 };
 347
 348 #define PHY_REG_SIZE (32 * sizeof(u32))
 349
 350 struct lan78xx_net;
 351
 352 struct lan78xx_priv {
 353         struct lan78xx_net *dev;
 354         u32 rfe_ctl;
 355         u32 mchash_table[DP_SEL_VHF_HASH_LEN]; /* multicast hash table */
 356         u32 pfilter_table[NUM_OF_MAF][2]; /* perfect filter table */
 357         u32 vlan_table[DP_SEL_VHF_VLAN_LEN];
 358         struct mutex dataport_mutex; /* for dataport access */
 359         spinlock_t rfe_ctl_lock; /* for rfe register access */
 360         struct work_struct set_multicast;
 361         struct work_struct set_vlan;
 362         u32 wol;
 363 };
 364
 365 enum skb_state {
 366         illegal = 0,
 367         tx_start,
 368         tx_done,
 369         rx_start,
 370         rx_done,
 371         rx_cleanup,
 372         unlink_start
 373 };
 374
 375 struct skb_data {               /* skb->cb is one of these */
 376         struct urb *urb;
 377         struct lan78xx_net *dev;
 378         enum skb_state state;
 379         size_t length;
 380         int num_of_packet;
 381 };
 382
 383 struct usb_context {
 384         struct usb_ctrlrequest req;
 385         struct lan78xx_net *dev;
 386 };
 387
 388 #define EVENT_TX_HALT                   0
 389 #define EVENT_RX_HALT                   1
 390 #define EVENT_RX_MEMORY                 2
 391 #define EVENT_STS_SPLIT                 3
 392 #define EVENT_LINK_RESET                4
 393 #define EVENT_RX_PAUSED                 5
 394 #define EVENT_DEV_WAKING                6
 395 #define EVENT_DEV_ASLEEP                7
 396 #define EVENT_DEV_OPEN                  8
 397 #define EVENT_STAT_UPDATE               9
 398 #define EVENT_DEV_DISCONNECT            10
 399
 400 struct statstage {
 401         struct mutex                    access_lock;    /* for stats access */
 402         struct lan78xx_statstage        saved;
 403         struct lan78xx_statstage        rollover_count;
 404         struct lan78xx_statstage        rollover_max;
 405         struct lan78xx_statstage64      curr_stat;
 406 };
 407
 408 struct irq_domain_data {
 409         struct irq_domain       *irqdomain;
 410         unsigned int            phyirq;
 411         struct irq_chip         *irqchip;
 412         irq_flow_handler_t      irq_handler;
 413         u32                     irqenable;
 414         struct mutex            irq_lock;               /* for irq bus access */
 415 };
 416
 417 struct lan78xx_net {
 418         struct net_device       *net;
 419         struct usb_device       *udev;
 420         struct usb_interface    *intf;
 421         void                    *driver_priv;
 422
 423         unsigned int            tx_pend_data_len;
 424         size_t                  n_tx_urbs;
 425         size_t                  n_rx_urbs;
 426         size_t                  tx_urb_size;
 427         size_t                  rx_urb_size;
 428
 429         struct sk_buff_head     rxq_free;
 430         struct sk_buff_head     rxq;
 431         struct sk_buff_head     rxq_done;
 432         struct sk_buff_head     rxq_overflow;
 433         struct sk_buff_head     txq_free;
 434         struct sk_buff_head     txq;
 435         struct sk_buff_head     txq_pend;
 436
 437         struct napi_struct      napi;
 438
 439         struct delayed_work     wq;
 440
 441         int                     msg_enable;
 442
 443         struct urb              *urb_intr;
 444         struct usb_anchor       deferred;
 445
 446         struct mutex            dev_mutex; /* serialise open/stop wrt suspend/resume */
 447         struct mutex            phy_mutex; /* for phy access */
 448         unsigned int            pipe_in, pipe_out, pipe_intr;
 449
 450         unsigned int            bulk_in_delay;
 451         unsigned int            burst_cap;
 452
 453         unsigned long           flags;
 454
 455         wait_queue_head_t       *wait;
 456         unsigned char           suspend_count;
 457
 458         unsigned int            maxpacket;
 459         struct timer_list       stat_monitor;
 460
 461         unsigned long           data[5];
 462
 463         int                     link_on;
 464         u8                      mdix_ctrl;
 465
 466         u32                     chipid;
 467         u32                     chiprev;
 468         struct mii_bus          *mdiobus;
 469         phy_interface_t         interface;
 470
 471         int                     fc_autoneg;
 472         u8                      fc_request_control;
 473
 474         int                     delta;
 475         struct statstage        stats;
 476
 477         struct irq_domain_data  domain_data;
 478 };
 479
 480 /* define external phy id */
 481 #define PHY_LAN8835                     (0x0007C130)
 482 #define PHY_KSZ9031RNX                  (0x00221620)
 483
 484 /* use ethtool to change the level for any given device */
 485 static int msg_level = -1;
 486 module_param(msg_level, int, 0);
 487 MODULE_PARM_DESC(msg_level, "Override default message level");
 488
 489 static struct sk_buff *lan78xx_get_buf(struct sk_buff_head *buf_pool)
 490 {
 491         if (skb_queue_empty(buf_pool))
 492                 return NULL;
 493
 494         return skb_dequeue(buf_pool);
 495 }
 496
 497 static void lan78xx_release_buf(struct sk_buff_head *buf_pool,
 498                                 struct sk_buff *buf)
 499 {
 500         buf->data = buf->head;
 501         skb_reset_tail_pointer(buf);
 502
 503         buf->len = 0;
 504         buf->data_len = 0;
 505
 506         skb_queue_tail(buf_pool, buf);
 507 }
 508
 509 static void lan78xx_free_buf_pool(struct sk_buff_head *buf_pool)
 510 {
 511         struct skb_data *entry;
 512         struct sk_buff *buf;
 513
 514         while (!skb_queue_empty(buf_pool)) {
 515                 buf = skb_dequeue(buf_pool);
 516                 if (buf) {
 517                         entry = (struct skb_data *)buf->cb;
 518                         usb_free_urb(entry->urb);
 519                         dev_kfree_skb_any(buf);
 520                 }
 521         }
 522 }
 523
 524 static int lan78xx_alloc_buf_pool(struct sk_buff_head *buf_pool,
 525                                   size_t n_urbs, size_t urb_size,
 526                                   struct lan78xx_net *dev)
 527 {
 528         struct skb_data *entry;
 529         struct sk_buff *buf;
 530         struct urb *urb;
 531         int i;
 532
 533         skb_queue_head_init(buf_pool);
 534
 535         for (i = 0; i < n_urbs; i++) {
 536                 buf = alloc_skb(urb_size, GFP_ATOMIC);
 537                 if (!buf)
 538                         goto error;
 539
 540                 if (skb_linearize(buf) != 0) {
 541                         dev_kfree_skb_any(buf);
 542                         goto error;
 543                 }
 544
 545                 urb = usb_alloc_urb(0, GFP_ATOMIC);
 546                 if (!urb) {
 547                         dev_kfree_skb_any(buf);
 548                         goto error;
 549                 }
 550
 551                 entry = (struct skb_data *)buf->cb;
 552                 entry->urb = urb;
 553                 entry->dev = dev;
 554                 entry->length = 0;
 555                 entry->num_of_packet = 0;
 556
 557                 skb_queue_tail(buf_pool, buf);
 558         }
 559
 560         return 0;
 561
 562 error:
 563         lan78xx_free_buf_pool(buf_pool);
 564
 565         return -ENOMEM;
 566 }
 567
 568 static struct sk_buff *lan78xx_get_rx_buf(struct lan78xx_net *dev)
 569 {
 570         return lan78xx_get_buf(&dev->rxq_free);
 571 }
 572
 573 static void lan78xx_release_rx_buf(struct lan78xx_net *dev,
 574                                    struct sk_buff *rx_buf)
 575 {
 576         lan78xx_release_buf(&dev->rxq_free, rx_buf);
 577 }
 578
 579 static void lan78xx_free_rx_resources(struct lan78xx_net *dev)
 580 {
 581         lan78xx_free_buf_pool(&dev->rxq_free);
 582 }
 583
 584 static int lan78xx_alloc_rx_resources(struct lan78xx_net *dev)
 585 {
 586         return lan78xx_alloc_buf_pool(&dev->rxq_free,
 587                                       dev->n_rx_urbs, dev->rx_urb_size, dev);
 588 }
 589
 590 static struct sk_buff *lan78xx_get_tx_buf(struct lan78xx_net *dev)
 591 {
 592         return lan78xx_get_buf(&dev->txq_free);
 593 }
 594
 595 static void lan78xx_release_tx_buf(struct lan78xx_net *dev,
 596                                    struct sk_buff *tx_buf)
 597 {
 598         lan78xx_release_buf(&dev->txq_free, tx_buf);
 599 }
 600
 601 static void lan78xx_free_tx_resources(struct lan78xx_net *dev)
 602 {
 603         lan78xx_free_buf_pool(&dev->txq_free);
 604 }
 605
 606 static int lan78xx_alloc_tx_resources(struct lan78xx_net *dev)
 607 {
 608         return lan78xx_alloc_buf_pool(&dev->txq_free,
 609                                       dev->n_tx_urbs, dev->tx_urb_size, dev);
 610 }
 611
 612 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
 613 {
 614         u32 *buf;
 615         int ret;
 616
 617         if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
 618                 return -ENODEV;
 619
 620         buf = kmalloc(sizeof(u32), GFP_KERNEL);
 621         if (!buf)
 622                 return -ENOMEM;
 623
 624         ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
 625                               USB_VENDOR_REQUEST_READ_REGISTER,
 626                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 627                               0, index, buf, 4, USB_CTRL_GET_TIMEOUT);
 628         if (likely(ret >= 0)) {
 629                 le32_to_cpus(buf);
 630                 *data = *buf;
 631         } else if (net_ratelimit()) {
 632                 netdev_warn(dev->net,
 633                             "Failed to read register index 0x%08x. ret = %d",
 634                             index, ret);
 635         }
 636
 637         kfree(buf);
 638
 639         return ret;
 640 }
 641
 642 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
 643 {
 644         u32 *buf;
 645         int ret;
 646
 647         if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
 648                 return -ENODEV;
 649
 650         buf = kmalloc(sizeof(u32), GFP_KERNEL);
 651         if (!buf)
 652                 return -ENOMEM;
 653
 654         *buf = data;
 655         cpu_to_le32s(buf);
 656
 657         ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
 658                               USB_VENDOR_REQUEST_WRITE_REGISTER,
 659                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 660                               0, index, buf, 4, USB_CTRL_SET_TIMEOUT);
 661         if (unlikely(ret < 0) &&
 662             net_ratelimit()) {
 663                 netdev_warn(dev->net,
 664                             "Failed to write register index 0x%08x. ret = %d",
 665                             index, ret);
 666         }
 667
 668         kfree(buf);
 669
 670         return ret;
 671 }
 672
 673 static int lan78xx_update_reg(struct lan78xx_net *dev, u32 reg, u32 mask,
 674                               u32 data)
 675 {
 676         int ret;
 677         u32 buf;
 678
 679         ret = lan78xx_read_reg(dev, reg, &buf);
 680         if (ret < 0)
 681                 return ret;
 682
 683         buf &= ~mask;
 684         buf |= (mask & data);
 685
 686         ret = lan78xx_write_reg(dev, reg, buf);
 687         if (ret < 0)
 688                 return ret;
 689
 690         return 0;
 691 }
 692
 693 static int lan78xx_read_stats(struct lan78xx_net *dev,
 694                               struct lan78xx_statstage *data)
 695 {
 696         int ret = 0;
 697         int i;
 698         struct lan78xx_statstage *stats;
 699         u32 *src;
 700         u32 *dst;
 701
 702         stats = kmalloc(sizeof(*stats), GFP_KERNEL);
 703         if (!stats)
 704                 return -ENOMEM;
 705
 706         ret = usb_control_msg(dev->udev,
 707                               usb_rcvctrlpipe(dev->udev, 0),
 708                               USB_VENDOR_REQUEST_GET_STATS,
 709                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 710                               0,
 711                               0,
 712                               (void *)stats,
 713                               sizeof(*stats),
 714                               USB_CTRL_SET_TIMEOUT);
 715         if (likely(ret >= 0)) {
 716                 src = (u32 *)stats;
 717                 dst = (u32 *)data;
 718                 for (i = 0; i < sizeof(*stats) / sizeof(u32); i++) {
 719                         le32_to_cpus(&src[i]);
 720                         dst[i] = src[i];
 721                 }
 722         } else {
 723                 netdev_warn(dev->net,
 724                             "Failed to read stat ret = %d", ret);
 725         }
 726
 727         kfree(stats);
 728
 729         return ret;
 730 }
 731
 732 #define check_counter_rollover(struct1, dev_stats, member)              \
 733         do {                                                            \
 734                 if ((struct1)->member < (dev_stats).saved.member)       \
 735                         (dev_stats).rollover_count.member++;            \
 736         } while (0)
 737
 738 static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,
 739                                         struct lan78xx_statstage *stats)
 740 {
 741         check_counter_rollover(stats, dev->stats, rx_fcs_errors);
 742         check_counter_rollover(stats, dev->stats, rx_alignment_errors);
 743         check_counter_rollover(stats, dev->stats, rx_fragment_errors);
 744         check_counter_rollover(stats, dev->stats, rx_jabber_errors);
 745         check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);
 746         check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);
 747         check_counter_rollover(stats, dev->stats, rx_dropped_frames);
 748         check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);
 749         check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);
 750         check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);
 751         check_counter_rollover(stats, dev->stats, rx_unicast_frames);
 752         check_counter_rollover(stats, dev->stats, rx_broadcast_frames);
 753         check_counter_rollover(stats, dev->stats, rx_multicast_frames);
 754         check_counter_rollover(stats, dev->stats, rx_pause_frames);
 755         check_counter_rollover(stats, dev->stats, rx_64_byte_frames);
 756         check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);
 757         check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);
 758         check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);
 759         check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);
 760         check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);
 761         check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);
 762         check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);
 763         check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);
 764         check_counter_rollover(stats, dev->stats, tx_fcs_errors);
 765         check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);
 766         check_counter_rollover(stats, dev->stats, tx_carrier_errors);
 767         check_counter_rollover(stats, dev->stats, tx_bad_byte_count);
 768         check_counter_rollover(stats, dev->stats, tx_single_collisions);
 769         check_counter_rollover(stats, dev->stats, tx_multiple_collisions);
 770         check_counter_rollover(stats, dev->stats, tx_excessive_collision);
 771         check_counter_rollover(stats, dev->stats, tx_late_collisions);
 772         check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);
 773         check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);
 774         check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);
 775         check_counter_rollover(stats, dev->stats, tx_unicast_frames);
 776         check_counter_rollover(stats, dev->stats, tx_broadcast_frames);
 777         check_counter_rollover(stats, dev->stats, tx_multicast_frames);
 778         check_counter_rollover(stats, dev->stats, tx_pause_frames);
 779         check_counter_rollover(stats, dev->stats, tx_64_byte_frames);
 780         check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);
 781         check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);
 782         check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);
 783         check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);
 784         check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);
 785         check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);
 786         check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);
 787         check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);
 788
 789         memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));
 790 }
 791
 792 static void lan78xx_update_stats(struct lan78xx_net *dev)
 793 {
 794         u32 *p, *count, *max;
 795         u64 *data;
 796         int i;
 797         struct lan78xx_statstage lan78xx_stats;
 798
 799         if (usb_autopm_get_interface(dev->intf) < 0)
 800                 return;
 801
 802         p = (u32 *)&lan78xx_stats;
 803         count = (u32 *)&dev->stats.rollover_count;
 804         max = (u32 *)&dev->stats.rollover_max;
 805         data = (u64 *)&dev->stats.curr_stat;
 806
 807         mutex_lock(&dev->stats.access_lock);
 808
 809         if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)
 810                 lan78xx_check_stat_rollover(dev, &lan78xx_stats);
 811
 812         for (i = 0; i < (sizeof(lan78xx_stats) / (sizeof(u32))); i++)
 813                 data[i] = (u64)p[i] + ((u64)count[i] * ((u64)max[i] + 1));
 814
 815         mutex_unlock(&dev->stats.access_lock);
 816
 817         usb_autopm_put_interface(dev->intf);
 818 }
 819
 820 /* Loop until the read is completed with timeout called with phy_mutex held */
 821 static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
 822 {
 823         unsigned long start_time = jiffies;
 824         u32 val;
 825         int ret;
 826
 827         do {
 828                 ret = lan78xx_read_reg(dev, MII_ACC, &val);
 829                 if (unlikely(ret < 0))
 830                         return -EIO;
 831
 832                 if (!(val & MII_ACC_MII_BUSY_))
 833                         return 0;
 834         } while (!time_after(jiffies, start_time + HZ));
 835
 836         return -EIO;
 837 }
 838
 839 static inline u32 mii_access(int id, int index, int read)
 840 {
 841         u32 ret;
 842
 843         ret = ((u32)id << MII_ACC_PHY_ADDR_SHIFT_) & MII_ACC_PHY_ADDR_MASK_;
 844         ret |= ((u32)index << MII_ACC_MIIRINDA_SHIFT_) & MII_ACC_MIIRINDA_MASK_;
 845         if (read)
 846                 ret |= MII_ACC_MII_READ_;
 847         else
 848                 ret |= MII_ACC_MII_WRITE_;
 849         ret |= MII_ACC_MII_BUSY_;
 850
 851         return ret;
 852 }
 853
 854 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
 855 {
 856         unsigned long start_time = jiffies;
 857         u32 val;
 858         int ret;
 859
 860         do {
 861                 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
 862                 if (unlikely(ret < 0))
 863                         return -EIO;
 864
 865                 if (!(val & E2P_CMD_EPC_BUSY_) ||
 866                     (val & E2P_CMD_EPC_TIMEOUT_))
 867                         break;
 868                 usleep_range(40, 100);
 869         } while (!time_after(jiffies, start_time + HZ));
 870
 871         if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
 872                 netdev_warn(dev->net, "EEPROM read operation timeout");
 873                 return -EIO;
 874         }
 875
 876         return 0;
 877 }
 878
 879 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
 880 {
 881         unsigned long start_time = jiffies;
 882         u32 val;
 883         int ret;
 884
 885         do {
 886                 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
 887                 if (unlikely(ret < 0))
 888                         return -EIO;
 889
 890                 if (!(val & E2P_CMD_EPC_BUSY_))
 891                         return 0;
 892
 893                 usleep_range(40, 100);
 894         } while (!time_after(jiffies, start_time + HZ));
 895
 896         netdev_warn(dev->net, "EEPROM is busy");
 897         return -EIO;
 898 }
 899
 900 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
 901                                    u32 length, u8 *data)
 902 {
 903         u32 val;
 904         u32 saved;
 905         int i, ret;
 906         int retval;
 907
 908         /* depends on chip, some EEPROM pins are muxed with LED function.
 909          * disable & restore LED function to access EEPROM.
 910          */
 911         ret = lan78xx_read_reg(dev, HW_CFG, &val);
 912         saved = val;
 913         if (dev->chipid == ID_REV_CHIP_ID_7800_) {
 914                 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
 915                 ret = lan78xx_write_reg(dev, HW_CFG, val);
 916         }
 917
 918         retval = lan78xx_eeprom_confirm_not_busy(dev);
 919         if (retval)
 920                 return retval;
 921
 922         for (i = 0; i < length; i++) {
 923                 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
 924                 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
 925                 ret = lan78xx_write_reg(dev, E2P_CMD, val);
 926                 if (unlikely(ret < 0)) {
 927                         retval = -EIO;
 928                         goto exit;
 929                 }
 930
 931                 retval = lan78xx_wait_eeprom(dev);
 932                 if (retval < 0)
 933                         goto exit;
 934
 935                 ret = lan78xx_read_reg(dev, E2P_DATA, &val);
 936                 if (unlikely(ret < 0)) {
 937                         retval = -EIO;
 938                         goto exit;
 939                 }
 940
 941                 data[i] = val & 0xFF;
 942                 offset++;
 943         }
 944
 945         retval = 0;
 946 exit:
 947         if (dev->chipid == ID_REV_CHIP_ID_7800_)
 948                 ret = lan78xx_write_reg(dev, HW_CFG, saved);
 949
 950         return retval;
 951 }
 952
 953 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
 954                                u32 length, u8 *data)
 955 {
 956         u8 sig;
 957         int ret;
 958
 959         ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
 960         if ((ret == 0) && (sig == EEPROM_INDICATOR))
 961                 ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
 962         else
 963                 ret = -EINVAL;
 964
 965         return ret;
 966 }
 967
 968 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
 969                                     u32 length, u8 *data)
 970 {
 971         u32 val;
 972         u32 saved;
 973         int i, ret;
 974         int retval;
 975
 976         /* depends on chip, some EEPROM pins are muxed with LED function.
 977          * disable & restore LED function to access EEPROM.
 978          */
 979         ret = lan78xx_read_reg(dev, HW_CFG, &val);
 980         saved = val;
 981         if (dev->chipid == ID_REV_CHIP_ID_7800_) {
 982                 val &= ~(HW_CFG_LED1_EN_ | HW_CFG_LED0_EN_);
 983                 ret = lan78xx_write_reg(dev, HW_CFG, val);
 984         }
 985
 986         retval = lan78xx_eeprom_confirm_not_busy(dev);
 987         if (retval)
 988                 goto exit;
 989
 990         /* Issue write/erase enable command */
 991         val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
 992         ret = lan78xx_write_reg(dev, E2P_CMD, val);
 993         if (unlikely(ret < 0)) {
 994                 retval = -EIO;
 995                 goto exit;
 996         }
 997
 998         retval = lan78xx_wait_eeprom(dev);
 999         if (retval < 0)
1000                 goto exit;
1001
1002         for (i = 0; i < length; i++) {
1003                 /* Fill data register */
1004                 val = data[i];
1005                 ret = lan78xx_write_reg(dev, E2P_DATA, val);
1006                 if (ret < 0) {
1007                         retval = -EIO;
1008                         goto exit;
1009                 }
1010
1011                 /* Send "write" command */
1012                 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
1013                 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
1014                 ret = lan78xx_write_reg(dev, E2P_CMD, val);
1015                 if (ret < 0) {
1016                         retval = -EIO;
1017                         goto exit;
1018                 }
1019
1020                 retval = lan78xx_wait_eeprom(dev);
1021                 if (retval < 0)
1022                         goto exit;
1023
1024                 offset++;
1025         }
1026
1027         retval = 0;
1028 exit:
1029         if (dev->chipid == ID_REV_CHIP_ID_7800_)
1030                 ret = lan78xx_write_reg(dev, HW_CFG, saved);
1031
1032         return retval;
1033 }
1034
1035 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
1036                                 u32 length, u8 *data)
1037 {
1038         int i;
1039         u32 buf;
1040         unsigned long timeout;
1041
1042         lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1043
1044         if (buf & OTP_PWR_DN_PWRDN_N_) {
1045                 /* clear it and wait to be cleared */
1046                 lan78xx_write_reg(dev, OTP_PWR_DN, 0);
1047
1048                 timeout = jiffies + HZ;
1049                 do {
1050                         usleep_range(1, 10);
1051                         lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1052                         if (time_after(jiffies, timeout)) {
1053                                 netdev_warn(dev->net,
1054                                             "timeout on OTP_PWR_DN");
1055                                 return -EIO;
1056                         }
1057                 } while (buf & OTP_PWR_DN_PWRDN_N_);
1058         }
1059
1060         for (i = 0; i < length; i++) {
1061                 lan78xx_write_reg(dev, OTP_ADDR1,
1062                                   ((offset + i) >> 8) & OTP_ADDR1_15_11);
1063                 lan78xx_write_reg(dev, OTP_ADDR2,
1064                                   ((offset + i) & OTP_ADDR2_10_3));
1065
1066                 lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
1067                 lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
1068
1069                 timeout = jiffies + HZ;
1070                 do {
1071                         udelay(1);
1072                         lan78xx_read_reg(dev, OTP_STATUS, &buf);
1073                         if (time_after(jiffies, timeout)) {
1074                                 netdev_warn(dev->net,
1075                                             "timeout on OTP_STATUS");
1076                                 return -EIO;
1077                         }
1078                 } while (buf & OTP_STATUS_BUSY_);
1079
1080                 lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
1081
1082                 data[i] = (u8)(buf & 0xFF);
1083         }
1084
1085         return 0;
1086 }
1087
1088 static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
1089                                  u32 length, u8 *data)
1090 {
1091         int i;
1092         u32 buf;
1093         unsigned long timeout;
1094
1095         lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1096
1097         if (buf & OTP_PWR_DN_PWRDN_N_) {
1098                 /* clear it and wait to be cleared */
1099                 lan78xx_write_reg(dev, OTP_PWR_DN, 0);
1100
1101                 timeout = jiffies + HZ;
1102                 do {
1103                         udelay(1);
1104                         lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1105                         if (time_after(jiffies, timeout)) {
1106                                 netdev_warn(dev->net,
1107                                             "timeout on OTP_PWR_DN completion");
1108                                 return -EIO;
1109                         }
1110                 } while (buf & OTP_PWR_DN_PWRDN_N_);
1111         }
1112
1113         /* set to BYTE program mode */
1114         lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
1115
1116         for (i = 0; i < length; i++) {
1117                 lan78xx_write_reg(dev, OTP_ADDR1,
1118                                   ((offset + i) >> 8) & OTP_ADDR1_15_11);
1119                 lan78xx_write_reg(dev, OTP_ADDR2,
1120                                   ((offset + i) & OTP_ADDR2_10_3));
1121                 lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
1122                 lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
1123                 lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
1124
1125                 timeout = jiffies + HZ;
1126                 do {
1127                         udelay(1);
1128                         lan78xx_read_reg(dev, OTP_STATUS, &buf);
1129                         if (time_after(jiffies, timeout)) {
1130                                 netdev_warn(dev->net,
1131                                             "Timeout on OTP_STATUS completion");
1132                                 return -EIO;
1133                         }
1134                 } while (buf & OTP_STATUS_BUSY_);
1135         }
1136
1137         return 0;
1138 }
1139
1140 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
1141                             u32 length, u8 *data)
1142 {
1143         u8 sig;
1144         int ret;
1145
1146         ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
1147
1148         if (ret == 0) {
1149                 if (sig == OTP_INDICATOR_2)
1150                         offset += 0x100;
1151                 else if (sig != OTP_INDICATOR_1)
1152                         ret = -EINVAL;
1153                 if (!ret)
1154                         ret = lan78xx_read_raw_otp(dev, offset, length, data);
1155         }
1156
1157         return ret;
1158 }
1159
1160 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
1161 {
1162         int i, ret;
1163
1164         for (i = 0; i < 100; i++) {
1165                 u32 dp_sel;
1166
1167                 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
1168                 if (unlikely(ret < 0))
1169                         return -EIO;
1170
1171                 if (dp_sel & DP_SEL_DPRDY_)
1172                         return 0;
1173
1174                 usleep_range(40, 100);
1175         }
1176
1177         netdev_warn(dev->net, "%s timed out", __func__);
1178
1179         return -EIO;
1180 }
1181
1182 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
1183                                   u32 addr, u32 length, u32 *buf)
1184 {
1185         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1186         u32 dp_sel;
1187         int i, ret;
1188
1189         if (usb_autopm_get_interface(dev->intf) < 0)
1190                 return 0;
1191
1192         mutex_lock(&pdata->dataport_mutex);
1193
1194         ret = lan78xx_dataport_wait_not_busy(dev);
1195         if (ret < 0)
1196                 goto done;
1197
1198         ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
1199
1200         dp_sel &= ~DP_SEL_RSEL_MASK_;
1201         dp_sel |= ram_select;
1202         ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
1203
1204         for (i = 0; i < length; i++) {
1205                 ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
1206
1207                 ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
1208
1209                 ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
1210
1211                 ret = lan78xx_dataport_wait_not_busy(dev);
1212                 if (ret < 0)
1213                         goto done;
1214         }
1215
1216 done:
1217         mutex_unlock(&pdata->dataport_mutex);
1218         usb_autopm_put_interface(dev->intf);
1219
1220         return ret;
1221 }
1222
1223 static void lan78xx_set_addr_filter(struct lan78xx_priv *pdata,
1224                                     int index, u8 addr[ETH_ALEN])
1225 {
1226         u32 temp;
1227
1228         if ((pdata) && (index > 0) && (index < NUM_OF_MAF)) {
1229                 temp = addr[3];
1230                 temp = addr[2] | (temp << 8);
1231                 temp = addr[1] | (temp << 8);
1232                 temp = addr[0] | (temp << 8);
1233                 pdata->pfilter_table[index][1] = temp;
1234                 temp = addr[5];
1235                 temp = addr[4] | (temp << 8);
1236                 temp |= MAF_HI_VALID_ | MAF_HI_TYPE_DST_;
1237                 pdata->pfilter_table[index][0] = temp;
1238         }
1239 }
1240
1241 /* returns hash bit number for given MAC address */
1242 static inline u32 lan78xx_hash(char addr[ETH_ALEN])
1243 {
1244         return (ether_crc(ETH_ALEN, addr) >> 23) & 0x1ff;
1245 }
1246
1247 static void lan78xx_deferred_multicast_write(struct work_struct *param)
1248 {
1249         struct lan78xx_priv *pdata =
1250                         container_of(param, struct lan78xx_priv, set_multicast);
1251         struct lan78xx_net *dev = pdata->dev;
1252         int i;
1253
1254         netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
1255                   pdata->rfe_ctl);
1256
1257         lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
1258                                DP_SEL_VHF_HASH_LEN, pdata->mchash_table);
1259
1260         for (i = 1; i < NUM_OF_MAF; i++) {
1261                 lan78xx_write_reg(dev, MAF_HI(i), 0);
1262                 lan78xx_write_reg(dev, MAF_LO(i),
1263                                   pdata->pfilter_table[i][1]);
1264                 lan78xx_write_reg(dev, MAF_HI(i),
1265                                   pdata->pfilter_table[i][0]);
1266         }
1267
1268         lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1269 }
1270
1271 static void lan78xx_set_multicast(struct net_device *netdev)
1272 {
1273         struct lan78xx_net *dev = netdev_priv(netdev);
1274         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1275         unsigned long flags;
1276         int i;
1277
1278         spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
1279
1280         pdata->rfe_ctl &= ~(RFE_CTL_UCAST_EN_ | RFE_CTL_MCAST_EN_ |
1281                             RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
1282
1283         for (i = 0; i < DP_SEL_VHF_HASH_LEN; i++)
1284                 pdata->mchash_table[i] = 0;
1285
1286         /* pfilter_table[0] has own HW address */
1287         for (i = 1; i < NUM_OF_MAF; i++) {
1288                 pdata->pfilter_table[i][0] = 0;
1289                 pdata->pfilter_table[i][1] = 0;
1290         }
1291
1292         pdata->rfe_ctl |= RFE_CTL_BCAST_EN_;
1293
1294         if (dev->net->flags & IFF_PROMISC) {
1295                 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
1296                 pdata->rfe_ctl |= RFE_CTL_MCAST_EN_ | RFE_CTL_UCAST_EN_;
1297         } else {
1298                 if (dev->net->flags & IFF_ALLMULTI) {
1299                         netif_dbg(dev, drv, dev->net,
1300                                   "receive all multicast enabled");
1301                         pdata->rfe_ctl |= RFE_CTL_MCAST_EN_;
1302                 }
1303         }
1304
1305         if (netdev_mc_count(dev->net)) {
1306                 struct netdev_hw_addr *ha;
1307                 int i;
1308
1309                 netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
1310
1311                 pdata->rfe_ctl |= RFE_CTL_DA_PERFECT_;
1312
1313                 i = 1;
1314                 netdev_for_each_mc_addr(ha, netdev) {
1315                         /* set first 32 into Perfect Filter */
1316                         if (i < 33) {
1317                                 lan78xx_set_addr_filter(pdata, i, ha->addr);
1318                         } else {
1319                                 u32 bitnum = lan78xx_hash(ha->addr);
1320
1321                                 pdata->mchash_table[bitnum / 32] |=
1322                                                         (1 << (bitnum % 32));
1323                                 pdata->rfe_ctl |= RFE_CTL_MCAST_HASH_;
1324                         }
1325                         i++;
1326                 }
1327         }
1328
1329         spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
1330
1331         /* defer register writes to a sleepable context */
1332         schedule_work(&pdata->set_multicast);
1333 }
1334
1335 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1336                                       u16 lcladv, u16 rmtadv)
1337 {
1338         u32 flow = 0, fct_flow = 0;
1339         u8 cap;
1340
1341         if (dev->fc_autoneg)
1342                 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
1343         else
1344                 cap = dev->fc_request_control;
1345
1346         if (cap & FLOW_CTRL_TX)
1347                 flow |= (FLOW_CR_TX_FCEN_ | 0xFFFF);
1348
1349         if (cap & FLOW_CTRL_RX)
1350                 flow |= FLOW_CR_RX_FCEN_;
1351
1352         if (dev->udev->speed == USB_SPEED_SUPER)
1353                 fct_flow = FLOW_CTRL_THRESHOLD(FLOW_ON_SS, FLOW_OFF_SS);
1354         else if (dev->udev->speed == USB_SPEED_HIGH)
1355                 fct_flow = FLOW_CTRL_THRESHOLD(FLOW_ON_HS, FLOW_OFF_HS);
1356
1357         netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1358                   (cap & FLOW_CTRL_RX ? "enabled" : "disabled"),
1359                   (cap & FLOW_CTRL_TX ? "enabled" : "disabled"));
1360
1361         lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1362
1363         /* threshold value should be set before enabling flow */
1364         lan78xx_write_reg(dev, FLOW, flow);
1365
1366         return 0;
1367 }
1368
1369 static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev);
1370
1371 static int lan78xx_mac_reset(struct lan78xx_net *dev)
1372 {
1373         unsigned long start_time = jiffies;
1374         u32 val;
1375         int ret;
1376
1377         mutex_lock(&dev->phy_mutex);
1378
1379         /* Resetting the device while there is activity on the MDIO
1380          * bus can result in the MAC interface locking up and not
1381          * completing register access transactions.
1382          */
1383         ret = lan78xx_phy_wait_not_busy(dev);
1384         if (ret < 0)
1385                 goto done;
1386
1387         ret = lan78xx_read_reg(dev, MAC_CR, &val);
1388         if (ret < 0)
1389                 goto done;
1390
1391         val |= MAC_CR_RST_;
1392         ret = lan78xx_write_reg(dev, MAC_CR, val);
1393         if (ret < 0)
1394                 goto done;
1395
1396         /* Wait for the reset to complete before allowing any further
1397          * MAC register accesses otherwise the MAC may lock up.
1398          */
1399         do {
1400                 ret = lan78xx_read_reg(dev, MAC_CR, &val);
1401                 if (ret < 0)
1402                         goto done;
1403
1404                 if (!(val & MAC_CR_RST_)) {
1405                         ret = 0;
1406                         goto done;
1407                 }
1408         } while (!time_after(jiffies, start_time + HZ));
1409
1410         ret = -ETIMEDOUT;
1411 done:
1412         mutex_unlock(&dev->phy_mutex);
1413
1414         return ret;
1415 }
1416
1417 static int lan78xx_link_reset(struct lan78xx_net *dev)
1418 {
1419         struct phy_device *phydev = dev->net->phydev;
1420         struct ethtool_link_ksettings ecmd;
1421         int ladv, radv, ret, link;
1422         u32 buf;
1423
1424         /* clear LAN78xx interrupt status */
1425         ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1426         if (unlikely(ret < 0))
1427                 return ret;
1428
1429         mutex_lock(&phydev->lock);
1430         phy_read_status(phydev);
1431         link = phydev->link;
1432         mutex_unlock(&phydev->lock);
1433
1434         if (!link && dev->link_on) {
1435                 dev->link_on = false;
1436
1437                 /* reset MAC */
1438                 ret = lan78xx_mac_reset(dev);
1439                 if (ret < 0)
1440                         return ret;
1441
1442                 del_timer(&dev->stat_monitor);
1443         } else if (link && !dev->link_on) {
1444                 dev->link_on = true;
1445
1446                 phy_ethtool_ksettings_get(phydev, &ecmd);
1447
1448                 if (dev->udev->speed == USB_SPEED_SUPER) {
1449                         if (ecmd.base.speed == 1000) {
1450                                 /* disable U2 */
1451                                 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1452                                 if (ret < 0)
1453                                         return ret;
1454                                 buf &= ~USB_CFG1_DEV_U2_INIT_EN_;
1455                                 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1456                                 if (ret < 0)
1457                                         return ret;
1458                                 /* enable U1 */
1459                                 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1460                                 if (ret < 0)
1461                                         return ret;
1462                                 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1463                                 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1464                                 if (ret < 0)
1465                                         return ret;
1466                         } else {
1467                                 /* enable U1 & U2 */
1468                                 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1469                                 if (ret < 0)
1470                                         return ret;
1471                                 buf |= USB_CFG1_DEV_U2_INIT_EN_;
1472                                 buf |= USB_CFG1_DEV_U1_INIT_EN_;
1473                                 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1474                                 if (ret < 0)
1475                                         return ret;
1476                         }
1477                 }
1478
1479                 ladv = phy_read(phydev, MII_ADVERTISE);
1480                 if (ladv < 0)
1481                         return ladv;
1482
1483                 radv = phy_read(phydev, MII_LPA);
1484                 if (radv < 0)
1485                         return radv;
1486
1487                 netif_dbg(dev, link, dev->net,
1488                           "speed: %u duplex: %d anadv: 0x%04x anlpa: 0x%04x",
1489                           ecmd.base.speed, ecmd.base.duplex, ladv, radv);
1490
1491                 ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1492                                                  radv);
1493                 if (ret < 0)
1494                         return ret;
1495
1496                 if (!timer_pending(&dev->stat_monitor)) {
1497                         dev->delta = 1;
1498                         mod_timer(&dev->stat_monitor,
1499                                   jiffies + STAT_UPDATE_TIMER);
1500                 }
1501
1502                 lan78xx_rx_urb_submit_all(dev);
1503
1504                 napi_schedule(&dev->napi);
1505         }
1506
1507         return 0;
1508 }
1509
1510 /* some work can't be done in tasklets, so we use keventd
1511  *
1512  * NOTE:  annoying asymmetry:  if it's active, schedule_work() fails,
1513  * but tasklet_schedule() doesn't.      hope the failure is rare.
1514  */
1515 static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1516 {
1517         set_bit(work, &dev->flags);
1518         if (!schedule_delayed_work(&dev->wq, 0))
1519                 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1520 }
1521
1522 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1523 {
1524         u32 intdata;
1525
1526         if (urb->actual_length != 4) {
1527                 netdev_warn(dev->net,
1528                             "unexpected urb length %d", urb->actual_length);
1529                 return;
1530         }
1531
1532         intdata = get_unaligned_le32(urb->transfer_buffer);
1533
1534         if (intdata & INT_ENP_PHY_INT) {
1535                 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1536                 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1537
1538                 if (dev->domain_data.phyirq > 0)
1539                         generic_handle_irq_safe(dev->domain_data.phyirq);
1540         } else {
1541                 netdev_warn(dev->net,
1542                             "unexpected interrupt: 0x%08x\n", intdata);
1543         }
1544 }
1545
1546 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1547 {
1548         return MAX_EEPROM_SIZE;
1549 }
1550
1551 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1552                                       struct ethtool_eeprom *ee, u8 *data)
1553 {
1554         struct lan78xx_net *dev = netdev_priv(netdev);
1555         int ret;
1556
1557         ret = usb_autopm_get_interface(dev->intf);
1558         if (ret)
1559                 return ret;
1560
1561         ee->magic = LAN78XX_EEPROM_MAGIC;
1562
1563         ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1564
1565         usb_autopm_put_interface(dev->intf);
1566
1567         return ret;
1568 }
1569
1570 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1571                                       struct ethtool_eeprom *ee, u8 *data)
1572 {
1573         struct lan78xx_net *dev = netdev_priv(netdev);
1574         int ret;
1575
1576         ret = usb_autopm_get_interface(dev->intf);
1577         if (ret)
1578                 return ret;
1579
1580         /* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1581          * to load data from EEPROM
1582          */
1583         if (ee->magic == LAN78XX_EEPROM_MAGIC)
1584                 ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1585         else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1586                  (ee->offset == 0) &&
1587                  (ee->len == 512) &&
1588                  (data[0] == OTP_INDICATOR_1))
1589                 ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1590
1591         usb_autopm_put_interface(dev->intf);
1592
1593         return ret;
1594 }
1595
1596 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1597                                 u8 *data)
1598 {
1599         if (stringset == ETH_SS_STATS)
1600                 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1601 }
1602
1603 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1604 {
1605         if (sset == ETH_SS_STATS)
1606                 return ARRAY_SIZE(lan78xx_gstrings);
1607         else
1608                 return -EOPNOTSUPP;
1609 }
1610
1611 static void lan78xx_get_stats(struct net_device *netdev,
1612                               struct ethtool_stats *stats, u64 *data)
1613 {
1614         struct lan78xx_net *dev = netdev_priv(netdev);
1615
1616         lan78xx_update_stats(dev);
1617
1618         mutex_lock(&dev->stats.access_lock);
1619         memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1620         mutex_unlock(&dev->stats.access_lock);
1621 }
1622
1623 static void lan78xx_get_wol(struct net_device *netdev,
1624                             struct ethtool_wolinfo *wol)
1625 {
1626         struct lan78xx_net *dev = netdev_priv(netdev);
1627         int ret;
1628         u32 buf;
1629         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1630
1631         if (usb_autopm_get_interface(dev->intf) < 0)
1632                 return;
1633
1634         ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1635         if (unlikely(ret < 0)) {
1636                 wol->supported = 0;
1637                 wol->wolopts = 0;
1638         } else {
1639                 if (buf & USB_CFG_RMT_WKP_) {
1640                         wol->supported = WAKE_ALL;
1641                         wol->wolopts = pdata->wol;
1642                 } else {
1643                         wol->supported = 0;
1644                         wol->wolopts = 0;
1645                 }
1646         }
1647
1648         usb_autopm_put_interface(dev->intf);
1649 }
1650
1651 static int lan78xx_set_wol(struct net_device *netdev,
1652                            struct ethtool_wolinfo *wol)
1653 {
1654         struct lan78xx_net *dev = netdev_priv(netdev);
1655         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1656         int ret;
1657
1658         ret = usb_autopm_get_interface(dev->intf);
1659         if (ret < 0)
1660                 return ret;
1661
1662         if (wol->wolopts & ~WAKE_ALL)
1663                 return -EINVAL;
1664
1665         pdata->wol = wol->wolopts;
1666
1667         device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1668
1669         phy_ethtool_set_wol(netdev->phydev, wol);
1670
1671         usb_autopm_put_interface(dev->intf);
1672
1673         return ret;
1674 }
1675
1676 static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1677 {
1678         struct lan78xx_net *dev = netdev_priv(net);
1679         struct phy_device *phydev = net->phydev;
1680         int ret;
1681         u32 buf;
1682
1683         ret = usb_autopm_get_interface(dev->intf);
1684         if (ret < 0)
1685                 return ret;
1686
1687         ret = phy_ethtool_get_eee(phydev, edata);
1688         if (ret < 0)
1689                 goto exit;
1690
1691         ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1692         if (buf & MAC_CR_EEE_EN_) {
1693                 edata->eee_enabled = true;
1694                 edata->eee_active = !!(edata->advertised &
1695                                        edata->lp_advertised);
1696                 edata->tx_lpi_enabled = true;
1697                 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1698                 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1699                 edata->tx_lpi_timer = buf;
1700         } else {
1701                 edata->eee_enabled = false;
1702                 edata->eee_active = false;
1703                 edata->tx_lpi_enabled = false;
1704                 edata->tx_lpi_timer = 0;
1705         }
1706
1707         ret = 0;
1708 exit:
1709         usb_autopm_put_interface(dev->intf);
1710
1711         return ret;
1712 }
1713
1714 static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1715 {
1716         struct lan78xx_net *dev = netdev_priv(net);
1717         int ret;
1718         u32 buf;
1719
1720         ret = usb_autopm_get_interface(dev->intf);
1721         if (ret < 0)
1722                 return ret;
1723
1724         if (edata->eee_enabled) {
1725                 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1726                 buf |= MAC_CR_EEE_EN_;
1727                 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1728
1729                 phy_ethtool_set_eee(net->phydev, edata);
1730
1731                 buf = (u32)edata->tx_lpi_timer;
1732                 ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1733         } else {
1734                 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1735                 buf &= ~MAC_CR_EEE_EN_;
1736                 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1737         }
1738
1739         usb_autopm_put_interface(dev->intf);
1740
1741         return 0;
1742 }
1743
1744 static u32 lan78xx_get_link(struct net_device *net)
1745 {
1746         u32 link;
1747
1748         mutex_lock(&net->phydev->lock);
1749         phy_read_status(net->phydev);
1750         link = net->phydev->link;
1751         mutex_unlock(&net->phydev->lock);
1752
1753         return link;
1754 }
1755
1756 static void lan78xx_get_drvinfo(struct net_device *net,
1757                                 struct ethtool_drvinfo *info)
1758 {
1759         struct lan78xx_net *dev = netdev_priv(net);
1760
1761         strscpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1762         usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1763 }
1764
1765 static u32 lan78xx_get_msglevel(struct net_device *net)
1766 {
1767         struct lan78xx_net *dev = netdev_priv(net);
1768
1769         return dev->msg_enable;
1770 }
1771
1772 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1773 {
1774         struct lan78xx_net *dev = netdev_priv(net);
1775
1776         dev->msg_enable = level;
1777 }
1778
1779 static int lan78xx_get_link_ksettings(struct net_device *net,
1780                                       struct ethtool_link_ksettings *cmd)
1781 {
1782         struct lan78xx_net *dev = netdev_priv(net);
1783         struct phy_device *phydev = net->phydev;
1784         int ret;
1785
1786         ret = usb_autopm_get_interface(dev->intf);
1787         if (ret < 0)
1788                 return ret;
1789
1790         phy_ethtool_ksettings_get(phydev, cmd);
1791
1792         usb_autopm_put_interface(dev->intf);
1793
1794         return ret;
1795 }
1796
1797 static int lan78xx_set_link_ksettings(struct net_device *net,
1798                                       const struct ethtool_link_ksettings *cmd)
1799 {
1800         struct lan78xx_net *dev = netdev_priv(net);
1801         struct phy_device *phydev = net->phydev;
1802         int ret = 0;
1803         int temp;
1804
1805         ret = usb_autopm_get_interface(dev->intf);
1806         if (ret < 0)
1807                 return ret;
1808
1809         /* change speed & duplex */
1810         ret = phy_ethtool_ksettings_set(phydev, cmd);
1811
1812         if (!cmd->base.autoneg) {
1813                 /* force link down */
1814                 temp = phy_read(phydev, MII_BMCR);
1815                 phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);
1816                 mdelay(1);
1817                 phy_write(phydev, MII_BMCR, temp);
1818         }
1819
1820         usb_autopm_put_interface(dev->intf);
1821
1822         return ret;
1823 }
1824
1825 static void lan78xx_get_pause(struct net_device *net,
1826                               struct ethtool_pauseparam *pause)
1827 {
1828         struct lan78xx_net *dev = netdev_priv(net);
1829         struct phy_device *phydev = net->phydev;
1830         struct ethtool_link_ksettings ecmd;
1831
1832         phy_ethtool_ksettings_get(phydev, &ecmd);
1833
1834         pause->autoneg = dev->fc_autoneg;
1835
1836         if (dev->fc_request_control & FLOW_CTRL_TX)
1837                 pause->tx_pause = 1;
1838
1839         if (dev->fc_request_control & FLOW_CTRL_RX)
1840                 pause->rx_pause = 1;
1841 }
1842
1843 static int lan78xx_set_pause(struct net_device *net,
1844                              struct ethtool_pauseparam *pause)
1845 {
1846         struct lan78xx_net *dev = netdev_priv(net);
1847         struct phy_device *phydev = net->phydev;
1848         struct ethtool_link_ksettings ecmd;
1849         int ret;
1850
1851         phy_ethtool_ksettings_get(phydev, &ecmd);
1852
1853         if (pause->autoneg && !ecmd.base.autoneg) {
1854                 ret = -EINVAL;
1855                 goto exit;
1856         }
1857
1858         dev->fc_request_control = 0;
1859         if (pause->rx_pause)
1860                 dev->fc_request_control |= FLOW_CTRL_RX;
1861
1862         if (pause->tx_pause)
1863                 dev->fc_request_control |= FLOW_CTRL_TX;
1864
1865         if (ecmd.base.autoneg) {
1866                 __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
1867                 u32 mii_adv;
1868
1869                 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
1870                                    ecmd.link_modes.advertising);
1871                 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
1872                                    ecmd.link_modes.advertising);
1873                 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
1874                 mii_adv_to_linkmode_adv_t(fc, mii_adv);
1875                 linkmode_or(ecmd.link_modes.advertising, fc,
1876                             ecmd.link_modes.advertising);
1877
1878                 phy_ethtool_ksettings_set(phydev, &ecmd);
1879         }
1880
1881         dev->fc_autoneg = pause->autoneg;
1882
1883         ret = 0;
1884 exit:
1885         return ret;
1886 }
1887
1888 static int lan78xx_get_regs_len(struct net_device *netdev)
1889 {
1890         if (!netdev->phydev)
1891                 return (sizeof(lan78xx_regs));
1892         else
1893                 return (sizeof(lan78xx_regs) + PHY_REG_SIZE);
1894 }
1895
1896 static void
1897 lan78xx_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
1898                  void *buf)
1899 {
1900         u32 *data = buf;
1901         int i, j;
1902         struct lan78xx_net *dev = netdev_priv(netdev);
1903
1904         /* Read Device/MAC registers */
1905         for (i = 0; i < ARRAY_SIZE(lan78xx_regs); i++)
1906                 lan78xx_read_reg(dev, lan78xx_regs[i], &data[i]);
1907
1908         if (!netdev->phydev)
1909                 return;
1910
1911         /* Read PHY registers */
1912         for (j = 0; j < 32; i++, j++)
1913                 data[i] = phy_read(netdev->phydev, j);
1914 }
1915
1916 static const struct ethtool_ops lan78xx_ethtool_ops = {
1917         .get_link       = lan78xx_get_link,
1918         .nway_reset     = phy_ethtool_nway_reset,
1919         .get_drvinfo    = lan78xx_get_drvinfo,
1920         .get_msglevel   = lan78xx_get_msglevel,
1921         .set_msglevel   = lan78xx_set_msglevel,
1922         .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1923         .get_eeprom     = lan78xx_ethtool_get_eeprom,
1924         .set_eeprom     = lan78xx_ethtool_set_eeprom,
1925         .get_ethtool_stats = lan78xx_get_stats,
1926         .get_sset_count = lan78xx_get_sset_count,
1927         .get_strings    = lan78xx_get_strings,
1928         .get_wol        = lan78xx_get_wol,
1929         .set_wol        = lan78xx_set_wol,
1930         .get_ts_info    = ethtool_op_get_ts_info,
1931         .get_eee        = lan78xx_get_eee,
1932         .set_eee        = lan78xx_set_eee,
1933         .get_pauseparam = lan78xx_get_pause,
1934         .set_pauseparam = lan78xx_set_pause,
1935         .get_link_ksettings = lan78xx_get_link_ksettings,
1936         .set_link_ksettings = lan78xx_set_link_ksettings,
1937         .get_regs_len   = lan78xx_get_regs_len,
1938         .get_regs       = lan78xx_get_regs,
1939 };
1940
1941 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1942 {
1943         u32 addr_lo, addr_hi;
1944         u8 addr[6];
1945
1946         lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1947         lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1948
1949         addr[0] = addr_lo & 0xFF;
1950         addr[1] = (addr_lo >> 8) & 0xFF;
1951         addr[2] = (addr_lo >> 16) & 0xFF;
1952         addr[3] = (addr_lo >> 24) & 0xFF;
1953         addr[4] = addr_hi & 0xFF;
1954         addr[5] = (addr_hi >> 8) & 0xFF;
1955
1956         if (!is_valid_ether_addr(addr)) {
1957                 if (!eth_platform_get_mac_address(&dev->udev->dev, addr)) {
1958                         /* valid address present in Device Tree */
1959                         netif_dbg(dev, ifup, dev->net,
1960                                   "MAC address read from Device Tree");
1961                 } else if (((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET,
1962                                                  ETH_ALEN, addr) == 0) ||
1963                             (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET,
1964                                               ETH_ALEN, addr) == 0)) &&
1965                            is_valid_ether_addr(addr)) {
1966                         /* eeprom values are valid so use them */
1967                         netif_dbg(dev, ifup, dev->net,
1968                                   "MAC address read from EEPROM");
1969                 } else {
1970                         /* generate random MAC */
1971                         eth_random_addr(addr);
1972                         netif_dbg(dev, ifup, dev->net,
1973                                   "MAC address set to random addr");
1974                 }
1975
1976                 addr_lo = addr[0] | (addr[1] << 8) |
1977                           (addr[2] << 16) | (addr[3] << 24);
1978                 addr_hi = addr[4] | (addr[5] << 8);
1979
1980                 lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1981                 lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1982         }
1983
1984         lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1985         lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1986
1987         eth_hw_addr_set(dev->net, addr);
1988 }
1989
1990 /* MDIO read and write wrappers for phylib */
1991 static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
1992 {
1993         struct lan78xx_net *dev = bus->priv;
1994         u32 val, addr;
1995         int ret;
1996
1997         ret = usb_autopm_get_interface(dev->intf);
1998         if (ret < 0)
1999                 return ret;
2000
2001         mutex_lock(&dev->phy_mutex);
2002
2003         /* confirm MII not busy */
2004         ret = lan78xx_phy_wait_not_busy(dev);
2005         if (ret < 0)
2006                 goto done;
2007
2008         /* set the address, index & direction (read from PHY) */
2009         addr = mii_access(phy_id, idx, MII_READ);
2010         ret = lan78xx_write_reg(dev, MII_ACC, addr);
2011
2012         ret = lan78xx_phy_wait_not_busy(dev);
2013         if (ret < 0)
2014                 goto done;
2015
2016         ret = lan78xx_read_reg(dev, MII_DATA, &val);
2017
2018         ret = (int)(val & 0xFFFF);
2019
2020 done:
2021         mutex_unlock(&dev->phy_mutex);
2022         usb_autopm_put_interface(dev->intf);
2023
2024         return ret;
2025 }
2026
2027 static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
2028                                  u16 regval)
2029 {
2030         struct lan78xx_net *dev = bus->priv;
2031         u32 val, addr;
2032         int ret;
2033
2034         ret = usb_autopm_get_interface(dev->intf);
2035         if (ret < 0)
2036                 return ret;
2037
2038         mutex_lock(&dev->phy_mutex);
2039
2040         /* confirm MII not busy */
2041         ret = lan78xx_phy_wait_not_busy(dev);
2042         if (ret < 0)
2043                 goto done;
2044
2045         val = (u32)regval;
2046         ret = lan78xx_write_reg(dev, MII_DATA, val);
2047
2048         /* set the address, index & direction (write to PHY) */
2049         addr = mii_access(phy_id, idx, MII_WRITE);
2050         ret = lan78xx_write_reg(dev, MII_ACC, addr);
2051
2052         ret = lan78xx_phy_wait_not_busy(dev);
2053         if (ret < 0)
2054                 goto done;
2055
2056 done:
2057         mutex_unlock(&dev->phy_mutex);
2058         usb_autopm_put_interface(dev->intf);
2059         return 0;
2060 }
2061
2062 static int lan78xx_mdio_init(struct lan78xx_net *dev)
2063 {
2064         struct device_node *node;
2065         int ret;
2066
2067         dev->mdiobus = mdiobus_alloc();
2068         if (!dev->mdiobus) {
2069                 netdev_err(dev->net, "can't allocate MDIO bus\n");
2070                 return -ENOMEM;
2071         }
2072
2073         dev->mdiobus->priv = (void *)dev;
2074         dev->mdiobus->read = lan78xx_mdiobus_read;
2075         dev->mdiobus->write = lan78xx_mdiobus_write;
2076         dev->mdiobus->name = "lan78xx-mdiobus";
2077         dev->mdiobus->parent = &dev->udev->dev;
2078
2079         snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
2080                  dev->udev->bus->busnum, dev->udev->devnum);
2081
2082         switch (dev->chipid) {
2083         case ID_REV_CHIP_ID_7800_:
2084         case ID_REV_CHIP_ID_7850_:
2085                 /* set to internal PHY id */
2086                 dev->mdiobus->phy_mask = ~(1 << 1);
2087                 break;
2088         case ID_REV_CHIP_ID_7801_:
2089                 /* scan thru PHYAD[2..0] */
2090                 dev->mdiobus->phy_mask = ~(0xFF);
2091                 break;
2092         }
2093
2094         node = of_get_child_by_name(dev->udev->dev.of_node, "mdio");
2095         ret = of_mdiobus_register(dev->mdiobus, node);
2096         of_node_put(node);
2097         if (ret) {
2098                 netdev_err(dev->net, "can't register MDIO bus\n");
2099                 goto exit1;
2100         }
2101
2102         netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
2103         return 0;
2104 exit1:
2105         mdiobus_free(dev->mdiobus);
2106         return ret;
2107 }
2108
2109 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
2110 {
2111         mdiobus_unregister(dev->mdiobus);
2112         mdiobus_free(dev->mdiobus);
2113 }
2114
2115 static void lan78xx_link_status_change(struct net_device *net)
2116 {
2117         struct phy_device *phydev = net->phydev;
2118
2119         phy_print_status(phydev);
2120 }
2121
2122 static int irq_map(struct irq_domain *d, unsigned int irq,
2123                    irq_hw_number_t hwirq)
2124 {
2125         struct irq_domain_data *data = d->host_data;
2126
2127         irq_set_chip_data(irq, data);
2128         irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
2129         irq_set_noprobe(irq);
2130
2131         return 0;
2132 }
2133
2134 static void irq_unmap(struct irq_domain *d, unsigned int irq)
2135 {
2136         irq_set_chip_and_handler(irq, NULL, NULL);
2137         irq_set_chip_data(irq, NULL);
2138 }
2139
2140 static const struct irq_domain_ops chip_domain_ops = {
2141         .map    = irq_map,
2142         .unmap  = irq_unmap,
2143 };
2144
2145 static void lan78xx_irq_mask(struct irq_data *irqd)
2146 {
2147         struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2148
2149         data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
2150 }
2151
2152 static void lan78xx_irq_unmask(struct irq_data *irqd)
2153 {
2154         struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2155
2156         data->irqenable |= BIT(irqd_to_hwirq(irqd));
2157 }
2158
2159 static void lan78xx_irq_bus_lock(struct irq_data *irqd)
2160 {
2161         struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2162
2163         mutex_lock(&data->irq_lock);
2164 }
2165
2166 static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
2167 {
2168         struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
2169         struct lan78xx_net *dev =
2170                         container_of(data, struct lan78xx_net, domain_data);
2171         u32 buf;
2172
2173         /* call register access here because irq_bus_lock & irq_bus_sync_unlock
2174          * are only two callbacks executed in non-atomic contex.
2175          */
2176         lan78xx_read_reg(dev, INT_EP_CTL, &buf);
2177         if (buf != data->irqenable)
2178                 lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
2179
2180         mutex_unlock(&data->irq_lock);
2181 }
2182
2183 static struct irq_chip lan78xx_irqchip = {
2184         .name                   = "lan78xx-irqs",
2185         .irq_mask               = lan78xx_irq_mask,
2186         .irq_unmask             = lan78xx_irq_unmask,
2187         .irq_bus_lock           = lan78xx_irq_bus_lock,
2188         .irq_bus_sync_unlock    = lan78xx_irq_bus_sync_unlock,
2189 };
2190
2191 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
2192 {
2193         struct device_node *of_node;
2194         struct irq_domain *irqdomain;
2195         unsigned int irqmap = 0;
2196         u32 buf;
2197         int ret = 0;
2198
2199         of_node = dev->udev->dev.parent->of_node;
2200
2201         mutex_init(&dev->domain_data.irq_lock);
2202
2203         lan78xx_read_reg(dev, INT_EP_CTL, &buf);
2204         dev->domain_data.irqenable = buf;
2205
2206         dev->domain_data.irqchip = &lan78xx_irqchip;
2207         dev->domain_data.irq_handler = handle_simple_irq;
2208
2209         irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
2210                                           &chip_domain_ops, &dev->domain_data);
2211         if (irqdomain) {
2212                 /* create mapping for PHY interrupt */
2213                 irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
2214                 if (!irqmap) {
2215                         irq_domain_remove(irqdomain);
2216
2217                         irqdomain = NULL;
2218                         ret = -EINVAL;
2219                 }
2220         } else {
2221                 ret = -EINVAL;
2222         }
2223
2224         dev->domain_data.irqdomain = irqdomain;
2225         dev->domain_data.phyirq = irqmap;
2226
2227         return ret;
2228 }
2229
2230 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
2231 {
2232         if (dev->domain_data.phyirq > 0) {
2233                 irq_dispose_mapping(dev->domain_data.phyirq);
2234
2235                 if (dev->domain_data.irqdomain)
2236                         irq_domain_remove(dev->domain_data.irqdomain);
2237         }
2238         dev->domain_data.phyirq = 0;
2239         dev->domain_data.irqdomain = NULL;
2240 }
2241
2242 static int lan8835_fixup(struct phy_device *phydev)
2243 {
2244         int buf;
2245         struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2246
2247         /* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
2248         buf = phy_read_mmd(phydev, MDIO_MMD_PCS, 0x8010);
2249         buf &= ~0x1800;
2250         buf |= 0x0800;
2251         phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);
2252
2253         /* RGMII MAC TXC Delay Enable */
2254         lan78xx_write_reg(dev, MAC_RGMII_ID,
2255                           MAC_RGMII_ID_TXC_DELAY_EN_);
2256
2257         /* RGMII TX DLL Tune Adjust */
2258         lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2259
2260         dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
2261
2262         return 1;
2263 }
2264
2265 static int ksz9031rnx_fixup(struct phy_device *phydev)
2266 {
2267         struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2268
2269         /* Micrel9301RNX PHY configuration */
2270         /* RGMII Control Signal Pad Skew */
2271         phy_write_mmd(phydev, MDIO_MMD_WIS, 4, 0x0077);
2272         /* RGMII RX Data Pad Skew */
2273         phy_write_mmd(phydev, MDIO_MMD_WIS, 5, 0x7777);
2274         /* RGMII RX Clock Pad Skew */
2275         phy_write_mmd(phydev, MDIO_MMD_WIS, 8, 0x1FF);
2276
2277         dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
2278
2279         return 1;
2280 }
2281
2282 static struct phy_device *lan7801_phy_init(struct lan78xx_net *dev)
2283 {
2284         u32 buf;
2285         int ret;
2286         struct fixed_phy_status fphy_status = {
2287                 .link = 1,
2288                 .speed = SPEED_1000,
2289                 .duplex = DUPLEX_FULL,
2290         };
2291         struct phy_device *phydev;
2292
2293         phydev = phy_find_first(dev->mdiobus);
2294         if (!phydev) {
2295                 netdev_dbg(dev->net, "PHY Not Found!! Registering Fixed PHY\n");
2296                 phydev = fixed_phy_register(PHY_POLL, &fphy_status, NULL);
2297                 if (IS_ERR(phydev)) {
2298                         netdev_err(dev->net, "No PHY/fixed_PHY found\n");
2299                         return NULL;
2300                 }
2301                 netdev_dbg(dev->net, "Registered FIXED PHY\n");
2302                 dev->interface = PHY_INTERFACE_MODE_RGMII;
2303                 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2304                                         MAC_RGMII_ID_TXC_DELAY_EN_);
2305                 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2306                 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2307                 buf |= HW_CFG_CLK125_EN_;
2308                 buf |= HW_CFG_REFCLK25_EN_;
2309                 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2310         } else {
2311                 if (!phydev->drv) {
2312                         netdev_err(dev->net, "no PHY driver found\n");
2313                         return NULL;
2314                 }
2315                 dev->interface = PHY_INTERFACE_MODE_RGMII;
2316                 /* external PHY fixup for KSZ9031RNX */
2317                 ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,
2318                                                  ksz9031rnx_fixup);
2319                 if (ret < 0) {
2320                         netdev_err(dev->net, "Failed to register fixup for PHY_KSZ9031RNX\n");
2321                         return NULL;
2322                 }
2323                 /* external PHY fixup for LAN8835 */
2324                 ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,
2325                                                  lan8835_fixup);
2326                 if (ret < 0) {
2327                         netdev_err(dev->net, "Failed to register fixup for PHY_LAN8835\n");
2328                         return NULL;
2329                 }
2330                 /* add more external PHY fixup here if needed */
2331
2332                 phydev->is_internal = false;
2333         }
2334         return phydev;
2335 }
2336
2337 static int lan78xx_phy_init(struct lan78xx_net *dev)
2338 {
2339         __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
2340         int ret;
2341         u32 mii_adv;
2342         struct phy_device *phydev;
2343
2344         switch (dev->chipid) {
2345         case ID_REV_CHIP_ID_7801_:
2346                 phydev = lan7801_phy_init(dev);
2347                 if (!phydev) {
2348                         netdev_err(dev->net, "lan7801: PHY Init Failed");
2349                         return -EIO;
2350                 }
2351                 break;
2352
2353         case ID_REV_CHIP_ID_7800_:
2354         case ID_REV_CHIP_ID_7850_:
2355                 phydev = phy_find_first(dev->mdiobus);
2356                 if (!phydev) {
2357                         netdev_err(dev->net, "no PHY found\n");
2358                         return -EIO;
2359                 }
2360                 phydev->is_internal = true;
2361                 dev->interface = PHY_INTERFACE_MODE_GMII;
2362                 break;
2363
2364         default:
2365                 netdev_err(dev->net, "Unknown CHIP ID found\n");
2366                 return -EIO;
2367         }
2368
2369         /* if phyirq is not set, use polling mode in phylib */
2370         if (dev->domain_data.phyirq > 0)
2371                 phydev->irq = dev->domain_data.phyirq;
2372         else
2373                 phydev->irq = PHY_POLL;
2374         netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2375
2376         /* set to AUTOMDIX */
2377         phydev->mdix = ETH_TP_MDI_AUTO;
2378
2379         ret = phy_connect_direct(dev->net, phydev,
2380                                  lan78xx_link_status_change,
2381                                  dev->interface);
2382         if (ret) {
2383                 netdev_err(dev->net, "can't attach PHY to %s\n",
2384                            dev->mdiobus->id);
2385                 if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2386                         if (phy_is_pseudo_fixed_link(phydev)) {
2387                                 fixed_phy_unregister(phydev);
2388                         } else {
2389                                 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX,
2390                                                              0xfffffff0);
2391                                 phy_unregister_fixup_for_uid(PHY_LAN8835,
2392                                                              0xfffffff0);
2393                         }
2394                 }
2395                 return -EIO;
2396         }
2397
2398         /* MAC doesn't support 1000T Half */
2399         phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
2400
2401         /* support both flow controls */
2402         dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2403         linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2404                            phydev->advertising);
2405         linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2406                            phydev->advertising);
2407         mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2408         mii_adv_to_linkmode_adv_t(fc, mii_adv);
2409         linkmode_or(phydev->advertising, fc, phydev->advertising);
2410
2411         if (phydev->mdio.dev.of_node) {
2412                 u32 reg;
2413                 int len;
2414
2415                 len = of_property_count_elems_of_size(phydev->mdio.dev.of_node,
2416                                                       "microchip,led-modes",
2417                                                       sizeof(u32));
2418                 if (len >= 0) {
2419                         /* Ensure the appropriate LEDs are enabled */
2420                         lan78xx_read_reg(dev, HW_CFG, &reg);
2421                         reg &= ~(HW_CFG_LED0_EN_ |
2422                                  HW_CFG_LED1_EN_ |
2423                                  HW_CFG_LED2_EN_ |
2424                                  HW_CFG_LED3_EN_);
2425                         reg |= (len > 0) * HW_CFG_LED0_EN_ |
2426                                 (len > 1) * HW_CFG_LED1_EN_ |
2427                                 (len > 2) * HW_CFG_LED2_EN_ |
2428                                 (len > 3) * HW_CFG_LED3_EN_;
2429                         lan78xx_write_reg(dev, HW_CFG, reg);
2430                 }
2431         }
2432
2433         genphy_config_aneg(phydev);
2434
2435         dev->fc_autoneg = phydev->autoneg;
2436
2437         return 0;
2438 }
2439
2440 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2441 {
2442         u32 buf;
2443         bool rxenabled;
2444
2445         lan78xx_read_reg(dev, MAC_RX, &buf);
2446
2447         rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2448
2449         if (rxenabled) {
2450                 buf &= ~MAC_RX_RXEN_;
2451                 lan78xx_write_reg(dev, MAC_RX, buf);
2452         }
2453
2454         /* add 4 to size for FCS */
2455         buf &= ~MAC_RX_MAX_SIZE_MASK_;
2456         buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2457
2458         lan78xx_write_reg(dev, MAC_RX, buf);
2459
2460         if (rxenabled) {
2461                 buf |= MAC_RX_RXEN_;
2462                 lan78xx_write_reg(dev, MAC_RX, buf);
2463         }
2464
2465         return 0;
2466 }
2467
2468 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2469 {
2470         struct sk_buff *skb;
2471         unsigned long flags;
2472         int count = 0;
2473
2474         spin_lock_irqsave(&q->lock, flags);
2475         while (!skb_queue_empty(q)) {
2476                 struct skb_data *entry;
2477                 struct urb *urb;
2478                 int ret;
2479
2480                 skb_queue_walk(q, skb) {
2481                         entry = (struct skb_data *)skb->cb;
2482                         if (entry->state != unlink_start)
2483                                 goto found;
2484                 }
2485                 break;
2486 found:
2487                 entry->state = unlink_start;
2488                 urb = entry->urb;
2489
2490                 /* Get reference count of the URB to avoid it to be
2491                  * freed during usb_unlink_urb, which may trigger
2492                  * use-after-free problem inside usb_unlink_urb since
2493                  * usb_unlink_urb is always racing with .complete
2494                  * handler(include defer_bh).
2495                  */
2496                 usb_get_urb(urb);
2497                 spin_unlock_irqrestore(&q->lock, flags);
2498                 /* during some PM-driven resume scenarios,
2499                  * these (async) unlinks complete immediately
2500                  */
2501                 ret = usb_unlink_urb(urb);
2502                 if (ret != -EINPROGRESS && ret != 0)
2503                         netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2504                 else
2505                         count++;
2506                 usb_put_urb(urb);
2507                 spin_lock_irqsave(&q->lock, flags);
2508         }
2509         spin_unlock_irqrestore(&q->lock, flags);
2510         return count;
2511 }
2512
2513 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2514 {
2515         struct lan78xx_net *dev = netdev_priv(netdev);
2516         int max_frame_len = RX_MAX_FRAME_LEN(new_mtu);
2517         int ret;
2518
2519         /* no second zero-length packet read wanted after mtu-sized packets */
2520         if ((max_frame_len % dev->maxpacket) == 0)
2521                 return -EDOM;
2522
2523         ret = usb_autopm_get_interface(dev->intf);
2524         if (ret < 0)
2525                 return ret;
2526
2527         ret = lan78xx_set_rx_max_frame_length(dev, max_frame_len);
2528         if (!ret)
2529                 netdev->mtu = new_mtu;
2530
2531         usb_autopm_put_interface(dev->intf);
2532
2533         return ret;
2534 }
2535
2536 static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2537 {
2538         struct lan78xx_net *dev = netdev_priv(netdev);
2539         struct sockaddr *addr = p;
2540         u32 addr_lo, addr_hi;
2541
2542         if (netif_running(netdev))
2543                 return -EBUSY;
2544
2545         if (!is_valid_ether_addr(addr->sa_data))
2546                 return -EADDRNOTAVAIL;
2547
2548         eth_hw_addr_set(netdev, addr->sa_data);
2549
2550         addr_lo = netdev->dev_addr[0] |
2551                   netdev->dev_addr[1] << 8 |
2552                   netdev->dev_addr[2] << 16 |
2553                   netdev->dev_addr[3] << 24;
2554         addr_hi = netdev->dev_addr[4] |
2555                   netdev->dev_addr[5] << 8;
2556
2557         lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2558         lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2559
2560         /* Added to support MAC address changes */
2561         lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2562         lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2563
2564         return 0;
2565 }
2566
2567 /* Enable or disable Rx checksum offload engine */
2568 static int lan78xx_set_features(struct net_device *netdev,
2569                                 netdev_features_t features)
2570 {
2571         struct lan78xx_net *dev = netdev_priv(netdev);
2572         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2573         unsigned long flags;
2574
2575         spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2576
2577         if (features & NETIF_F_RXCSUM) {
2578                 pdata->rfe_ctl |= RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_;
2579                 pdata->rfe_ctl |= RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_;
2580         } else {
2581                 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2582                 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2583         }
2584
2585         if (features & NETIF_F_HW_VLAN_CTAG_RX)
2586                 pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_;
2587         else
2588                 pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;
2589
2590         if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
2591                 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2592         else
2593                 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2594
2595         spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2596
2597         lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2598
2599         return 0;
2600 }
2601
2602 static void lan78xx_deferred_vlan_write(struct work_struct *param)
2603 {
2604         struct lan78xx_priv *pdata =
2605                         container_of(param, struct lan78xx_priv, set_vlan);
2606         struct lan78xx_net *dev = pdata->dev;
2607
2608         lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2609                                DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2610 }
2611
2612 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2613                                    __be16 proto, u16 vid)
2614 {
2615         struct lan78xx_net *dev = netdev_priv(netdev);
2616         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2617         u16 vid_bit_index;
2618         u16 vid_dword_index;
2619
2620         vid_dword_index = (vid >> 5) & 0x7F;
2621         vid_bit_index = vid & 0x1F;
2622
2623         pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2624
2625         /* defer register writes to a sleepable context */
2626         schedule_work(&pdata->set_vlan);
2627
2628         return 0;
2629 }
2630
2631 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2632                                     __be16 proto, u16 vid)
2633 {
2634         struct lan78xx_net *dev = netdev_priv(netdev);
2635         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2636         u16 vid_bit_index;
2637         u16 vid_dword_index;
2638
2639         vid_dword_index = (vid >> 5) & 0x7F;
2640         vid_bit_index = vid & 0x1F;
2641
2642         pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2643
2644         /* defer register writes to a sleepable context */
2645         schedule_work(&pdata->set_vlan);
2646
2647         return 0;
2648 }
2649
2650 static void lan78xx_init_ltm(struct lan78xx_net *dev)
2651 {
2652         int ret;
2653         u32 buf;
2654         u32 regs[6] = { 0 };
2655
2656         ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2657         if (buf & USB_CFG1_LTM_ENABLE_) {
2658                 u8 temp[2];
2659                 /* Get values from EEPROM first */
2660                 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2661                         if (temp[0] == 24) {
2662                                 ret = lan78xx_read_raw_eeprom(dev,
2663                                                               temp[1] * 2,
2664                                                               24,
2665                                                               (u8 *)regs);
2666                                 if (ret < 0)
2667                                         return;
2668                         }
2669                 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2670                         if (temp[0] == 24) {
2671                                 ret = lan78xx_read_raw_otp(dev,
2672                                                            temp[1] * 2,
2673                                                            24,
2674                                                            (u8 *)regs);
2675                                 if (ret < 0)
2676                                         return;
2677                         }
2678                 }
2679         }
2680
2681         lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2682         lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2683         lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2684         lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2685         lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2686         lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2687 }
2688
2689 static int lan78xx_urb_config_init(struct lan78xx_net *dev)
2690 {
2691         int result = 0;
2692
2693         switch (dev->udev->speed) {
2694         case USB_SPEED_SUPER:
2695                 dev->rx_urb_size = RX_SS_URB_SIZE;
2696                 dev->tx_urb_size = TX_SS_URB_SIZE;
2697                 dev->n_rx_urbs = RX_SS_URB_NUM;
2698                 dev->n_tx_urbs = TX_SS_URB_NUM;
2699                 dev->bulk_in_delay = SS_BULK_IN_DELAY;
2700                 dev->burst_cap = SS_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2701                 break;
2702         case USB_SPEED_HIGH:
2703                 dev->rx_urb_size = RX_HS_URB_SIZE;
2704                 dev->tx_urb_size = TX_HS_URB_SIZE;
2705                 dev->n_rx_urbs = RX_HS_URB_NUM;
2706                 dev->n_tx_urbs = TX_HS_URB_NUM;
2707                 dev->bulk_in_delay = HS_BULK_IN_DELAY;
2708                 dev->burst_cap = HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2709                 break;
2710         case USB_SPEED_FULL:
2711                 dev->rx_urb_size = RX_FS_URB_SIZE;
2712                 dev->tx_urb_size = TX_FS_URB_SIZE;
2713                 dev->n_rx_urbs = RX_FS_URB_NUM;
2714                 dev->n_tx_urbs = TX_FS_URB_NUM;
2715                 dev->bulk_in_delay = FS_BULK_IN_DELAY;
2716                 dev->burst_cap = FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2717                 break;
2718         default:
2719                 netdev_warn(dev->net, "USB bus speed not supported\n");
2720                 result = -EIO;
2721                 break;
2722         }
2723
2724         return result;
2725 }
2726
2727 static int lan78xx_start_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enable)
2728 {
2729         return lan78xx_update_reg(dev, reg, hw_enable, hw_enable);
2730 }
2731
2732 static int lan78xx_stop_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enabled,
2733                            u32 hw_disabled)
2734 {
2735         unsigned long timeout;
2736         bool stopped = true;
2737         int ret;
2738         u32 buf;
2739
2740         /* Stop the h/w block (if not already stopped) */
2741
2742         ret = lan78xx_read_reg(dev, reg, &buf);
2743         if (ret < 0)
2744                 return ret;
2745
2746         if (buf & hw_enabled) {
2747                 buf &= ~hw_enabled;
2748
2749                 ret = lan78xx_write_reg(dev, reg, buf);
2750                 if (ret < 0)
2751                         return ret;
2752
2753                 stopped = false;
2754                 timeout = jiffies + HW_DISABLE_TIMEOUT;
2755                 do  {
2756                         ret = lan78xx_read_reg(dev, reg, &buf);
2757                         if (ret < 0)
2758                                 return ret;
2759
2760                         if (buf & hw_disabled)
2761                                 stopped = true;
2762                         else
2763                                 msleep(HW_DISABLE_DELAY_MS);
2764                 } while (!stopped && !time_after(jiffies, timeout));
2765         }
2766
2767         ret = stopped ? 0 : -ETIME;
2768
2769         return ret;
2770 }
2771
2772 static int lan78xx_flush_fifo(struct lan78xx_net *dev, u32 reg, u32 fifo_flush)
2773 {
2774         return lan78xx_update_reg(dev, reg, fifo_flush, fifo_flush);
2775 }
2776
2777 static int lan78xx_start_tx_path(struct lan78xx_net *dev)
2778 {
2779         int ret;
2780
2781         netif_dbg(dev, drv, dev->net, "start tx path");
2782
2783         /* Start the MAC transmitter */
2784
2785         ret = lan78xx_start_hw(dev, MAC_TX, MAC_TX_TXEN_);
2786         if (ret < 0)
2787                 return ret;
2788
2789         /* Start the Tx FIFO */
2790
2791         ret = lan78xx_start_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_);
2792         if (ret < 0)
2793                 return ret;
2794
2795         return 0;
2796 }
2797
2798 static int lan78xx_stop_tx_path(struct lan78xx_net *dev)
2799 {
2800         int ret;
2801
2802         netif_dbg(dev, drv, dev->net, "stop tx path");
2803
2804         /* Stop the Tx FIFO */
2805
2806         ret = lan78xx_stop_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_, FCT_TX_CTL_DIS_);
2807         if (ret < 0)
2808                 return ret;
2809
2810         /* Stop the MAC transmitter */
2811
2812         ret = lan78xx_stop_hw(dev, MAC_TX, MAC_TX_TXEN_, MAC_TX_TXD_);
2813         if (ret < 0)
2814                 return ret;
2815
2816         return 0;
2817 }
2818
2819 /* The caller must ensure the Tx path is stopped before calling
2820  * lan78xx_flush_tx_fifo().
2821  */
2822 static int lan78xx_flush_tx_fifo(struct lan78xx_net *dev)
2823 {
2824         return lan78xx_flush_fifo(dev, FCT_TX_CTL, FCT_TX_CTL_RST_);
2825 }
2826
2827 static int lan78xx_start_rx_path(struct lan78xx_net *dev)
2828 {
2829         int ret;
2830
2831         netif_dbg(dev, drv, dev->net, "start rx path");
2832
2833         /* Start the Rx FIFO */
2834
2835         ret = lan78xx_start_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_);
2836         if (ret < 0)
2837                 return ret;
2838
2839         /* Start the MAC receiver*/
2840
2841         ret = lan78xx_start_hw(dev, MAC_RX, MAC_RX_RXEN_);
2842         if (ret < 0)
2843                 return ret;
2844
2845         return 0;
2846 }
2847
2848 static int lan78xx_stop_rx_path(struct lan78xx_net *dev)
2849 {
2850         int ret;
2851
2852         netif_dbg(dev, drv, dev->net, "stop rx path");
2853
2854         /* Stop the MAC receiver */
2855
2856         ret = lan78xx_stop_hw(dev, MAC_RX, MAC_RX_RXEN_, MAC_RX_RXD_);
2857         if (ret < 0)
2858                 return ret;
2859
2860         /* Stop the Rx FIFO */
2861
2862         ret = lan78xx_stop_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_, FCT_RX_CTL_DIS_);
2863         if (ret < 0)
2864                 return ret;
2865
2866         return 0;
2867 }
2868
2869 /* The caller must ensure the Rx path is stopped before calling
2870  * lan78xx_flush_rx_fifo().
2871  */
2872 static int lan78xx_flush_rx_fifo(struct lan78xx_net *dev)
2873 {
2874         return lan78xx_flush_fifo(dev, FCT_RX_CTL, FCT_RX_CTL_RST_);
2875 }
2876
2877 static int lan78xx_reset(struct lan78xx_net *dev)
2878 {
2879         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2880         unsigned long timeout;
2881         int ret;
2882         u32 buf;
2883         u8 sig;
2884
2885         ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2886         if (ret < 0)
2887                 return ret;
2888
2889         buf |= HW_CFG_LRST_;
2890
2891         ret = lan78xx_write_reg(dev, HW_CFG, buf);
2892         if (ret < 0)
2893                 return ret;
2894
2895         timeout = jiffies + HZ;
2896         do {
2897                 mdelay(1);
2898                 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2899                 if (ret < 0)
2900                         return ret;
2901
2902                 if (time_after(jiffies, timeout)) {
2903                         netdev_warn(dev->net,
2904                                     "timeout on completion of LiteReset");
2905                         ret = -ETIMEDOUT;
2906                         return ret;
2907                 }
2908         } while (buf & HW_CFG_LRST_);
2909
2910         lan78xx_init_mac_address(dev);
2911
2912         /* save DEVID for later usage */
2913         ret = lan78xx_read_reg(dev, ID_REV, &buf);
2914         if (ret < 0)
2915                 return ret;
2916
2917         dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2918         dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2919
2920         /* Respond to the IN token with a NAK */
2921         ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2922         if (ret < 0)
2923                 return ret;
2924
2925         buf |= USB_CFG_BIR_;
2926
2927         ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2928         if (ret < 0)
2929                 return ret;
2930
2931         /* Init LTM */
2932         lan78xx_init_ltm(dev);
2933
2934         ret = lan78xx_write_reg(dev, BURST_CAP, dev->burst_cap);
2935         if (ret < 0)
2936                 return ret;
2937
2938         ret = lan78xx_write_reg(dev, BULK_IN_DLY, dev->bulk_in_delay);
2939         if (ret < 0)
2940                 return ret;
2941
2942         ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2943         if (ret < 0)
2944                 return ret;
2945
2946         buf |= HW_CFG_MEF_;
2947
2948         ret = lan78xx_write_reg(dev, HW_CFG, buf);
2949         if (ret < 0)
2950                 return ret;
2951
2952         ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2953         if (ret < 0)
2954                 return ret;
2955
2956         buf |= USB_CFG_BCE_;
2957
2958         ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2959         if (ret < 0)
2960                 return ret;
2961
2962         /* set FIFO sizes */
2963         buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2964
2965         ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2966         if (ret < 0)
2967                 return ret;
2968
2969         buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2970
2971         ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2972         if (ret < 0)
2973                 return ret;
2974
2975         ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2976         if (ret < 0)
2977                 return ret;
2978
2979         ret = lan78xx_write_reg(dev, FLOW, 0);
2980         if (ret < 0)
2981                 return ret;
2982
2983         ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2984         if (ret < 0)
2985                 return ret;
2986
2987         /* Don't need rfe_ctl_lock during initialisation */
2988         ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2989         if (ret < 0)
2990                 return ret;
2991
2992         pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2993
2994         ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2995         if (ret < 0)
2996                 return ret;
2997
2998         /* Enable or disable checksum offload engines */
2999         ret = lan78xx_set_features(dev->net, dev->net->features);
3000         if (ret < 0)
3001                 return ret;
3002
3003         lan78xx_set_multicast(dev->net);
3004
3005         /* reset PHY */
3006         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3007         if (ret < 0)
3008                 return ret;
3009
3010         buf |= PMT_CTL_PHY_RST_;
3011
3012         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3013         if (ret < 0)
3014                 return ret;
3015
3016         timeout = jiffies + HZ;
3017         do {
3018                 mdelay(1);
3019                 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3020                 if (ret < 0)
3021                         return ret;
3022
3023                 if (time_after(jiffies, timeout)) {
3024                         netdev_warn(dev->net, "timeout waiting for PHY Reset");
3025                         ret = -ETIMEDOUT;
3026                         return ret;
3027                 }
3028         } while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
3029
3030         ret = lan78xx_read_reg(dev, MAC_CR, &buf);
3031         if (ret < 0)
3032                 return ret;
3033
3034         /* LAN7801 only has RGMII mode */
3035         if (dev->chipid == ID_REV_CHIP_ID_7801_)
3036                 buf &= ~MAC_CR_GMII_EN_;
3037
3038         if (dev->chipid == ID_REV_CHIP_ID_7800_) {
3039                 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
3040                 if (!ret && sig != EEPROM_INDICATOR) {
3041                         /* Implies there is no external eeprom. Set mac speed */
3042                         netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
3043                         buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
3044                 }
3045         }
3046         ret = lan78xx_write_reg(dev, MAC_CR, buf);
3047         if (ret < 0)
3048                 return ret;
3049
3050         ret = lan78xx_set_rx_max_frame_length(dev,
3051                                               RX_MAX_FRAME_LEN(dev->net->mtu));
3052
3053         return ret;
3054 }
3055
3056 static void lan78xx_init_stats(struct lan78xx_net *dev)
3057 {
3058         u32 *p;
3059         int i;
3060
3061         /* initialize for stats update
3062          * some counters are 20bits and some are 32bits
3063          */
3064         p = (u32 *)&dev->stats.rollover_max;
3065         for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
3066                 p[i] = 0xFFFFF;
3067
3068         dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
3069         dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
3070         dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
3071         dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
3072         dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
3073         dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
3074         dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
3075         dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
3076         dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
3077         dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
3078
3079         set_bit(EVENT_STAT_UPDATE, &dev->flags);
3080 }
3081
3082 static int lan78xx_open(struct net_device *net)
3083 {
3084         struct lan78xx_net *dev = netdev_priv(net);
3085         int ret;
3086
3087         netif_dbg(dev, ifup, dev->net, "open device");
3088
3089         ret = usb_autopm_get_interface(dev->intf);
3090         if (ret < 0)
3091                 return ret;
3092
3093         mutex_lock(&dev->dev_mutex);
3094
3095         phy_start(net->phydev);
3096
3097         netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
3098
3099         /* for Link Check */
3100         if (dev->urb_intr) {
3101                 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
3102                 if (ret < 0) {
3103                         netif_err(dev, ifup, dev->net,
3104                                   "intr submit %d\n", ret);
3105                         goto done;
3106                 }
3107         }
3108
3109         ret = lan78xx_flush_rx_fifo(dev);
3110         if (ret < 0)
3111                 goto done;
3112         ret = lan78xx_flush_tx_fifo(dev);
3113         if (ret < 0)
3114                 goto done;
3115
3116         ret = lan78xx_start_tx_path(dev);
3117         if (ret < 0)
3118                 goto done;
3119         ret = lan78xx_start_rx_path(dev);
3120         if (ret < 0)
3121                 goto done;
3122
3123         lan78xx_init_stats(dev);
3124
3125         set_bit(EVENT_DEV_OPEN, &dev->flags);
3126
3127         netif_start_queue(net);
3128
3129         dev->link_on = false;
3130
3131         napi_enable(&dev->napi);
3132
3133         lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
3134 done:
3135         mutex_unlock(&dev->dev_mutex);
3136
3137         usb_autopm_put_interface(dev->intf);
3138
3139         return ret;
3140 }
3141
3142 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
3143 {
3144         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
3145         DECLARE_WAITQUEUE(wait, current);
3146         int temp;
3147
3148         /* ensure there are no more active urbs */
3149         add_wait_queue(&unlink_wakeup, &wait);
3150         set_current_state(TASK_UNINTERRUPTIBLE);
3151         dev->wait = &unlink_wakeup;
3152         temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
3153
3154         /* maybe wait for deletions to finish. */
3155         while (!skb_queue_empty(&dev->rxq) ||
3156                !skb_queue_empty(&dev->txq)) {
3157                 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
3158                 set_current_state(TASK_UNINTERRUPTIBLE);
3159                 netif_dbg(dev, ifdown, dev->net,
3160                           "waited for %d urb completions", temp);
3161         }
3162         set_current_state(TASK_RUNNING);
3163         dev->wait = NULL;
3164         remove_wait_queue(&unlink_wakeup, &wait);
3165
3166         /* empty Rx done, Rx overflow and Tx pend queues
3167          */
3168         while (!skb_queue_empty(&dev->rxq_done)) {
3169                 struct sk_buff *skb = skb_dequeue(&dev->rxq_done);
3170
3171                 lan78xx_release_rx_buf(dev, skb);
3172         }
3173
3174         skb_queue_purge(&dev->rxq_overflow);
3175         skb_queue_purge(&dev->txq_pend);
3176 }
3177
3178 static int lan78xx_stop(struct net_device *net)
3179 {
3180         struct lan78xx_net *dev = netdev_priv(net);
3181
3182         netif_dbg(dev, ifup, dev->net, "stop device");
3183
3184         mutex_lock(&dev->dev_mutex);
3185
3186         if (timer_pending(&dev->stat_monitor))
3187                 del_timer_sync(&dev->stat_monitor);
3188
3189         clear_bit(EVENT_DEV_OPEN, &dev->flags);
3190         netif_stop_queue(net);
3191         napi_disable(&dev->napi);
3192
3193         lan78xx_terminate_urbs(dev);
3194
3195         netif_info(dev, ifdown, dev->net,
3196                    "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
3197                    net->stats.rx_packets, net->stats.tx_packets,
3198                    net->stats.rx_errors, net->stats.tx_errors);
3199
3200         /* ignore errors that occur stopping the Tx and Rx data paths */
3201         lan78xx_stop_tx_path(dev);
3202         lan78xx_stop_rx_path(dev);
3203
3204         if (net->phydev)
3205                 phy_stop(net->phydev);
3206
3207         usb_kill_urb(dev->urb_intr);
3208
3209         /* deferred work (task, timer, softirq) must also stop.
3210          * can't flush_scheduled_work() until we drop rtnl (later),
3211          * else workers could deadlock; so make workers a NOP.
3212          */
3213         clear_bit(EVENT_TX_HALT, &dev->flags);
3214         clear_bit(EVENT_RX_HALT, &dev->flags);
3215         clear_bit(EVENT_LINK_RESET, &dev->flags);
3216         clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3217
3218         cancel_delayed_work_sync(&dev->wq);
3219
3220         usb_autopm_put_interface(dev->intf);
3221
3222         mutex_unlock(&dev->dev_mutex);
3223
3224         return 0;
3225 }
3226
3227 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
3228                                struct sk_buff_head *list, enum skb_state state)
3229 {
3230         unsigned long flags;
3231         enum skb_state old_state;
3232         struct skb_data *entry = (struct skb_data *)skb->cb;
3233
3234         spin_lock_irqsave(&list->lock, flags);
3235         old_state = entry->state;
3236         entry->state = state;
3237
3238         __skb_unlink(skb, list);
3239         spin_unlock(&list->lock);
3240         spin_lock(&dev->rxq_done.lock);
3241
3242         __skb_queue_tail(&dev->rxq_done, skb);
3243         if (skb_queue_len(&dev->rxq_done) == 1)
3244                 napi_schedule(&dev->napi);
3245
3246         spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
3247
3248         return old_state;
3249 }
3250
3251 static void tx_complete(struct urb *urb)
3252 {
3253         struct sk_buff *skb = (struct sk_buff *)urb->context;
3254         struct skb_data *entry = (struct skb_data *)skb->cb;
3255         struct lan78xx_net *dev = entry->dev;
3256
3257         if (urb->status == 0) {
3258                 dev->net->stats.tx_packets += entry->num_of_packet;
3259                 dev->net->stats.tx_bytes += entry->length;
3260         } else {
3261                 dev->net->stats.tx_errors += entry->num_of_packet;
3262
3263                 switch (urb->status) {
3264                 case -EPIPE:
3265                         lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3266                         break;
3267
3268                 /* software-driven interface shutdown */
3269                 case -ECONNRESET:
3270                 case -ESHUTDOWN:
3271                         netif_dbg(dev, tx_err, dev->net,
3272                                   "tx err interface gone %d\n",
3273                                   entry->urb->status);
3274                         break;
3275
3276                 case -EPROTO:
3277                 case -ETIME:
3278                 case -EILSEQ:
3279                         netif_stop_queue(dev->net);
3280                         netif_dbg(dev, tx_err, dev->net,
3281                                   "tx err queue stopped %d\n",
3282                                   entry->urb->status);
3283                         break;
3284                 default:
3285                         netif_dbg(dev, tx_err, dev->net,
3286                                   "unknown tx err %d\n",
3287                                   entry->urb->status);
3288                         break;
3289                 }
3290         }
3291
3292         usb_autopm_put_interface_async(dev->intf);
3293
3294         skb_unlink(skb, &dev->txq);
3295
3296         lan78xx_release_tx_buf(dev, skb);
3297
3298         /* Re-schedule NAPI if Tx data pending but no URBs in progress.
3299          */
3300         if (skb_queue_empty(&dev->txq) &&
3301             !skb_queue_empty(&dev->txq_pend))
3302                 napi_schedule(&dev->napi);
3303 }
3304
3305 static void lan78xx_queue_skb(struct sk_buff_head *list,
3306                               struct sk_buff *newsk, enum skb_state state)
3307 {
3308         struct skb_data *entry = (struct skb_data *)newsk->cb;
3309
3310         __skb_queue_tail(list, newsk);
3311         entry->state = state;
3312 }
3313
3314 static unsigned int lan78xx_tx_urb_space(struct lan78xx_net *dev)
3315 {
3316         return skb_queue_len(&dev->txq_free) * dev->tx_urb_size;
3317 }
3318
3319 static unsigned int lan78xx_tx_pend_data_len(struct lan78xx_net *dev)
3320 {
3321         return dev->tx_pend_data_len;
3322 }
3323
3324 static void lan78xx_tx_pend_skb_add(struct lan78xx_net *dev,
3325                                     struct sk_buff *skb,
3326                                     unsigned int *tx_pend_data_len)
3327 {
3328         unsigned long flags;
3329
3330         spin_lock_irqsave(&dev->txq_pend.lock, flags);
3331
3332         __skb_queue_tail(&dev->txq_pend, skb);
3333
3334         dev->tx_pend_data_len += skb->len;
3335         *tx_pend_data_len = dev->tx_pend_data_len;
3336
3337         spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3338 }
3339
3340 static void lan78xx_tx_pend_skb_head_add(struct lan78xx_net *dev,
3341                                          struct sk_buff *skb,
3342                                          unsigned int *tx_pend_data_len)
3343 {
3344         unsigned long flags;
3345
3346         spin_lock_irqsave(&dev->txq_pend.lock, flags);
3347
3348         __skb_queue_head(&dev->txq_pend, skb);
3349
3350         dev->tx_pend_data_len += skb->len;
3351         *tx_pend_data_len = dev->tx_pend_data_len;
3352
3353         spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3354 }
3355
3356 static void lan78xx_tx_pend_skb_get(struct lan78xx_net *dev,
3357                                     struct sk_buff **skb,
3358                                     unsigned int *tx_pend_data_len)
3359 {
3360         unsigned long flags;
3361
3362         spin_lock_irqsave(&dev->txq_pend.lock, flags);
3363
3364         *skb = __skb_dequeue(&dev->txq_pend);
3365         if (*skb)
3366                 dev->tx_pend_data_len -= (*skb)->len;
3367         *tx_pend_data_len = dev->tx_pend_data_len;
3368
3369         spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3370 }
3371
3372 static netdev_tx_t
3373 lan78xx_start_xmit(struct sk_buff *skb, struct net_device *net)
3374 {
3375         struct lan78xx_net *dev = netdev_priv(net);
3376         unsigned int tx_pend_data_len;
3377
3378         if (test_bit(EVENT_DEV_ASLEEP, &dev->flags))
3379                 schedule_delayed_work(&dev->wq, 0);
3380
3381         skb_tx_timestamp(skb);
3382
3383         lan78xx_tx_pend_skb_add(dev, skb, &tx_pend_data_len);
3384
3385         /* Set up a Tx URB if none is in progress */
3386
3387         if (skb_queue_empty(&dev->txq))
3388                 napi_schedule(&dev->napi);
3389
3390         /* Stop stack Tx queue if we have enough data to fill
3391          * all the free Tx URBs.
3392          */
3393         if (tx_pend_data_len > lan78xx_tx_urb_space(dev)) {
3394                 netif_stop_queue(net);
3395
3396                 netif_dbg(dev, hw, dev->net, "tx data len: %u, urb space %u",
3397                           tx_pend_data_len, lan78xx_tx_urb_space(dev));
3398
3399                 /* Kick off transmission of pending data */
3400
3401                 if (!skb_queue_empty(&dev->txq_free))
3402                         napi_schedule(&dev->napi);
3403         }
3404
3405         return NETDEV_TX_OK;
3406 }
3407
3408 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
3409 {
3410         struct lan78xx_priv *pdata = NULL;
3411         int ret;
3412         int i;
3413
3414         dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
3415
3416         pdata = (struct lan78xx_priv *)(dev->data[0]);
3417         if (!pdata) {
3418                 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
3419                 return -ENOMEM;
3420         }
3421
3422         pdata->dev = dev;
3423
3424         spin_lock_init(&pdata->rfe_ctl_lock);
3425         mutex_init(&pdata->dataport_mutex);
3426
3427         INIT_WORK(&pdata->set_multicast, lan78xx_deferred_multicast_write);
3428
3429         for (i = 0; i < DP_SEL_VHF_VLAN_LEN; i++)
3430                 pdata->vlan_table[i] = 0;
3431
3432         INIT_WORK(&pdata->set_vlan, lan78xx_deferred_vlan_write);
3433
3434         dev->net->features = 0;
3435
3436         if (DEFAULT_TX_CSUM_ENABLE)
3437                 dev->net->features |= NETIF_F_HW_CSUM;
3438
3439         if (DEFAULT_RX_CSUM_ENABLE)
3440                 dev->net->features |= NETIF_F_RXCSUM;
3441
3442         if (DEFAULT_TSO_CSUM_ENABLE)
3443                 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
3444
3445         if (DEFAULT_VLAN_RX_OFFLOAD)
3446                 dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;
3447
3448         if (DEFAULT_VLAN_FILTER_ENABLE)
3449                 dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
3450
3451         dev->net->hw_features = dev->net->features;
3452
3453         ret = lan78xx_setup_irq_domain(dev);
3454         if (ret < 0) {
3455                 netdev_warn(dev->net,
3456                             "lan78xx_setup_irq_domain() failed : %d", ret);
3457                 goto out1;
3458         }
3459
3460         /* Init all registers */
3461         ret = lan78xx_reset(dev);
3462         if (ret) {
3463                 netdev_warn(dev->net, "Registers INIT FAILED....");
3464                 goto out2;
3465         }
3466
3467         ret = lan78xx_mdio_init(dev);
3468         if (ret) {
3469                 netdev_warn(dev->net, "MDIO INIT FAILED.....");
3470                 goto out2;
3471         }
3472
3473         dev->net->flags |= IFF_MULTICAST;
3474
3475         pdata->wol = WAKE_MAGIC;
3476
3477         return ret;
3478
3479 out2:
3480         lan78xx_remove_irq_domain(dev);
3481
3482 out1:
3483         netdev_warn(dev->net, "Bind routine FAILED");
3484         cancel_work_sync(&pdata->set_multicast);
3485         cancel_work_sync(&pdata->set_vlan);
3486         kfree(pdata);
3487         return ret;
3488 }
3489
3490 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
3491 {
3492         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3493
3494         lan78xx_remove_irq_domain(dev);
3495
3496         lan78xx_remove_mdio(dev);
3497
3498         if (pdata) {
3499                 cancel_work_sync(&pdata->set_multicast);
3500                 cancel_work_sync(&pdata->set_vlan);
3501                 netif_dbg(dev, ifdown, dev->net, "free pdata");
3502                 kfree(pdata);
3503                 pdata = NULL;
3504                 dev->data[0] = 0;
3505         }
3506 }
3507
3508 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
3509                                     struct sk_buff *skb,
3510                                     u32 rx_cmd_a, u32 rx_cmd_b)
3511 {
3512         /* HW Checksum offload appears to be flawed if used when not stripping
3513          * VLAN headers. Drop back to S/W checksums under these conditions.
3514          */
3515         if (!(dev->net->features & NETIF_F_RXCSUM) ||
3516             unlikely(rx_cmd_a & RX_CMD_A_ICSM_) ||
3517             ((rx_cmd_a & RX_CMD_A_FVTG_) &&
3518              !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {
3519                 skb->ip_summed = CHECKSUM_NONE;
3520         } else {
3521                 skb->csum = ntohs((u16)(rx_cmd_b >> RX_CMD_B_CSUM_SHIFT_));
3522                 skb->ip_summed = CHECKSUM_COMPLETE;
3523         }
3524 }
3525
3526 static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,
3527                                     struct sk_buff *skb,
3528                                     u32 rx_cmd_a, u32 rx_cmd_b)
3529 {
3530         if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&
3531             (rx_cmd_a & RX_CMD_A_FVTG_))
3532                 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
3533                                        (rx_cmd_b & 0xffff));
3534 }
3535
3536 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
3537 {
3538         dev->net->stats.rx_packets++;
3539         dev->net->stats.rx_bytes += skb->len;
3540
3541         skb->protocol = eth_type_trans(skb, dev->net);
3542
3543         netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
3544                   skb->len + sizeof(struct ethhdr), skb->protocol);
3545         memset(skb->cb, 0, sizeof(struct skb_data));
3546
3547         if (skb_defer_rx_timestamp(skb))
3548                 return;
3549
3550         napi_gro_receive(&dev->napi, skb);
3551 }
3552
3553 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb,
3554                       int budget, int *work_done)
3555 {
3556         if (skb->len < RX_SKB_MIN_LEN)
3557                 return 0;
3558
3559         /* Extract frames from the URB buffer and pass each one to
3560          * the stack in a new NAPI SKB.
3561          */
3562         while (skb->len > 0) {
3563                 u32 rx_cmd_a, rx_cmd_b, align_count, size;
3564                 u16 rx_cmd_c;
3565                 unsigned char *packet;
3566
3567                 rx_cmd_a = get_unaligned_le32(skb->data);
3568                 skb_pull(skb, sizeof(rx_cmd_a));
3569
3570                 rx_cmd_b = get_unaligned_le32(skb->data);
3571                 skb_pull(skb, sizeof(rx_cmd_b));
3572
3573                 rx_cmd_c = get_unaligned_le16(skb->data);
3574                 skb_pull(skb, sizeof(rx_cmd_c));
3575
3576                 packet = skb->data;
3577
3578                 /* get the packet length */
3579                 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
3580                 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
3581
3582                 if (unlikely(size > skb->len)) {
3583                         netif_dbg(dev, rx_err, dev->net,
3584                                   "size err rx_cmd_a=0x%08x\n",
3585                                   rx_cmd_a);
3586                         return 0;
3587                 }
3588
3589                 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
3590                         netif_dbg(dev, rx_err, dev->net,
3591                                   "Error rx_cmd_a=0x%08x", rx_cmd_a);
3592                 } else {
3593                         u32 frame_len;
3594                         struct sk_buff *skb2;
3595
3596                         if (unlikely(size < ETH_FCS_LEN)) {
3597                                 netif_dbg(dev, rx_err, dev->net,
3598                                           "size err rx_cmd_a=0x%08x\n",
3599                                           rx_cmd_a);
3600                                 return 0;
3601                         }
3602
3603                         frame_len = size - ETH_FCS_LEN;
3604
3605                         skb2 = napi_alloc_skb(&dev->napi, frame_len);
3606                         if (!skb2)
3607                                 return 0;
3608
3609                         memcpy(skb2->data, packet, frame_len);
3610
3611                         skb_put(skb2, frame_len);
3612
3613                         lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3614                         lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3615
3616                         /* Processing of the URB buffer must complete once
3617                          * it has started. If the NAPI work budget is exhausted
3618                          * while frames remain they are added to the overflow
3619                          * queue for delivery in the next NAPI polling cycle.
3620                          */
3621                         if (*work_done < budget) {
3622                                 lan78xx_skb_return(dev, skb2);
3623                                 ++(*work_done);
3624                         } else {
3625                                 skb_queue_tail(&dev->rxq_overflow, skb2);
3626                         }
3627                 }
3628
3629                 skb_pull(skb, size);
3630
3631                 /* skip padding bytes before the next frame starts */
3632                 if (skb->len)
3633                         skb_pull(skb, align_count);
3634         }
3635
3636         return 1;
3637 }
3638
3639 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb,
3640                               int budget, int *work_done)
3641 {
3642         if (!lan78xx_rx(dev, skb, budget, work_done)) {
3643                 netif_dbg(dev, rx_err, dev->net, "drop\n");
3644                 dev->net->stats.rx_errors++;
3645         }
3646 }
3647
3648 static void rx_complete(struct urb *urb)
3649 {
3650         struct sk_buff  *skb = (struct sk_buff *)urb->context;
3651         struct skb_data *entry = (struct skb_data *)skb->cb;
3652         struct lan78xx_net *dev = entry->dev;
3653         int urb_status = urb->status;
3654         enum skb_state state;
3655
3656         netif_dbg(dev, rx_status, dev->net,
3657                   "rx done: status %d", urb->status);
3658
3659         skb_put(skb, urb->actual_length);
3660         state = rx_done;
3661
3662         if (urb != entry->urb)
3663                 netif_warn(dev, rx_err, dev->net, "URB pointer mismatch");
3664
3665         switch (urb_status) {
3666         case 0:
3667                 if (skb->len < RX_SKB_MIN_LEN) {
3668                         state = rx_cleanup;
3669                         dev->net->stats.rx_errors++;
3670                         dev->net->stats.rx_length_errors++;
3671                         netif_dbg(dev, rx_err, dev->net,
3672                                   "rx length %d\n", skb->len);
3673                 }
3674                 usb_mark_last_busy(dev->udev);
3675                 break;
3676         case -EPIPE:
3677                 dev->net->stats.rx_errors++;
3678                 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3679                 fallthrough;
3680         case -ECONNRESET:                               /* async unlink */
3681         case -ESHUTDOWN:                                /* hardware gone */
3682                 netif_dbg(dev, ifdown, dev->net,
3683                           "rx shutdown, code %d\n", urb_status);
3684                 state = rx_cleanup;
3685                 break;
3686         case -EPROTO:
3687         case -ETIME:
3688         case -EILSEQ:
3689                 dev->net->stats.rx_errors++;
3690                 state = rx_cleanup;
3691                 break;
3692
3693         /* data overrun ... flush fifo? */
3694         case -EOVERFLOW:
3695                 dev->net->stats.rx_over_errors++;
3696                 fallthrough;
3697
3698         default:
3699                 state = rx_cleanup;
3700                 dev->net->stats.rx_errors++;
3701                 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3702                 break;
3703         }
3704
3705         state = defer_bh(dev, skb, &dev->rxq, state);
3706 }
3707
3708 static int rx_submit(struct lan78xx_net *dev, struct sk_buff *skb, gfp_t flags)
3709 {
3710         struct skb_data *entry = (struct skb_data *)skb->cb;
3711         size_t size = dev->rx_urb_size;
3712         struct urb *urb = entry->urb;
3713         unsigned long lockflags;
3714         int ret = 0;
3715
3716         usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3717                           skb->data, size, rx_complete, skb);
3718
3719         spin_lock_irqsave(&dev->rxq.lock, lockflags);
3720
3721         if (netif_device_present(dev->net) &&
3722             netif_running(dev->net) &&
3723             !test_bit(EVENT_RX_HALT, &dev->flags) &&
3724             !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3725                 ret = usb_submit_urb(urb, flags);
3726                 switch (ret) {
3727                 case 0:
3728                         lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3729                         break;
3730                 case -EPIPE:
3731                         lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3732                         break;
3733                 case -ENODEV:
3734                 case -ENOENT:
3735                         netif_dbg(dev, ifdown, dev->net, "device gone\n");
3736                         netif_device_detach(dev->net);
3737                         break;
3738                 case -EHOSTUNREACH:
3739                         ret = -ENOLINK;
3740                         napi_schedule(&dev->napi);
3741                         break;
3742                 default:
3743                         netif_dbg(dev, rx_err, dev->net,
3744                                   "rx submit, %d\n", ret);
3745                         napi_schedule(&dev->napi);
3746                         break;
3747                 }
3748         } else {
3749                 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3750                 ret = -ENOLINK;
3751         }
3752         spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3753
3754         if (ret)
3755                 lan78xx_release_rx_buf(dev, skb);
3756
3757         return ret;
3758 }
3759
3760 static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev)
3761 {
3762         struct sk_buff *rx_buf;
3763
3764         /* Ensure the maximum number of Rx URBs is submitted
3765          */
3766         while ((rx_buf = lan78xx_get_rx_buf(dev)) != NULL) {
3767                 if (rx_submit(dev, rx_buf, GFP_ATOMIC) != 0)
3768                         break;
3769         }
3770 }
3771
3772 static void lan78xx_rx_urb_resubmit(struct lan78xx_net *dev,
3773                                     struct sk_buff *rx_buf)
3774 {
3775         /* reset SKB data pointers */
3776
3777         rx_buf->data = rx_buf->head;
3778         skb_reset_tail_pointer(rx_buf);
3779         rx_buf->len = 0;
3780         rx_buf->data_len = 0;
3781
3782         rx_submit(dev, rx_buf, GFP_ATOMIC);
3783 }
3784
3785 static void lan78xx_fill_tx_cmd_words(struct sk_buff *skb, u8 *buffer)
3786 {
3787         u32 tx_cmd_a;
3788         u32 tx_cmd_b;
3789
3790         tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
3791
3792         if (skb->ip_summed == CHECKSUM_PARTIAL)
3793                 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
3794
3795         tx_cmd_b = 0;
3796         if (skb_is_gso(skb)) {
3797                 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
3798
3799                 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
3800
3801                 tx_cmd_a |= TX_CMD_A_LSO_;
3802         }
3803
3804         if (skb_vlan_tag_present(skb)) {
3805                 tx_cmd_a |= TX_CMD_A_IVTG_;
3806                 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
3807         }
3808
3809         put_unaligned_le32(tx_cmd_a, buffer);
3810         put_unaligned_le32(tx_cmd_b, buffer + 4);
3811 }
3812
3813 static struct skb_data *lan78xx_tx_buf_fill(struct lan78xx_net *dev,
3814                                             struct sk_buff *tx_buf)
3815 {
3816         struct skb_data *entry = (struct skb_data *)tx_buf->cb;
3817         int remain = dev->tx_urb_size;
3818         u8 *tx_data = tx_buf->data;
3819         u32 urb_len = 0;
3820
3821         entry->num_of_packet = 0;
3822         entry->length = 0;
3823
3824         /* Work through the pending SKBs and copy the data of each SKB into
3825          * the URB buffer if there room for all the SKB data.
3826          *
3827          * There must be at least DST+SRC+TYPE in the SKB (with padding enabled)
3828          */
3829         while (remain >= TX_SKB_MIN_LEN) {
3830                 unsigned int pending_bytes;
3831                 unsigned int align_bytes;
3832                 struct sk_buff *skb;
3833                 unsigned int len;
3834
3835                 lan78xx_tx_pend_skb_get(dev, &skb, &pending_bytes);
3836
3837                 if (!skb)
3838                         break;
3839
3840                 align_bytes = (TX_ALIGNMENT - (urb_len % TX_ALIGNMENT)) %
3841                               TX_ALIGNMENT;
3842                 len = align_bytes + TX_CMD_LEN + skb->len;
3843                 if (len > remain) {
3844                         lan78xx_tx_pend_skb_head_add(dev, skb, &pending_bytes);
3845                         break;
3846                 }
3847
3848                 tx_data += align_bytes;
3849
3850                 lan78xx_fill_tx_cmd_words(skb, tx_data);
3851                 tx_data += TX_CMD_LEN;
3852
3853                 len = skb->len;
3854                 if (skb_copy_bits(skb, 0, tx_data, len) < 0) {
3855                         struct net_device_stats *stats = &dev->net->stats;
3856
3857                         stats->tx_dropped++;
3858                         dev_kfree_skb_any(skb);
3859                         tx_data -= TX_CMD_LEN;
3860                         continue;
3861                 }
3862
3863                 tx_data += len;
3864                 entry->length += len;
3865                 entry->num_of_packet += skb_shinfo(skb)->gso_segs ?: 1;
3866
3867                 dev_kfree_skb_any(skb);
3868
3869                 urb_len = (u32)(tx_data - (u8 *)tx_buf->data);
3870
3871                 remain = dev->tx_urb_size - urb_len;
3872         }
3873
3874         skb_put(tx_buf, urb_len);
3875
3876         return entry;
3877 }
3878
3879 static void lan78xx_tx_bh(struct lan78xx_net *dev)
3880 {
3881         int ret;
3882
3883         /* Start the stack Tx queue if it was stopped
3884          */
3885         netif_tx_lock(dev->net);
3886         if (netif_queue_stopped(dev->net)) {
3887                 if (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev))
3888                         netif_wake_queue(dev->net);
3889         }
3890         netif_tx_unlock(dev->net);
3891
3892         /* Go through the Tx pending queue and set up URBs to transfer
3893          * the data to the device. Stop if no more pending data or URBs,
3894          * or if an error occurs when a URB is submitted.
3895          */
3896         do {
3897                 struct skb_data *entry;
3898                 struct sk_buff *tx_buf;
3899                 unsigned long flags;
3900
3901                 if (skb_queue_empty(&dev->txq_pend))
3902                         break;
3903
3904                 tx_buf = lan78xx_get_tx_buf(dev);
3905                 if (!tx_buf)
3906                         break;
3907
3908                 entry = lan78xx_tx_buf_fill(dev, tx_buf);
3909
3910                 spin_lock_irqsave(&dev->txq.lock, flags);
3911                 ret = usb_autopm_get_interface_async(dev->intf);
3912                 if (ret < 0) {
3913                         spin_unlock_irqrestore(&dev->txq.lock, flags);
3914                         goto out;
3915                 }
3916
3917                 usb_fill_bulk_urb(entry->urb, dev->udev, dev->pipe_out,
3918                                   tx_buf->data, tx_buf->len, tx_complete,
3919                                   tx_buf);
3920
3921                 if (tx_buf->len % dev->maxpacket == 0) {
3922                         /* send USB_ZERO_PACKET */
3923                         entry->urb->transfer_flags |= URB_ZERO_PACKET;
3924                 }
3925
3926 #ifdef CONFIG_PM
3927                 /* if device is asleep stop outgoing packet processing */
3928                 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3929                         usb_anchor_urb(entry->urb, &dev->deferred);
3930                         netif_stop_queue(dev->net);
3931                         spin_unlock_irqrestore(&dev->txq.lock, flags);
3932                         netdev_dbg(dev->net,
3933                                    "Delaying transmission for resumption\n");
3934                         return;
3935                 }
3936 #endif
3937                 ret = usb_submit_urb(entry->urb, GFP_ATOMIC);
3938                 switch (ret) {
3939                 case 0:
3940                         netif_trans_update(dev->net);
3941                         lan78xx_queue_skb(&dev->txq, tx_buf, tx_start);
3942                         break;
3943                 case -EPIPE:
3944                         netif_stop_queue(dev->net);
3945                         lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3946                         usb_autopm_put_interface_async(dev->intf);
3947                         break;
3948                 case -ENODEV:
3949                 case -ENOENT:
3950                         netif_dbg(dev, tx_err, dev->net,
3951                                   "tx submit urb err %d (disconnected?)", ret);
3952                         netif_device_detach(dev->net);
3953                         break;
3954                 default:
3955                         usb_autopm_put_interface_async(dev->intf);
3956                         netif_dbg(dev, tx_err, dev->net,
3957                                   "tx submit urb err %d\n", ret);
3958                         break;
3959                 }
3960
3961                 spin_unlock_irqrestore(&dev->txq.lock, flags);
3962
3963                 if (ret) {
3964                         netdev_warn(dev->net, "failed to tx urb %d\n", ret);
3965 out:
3966                         dev->net->stats.tx_dropped += entry->num_of_packet;
3967                         lan78xx_release_tx_buf(dev, tx_buf);
3968                 }
3969         } while (ret == 0);
3970 }
3971
3972 static int lan78xx_bh(struct lan78xx_net *dev, int budget)
3973 {
3974         struct sk_buff_head done;
3975         struct sk_buff *rx_buf;
3976         struct skb_data *entry;
3977         unsigned long flags;
3978         int work_done = 0;
3979
3980         /* Pass frames received in the last NAPI cycle before
3981          * working on newly completed URBs.
3982          */
3983         while (!skb_queue_empty(&dev->rxq_overflow)) {
3984                 lan78xx_skb_return(dev, skb_dequeue(&dev->rxq_overflow));
3985                 ++work_done;
3986         }
3987
3988         /* Take a snapshot of the done queue and move items to a
3989          * temporary queue. Rx URB completions will continue to add
3990          * to the done queue.
3991          */
3992         __skb_queue_head_init(&done);
3993
3994         spin_lock_irqsave(&dev->rxq_done.lock, flags);
3995         skb_queue_splice_init(&dev->rxq_done, &done);
3996         spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
3997
3998         /* Extract receive frames from completed URBs and
3999          * pass them to the stack. Re-submit each completed URB.
4000          */
4001         while ((work_done < budget) &&
4002                (rx_buf = __skb_dequeue(&done))) {
4003                 entry = (struct skb_data *)(rx_buf->cb);
4004                 switch (entry->state) {
4005                 case rx_done:
4006                         rx_process(dev, rx_buf, budget, &work_done);
4007                         break;
4008                 case rx_cleanup:
4009                         break;
4010                 default:
4011                         netdev_dbg(dev->net, "rx buf state %d\n",
4012                                    entry->state);
4013                         break;
4014                 }
4015
4016                 lan78xx_rx_urb_resubmit(dev, rx_buf);
4017         }
4018
4019         /* If budget was consumed before processing all the URBs put them
4020          * back on the front of the done queue. They will be first to be
4021          * processed in the next NAPI cycle.
4022          */
4023         spin_lock_irqsave(&dev->rxq_done.lock, flags);
4024         skb_queue_splice(&done, &dev->rxq_done);
4025         spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
4026
4027         if (netif_device_present(dev->net) && netif_running(dev->net)) {
4028                 /* reset update timer delta */
4029                 if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
4030                         dev->delta = 1;
4031                         mod_timer(&dev->stat_monitor,
4032                                   jiffies + STAT_UPDATE_TIMER);
4033                 }
4034
4035                 /* Submit all free Rx URBs */
4036
4037                 if (!test_bit(EVENT_RX_HALT, &dev->flags))
4038                         lan78xx_rx_urb_submit_all(dev);
4039
4040                 /* Submit new Tx URBs */
4041
4042                 lan78xx_tx_bh(dev);
4043         }
4044
4045         return work_done;
4046 }
4047
4048 static int lan78xx_poll(struct napi_struct *napi, int budget)
4049 {
4050         struct lan78xx_net *dev = container_of(napi, struct lan78xx_net, napi);
4051         int result = budget;
4052         int work_done;
4053
4054         /* Don't do any work if the device is suspended */
4055
4056         if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
4057                 napi_complete_done(napi, 0);
4058                 return 0;
4059         }
4060
4061         /* Process completed URBs and submit new URBs */
4062
4063         work_done = lan78xx_bh(dev, budget);
4064
4065         if (work_done < budget) {
4066                 napi_complete_done(napi, work_done);
4067
4068                 /* Start a new polling cycle if data was received or
4069                  * data is waiting to be transmitted.
4070                  */
4071                 if (!skb_queue_empty(&dev->rxq_done)) {
4072                         napi_schedule(napi);
4073                 } else if (netif_carrier_ok(dev->net)) {
4074                         if (skb_queue_empty(&dev->txq) &&
4075                             !skb_queue_empty(&dev->txq_pend)) {
4076                                 napi_schedule(napi);
4077                         } else {
4078                                 netif_tx_lock(dev->net);
4079                                 if (netif_queue_stopped(dev->net)) {
4080                                         netif_wake_queue(dev->net);
4081                                         napi_schedule(napi);
4082                                 }
4083                                 netif_tx_unlock(dev->net);
4084                         }
4085                 }
4086                 result = work_done;
4087         }
4088
4089         return result;
4090 }
4091
4092 static void lan78xx_delayedwork(struct work_struct *work)
4093 {
4094         int status;
4095         struct lan78xx_net *dev;
4096
4097         dev = container_of(work, struct lan78xx_net, wq.work);
4098
4099         if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
4100                 return;
4101
4102         if (usb_autopm_get_interface(dev->intf) < 0)
4103                 return;
4104
4105         if (test_bit(EVENT_TX_HALT, &dev->flags)) {
4106                 unlink_urbs(dev, &dev->txq);
4107
4108                 status = usb_clear_halt(dev->udev, dev->pipe_out);
4109                 if (status < 0 &&
4110                     status != -EPIPE &&
4111                     status != -ESHUTDOWN) {
4112                         if (netif_msg_tx_err(dev))
4113                                 netdev_err(dev->net,
4114                                            "can't clear tx halt, status %d\n",
4115                                            status);
4116                 } else {
4117                         clear_bit(EVENT_TX_HALT, &dev->flags);
4118                         if (status != -ESHUTDOWN)
4119                                 netif_wake_queue(dev->net);
4120                 }
4121         }
4122
4123         if (test_bit(EVENT_RX_HALT, &dev->flags)) {
4124                 unlink_urbs(dev, &dev->rxq);
4125                 status = usb_clear_halt(dev->udev, dev->pipe_in);
4126                 if (status < 0 &&
4127                     status != -EPIPE &&
4128                     status != -ESHUTDOWN) {
4129                         if (netif_msg_rx_err(dev))
4130                                 netdev_err(dev->net,
4131                                            "can't clear rx halt, status %d\n",
4132                                            status);
4133                 } else {
4134                         clear_bit(EVENT_RX_HALT, &dev->flags);
4135                         napi_schedule(&dev->napi);
4136                 }
4137         }
4138
4139         if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
4140                 int ret = 0;
4141
4142                 clear_bit(EVENT_LINK_RESET, &dev->flags);
4143                 if (lan78xx_link_reset(dev) < 0) {
4144                         netdev_info(dev->net, "link reset failed (%d)\n",
4145                                     ret);
4146                 }
4147         }
4148
4149         if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
4150                 lan78xx_update_stats(dev);
4151
4152                 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
4153
4154                 mod_timer(&dev->stat_monitor,
4155                           jiffies + (STAT_UPDATE_TIMER * dev->delta));
4156
4157                 dev->delta = min((dev->delta * 2), 50);
4158         }
4159
4160         usb_autopm_put_interface(dev->intf);
4161 }
4162
4163 static void intr_complete(struct urb *urb)
4164 {
4165         struct lan78xx_net *dev = urb->context;
4166         int status = urb->status;
4167
4168         switch (status) {
4169         /* success */
4170         case 0:
4171                 lan78xx_status(dev, urb);
4172                 break;
4173
4174         /* software-driven interface shutdown */
4175         case -ENOENT:                   /* urb killed */
4176         case -ENODEV:                   /* hardware gone */
4177         case -ESHUTDOWN:                /* hardware gone */
4178                 netif_dbg(dev, ifdown, dev->net,
4179                           "intr shutdown, code %d\n", status);
4180                 return;
4181
4182         /* NOTE:  not throttling like RX/TX, since this endpoint
4183          * already polls infrequently
4184          */
4185         default:
4186                 netdev_dbg(dev->net, "intr status %d\n", status);
4187                 break;
4188         }
4189
4190         if (!netif_device_present(dev->net) ||
4191             !netif_running(dev->net)) {
4192                 netdev_warn(dev->net, "not submitting new status URB");
4193                 return;
4194         }
4195
4196         memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
4197         status = usb_submit_urb(urb, GFP_ATOMIC);
4198
4199         switch (status) {
4200         case  0:
4201                 break;
4202         case -ENODEV:
4203         case -ENOENT:
4204                 netif_dbg(dev, timer, dev->net,
4205                           "intr resubmit %d (disconnect?)", status);
4206                 netif_device_detach(dev->net);
4207                 break;
4208         default:
4209                 netif_err(dev, timer, dev->net,
4210                           "intr resubmit --> %d\n", status);
4211                 break;
4212         }
4213 }
4214
4215 static void lan78xx_disconnect(struct usb_interface *intf)
4216 {
4217         struct lan78xx_net *dev;
4218         struct usb_device *udev;
4219         struct net_device *net;
4220         struct phy_device *phydev;
4221
4222         dev = usb_get_intfdata(intf);
4223         usb_set_intfdata(intf, NULL);
4224         if (!dev)
4225                 return;
4226
4227         netif_napi_del(&dev->napi);
4228
4229         udev = interface_to_usbdev(intf);
4230         net = dev->net;
4231
4232         unregister_netdev(net);
4233
4234         timer_shutdown_sync(&dev->stat_monitor);
4235         set_bit(EVENT_DEV_DISCONNECT, &dev->flags);
4236         cancel_delayed_work_sync(&dev->wq);
4237
4238         phydev = net->phydev;
4239
4240         phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
4241         phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
4242
4243         phy_disconnect(net->phydev);
4244
4245         if (phy_is_pseudo_fixed_link(phydev))
4246                 fixed_phy_unregister(phydev);
4247
4248         usb_scuttle_anchored_urbs(&dev->deferred);
4249
4250         lan78xx_unbind(dev, intf);
4251
4252         lan78xx_free_tx_resources(dev);
4253         lan78xx_free_rx_resources(dev);
4254
4255         usb_kill_urb(dev->urb_intr);
4256         usb_free_urb(dev->urb_intr);
4257
4258         free_netdev(net);
4259         usb_put_dev(udev);
4260 }
4261
4262 static void lan78xx_tx_timeout(struct net_device *net, unsigned int txqueue)
4263 {
4264         struct lan78xx_net *dev = netdev_priv(net);
4265
4266         unlink_urbs(dev, &dev->txq);
4267         napi_schedule(&dev->napi);
4268 }
4269
4270 static netdev_features_t lan78xx_features_check(struct sk_buff *skb,
4271                                                 struct net_device *netdev,
4272                                                 netdev_features_t features)
4273 {
4274         struct lan78xx_net *dev = netdev_priv(netdev);
4275
4276         if (skb->len > LAN78XX_TSO_SIZE(dev))
4277                 features &= ~NETIF_F_GSO_MASK;
4278
4279         features = vlan_features_check(skb, features);
4280         features = vxlan_features_check(skb, features);
4281
4282         return features;
4283 }
4284
4285 static const struct net_device_ops lan78xx_netdev_ops = {
4286         .ndo_open               = lan78xx_open,
4287         .ndo_stop               = lan78xx_stop,
4288         .ndo_start_xmit         = lan78xx_start_xmit,
4289         .ndo_tx_timeout         = lan78xx_tx_timeout,
4290         .ndo_change_mtu         = lan78xx_change_mtu,
4291         .ndo_set_mac_address    = lan78xx_set_mac_addr,
4292         .ndo_validate_addr      = eth_validate_addr,
4293         .ndo_eth_ioctl          = phy_do_ioctl_running,
4294         .ndo_set_rx_mode        = lan78xx_set_multicast,
4295         .ndo_set_features       = lan78xx_set_features,
4296         .ndo_vlan_rx_add_vid    = lan78xx_vlan_rx_add_vid,
4297         .ndo_vlan_rx_kill_vid   = lan78xx_vlan_rx_kill_vid,
4298         .ndo_features_check     = lan78xx_features_check,
4299 };
4300
4301 static void lan78xx_stat_monitor(struct timer_list *t)
4302 {
4303         struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
4304
4305         lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
4306 }
4307
4308 static int lan78xx_probe(struct usb_interface *intf,
4309                          const struct usb_device_id *id)
4310 {
4311         struct usb_host_endpoint *ep_blkin, *ep_blkout, *ep_intr;
4312         struct lan78xx_net *dev;
4313         struct net_device *netdev;
4314         struct usb_device *udev;
4315         int ret;
4316         unsigned int maxp;
4317         unsigned int period;
4318         u8 *buf = NULL;
4319
4320         udev = interface_to_usbdev(intf);
4321         udev = usb_get_dev(udev);
4322
4323         netdev = alloc_etherdev(sizeof(struct lan78xx_net));
4324         if (!netdev) {
4325                 dev_err(&intf->dev, "Error: OOM\n");
4326                 ret = -ENOMEM;
4327                 goto out1;
4328         }
4329
4330         /* netdev_printk() needs this */
4331         SET_NETDEV_DEV(netdev, &intf->dev);
4332
4333         dev = netdev_priv(netdev);
4334         dev->udev = udev;
4335         dev->intf = intf;
4336         dev->net = netdev;
4337         dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
4338                                         | NETIF_MSG_PROBE | NETIF_MSG_LINK);
4339
4340         skb_queue_head_init(&dev->rxq);
4341         skb_queue_head_init(&dev->txq);
4342         skb_queue_head_init(&dev->rxq_done);
4343         skb_queue_head_init(&dev->txq_pend);
4344         skb_queue_head_init(&dev->rxq_overflow);
4345         mutex_init(&dev->phy_mutex);
4346         mutex_init(&dev->dev_mutex);
4347
4348         ret = lan78xx_urb_config_init(dev);
4349         if (ret < 0)
4350                 goto out2;
4351
4352         ret = lan78xx_alloc_tx_resources(dev);
4353         if (ret < 0)
4354                 goto out2;
4355
4356         ret = lan78xx_alloc_rx_resources(dev);
4357         if (ret < 0)
4358                 goto out3;
4359
4360         /* MTU range: 68 - 9000 */
4361         netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
4362
4363         netif_set_tso_max_size(netdev, LAN78XX_TSO_SIZE(dev));
4364
4365         netif_napi_add(netdev, &dev->napi, lan78xx_poll);
4366
4367         INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
4368         init_usb_anchor(&dev->deferred);
4369
4370         netdev->netdev_ops = &lan78xx_netdev_ops;
4371         netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
4372         netdev->ethtool_ops = &lan78xx_ethtool_ops;
4373
4374         dev->delta = 1;
4375         timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
4376
4377         mutex_init(&dev->stats.access_lock);
4378
4379         if (intf->cur_altsetting->desc.bNumEndpoints < 3) {
4380                 ret = -ENODEV;
4381                 goto out4;
4382         }
4383
4384         dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
4385         ep_blkin = usb_pipe_endpoint(udev, dev->pipe_in);
4386         if (!ep_blkin || !usb_endpoint_is_bulk_in(&ep_blkin->desc)) {
4387                 ret = -ENODEV;
4388                 goto out4;
4389         }
4390
4391         dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
4392         ep_blkout = usb_pipe_endpoint(udev, dev->pipe_out);
4393         if (!ep_blkout || !usb_endpoint_is_bulk_out(&ep_blkout->desc)) {
4394                 ret = -ENODEV;
4395                 goto out4;
4396         }
4397
4398         ep_intr = &intf->cur_altsetting->endpoint[2];
4399         if (!usb_endpoint_is_int_in(&ep_intr->desc)) {
4400                 ret = -ENODEV;
4401                 goto out4;
4402         }
4403
4404         dev->pipe_intr = usb_rcvintpipe(dev->udev,
4405                                         usb_endpoint_num(&ep_intr->desc));
4406
4407         ret = lan78xx_bind(dev, intf);
4408         if (ret < 0)
4409                 goto out4;
4410
4411         period = ep_intr->desc.bInterval;
4412         maxp = usb_maxpacket(dev->udev, dev->pipe_intr);
4413         buf = kmalloc(maxp, GFP_KERNEL);
4414         if (!buf) {
4415                 ret = -ENOMEM;
4416                 goto out5;
4417         }
4418
4419         dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
4420         if (!dev->urb_intr) {
4421                 ret = -ENOMEM;
4422                 goto out6;
4423         } else {
4424                 usb_fill_int_urb(dev->urb_intr, dev->udev,
4425                                  dev->pipe_intr, buf, maxp,
4426                                  intr_complete, dev, period);
4427                 dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;
4428         }
4429
4430         dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out);
4431
4432         /* Reject broken descriptors. */
4433         if (dev->maxpacket == 0) {
4434                 ret = -ENODEV;
4435                 goto out6;
4436         }
4437
4438         /* driver requires remote-wakeup capability during autosuspend. */
4439         intf->needs_remote_wakeup = 1;
4440
4441         ret = lan78xx_phy_init(dev);
4442         if (ret < 0)
4443                 goto out7;
4444
4445         ret = register_netdev(netdev);
4446         if (ret != 0) {
4447                 netif_err(dev, probe, netdev, "couldn't register the device\n");
4448                 goto out8;
4449         }
4450
4451         usb_set_intfdata(intf, dev);
4452
4453         ret = device_set_wakeup_enable(&udev->dev, true);
4454
4455          /* Default delay of 2sec has more overhead than advantage.
4456           * Set to 10sec as default.
4457           */
4458         pm_runtime_set_autosuspend_delay(&udev->dev,
4459                                          DEFAULT_AUTOSUSPEND_DELAY);
4460
4461         return 0;
4462
4463 out8:
4464         phy_disconnect(netdev->phydev);
4465 out7:
4466         usb_free_urb(dev->urb_intr);
4467 out6:
4468         kfree(buf);
4469 out5:
4470         lan78xx_unbind(dev, intf);
4471 out4:
4472         netif_napi_del(&dev->napi);
4473         lan78xx_free_rx_resources(dev);
4474 out3:
4475         lan78xx_free_tx_resources(dev);
4476 out2:
4477         free_netdev(netdev);
4478 out1:
4479         usb_put_dev(udev);
4480
4481         return ret;
4482 }
4483
4484 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
4485 {
4486         const u16 crc16poly = 0x8005;
4487         int i;
4488         u16 bit, crc, msb;
4489         u8 data;
4490
4491         crc = 0xFFFF;
4492         for (i = 0; i < len; i++) {
4493                 data = *buf++;
4494                 for (bit = 0; bit < 8; bit++) {
4495                         msb = crc >> 15;
4496                         crc <<= 1;
4497
4498                         if (msb ^ (u16)(data & 1)) {
4499                                 crc ^= crc16poly;
4500                                 crc |= (u16)0x0001U;
4501                         }
4502                         data >>= 1;
4503                 }
4504         }
4505
4506         return crc;
4507 }
4508
4509 static int lan78xx_set_auto_suspend(struct lan78xx_net *dev)
4510 {
4511         u32 buf;
4512         int ret;
4513
4514         ret = lan78xx_stop_tx_path(dev);
4515         if (ret < 0)
4516                 return ret;
4517
4518         ret = lan78xx_stop_rx_path(dev);
4519         if (ret < 0)
4520                 return ret;
4521
4522         /* auto suspend (selective suspend) */
4523
4524         ret = lan78xx_write_reg(dev, WUCSR, 0);
4525         if (ret < 0)
4526                 return ret;
4527         ret = lan78xx_write_reg(dev, WUCSR2, 0);
4528         if (ret < 0)
4529                 return ret;
4530         ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4531         if (ret < 0)
4532                 return ret;
4533
4534         /* set goodframe wakeup */
4535
4536         ret = lan78xx_read_reg(dev, WUCSR, &buf);
4537         if (ret < 0)
4538                 return ret;
4539
4540         buf |= WUCSR_RFE_WAKE_EN_;
4541         buf |= WUCSR_STORE_WAKE_;
4542
4543         ret = lan78xx_write_reg(dev, WUCSR, buf);
4544         if (ret < 0)
4545                 return ret;
4546
4547         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4548         if (ret < 0)
4549                 return ret;
4550
4551         buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4552         buf |= PMT_CTL_RES_CLR_WKP_STS_;
4553         buf |= PMT_CTL_PHY_WAKE_EN_;
4554         buf |= PMT_CTL_WOL_EN_;
4555         buf &= ~PMT_CTL_SUS_MODE_MASK_;
4556         buf |= PMT_CTL_SUS_MODE_3_;
4557
4558         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4559         if (ret < 0)
4560                 return ret;
4561
4562         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4563         if (ret < 0)
4564                 return ret;
4565
4566         buf |= PMT_CTL_WUPS_MASK_;
4567
4568         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4569         if (ret < 0)
4570                 return ret;
4571
4572         ret = lan78xx_start_rx_path(dev);
4573
4574         return ret;
4575 }
4576
4577 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
4578 {
4579         const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
4580         const u8 ipv6_multicast[3] = { 0x33, 0x33 };
4581         const u8 arp_type[2] = { 0x08, 0x06 };
4582         u32 temp_pmt_ctl;
4583         int mask_index;
4584         u32 temp_wucsr;
4585         u32 buf;
4586         u16 crc;
4587         int ret;
4588
4589         ret = lan78xx_stop_tx_path(dev);
4590         if (ret < 0)
4591                 return ret;
4592         ret = lan78xx_stop_rx_path(dev);
4593         if (ret < 0)
4594                 return ret;
4595
4596         ret = lan78xx_write_reg(dev, WUCSR, 0);
4597         if (ret < 0)
4598                 return ret;
4599         ret = lan78xx_write_reg(dev, WUCSR2, 0);
4600         if (ret < 0)
4601                 return ret;
4602         ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4603         if (ret < 0)
4604                 return ret;
4605
4606         temp_wucsr = 0;
4607
4608         temp_pmt_ctl = 0;
4609
4610         ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
4611         if (ret < 0)
4612                 return ret;
4613
4614         temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
4615         temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
4616
4617         for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++) {
4618                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
4619                 if (ret < 0)
4620                         return ret;
4621         }
4622
4623         mask_index = 0;
4624         if (wol & WAKE_PHY) {
4625                 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
4626
4627                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4628                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4629                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4630         }
4631         if (wol & WAKE_MAGIC) {
4632                 temp_wucsr |= WUCSR_MPEN_;
4633
4634                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4635                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4636                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
4637         }
4638         if (wol & WAKE_BCAST) {
4639                 temp_wucsr |= WUCSR_BCST_EN_;
4640
4641                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4642                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4643                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4644         }
4645         if (wol & WAKE_MCAST) {
4646                 temp_wucsr |= WUCSR_WAKE_EN_;
4647
4648                 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
4649                 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
4650                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4651                                         WUF_CFGX_EN_ |
4652                                         WUF_CFGX_TYPE_MCAST_ |
4653                                         (0 << WUF_CFGX_OFFSET_SHIFT_) |
4654                                         (crc & WUF_CFGX_CRC16_MASK_));
4655                 if (ret < 0)
4656                         return ret;
4657
4658                 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
4659                 if (ret < 0)
4660                         return ret;
4661                 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4662                 if (ret < 0)
4663                         return ret;
4664                 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4665                 if (ret < 0)
4666                         return ret;
4667                 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4668                 if (ret < 0)
4669                         return ret;
4670
4671                 mask_index++;
4672
4673                 /* for IPv6 Multicast */
4674                 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
4675                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4676                                         WUF_CFGX_EN_ |
4677                                         WUF_CFGX_TYPE_MCAST_ |
4678                                         (0 << WUF_CFGX_OFFSET_SHIFT_) |
4679                                         (crc & WUF_CFGX_CRC16_MASK_));
4680                 if (ret < 0)
4681                         return ret;
4682
4683                 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
4684                 if (ret < 0)
4685                         return ret;
4686                 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4687                 if (ret < 0)
4688                         return ret;
4689                 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4690                 if (ret < 0)
4691                         return ret;
4692                 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4693                 if (ret < 0)
4694                         return ret;
4695
4696                 mask_index++;
4697
4698                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4699                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4700                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4701         }
4702         if (wol & WAKE_UCAST) {
4703                 temp_wucsr |= WUCSR_PFDA_EN_;
4704
4705                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4706                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4707                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4708         }
4709         if (wol & WAKE_ARP) {
4710                 temp_wucsr |= WUCSR_WAKE_EN_;
4711
4712                 /* set WUF_CFG & WUF_MASK
4713                  * for packettype (offset 12,13) = ARP (0x0806)
4714                  */
4715                 crc = lan78xx_wakeframe_crc16(arp_type, 2);
4716                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4717                                         WUF_CFGX_EN_ |
4718                                         WUF_CFGX_TYPE_ALL_ |
4719                                         (0 << WUF_CFGX_OFFSET_SHIFT_) |
4720                                         (crc & WUF_CFGX_CRC16_MASK_));
4721                 if (ret < 0)
4722                         return ret;
4723
4724                 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
4725                 if (ret < 0)
4726                         return ret;
4727                 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4728                 if (ret < 0)
4729                         return ret;
4730                 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4731                 if (ret < 0)
4732                         return ret;
4733                 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4734                 if (ret < 0)
4735                         return ret;
4736
4737                 mask_index++;
4738
4739                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4740                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4741                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4742         }
4743
4744         ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
4745         if (ret < 0)
4746                 return ret;
4747
4748         /* when multiple WOL bits are set */
4749         if (hweight_long((unsigned long)wol) > 1) {
4750                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
4751                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
4752                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
4753         }
4754         ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
4755         if (ret < 0)
4756                 return ret;
4757
4758         /* clear WUPS */
4759         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4760         if (ret < 0)
4761                 return ret;
4762
4763         buf |= PMT_CTL_WUPS_MASK_;
4764
4765         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4766         if (ret < 0)
4767                 return ret;
4768
4769         ret = lan78xx_start_rx_path(dev);
4770
4771         return ret;
4772 }
4773
4774 static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
4775 {
4776         struct lan78xx_net *dev = usb_get_intfdata(intf);
4777         bool dev_open;
4778         int ret;
4779
4780         mutex_lock(&dev->dev_mutex);
4781
4782         netif_dbg(dev, ifdown, dev->net,
4783                   "suspending: pm event %#x", message.event);
4784
4785         dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
4786
4787         if (dev_open) {
4788                 spin_lock_irq(&dev->txq.lock);
4789                 /* don't autosuspend while transmitting */
4790                 if ((skb_queue_len(&dev->txq) ||
4791                      skb_queue_len(&dev->txq_pend)) &&
4792                     PMSG_IS_AUTO(message)) {
4793                         spin_unlock_irq(&dev->txq.lock);
4794                         ret = -EBUSY;
4795                         goto out;
4796                 } else {
4797                         set_bit(EVENT_DEV_ASLEEP, &dev->flags);
4798                         spin_unlock_irq(&dev->txq.lock);
4799                 }
4800
4801                 /* stop RX */
4802                 ret = lan78xx_stop_rx_path(dev);
4803                 if (ret < 0)
4804                         goto out;
4805
4806                 ret = lan78xx_flush_rx_fifo(dev);
4807                 if (ret < 0)
4808                         goto out;
4809
4810                 /* stop Tx */
4811                 ret = lan78xx_stop_tx_path(dev);
4812                 if (ret < 0)
4813                         goto out;
4814
4815                 /* empty out the Rx and Tx queues */
4816                 netif_device_detach(dev->net);
4817                 lan78xx_terminate_urbs(dev);
4818                 usb_kill_urb(dev->urb_intr);
4819
4820                 /* reattach */
4821                 netif_device_attach(dev->net);
4822
4823                 del_timer(&dev->stat_monitor);
4824
4825                 if (PMSG_IS_AUTO(message)) {
4826                         ret = lan78xx_set_auto_suspend(dev);
4827                         if (ret < 0)
4828                                 goto out;
4829                 } else {
4830                         struct lan78xx_priv *pdata;
4831
4832                         pdata = (struct lan78xx_priv *)(dev->data[0]);
4833                         netif_carrier_off(dev->net);
4834                         ret = lan78xx_set_suspend(dev, pdata->wol);
4835                         if (ret < 0)
4836                                 goto out;
4837                 }
4838         } else {
4839                 /* Interface is down; don't allow WOL and PHY
4840                  * events to wake up the host
4841                  */
4842                 u32 buf;
4843
4844                 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
4845
4846                 ret = lan78xx_write_reg(dev, WUCSR, 0);
4847                 if (ret < 0)
4848                         goto out;
4849                 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4850                 if (ret < 0)
4851                         goto out;
4852
4853                 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4854                 if (ret < 0)
4855                         goto out;
4856
4857                 buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4858                 buf |= PMT_CTL_RES_CLR_WKP_STS_;
4859                 buf &= ~PMT_CTL_SUS_MODE_MASK_;
4860                 buf |= PMT_CTL_SUS_MODE_3_;
4861
4862                 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4863                 if (ret < 0)
4864                         goto out;
4865
4866                 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4867                 if (ret < 0)
4868                         goto out;
4869
4870                 buf |= PMT_CTL_WUPS_MASK_;
4871
4872                 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4873                 if (ret < 0)
4874                         goto out;
4875         }
4876
4877         ret = 0;
4878 out:
4879         mutex_unlock(&dev->dev_mutex);
4880
4881         return ret;
4882 }
4883
4884 static bool lan78xx_submit_deferred_urbs(struct lan78xx_net *dev)
4885 {
4886         bool pipe_halted = false;
4887         struct urb *urb;
4888
4889         while ((urb = usb_get_from_anchor(&dev->deferred))) {
4890                 struct sk_buff *skb = urb->context;
4891                 int ret;
4892
4893                 if (!netif_device_present(dev->net) ||
4894                     !netif_carrier_ok(dev->net) ||
4895                     pipe_halted) {
4896                         lan78xx_release_tx_buf(dev, skb);
4897                         continue;
4898                 }
4899
4900                 ret = usb_submit_urb(urb, GFP_ATOMIC);
4901
4902                 if (ret == 0) {
4903                         netif_trans_update(dev->net);
4904                         lan78xx_queue_skb(&dev->txq, skb, tx_start);
4905                 } else {
4906                         if (ret == -EPIPE) {
4907                                 netif_stop_queue(dev->net);
4908                                 pipe_halted = true;
4909                         } else if (ret == -ENODEV) {
4910                                 netif_device_detach(dev->net);
4911                         }
4912
4913                         lan78xx_release_tx_buf(dev, skb);
4914                 }
4915         }
4916
4917         return pipe_halted;
4918 }
4919
4920 static int lan78xx_resume(struct usb_interface *intf)
4921 {
4922         struct lan78xx_net *dev = usb_get_intfdata(intf);
4923         bool dev_open;
4924         int ret;
4925
4926         mutex_lock(&dev->dev_mutex);
4927
4928         netif_dbg(dev, ifup, dev->net, "resuming device");
4929
4930         dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
4931
4932         if (dev_open) {
4933                 bool pipe_halted = false;
4934
4935                 ret = lan78xx_flush_tx_fifo(dev);
4936                 if (ret < 0)
4937                         goto out;
4938
4939                 if (dev->urb_intr) {
4940                         int ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
4941
4942                         if (ret < 0) {
4943                                 if (ret == -ENODEV)
4944                                         netif_device_detach(dev->net);
4945                                 netdev_warn(dev->net, "Failed to submit intr URB");
4946                         }
4947                 }
4948
4949                 spin_lock_irq(&dev->txq.lock);
4950
4951                 if (netif_device_present(dev->net)) {
4952                         pipe_halted = lan78xx_submit_deferred_urbs(dev);
4953
4954                         if (pipe_halted)
4955                                 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
4956                 }
4957
4958                 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4959
4960                 spin_unlock_irq(&dev->txq.lock);
4961
4962                 if (!pipe_halted &&
4963                     netif_device_present(dev->net) &&
4964                     (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev)))
4965                         netif_start_queue(dev->net);
4966
4967                 ret = lan78xx_start_tx_path(dev);
4968                 if (ret < 0)
4969                         goto out;
4970
4971                 napi_schedule(&dev->napi);
4972
4973                 if (!timer_pending(&dev->stat_monitor)) {
4974                         dev->delta = 1;
4975                         mod_timer(&dev->stat_monitor,
4976                                   jiffies + STAT_UPDATE_TIMER);
4977                 }
4978
4979         } else {
4980                 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4981         }
4982
4983         ret = lan78xx_write_reg(dev, WUCSR2, 0);
4984         if (ret < 0)
4985                 goto out;
4986         ret = lan78xx_write_reg(dev, WUCSR, 0);
4987         if (ret < 0)
4988                 goto out;
4989         ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4990         if (ret < 0)
4991                 goto out;
4992
4993         ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
4994                                              WUCSR2_ARP_RCD_ |
4995                                              WUCSR2_IPV6_TCPSYN_RCD_ |
4996                                              WUCSR2_IPV4_TCPSYN_RCD_);
4997         if (ret < 0)
4998                 goto out;
4999
5000         ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
5001                                             WUCSR_EEE_RX_WAKE_ |
5002                                             WUCSR_PFDA_FR_ |
5003                                             WUCSR_RFE_WAKE_FR_ |
5004                                             WUCSR_WUFR_ |
5005                                             WUCSR_MPR_ |
5006                                             WUCSR_BCST_FR_);
5007         if (ret < 0)
5008                 goto out;
5009
5010         ret = 0;
5011 out:
5012         mutex_unlock(&dev->dev_mutex);
5013
5014         return ret;
5015 }
5016
5017 static int lan78xx_reset_resume(struct usb_interface *intf)
5018 {
5019         struct lan78xx_net *dev = usb_get_intfdata(intf);
5020         int ret;
5021
5022         netif_dbg(dev, ifup, dev->net, "(reset) resuming device");
5023
5024         ret = lan78xx_reset(dev);
5025         if (ret < 0)
5026                 return ret;
5027
5028         phy_start(dev->net->phydev);
5029
5030         ret = lan78xx_resume(intf);
5031
5032         return ret;
5033 }
5034
5035 static const struct usb_device_id products[] = {
5036         {
5037         /* LAN7800 USB Gigabit Ethernet Device */
5038         USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
5039         },
5040         {
5041         /* LAN7850 USB Gigabit Ethernet Device */
5042         USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
5043         },
5044         {
5045         /* LAN7801 USB Gigabit Ethernet Device */
5046         USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
5047         },
5048         {
5049         /* ATM2-AF USB Gigabit Ethernet Device */
5050         USB_DEVICE(AT29M2AF_USB_VENDOR_ID, AT29M2AF_USB_PRODUCT_ID),
5051         },
5052         {},
5053 };
5054 MODULE_DEVICE_TABLE(usb, products);
5055
5056 static struct usb_driver lan78xx_driver = {
5057         .name                   = DRIVER_NAME,
5058         .id_table               = products,
5059         .probe                  = lan78xx_probe,
5060         .disconnect             = lan78xx_disconnect,
5061         .suspend                = lan78xx_suspend,
5062         .resume                 = lan78xx_resume,
5063         .reset_resume           = lan78xx_reset_resume,
5064         .supports_autosuspend   = 1,
5065         .disable_hub_initiated_lpm = 1,
5066 };
5067
5068 module_usb_driver(lan78xx_driver);
5069
5070 MODULE_AUTHOR(DRIVER_AUTHOR);
5071 MODULE_DESCRIPTION(DRIVER_DESC);
5072 MODULE_LICENSE("GPL");