URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [usb/] [rtl8150.c] - Blame information for rev 1779

Go to most recent revision | Details | Compare with Previous | View Log


/*
 *  Copyright (c) 2002 Petko Manolov (petkan@users.sourceforge.net)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 */
 
#include <linux/config.h>
#include <linux/sched.h>
#include <linux/signal.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/usb.h>
#include <linux/init.h>
#include <asm/uaccess.h>
 
/* Version Information */
#define DRIVER_VERSION "v0.4.3 (2002/12/31)"
#define DRIVER_AUTHOR "Petko Manolov <petkan@users.sourceforge.net>"
#define DRIVER_DESC "rtl8150 based usb-ethernet driver"
 
#define IDR                     0x0120
#define MAR                     0x0126
#define CR                      0x012e
#define TCR                     0x012f
#define RCR                     0x0130
#define TSR                     0x0132
#define RSR                     0x0133
#define CON0                    0x0135
#define CON1                    0x0136
#define MSR                     0x0137
#define PHYADD                  0x0138
#define PHYDAT                  0x0139
#define PHYCNT                  0x013b
#define GPPC                    0x013d
#define BMCR                    0x0140
#define BMSR                    0x0142
#define ANAR                    0x0144
#define ANLP                    0x0146
#define AER                     0x0148
 
#define IDR_EEPROM              0x1202
 
#define PHY_READ                0
#define PHY_WRITE               0x20
#define PHY_GO                  0x40
 
#define RTL8150_REQT_READ       0xc0
#define RTL8150_REQT_WRITE      0x40
#define RTL8150_REQ_GET_REGS    0x05
#define RTL8150_REQ_SET_REGS    0x05
 
#define RTL8150_MTU             1500
#define RTL8150_MAX_MTU         1536
 
#define RTL8150_TX_TIMEOUT      (HZ)
 
/* rtl8150 flags */
#define RTL8150_FLAG_HWCRC      0
#define RX_REG_SET              1
#define RTL8150_UNPLUG          2
 
/* Define these values to match your device */
#define VENDOR_ID_REALTEK               0x0bda
#define VENDOR_ID_MELCO                 0x0411
 
#define PRODUCT_ID_RTL8150              0x8150
#define PRODUCT_ID_LUAKTX               0x0012
 
#undef EEPROM_WRITE
 
/* table of devices that work with this driver */
static struct usb_device_id rtl8150_table[] = {
        {USB_DEVICE(VENDOR_ID_REALTEK, PRODUCT_ID_RTL8150)},
        {USB_DEVICE(VENDOR_ID_MELCO, PRODUCT_ID_LUAKTX)},
        {}
};
 
MODULE_DEVICE_TABLE(usb, rtl8150_table);
 
struct rtl8150 {
        unsigned int flags;
        struct usb_device *udev;
        struct usb_interface *interface;
        struct semaphore sem;
        struct net_device_stats stats;
        struct net_device *netdev;
        struct urb *rx_urb, *tx_urb, *intr_urb, *ctrl_urb;
        struct usb_ctrlrequest dr;
        int intr_interval;
        u16 rx_creg;
        u8 rx_buff[RTL8150_MAX_MTU];
        u8 tx_buff[RTL8150_MAX_MTU];
        u8 intr_buff[8];
        u8 phy;
};
 
typedef struct rtl8150 rtl8150_t;
 
/* the global usb devfs handle */
extern devfs_handle_t usb_devfs_handle;
unsigned long multicast_filter_limit = 32;
 
static void rtl8150_disconnect(struct usb_device *dev, void *ptr);
static void *rtl8150_probe(struct usb_device *dev, unsigned int ifnum,
                           const struct usb_device_id *id);
 
static const char driver_name[] = "rtl8150";
 
static struct usb_driver rtl8150_driver = {
        name:           driver_name,
        probe:          rtl8150_probe,
        disconnect:     rtl8150_disconnect,
        id_table:       rtl8150_table,
};
 
/*
**
**      device related part of the code
**
*/
static int get_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
{
        return usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
                               RTL8150_REQ_GET_REGS, RTL8150_REQT_READ,
                               indx, 0, data, size, HZ / 2);
}
 
