drivers/net/usb/lan78xx.c

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