drivers/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/config.h>
  10 #include <linux/sched.h>
  11 #include <linux/signal.h>
  12 #include <linux/slab.h>
  13 #include <linux/module.h>
  14 #include <linux/netdevice.h>
  15 #include <linux/etherdevice.h>
  16 #include <linux/mii.h>
  17 #include <linux/ethtool.h>
  18 #include <linux/devfs_fs_kernel.h>
  19 #include <linux/usb.h>
  20 #include <linux/init.h>
  21 #include <asm/uaccess.h>
  22
  23 /* Version Information */
  24 #define DRIVER_VERSION "v0.4.3 (2002/12/31)"
  25 #define DRIVER_AUTHOR "Petko Manolov <petkan@users.sourceforge.net>"
  26 #define DRIVER_DESC "rtl8150 based usb-ethernet driver"
  27
  28 #define IDR                     0x0120
  29 #define MAR                     0x0126
  30 #define CR                      0x012e
  31 #define TCR                     0x012f
  32 #define RCR                     0x0130
  33 #define TSR                     0x0132
  34 #define RSR                     0x0133
  35 #define CON0                    0x0135
  36 #define CON1                    0x0136
  37 #define MSR                     0x0137
  38 #define PHYADD                  0x0138
  39 #define PHYDAT                  0x0139
  40 #define PHYCNT                  0x013b
  41 #define GPPC                    0x013d
  42 #define BMCR                    0x0140
  43 #define BMSR                    0x0142
  44 #define ANAR                    0x0144
  45 #define ANLP                    0x0146
  46 #define AER                     0x0148
  47
  48 #define IDR_EEPROM              0x1202
  49
  50 #define PHY_READ                0
  51 #define PHY_WRITE               0x20
  52 #define PHY_GO                  0x40
  53
  54 #define RTL8150_REQT_READ       0xc0
  55 #define RTL8150_REQT_WRITE      0x40
  56 #define RTL8150_REQ_GET_REGS    0x05
  57 #define RTL8150_REQ_SET_REGS    0x05
  58
  59 #define RTL8150_MTU             1500
  60 #define RTL8150_MAX_MTU         1536
  61
  62 #define RTL8150_TX_TIMEOUT      (HZ)
  63
  64 /* rtl8150 flags */
  65 #define RTL8150_FLAG_HWCRC      0
  66 #define RX_REG_SET              1
  67 #define RTL8150_UNPLUG          2
  68
  69 /* Define these values to match your device */
  70 #define VENDOR_ID_REALTEK               0x0bda
  71 #define VENDOR_ID_MELCO                 0x0411
  72
  73 #define PRODUCT_ID_RTL8150              0x8150
  74 #define PRODUCT_ID_LUAKTX               0x0012
  75
  76 #undef EEPROM_WRITE
  77
  78 /* table of devices that work with this driver */
  79 static struct usb_device_id rtl8150_table[] = {
  80         {USB_DEVICE(VENDOR_ID_REALTEK, PRODUCT_ID_RTL8150)},
  81         {USB_DEVICE(VENDOR_ID_MELCO, PRODUCT_ID_LUAKTX)},
  82         {}
  83 };
  84
  85 MODULE_DEVICE_TABLE(usb, rtl8150_table);
  86
  87 struct rtl8150 {
  88         unsigned int flags;
  89         struct usb_device *udev;
  90         struct usb_interface *interface;
  91         struct semaphore sem;
  92         struct net_device_stats stats;
  93         struct net_device *netdev;
  94         struct urb *rx_urb, *tx_urb, *intr_urb, *ctrl_urb;
  95         struct usb_ctrlrequest dr;
  96         int intr_interval;
  97         u16 rx_creg;
  98         u8 rx_buff[RTL8150_MAX_MTU];
  99         u8 tx_buff[RTL8150_MAX_MTU];
 100         u8 intr_buff[8];
 101         u8 phy;
 102 };
 103
 104 typedef struct rtl8150 rtl8150_t;
 105
 106 /* the global usb devfs handle */
 107 extern devfs_handle_t usb_devfs_handle;
 108 unsigned long multicast_filter_limit = 32;
 109
 110 static void rtl8150_disconnect(struct usb_device *dev, void *ptr);
 111 static void *rtl8150_probe(struct usb_device *dev, unsigned int ifnum,
 112                            const struct usb_device_id *id);
 113
 114 static const char driver_name[] = "rtl8150";
 115
 116 static struct usb_driver rtl8150_driver = {
 117         name:           driver_name,
 118         probe:          rtl8150_probe,
 119         disconnect:     rtl8150_disconnect,
 120         id_table:       rtl8150_table,
 121 };
 122
 123 /*
 124 **
 125 **      device related part of the code
 126 **
 127 */
 128 static int get_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
 129 {
 130         return usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
 131                                RTL8150_REQ_GET_REGS, RTL8150_REQT_READ,
 132                                indx, 0, data, size, HZ / 2);
 133 }
 134
 135 static int set_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
 136 {
 137         return usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
 138                                RTL8150_REQ_SET_REGS, RTL8150_REQT_WRITE,
 139                                indx, 0, data, size, HZ / 2);
 140 }
 141
 142 static void ctrl_callback(struct urb *urb)
 143 {
 144         rtl8150_t *dev;
 145
 146         switch (urb->status) {
 147         case 0:
 148                 break;
 149         case -EINPROGRESS:
 150                 break;
 151         case -ENOENT:
 152                 break;
 153         default:
 154                 warn("ctrl urb status %d", urb->status);
 155         }
 156         dev = urb->context;
 157         clear_bit(RX_REG_SET, &dev->flags);
 158 }
 159
 160 static int async_set_registers(rtl8150_t * dev, u16 indx, u16 size)
 161 {
 162         int ret;
 163
 164         if (test_bit(RX_REG_SET, &dev->flags))
 165                 return -EAGAIN;
 166
 167         dev->dr.bRequestType = RTL8150_REQT_WRITE;
 168         dev->dr.bRequest = RTL8150_REQ_SET_REGS;
 169         dev->dr.wValue = cpu_to_le16(indx);
 170         dev->dr.wIndex = 0;
 171         dev->dr.wLength = cpu_to_le16(2);
 172         dev->ctrl_urb->transfer_buffer_length = 2;
 173         FILL_CONTROL_URB(dev->ctrl_urb, dev->udev,
 174                          usb_sndctrlpipe(dev->udev, 0), (char *) &dev->dr,
 175                          &dev->rx_creg, 2, ctrl_callback, dev);
 176         if ((ret = usb_submit_urb(dev->ctrl_urb)))
 177                 err("control request submission failed: %d", ret);
 178         else
 179                 set_bit(RX_REG_SET, &dev->flags);
 180
 181         return ret;
 182 }
 183
 184 static int read_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 * reg)
 185 {
 186         int i;
 187         u8 data[3], tmp;
 188
 189         data[0] = phy;
 190         data[1] = data[2] = 0;
 191         tmp = indx | PHY_READ | PHY_GO;
 192         i = 0;
 193
 194         set_registers(dev, PHYADD, sizeof(data), data);
 195         set_registers(dev, PHYCNT, 1, &tmp);
 196         do {
 197                 get_registers(dev, PHYCNT, 1, data);
 198         } while ((data[0] & PHY_GO) && (i++ < HZ));
 199
 200         if (i < HZ) {
 201                 get_registers(dev, PHYDAT, 2, data);
 202                 *reg = le16_to_cpup((u16 *)data);
 203                 return 0;
 204         } else
 205                 return 1;
 206 }
 207
 208 static int write_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 reg)
 209 {
 210         int i;
 211         u8 data[3], tmp;
 212
 213         data[0] = phy;
 214         *(data + 1) = cpu_to_le16p(&reg);
 215         tmp = indx | PHY_WRITE | PHY_GO;
 216         i = 0;
 217
 218         set_registers(dev, PHYADD, sizeof(data), data);
 219         set_registers(dev, PHYCNT, 1, &tmp);
 220         do {
 221                 get_registers(dev, PHYCNT, 1, data);
 222         } while ((data[0] & PHY_GO) && (i++ < HZ));
 223
 224         if (i < HZ)
 225                 return 0;
 226         else
 227                 return 1;
 228 }
 229
 230 static inline void set_ethernet_addr(rtl8150_t * dev)
 231 {
 232         u8 node_id[6];
 233
 234         get_registers(dev, IDR, sizeof(node_id), node_id);
 235         memcpy(dev->netdev->dev_addr, node_id, sizeof(node_id));
 236 }
 237
 238 static int rtl8150_set_mac_address(struct net_device *netdev, void *p)
 239 {
 240         struct sockaddr *addr = p;
 241         rtl8150_t *dev;
 242         int i;
 243
 244         if (netif_running(netdev))
 245                 return -EBUSY;
 246         dev = netdev->priv;
 247         if (dev == NULL) {
 248                 return -ENODEV;
 249         }
 250         memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
 251         dbg("%s: Setting MAC address to ", netdev->name);
 252         for (i = 0; i < 5; i++)
 253                 printk("%02X:", netdev->dev_addr[i]);
 254         dbg("%02X\n", netdev->dev_addr[i]);
 255         /* Set the IDR registers. */
 256         set_registers(dev, IDR, sizeof(netdev->dev_addr), netdev->dev_addr);
 257 #ifdef EEPROM_WRITE
 258         {
 259         u8 cr;
 260         /* Get the CR contents. */
 261         get_registers(dev, CR, 1, &cr);
 262         /* Set the WEPROM bit (eeprom write enable). */
 263         cr |= 0x20;
 264         set_registers(dev, CR, 1, &cr);
 265         /* Write the MAC address into eeprom. Eeprom writes must be word-sized,
 266            so we need to split them up. */
 267         for (i = 0; i * 2 < netdev->addr_len; i++) {
 268                 set_registers(dev, IDR_EEPROM + (i * 2), 2,
 269                               netdev->dev_addr + (i * 2));
 270         }
 271         /* Clear the WEPROM bit (preventing accidental eeprom writes). */
 272         cr &= 0xdf;
 273         set_registers(dev, CR, 1, &cr);
 274         }
 275 #endif
 276         return 0;
 277 }
 278
 279 static int rtl8150_reset(rtl8150_t * dev)
 280 {
 281         u8 data = 0x10;
 282         int i = HZ;
 283
 284         set_registers(dev, CR, 1, &data);
 285         do {
 286                 get_registers(dev, CR, 1, &data);
 287         } while ((data & 0x10) && --i);
 288
 289         return (i > 0) ? 0 : -1;
 290 }
 291
 292 static int alloc_all_urbs(rtl8150_t * dev)
 293 {
 294         dev->rx_urb = usb_alloc_urb(0);
 295         if (!dev->rx_urb)
 296                 return 0;
 297         dev->tx_urb = usb_alloc_urb(0);
 298         if (!dev->tx_urb) {
 299                 usb_free_urb(dev->rx_urb);
 300                 return 0;
 301         }
 302         dev->intr_urb = usb_alloc_urb(0);
 303         if (!dev->intr_urb) {
 304                 usb_free_urb(dev->rx_urb);
 305                 usb_free_urb(dev->tx_urb);
 306                 return 0;
 307         }
 308         dev->ctrl_urb = usb_alloc_urb(0);
 309         if (!dev->ctrl_urb) {
 310                 usb_free_urb(dev->rx_urb);
 311                 usb_free_urb(dev->tx_urb);
 312                 usb_free_urb(dev->intr_urb);
 313                 return 0;
 314         }
 315
 316         return 1;
 317 }
 318
 319 static void free_all_urbs(rtl8150_t * dev)
 320 {
 321         usb_free_urb(dev->rx_urb);
 322         usb_free_urb(dev->tx_urb);
 323         usb_free_urb(dev->intr_urb);
 324         usb_free_urb(dev->ctrl_urb);
 325 }
 326
 327 static void unlink_all_urbs(rtl8150_t * dev)
 328 {
 329         usb_unlink_urb(dev->rx_urb);
 330         usb_unlink_urb(dev->tx_urb);
 331         usb_unlink_urb(dev->intr_urb);
 332         usb_unlink_urb(dev->ctrl_urb);
 333 }
 334
 335 static void read_bulk_callback(struct urb *urb)
 336 {
 337         rtl8150_t *dev;
 338         int pkt_len, res;
 339         struct sk_buff *skb;
 340         struct net_device *netdev;
 341         u16 rx_stat;
 342
 343         dev = urb->context;
 344         if (!dev) {
 345                 warn("!dev");
 346                 return;
 347         }
 348         netdev = dev->netdev;
 349         if (!netif_device_present(netdev)) {
 350                 warn("netdev is not present");
 351                 return;
 352         }
 353         switch (urb->status) {
 354         case 0:
 355                 break;
 356         case -ENOENT:
 357                 return;
 358         case -ETIMEDOUT:
 359                 warn("need a device reset?..");
 360                 goto goon;
 361         default:
 362                 warn("Rx status %d", urb->status);
 363                 goto goon;
 364         }
 365
 366         pkt_len = urb->actual_length - 4;
 367         rx_stat = le16_to_cpu(*(u16 *) (dev->rx_buff + pkt_len));
 368
 369         if (!(skb = dev_alloc_skb(pkt_len + 2)))
 370                 goto goon;
 371         skb->dev = netdev;
 372         skb_reserve(skb, 2);
 373         eth_copy_and_sum(skb, dev->rx_buff, pkt_len, 0);
 374         skb_put(skb, pkt_len);
 375         skb->protocol = eth_type_trans(skb, netdev);
 376         netif_rx(skb);
 377         dev->stats.rx_packets++;
 378         dev->stats.rx_bytes += pkt_len;
 379 goon:
 380         FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
 381                       dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev);
 382         if ((res = usb_submit_urb(dev->rx_urb)))
 383                 warn("%s: Rx urb submission failed %d", netdev->name, res);
 384 }
 385
 386 static void write_bulk_callback(struct urb *urb)
 387 {
 388         rtl8150_t *dev;
 389
 390         dev = urb->context;
 391         if (!dev)
 392                 return;
 393         if (!netif_device_present(dev->netdev))
 394                 return;
 395         if (urb->status)
 396                 info("%s: Tx status %d", dev->netdev->name, urb->status);
 397         dev->netdev->trans_start = jiffies;
 398         netif_wake_queue(dev->netdev);
 399 }
 400
 401 void intr_callback(struct urb *urb)
 402 {
 403         rtl8150_t *dev;
 404
 405         dev = urb->context;
 406         if (!dev)
 407                 return;
 408         switch (urb->status) {
 409         case 0:
 410                 break;
 411         case -ENOENT:
 412                 return;
 413         default:
 414                 info("%s: intr status %d", dev->netdev->name, urb->status);
 415         }
 416 }
 417
 418 /*
 419 **
 420 **      network related part of the code
 421 **
 422 */
 423
 424 static int enable_net_traffic(rtl8150_t * dev)
 425 {
 426         u8 cr, tcr, rcr, msr;
 427
 428         if (rtl8150_reset(dev)) {
 429                 warn("%s - device reset failed", __FUNCTION__);
 430         }
 431         rcr = 0x9e;     /* bit7=1 attach Rx info at the end */
 432         dev->rx_creg = cpu_to_le16(rcr);
 433         tcr = 0xd8;
 434         cr = 0x0c;
 435         set_registers(dev, RCR, 1, &rcr);
 436         set_registers(dev, TCR, 1, &tcr);
 437         set_registers(dev, CR, 1, &cr);
 438         get_registers(dev, MSR, 1, &msr);
 439
 440         return 0;
 441 }
 442
 443 static void disable_net_traffic(rtl8150_t * dev)
 444 {
 445         u8 cr;
 446
 447         get_registers(dev, CR, 1, &cr);
 448         cr &= 0xf3;
 449         set_registers(dev, CR, 1, &cr);
 450 }
 451
 452 static struct net_device_stats *rtl8150_netdev_stats(struct net_device *dev)
 453 {
 454         return &((rtl8150_t *) dev->priv)->stats;
 455 }
 456
 457 static void rtl8150_tx_timeout(struct net_device *netdev)
 458 {
 459         rtl8150_t *dev;
 460
 461         dev = netdev->priv;
 462         if (!dev)
 463                 return;
 464         warn("%s: Tx timeout.", netdev->name);
 465         dev->tx_urb->transfer_flags |= USB_ASYNC_UNLINK;
 466         usb_unlink_urb(dev->tx_urb);
 467         dev->stats.tx_errors++;
 468 }
 469
 470 static void rtl8150_set_multicast(struct net_device *netdev)
 471 {
 472         rtl8150_t *dev;
 473
 474         dev = netdev->priv;
 475         netif_stop_queue(netdev);
 476         if (netdev->flags & IFF_PROMISC) {
 477                 dev->rx_creg |= cpu_to_le16(0x0001);
 478                 info("%s: promiscuous mode", netdev->name);
 479         } else if ((netdev->mc_count > multicast_filter_limit) ||
 480                    (netdev->flags & IFF_ALLMULTI)) {
 481                 dev->rx_creg &= cpu_to_le16(0xfffe);
 482                 dev->rx_creg |= cpu_to_le16(0x0002);
 483                 info("%s: allmulti set", netdev->name);
 484         } else {
 485                 /* ~RX_MULTICAST, ~RX_PROMISCUOUS */
 486                 dev->rx_creg &= cpu_to_le16(0x00fc);
 487         }
 488         async_set_registers(dev, RCR, 2);
 489         netif_wake_queue(netdev);
 490 }
 491
 492 static int rtl8150_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 493 {
 494         rtl8150_t *dev;
 495         int count, res;
 496
 497         netif_stop_queue(netdev);
 498         dev = netdev->priv;
 499         count = (skb->len < 60) ? 60 : skb->len;
 500         count = (count & 0x3f) ? count : count + 1;
 501         memcpy(dev->tx_buff, skb->data, skb->len);
 502         FILL_BULK_URB(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev, 2),
 503                       dev->tx_buff, count, write_bulk_callback, dev);
 504         dev->tx_urb->transfer_buffer_length = count;
 505
 506         if ((res = usb_submit_urb(dev->tx_urb))) {
 507                 warn("failed tx_urb %d\n", res);
 508                 dev->stats.tx_errors++;
 509                 netif_start_queue(netdev);
 510         } else {
 511                 dev->stats.tx_packets++;
 512                 dev->stats.tx_bytes += skb->len;
 513                 netdev->trans_start = jiffies;
 514         }
 515         dev_kfree_skb(skb);
 516
 517         return 0;
 518 }
 519
 520 static int rtl8150_open(struct net_device *netdev)
 521 {
 522         rtl8150_t *dev;
 523         int res;
 524
 525         dev = netdev->priv;
 526         if (dev == NULL) {
 527                 return -ENODEV;
 528         }
 529
 530         down(&dev->sem);
 531
 532         set_registers(dev, IDR, 6, netdev->dev_addr);
 533
 534         FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
 535                       dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev);
 536         if ((res = usb_submit_urb(dev->rx_urb)))
 537                 warn("%s: rx_urb submit failed: %d", __FUNCTION__, res);
 538         FILL_INT_URB(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3),
 539                      dev->intr_buff, sizeof(dev->intr_buff), intr_callback,
 540                      dev, dev->intr_interval);
 541         if ((res = usb_submit_urb(dev->intr_urb)))
 542                 warn("%s: intr_urb submit failed: %d", __FUNCTION__, res);
 543         netif_start_queue(netdev);
 544         enable_net_traffic(dev);
 545         up(&dev->sem);
 546
 547         return res;
 548 }
 549
 550 static int rtl8150_close(struct net_device *netdev)
 551 {
 552         rtl8150_t *dev;
 553         int res = 0;
 554
 555         dev = netdev->priv;
 556         if (!dev)
 557                 return -ENODEV;
 558
 559         down(&dev->sem);
 560         if (!test_bit(RTL8150_UNPLUG, &dev->flags))
 561                 disable_net_traffic(dev);
 562         unlink_all_urbs(dev);
 563         netif_stop_queue(netdev);
 564         up(&dev->sem);
 565
 566         return res;
 567 }
 568
 569 static int rtl8150_ethtool_ioctl(struct net_device *netdev, void *uaddr)
 570 {
 571         rtl8150_t *dev;
 572         int cmd;
 573         char tmp[128];
 574
 575         dev = netdev->priv;
 576         if (get_user(cmd, (int *) uaddr))
 577                 return -EFAULT;
 578
 579         switch (cmd) {
 580         case ETHTOOL_GDRVINFO:{
 581                         struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
 582
 583                         strncpy(info.driver, driver_name, ETHTOOL_BUSINFO_LEN);
 584                         strncpy(info.version, DRIVER_VERSION,
 585                                 ETHTOOL_BUSINFO_LEN);
 586                         sprintf(tmp, "usb%d:%d", dev->udev->bus->busnum,
 587                                 dev->udev->devnum);
 588                         strncpy(info.bus_info, tmp, ETHTOOL_BUSINFO_LEN);
 589                         if (copy_to_user(uaddr, &info, sizeof(info)))
 590                                 return -EFAULT;
 591                         return 0;
 592                 }
 593         case ETHTOOL_GSET:{
 594                         struct ethtool_cmd ecmd;
 595                         short lpa, bmcr;
 596
 597                         if (copy_from_user(&ecmd, uaddr, sizeof(ecmd)))
 598                                 return -EFAULT;
 599                         ecmd.supported = (SUPPORTED_10baseT_Half |
 600                                           SUPPORTED_10baseT_Full |
 601                                           SUPPORTED_100baseT_Half |
 602                                           SUPPORTED_100baseT_Full |
 603                                           SUPPORTED_Autoneg |
 604                                           SUPPORTED_TP | SUPPORTED_MII);
 605                         ecmd.port = PORT_TP;
 606                         ecmd.transceiver = XCVR_INTERNAL;
 607                         ecmd.phy_address = dev->phy;
 608                         get_registers(dev, BMCR, 2, &bmcr);
 609                         get_registers(dev, ANLP, 2, &lpa);
 610                         if (bmcr & BMCR_ANENABLE) {
 611                                 ecmd.autoneg = AUTONEG_ENABLE;
 612                                 ecmd.speed =
 613                                     (lpa & (LPA_100HALF | LPA_100FULL)) ?
 614                                     SPEED_100 : SPEED_10;
 615                                 if (ecmd.speed == SPEED_100)
 616                                         ecmd.duplex = (lpa & LPA_100FULL) ?
 617                                             DUPLEX_FULL : DUPLEX_HALF;
 618                                 else
 619                                         ecmd.duplex = (lpa & LPA_10FULL) ?
 620                                             DUPLEX_FULL : DUPLEX_HALF;
 621                         } else {
 622                                 ecmd.autoneg = AUTONEG_DISABLE;
 623                                 ecmd.speed = (bmcr & BMCR_SPEED100) ?
 624                                     SPEED_100 : SPEED_10;
 625                                 ecmd.duplex = (bmcr & BMCR_FULLDPLX) ?
 626                                     DUPLEX_FULL : DUPLEX_HALF;
 627                         }
 628                         if (copy_to_user(uaddr, &ecmd, sizeof(ecmd)))
 629                                 return -EFAULT;
 630                         return 0;
 631                 }
 632         case ETHTOOL_SSET:
 633                 return -ENOTSUPP;
 634         case ETHTOOL_GLINK:{
 635                         struct ethtool_value edata = { ETHTOOL_GLINK };
 636
 637                         edata.data = netif_carrier_ok(netdev);
 638                         if (copy_to_user(uaddr, &edata, sizeof(edata)))
 639                                 return -EFAULT;
 640                         return 0;
 641                 }
 642         default:
 643                 return -EOPNOTSUPP;
 644         }
 645 }
 646
 647 static int rtl8150_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
 648 {
 649         rtl8150_t *dev;
 650         u16 *data;
 651         int res;
 652
 653         dev = netdev->priv;
 654         data = (u16 *) & rq->ifr_data;
 655         res = 0;
 656
 657         down(&dev->sem);
 658         switch (cmd) {
 659         case SIOCETHTOOL:
 660                 res = rtl8150_ethtool_ioctl(netdev, rq->ifr_data);
 661                 break;
 662         case SIOCDEVPRIVATE:
 663                 data[0] = dev->phy;
 664         case SIOCDEVPRIVATE + 1:
 665                 read_mii_word(dev, dev->phy, (data[1] & 0x1f), &data[3]);
 666                 break;
 667         case SIOCDEVPRIVATE + 2:
 668                 if (!capable(CAP_NET_ADMIN)) {
 669                         up(&dev->sem);
 670                         return -EPERM;
 671                 }
 672                 write_mii_word(dev, dev->phy, (data[1] & 0x1f), data[2]);
 673                 break;
 674         default:
 675                 res = -EOPNOTSUPP;
 676         }
 677         up(&dev->sem);
 678
 679         return res;
 680 }
 681
 682 static void *rtl8150_probe(struct usb_device *udev, unsigned int ifnum,
 683                            const struct usb_device_id *id)
 684 {
 685         rtl8150_t *dev;
 686         struct net_device *netdev;
 687
 688         udev->config[0].bConfigurationValue = 1;
 689         if (usb_set_configuration(udev, udev->config[0].bConfigurationValue)) {
 690                 err("usb_set_configuration() failed");
 691                 return NULL;
 692         }
 693         dev = kmalloc(sizeof(rtl8150_t), GFP_KERNEL);
 694         if (!dev) {
 695                 err("Out of memory");
 696                 goto exit;
 697         } else
 698                 memset(dev, 0, sizeof(rtl8150_t));
 699
 700         netdev = init_etherdev(NULL, 0);
 701         if (!netdev) {
 702                 kfree(dev);
 703                 err("Oh boy, out of memory again?!?");
 704                 dev = NULL;
 705                 goto exit;
 706         }
 707
 708         init_MUTEX(&dev->sem);
 709         dev->udev = udev;
 710         dev->netdev = netdev;
 711         SET_MODULE_OWNER(netdev);
 712         netdev->priv = dev;
 713         netdev->open = rtl8150_open;
 714         netdev->stop = rtl8150_close;
 715         netdev->do_ioctl = rtl8150_ioctl;
 716         netdev->watchdog_timeo = RTL8150_TX_TIMEOUT;
 717         netdev->tx_timeout = rtl8150_tx_timeout;
 718         netdev->hard_start_xmit = rtl8150_start_xmit;
 719         netdev->set_multicast_list = rtl8150_set_multicast;
 720         netdev->set_mac_address = rtl8150_set_mac_address;
 721         netdev->get_stats = rtl8150_netdev_stats;
 722         netdev->mtu = RTL8150_MTU;
 723         dev->intr_interval = 100;       /* 100ms */
 724
 725         if (rtl8150_reset(dev) || !alloc_all_urbs(dev)) {
 726                 err("couldn't reset the device");
 727                 free_all_urbs(dev);
 728                 unregister_netdev(dev->netdev);
 729                 kfree(netdev);
 730                 kfree(dev);
 731                 dev = NULL;
 732                 goto exit;
 733         }
 734
 735         set_ethernet_addr(dev);
 736         /* let's not be very nasty :-) */
 737         info("%s: rtl8150 is detected", netdev->name);
 738 exit:
 739         return dev;
 740 }
 741
 742 static void rtl8150_disconnect(struct usb_device *udev, void *ptr)
 743 {
 744         rtl8150_t *dev;
 745
 746         dev = ptr;
 747         set_bit(RTL8150_UNPLUG, &dev->flags);
 748         unregister_netdev(dev->netdev);
 749         unlink_all_urbs(dev);
 750         free_all_urbs(dev);
 751         kfree(dev->netdev);
 752         kfree(dev);
 753         dev->netdev = NULL;
 754         dev = NULL;
 755 }
 756
 757 static int __init usb_rtl8150_init(void)
 758 {
 759         info(DRIVER_DESC " " DRIVER_VERSION);
 760         return usb_register(&rtl8150_driver);
 761 }
 762
 763 static void __exit usb_rtl8150_exit(void)
 764 {
 765         usb_deregister(&rtl8150_driver);
 766 }
 767
 768 module_init(usb_rtl8150_init);
 769 module_exit(usb_rtl8150_exit);
 770
 771 MODULE_AUTHOR(DRIVER_AUTHOR);
 772 MODULE_DESCRIPTION(DRIVER_DESC);
 773 MODULE_LICENSE("GPL");