static int set_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
{
        return usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
                               RTL8150_REQ_SET_REGS, RTL8150_REQT_WRITE,
                               indx, 0, data, size, HZ / 2);
}
 
static void ctrl_callback(struct urb *urb)
{
        rtl8150_t *dev;
 
        switch (urb->status) {
        case 0:
                break;
        case -EINPROGRESS:
                break;
        case -ENOENT:
                break;
        default:
                warn("ctrl urb status %d", urb->status);
        }
        dev = urb->context;
        clear_bit(RX_REG_SET, &dev->flags);
}
 
static int async_set_registers(rtl8150_t * dev, u16 indx, u16 size)
{
        int ret;
 
        if (test_bit(RX_REG_SET, &dev->flags))
                return -EAGAIN;
 
        dev->dr.bRequestType = RTL8150_REQT_WRITE;
        dev->dr.bRequest = RTL8150_REQ_SET_REGS;
        dev->dr.wValue = cpu_to_le16(indx);
        dev->dr.wIndex = 0;
        dev->dr.wLength = cpu_to_le16(2);
        dev->ctrl_urb->transfer_buffer_length = 2;
        FILL_CONTROL_URB(dev->ctrl_urb, dev->udev,
                         usb_sndctrlpipe(dev->udev, 0), (char *) &dev->dr,
                         &dev->rx_creg, 2, ctrl_callback, dev);
        if ((ret = usb_submit_urb(dev->ctrl_urb)))
                err("control request submission failed: %d", ret);
        else
                set_bit(RX_REG_SET, &dev->flags);
 
        return ret;
}
 
static int read_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 * reg)
{
        int i;
        u8 data[3], tmp;
 
        data[0] = phy;
        data[1] = data[2] = 0;
        tmp = indx | PHY_READ | PHY_GO;
        i = 0;
 
        set_registers(dev, PHYADD, sizeof(data), data);
        set_registers(dev, PHYCNT, 1, &tmp);
        do {
                get_registers(dev, PHYCNT, 1, data);
        } while ((data[0] & PHY_GO) && (i++ < HZ));
 
        if (i < HZ) {
                get_registers(dev, PHYDAT, 2, data);
                *reg = le16_to_cpup((u16 *)data);
                return 0;
        } else
                return 1;
}
 
static int write_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 reg)
{
        int i;
        u8 data[3], tmp;
 
        data[0] = phy;
        *(data + 1) = cpu_to_le16p(&reg);
        tmp = indx | PHY_WRITE | PHY_GO;
        i = 0;
 
        set_registers(dev, PHYADD, sizeof(data), data);
        set_registers(dev, PHYCNT, 1, &tmp);
        do {
                get_registers(dev, PHYCNT, 1, data);
        } while ((data[0] & PHY_GO) && (i++ < HZ));
 
        if (i < HZ)
                return 0;
        else
                return 1;
}
 
static inline void set_ethernet_addr(rtl8150_t * dev)
{
        u8 node_id[6];
 
        get_registers(dev, IDR, sizeof(node_id), node_id);
        memcpy(dev->netdev->dev_addr, node_id, sizeof(node_id));
}
 
static int rtl8150_set_mac_address(struct net_device *netdev, void *p)
{
        struct sockaddr *addr = p;
        rtl8150_t *dev;
        int i;
 
        if (netif_running(netdev))
                return -EBUSY;
        dev = netdev->priv;
        if (dev == NULL) {
                return -ENODEV;
        }
        memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
        dbg("%s: Setting MAC address to ", netdev->name);
        for (i = 0; i < 5; i++)
                printk("%02X:", netdev->dev_addr[i]);
        dbg("%02X\n", netdev->dev_addr[i]);
        /* Set the IDR registers. */
        set_registers(dev, IDR, sizeof(netdev->dev_addr), netdev->dev_addr);
#ifdef EEPROM_WRITE
        {
        u8 cr;
        /* Get the CR contents. */
        get_registers(dev, CR, 1, &cr);
        /* Set the WEPROM bit (eeprom write enable). */
        cr |= 0x20;
        set_registers(dev, CR, 1, &cr);
        /* Write the MAC address into eeprom. Eeprom writes must be word-sized,
           so we need to split them up. */
        for (i = 0; i * 2 < netdev->addr_len; i++) {
                set_registers(dev, IDR_EEPROM + (i * 2), 2,
                              netdev->dev_addr + (i * 2));
        }
        /* Clear the WEPROM bit (preventing accidental eeprom writes). */
        cr &= 0xdf;
        set_registers(dev, CR, 1, &cr);
        }
#endif  
        return 0;
}
 
