drivers/net/usb/rtl8150.c

   1 /*
   2  *  Copyright (c) 2002 Petko Manolov (petkan@users.sourceforge.net)
   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  * version 2 as published by the Free Software Foundation.
   7  */
   8
   9 #include <linux/signal.h>
  10 #include <linux/slab.h>
  11 #include <linux/module.h>
  12 #include <linux/netdevice.h>
  13 #include <linux/etherdevice.h>
  14 #include <linux/mii.h>
  15 #include <linux/ethtool.h>
  16 #include <linux/usb.h>
  17 #include <asm/uaccess.h>
  18
  19 /* Version Information */
  20 #define DRIVER_VERSION "v0.6.2 (2004/08/27)"
  21 #define DRIVER_AUTHOR "Petko Manolov <petkan@users.sourceforge.net>"
  22 #define DRIVER_DESC "rtl8150 based usb-ethernet driver"
  23
  24 #define IDR                     0x0120
  25 #define MAR                     0x0126
  26 #define CR                      0x012e
  27 #define TCR                     0x012f
  28 #define RCR                     0x0130
  29 #define TSR                     0x0132
  30 #define RSR                     0x0133
  31 #define CON0                    0x0135
  32 #define CON1                    0x0136
  33 #define MSR                     0x0137
  34 #define PHYADD                  0x0138
  35 #define PHYDAT                  0x0139
  36 #define PHYCNT                  0x013b
  37 #define GPPC                    0x013d
  38 #define BMCR                    0x0140
  39 #define BMSR                    0x0142
  40 #define ANAR                    0x0144
  41 #define ANLP                    0x0146
  42 #define AER                     0x0148
  43 #define CSCR                    0x014C  /* This one has the link status */
  44 #define CSCR_LINK_STATUS        (1 << 3)
  45
  46 #define IDR_EEPROM              0x1202
  47
  48 #define PHY_READ                0
  49 #define PHY_WRITE               0x20
  50 #define PHY_GO                  0x40
  51
  52 #define MII_TIMEOUT             10
  53 #define INTBUFSIZE              8
  54
  55 #define RTL8150_REQT_READ       0xc0
  56 #define RTL8150_REQT_WRITE      0x40
  57 #define RTL8150_REQ_GET_REGS    0x05
  58 #define RTL8150_REQ_SET_REGS    0x05
  59
  60
  61 /* Transmit status register errors */
  62 #define TSR_ECOL                (1<<5)
  63 #define TSR_LCOL                (1<<4)
  64 #define TSR_LOSS_CRS            (1<<3)
  65 #define TSR_JBR                 (1<<2)
  66 #define TSR_ERRORS              (TSR_ECOL | TSR_LCOL | TSR_LOSS_CRS | TSR_JBR)
  67 /* Receive status register errors */
  68 #define RSR_CRC                 (1<<2)
  69 #define RSR_FAE                 (1<<1)
  70 #define RSR_ERRORS              (RSR_CRC | RSR_FAE)
  71
  72 /* Media status register definitions */
  73 #define MSR_DUPLEX              (1<<4)
  74 #define MSR_SPEED               (1<<3)
  75 #define MSR_LINK                (1<<2)
  76
  77 /* Interrupt pipe data */
  78 #define INT_TSR                 0x00
  79 #define INT_RSR                 0x01
  80 #define INT_MSR                 0x02
  81 #define INT_WAKSR               0x03
  82 #define INT_TXOK_CNT            0x04
  83 #define INT_RXLOST_CNT          0x05
  84 #define INT_CRERR_CNT           0x06
  85 #define INT_COL_CNT             0x07
  86
  87
  88 #define RTL8150_MTU             1540
  89 #define RTL8150_TX_TIMEOUT      (HZ)
  90 #define RX_SKB_POOL_SIZE        4
  91
  92 /* rtl8150 flags */
  93 #define RTL8150_HW_CRC          0
  94 #define RX_REG_SET              1
  95 #define RTL8150_UNPLUG          2
  96 #define RX_URB_FAIL             3
  97
  98 /* Define these values to match your device */
  99 #define VENDOR_ID_REALTEK               0x0bda
 100 #define VENDOR_ID_MELCO                 0x0411
 101 #define VENDOR_ID_MICRONET              0x3980
 102 #define VENDOR_ID_LONGSHINE             0x07b8
 103 #define VENDOR_ID_OQO                   0x1557
 104 #define VENDOR_ID_ZYXEL                 0x0586
 105
 106 #define PRODUCT_ID_RTL8150              0x8150
 107 #define PRODUCT_ID_LUAKTX               0x0012
 108 #define PRODUCT_ID_LCS8138TX            0x401a
 109 #define PRODUCT_ID_SP128AR              0x0003
 110 #define PRODUCT_ID_PRESTIGE             0x401a
 111
 112 #undef  EEPROM_WRITE
 113
 114 /* table of devices that work with this driver */
 115 static struct usb_device_id rtl8150_table[] = {
 116         {USB_DEVICE(VENDOR_ID_REALTEK, PRODUCT_ID_RTL8150)},
 117         {USB_DEVICE(VENDOR_ID_MELCO, PRODUCT_ID_LUAKTX)},
 118         {USB_DEVICE(VENDOR_ID_MICRONET, PRODUCT_ID_SP128AR)},
 119         {USB_DEVICE(VENDOR_ID_LONGSHINE, PRODUCT_ID_LCS8138TX)},
 120         {USB_DEVICE(VENDOR_ID_OQO, PRODUCT_ID_RTL8150)},
 121         {USB_DEVICE(VENDOR_ID_ZYXEL, PRODUCT_ID_PRESTIGE)},
 122         {}
 123 };
 124
 125 MODULE_DEVICE_TABLE(usb, rtl8150_table);
 126
 127 struct rtl8150 {
 128         unsigned long flags;
 129         struct usb_device *udev;
 130         struct tasklet_struct tl;
 131         struct net_device *netdev;
 132         struct urb *rx_urb, *tx_urb, *intr_urb;
 133         struct sk_buff *tx_skb, *rx_skb;
 134         struct sk_buff *rx_skb_pool[RX_SKB_POOL_SIZE];
 135         spinlock_t rx_pool_lock;
 136         struct usb_ctrlrequest dr;
 137         int intr_interval;
 138         u8 *intr_buff;
 139         u8 phy;
 140 };
 141
 142 typedef struct rtl8150 rtl8150_t;
 143
 144 struct async_req {
 145         struct usb_ctrlrequest dr;
 146         u16 rx_creg;
 147 };
 148
 149 static const char driver_name [] = "rtl8150";
 150
 151 /*
 152 **
 153 **      device related part of the code
 154 **
 155 */
 156 static int get_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
 157 {
 158         return usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
 159                                RTL8150_REQ_GET_REGS, RTL8150_REQT_READ,
 160                                indx, 0, data, size, 500);
 161 }
 162
 163 static int set_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
 164 {
 165         return usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
 166                                RTL8150_REQ_SET_REGS, RTL8150_REQT_WRITE,
 167                                indx, 0, data, size, 500);
 168 }
 169
 170 static void async_set_reg_cb(struct urb *urb)
 171 {
 172         struct async_req *req = (struct async_req *)urb->context;
 173         int status = urb->status;
 174
 175         if (status < 0)
 176                 dev_dbg(&urb->dev->dev, "%s failed with %d", __func__, status);
 177         kfree(req);
 178         usb_free_urb(urb);
 179 }
 180
 181 static int async_set_registers(rtl8150_t *dev, u16 indx, u16 size, u16 reg)
 182 {
 183         int res = -ENOMEM;
 184         struct urb *async_urb;
 185         struct async_req *req;
 186
 187         req = kmalloc(sizeof(struct async_req), GFP_ATOMIC);
 188         if (req == NULL)
 189                 return res;
 190         async_urb = usb_alloc_urb(0, GFP_ATOMIC);
 191         if (async_urb == NULL) {
 192                 kfree(req);
 193                 return res;
 194         }
 195         req->rx_creg = cpu_to_le16(reg);
 196         req->dr.bRequestType = RTL8150_REQT_WRITE;
 197         req->dr.bRequest = RTL8150_REQ_SET_REGS;
 198         req->dr.wIndex = 0;
 199         req->dr.wValue = cpu_to_le16(indx);
 200         req->dr.wLength = cpu_to_le16(size);
 201         usb_fill_control_urb(async_urb, dev->udev,
 202                              usb_sndctrlpipe(dev->udev, 0), (void *)&req->dr,
 203                              &req->rx_creg, size, async_set_reg_cb, req);
 204         res = usb_submit_urb(async_urb, GFP_ATOMIC);
 205         if (res) {
 206                 if (res == -ENODEV)
 207                         netif_device_detach(dev->netdev);
 208                 dev_err(&dev->udev->dev, "%s failed with %d\n", __func__, res);
 209         }
 210         return res;
 211 }
 212
 213 static int read_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 * reg)
 214 {
 215         int i;
 216         u8 data[3], tmp;
 217
 218         data[0] = phy;
 219         data[1] = data[2] = 0;
 220         tmp = indx | PHY_READ | PHY_GO;
 221         i = 0;
 222
 223         set_registers(dev, PHYADD, sizeof(data), data);
 224         set_registers(dev, PHYCNT, 1, &tmp);
 225         do {
 226                 get_registers(dev, PHYCNT, 1, data);
 227         } while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
 228
 229         if (i <= MII_TIMEOUT) {
 230                 get_registers(dev, PHYDAT, 2, data);
 231                 *reg = data[0] | (data[1] << 8);
 232                 return 0;
 233         } else
 234                 return 1;
 235 }
 236
 237 static int write_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 reg)
 238 {
 239         int i;
 240         u8 data[3], tmp;
 241
 242         data[0] = phy;
 243         data[1] = reg & 0xff;
 244         data[2] = (reg >> 8) & 0xff;
 245         tmp = indx | PHY_WRITE | PHY_GO;
 246         i = 0;
 247
 248         set_registers(dev, PHYADD, sizeof(data), data);
 249         set_registers(dev, PHYCNT, 1, &tmp);
 250         do {
 251                 get_registers(dev, PHYCNT, 1, data);
 252         } while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
 253
 254         if (i <= MII_TIMEOUT)
 255                 return 0;
 256         else
 257                 return 1;
 258 }
 259
 260 static inline void set_ethernet_addr(rtl8150_t * dev)
 261 {
 262         u8 node_id[6];
 263
 264         get_registers(dev, IDR, sizeof(node_id), node_id);
 265         memcpy(dev->netdev->dev_addr, node_id, sizeof(node_id));
 266 }
 267
 268 static int rtl8150_set_mac_address(struct net_device *netdev, void *p)
 269 {
 270         struct sockaddr *addr = p;
 271         rtl8150_t *dev = netdev_priv(netdev);
 272
 273         if (netif_running(netdev))
 274                 return -EBUSY;
 275
 276         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
 277         netdev_dbg(netdev, "Setting MAC address to %pM\n", netdev->dev_addr);
 278         /* Set the IDR registers. */
 279         set_registers(dev, IDR, netdev->addr_len, netdev->dev_addr);
 280 #ifdef EEPROM_WRITE
 281         {
 282         int i;
 283         u8 cr;
 284         /* Get the CR contents. */
 285         get_registers(dev, CR, 1, &cr);
 286         /* Set the WEPROM bit (eeprom write enable). */
 287         cr |= 0x20;
 288         set_registers(dev, CR, 1, &cr);
 289         /* Write the MAC address into eeprom. Eeprom writes must be word-sized,
 290            so we need to split them up. */
 291         for (i = 0; i * 2 < netdev->addr_len; i++) {
 292                 set_registers(dev, IDR_EEPROM + (i * 2), 2,
 293                 netdev->dev_addr + (i * 2));
 294         }
 295         /* Clear the WEPROM bit (preventing accidental eeprom writes). */
 296         cr &= 0xdf;
 297         set_registers(dev, CR, 1, &cr);
 298         }
 299 #endif
 300         return 0;
 301 }
 302
 303 static int rtl8150_reset(rtl8150_t * dev)
 304 {
 305         u8 data = 0x10;
 306         int i = HZ;
 307
 308         set_registers(dev, CR, 1, &data);
 309         do {
 310                 get_registers(dev, CR, 1, &data);
 311         } while ((data & 0x10) && --i);
 312
 313         return (i > 0) ? 1 : 0;
 314 }
 315
 316 static int alloc_all_urbs(rtl8150_t * dev)
 317 {
 318         dev->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
 319         if (!dev->rx_urb)
 320                 return 0;
 321         dev->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
 322         if (!dev->tx_urb) {
 323                 usb_free_urb(dev->rx_urb);
 324                 return 0;
 325         }
 326         dev->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
 327         if (!dev->intr_urb) {
 328                 usb_free_urb(dev->rx_urb);
 329                 usb_free_urb(dev->tx_urb);
 330                 return 0;
 331         }
 332
 333         return 1;
 334 }
 335
 336 static void free_all_urbs(rtl8150_t * dev)
 337 {
 338         usb_free_urb(dev->rx_urb);
 339         usb_free_urb(dev->tx_urb);
 340         usb_free_urb(dev->intr_urb);
 341 }
 342
 343 static void unlink_all_urbs(rtl8150_t * dev)
 344 {
 345         usb_kill_urb(dev->rx_urb);
 346         usb_kill_urb(dev->tx_urb);
 347         usb_kill_urb(dev->intr_urb);
 348 }
 349
 350 static inline struct sk_buff *pull_skb(rtl8150_t *dev)
 351 {
 352         struct sk_buff *skb;
 353         int i;
 354
 355         for (i = 0; i < RX_SKB_POOL_SIZE; i++) {
 356                 if (dev->rx_skb_pool[i]) {
 357                         skb = dev->rx_skb_pool[i];
 358                         dev->rx_skb_pool[i] = NULL;
 359                         return skb;
 360                 }
 361         }
 362         return NULL;
 363 }
 364
 365 static void read_bulk_callback(struct urb *urb)
 366 {
 367         rtl8150_t *dev;
 368         unsigned pkt_len, res;
 369         struct sk_buff *skb;
 370         struct net_device *netdev;
 371         u16 rx_stat;
 372         int status = urb->status;
 373         int result;
 374
 375         dev = urb->context;
 376         if (!dev)
 377                 return;
 378         if (test_bit(RTL8150_UNPLUG, &dev->flags))
 379                 return;
 380         netdev = dev->netdev;
 381         if (!netif_device_present(netdev))
 382                 return;
 383
 384         switch (status) {
 385         case 0:
 386                 break;
 387         case -ENOENT:
 388                 return; /* the urb is in unlink state */
 389         case -ETIME:
 390                 if (printk_ratelimit())
 391                         dev_warn(&urb->dev->dev, "may be reset is needed?..\n");
 392                 goto goon;
 393         default:
 394                 if (printk_ratelimit())
 395                         dev_warn(&urb->dev->dev, "Rx status %d\n", status);
 396                 goto goon;
 397         }
 398
 399         if (!dev->rx_skb)
 400                 goto resched;
 401         /* protect against short packets (tell me why we got some?!?) */
 402         if (urb->actual_length < 4)
 403                 goto goon;
 404
 405         res = urb->actual_length;
 406         rx_stat = le16_to_cpu(*(__le16 *)(urb->transfer_buffer + res - 4));
 407         pkt_len = res - 4;
 408
 409         skb_put(dev->rx_skb, pkt_len);
 410         dev->rx_skb->protocol = eth_type_trans(dev->rx_skb, netdev);
 411         netif_rx(dev->rx_skb);
 412         netdev->stats.rx_packets++;
 413         netdev->stats.rx_bytes += pkt_len;
 414
 415         spin_lock(&dev->rx_pool_lock);
 416         skb = pull_skb(dev);
 417         spin_unlock(&dev->rx_pool_lock);
 418         if (!skb)
 419                 goto resched;
 420
 421         dev->rx_skb = skb;
 422 goon:
 423         usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
 424                       dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
 425         result = usb_submit_urb(dev->rx_urb, GFP_ATOMIC);
 426         if (result == -ENODEV)
 427                 netif_device_detach(dev->netdev);
 428         else if (result) {
 429                 set_bit(RX_URB_FAIL, &dev->flags);
 430                 goto resched;
 431         } else {
 432                 clear_bit(RX_URB_FAIL, &dev->flags);
 433         }
 434
 435         return;
 436 resched:
 437         tasklet_schedule(&dev->tl);
 438 }
 439
 440 static void write_bulk_callback(struct urb *urb)
 441 {
 442         rtl8150_t *dev;
 443         int status = urb->status;
 444
 445         dev = urb->context;
 446         if (!dev)
 447                 return;
 448         dev_kfree_skb_irq(dev->tx_skb);
 449         if (!netif_device_present(dev->netdev))
 450                 return;
 451         if (status)
 452                 dev_info(&urb->dev->dev, "%s: Tx status %d\n",
 453                          dev->netdev->name, status);
 454         dev->netdev->trans_start = jiffies;
 455         netif_wake_queue(dev->netdev);
 456 }
 457
 458 static void intr_callback(struct urb *urb)
 459 {
 460         rtl8150_t *dev;
 461         __u8 *d;
 462         int status = urb->status;
 463         int res;
 464
 465         dev = urb->context;
 466         if (!dev)
 467                 return;
 468         switch (status) {
 469         case 0:                 /* success */
 470                 break;
 471         case -ECONNRESET:       /* unlink */
 472         case -ENOENT:
 473         case -ESHUTDOWN:
 474                 return;
 475         /* -EPIPE:  should clear the halt */
 476         default:
 477                 dev_info(&urb->dev->dev, "%s: intr status %d\n",
 478                          dev->netdev->name, status);
 479                 goto resubmit;
 480         }
 481
 482         d = urb->transfer_buffer;
 483         if (d[0] & TSR_ERRORS) {
 484                 dev->netdev->stats.tx_errors++;
 485                 if (d[INT_TSR] & (TSR_ECOL | TSR_JBR))
 486                         dev->netdev->stats.tx_aborted_errors++;
 487                 if (d[INT_TSR] & TSR_LCOL)
 488                         dev->netdev->stats.tx_window_errors++;
 489                 if (d[INT_TSR] & TSR_LOSS_CRS)
 490                         dev->netdev->stats.tx_carrier_errors++;
 491         }
 492         /* Report link status changes to the network stack */
 493         if ((d[INT_MSR] & MSR_LINK) == 0) {
 494                 if (netif_carrier_ok(dev->netdev)) {
 495                         netif_carrier_off(dev->netdev);
 496                         netdev_dbg(dev->netdev, "%s: LINK LOST\n", __func__);
 497                 }
 498         } else {
 499                 if (!netif_carrier_ok(dev->netdev)) {
 500                         netif_carrier_on(dev->netdev);
 501                         netdev_dbg(dev->netdev, "%s: LINK CAME BACK\n", __func__);
 502                 }
 503         }
 504
 505 resubmit:
 506         res = usb_submit_urb (urb, GFP_ATOMIC);
 507         if (res == -ENODEV)
 508                 netif_device_detach(dev->netdev);
 509         else if (res)
 510                 dev_err(&dev->udev->dev,
 511                         "can't resubmit intr, %s-%s/input0, status %d\n",
 512                         dev->udev->bus->bus_name, dev->udev->devpath, res);
 513 }
 514
 515 static int rtl8150_suspend(struct usb_interface *intf, pm_message_t message)
 516 {
 517         rtl8150_t *dev = usb_get_intfdata(intf);
 518
 519         netif_device_detach(dev->netdev);
 520
 521         if (netif_running(dev->netdev)) {
 522                 usb_kill_urb(dev->rx_urb);
 523                 usb_kill_urb(dev->intr_urb);
 524         }
 525         return 0;
 526 }
 527
 528 static int rtl8150_resume(struct usb_interface *intf)
 529 {
 530         rtl8150_t *dev = usb_get_intfdata(intf);
 531
 532         netif_device_attach(dev->netdev);
 533         if (netif_running(dev->netdev)) {
 534                 dev->rx_urb->status = 0;
 535                 dev->rx_urb->actual_length = 0;
 536                 read_bulk_callback(dev->rx_urb);
 537
 538                 dev->intr_urb->status = 0;
 539                 dev->intr_urb->actual_length = 0;
 540                 intr_callback(dev->intr_urb);
 541         }
 542         return 0;
 543 }
 544
 545 /*
 546 **
 547 **      network related part of the code
 548 **
 549 */
 550
 551 static void fill_skb_pool(rtl8150_t *dev)
 552 {
 553         struct sk_buff *skb;
 554         int i;
 555
 556         for (i = 0; i < RX_SKB_POOL_SIZE; i++) {
 557                 if (dev->rx_skb_pool[i])
 558                         continue;
 559                 skb = dev_alloc_skb(RTL8150_MTU + 2);
 560                 if (!skb) {
 561                         return;
 562                 }
 563                 skb_reserve(skb, 2);
 564                 dev->rx_skb_pool[i] = skb;
 565         }
 566 }
 567
 568 static void free_skb_pool(rtl8150_t *dev)
 569 {
 570         int i;
 571
 572         for (i = 0; i < RX_SKB_POOL_SIZE; i++)
 573                 if (dev->rx_skb_pool[i])
 574                         dev_kfree_skb(dev->rx_skb_pool[i]);
 575 }
 576
 577 static void rx_fixup(unsigned long data)
 578 {
 579         struct rtl8150 *dev = (struct rtl8150 *)data;
 580         struct sk_buff *skb;
 581         int status;
 582
 583         spin_lock_irq(&dev->rx_pool_lock);
 584         fill_skb_pool(dev);
 585         spin_unlock_irq(&dev->rx_pool_lock);
 586         if (test_bit(RX_URB_FAIL, &dev->flags))
 587                 if (dev->rx_skb)
 588                         goto try_again;
 589         spin_lock_irq(&dev->rx_pool_lock);
 590         skb = pull_skb(dev);
 591         spin_unlock_irq(&dev->rx_pool_lock);
 592         if (skb == NULL)
 593                 goto tlsched;
 594         dev->rx_skb = skb;
 595         usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
 596                       dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
 597 try_again:
 598         status = usb_submit_urb(dev->rx_urb, GFP_ATOMIC);
 599         if (status == -ENODEV) {
 600                 netif_device_detach(dev->netdev);
 601         } else if (status) {
 602                 set_bit(RX_URB_FAIL, &dev->flags);
 603                 goto tlsched;
 604         } else {
 605                 clear_bit(RX_URB_FAIL, &dev->flags);
 606         }
 607
 608         return;
 609 tlsched:
 610         tasklet_schedule(&dev->tl);
 611 }
 612
 613 static int enable_net_traffic(rtl8150_t * dev)
 614 {
 615         u8 cr, tcr, rcr, msr;
 616
 617         if (!rtl8150_reset(dev)) {
 618                 dev_warn(&dev->udev->dev, "device reset failed\n");
 619         }
 620         /* RCR bit7=1 attach Rx info at the end;  =0 HW CRC (which is broken) */
 621         rcr = 0x9e;
 622         tcr = 0xd8;
 623         cr = 0x0c;
 624         if (!(rcr & 0x80))
 625                 set_bit(RTL8150_HW_CRC, &dev->flags);
 626         set_registers(dev, RCR, 1, &rcr);
 627         set_registers(dev, TCR, 1, &tcr);
 628         set_registers(dev, CR, 1, &cr);
 629         get_registers(dev, MSR, 1, &msr);
 630
 631         return 0;
 632 }
 633
 634 static void disable_net_traffic(rtl8150_t * dev)
 635 {
 636         u8 cr;
 637
 638         get_registers(dev, CR, 1, &cr);
 639         cr &= 0xf3;
 640         set_registers(dev, CR, 1, &cr);
 641 }
 642
 643 static void rtl8150_tx_timeout(struct net_device *netdev)
 644 {
 645         rtl8150_t *dev = netdev_priv(netdev);
 646         dev_warn(&netdev->dev, "Tx timeout.\n");
 647         usb_unlink_urb(dev->tx_urb);
 648         netdev->stats.tx_errors++;
 649 }
 650
 651 static void rtl8150_set_multicast(struct net_device *netdev)
 652 {
 653         rtl8150_t *dev = netdev_priv(netdev);
 654         u16 rx_creg = 0x9e;
 655
 656         netif_stop_queue(netdev);
 657         if (netdev->flags & IFF_PROMISC) {
 658                 rx_creg |= 0x0001;
 659                 dev_info(&netdev->dev, "%s: promiscuous mode\n", netdev->name);
 660         } else if (!netdev_mc_empty(netdev) ||
 661                    (netdev->flags & IFF_ALLMULTI)) {
 662                 rx_creg &= 0xfffe;
 663                 rx_creg |= 0x0002;
 664                 dev_info(&netdev->dev, "%s: allmulti set\n", netdev->name);
 665         } else {
 666                 /* ~RX_MULTICAST, ~RX_PROMISCUOUS */
 667                 rx_creg &= 0x00fc;
 668         }
 669         async_set_registers(dev, RCR, sizeof(rx_creg), rx_creg);
 670         netif_wake_queue(netdev);
 671 }
 672
 673 static netdev_tx_t rtl8150_start_xmit(struct sk_buff *skb,
 674                                             struct net_device *netdev)
 675 {
 676         rtl8150_t *dev = netdev_priv(netdev);
 677         int count, res;
 678
 679         netif_stop_queue(netdev);
 680         count = (skb->len < 60) ? 60 : skb->len;
 681         count = (count & 0x3f) ? count : count + 1;
 682         dev->tx_skb = skb;
 683         usb_fill_bulk_urb(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev, 2),
 684                       skb->data, count, write_bulk_callback, dev);
 685         if ((res = usb_submit_urb(dev->tx_urb, GFP_ATOMIC))) {
 686                 /* Can we get/handle EPIPE here? */
 687                 if (res == -ENODEV)
 688                         netif_device_detach(dev->netdev);
 689                 else {
 690                         dev_warn(&netdev->dev, "failed tx_urb %d\n", res);
 691                         netdev->stats.tx_errors++;
 692                         netif_start_queue(netdev);
 693                 }
 694         } else {
 695                 netdev->stats.tx_packets++;
 696                 netdev->stats.tx_bytes += skb->len;
 697                 netdev->trans_start = jiffies;
 698         }
 699
 700         return NETDEV_TX_OK;
 701 }
 702
 703
 704 static void set_carrier(struct net_device *netdev)
 705 {
 706         rtl8150_t *dev = netdev_priv(netdev);
 707         short tmp;
 708
 709         get_registers(dev, CSCR, 2, &tmp);
 710         if (tmp & CSCR_LINK_STATUS)
 711                 netif_carrier_on(netdev);
 712         else
 713                 netif_carrier_off(netdev);
 714 }
 715
 716 static int rtl8150_open(struct net_device *netdev)
 717 {
 718         rtl8150_t *dev = netdev_priv(netdev);
 719         int res;
 720
 721         if (dev->rx_skb == NULL)
 722                 dev->rx_skb = pull_skb(dev);
 723         if (!dev->rx_skb)
 724                 return -ENOMEM;
 725
 726         set_registers(dev, IDR, 6, netdev->dev_addr);
 727
 728         usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
 729                       dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
 730         if ((res = usb_submit_urb(dev->rx_urb, GFP_KERNEL))) {
 731                 if (res == -ENODEV)
 732                         netif_device_detach(dev->netdev);
 733                 dev_warn(&netdev->dev, "rx_urb submit failed: %d\n", res);
 734                 return res;
 735         }
 736         usb_fill_int_urb(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3),
 737                      dev->intr_buff, INTBUFSIZE, intr_callback,
 738                      dev, dev->intr_interval);
 739         if ((res = usb_submit_urb(dev->intr_urb, GFP_KERNEL))) {
 740                 if (res == -ENODEV)
 741                         netif_device_detach(dev->netdev);
 742                 dev_warn(&netdev->dev, "intr_urb submit failed: %d\n", res);
 743                 usb_kill_urb(dev->rx_urb);
 744                 return res;
 745         }
 746         enable_net_traffic(dev);
 747         set_carrier(netdev);
 748         netif_start_queue(netdev);
 749
 750         return res;
 751 }
 752
 753 static int rtl8150_close(struct net_device *netdev)
 754 {
 755         rtl8150_t *dev = netdev_priv(netdev);
 756         int res = 0;
 757
 758         netif_stop_queue(netdev);
 759         if (!test_bit(RTL8150_UNPLUG, &dev->flags))
 760                 disable_net_traffic(dev);
 761         unlink_all_urbs(dev);
 762
 763         return res;
 764 }
 765
 766 static void rtl8150_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *info)
 767 {
 768         rtl8150_t *dev = netdev_priv(netdev);
 769
 770         strlcpy(info->driver, driver_name, sizeof(info->driver));
 771         strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
 772         usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
 773 }
 774
 775 static int rtl8150_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
 776 {
 777         rtl8150_t *dev = netdev_priv(netdev);
 778         short lpa, bmcr;
 779
 780         ecmd->supported = (SUPPORTED_10baseT_Half |
 781                           SUPPORTED_10baseT_Full |
 782                           SUPPORTED_100baseT_Half |
 783                           SUPPORTED_100baseT_Full |
 784                           SUPPORTED_Autoneg |
 785                           SUPPORTED_TP | SUPPORTED_MII);
 786         ecmd->port = PORT_TP;
 787         ecmd->transceiver = XCVR_INTERNAL;
 788         ecmd->phy_address = dev->phy;
 789         get_registers(dev, BMCR, 2, &bmcr);
 790         get_registers(dev, ANLP, 2, &lpa);
 791         if (bmcr & BMCR_ANENABLE) {
 792                 u32 speed = ((lpa & (LPA_100HALF | LPA_100FULL)) ?
 793                              SPEED_100 : SPEED_10);
 794                 ethtool_cmd_speed_set(ecmd, speed);
 795                 ecmd->autoneg = AUTONEG_ENABLE;
 796                 if (speed == SPEED_100)
 797                         ecmd->duplex = (lpa & LPA_100FULL) ?
 798                             DUPLEX_FULL : DUPLEX_HALF;
 799                 else
 800                         ecmd->duplex = (lpa & LPA_10FULL) ?
 801                             DUPLEX_FULL : DUPLEX_HALF;
 802         } else {
 803                 ecmd->autoneg = AUTONEG_DISABLE;
 804                 ethtool_cmd_speed_set(ecmd, ((bmcr & BMCR_SPEED100) ?
 805                                              SPEED_100 : SPEED_10));
 806                 ecmd->duplex = (bmcr & BMCR_FULLDPLX) ?
 807                     DUPLEX_FULL : DUPLEX_HALF;
 808         }
 809         return 0;
 810 }
 811
 812 static const struct ethtool_ops ops = {
 813         .get_drvinfo = rtl8150_get_drvinfo,
 814         .get_settings = rtl8150_get_settings,
 815         .get_link = ethtool_op_get_link
 816 };
 817
 818 static int rtl8150_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
 819 {
 820         rtl8150_t *dev = netdev_priv(netdev);
 821         u16 *data = (u16 *) & rq->ifr_ifru;
 822         int res = 0;
 823
 824         switch (cmd) {
 825         case SIOCDEVPRIVATE:
 826                 data[0] = dev->phy;
 827         case SIOCDEVPRIVATE + 1:
 828                 read_mii_word(dev, dev->phy, (data[1] & 0x1f), &data[3]);
 829                 break;
 830         case SIOCDEVPRIVATE + 2:
 831                 if (!capable(CAP_NET_ADMIN))
 832                         return -EPERM;
 833                 write_mii_word(dev, dev->phy, (data[1] & 0x1f), data[2]);
 834                 break;
 835         default:
 836                 res = -EOPNOTSUPP;
 837         }
 838
 839         return res;
 840 }
 841
 842 static const struct net_device_ops rtl8150_netdev_ops = {
 843         .ndo_open               = rtl8150_open,
 844         .ndo_stop               = rtl8150_close,
 845         .ndo_do_ioctl           = rtl8150_ioctl,
 846         .ndo_start_xmit         = rtl8150_start_xmit,
 847         .ndo_tx_timeout         = rtl8150_tx_timeout,
 848         .ndo_set_rx_mode        = rtl8150_set_multicast,
 849         .ndo_set_mac_address    = rtl8150_set_mac_address,
 850
 851         .ndo_change_mtu         = eth_change_mtu,
 852         .ndo_validate_addr      = eth_validate_addr,
 853 };
 854
 855 static int rtl8150_probe(struct usb_interface *intf,
 856                          const struct usb_device_id *id)
 857 {
 858         struct usb_device *udev = interface_to_usbdev(intf);
 859         rtl8150_t *dev;
 860         struct net_device *netdev;
 861
 862         netdev = alloc_etherdev(sizeof(rtl8150_t));
 863         if (!netdev)
 864                 return -ENOMEM;
 865
 866         dev = netdev_priv(netdev);
 867
 868         dev->intr_buff = kmalloc(INTBUFSIZE, GFP_KERNEL);
 869         if (!dev->intr_buff) {
 870                 free_netdev(netdev);
 871                 return -ENOMEM;
 872         }
 873
 874         tasklet_init(&dev->tl, rx_fixup, (unsigned long)dev);
 875         spin_lock_init(&dev->rx_pool_lock);
 876
 877         dev->udev = udev;
 878         dev->netdev = netdev;
 879         netdev->netdev_ops = &rtl8150_netdev_ops;
 880         netdev->watchdog_timeo = RTL8150_TX_TIMEOUT;
 881         SET_ETHTOOL_OPS(netdev, &ops);
 882         dev->intr_interval = 100;       /* 100ms */
 883
 884         if (!alloc_all_urbs(dev)) {
 885                 dev_err(&intf->dev, "out of memory\n");
 886                 goto out;
 887         }
 888         if (!rtl8150_reset(dev)) {
 889                 dev_err(&intf->dev, "couldn't reset the device\n");
 890                 goto out1;
 891         }
 892         fill_skb_pool(dev);
 893         set_ethernet_addr(dev);
 894
 895         usb_set_intfdata(intf, dev);
 896         SET_NETDEV_DEV(netdev, &intf->dev);
 897         if (register_netdev(netdev) != 0) {
 898                 dev_err(&intf->dev, "couldn't register the device\n");
 899                 goto out2;
 900         }
 901
 902         dev_info(&intf->dev, "%s: rtl8150 is detected\n", netdev->name);
 903
 904         return 0;
 905
 906 out2:
 907         usb_set_intfdata(intf, NULL);
 908         free_skb_pool(dev);
 909 out1:
 910         free_all_urbs(dev);
 911 out:
 912         kfree(dev->intr_buff);
 913         free_netdev(netdev);
 914         return -EIO;
 915 }
 916
 917 static void rtl8150_disconnect(struct usb_interface *intf)
 918 {
 919         rtl8150_t *dev = usb_get_intfdata(intf);
 920
 921         usb_set_intfdata(intf, NULL);
 922         if (dev) {
 923                 set_bit(RTL8150_UNPLUG, &dev->flags);
 924                 tasklet_kill(&dev->tl);
 925                 unregister_netdev(dev->netdev);
 926                 unlink_all_urbs(dev);
 927                 free_all_urbs(dev);
 928                 free_skb_pool(dev);
 929                 if (dev->rx_skb)
 930                         dev_kfree_skb(dev->rx_skb);
 931                 kfree(dev->intr_buff);
 932                 free_netdev(dev->netdev);
 933         }
 934 }
 935
 936 static struct usb_driver rtl8150_driver = {
 937         .name           = driver_name,
 938         .probe          = rtl8150_probe,
 939         .disconnect     = rtl8150_disconnect,
 940         .id_table       = rtl8150_table,
 941         .suspend        = rtl8150_suspend,
 942         .resume         = rtl8150_resume,
 943         .disable_hub_initiated_lpm = 1,
 944 };
 945
 946 module_usb_driver(rtl8150_driver);
 947
 948 MODULE_AUTHOR(DRIVER_AUTHOR);
 949 MODULE_DESCRIPTION(DRIVER_DESC);
 950 MODULE_LICENSE("GPL");