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