static int rtl8150_reset(rtl8150_t * dev)
{
        u8 data = 0x10;
        int i = HZ;
 
        set_registers(dev, CR, 1, &data);
        do {
                get_registers(dev, CR, 1, &data);
        } while ((data & 0x10) && --i);
 
        return (i > 0) ? 0 : -1;
}
 
static int alloc_all_urbs(rtl8150_t * dev)
{
        dev->rx_urb = usb_alloc_urb(0);
        if (!dev->rx_urb)
                return 0;
        dev->tx_urb = usb_alloc_urb(0);
        if (!dev->tx_urb) {
                usb_free_urb(dev->rx_urb);
                return 0;
        }
        dev->intr_urb = usb_alloc_urb(0);
        if (!dev->intr_urb) {
                usb_free_urb(dev->rx_urb);
                usb_free_urb(dev->tx_urb);
                return 0;
        }
        dev->ctrl_urb = usb_alloc_urb(0);
        if (!dev->ctrl_urb) {
                usb_free_urb(dev->rx_urb);
                usb_free_urb(dev->tx_urb);
                usb_free_urb(dev->intr_urb);
                return 0;
        }
 
        return 1;
}
 
static void free_all_urbs(rtl8150_t * dev)
{
        usb_free_urb(dev->rx_urb);
        usb_free_urb(dev->tx_urb);
        usb_free_urb(dev->intr_urb);
        usb_free_urb(dev->ctrl_urb);
}
 
static void unlink_all_urbs(rtl8150_t * dev)
{
        usb_unlink_urb(dev->rx_urb);
        usb_unlink_urb(dev->tx_urb);
        usb_unlink_urb(dev->intr_urb);
        usb_unlink_urb(dev->ctrl_urb);
}
 
static void read_bulk_callback(struct urb *urb)
{
        rtl8150_t *dev;
        int pkt_len, res;
        struct sk_buff *skb;
        struct net_device *netdev;
        u16 rx_stat;
 
        dev = urb->context;
        if (!dev) {
                warn("!dev");
                return;
        }
        netdev = dev->netdev;
        if (!netif_device_present(netdev)) {
                warn("netdev is not present");
                return;
        }
        switch (urb->status) {
        case 0:
                break;
        case -ENOENT:
                return;
        case -ETIMEDOUT:
                warn("need a device reset?..");
                goto goon;
        default:
                warn("Rx status %d", urb->status);
                goto goon;
        }
 
        pkt_len = urb->actual_length - 4;
        rx_stat = le16_to_cpu(*(u16 *) (dev->rx_buff + pkt_len));
 
        if (!(skb = dev_alloc_skb(pkt_len + 2)))
                goto goon;
        skb->dev = netdev;
        skb_reserve(skb, 2);
        eth_copy_and_sum(skb, dev->rx_buff, pkt_len, 0);
        skb_put(skb, pkt_len);
        skb->protocol = eth_type_trans(skb, netdev);
        netif_rx(skb);
        dev->stats.rx_packets++;
        dev->stats.rx_bytes += pkt_len;
goon:
        FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
                      dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev);
        if ((res = usb_submit_urb(dev->rx_urb)))
                warn("%s: Rx urb submission failed %d", netdev->name, res);
}
 
static void write_bulk_callback(struct urb *urb)
{
        rtl8150_t *dev;
 
        dev = urb->context;
        if (!dev)
                return;
        if (!netif_device_present(dev->netdev))
                return;
        if (urb->status)
                info("%s: Tx status %d", dev->netdev->name, urb->status);
        dev->netdev->trans_start = jiffies;
        netif_wake_queue(dev->netdev);
}
 
