drivers/net/usb/lan78xx.c

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