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