void intr_callback(struct urb *urb)
{
        rtl8150_t *dev;
 
        dev = urb->context;
        if (!dev)
                return;
        switch (urb->status) {
        case 0:
                break;
        case -ENOENT:
                return;
        default:
                info("%s: intr status %d", dev->netdev->name, urb->status);
        }
}
 
/*
**
**      network related part of the code
**
*/
 
static int enable_net_traffic(rtl8150_t * dev)
{
        u8 cr, tcr, rcr, msr;
 
        if (rtl8150_reset(dev)) {
                warn("%s - device reset failed", __FUNCTION__);
        }
        rcr = 0x9e;     /* bit7=1 attach Rx info at the end */
        dev->rx_creg = cpu_to_le16(rcr);
        tcr = 0xd8;
        cr = 0x0c;
        set_registers(dev, RCR, 1, &rcr);
        set_registers(dev, TCR, 1, &tcr);
        set_registers(dev, CR, 1, &cr);
        get_registers(dev, MSR, 1, &msr);
 
        return 0;
}
 
static void disable_net_traffic(rtl8150_t * dev)
{
        u8 cr;
 
        get_registers(dev, CR, 1, &cr);
        cr &= 0xf3;
        set_registers(dev, CR, 1, &cr);
}
 
static struct net_device_stats *rtl8150_netdev_stats(struct net_device *dev)
{
        return &((rtl8150_t *) dev->priv)->stats;
}
 
static void rtl8150_tx_timeout(struct net_device *netdev)
{
        rtl8150_t *dev;
 
        dev = netdev->priv;
        if (!dev)
                return;
        warn("%s: Tx timeout.", netdev->name);
        dev->tx_urb->transfer_flags |= USB_ASYNC_UNLINK;
        usb_unlink_urb(dev->tx_urb);
        dev->stats.tx_errors++;
}
 
static void rtl8150_set_multicast(struct net_device *netdev)
{
        rtl8150_t *dev;
 
        dev = netdev->priv;
        netif_stop_queue(netdev);
        if (netdev->flags & IFF_PROMISC) {
                dev->rx_creg |= cpu_to_le16(0x0001);
                info("%s: promiscuous mode", netdev->name);
        } else if ((netdev->mc_count > multicast_filter_limit) ||
                   (netdev->flags & IFF_ALLMULTI)) {
                dev->rx_creg &= cpu_to_le16(0xfffe);
                dev->rx_creg |= cpu_to_le16(0x0002);
                info("%s: allmulti set", netdev->name);
        } else {
                /* ~RX_MULTICAST, ~RX_PROMISCUOUS */
                dev->rx_creg &= cpu_to_le16(0x00fc);
        }
        async_set_registers(dev, RCR, 2);
        netif_wake_queue(netdev);
}
 
static int rtl8150_start_xmit(struct sk_buff *skb, struct net_device *netdev)
{
        rtl8150_t *dev;
        int count, res;
 
        netif_stop_queue(netdev);
        dev = netdev->priv;
        count = (skb->len < 60) ? 60 : skb->len;
        count = (count & 0x3f) ? count : count + 1;
        memcpy(dev->tx_buff, skb->data, skb->len);
        FILL_BULK_URB(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev, 2),
                      dev->tx_buff, count, write_bulk_callback, dev);
        dev->tx_urb->transfer_buffer_length = count;
 
        if ((res = usb_submit_urb(dev->tx_urb))) {
                warn("failed tx_urb %d\n", res);
                dev->stats.tx_errors++;
                netif_start_queue(netdev);
        } else {
                dev->stats.tx_packets++;
                dev->stats.tx_bytes += skb->len;
                netdev->trans_start = jiffies;
        }
        dev_kfree_skb(skb);
 
        return 0;
}
 
