drivers/net/usb/lan78xx.c

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