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