static int rtl8150_open(struct net_device *netdev)
{
        rtl8150_t *dev;
        int res;
 
        dev = netdev->priv;
        if (dev == NULL) {
                return -ENODEV;
        }
 
        down(&dev->sem);
 
        set_registers(dev, IDR, 6, netdev->dev_addr);
 
        FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
                      dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev);
        if ((res = usb_submit_urb(dev->rx_urb)))
                warn("%s: rx_urb submit failed: %d", __FUNCTION__, res);
        FILL_INT_URB(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3),
                     dev->intr_buff, sizeof(dev->intr_buff), intr_callback,
                     dev, dev->intr_interval);
        if ((res = usb_submit_urb(dev->intr_urb)))
                warn("%s: intr_urb submit failed: %d", __FUNCTION__, res);
        netif_start_queue(netdev);
        enable_net_traffic(dev);
        up(&dev->sem);
 
        return res;
}
 
static int rtl8150_close(struct net_device *netdev)
{
        rtl8150_t *dev;
        int res = 0;
 
        dev = netdev->priv;
        if (!dev)
                return -ENODEV;
 
        down(&dev->sem);
        if (!test_bit(RTL8150_UNPLUG, &dev->flags))
                disable_net_traffic(dev);
        unlink_all_urbs(dev);
        netif_stop_queue(netdev);
        up(&dev->sem);
 
        return res;
}
 
static int rtl8150_ethtool_ioctl(struct net_device *netdev, void *uaddr)
{
        rtl8150_t *dev;
        int cmd;
        char tmp[128];
 
        dev = netdev->priv;
        if (get_user(cmd, (int *) uaddr))
                return -EFAULT;
 
        switch (cmd) {
        case ETHTOOL_GDRVINFO:{
                        struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
 
                        strncpy(info.driver, driver_name, ETHTOOL_BUSINFO_LEN);
                        strncpy(info.version, DRIVER_VERSION,
                                ETHTOOL_BUSINFO_LEN);
                        sprintf(tmp, "usb%d:%d", dev->udev->bus->busnum,
                                dev->udev->devnum);
                        strncpy(info.bus_info, tmp, ETHTOOL_BUSINFO_LEN);
                        if (copy_to_user(uaddr, &info, sizeof(info)))
                                return -EFAULT;
                        return 0;
                }
        case ETHTOOL_GSET:{
                        struct ethtool_cmd ecmd;
                        short lpa, bmcr;
 
                        if (copy_from_user(&ecmd, uaddr, sizeof(ecmd)))
                                return -EFAULT;
                        ecmd.supported = (SUPPORTED_10baseT_Half |
                                          SUPPORTED_10baseT_Full |
                                          SUPPORTED_100baseT_Half |
                                          SUPPORTED_100baseT_Full |
                                          SUPPORTED_Autoneg |
                                          SUPPORTED_TP | SUPPORTED_MII);
                        ecmd.port = PORT_TP;
                        ecmd.transceiver = XCVR_INTERNAL;
                        ecmd.phy_address = dev->phy;
                        get_registers(dev, BMCR, 2, &bmcr);
                        get_registers(dev, ANLP, 2, &lpa);
                        if (bmcr & BMCR_ANENABLE) {
                                ecmd.autoneg = AUTONEG_ENABLE;
                                ecmd.speed =
                                    (lpa & (LPA_100HALF | LPA_100FULL)) ?
                                    SPEED_100 : SPEED_10;
                                if (ecmd.speed == SPEED_100)
                                        ecmd.duplex = (lpa & LPA_100FULL) ?
                                            DUPLEX_FULL : DUPLEX_HALF;
                                else
                                        ecmd.duplex = (lpa & LPA_10FULL) ?
                                            DUPLEX_FULL : DUPLEX_HALF;
                        } else {
                                ecmd.autoneg = AUTONEG_DISABLE;
                                ecmd.speed = (bmcr & BMCR_SPEED100) ?
                                    SPEED_100 : SPEED_10;
                                ecmd.duplex = (bmcr & BMCR_FULLDPLX) ?
                                    DUPLEX_FULL : DUPLEX_HALF;
                        }
                        if (copy_to_user(uaddr, &ecmd, sizeof(ecmd)))
                                return -EFAULT;
                        return 0;
                }
        case ETHTOOL_SSET:
                return -ENOTSUPP;
        case ETHTOOL_GLINK:{
                        struct ethtool_value edata = { ETHTOOL_GLINK };
 
                        edata.data = netif_carrier_ok(netdev);
                        if (copy_to_user(uaddr, &edata, sizeof(edata)))
                                return -EFAULT;
                        return 0;
                }
        default:
                return -EOPNOTSUPP;
        }
}
 
