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