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 = %d", 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         intdata = get_unaligned_le32(urb->transfer_buffer);
1262
1263         if (intdata & INT_ENP_PHY_INT) {
1264                 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1265                 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1266
1267                 if (dev->domain_data.phyirq > 0) {
1268                         local_irq_disable();
1269                         generic_handle_irq(dev->domain_data.phyirq);
1270                         local_irq_enable();
1271                 }
1272         } else
1273                 netdev_warn(dev->net,
1274                             "unexpected interrupt: 0x%08x\n", intdata);
1275 }
1276
1277 static int lan78xx_ethtool_get_eeprom_len(struct net_device *netdev)
1278 {
1279         return MAX_EEPROM_SIZE;
1280 }
1281
1282 static int lan78xx_ethtool_get_eeprom(struct net_device *netdev,
1283                                       struct ethtool_eeprom *ee, u8 *data)
1284 {
1285         struct lan78xx_net *dev = netdev_priv(netdev);
1286         int ret;
1287
1288         ret = usb_autopm_get_interface(dev->intf);
1289         if (ret)
1290                 return ret;
1291
1292         ee->magic = LAN78XX_EEPROM_MAGIC;
1293
1294         ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1295
1296         usb_autopm_put_interface(dev->intf);
1297
1298         return ret;
1299 }
1300
1301 static int lan78xx_ethtool_set_eeprom(struct net_device *netdev,
1302                                       struct ethtool_eeprom *ee, u8 *data)
1303 {
1304         struct lan78xx_net *dev = netdev_priv(netdev);
1305         int ret;
1306
1307         ret = usb_autopm_get_interface(dev->intf);
1308         if (ret)
1309                 return ret;
1310
1311         /* Invalid EEPROM_INDICATOR at offset zero will result in a failure
1312          * to load data from EEPROM
1313          */
1314         if (ee->magic == LAN78XX_EEPROM_MAGIC)
1315                 ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1316         else if ((ee->magic == LAN78XX_OTP_MAGIC) &&
1317                  (ee->offset == 0) &&
1318                  (ee->len == 512) &&
1319                  (data[0] == OTP_INDICATOR_1))
1320                 ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1321
1322         usb_autopm_put_interface(dev->intf);
1323
1324         return ret;
1325 }
1326
1327 static void lan78xx_get_strings(struct net_device *netdev, u32 stringset,
1328                                 u8 *data)
1329 {
1330         if (stringset == ETH_SS_STATS)
1331                 memcpy(data, lan78xx_gstrings, sizeof(lan78xx_gstrings));
1332 }
1333
1334 static int lan78xx_get_sset_count(struct net_device *netdev, int sset)
1335 {
1336         if (sset == ETH_SS_STATS)
1337                 return ARRAY_SIZE(lan78xx_gstrings);
1338         else
1339                 return -EOPNOTSUPP;
1340 }
1341
1342 static void lan78xx_get_stats(struct net_device *netdev,
1343                               struct ethtool_stats *stats, u64 *data)
1344 {
1345         struct lan78xx_net *dev = netdev_priv(netdev);
1346
1347         lan78xx_update_stats(dev);
1348
1349         mutex_lock(&dev->stats.access_lock);
1350         memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1351         mutex_unlock(&dev->stats.access_lock);
1352 }
1353
1354 static void lan78xx_get_wol(struct net_device *netdev,
1355                             struct ethtool_wolinfo *wol)
1356 {
1357         struct lan78xx_net *dev = netdev_priv(netdev);
1358         int ret;
1359         u32 buf;
1360         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1361
1362         if (usb_autopm_get_interface(dev->intf) < 0)
1363                         return;
1364
1365         ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1366         if (unlikely(ret < 0)) {
1367                 wol->supported = 0;
1368                 wol->wolopts = 0;
1369         } else {
1370                 if (buf & USB_CFG_RMT_WKP_) {
1371                         wol->supported = WAKE_ALL;
1372                         wol->wolopts = pdata->wol;
1373                 } else {
1374                         wol->supported = 0;
1375                         wol->wolopts = 0;
1376                 }
1377         }
1378
1379         usb_autopm_put_interface(dev->intf);
1380 }
1381
1382 static int lan78xx_set_wol(struct net_device *netdev,
1383                            struct ethtool_wolinfo *wol)
1384 {
1385         struct lan78xx_net *dev = netdev_priv(netdev);
1386         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1387         int ret;
1388
1389         ret = usb_autopm_get_interface(dev->intf);
1390         if (ret < 0)
1391                 return ret;
1392
1393         if (wol->wolopts & ~WAKE_ALL)
1394                 return -EINVAL;
1395
1396         pdata->wol = wol->wolopts;
1397
1398         device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1399
1400         phy_ethtool_set_wol(netdev->phydev, wol);
1401
1402         usb_autopm_put_interface(dev->intf);
1403
1404         return ret;
1405 }
1406
1407 static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
1408 {
1409         struct lan78xx_net *dev = netdev_priv(net);
1410         struct phy_device *phydev = net->phydev;
1411         int ret;
1412         u32 buf;
1413
1414         ret = usb_autopm_get_interface(dev->intf);
1415         if (ret < 0)
1416                 return ret;
1417
1418         ret = phy_ethtool_get_eee(phydev, edata);
1419         if (ret < 0)
1420                 goto exit;
1421
1422         ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1423         if (buf & MAC_CR_EEE_EN_) {
1424                 edata->eee_enabled = true;
1425                 edata->eee_active = !!(edata->advertised &
1426                                        edata->lp_advertised);
1427                 edata->tx_lpi_enabled = true;
1428                 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1429                 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1430                 edata->tx_lpi_timer = buf;
1431         } else {
1432                 edata->eee_enabled = false;
1433                 edata->eee_active = false;
1434                 edata->tx_lpi_enabled = false;
1435                 edata->tx_lpi_timer = 0;
1436         }
1437
1438         ret = 0;
1439 exit:
1440         usb_autopm_put_interface(dev->intf);
1441
1442         return ret;
1443 }
1444
1445 static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
1446 {
1447         struct lan78xx_net *dev = netdev_priv(net);
1448         int ret;
1449         u32 buf;
1450
1451         ret = usb_autopm_get_interface(dev->intf);
1452         if (ret < 0)
1453                 return ret;
1454
1455         if (edata->eee_enabled) {
1456                 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1457                 buf |= MAC_CR_EEE_EN_;
1458                 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1459
1460                 phy_ethtool_set_eee(net->phydev, edata);
1461
1462                 buf = (u32)edata->tx_lpi_timer;
1463                 ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1464         } else {
1465                 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1466                 buf &= ~MAC_CR_EEE_EN_;
1467                 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1468         }
1469
1470         usb_autopm_put_interface(dev->intf);
1471
1472         return 0;
1473 }
1474
1475 static u32 lan78xx_get_link(struct net_device *net)
1476 {
1477         phy_read_status(net->phydev);
1478
1479         return net->phydev->link;
1480 }
1481
1482 static void lan78xx_get_drvinfo(struct net_device *net,
1483                                 struct ethtool_drvinfo *info)
1484 {
1485         struct lan78xx_net *dev = netdev_priv(net);
1486
1487         strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
1488         usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1489 }
1490
1491 static u32 lan78xx_get_msglevel(struct net_device *net)
1492 {
1493         struct lan78xx_net *dev = netdev_priv(net);
1494
1495         return dev->msg_enable;
1496 }
1497
1498 static void lan78xx_set_msglevel(struct net_device *net, u32 level)
1499 {
1500         struct lan78xx_net *dev = netdev_priv(net);
1501
1502         dev->msg_enable = level;
1503 }
1504
1505 static int lan78xx_get_link_ksettings(struct net_device *net,
1506                                       struct ethtool_link_ksettings *cmd)
1507 {
1508         struct lan78xx_net *dev = netdev_priv(net);
1509         struct phy_device *phydev = net->phydev;
1510         int ret;
1511
1512         ret = usb_autopm_get_interface(dev->intf);
1513         if (ret < 0)
1514                 return ret;
1515
1516         phy_ethtool_ksettings_get(phydev, cmd);
1517
1518         usb_autopm_put_interface(dev->intf);
1519
1520         return ret;
1521 }
1522
1523 static int lan78xx_set_link_ksettings(struct net_device *net,
1524                                       const struct ethtool_link_ksettings *cmd)
1525 {
1526         struct lan78xx_net *dev = netdev_priv(net);
1527         struct phy_device *phydev = net->phydev;
1528         int ret = 0;
1529         int temp;
1530
1531         ret = usb_autopm_get_interface(dev->intf);
1532         if (ret < 0)
1533                 return ret;
1534
1535         /* change speed & duplex */
1536         ret = phy_ethtool_ksettings_set(phydev, cmd);
1537
1538         if (!cmd->base.autoneg) {
1539                 /* force link down */
1540                 temp = phy_read(phydev, MII_BMCR);
1541                 phy_write(phydev, MII_BMCR, temp | BMCR_LOOPBACK);
1542                 mdelay(1);
1543                 phy_write(phydev, MII_BMCR, temp);
1544         }
1545
1546         usb_autopm_put_interface(dev->intf);
1547
1548         return ret;
1549 }
1550
1551 static void lan78xx_get_pause(struct net_device *net,
1552                               struct ethtool_pauseparam *pause)
1553 {
1554         struct lan78xx_net *dev = netdev_priv(net);
1555         struct phy_device *phydev = net->phydev;
1556         struct ethtool_link_ksettings ecmd;
1557
1558         phy_ethtool_ksettings_get(phydev, &ecmd);
1559
1560         pause->autoneg = dev->fc_autoneg;
1561
1562         if (dev->fc_request_control & FLOW_CTRL_TX)
1563                 pause->tx_pause = 1;
1564
1565         if (dev->fc_request_control & FLOW_CTRL_RX)
1566                 pause->rx_pause = 1;
1567 }
1568
1569 static int lan78xx_set_pause(struct net_device *net,
1570                              struct ethtool_pauseparam *pause)
1571 {
1572         struct lan78xx_net *dev = netdev_priv(net);
1573         struct phy_device *phydev = net->phydev;
1574         struct ethtool_link_ksettings ecmd;
1575         int ret;
1576
1577         phy_ethtool_ksettings_get(phydev, &ecmd);
1578
1579         if (pause->autoneg && !ecmd.base.autoneg) {
1580                 ret = -EINVAL;
1581                 goto exit;
1582         }
1583
1584         dev->fc_request_control = 0;
1585         if (pause->rx_pause)
1586                 dev->fc_request_control |= FLOW_CTRL_RX;
1587
1588         if (pause->tx_pause)
1589                 dev->fc_request_control |= FLOW_CTRL_TX;
1590
1591         if (ecmd.base.autoneg) {
1592                 __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
1593                 u32 mii_adv;
1594
1595                 linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
1596                                    ecmd.link_modes.advertising);
1597                 linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
1598                                    ecmd.link_modes.advertising);
1599                 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
1600                 mii_adv_to_linkmode_adv_t(fc, mii_adv);
1601                 linkmode_or(ecmd.link_modes.advertising, fc,
1602                             ecmd.link_modes.advertising);
1603
1604                 phy_ethtool_ksettings_set(phydev, &ecmd);
1605         }
1606
1607         dev->fc_autoneg = pause->autoneg;
1608
1609         ret = 0;
1610 exit:
1611         return ret;
1612 }
1613
1614 static int lan78xx_get_regs_len(struct net_device *netdev)
1615 {
1616         if (!netdev->phydev)
1617                 return (sizeof(lan78xx_regs));
1618         else
1619                 return (sizeof(lan78xx_regs) + PHY_REG_SIZE);
1620 }
1621
1622 static void
1623 lan78xx_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
1624                  void *buf)
1625 {
1626         u32 *data = buf;
1627         int i, j;
1628         struct lan78xx_net *dev = netdev_priv(netdev);
1629
1630         /* Read Device/MAC registers */
1631         for (i = 0; i < ARRAY_SIZE(lan78xx_regs); i++)
1632                 lan78xx_read_reg(dev, lan78xx_regs[i], &data[i]);
1633
1634         if (!netdev->phydev)
1635                 return;
1636
1637         /* Read PHY registers */
1638         for (j = 0; j < 32; i++, j++)
1639                 data[i] = phy_read(netdev->phydev, j);
1640 }
1641
1642 static const struct ethtool_ops lan78xx_ethtool_ops = {
1643         .get_link       = lan78xx_get_link,
1644         .nway_reset     = phy_ethtool_nway_reset,
1645         .get_drvinfo    = lan78xx_get_drvinfo,
1646         .get_msglevel   = lan78xx_get_msglevel,
1647         .set_msglevel   = lan78xx_set_msglevel,
1648         .get_eeprom_len = lan78xx_ethtool_get_eeprom_len,
1649         .get_eeprom     = lan78xx_ethtool_get_eeprom,
1650         .set_eeprom     = lan78xx_ethtool_set_eeprom,
1651         .get_ethtool_stats = lan78xx_get_stats,
1652         .get_sset_count = lan78xx_get_sset_count,
1653         .get_strings    = lan78xx_get_strings,
1654         .get_wol        = lan78xx_get_wol,
1655         .set_wol        = lan78xx_set_wol,
1656         .get_eee        = lan78xx_get_eee,
1657         .set_eee        = lan78xx_set_eee,
1658         .get_pauseparam = lan78xx_get_pause,
1659         .set_pauseparam = lan78xx_set_pause,
1660         .get_link_ksettings = lan78xx_get_link_ksettings,
1661         .set_link_ksettings = lan78xx_set_link_ksettings,
1662         .get_regs_len   = lan78xx_get_regs_len,
1663         .get_regs       = lan78xx_get_regs,
1664 };
1665
1666 static int lan78xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
1667 {
1668         if (!netif_running(netdev))
1669                 return -EINVAL;
1670
1671         return phy_mii_ioctl(netdev->phydev, rq, cmd);
1672 }
1673
1674 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1675 {
1676         u32 addr_lo, addr_hi;
1677         int ret;
1678         u8 addr[6];
1679
1680         ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1681         ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1682
1683         addr[0] = addr_lo & 0xFF;
1684         addr[1] = (addr_lo >> 8) & 0xFF;
1685         addr[2] = (addr_lo >> 16) & 0xFF;
1686         addr[3] = (addr_lo >> 24) & 0xFF;
1687         addr[4] = addr_hi & 0xFF;
1688         addr[5] = (addr_hi >> 8) & 0xFF;
1689
1690         if (!is_valid_ether_addr(addr)) {
1691                 if (!eth_platform_get_mac_address(&dev->udev->dev, addr)) {
1692                         /* valid address present in Device Tree */
1693                         netif_dbg(dev, ifup, dev->net,
1694                                   "MAC address read from Device Tree");
1695                 } else if (((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET,
1696                                                  ETH_ALEN, addr) == 0) ||
1697                             (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET,
1698                                               ETH_ALEN, addr) == 0)) &&
1699                            is_valid_ether_addr(addr)) {
1700                         /* eeprom values are valid so use them */
1701                         netif_dbg(dev, ifup, dev->net,
1702                                   "MAC address read from EEPROM");
1703                 } else {
1704                         /* generate random MAC */
1705                         eth_random_addr(addr);
1706                         netif_dbg(dev, ifup, dev->net,
1707                                   "MAC address set to random addr");
1708                 }
1709
1710                 addr_lo = addr[0] | (addr[1] << 8) |
1711                           (addr[2] << 16) | (addr[3] << 24);
1712                 addr_hi = addr[4] | (addr[5] << 8);
1713
1714                 ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1715                 ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1716         }
1717
1718         ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1719         ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1720
1721         ether_addr_copy(dev->net->dev_addr, addr);
1722 }
1723
1724 /* MDIO read and write wrappers for phylib */
1725 static int lan78xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
1726 {
1727         struct lan78xx_net *dev = bus->priv;
1728         u32 val, addr;
1729         int ret;
1730
1731         ret = usb_autopm_get_interface(dev->intf);
1732         if (ret < 0)
1733                 return ret;
1734
1735         mutex_lock(&dev->phy_mutex);
1736
1737         /* confirm MII not busy */
1738         ret = lan78xx_phy_wait_not_busy(dev);
1739         if (ret < 0)
1740                 goto done;
1741
1742         /* set the address, index & direction (read from PHY) */
1743         addr = mii_access(phy_id, idx, MII_READ);
1744         ret = lan78xx_write_reg(dev, MII_ACC, addr);
1745
1746         ret = lan78xx_phy_wait_not_busy(dev);
1747         if (ret < 0)
1748                 goto done;
1749
1750         ret = lan78xx_read_reg(dev, MII_DATA, &val);
1751
1752         ret = (int)(val & 0xFFFF);
1753
1754 done:
1755         mutex_unlock(&dev->phy_mutex);
1756         usb_autopm_put_interface(dev->intf);
1757
1758         return ret;
1759 }
1760
1761 static int lan78xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
1762                                  u16 regval)
1763 {
1764         struct lan78xx_net *dev = bus->priv;
1765         u32 val, addr;
1766         int ret;
1767
1768         ret = usb_autopm_get_interface(dev->intf);
1769         if (ret < 0)
1770                 return ret;
1771
1772         mutex_lock(&dev->phy_mutex);
1773
1774         /* confirm MII not busy */
1775         ret = lan78xx_phy_wait_not_busy(dev);
1776         if (ret < 0)
1777                 goto done;
1778
1779         val = (u32)regval;
1780         ret = lan78xx_write_reg(dev, MII_DATA, val);
1781
1782         /* set the address, index & direction (write to PHY) */
1783         addr = mii_access(phy_id, idx, MII_WRITE);
1784         ret = lan78xx_write_reg(dev, MII_ACC, addr);
1785
1786         ret = lan78xx_phy_wait_not_busy(dev);
1787         if (ret < 0)
1788                 goto done;
1789
1790 done:
1791         mutex_unlock(&dev->phy_mutex);
1792         usb_autopm_put_interface(dev->intf);
1793         return 0;
1794 }
1795
1796 static int lan78xx_mdio_init(struct lan78xx_net *dev)
1797 {
1798         struct device_node *node;
1799         int ret;
1800
1801         dev->mdiobus = mdiobus_alloc();
1802         if (!dev->mdiobus) {
1803                 netdev_err(dev->net, "can't allocate MDIO bus\n");
1804                 return -ENOMEM;
1805         }
1806
1807         dev->mdiobus->priv = (void *)dev;
1808         dev->mdiobus->read = lan78xx_mdiobus_read;
1809         dev->mdiobus->write = lan78xx_mdiobus_write;
1810         dev->mdiobus->name = "lan78xx-mdiobus";
1811         dev->mdiobus->parent = &dev->udev->dev;
1812
1813         snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
1814                  dev->udev->bus->busnum, dev->udev->devnum);
1815
1816         switch (dev->chipid) {
1817         case ID_REV_CHIP_ID_7800_:
1818         case ID_REV_CHIP_ID_7850_:
1819                 /* set to internal PHY id */
1820                 dev->mdiobus->phy_mask = ~(1 << 1);
1821                 break;
1822         case ID_REV_CHIP_ID_7801_:
1823                 /* scan thru PHYAD[2..0] */
1824                 dev->mdiobus->phy_mask = ~(0xFF);
1825                 break;
1826         }
1827
1828         node = of_get_child_by_name(dev->udev->dev.of_node, "mdio");
1829         ret = of_mdiobus_register(dev->mdiobus, node);
1830         of_node_put(node);
1831         if (ret) {
1832                 netdev_err(dev->net, "can't register MDIO bus\n");
1833                 goto exit1;
1834         }
1835
1836         netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
1837         return 0;
1838 exit1:
1839         mdiobus_free(dev->mdiobus);
1840         return ret;
1841 }
1842
1843 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
1844 {
1845         mdiobus_unregister(dev->mdiobus);
1846         mdiobus_free(dev->mdiobus);
1847 }
1848
1849 static void lan78xx_link_status_change(struct net_device *net)
1850 {
1851         struct phy_device *phydev = net->phydev;
1852         int ret, temp;
1853
1854         /* At forced 100 F/H mode, chip may fail to set mode correctly
1855          * when cable is switched between long(~50+m) and short one.
1856          * As workaround, set to 10 before setting to 100
1857          * at forced 100 F/H mode.
1858          */
1859         if (!phydev->autoneg && (phydev->speed == 100)) {
1860                 /* disable phy interrupt */
1861                 temp = phy_read(phydev, LAN88XX_INT_MASK);
1862                 temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
1863                 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1864
1865                 temp = phy_read(phydev, MII_BMCR);
1866                 temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
1867                 phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
1868                 temp |= BMCR_SPEED100;
1869                 phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
1870
1871                 /* clear pending interrupt generated while workaround */
1872                 temp = phy_read(phydev, LAN88XX_INT_STS);
1873
1874                 /* enable phy interrupt back */
1875                 temp = phy_read(phydev, LAN88XX_INT_MASK);
1876                 temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
1877                 ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
1878         }
1879 }
1880
1881 static int irq_map(struct irq_domain *d, unsigned int irq,
1882                    irq_hw_number_t hwirq)
1883 {
1884         struct irq_domain_data *data = d->host_data;
1885
1886         irq_set_chip_data(irq, data);
1887         irq_set_chip_and_handler(irq, data->irqchip, data->irq_handler);
1888         irq_set_noprobe(irq);
1889
1890         return 0;
1891 }
1892
1893 static void irq_unmap(struct irq_domain *d, unsigned int irq)
1894 {
1895         irq_set_chip_and_handler(irq, NULL, NULL);
1896         irq_set_chip_data(irq, NULL);
1897 }
1898
1899 static const struct irq_domain_ops chip_domain_ops = {
1900         .map    = irq_map,
1901         .unmap  = irq_unmap,
1902 };
1903
1904 static void lan78xx_irq_mask(struct irq_data *irqd)
1905 {
1906         struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1907
1908         data->irqenable &= ~BIT(irqd_to_hwirq(irqd));
1909 }
1910
1911 static void lan78xx_irq_unmask(struct irq_data *irqd)
1912 {
1913         struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1914
1915         data->irqenable |= BIT(irqd_to_hwirq(irqd));
1916 }
1917
1918 static void lan78xx_irq_bus_lock(struct irq_data *irqd)
1919 {
1920         struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1921
1922         mutex_lock(&data->irq_lock);
1923 }
1924
1925 static void lan78xx_irq_bus_sync_unlock(struct irq_data *irqd)
1926 {
1927         struct irq_domain_data *data = irq_data_get_irq_chip_data(irqd);
1928         struct lan78xx_net *dev =
1929                         container_of(data, struct lan78xx_net, domain_data);
1930         u32 buf;
1931         int ret;
1932
1933         /* call register access here because irq_bus_lock & irq_bus_sync_unlock
1934          * are only two callbacks executed in non-atomic contex.
1935          */
1936         ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1937         if (buf != data->irqenable)
1938                 ret = lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
1939
1940         mutex_unlock(&data->irq_lock);
1941 }
1942
1943 static struct irq_chip lan78xx_irqchip = {
1944         .name                   = "lan78xx-irqs",
1945         .irq_mask               = lan78xx_irq_mask,
1946         .irq_unmask             = lan78xx_irq_unmask,
1947         .irq_bus_lock           = lan78xx_irq_bus_lock,
1948         .irq_bus_sync_unlock    = lan78xx_irq_bus_sync_unlock,
1949 };
1950
1951 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
1952 {
1953         struct device_node *of_node;
1954         struct irq_domain *irqdomain;
1955         unsigned int irqmap = 0;
1956         u32 buf;
1957         int ret = 0;
1958
1959         of_node = dev->udev->dev.parent->of_node;
1960
1961         mutex_init(&dev->domain_data.irq_lock);
1962
1963         lan78xx_read_reg(dev, INT_EP_CTL, &buf);
1964         dev->domain_data.irqenable = buf;
1965
1966         dev->domain_data.irqchip = &lan78xx_irqchip;
1967         dev->domain_data.irq_handler = handle_simple_irq;
1968
1969         irqdomain = irq_domain_add_simple(of_node, MAX_INT_EP, 0,
1970                                           &chip_domain_ops, &dev->domain_data);
1971         if (irqdomain) {
1972                 /* create mapping for PHY interrupt */
1973                 irqmap = irq_create_mapping(irqdomain, INT_EP_PHY);
1974                 if (!irqmap) {
1975                         irq_domain_remove(irqdomain);
1976
1977                         irqdomain = NULL;
1978                         ret = -EINVAL;
1979                 }
1980         } else {
1981                 ret = -EINVAL;
1982         }
1983
1984         dev->domain_data.irqdomain = irqdomain;
1985         dev->domain_data.phyirq = irqmap;
1986
1987         return ret;
1988 }
1989
1990 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
1991 {
1992         if (dev->domain_data.phyirq > 0) {
1993                 irq_dispose_mapping(dev->domain_data.phyirq);
1994
1995                 if (dev->domain_data.irqdomain)
1996                         irq_domain_remove(dev->domain_data.irqdomain);
1997         }
1998         dev->domain_data.phyirq = 0;
1999         dev->domain_data.irqdomain = NULL;
2000 }
2001
2002 static int lan8835_fixup(struct phy_device *phydev)
2003 {
2004         int buf;
2005         int ret;
2006         struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2007
2008         /* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */
2009         buf = phy_read_mmd(phydev, MDIO_MMD_PCS, 0x8010);
2010         buf &= ~0x1800;
2011         buf |= 0x0800;
2012         phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf);
2013
2014         /* RGMII MAC TXC Delay Enable */
2015         ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2016                                 MAC_RGMII_ID_TXC_DELAY_EN_);
2017
2018         /* RGMII TX DLL Tune Adjust */
2019         ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2020
2021         dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
2022
2023         return 1;
2024 }
2025
2026 static int ksz9031rnx_fixup(struct phy_device *phydev)
2027 {
2028         struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2029
2030         /* Micrel9301RNX PHY configuration */
2031         /* RGMII Control Signal Pad Skew */
2032         phy_write_mmd(phydev, MDIO_MMD_WIS, 4, 0x0077);
2033         /* RGMII RX Data Pad Skew */
2034         phy_write_mmd(phydev, MDIO_MMD_WIS, 5, 0x7777);
2035         /* RGMII RX Clock Pad Skew */
2036         phy_write_mmd(phydev, MDIO_MMD_WIS, 8, 0x1FF);
2037
2038         dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
2039
2040         return 1;
2041 }
2042
2043 static struct phy_device *lan7801_phy_init(struct lan78xx_net *dev)
2044 {
2045         u32 buf;
2046         int ret;
2047         struct fixed_phy_status fphy_status = {
2048                 .link = 1,
2049                 .speed = SPEED_1000,
2050                 .duplex = DUPLEX_FULL,
2051         };
2052         struct phy_device *phydev;
2053
2054         phydev = phy_find_first(dev->mdiobus);
2055         if (!phydev) {
2056                 netdev_dbg(dev->net, "PHY Not Found!! Registering Fixed PHY\n");
2057                 phydev = fixed_phy_register(PHY_POLL, &fphy_status, NULL);
2058                 if (IS_ERR(phydev)) {
2059                         netdev_err(dev->net, "No PHY/fixed_PHY found\n");
2060                         return NULL;
2061                 }
2062                 netdev_dbg(dev->net, "Registered FIXED PHY\n");
2063                 dev->interface = PHY_INTERFACE_MODE_RGMII;
2064                 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2065                                         MAC_RGMII_ID_TXC_DELAY_EN_);
2066                 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2067                 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2068                 buf |= HW_CFG_CLK125_EN_;
2069                 buf |= HW_CFG_REFCLK25_EN_;
2070                 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2071         } else {
2072                 if (!phydev->drv) {
2073                         netdev_err(dev->net, "no PHY driver found\n");
2074                         return NULL;
2075                 }
2076                 dev->interface = PHY_INTERFACE_MODE_RGMII;
2077                 /* external PHY fixup for KSZ9031RNX */
2078                 ret = phy_register_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0,
2079                                                  ksz9031rnx_fixup);
2080                 if (ret < 0) {
2081                         netdev_err(dev->net, "Failed to register fixup for PHY_KSZ9031RNX\n");
2082                         return NULL;
2083                 }
2084                 /* external PHY fixup for LAN8835 */
2085                 ret = phy_register_fixup_for_uid(PHY_LAN8835, 0xfffffff0,
2086                                                  lan8835_fixup);
2087                 if (ret < 0) {
2088                         netdev_err(dev->net, "Failed to register fixup for PHY_LAN8835\n");
2089                         return NULL;
2090                 }
2091                 /* add more external PHY fixup here if needed */
2092
2093                 phydev->is_internal = false;
2094         }
2095         return phydev;
2096 }
2097
2098 static int lan78xx_phy_init(struct lan78xx_net *dev)
2099 {
2100         __ETHTOOL_DECLARE_LINK_MODE_MASK(fc) = { 0, };
2101         int ret;
2102         u32 mii_adv;
2103         struct phy_device *phydev;
2104
2105         switch (dev->chipid) {
2106         case ID_REV_CHIP_ID_7801_:
2107                 phydev = lan7801_phy_init(dev);
2108                 if (!phydev) {
2109                         netdev_err(dev->net, "lan7801: PHY Init Failed");
2110                         return -EIO;
2111                 }
2112                 break;
2113
2114         case ID_REV_CHIP_ID_7800_:
2115         case ID_REV_CHIP_ID_7850_:
2116                 phydev = phy_find_first(dev->mdiobus);
2117                 if (!phydev) {
2118                         netdev_err(dev->net, "no PHY found\n");
2119                         return -EIO;
2120                 }
2121                 phydev->is_internal = true;
2122                 dev->interface = PHY_INTERFACE_MODE_GMII;
2123                 break;
2124
2125         default:
2126                 netdev_err(dev->net, "Unknown CHIP ID found\n");
2127                 return -EIO;
2128         }
2129
2130         /* if phyirq is not set, use polling mode in phylib */
2131         if (dev->domain_data.phyirq > 0)
2132                 phydev->irq = dev->domain_data.phyirq;
2133         else
2134                 phydev->irq = 0;
2135         netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2136
2137         /* set to AUTOMDIX */
2138         phydev->mdix = ETH_TP_MDI_AUTO;
2139
2140         ret = phy_connect_direct(dev->net, phydev,
2141                                  lan78xx_link_status_change,
2142                                  dev->interface);
2143         if (ret) {
2144                 netdev_err(dev->net, "can't attach PHY to %s\n",
2145                            dev->mdiobus->id);
2146                 if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2147                         if (phy_is_pseudo_fixed_link(phydev)) {
2148                                 fixed_phy_unregister(phydev);
2149                         } else {
2150                                 phy_unregister_fixup_for_uid(PHY_KSZ9031RNX,
2151                                                              0xfffffff0);
2152                                 phy_unregister_fixup_for_uid(PHY_LAN8835,
2153                                                              0xfffffff0);
2154                         }
2155                 }
2156                 return -EIO;
2157         }
2158
2159         /* MAC doesn't support 1000T Half */
2160         phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
2161
2162         /* support both flow controls */
2163         dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2164         linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT,
2165                            phydev->advertising);
2166         linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT,
2167                            phydev->advertising);
2168         mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2169         mii_adv_to_linkmode_adv_t(fc, mii_adv);
2170         linkmode_or(phydev->advertising, fc, phydev->advertising);
2171
2172         if (phydev->mdio.dev.of_node) {
2173                 u32 reg;
2174                 int len;
2175
2176                 len = of_property_count_elems_of_size(phydev->mdio.dev.of_node,
2177                                                       "microchip,led-modes",
2178                                                       sizeof(u32));
2179                 if (len >= 0) {
2180                         /* Ensure the appropriate LEDs are enabled */
2181                         lan78xx_read_reg(dev, HW_CFG, &reg);
2182                         reg &= ~(HW_CFG_LED0_EN_ |
2183                                  HW_CFG_LED1_EN_ |
2184                                  HW_CFG_LED2_EN_ |
2185                                  HW_CFG_LED3_EN_);
2186                         reg |= (len > 0) * HW_CFG_LED0_EN_ |
2187                                 (len > 1) * HW_CFG_LED1_EN_ |
2188                                 (len > 2) * HW_CFG_LED2_EN_ |
2189                                 (len > 3) * HW_CFG_LED3_EN_;
2190                         lan78xx_write_reg(dev, HW_CFG, reg);
2191                 }
2192         }
2193
2194         genphy_config_aneg(phydev);
2195
2196         dev->fc_autoneg = phydev->autoneg;
2197
2198         return 0;
2199 }
2200
2201 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2202 {
2203         int ret = 0;
2204         u32 buf;
2205         bool rxenabled;
2206
2207         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2208
2209         rxenabled = ((buf & MAC_RX_RXEN_) != 0);
2210
2211         if (rxenabled) {
2212                 buf &= ~MAC_RX_RXEN_;
2213                 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2214         }
2215
2216         /* add 4 to size for FCS */
2217         buf &= ~MAC_RX_MAX_SIZE_MASK_;
2218         buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
2219
2220         ret = lan78xx_write_reg(dev, MAC_RX, buf);
2221
2222         if (rxenabled) {
2223                 buf |= MAC_RX_RXEN_;
2224                 ret = lan78xx_write_reg(dev, MAC_RX, buf);
2225         }
2226
2227         return 0;
2228 }
2229
2230 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2231 {
2232         struct sk_buff *skb;
2233         unsigned long flags;
2234         int count = 0;
2235
2236         spin_lock_irqsave(&q->lock, flags);
2237         while (!skb_queue_empty(q)) {
2238                 struct skb_data *entry;
2239                 struct urb *urb;
2240                 int ret;
2241
2242                 skb_queue_walk(q, skb) {
2243                         entry = (struct skb_data *)skb->cb;
2244                         if (entry->state != unlink_start)
2245                                 goto found;
2246                 }
2247                 break;
2248 found:
2249                 entry->state = unlink_start;
2250                 urb = entry->urb;
2251
2252                 /* Get reference count of the URB to avoid it to be
2253                  * freed during usb_unlink_urb, which may trigger
2254                  * use-after-free problem inside usb_unlink_urb since
2255                  * usb_unlink_urb is always racing with .complete
2256                  * handler(include defer_bh).
2257                  */
2258                 usb_get_urb(urb);
2259                 spin_unlock_irqrestore(&q->lock, flags);
2260                 /* during some PM-driven resume scenarios,
2261                  * these (async) unlinks complete immediately
2262                  */
2263                 ret = usb_unlink_urb(urb);
2264                 if (ret != -EINPROGRESS && ret != 0)
2265                         netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2266                 else
2267                         count++;
2268                 usb_put_urb(urb);
2269                 spin_lock_irqsave(&q->lock, flags);
2270         }
2271         spin_unlock_irqrestore(&q->lock, flags);
2272         return count;
2273 }
2274
2275 static int lan78xx_change_mtu(struct net_device *netdev, int new_mtu)
2276 {
2277         struct lan78xx_net *dev = netdev_priv(netdev);
2278         int ll_mtu = new_mtu + netdev->hard_header_len;
2279         int old_hard_mtu = dev->hard_mtu;
2280         int old_rx_urb_size = dev->rx_urb_size;
2281         int ret;
2282
2283         /* no second zero-length packet read wanted after mtu-sized packets */
2284         if ((ll_mtu % dev->maxpacket) == 0)
2285                 return -EDOM;
2286
2287         ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + VLAN_ETH_HLEN);
2288
2289         netdev->mtu = new_mtu;
2290
2291         dev->hard_mtu = netdev->mtu + netdev->hard_header_len;
2292         if (dev->rx_urb_size == old_hard_mtu) {
2293                 dev->rx_urb_size = dev->hard_mtu;
2294                 if (dev->rx_urb_size > old_rx_urb_size) {
2295                         if (netif_running(dev->net)) {
2296                                 unlink_urbs(dev, &dev->rxq);
2297                                 tasklet_schedule(&dev->bh);
2298                         }
2299                 }
2300         }
2301
2302         return 0;
2303 }
2304
2305 static int lan78xx_set_mac_addr(struct net_device *netdev, void *p)
2306 {
2307         struct lan78xx_net *dev = netdev_priv(netdev);
2308         struct sockaddr *addr = p;
2309         u32 addr_lo, addr_hi;
2310         int ret;
2311
2312         if (netif_running(netdev))
2313                 return -EBUSY;
2314
2315         if (!is_valid_ether_addr(addr->sa_data))
2316                 return -EADDRNOTAVAIL;
2317
2318         ether_addr_copy(netdev->dev_addr, addr->sa_data);
2319
2320         addr_lo = netdev->dev_addr[0] |
2321                   netdev->dev_addr[1] << 8 |
2322                   netdev->dev_addr[2] << 16 |
2323                   netdev->dev_addr[3] << 24;
2324         addr_hi = netdev->dev_addr[4] |
2325                   netdev->dev_addr[5] << 8;
2326
2327         ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2328         ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2329
2330         /* Added to support MAC address changes */
2331         ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2332         ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2333
2334         return 0;
2335 }
2336
2337 /* Enable or disable Rx checksum offload engine */
2338 static int lan78xx_set_features(struct net_device *netdev,
2339                                 netdev_features_t features)
2340 {
2341         struct lan78xx_net *dev = netdev_priv(netdev);
2342         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2343         unsigned long flags;
2344         int ret;
2345
2346         spin_lock_irqsave(&pdata->rfe_ctl_lock, flags);
2347
2348         if (features & NETIF_F_RXCSUM) {
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         } else {
2352                 pdata->rfe_ctl &= ~(RFE_CTL_TCPUDP_COE_ | RFE_CTL_IP_COE_);
2353                 pdata->rfe_ctl &= ~(RFE_CTL_ICMP_COE_ | RFE_CTL_IGMP_COE_);
2354         }
2355
2356         if (features & NETIF_F_HW_VLAN_CTAG_RX)
2357                 pdata->rfe_ctl |= RFE_CTL_VLAN_STRIP_;
2358         else
2359                 pdata->rfe_ctl &= ~RFE_CTL_VLAN_STRIP_;
2360
2361         if (features & NETIF_F_HW_VLAN_CTAG_FILTER)
2362                 pdata->rfe_ctl |= RFE_CTL_VLAN_FILTER_;
2363         else
2364                 pdata->rfe_ctl &= ~RFE_CTL_VLAN_FILTER_;
2365
2366         spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags);
2367
2368         ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2369
2370         return 0;
2371 }
2372
2373 static void lan78xx_deferred_vlan_write(struct work_struct *param)
2374 {
2375         struct lan78xx_priv *pdata =
2376                         container_of(param, struct lan78xx_priv, set_vlan);
2377         struct lan78xx_net *dev = pdata->dev;
2378
2379         lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2380                                DP_SEL_VHF_VLAN_LEN, pdata->vlan_table);
2381 }
2382
2383 static int lan78xx_vlan_rx_add_vid(struct net_device *netdev,
2384                                    __be16 proto, u16 vid)
2385 {
2386         struct lan78xx_net *dev = netdev_priv(netdev);
2387         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2388         u16 vid_bit_index;
2389         u16 vid_dword_index;
2390
2391         vid_dword_index = (vid >> 5) & 0x7F;
2392         vid_bit_index = vid & 0x1F;
2393
2394         pdata->vlan_table[vid_dword_index] |= (1 << vid_bit_index);
2395
2396         /* defer register writes to a sleepable context */
2397         schedule_work(&pdata->set_vlan);
2398
2399         return 0;
2400 }
2401
2402 static int lan78xx_vlan_rx_kill_vid(struct net_device *netdev,
2403                                     __be16 proto, u16 vid)
2404 {
2405         struct lan78xx_net *dev = netdev_priv(netdev);
2406         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2407         u16 vid_bit_index;
2408         u16 vid_dword_index;
2409
2410         vid_dword_index = (vid >> 5) & 0x7F;
2411         vid_bit_index = vid & 0x1F;
2412
2413         pdata->vlan_table[vid_dword_index] &= ~(1 << vid_bit_index);
2414
2415         /* defer register writes to a sleepable context */
2416         schedule_work(&pdata->set_vlan);
2417
2418         return 0;
2419 }
2420
2421 static void lan78xx_init_ltm(struct lan78xx_net *dev)
2422 {
2423         int ret;
2424         u32 buf;
2425         u32 regs[6] = { 0 };
2426
2427         ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2428         if (buf & USB_CFG1_LTM_ENABLE_) {
2429                 u8 temp[2];
2430                 /* Get values from EEPROM first */
2431                 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2432                         if (temp[0] == 24) {
2433                                 ret = lan78xx_read_raw_eeprom(dev,
2434                                                               temp[1] * 2,
2435                                                               24,
2436                                                               (u8 *)regs);
2437                                 if (ret < 0)
2438                                         return;
2439                         }
2440                 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2441                         if (temp[0] == 24) {
2442                                 ret = lan78xx_read_raw_otp(dev,
2443                                                            temp[1] * 2,
2444                                                            24,
2445                                                            (u8 *)regs);
2446                                 if (ret < 0)
2447                                         return;
2448                         }
2449                 }
2450         }
2451
2452         lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2453         lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2454         lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2455         lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2456         lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2457         lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2458 }
2459
2460 static int lan78xx_reset(struct lan78xx_net *dev)
2461 {
2462         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2463         u32 buf;
2464         int ret = 0;
2465         unsigned long timeout;
2466         u8 sig;
2467
2468         ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2469         buf |= HW_CFG_LRST_;
2470         ret = lan78xx_write_reg(dev, HW_CFG, buf);
2471
2472         timeout = jiffies + HZ;
2473         do {
2474                 mdelay(1);
2475                 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2476                 if (time_after(jiffies, timeout)) {
2477                         netdev_warn(dev->net,
2478                                     "timeout on completion of LiteReset");
2479                         return -EIO;
2480                 }
2481         } while (buf & HW_CFG_LRST_);
2482
2483         lan78xx_init_mac_address(dev);
2484
2485         /* save DEVID for later usage */
2486         ret = lan78xx_read_reg(dev, ID_REV, &buf);
2487         dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2488         dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2489
2490         /* Respond to the IN token with a NAK */
2491         ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2492         buf |= USB_CFG_BIR_;
2493         ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2494
2495         /* Init LTM */
2496         lan78xx_init_ltm(dev);
2497
2498         if (dev->udev->speed == USB_SPEED_SUPER) {
2499                 buf = DEFAULT_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2500                 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2501                 dev->rx_qlen = 4;
2502                 dev->tx_qlen = 4;
2503         } else if (dev->udev->speed == USB_SPEED_HIGH) {
2504                 buf = DEFAULT_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2505                 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2506                 dev->rx_qlen = RX_MAX_QUEUE_MEMORY / dev->rx_urb_size;
2507                 dev->tx_qlen = RX_MAX_QUEUE_MEMORY / dev->hard_mtu;
2508         } else {
2509                 buf = DEFAULT_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2510                 dev->rx_urb_size = DEFAULT_BURST_CAP_SIZE;
2511                 dev->rx_qlen = 4;
2512                 dev->tx_qlen = 4;
2513         }
2514
2515         ret = lan78xx_write_reg(dev, BURST_CAP, buf);
2516         ret = lan78xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
2517
2518         ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2519         buf |= HW_CFG_MEF_;
2520         ret = lan78xx_write_reg(dev, HW_CFG, buf);
2521
2522         ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2523         buf |= USB_CFG_BCE_;
2524         ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2525
2526         /* set FIFO sizes */
2527         buf = (MAX_RX_FIFO_SIZE - 512) / 512;
2528         ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2529
2530         buf = (MAX_TX_FIFO_SIZE - 512) / 512;
2531         ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2532
2533         ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2534         ret = lan78xx_write_reg(dev, FLOW, 0);
2535         ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2536
2537         /* Don't need rfe_ctl_lock during initialisation */
2538         ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2539         pdata->rfe_ctl |= RFE_CTL_BCAST_EN_ | RFE_CTL_DA_PERFECT_;
2540         ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2541
2542         /* Enable or disable checksum offload engines */
2543         lan78xx_set_features(dev->net, dev->net->features);
2544
2545         lan78xx_set_multicast(dev->net);
2546
2547         /* reset PHY */
2548         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2549         buf |= PMT_CTL_PHY_RST_;
2550         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
2551
2552         timeout = jiffies + HZ;
2553         do {
2554                 mdelay(1);
2555                 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
2556                 if (time_after(jiffies, timeout)) {
2557                         netdev_warn(dev->net, "timeout waiting for PHY Reset");
2558                         return -EIO;
2559                 }
2560         } while ((buf & PMT_CTL_PHY_RST_) || !(buf & PMT_CTL_READY_));
2561
2562         ret = lan78xx_read_reg(dev, MAC_CR, &buf);
2563         /* LAN7801 only has RGMII mode */
2564         if (dev->chipid == ID_REV_CHIP_ID_7801_)
2565                 buf &= ~MAC_CR_GMII_EN_;
2566
2567         if (dev->chipid == ID_REV_CHIP_ID_7800_) {
2568                 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
2569                 if (!ret && sig != EEPROM_INDICATOR) {
2570                         /* Implies there is no external eeprom. Set mac speed */
2571                         netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
2572                         buf |= MAC_CR_AUTO_DUPLEX_ | MAC_CR_AUTO_SPEED_;
2573                 }
2574         }
2575         ret = lan78xx_write_reg(dev, MAC_CR, buf);
2576
2577         ret = lan78xx_read_reg(dev, MAC_TX, &buf);
2578         buf |= MAC_TX_TXEN_;
2579         ret = lan78xx_write_reg(dev, MAC_TX, buf);
2580
2581         ret = lan78xx_read_reg(dev, FCT_TX_CTL, &buf);
2582         buf |= FCT_TX_CTL_EN_;
2583         ret = lan78xx_write_reg(dev, FCT_TX_CTL, buf);
2584
2585         ret = lan78xx_set_rx_max_frame_length(dev,
2586                                               dev->net->mtu + VLAN_ETH_HLEN);
2587
2588         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
2589         buf |= MAC_RX_RXEN_;
2590         ret = lan78xx_write_reg(dev, MAC_RX, buf);
2591
2592         ret = lan78xx_read_reg(dev, FCT_RX_CTL, &buf);
2593         buf |= FCT_RX_CTL_EN_;
2594         ret = lan78xx_write_reg(dev, FCT_RX_CTL, buf);
2595
2596         return 0;
2597 }
2598
2599 static void lan78xx_init_stats(struct lan78xx_net *dev)
2600 {
2601         u32 *p;
2602         int i;
2603
2604         /* initialize for stats update
2605          * some counters are 20bits and some are 32bits
2606          */
2607         p = (u32 *)&dev->stats.rollover_max;
2608         for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
2609                 p[i] = 0xFFFFF;
2610
2611         dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
2612         dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
2613         dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
2614         dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
2615         dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
2616         dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
2617         dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
2618         dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
2619         dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
2620         dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
2621
2622         set_bit(EVENT_STAT_UPDATE, &dev->flags);
2623 }
2624
2625 static int lan78xx_open(struct net_device *net)
2626 {
2627         struct lan78xx_net *dev = netdev_priv(net);
2628         int ret;
2629
2630         ret = usb_autopm_get_interface(dev->intf);
2631         if (ret < 0)
2632                 goto out;
2633
2634         phy_start(net->phydev);
2635
2636         netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
2637
2638         /* for Link Check */
2639         if (dev->urb_intr) {
2640                 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
2641                 if (ret < 0) {
2642                         netif_err(dev, ifup, dev->net,
2643                                   "intr submit %d\n", ret);
2644                         goto done;
2645                 }
2646         }
2647
2648         lan78xx_init_stats(dev);
2649
2650         set_bit(EVENT_DEV_OPEN, &dev->flags);
2651
2652         netif_start_queue(net);
2653
2654         dev->link_on = false;
2655
2656         lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
2657 done:
2658         usb_autopm_put_interface(dev->intf);
2659
2660 out:
2661         return ret;
2662 }
2663
2664 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
2665 {
2666         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(unlink_wakeup);
2667         DECLARE_WAITQUEUE(wait, current);
2668         int temp;
2669
2670         /* ensure there are no more active urbs */
2671         add_wait_queue(&unlink_wakeup, &wait);
2672         set_current_state(TASK_UNINTERRUPTIBLE);
2673         dev->wait = &unlink_wakeup;
2674         temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
2675
2676         /* maybe wait for deletions to finish. */
2677         while (!skb_queue_empty(&dev->rxq) &&
2678                !skb_queue_empty(&dev->txq) &&
2679                !skb_queue_empty(&dev->done)) {
2680                 schedule_timeout(msecs_to_jiffies(UNLINK_TIMEOUT_MS));
2681                 set_current_state(TASK_UNINTERRUPTIBLE);
2682                 netif_dbg(dev, ifdown, dev->net,
2683                           "waited for %d urb completions\n", temp);
2684         }
2685         set_current_state(TASK_RUNNING);
2686         dev->wait = NULL;
2687         remove_wait_queue(&unlink_wakeup, &wait);
2688 }
2689
2690 static int lan78xx_stop(struct net_device *net)
2691 {
2692         struct lan78xx_net *dev = netdev_priv(net);
2693
2694         if (timer_pending(&dev->stat_monitor))
2695                 del_timer_sync(&dev->stat_monitor);
2696
2697         if (net->phydev)
2698                 phy_stop(net->phydev);
2699
2700         clear_bit(EVENT_DEV_OPEN, &dev->flags);
2701         netif_stop_queue(net);
2702
2703         netif_info(dev, ifdown, dev->net,
2704                    "stop stats: rx/tx %lu/%lu, errs %lu/%lu\n",
2705                    net->stats.rx_packets, net->stats.tx_packets,
2706                    net->stats.rx_errors, net->stats.tx_errors);
2707
2708         lan78xx_terminate_urbs(dev);
2709
2710         usb_kill_urb(dev->urb_intr);
2711
2712         skb_queue_purge(&dev->rxq_pause);
2713
2714         /* deferred work (task, timer, softirq) must also stop.
2715          * can't flush_scheduled_work() until we drop rtnl (later),
2716          * else workers could deadlock; so make workers a NOP.
2717          */
2718         dev->flags = 0;
2719         cancel_delayed_work_sync(&dev->wq);
2720         tasklet_kill(&dev->bh);
2721
2722         usb_autopm_put_interface(dev->intf);
2723
2724         return 0;
2725 }
2726
2727 static int lan78xx_linearize(struct sk_buff *skb)
2728 {
2729         return skb_linearize(skb);
2730 }
2731
2732 static struct sk_buff *lan78xx_tx_prep(struct lan78xx_net *dev,
2733                                        struct sk_buff *skb, gfp_t flags)
2734 {
2735         u32 tx_cmd_a, tx_cmd_b;
2736         void *ptr;
2737
2738         if (skb_cow_head(skb, TX_OVERHEAD)) {
2739                 dev_kfree_skb_any(skb);
2740                 return NULL;
2741         }
2742
2743         if (lan78xx_linearize(skb) < 0)
2744                 return NULL;
2745
2746         tx_cmd_a = (u32)(skb->len & TX_CMD_A_LEN_MASK_) | TX_CMD_A_FCS_;
2747
2748         if (skb->ip_summed == CHECKSUM_PARTIAL)
2749                 tx_cmd_a |= TX_CMD_A_IPE_ | TX_CMD_A_TPE_;
2750
2751         tx_cmd_b = 0;
2752         if (skb_is_gso(skb)) {
2753                 u16 mss = max(skb_shinfo(skb)->gso_size, TX_CMD_B_MSS_MIN_);
2754
2755                 tx_cmd_b = (mss << TX_CMD_B_MSS_SHIFT_) & TX_CMD_B_MSS_MASK_;
2756
2757                 tx_cmd_a |= TX_CMD_A_LSO_;
2758         }
2759
2760         if (skb_vlan_tag_present(skb)) {
2761                 tx_cmd_a |= TX_CMD_A_IVTG_;
2762                 tx_cmd_b |= skb_vlan_tag_get(skb) & TX_CMD_B_VTAG_MASK_;
2763         }
2764
2765         ptr = skb_push(skb, 8);
2766         put_unaligned_le32(tx_cmd_a, ptr);
2767         put_unaligned_le32(tx_cmd_b, ptr + 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                 rx_cmd_a = get_unaligned_le32(skb->data);
3109                 skb_pull(skb, sizeof(rx_cmd_a));
3110
3111                 rx_cmd_b = get_unaligned_le32(skb->data);
3112                 skb_pull(skb, sizeof(rx_cmd_b));
3113
3114                 rx_cmd_c = get_unaligned_le16(skb->data);
3115                 skb_pull(skb, sizeof(rx_cmd_c));
3116
3117                 packet = skb->data;
3118
3119                 /* get the packet length */
3120                 size = (rx_cmd_a & RX_CMD_A_LEN_MASK_);
3121                 align_count = (4 - ((size + RXW_PADDING) % 4)) % 4;
3122
3123                 if (unlikely(rx_cmd_a & RX_CMD_A_RED_)) {
3124                         netif_dbg(dev, rx_err, dev->net,
3125                                   "Error rx_cmd_a=0x%08x", rx_cmd_a);
3126                 } else {
3127                         /* last frame in this batch */
3128                         if (skb->len == size) {
3129                                 lan78xx_rx_csum_offload(dev, skb,
3130                                                         rx_cmd_a, rx_cmd_b);
3131                                 lan78xx_rx_vlan_offload(dev, skb,
3132                                                         rx_cmd_a, rx_cmd_b);
3133
3134                                 skb_trim(skb, skb->len - 4); /* remove fcs */
3135                                 skb->truesize = size + sizeof(struct sk_buff);
3136
3137                                 return 1;
3138                         }
3139
3140                         skb2 = skb_clone(skb, GFP_ATOMIC);
3141                         if (unlikely(!skb2)) {
3142                                 netdev_warn(dev->net, "Error allocating skb");
3143                                 return 0;
3144                         }
3145
3146                         skb2->len = size;
3147                         skb2->data = packet;
3148                         skb_set_tail_pointer(skb2, size);
3149
3150                         lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3151                         lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3152
3153                         skb_trim(skb2, skb2->len - 4); /* remove fcs */
3154                         skb2->truesize = size + sizeof(struct sk_buff);
3155
3156                         lan78xx_skb_return(dev, skb2);
3157                 }
3158
3159                 skb_pull(skb, size);
3160
3161                 /* padding bytes before the next frame starts */
3162                 if (skb->len)
3163                         skb_pull(skb, align_count);
3164         }
3165
3166         return 1;
3167 }
3168
3169 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb)
3170 {
3171         if (!lan78xx_rx(dev, skb)) {
3172                 dev->net->stats.rx_errors++;
3173                 goto done;
3174         }
3175
3176         if (skb->len) {
3177                 lan78xx_skb_return(dev, skb);
3178                 return;
3179         }
3180
3181         netif_dbg(dev, rx_err, dev->net, "drop\n");
3182         dev->net->stats.rx_errors++;
3183 done:
3184         skb_queue_tail(&dev->done, skb);
3185 }
3186
3187 static void rx_complete(struct urb *urb);
3188
3189 static int rx_submit(struct lan78xx_net *dev, struct urb *urb, gfp_t flags)
3190 {
3191         struct sk_buff *skb;
3192         struct skb_data *entry;
3193         unsigned long lockflags;
3194         size_t size = dev->rx_urb_size;
3195         int ret = 0;
3196
3197         skb = netdev_alloc_skb_ip_align(dev->net, size);
3198         if (!skb) {
3199                 usb_free_urb(urb);
3200                 return -ENOMEM;
3201         }
3202
3203         entry = (struct skb_data *)skb->cb;
3204         entry->urb = urb;
3205         entry->dev = dev;
3206         entry->length = 0;
3207
3208         usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3209                           skb->data, size, rx_complete, skb);
3210
3211         spin_lock_irqsave(&dev->rxq.lock, lockflags);
3212
3213         if (netif_device_present(dev->net) &&
3214             netif_running(dev->net) &&
3215             !test_bit(EVENT_RX_HALT, &dev->flags) &&
3216             !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3217                 ret = usb_submit_urb(urb, GFP_ATOMIC);
3218                 switch (ret) {
3219                 case 0:
3220                         lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3221                         break;
3222                 case -EPIPE:
3223                         lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3224                         break;
3225                 case -ENODEV:
3226                         netif_dbg(dev, ifdown, dev->net, "device gone\n");
3227                         netif_device_detach(dev->net);
3228                         break;
3229                 case -EHOSTUNREACH:
3230                         ret = -ENOLINK;
3231                         break;
3232                 default:
3233                         netif_dbg(dev, rx_err, dev->net,
3234                                   "rx submit, %d\n", ret);
3235                         tasklet_schedule(&dev->bh);
3236                 }
3237         } else {
3238                 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3239                 ret = -ENOLINK;
3240         }
3241         spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3242         if (ret) {
3243                 dev_kfree_skb_any(skb);
3244                 usb_free_urb(urb);
3245         }
3246         return ret;
3247 }
3248
3249 static void rx_complete(struct urb *urb)
3250 {
3251         struct sk_buff  *skb = (struct sk_buff *)urb->context;
3252         struct skb_data *entry = (struct skb_data *)skb->cb;
3253         struct lan78xx_net *dev = entry->dev;
3254         int urb_status = urb->status;
3255         enum skb_state state;
3256
3257         skb_put(skb, urb->actual_length);
3258         state = rx_done;
3259         entry->urb = NULL;
3260
3261         switch (urb_status) {
3262         case 0:
3263                 if (skb->len < dev->net->hard_header_len) {
3264                         state = rx_cleanup;
3265                         dev->net->stats.rx_errors++;
3266                         dev->net->stats.rx_length_errors++;
3267                         netif_dbg(dev, rx_err, dev->net,
3268                                   "rx length %d\n", skb->len);
3269                 }
3270                 usb_mark_last_busy(dev->udev);
3271                 break;
3272         case -EPIPE:
3273                 dev->net->stats.rx_errors++;
3274                 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3275                 /* FALLTHROUGH */
3276         case -ECONNRESET:                               /* async unlink */
3277         case -ESHUTDOWN:                                /* hardware gone */
3278                 netif_dbg(dev, ifdown, dev->net,
3279                           "rx shutdown, code %d\n", urb_status);
3280                 state = rx_cleanup;
3281                 entry->urb = urb;
3282                 urb = NULL;
3283                 break;
3284         case -EPROTO:
3285         case -ETIME:
3286         case -EILSEQ:
3287                 dev->net->stats.rx_errors++;
3288                 state = rx_cleanup;
3289                 entry->urb = urb;
3290                 urb = NULL;
3291                 break;
3292
3293         /* data overrun ... flush fifo? */
3294         case -EOVERFLOW:
3295                 dev->net->stats.rx_over_errors++;
3296                 /* FALLTHROUGH */
3297
3298         default:
3299                 state = rx_cleanup;
3300                 dev->net->stats.rx_errors++;
3301                 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3302                 break;
3303         }
3304
3305         state = defer_bh(dev, skb, &dev->rxq, state);
3306
3307         if (urb) {
3308                 if (netif_running(dev->net) &&
3309                     !test_bit(EVENT_RX_HALT, &dev->flags) &&
3310                     state != unlink_start) {
3311                         rx_submit(dev, urb, GFP_ATOMIC);
3312                         return;
3313                 }
3314                 usb_free_urb(urb);
3315         }
3316         netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n");
3317 }
3318
3319 static void lan78xx_tx_bh(struct lan78xx_net *dev)
3320 {
3321         int length;
3322         struct urb *urb = NULL;
3323         struct skb_data *entry;
3324         unsigned long flags;
3325         struct sk_buff_head *tqp = &dev->txq_pend;
3326         struct sk_buff *skb, *skb2;
3327         int ret;
3328         int count, pos;
3329         int skb_totallen, pkt_cnt;
3330
3331         skb_totallen = 0;
3332         pkt_cnt = 0;
3333         count = 0;
3334         length = 0;
3335         spin_lock_irqsave(&tqp->lock, flags);
3336         skb_queue_walk(tqp, skb) {
3337                 if (skb_is_gso(skb)) {
3338                         if (!skb_queue_is_first(tqp, skb)) {
3339                                 /* handle previous packets first */
3340                                 break;
3341                         }
3342                         count = 1;
3343                         length = skb->len - TX_OVERHEAD;
3344                         __skb_unlink(skb, tqp);
3345                         spin_unlock_irqrestore(&tqp->lock, flags);
3346                         goto gso_skb;
3347                 }
3348
3349                 if ((skb_totallen + skb->len) > MAX_SINGLE_PACKET_SIZE)
3350                         break;
3351                 skb_totallen = skb->len + roundup(skb_totallen, sizeof(u32));
3352                 pkt_cnt++;
3353         }
3354         spin_unlock_irqrestore(&tqp->lock, flags);
3355
3356         /* copy to a single skb */
3357         skb = alloc_skb(skb_totallen, GFP_ATOMIC);
3358         if (!skb)
3359                 goto drop;
3360
3361         skb_put(skb, skb_totallen);
3362
3363         for (count = pos = 0; count < pkt_cnt; count++) {
3364                 skb2 = skb_dequeue(tqp);
3365                 if (skb2) {
3366                         length += (skb2->len - TX_OVERHEAD);
3367                         memcpy(skb->data + pos, skb2->data, skb2->len);
3368                         pos += roundup(skb2->len, sizeof(u32));
3369                         dev_kfree_skb(skb2);
3370                 }
3371         }
3372
3373 gso_skb:
3374         urb = usb_alloc_urb(0, GFP_ATOMIC);
3375         if (!urb)
3376                 goto drop;
3377
3378         entry = (struct skb_data *)skb->cb;
3379         entry->urb = urb;
3380         entry->dev = dev;
3381         entry->length = length;
3382         entry->num_of_packet = count;
3383
3384         spin_lock_irqsave(&dev->txq.lock, flags);
3385         ret = usb_autopm_get_interface_async(dev->intf);
3386         if (ret < 0) {
3387                 spin_unlock_irqrestore(&dev->txq.lock, flags);
3388                 goto drop;
3389         }
3390
3391         usb_fill_bulk_urb(urb, dev->udev, dev->pipe_out,
3392                           skb->data, skb->len, tx_complete, skb);
3393
3394         if (length % dev->maxpacket == 0) {
3395                 /* send USB_ZERO_PACKET */
3396                 urb->transfer_flags |= URB_ZERO_PACKET;
3397         }
3398
3399 #ifdef CONFIG_PM
3400         /* if this triggers the device is still a sleep */
3401         if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3402                 /* transmission will be done in resume */
3403                 usb_anchor_urb(urb, &dev->deferred);
3404                 /* no use to process more packets */
3405                 netif_stop_queue(dev->net);
3406                 usb_put_urb(urb);
3407                 spin_unlock_irqrestore(&dev->txq.lock, flags);
3408                 netdev_dbg(dev->net, "Delaying transmission for resumption\n");
3409                 return;
3410         }
3411 #endif
3412
3413         ret = usb_submit_urb(urb, GFP_ATOMIC);
3414         switch (ret) {
3415         case 0:
3416                 netif_trans_update(dev->net);
3417                 lan78xx_queue_skb(&dev->txq, skb, tx_start);
3418                 if (skb_queue_len(&dev->txq) >= dev->tx_qlen)
3419                         netif_stop_queue(dev->net);
3420                 break;
3421         case -EPIPE:
3422                 netif_stop_queue(dev->net);
3423                 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3424                 usb_autopm_put_interface_async(dev->intf);
3425                 break;
3426         default:
3427                 usb_autopm_put_interface_async(dev->intf);
3428                 netif_dbg(dev, tx_err, dev->net,
3429                           "tx: submit urb err %d\n", ret);
3430                 break;
3431         }
3432
3433         spin_unlock_irqrestore(&dev->txq.lock, flags);
3434
3435         if (ret) {
3436                 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", ret);
3437 drop:
3438                 dev->net->stats.tx_dropped++;
3439                 if (skb)
3440                         dev_kfree_skb_any(skb);
3441                 usb_free_urb(urb);
3442         } else
3443                 netif_dbg(dev, tx_queued, dev->net,
3444                           "> tx, len %d, type 0x%x\n", length, skb->protocol);
3445 }
3446
3447 static void lan78xx_rx_bh(struct lan78xx_net *dev)
3448 {
3449         struct urb *urb;
3450         int i;
3451
3452         if (skb_queue_len(&dev->rxq) < dev->rx_qlen) {
3453                 for (i = 0; i < 10; i++) {
3454                         if (skb_queue_len(&dev->rxq) >= dev->rx_qlen)
3455                                 break;
3456                         urb = usb_alloc_urb(0, GFP_ATOMIC);
3457                         if (urb)
3458                                 if (rx_submit(dev, urb, GFP_ATOMIC) == -ENOLINK)
3459                                         return;
3460                 }
3461
3462                 if (skb_queue_len(&dev->rxq) < dev->rx_qlen)
3463                         tasklet_schedule(&dev->bh);
3464         }
3465         if (skb_queue_len(&dev->txq) < dev->tx_qlen)
3466                 netif_wake_queue(dev->net);
3467 }
3468
3469 static void lan78xx_bh(unsigned long param)
3470 {
3471         struct lan78xx_net *dev = (struct lan78xx_net *)param;
3472         struct sk_buff *skb;
3473         struct skb_data *entry;
3474
3475         while ((skb = skb_dequeue(&dev->done))) {
3476                 entry = (struct skb_data *)(skb->cb);
3477                 switch (entry->state) {
3478                 case rx_done:
3479                         entry->state = rx_cleanup;
3480                         rx_process(dev, skb);
3481                         continue;
3482                 case tx_done:
3483                         usb_free_urb(entry->urb);
3484                         dev_kfree_skb(skb);
3485                         continue;
3486                 case rx_cleanup:
3487                         usb_free_urb(entry->urb);
3488                         dev_kfree_skb(skb);
3489                         continue;
3490                 default:
3491                         netdev_dbg(dev->net, "skb state %d\n", entry->state);
3492                         return;
3493                 }
3494         }
3495
3496         if (netif_device_present(dev->net) && netif_running(dev->net)) {
3497                 /* reset update timer delta */
3498                 if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
3499                         dev->delta = 1;
3500                         mod_timer(&dev->stat_monitor,
3501                                   jiffies + STAT_UPDATE_TIMER);
3502                 }
3503
3504                 if (!skb_queue_empty(&dev->txq_pend))
3505                         lan78xx_tx_bh(dev);
3506
3507                 if (!timer_pending(&dev->delay) &&
3508                     !test_bit(EVENT_RX_HALT, &dev->flags))
3509                         lan78xx_rx_bh(dev);
3510         }
3511 }
3512
3513 static void lan78xx_delayedwork(struct work_struct *work)
3514 {
3515         int status;
3516         struct lan78xx_net *dev;
3517
3518         dev = container_of(work, struct lan78xx_net, wq.work);
3519
3520         if (test_bit(EVENT_TX_HALT, &dev->flags)) {
3521                 unlink_urbs(dev, &dev->txq);
3522                 status = usb_autopm_get_interface(dev->intf);
3523                 if (status < 0)
3524                         goto fail_pipe;
3525                 status = usb_clear_halt(dev->udev, dev->pipe_out);
3526                 usb_autopm_put_interface(dev->intf);
3527                 if (status < 0 &&
3528                     status != -EPIPE &&
3529                     status != -ESHUTDOWN) {
3530                         if (netif_msg_tx_err(dev))
3531 fail_pipe:
3532                                 netdev_err(dev->net,
3533                                            "can't clear tx halt, status %d\n",
3534                                            status);
3535                 } else {
3536                         clear_bit(EVENT_TX_HALT, &dev->flags);
3537                         if (status != -ESHUTDOWN)
3538                                 netif_wake_queue(dev->net);
3539                 }
3540         }
3541         if (test_bit(EVENT_RX_HALT, &dev->flags)) {
3542                 unlink_urbs(dev, &dev->rxq);
3543                 status = usb_autopm_get_interface(dev->intf);
3544                 if (status < 0)
3545                                 goto fail_halt;
3546                 status = usb_clear_halt(dev->udev, dev->pipe_in);
3547                 usb_autopm_put_interface(dev->intf);
3548                 if (status < 0 &&
3549                     status != -EPIPE &&
3550                     status != -ESHUTDOWN) {
3551                         if (netif_msg_rx_err(dev))
3552 fail_halt:
3553                                 netdev_err(dev->net,
3554                                            "can't clear rx halt, status %d\n",
3555                                            status);
3556                 } else {
3557                         clear_bit(EVENT_RX_HALT, &dev->flags);
3558                         tasklet_schedule(&dev->bh);
3559                 }
3560         }
3561
3562         if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
3563                 int ret = 0;
3564
3565                 clear_bit(EVENT_LINK_RESET, &dev->flags);
3566                 status = usb_autopm_get_interface(dev->intf);
3567                 if (status < 0)
3568                         goto skip_reset;
3569                 if (lan78xx_link_reset(dev) < 0) {
3570                         usb_autopm_put_interface(dev->intf);
3571 skip_reset:
3572                         netdev_info(dev->net, "link reset failed (%d)\n",
3573                                     ret);
3574                 } else {
3575                         usb_autopm_put_interface(dev->intf);
3576                 }
3577         }
3578
3579         if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
3580                 lan78xx_update_stats(dev);
3581
3582                 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3583
3584                 mod_timer(&dev->stat_monitor,
3585                           jiffies + (STAT_UPDATE_TIMER * dev->delta));
3586
3587                 dev->delta = min((dev->delta * 2), 50);
3588         }
3589 }
3590
3591 static void intr_complete(struct urb *urb)
3592 {
3593         struct lan78xx_net *dev = urb->context;
3594         int status = urb->status;
3595
3596         switch (status) {
3597         /* success */
3598         case 0:
3599                 lan78xx_status(dev, urb);
3600                 break;
3601
3602         /* software-driven interface shutdown */
3603         case -ENOENT:                   /* urb killed */
3604         case -ESHUTDOWN:                /* hardware gone */
3605                 netif_dbg(dev, ifdown, dev->net,
3606                           "intr shutdown, code %d\n", status);
3607                 return;
3608
3609         /* NOTE:  not throttling like RX/TX, since this endpoint
3610          * already polls infrequently
3611          */
3612         default:
3613                 netdev_dbg(dev->net, "intr status %d\n", status);
3614                 break;
3615         }
3616
3617         if (!netif_running(dev->net))
3618                 return;
3619
3620         memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
3621         status = usb_submit_urb(urb, GFP_ATOMIC);
3622         if (status != 0)
3623                 netif_err(dev, timer, dev->net,
3624                           "intr resubmit --> %d\n", status);
3625 }
3626
3627 static void lan78xx_disconnect(struct usb_interface *intf)
3628 {
3629         struct lan78xx_net *dev;
3630         struct usb_device *udev;
3631         struct net_device *net;
3632         struct phy_device *phydev;
3633
3634         dev = usb_get_intfdata(intf);
3635         usb_set_intfdata(intf, NULL);
3636         if (!dev)
3637                 return;
3638
3639         udev = interface_to_usbdev(intf);
3640         net = dev->net;
3641         phydev = net->phydev;
3642
3643         phy_unregister_fixup_for_uid(PHY_KSZ9031RNX, 0xfffffff0);
3644         phy_unregister_fixup_for_uid(PHY_LAN8835, 0xfffffff0);
3645
3646         phy_disconnect(net->phydev);
3647
3648         if (phy_is_pseudo_fixed_link(phydev))
3649                 fixed_phy_unregister(phydev);
3650
3651         unregister_netdev(net);
3652
3653         cancel_delayed_work_sync(&dev->wq);
3654
3655         usb_scuttle_anchored_urbs(&dev->deferred);
3656
3657         lan78xx_unbind(dev, intf);
3658
3659         usb_kill_urb(dev->urb_intr);
3660         usb_free_urb(dev->urb_intr);
3661
3662         free_netdev(net);
3663         usb_put_dev(udev);
3664 }
3665
3666 static void lan78xx_tx_timeout(struct net_device *net, unsigned int txqueue)
3667 {
3668         struct lan78xx_net *dev = netdev_priv(net);
3669
3670         unlink_urbs(dev, &dev->txq);
3671         tasklet_schedule(&dev->bh);
3672 }
3673
3674 static const struct net_device_ops lan78xx_netdev_ops = {
3675         .ndo_open               = lan78xx_open,
3676         .ndo_stop               = lan78xx_stop,
3677         .ndo_start_xmit         = lan78xx_start_xmit,
3678         .ndo_tx_timeout         = lan78xx_tx_timeout,
3679         .ndo_change_mtu         = lan78xx_change_mtu,
3680         .ndo_set_mac_address    = lan78xx_set_mac_addr,
3681         .ndo_validate_addr      = eth_validate_addr,
3682         .ndo_do_ioctl           = lan78xx_ioctl,
3683         .ndo_set_rx_mode        = lan78xx_set_multicast,
3684         .ndo_set_features       = lan78xx_set_features,
3685         .ndo_vlan_rx_add_vid    = lan78xx_vlan_rx_add_vid,
3686         .ndo_vlan_rx_kill_vid   = lan78xx_vlan_rx_kill_vid,
3687 };
3688
3689 static void lan78xx_stat_monitor(struct timer_list *t)
3690 {
3691         struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
3692
3693         lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
3694 }
3695
3696 static int lan78xx_probe(struct usb_interface *intf,
3697                          const struct usb_device_id *id)
3698 {
3699         struct lan78xx_net *dev;
3700         struct net_device *netdev;
3701         struct usb_device *udev;
3702         int ret;
3703         unsigned maxp;
3704         unsigned period;
3705         u8 *buf = NULL;
3706
3707         udev = interface_to_usbdev(intf);
3708         udev = usb_get_dev(udev);
3709
3710         netdev = alloc_etherdev(sizeof(struct lan78xx_net));
3711         if (!netdev) {
3712                 dev_err(&intf->dev, "Error: OOM\n");
3713                 ret = -ENOMEM;
3714                 goto out1;
3715         }
3716
3717         /* netdev_printk() needs this */
3718         SET_NETDEV_DEV(netdev, &intf->dev);
3719
3720         dev = netdev_priv(netdev);
3721         dev->udev = udev;
3722         dev->intf = intf;
3723         dev->net = netdev;
3724         dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
3725                                         | NETIF_MSG_PROBE | NETIF_MSG_LINK);
3726
3727         skb_queue_head_init(&dev->rxq);
3728         skb_queue_head_init(&dev->txq);
3729         skb_queue_head_init(&dev->done);
3730         skb_queue_head_init(&dev->rxq_pause);
3731         skb_queue_head_init(&dev->txq_pend);
3732         mutex_init(&dev->phy_mutex);
3733
3734         tasklet_init(&dev->bh, lan78xx_bh, (unsigned long)dev);
3735         INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
3736         init_usb_anchor(&dev->deferred);
3737
3738         netdev->netdev_ops = &lan78xx_netdev_ops;
3739         netdev->watchdog_timeo = TX_TIMEOUT_JIFFIES;
3740         netdev->ethtool_ops = &lan78xx_ethtool_ops;
3741
3742         dev->delta = 1;
3743         timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
3744
3745         mutex_init(&dev->stats.access_lock);
3746
3747         ret = lan78xx_bind(dev, intf);
3748         if (ret < 0)
3749                 goto out2;
3750
3751         if (netdev->mtu > (dev->hard_mtu - netdev->hard_header_len))
3752                 netdev->mtu = dev->hard_mtu - netdev->hard_header_len;
3753
3754         /* MTU range: 68 - 9000 */
3755         netdev->max_mtu = MAX_SINGLE_PACKET_SIZE;
3756
3757         dev->ep_blkin = (intf->cur_altsetting)->endpoint + 0;
3758         dev->ep_blkout = (intf->cur_altsetting)->endpoint + 1;
3759         dev->ep_intr = (intf->cur_altsetting)->endpoint + 2;
3760
3761         dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
3762         dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
3763
3764         dev->pipe_intr = usb_rcvintpipe(dev->udev,
3765                                         dev->ep_intr->desc.bEndpointAddress &
3766                                         USB_ENDPOINT_NUMBER_MASK);
3767         period = dev->ep_intr->desc.bInterval;
3768
3769         maxp = usb_maxpacket(dev->udev, dev->pipe_intr, 0);
3770         buf = kmalloc(maxp, GFP_KERNEL);
3771         if (buf) {
3772                 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
3773                 if (!dev->urb_intr) {
3774                         ret = -ENOMEM;
3775                         kfree(buf);
3776                         goto out3;
3777                 } else {
3778                         usb_fill_int_urb(dev->urb_intr, dev->udev,
3779                                          dev->pipe_intr, buf, maxp,
3780                                          intr_complete, dev, period);
3781                 }
3782         }
3783
3784         dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out, 1);
3785
3786         /* driver requires remote-wakeup capability during autosuspend. */
3787         intf->needs_remote_wakeup = 1;
3788
3789         ret = lan78xx_phy_init(dev);
3790         if (ret < 0)
3791                 goto out4;
3792
3793         ret = register_netdev(netdev);
3794         if (ret != 0) {
3795                 netif_err(dev, probe, netdev, "couldn't register the device\n");
3796                 goto out5;
3797         }
3798
3799         usb_set_intfdata(intf, dev);
3800
3801         ret = device_set_wakeup_enable(&udev->dev, true);
3802
3803          /* Default delay of 2sec has more overhead than advantage.
3804           * Set to 10sec as default.
3805           */
3806         pm_runtime_set_autosuspend_delay(&udev->dev,
3807                                          DEFAULT_AUTOSUSPEND_DELAY);
3808
3809         return 0;
3810
3811 out5:
3812         phy_disconnect(netdev->phydev);
3813 out4:
3814         usb_free_urb(dev->urb_intr);
3815 out3:
3816         lan78xx_unbind(dev, intf);
3817 out2:
3818         free_netdev(netdev);
3819 out1:
3820         usb_put_dev(udev);
3821
3822         return ret;
3823 }
3824
3825 static u16 lan78xx_wakeframe_crc16(const u8 *buf, int len)
3826 {
3827         const u16 crc16poly = 0x8005;
3828         int i;
3829         u16 bit, crc, msb;
3830         u8 data;
3831
3832         crc = 0xFFFF;
3833         for (i = 0; i < len; i++) {
3834                 data = *buf++;
3835                 for (bit = 0; bit < 8; bit++) {
3836                         msb = crc >> 15;
3837                         crc <<= 1;
3838
3839                         if (msb ^ (u16)(data & 1)) {
3840                                 crc ^= crc16poly;
3841                                 crc |= (u16)0x0001U;
3842                         }
3843                         data >>= 1;
3844                 }
3845         }
3846
3847         return crc;
3848 }
3849
3850 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
3851 {
3852         u32 buf;
3853         int ret;
3854         int mask_index;
3855         u16 crc;
3856         u32 temp_wucsr;
3857         u32 temp_pmt_ctl;
3858         const u8 ipv4_multicast[3] = { 0x01, 0x00, 0x5E };
3859         const u8 ipv6_multicast[3] = { 0x33, 0x33 };
3860         const u8 arp_type[2] = { 0x08, 0x06 };
3861
3862         ret = lan78xx_read_reg(dev, MAC_TX, &buf);
3863         buf &= ~MAC_TX_TXEN_;
3864         ret = lan78xx_write_reg(dev, MAC_TX, buf);
3865         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3866         buf &= ~MAC_RX_RXEN_;
3867         ret = lan78xx_write_reg(dev, MAC_RX, buf);
3868
3869         ret = lan78xx_write_reg(dev, WUCSR, 0);
3870         ret = lan78xx_write_reg(dev, WUCSR2, 0);
3871         ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
3872
3873         temp_wucsr = 0;
3874
3875         temp_pmt_ctl = 0;
3876         ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
3877         temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_;
3878         temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_;
3879
3880         for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++)
3881                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
3882
3883         mask_index = 0;
3884         if (wol & WAKE_PHY) {
3885                 temp_pmt_ctl |= PMT_CTL_PHY_WAKE_EN_;
3886
3887                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3888                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3889                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3890         }
3891         if (wol & WAKE_MAGIC) {
3892                 temp_wucsr |= WUCSR_MPEN_;
3893
3894                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3895                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3896                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_3_;
3897         }
3898         if (wol & WAKE_BCAST) {
3899                 temp_wucsr |= WUCSR_BCST_EN_;
3900
3901                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3902                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3903                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3904         }
3905         if (wol & WAKE_MCAST) {
3906                 temp_wucsr |= WUCSR_WAKE_EN_;
3907
3908                 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */
3909                 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3);
3910                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3911                                         WUF_CFGX_EN_ |
3912                                         WUF_CFGX_TYPE_MCAST_ |
3913                                         (0 << WUF_CFGX_OFFSET_SHIFT_) |
3914                                         (crc & WUF_CFGX_CRC16_MASK_));
3915
3916                 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
3917                 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3918                 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3919                 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3920                 mask_index++;
3921
3922                 /* for IPv6 Multicast */
3923                 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2);
3924                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3925                                         WUF_CFGX_EN_ |
3926                                         WUF_CFGX_TYPE_MCAST_ |
3927                                         (0 << WUF_CFGX_OFFSET_SHIFT_) |
3928                                         (crc & WUF_CFGX_CRC16_MASK_));
3929
3930                 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
3931                 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3932                 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3933                 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3934                 mask_index++;
3935
3936                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3937                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3938                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3939         }
3940         if (wol & WAKE_UCAST) {
3941                 temp_wucsr |= WUCSR_PFDA_EN_;
3942
3943                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3944                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3945                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3946         }
3947         if (wol & WAKE_ARP) {
3948                 temp_wucsr |= WUCSR_WAKE_EN_;
3949
3950                 /* set WUF_CFG & WUF_MASK
3951                  * for packettype (offset 12,13) = ARP (0x0806)
3952                  */
3953                 crc = lan78xx_wakeframe_crc16(arp_type, 2);
3954                 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
3955                                         WUF_CFGX_EN_ |
3956                                         WUF_CFGX_TYPE_ALL_ |
3957                                         (0 << WUF_CFGX_OFFSET_SHIFT_) |
3958                                         (crc & WUF_CFGX_CRC16_MASK_));
3959
3960                 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
3961                 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
3962                 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
3963                 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
3964                 mask_index++;
3965
3966                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3967                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3968                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3969         }
3970
3971         ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
3972
3973         /* when multiple WOL bits are set */
3974         if (hweight_long((unsigned long)wol) > 1) {
3975                 temp_pmt_ctl |= PMT_CTL_WOL_EN_;
3976                 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_;
3977                 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_;
3978         }
3979         ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
3980
3981         /* clear WUPS */
3982         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3983         buf |= PMT_CTL_WUPS_MASK_;
3984         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3985
3986         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
3987         buf |= MAC_RX_RXEN_;
3988         ret = lan78xx_write_reg(dev, MAC_RX, buf);
3989
3990         return 0;
3991 }
3992
3993 static int lan78xx_suspend(struct usb_interface *intf, pm_message_t message)
3994 {
3995         struct lan78xx_net *dev = usb_get_intfdata(intf);
3996         struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3997         u32 buf;
3998         int ret;
3999
4000         if (!dev->suspend_count++) {
4001                 spin_lock_irq(&dev->txq.lock);
4002                 /* don't autosuspend while transmitting */
4003                 if ((skb_queue_len(&dev->txq) ||
4004                      skb_queue_len(&dev->txq_pend)) &&
4005                         PMSG_IS_AUTO(message)) {
4006                         spin_unlock_irq(&dev->txq.lock);
4007                         ret = -EBUSY;
4008                         goto out;
4009                 } else {
4010                         set_bit(EVENT_DEV_ASLEEP, &dev->flags);
4011                         spin_unlock_irq(&dev->txq.lock);
4012                 }
4013
4014                 /* stop TX & RX */
4015                 ret = lan78xx_read_reg(dev, MAC_TX, &buf);
4016                 buf &= ~MAC_TX_TXEN_;
4017                 ret = lan78xx_write_reg(dev, MAC_TX, buf);
4018                 ret = lan78xx_read_reg(dev, MAC_RX, &buf);
4019                 buf &= ~MAC_RX_RXEN_;
4020                 ret = lan78xx_write_reg(dev, MAC_RX, buf);
4021
4022                 /* empty out the rx and queues */
4023                 netif_device_detach(dev->net);
4024                 lan78xx_terminate_urbs(dev);
4025                 usb_kill_urb(dev->urb_intr);
4026
4027                 /* reattach */
4028                 netif_device_attach(dev->net);
4029         }
4030
4031         if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
4032                 del_timer(&dev->stat_monitor);
4033
4034                 if (PMSG_IS_AUTO(message)) {
4035                         /* auto suspend (selective suspend) */
4036                         ret = lan78xx_read_reg(dev, MAC_TX, &buf);
4037                         buf &= ~MAC_TX_TXEN_;
4038                         ret = lan78xx_write_reg(dev, MAC_TX, buf);
4039                         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
4040                         buf &= ~MAC_RX_RXEN_;
4041                         ret = lan78xx_write_reg(dev, MAC_RX, buf);
4042
4043                         ret = lan78xx_write_reg(dev, WUCSR, 0);
4044                         ret = lan78xx_write_reg(dev, WUCSR2, 0);
4045                         ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4046
4047                         /* set goodframe wakeup */
4048                         ret = lan78xx_read_reg(dev, WUCSR, &buf);
4049
4050                         buf |= WUCSR_RFE_WAKE_EN_;
4051                         buf |= WUCSR_STORE_WAKE_;
4052
4053                         ret = lan78xx_write_reg(dev, WUCSR, buf);
4054
4055                         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4056
4057                         buf &= ~PMT_CTL_RES_CLR_WKP_EN_;
4058                         buf |= PMT_CTL_RES_CLR_WKP_STS_;
4059
4060                         buf |= PMT_CTL_PHY_WAKE_EN_;
4061                         buf |= PMT_CTL_WOL_EN_;
4062                         buf &= ~PMT_CTL_SUS_MODE_MASK_;
4063                         buf |= PMT_CTL_SUS_MODE_3_;
4064
4065                         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4066
4067                         ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4068
4069                         buf |= PMT_CTL_WUPS_MASK_;
4070
4071                         ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4072
4073                         ret = lan78xx_read_reg(dev, MAC_RX, &buf);
4074                         buf |= MAC_RX_RXEN_;
4075                         ret = lan78xx_write_reg(dev, MAC_RX, buf);
4076                 } else {
4077                         lan78xx_set_suspend(dev, pdata->wol);
4078                 }
4079         }
4080
4081         ret = 0;
4082 out:
4083         return ret;
4084 }
4085
4086 static int lan78xx_resume(struct usb_interface *intf)
4087 {
4088         struct lan78xx_net *dev = usb_get_intfdata(intf);
4089         struct sk_buff *skb;
4090         struct urb *res;
4091         int ret;
4092         u32 buf;
4093
4094         if (!timer_pending(&dev->stat_monitor)) {
4095                 dev->delta = 1;
4096                 mod_timer(&dev->stat_monitor,
4097                           jiffies + STAT_UPDATE_TIMER);
4098         }
4099
4100         if (!--dev->suspend_count) {
4101                 /* resume interrupt URBs */
4102                 if (dev->urb_intr && test_bit(EVENT_DEV_OPEN, &dev->flags))
4103                                 usb_submit_urb(dev->urb_intr, GFP_NOIO);
4104
4105                 spin_lock_irq(&dev->txq.lock);
4106                 while ((res = usb_get_from_anchor(&dev->deferred))) {
4107                         skb = (struct sk_buff *)res->context;
4108                         ret = usb_submit_urb(res, GFP_ATOMIC);
4109                         if (ret < 0) {
4110                                 dev_kfree_skb_any(skb);
4111                                 usb_free_urb(res);
4112                                 usb_autopm_put_interface_async(dev->intf);
4113                         } else {
4114                                 netif_trans_update(dev->net);
4115                                 lan78xx_queue_skb(&dev->txq, skb, tx_start);
4116                         }
4117                 }
4118
4119                 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4120                 spin_unlock_irq(&dev->txq.lock);
4121
4122                 if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {
4123                         if (!(skb_queue_len(&dev->txq) >= dev->tx_qlen))
4124                                 netif_start_queue(dev->net);
4125                         tasklet_schedule(&dev->bh);
4126                 }
4127         }
4128
4129         ret = lan78xx_write_reg(dev, WUCSR2, 0);
4130         ret = lan78xx_write_reg(dev, WUCSR, 0);
4131         ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4132
4133         ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
4134                                              WUCSR2_ARP_RCD_ |
4135                                              WUCSR2_IPV6_TCPSYN_RCD_ |
4136                                              WUCSR2_IPV4_TCPSYN_RCD_);
4137
4138         ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
4139                                             WUCSR_EEE_RX_WAKE_ |
4140                                             WUCSR_PFDA_FR_ |
4141                                             WUCSR_RFE_WAKE_FR_ |
4142                                             WUCSR_WUFR_ |
4143                                             WUCSR_MPR_ |
4144                                             WUCSR_BCST_FR_);
4145
4146         ret = lan78xx_read_reg(dev, MAC_TX, &buf);
4147         buf |= MAC_TX_TXEN_;
4148         ret = lan78xx_write_reg(dev, MAC_TX, buf);
4149
4150         return 0;
4151 }
4152
4153 static int lan78xx_reset_resume(struct usb_interface *intf)
4154 {
4155         struct lan78xx_net *dev = usb_get_intfdata(intf);
4156
4157         lan78xx_reset(dev);
4158
4159         phy_start(dev->net->phydev);
4160
4161         return lan78xx_resume(intf);
4162 }
4163
4164 static const struct usb_device_id products[] = {
4165         {
4166         /* LAN7800 USB Gigabit Ethernet Device */
4167         USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7800_USB_PRODUCT_ID),
4168         },
4169         {
4170         /* LAN7850 USB Gigabit Ethernet Device */
4171         USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7850_USB_PRODUCT_ID),
4172         },
4173         {
4174         /* LAN7801 USB Gigabit Ethernet Device */
4175         USB_DEVICE(LAN78XX_USB_VENDOR_ID, LAN7801_USB_PRODUCT_ID),
4176         },
4177         {},
4178 };
4179 MODULE_DEVICE_TABLE(usb, products);
4180
4181 static struct usb_driver lan78xx_driver = {
4182         .name                   = DRIVER_NAME,
4183         .id_table               = products,
4184         .probe                  = lan78xx_probe,
4185         .disconnect             = lan78xx_disconnect,
4186         .suspend                = lan78xx_suspend,
4187         .resume                 = lan78xx_resume,
4188         .reset_resume           = lan78xx_reset_resume,
4189         .supports_autosuspend   = 1,
4190         .disable_hub_initiated_lpm = 1,
4191 };
4192
4193 module_usb_driver(lan78xx_driver);
4194
4195 MODULE_AUTHOR(DRIVER_AUTHOR);
4196 MODULE_DESCRIPTION(DRIVER_DESC);
4197 MODULE_LICENSE("GPL");