static int rtl8150_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
{
        rtl8150_t *dev;
        u16 *data;
        int res;
 
        dev = netdev->priv;
        data = (u16 *) & rq->ifr_data;
        res = 0;
 
        down(&dev->sem);
        switch (cmd) {
        case SIOCETHTOOL:
                res = rtl8150_ethtool_ioctl(netdev, rq->ifr_data);
                break;
        case SIOCDEVPRIVATE:
                data[0] = dev->phy;
        case SIOCDEVPRIVATE + 1:
                read_mii_word(dev, dev->phy, (data[1] & 0x1f), &data[3]);
                break;
        case SIOCDEVPRIVATE + 2:
                if (!capable(CAP_NET_ADMIN)) {
                        up(&dev->sem);
                        return -EPERM;
                }
                write_mii_word(dev, dev->phy, (data[1] & 0x1f), data[2]);
                break;
        default:
                res = -EOPNOTSUPP;
        }
        up(&dev->sem);
 
        return res;
}
 
static void *rtl8150_probe(struct usb_device *udev, unsigned int ifnum,
                           const struct usb_device_id *id)
{
        rtl8150_t *dev;
        struct net_device *netdev;
 
        udev->config[0].bConfigurationValue = 1;
        if (usb_set_configuration(udev, udev->config[0].bConfigurationValue)) {
                err("usb_set_configuration() failed");
                return NULL;
        }
        dev = kmalloc(sizeof(rtl8150_t), GFP_KERNEL);
        if (!dev) {
                err("Out of memory");
                goto exit;
        } else
                memset(dev, 0, sizeof(rtl8150_t));
 
        netdev = init_etherdev(NULL, 0);
        if (!netdev) {
                kfree(dev);
                err("Oh boy, out of memory again?!?");
                dev = NULL;
                goto exit;
        }
 
        init_MUTEX(&dev->sem);
        dev->udev = udev;
        dev->netdev = netdev;
        SET_MODULE_OWNER(netdev);
        netdev->priv = dev;
        netdev->open = rtl8150_open;
        netdev->stop = rtl8150_close;
        netdev->do_ioctl = rtl8150_ioctl;
        netdev->watchdog_timeo = RTL8150_TX_TIMEOUT;
        netdev->tx_timeout = rtl8150_tx_timeout;
        netdev->hard_start_xmit = rtl8150_start_xmit;
        netdev->set_multicast_list = rtl8150_set_multicast;
        netdev->set_mac_address = rtl8150_set_mac_address;
        netdev->get_stats = rtl8150_netdev_stats;
        netdev->mtu = RTL8150_MTU;
        dev->intr_interval = 100;       /* 100ms */
 
        if (rtl8150_reset(dev) || !alloc_all_urbs(dev)) {
                err("couldn't reset the device");
                free_all_urbs(dev);
                unregister_netdev(dev->netdev);
                kfree(netdev);
                kfree(dev);
                dev = NULL;
                goto exit;
        }
 
        set_ethernet_addr(dev);
        /* let's not be very nasty :-) */
        info("%s: rtl8150 is detected", netdev->name);
exit:
        return dev;
}
 
static void rtl8150_disconnect(struct usb_device *udev, void *ptr)
{
        rtl8150_t *dev;
 
        dev = ptr;
        set_bit(RTL8150_UNPLUG, &dev->flags);
        unregister_netdev(dev->netdev);
        unlink_all_urbs(dev);
        free_all_urbs(dev);
        kfree(dev->netdev);
        kfree(dev);
        dev->netdev = NULL;
        dev = NULL;
}
 
static int __init usb_rtl8150_init(void)
{
        info(DRIVER_DESC " " DRIVER_VERSION);
        return usb_register(&rtl8150_driver);
}
 
static void __exit usb_rtl8150_exit(void)
{
        usb_deregister(&rtl8150_driver);
}
 
module_init(usb_rtl8150_init);
module_exit(usb_rtl8150_exit);
 
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [usb/] [rtl8150.c] - Blame information for rev 1779

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
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");`