drivers/net/usb/lan78xx.c

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