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

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [net/] [usb/] [dm9601.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * Davicom DM9601 USB 1.1 10/100Mbps ethernet devices
 *
 * Peter Korsgaard <jacmet@sunsite.dk>
 *
 * This file is licensed under the terms of the GNU General Public License
 * version 2.  This program is licensed "as is" without any warranty of any
 * kind, whether express or implied.
 */
 
//#define DEBUG
 
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/stddef.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/mii.h>
#include <linux/usb.h>
#include <linux/crc32.h>
 
#include "usbnet.h"
 
/* datasheet:
 http://www.davicom.com.tw/big5/download/Data%20Sheet/DM9601-DS-P01-930914.pdf
*/
 
/* control requests */
#define DM_READ_REGS    0x00
#define DM_WRITE_REGS   0x01
#define DM_READ_MEMS    0x02
#define DM_WRITE_REG    0x03
#define DM_WRITE_MEMS   0x05
#define DM_WRITE_MEM    0x07
 
/* registers */
#define DM_NET_CTRL     0x00
#define DM_RX_CTRL      0x05
#define DM_SHARED_CTRL  0x0b
#define DM_SHARED_ADDR  0x0c
#define DM_SHARED_DATA  0x0d    /* low + high */
#define DM_PHY_ADDR     0x10    /* 6 bytes */
#define DM_MCAST_ADDR   0x16    /* 8 bytes */
#define DM_GPR_CTRL     0x1e
#define DM_GPR_DATA     0x1f
 
#define DM_MAX_MCAST    64
#define DM_MCAST_SIZE   8
#define DM_EEPROM_LEN   256
#define DM_TX_OVERHEAD  2       /* 2 byte header */
#define DM_RX_OVERHEAD  7       /* 3 byte header + 4 byte crc tail */
#define DM_TIMEOUT      1000
 
 
static int dm_read(struct usbnet *dev, u8 reg, u16 length, void *data)
{
        devdbg(dev, "dm_read() reg=0x%02x length=%d", reg, length);
        return usb_control_msg(dev->udev,
                               usb_rcvctrlpipe(dev->udev, 0),
                               DM_READ_REGS,
                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                               0, reg, data, length, USB_CTRL_SET_TIMEOUT);
}
 
static int dm_read_reg(struct usbnet *dev, u8 reg, u8 *value)
{
        return dm_read(dev, reg, 1, value);
}
 
static int dm_write(struct usbnet *dev, u8 reg, u16 length, void *data)
{
        devdbg(dev, "dm_write() reg=0x%02x, length=%d", reg, length);
        return usb_control_msg(dev->udev,
                               usb_sndctrlpipe(dev->udev, 0),
                               DM_WRITE_REGS,
                               USB_DIR_OUT | USB_TYPE_VENDOR |USB_RECIP_DEVICE,
                               0, reg, data, length, USB_CTRL_SET_TIMEOUT);
}
 
static int dm_write_reg(struct usbnet *dev, u8 reg, u8 value)
{
        devdbg(dev, "dm_write_reg() reg=0x%02x, value=0x%02x", reg, value);
        return usb_control_msg(dev->udev,
                               usb_sndctrlpipe(dev->udev, 0),
                               DM_WRITE_REG,
                               USB_DIR_OUT | USB_TYPE_VENDOR |USB_RECIP_DEVICE,
                               value, reg, NULL, 0, USB_CTRL_SET_TIMEOUT);
}
 
static void dm_write_async_callback(struct urb *urb)
{
        struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
 
        if (urb->status < 0)
                printk(KERN_DEBUG "dm_write_async_callback() failed with %d\n",
                       urb->status);
 
        kfree(req);
        usb_free_urb(urb);
}
 
static void dm_write_async(struct usbnet *dev, u8 reg, u16 length, void *data)
{
        struct usb_ctrlrequest *req;
        struct urb *urb;
        int status;
 
        devdbg(dev, "dm_write_async() reg=0x%02x length=%d", reg, length);
 
        urb = usb_alloc_urb(0, GFP_ATOMIC);
        if (!urb) {
                deverr(dev, "Error allocating URB in dm_write_async!");
                return;
        }
 
        req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
        if (!req) {
                deverr(dev, "Failed to allocate memory for control request");
                usb_free_urb(urb);
                return;
        }
 
        req->bRequestType = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
        req->bRequest = DM_WRITE_REGS;
        req->wValue = 0;
        req->wIndex = cpu_to_le16(reg);
        req->wLength = cpu_to_le16(length);
 
        usb_fill_control_urb(urb, dev->udev,
                             usb_sndctrlpipe(dev->udev, 0),
                             (void *)req, data, length,
                             dm_write_async_callback, req);
 
        status = usb_submit_urb(urb, GFP_ATOMIC);
        if (status < 0) {
                deverr(dev, "Error submitting the control message: status=%d",
                       status);
                kfree(req);
                usb_free_urb(urb);
        }
}
 
static void dm_write_reg_async(struct usbnet *dev, u8 reg, u8 value)
{
        struct usb_ctrlrequest *req;
        struct urb *urb;
        int status;
 
        devdbg(dev, "dm_write_reg_async() reg=0x%02x value=0x%02x",
               reg, value);
 
        urb = usb_alloc_urb(0, GFP_ATOMIC);
        if (!urb) {
                deverr(dev, "Error allocating URB in dm_write_async!");
                return;
        }
 
        req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
        if (!req) {
                deverr(dev, "Failed to allocate memory for control request");
                usb_free_urb(urb);
                return;
        }
 
        req->bRequestType = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
        req->bRequest = DM_WRITE_REG;
        req->wValue = cpu_to_le16(value);
        req->wIndex = cpu_to_le16(reg);
        req->wLength = 0;
 
        usb_fill_control_urb(urb, dev->udev,
                             usb_sndctrlpipe(dev->udev, 0),
                             (void *)req, NULL, 0, dm_write_async_callback, req);
 
        status = usb_submit_urb(urb, GFP_ATOMIC);
        if (status < 0) {
                deverr(dev, "Error submitting the control message: status=%d",
                       status);
                kfree(req);
                usb_free_urb(urb);
        }
}
 
static int dm_read_shared_word(struct usbnet *dev, int phy, u8 reg, u16 *value)
{
        int ret, i;
 
        mutex_lock(&dev->phy_mutex);
 
        dm_write_reg(dev, DM_SHARED_ADDR, phy ? (reg | 0x40) : reg);
        dm_write_reg(dev, DM_SHARED_CTRL, phy ? 0xc : 0x4);
 
        for (i = 0; i < DM_TIMEOUT; i++) {
                u8 tmp;
 
                udelay(1);
                ret = dm_read_reg(dev, DM_SHARED_CTRL, &tmp);
                if (ret < 0)
                        goto out;
 
                /* ready */
                if ((tmp & 1) == 0)
                        break;
        }
 
        if (i == DM_TIMEOUT) {
                deverr(dev, "%s read timed out!", phy ? "phy" : "eeprom");
                ret = -EIO;
                goto out;
        }
 
        dm_write_reg(dev, DM_SHARED_CTRL, 0x0);
        ret = dm_read(dev, DM_SHARED_DATA, 2, value);
 
        devdbg(dev, "read shared %d 0x%02x returned 0x%04x, %d",
               phy, reg, *value, ret);
 
 out:
        mutex_unlock(&dev->phy_mutex);
        return ret;
}
 
static int dm_write_shared_word(struct usbnet *dev, int phy, u8 reg, u16 value)
{
        int ret, i;
 
        mutex_lock(&dev->phy_mutex);
 
        ret = dm_write(dev, DM_SHARED_DATA, 2, &value);
        if (ret < 0)
                goto out;
 
        dm_write_reg(dev, DM_SHARED_ADDR, phy ? (reg | 0x40) : reg);
        dm_write_reg(dev, DM_SHARED_CTRL, phy ? 0x1c : 0x14);
 
        for (i = 0; i < DM_TIMEOUT; i++) {
                u8 tmp;
 
                udelay(1);
                ret = dm_read_reg(dev, DM_SHARED_CTRL, &tmp);
                if (ret < 0)
                        goto out;
 
                /* ready */
                if ((tmp & 1) == 0)
                        break;
        }
 
        if (i == DM_TIMEOUT) {
                deverr(dev, "%s write timed out!", phy ? "phy" : "eeprom");
                ret = -EIO;
                goto out;
        }
 
        dm_write_reg(dev, DM_SHARED_CTRL, 0x0);
 
out:
        mutex_unlock(&dev->phy_mutex);
        return ret;
}
 
static int dm_read_eeprom_word(struct usbnet *dev, u8 offset, void *value)
{
        return dm_read_shared_word(dev, 0, offset, value);
}
 
 
 
static int dm9601_get_eeprom_len(struct net_device *dev)
{
        return DM_EEPROM_LEN;
}
 
static int dm9601_get_eeprom(struct net_device *net,
                             struct ethtool_eeprom *eeprom, u8 * data)
{
        struct usbnet *dev = netdev_priv(net);
        u16 *ebuf = (u16 *) data;
        int i;
 
        /* access is 16bit */
        if ((eeprom->offset % 2) || (eeprom->len % 2))
                return -EINVAL;
 
        for (i = 0; i < eeprom->len / 2; i++) {
                if (dm_read_eeprom_word(dev, eeprom->offset / 2 + i,
                                        &ebuf[i]) < 0)
                        return -EINVAL;
        }
        return 0;
}
 
static int dm9601_mdio_read(struct net_device *netdev, int phy_id, int loc)
{
        struct usbnet *dev = netdev_priv(netdev);
 
        u16 res;
 
        if (phy_id) {
                devdbg(dev, "Only internal phy supported");
                return 0;
        }
 
        dm_read_shared_word(dev, 1, loc, &res);
 
        devdbg(dev,
               "dm9601_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x",
               phy_id, loc, le16_to_cpu(res));
 
        return le16_to_cpu(res);
}
 
static void dm9601_mdio_write(struct net_device *netdev, int phy_id, int loc,
                              int val)
{
        struct usbnet *dev = netdev_priv(netdev);
        u16 res = cpu_to_le16(val);
 
        if (phy_id) {
                devdbg(dev, "Only internal phy supported");
                return;
        }
 
        devdbg(dev,"dm9601_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x",
               phy_id, loc, val);
 
        dm_write_shared_word(dev, 1, loc, res);
}
 
static void dm9601_get_drvinfo(struct net_device *net,
                               struct ethtool_drvinfo *info)
{
        /* Inherit standard device info */
        usbnet_get_drvinfo(net, info);
        info->eedump_len = DM_EEPROM_LEN;
}
 
static u32 dm9601_get_link(struct net_device *net)
{
        struct usbnet *dev = netdev_priv(net);
 
        return mii_link_ok(&dev->mii);
}
 
static int dm9601_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
{
        struct usbnet *dev = netdev_priv(net);
 
        return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
}
 
static struct ethtool_ops dm9601_ethtool_ops = {
        .get_drvinfo    = dm9601_get_drvinfo,
        .get_link       = dm9601_get_link,
        .get_msglevel   = usbnet_get_msglevel,
        .set_msglevel   = usbnet_set_msglevel,
        .get_eeprom_len = dm9601_get_eeprom_len,
        .get_eeprom     = dm9601_get_eeprom,
        .get_settings   = usbnet_get_settings,
        .set_settings   = usbnet_set_settings,
        .nway_reset     = usbnet_nway_reset,
};
 
static void dm9601_set_multicast(struct net_device *net)
{
        struct usbnet *dev = netdev_priv(net);
        /* We use the 20 byte dev->data for our 8 byte filter buffer
         * to avoid allocating memory that is tricky to free later */
        u8 *hashes = (u8 *) & dev->data;
        u8 rx_ctl = 0x01;
 
        memset(hashes, 0x00, DM_MCAST_SIZE);
        hashes[DM_MCAST_SIZE - 1] |= 0x80;      /* broadcast address */
 
        if (net->flags & IFF_PROMISC) {
                rx_ctl |= 0x02;
        } else if (net->flags & IFF_ALLMULTI || net->mc_count > DM_MAX_MCAST) {
                rx_ctl |= 0x04;
        } else if (net->mc_count) {
                struct dev_mc_list *mc_list = net->mc_list;
                int i;
 
                for (i = 0; i < net->mc_count; i++) {
                        u32 crc = ether_crc(ETH_ALEN, mc_list->dmi_addr) >> 26;
                        hashes[crc >> 3] |= 1 << (crc & 0x7);
                }
        }
 
        dm_write_async(dev, DM_MCAST_ADDR, DM_MCAST_SIZE, hashes);
        dm_write_reg_async(dev, DM_RX_CTRL, rx_ctl);
}
 
static int dm9601_bind(struct usbnet *dev, struct usb_interface *intf)
{
        int ret;
 
        ret = usbnet_get_endpoints(dev, intf);
        if (ret)
                goto out;
 
        dev->net->do_ioctl = dm9601_ioctl;
        dev->net->set_multicast_list = dm9601_set_multicast;
        dev->net->ethtool_ops = &dm9601_ethtool_ops;
        dev->net->hard_header_len += DM_TX_OVERHEAD;
        dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
        dev->rx_urb_size = dev->net->mtu + ETH_HLEN + DM_RX_OVERHEAD;
 
        dev->mii.dev = dev->net;
        dev->mii.mdio_read = dm9601_mdio_read;
        dev->mii.mdio_write = dm9601_mdio_write;
        dev->mii.phy_id_mask = 0x1f;
        dev->mii.reg_num_mask = 0x1f;
 
        /* reset */
        dm_write_reg(dev, DM_NET_CTRL, 1);
        udelay(20);
 
        /* read MAC */
        if (dm_read(dev, DM_PHY_ADDR, ETH_ALEN, dev->net->dev_addr) < 0) {
                printk(KERN_ERR "Error reading MAC address\n");
                ret = -ENODEV;
                goto out;
        }
 
        /* power up phy */
        dm_write_reg(dev, DM_GPR_CTRL, 1);
        dm_write_reg(dev, DM_GPR_DATA, 0);
 
        /* receive broadcast packets */
        dm9601_set_multicast(dev->net);
 
        dm9601_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
        dm9601_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
                          ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
        mii_nway_restart(&dev->mii);
 
out:
        return ret;
}
 
static int dm9601_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
{
        u8 status;
        int len;
 
        /* format:
           b0: rx status
           b1: packet length (incl crc) low
           b2: packet length (incl crc) high
           b3..n-4: packet data
           bn-3..bn: ethernet crc
         */
 
        if (unlikely(skb->len < DM_RX_OVERHEAD)) {
                dev_err(&dev->udev->dev, "unexpected tiny rx frame\n");
                return 0;
        }
 
        status = skb->data[0];
        len = (skb->data[1] | (skb->data[2] << 8)) - 4;
 
        if (unlikely(status & 0xbf)) {
                if (status & 0x01) dev->stats.rx_fifo_errors++;
                if (status & 0x02) dev->stats.rx_crc_errors++;
                if (status & 0x04) dev->stats.rx_frame_errors++;
                if (status & 0x20) dev->stats.rx_missed_errors++;
                if (status & 0x90) dev->stats.rx_length_errors++;
                return 0;
        }
 
        skb_pull(skb, 3);
        skb_trim(skb, len);
 
        return 1;
}
 
static struct sk_buff *dm9601_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
                                       gfp_t flags)
{
        int len;
 
        /* format:
           b0: packet length low
           b1: packet length high
           b3..n: packet data
        */
 
        len = skb->len;
 
        if (skb_headroom(skb) < DM_TX_OVERHEAD) {
                struct sk_buff *skb2;
 
                skb2 = skb_copy_expand(skb, DM_TX_OVERHEAD, 0, flags);
                dev_kfree_skb_any(skb);
                skb = skb2;
                if (!skb)
                        return NULL;
        }
 
        __skb_push(skb, DM_TX_OVERHEAD);
 
        /* usbnet adds padding if length is a multiple of packet size
           if so, adjust length value in header */
        if ((skb->len % dev->maxpacket) == 0)
                len++;
 
        skb->data[0] = len;
        skb->data[1] = len >> 8;
 
        return skb;
}
 
static void dm9601_status(struct usbnet *dev, struct urb *urb)
{
        int link;
        u8 *buf;
 
        /* format:
           b0: net status
           b1: tx status 1
           b2: tx status 2
           b3: rx status
           b4: rx overflow
           b5: rx count
           b6: tx count
           b7: gpr
        */
 
        if (urb->actual_length < 8)
                return;
 
        buf = urb->transfer_buffer;
 
        link = !!(buf[0] & 0x40);
        if (netif_carrier_ok(dev->net) != link) {
                if (link) {
                        netif_carrier_on(dev->net);
                        usbnet_defer_kevent (dev, EVENT_LINK_RESET);
                }
                else
                        netif_carrier_off(dev->net);
                devdbg(dev, "Link Status is: %d", link);
        }
}
 
static int dm9601_link_reset(struct usbnet *dev)
{
        struct ethtool_cmd ecmd;
 
        mii_check_media(&dev->mii, 1, 1);
        mii_ethtool_gset(&dev->mii, &ecmd);
 
        devdbg(dev, "link_reset() speed: %d duplex: %d",
               ecmd.speed, ecmd.duplex);
 
        return 0;
}
 
static const struct driver_info dm9601_info = {
        .description    = "Davicom DM9601 USB Ethernet",
        .flags          = FLAG_ETHER,
        .bind           = dm9601_bind,
        .rx_fixup       = dm9601_rx_fixup,
        .tx_fixup       = dm9601_tx_fixup,
        .status         = dm9601_status,
        .link_reset     = dm9601_link_reset,
        .reset          = dm9601_link_reset,
};
 
static const struct usb_device_id products[] = {
        {
         USB_DEVICE(0x07aa, 0x9601),    /* Corega FEther USB-TXC */
         .driver_info = (unsigned long)&dm9601_info,
         },
        {
         USB_DEVICE(0x0a46, 0x9601),    /* Davicom USB-100 */
         .driver_info = (unsigned long)&dm9601_info,
         },
        {
         USB_DEVICE(0x0a46, 0x6688),    /* ZT6688 USB NIC */
         .driver_info = (unsigned long)&dm9601_info,
         },
        {
         USB_DEVICE(0x0a46, 0x0268),    /* ShanTou ST268 USB NIC */
         .driver_info = (unsigned long)&dm9601_info,
         },
        {
         USB_DEVICE(0x0a46, 0x8515),    /* ADMtek ADM8515 USB NIC */
         .driver_info = (unsigned long)&dm9601_info,
         },
        {},                     // END
};
 
MODULE_DEVICE_TABLE(usb, products);
 
static struct usb_driver dm9601_driver = {
        .name = "dm9601",
        .id_table = products,
        .probe = usbnet_probe,
        .disconnect = usbnet_disconnect,
        .suspend = usbnet_suspend,
        .resume = usbnet_resume,
};
 
static int __init dm9601_init(void)
{
        return usb_register(&dm9601_driver);
}
 
static void __exit dm9601_exit(void)
{
        usb_deregister(&dm9601_driver);
}
 
module_init(dm9601_init);
module_exit(dm9601_exit);
 
MODULE_AUTHOR("Peter Korsgaard <jacmet@sunsite.dk>");
MODULE_DESCRIPTION("Davicom DM9601 USB 1.1 ethernet devices");
MODULE_LICENSE("GPL");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [net/] [usb/] [dm9601.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* Davicom DM9601 USB 1.1 10/100Mbps ethernet devices`
3			`*`
4			`* Peter Korsgaard <jacmet@sunsite.dk>`
5			`*`
6			`* This file is licensed under the terms of the GNU General Public License`
7			`* version 2. This program is licensed "as is" without any warranty of any`
8			`* kind, whether express or implied.`
9			`*/`
10
11			`//#define DEBUG`
12
13			`#include <linux/module.h>`
14			`#include <linux/sched.h>`
15			`#include <linux/stddef.h>`
16			`#include <linux/init.h>`
17			`#include <linux/netdevice.h>`
18			`#include <linux/etherdevice.h>`
19			`#include <linux/ethtool.h>`
20			`#include <linux/mii.h>`
21			`#include <linux/usb.h>`
22			`#include <linux/crc32.h>`
23
24			`#include "usbnet.h"`
25
26			`/* datasheet:`
27			`http://www.davicom.com.tw/big5/download/Data%20Sheet/DM9601-DS-P01-930914.pdf`
28			`*/`
29
30			`/* control requests */`
31			`#define DM_READ_REGS 0x00`
32			`#define DM_WRITE_REGS 0x01`
33			`#define DM_READ_MEMS 0x02`
34			`#define DM_WRITE_REG 0x03`
35			`#define DM_WRITE_MEMS 0x05`
36			`#define DM_WRITE_MEM 0x07`
37
38			`/* registers */`
39			`#define DM_NET_CTRL 0x00`
40			`#define DM_RX_CTRL 0x05`
41			`#define DM_SHARED_CTRL 0x0b`
42			`#define DM_SHARED_ADDR 0x0c`
43			`#define DM_SHARED_DATA 0x0d /* low + high */`
44			`#define DM_PHY_ADDR 0x10 /* 6 bytes */`
45			`#define DM_MCAST_ADDR 0x16 /* 8 bytes */`
46			`#define DM_GPR_CTRL 0x1e`
47			`#define DM_GPR_DATA 0x1f`
48
49			`#define DM_MAX_MCAST 64`
50			`#define DM_MCAST_SIZE 8`
51			`#define DM_EEPROM_LEN 256`
52			`#define DM_TX_OVERHEAD 2 /* 2 byte header */`
53			`#define DM_RX_OVERHEAD 7 /* 3 byte header + 4 byte crc tail */`
54			`#define DM_TIMEOUT 1000`
55
56
57			`static int dm_read(struct usbnet dev, u8 reg, u16 length, void data)`
58			`{`
59			`devdbg(dev, "dm_read() reg=0x%02x length=%d", reg, length);`
60			`return usb_control_msg(dev->udev,`
61			`usb_rcvctrlpipe(dev->udev, 0),`
62			`DM_READ_REGS,`
63			`USB_DIR_IN \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,`
64			`0, reg, data, length, USB_CTRL_SET_TIMEOUT);`
65			`}`
66
67			`static int dm_read_reg(struct usbnet dev, u8 reg, u8 value)`
68			`{`
69			`return dm_read(dev, reg, 1, value);`
70			`}`
71
72			`static int dm_write(struct usbnet dev, u8 reg, u16 length, void data)`
73			`{`
74			`devdbg(dev, "dm_write() reg=0x%02x, length=%d", reg, length);`
75			`return usb_control_msg(dev->udev,`
76			`usb_sndctrlpipe(dev->udev, 0),`
77			`DM_WRITE_REGS,`
78			`USB_DIR_OUT \| USB_TYPE_VENDOR \|USB_RECIP_DEVICE,`
79			`0, reg, data, length, USB_CTRL_SET_TIMEOUT);`
80			`}`
81
82			`static int dm_write_reg(struct usbnet *dev, u8 reg, u8 value)`
83			`{`
84			`devdbg(dev, "dm_write_reg() reg=0x%02x, value=0x%02x", reg, value);`
85			`return usb_control_msg(dev->udev,`
86			`usb_sndctrlpipe(dev->udev, 0),`
87			`DM_WRITE_REG,`
88			`USB_DIR_OUT \| USB_TYPE_VENDOR \|USB_RECIP_DEVICE,`
89			`value, reg, NULL, 0, USB_CTRL_SET_TIMEOUT);`
90			`}`
91
92			`static void dm_write_async_callback(struct urb *urb)`
93			`{`
94			`struct usb_ctrlrequest req = (struct usb_ctrlrequest )urb->context;`
95
96			`if (urb->status < 0)`
97			`printk(KERN_DEBUG "dm_write_async_callback() failed with %d\n",`
98			`urb->status);`
99
100			`kfree(req);`
101			`usb_free_urb(urb);`
102			`}`
103
104			`static void dm_write_async(struct usbnet dev, u8 reg, u16 length, void data)`
105			`{`
106			`struct usb_ctrlrequest *req;`
107			`struct urb *urb;`
108			`int status;`
109
110			`devdbg(dev, "dm_write_async() reg=0x%02x length=%d", reg, length);`
111
112			`urb = usb_alloc_urb(0, GFP_ATOMIC);`
113			`if (!urb) {`
114			`deverr(dev, "Error allocating URB in dm_write_async!");`
115			`return;`
116			`}`
117
118			`req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);`
119			`if (!req) {`
120			`deverr(dev, "Failed to allocate memory for control request");`
121			`usb_free_urb(urb);`
122			`return;`
123			`}`
124
125			`req->bRequestType = USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE;`
126			`req->bRequest = DM_WRITE_REGS;`
127			`req->wValue = 0;`
128			`req->wIndex = cpu_to_le16(reg);`
129			`req->wLength = cpu_to_le16(length);`
130
131			`usb_fill_control_urb(urb, dev->udev,`
132			`usb_sndctrlpipe(dev->udev, 0),`
133			`(void *)req, data, length,`
134			`dm_write_async_callback, req);`
135
136			`status = usb_submit_urb(urb, GFP_ATOMIC);`
137			`if (status < 0) {`
138			`deverr(dev, "Error submitting the control message: status=%d",`
139			`status);`
140			`kfree(req);`
141			`usb_free_urb(urb);`
142			`}`
143			`}`
144
145			`static void dm_write_reg_async(struct usbnet *dev, u8 reg, u8 value)`
146			`{`
147			`struct usb_ctrlrequest *req;`
148			`struct urb *urb;`
149			`int status;`
150
151			`devdbg(dev, "dm_write_reg_async() reg=0x%02x value=0x%02x",`
152			`reg, value);`
153
154			`urb = usb_alloc_urb(0, GFP_ATOMIC);`
155			`if (!urb) {`
156			`deverr(dev, "Error allocating URB in dm_write_async!");`
157			`return;`
158			`}`
159
160			`req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);`
161			`if (!req) {`
162			`deverr(dev, "Failed to allocate memory for control request");`
163			`usb_free_urb(urb);`
164			`return;`
165			`}`
166
167			`req->bRequestType = USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE;`
168			`req->bRequest = DM_WRITE_REG;`
169			`req->wValue = cpu_to_le16(value);`
170			`req->wIndex = cpu_to_le16(reg);`
171			`req->wLength = 0;`
172
173			`usb_fill_control_urb(urb, dev->udev,`
174			`usb_sndctrlpipe(dev->udev, 0),`
175			`(void *)req, NULL, 0, dm_write_async_callback, req);`
176
177			`status = usb_submit_urb(urb, GFP_ATOMIC);`
178			`if (status < 0) {`
179			`deverr(dev, "Error submitting the control message: status=%d",`
180			`status);`
181			`kfree(req);`
182			`usb_free_urb(urb);`
183			`}`
184			`}`
185
186			`static int dm_read_shared_word(struct usbnet dev, int phy, u8 reg, u16 value)`
187			`{`
188			`int ret, i;`
189
190			`mutex_lock(&dev->phy_mutex);`
191
192			`dm_write_reg(dev, DM_SHARED_ADDR, phy ? (reg \| 0x40) : reg);`
193			`dm_write_reg(dev, DM_SHARED_CTRL, phy ? 0xc : 0x4);`
194
195			`for (i = 0; i < DM_TIMEOUT; i++) {`
196			`u8 tmp;`
197
198			`udelay(1);`
199			`ret = dm_read_reg(dev, DM_SHARED_CTRL, &tmp);`
200			`if (ret < 0)`
201			`goto out;`
202
203			`/* ready */`
204			`if ((tmp & 1) == 0)`
205			`break;`
206			`}`
207
208			`if (i == DM_TIMEOUT) {`
209			`deverr(dev, "%s read timed out!", phy ? "phy" : "eeprom");`
210			`ret = -EIO;`
211			`goto out;`
212			`}`
213
214			`dm_write_reg(dev, DM_SHARED_CTRL, 0x0);`
215			`ret = dm_read(dev, DM_SHARED_DATA, 2, value);`
216
217			`devdbg(dev, "read shared %d 0x%02x returned 0x%04x, %d",`
218			`phy, reg, *value, ret);`
219
220			`out:`
221			`mutex_unlock(&dev->phy_mutex);`
222			`return ret;`
223			`}`
224
225			`static int dm_write_shared_word(struct usbnet *dev, int phy, u8 reg, u16 value)`
226			`{`
227			`int ret, i;`
228
229			`mutex_lock(&dev->phy_mutex);`
230
231			`ret = dm_write(dev, DM_SHARED_DATA, 2, &value);`
232			`if (ret < 0)`
233			`goto out;`
234
235			`dm_write_reg(dev, DM_SHARED_ADDR, phy ? (reg \| 0x40) : reg);`
236			`dm_write_reg(dev, DM_SHARED_CTRL, phy ? 0x1c : 0x14);`
237
238			`for (i = 0; i < DM_TIMEOUT; i++) {`
239			`u8 tmp;`
240
241			`udelay(1);`
242			`ret = dm_read_reg(dev, DM_SHARED_CTRL, &tmp);`
243			`if (ret < 0)`
244			`goto out;`
245
246			`/* ready */`
247			`if ((tmp & 1) == 0)`
248			`break;`
249			`}`
250
251			`if (i == DM_TIMEOUT) {`
252			`deverr(dev, "%s write timed out!", phy ? "phy" : "eeprom");`
253			`ret = -EIO;`
254			`goto out;`
255			`}`
256
257			`dm_write_reg(dev, DM_SHARED_CTRL, 0x0);`
258
259			`out:`
260			`mutex_unlock(&dev->phy_mutex);`
261			`return ret;`
262			`}`
263
264			`static int dm_read_eeprom_word(struct usbnet dev, u8 offset, void value)`
265			`{`
266			`return dm_read_shared_word(dev, 0, offset, value);`
267			`}`
268
269
270
271			`static int dm9601_get_eeprom_len(struct net_device *dev)`
272			`{`
273			`return DM_EEPROM_LEN;`
274			`}`
275
276			`static int dm9601_get_eeprom(struct net_device *net,`
277			`struct ethtool_eeprom eeprom, u8 data)`
278			`{`
279			`struct usbnet *dev = netdev_priv(net);`
280			`u16 ebuf = (u16 ) data;`
281			`int i;`
282
283			`/* access is 16bit */`
284			`if ((eeprom->offset % 2) \|\| (eeprom->len % 2))`
285			`return -EINVAL;`
286
287			`for (i = 0; i < eeprom->len / 2; i++) {`
288			`if (dm_read_eeprom_word(dev, eeprom->offset / 2 + i,`
289			`&ebuf[i]) < 0)`
290			`return -EINVAL;`
291			`}`
292			`return 0;`
293			`}`
294
295			`static int dm9601_mdio_read(struct net_device *netdev, int phy_id, int loc)`
296			`{`
297			`struct usbnet *dev = netdev_priv(netdev);`
298
299			`u16 res;`
300
301			`if (phy_id) {`
302			`devdbg(dev, "Only internal phy supported");`
303			`return 0;`
304			`}`
305
306			`dm_read_shared_word(dev, 1, loc, &res);`
307
308			`devdbg(dev,`
309			`"dm9601_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x",`
310			`phy_id, loc, le16_to_cpu(res));`
311
312			`return le16_to_cpu(res);`
313			`}`
314
315			`static void dm9601_mdio_write(struct net_device *netdev, int phy_id, int loc,`
316			`int val)`
317			`{`
318			`struct usbnet *dev = netdev_priv(netdev);`
319			`u16 res = cpu_to_le16(val);`
320
321			`if (phy_id) {`
322			`devdbg(dev, "Only internal phy supported");`
323			`return;`
324			`}`
325
326			`devdbg(dev,"dm9601_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x",`
327			`phy_id, loc, val);`
328
329			`dm_write_shared_word(dev, 1, loc, res);`
330			`}`
331
332			`static void dm9601_get_drvinfo(struct net_device *net,`
333			`struct ethtool_drvinfo *info)`
334			`{`
335			`/* Inherit standard device info */`
336			`usbnet_get_drvinfo(net, info);`
337			`info->eedump_len = DM_EEPROM_LEN;`
338			`}`
339
340			`static u32 dm9601_get_link(struct net_device *net)`
341			`{`
342			`struct usbnet *dev = netdev_priv(net);`
343
344			`return mii_link_ok(&dev->mii);`
345			`}`
346
347			`static int dm9601_ioctl(struct net_device net, struct ifreq rq, int cmd)`
348			`{`
349			`struct usbnet *dev = netdev_priv(net);`
350
351			`return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);`
352			`}`
353
354			`static struct ethtool_ops dm9601_ethtool_ops = {`
355			`.get_drvinfo = dm9601_get_drvinfo,`
356			`.get_link = dm9601_get_link,`
357			`.get_msglevel = usbnet_get_msglevel,`
358			`.set_msglevel = usbnet_set_msglevel,`
359			`.get_eeprom_len = dm9601_get_eeprom_len,`
360			`.get_eeprom = dm9601_get_eeprom,`
361			`.get_settings = usbnet_get_settings,`
362			`.set_settings = usbnet_set_settings,`
363			`.nway_reset = usbnet_nway_reset,`
364			`};`
365
366			`static void dm9601_set_multicast(struct net_device *net)`
367			`{`
368			`struct usbnet *dev = netdev_priv(net);`
369			`/* We use the 20 byte dev->data for our 8 byte filter buffer`
370			`* to avoid allocating memory that is tricky to free later */`
371			`u8 hashes = (u8 ) & dev->data;`
372			`u8 rx_ctl = 0x01;`
373
374			`memset(hashes, 0x00, DM_MCAST_SIZE);`
375			`hashes[DM_MCAST_SIZE - 1] \|= 0x80; /* broadcast address */`
376
377			`if (net->flags & IFF_PROMISC) {`
378			`rx_ctl \|= 0x02;`
379			`} else if (net->flags & IFF_ALLMULTI \|\| net->mc_count > DM_MAX_MCAST) {`
380			`rx_ctl \|= 0x04;`
381			`} else if (net->mc_count) {`
382			`struct dev_mc_list *mc_list = net->mc_list;`
383			`int i;`
384
385			`for (i = 0; i < net->mc_count; i++) {`
386			`u32 crc = ether_crc(ETH_ALEN, mc_list->dmi_addr) >> 26;`
387			`hashes[crc >> 3] \|= 1 << (crc & 0x7);`
388			`}`
389			`}`
390
391			`dm_write_async(dev, DM_MCAST_ADDR, DM_MCAST_SIZE, hashes);`
392			`dm_write_reg_async(dev, DM_RX_CTRL, rx_ctl);`
393			`}`
394
395			`static int dm9601_bind(struct usbnet dev, struct usb_interface intf)`
396			`{`
397			`int ret;`
398
399			`ret = usbnet_get_endpoints(dev, intf);`
400			`if (ret)`
401			`goto out;`
402
403			`dev->net->do_ioctl = dm9601_ioctl;`
404			`dev->net->set_multicast_list = dm9601_set_multicast;`
405			`dev->net->ethtool_ops = &dm9601_ethtool_ops;`
406			`dev->net->hard_header_len += DM_TX_OVERHEAD;`
407			`dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;`
408			`dev->rx_urb_size = dev->net->mtu + ETH_HLEN + DM_RX_OVERHEAD;`
409
410			`dev->mii.dev = dev->net;`
411			`dev->mii.mdio_read = dm9601_mdio_read;`
412			`dev->mii.mdio_write = dm9601_mdio_write;`
413			`dev->mii.phy_id_mask = 0x1f;`
414			`dev->mii.reg_num_mask = 0x1f;`
415
416			`/* reset */`
417			`dm_write_reg(dev, DM_NET_CTRL, 1);`
418			`udelay(20);`
419
420			`/* read MAC */`
421			`if (dm_read(dev, DM_PHY_ADDR, ETH_ALEN, dev->net->dev_addr) < 0) {`
422			`printk(KERN_ERR "Error reading MAC address\n");`
423			`ret = -ENODEV;`
424			`goto out;`
425			`}`
426
427			`/* power up phy */`
428			`dm_write_reg(dev, DM_GPR_CTRL, 1);`
429			`dm_write_reg(dev, DM_GPR_DATA, 0);`
430
431			`/* receive broadcast packets */`
432			`dm9601_set_multicast(dev->net);`
433
434			`dm9601_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);`
435			`dm9601_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,`
436			`ADVERTISE_ALL \| ADVERTISE_CSMA \| ADVERTISE_PAUSE_CAP);`
437			`mii_nway_restart(&dev->mii);`
438
439			`out:`
440			`return ret;`
441			`}`
442
443			`static int dm9601_rx_fixup(struct usbnet dev, struct sk_buff skb)`
444			`{`
445			`u8 status;`
446			`int len;`
447
448			`/* format:`
449			`b0: rx status`
450			`b1: packet length (incl crc) low`
451			`b2: packet length (incl crc) high`
452			`b3..n-4: packet data`
453			`bn-3..bn: ethernet crc`
454			`*/`
455
456			`if (unlikely(skb->len < DM_RX_OVERHEAD)) {`
457			`dev_err(&dev->udev->dev, "unexpected tiny rx frame\n");`
458			`return 0;`
459			`}`
460
461			`status = skb->data[0];`
462			`len = (skb->data[1] \| (skb->data[2] << 8)) - 4;`
463
464			`if (unlikely(status & 0xbf)) {`
465			`if (status & 0x01) dev->stats.rx_fifo_errors++;`
466			`if (status & 0x02) dev->stats.rx_crc_errors++;`
467			`if (status & 0x04) dev->stats.rx_frame_errors++;`
468			`if (status & 0x20) dev->stats.rx_missed_errors++;`
469			`if (status & 0x90) dev->stats.rx_length_errors++;`
470			`return 0;`
471			`}`
472
473			`skb_pull(skb, 3);`
474			`skb_trim(skb, len);`
475
476			`return 1;`
477			`}`
478
479			`static struct sk_buff dm9601_tx_fixup(struct usbnet dev, struct sk_buff *skb,`
480			`gfp_t flags)`
481			`{`
482			`int len;`
483
484			`/* format:`
485			`b0: packet length low`
486			`b1: packet length high`
487			`b3..n: packet data`
488			`*/`
489
490			`len = skb->len;`
491
492			`if (skb_headroom(skb) < DM_TX_OVERHEAD) {`
493			`struct sk_buff *skb2;`
494
495			`skb2 = skb_copy_expand(skb, DM_TX_OVERHEAD, 0, flags);`
496			`dev_kfree_skb_any(skb);`
497			`skb = skb2;`
498			`if (!skb)`
499			`return NULL;`
500			`}`
501
502			`__skb_push(skb, DM_TX_OVERHEAD);`
503
504			`/* usbnet adds padding if length is a multiple of packet size`
505			`if so, adjust length value in header */`
506			`if ((skb->len % dev->maxpacket) == 0)`
507			`len++;`
508
509			`skb->data[0] = len;`
510			`skb->data[1] = len >> 8;`
511
512			`return skb;`
513			`}`
514
515			`static void dm9601_status(struct usbnet dev, struct urb urb)`
516			`{`
517			`int link;`
518			`u8 *buf;`
519
520			`/* format:`
521			`b0: net status`
522			`b1: tx status 1`
523			`b2: tx status 2`
524			`b3: rx status`
525			`b4: rx overflow`
526			`b5: rx count`
527			`b6: tx count`
528			`b7: gpr`
529			`*/`
530
531			`if (urb->actual_length < 8)`
532			`return;`
533
534			`buf = urb->transfer_buffer;`
535
536			`link = !!(buf[0] & 0x40);`
537			`if (netif_carrier_ok(dev->net) != link) {`
538			`if (link) {`
539			`netif_carrier_on(dev->net);`
540			`usbnet_defer_kevent (dev, EVENT_LINK_RESET);`
541			`}`
542			`else`
543			`netif_carrier_off(dev->net);`
544			`devdbg(dev, "Link Status is: %d", link);`
545			`}`
546			`}`
547
548			`static int dm9601_link_reset(struct usbnet *dev)`
549			`{`
550			`struct ethtool_cmd ecmd;`
551
552			`mii_check_media(&dev->mii, 1, 1);`
553			`mii_ethtool_gset(&dev->mii, &ecmd);`
554
555			`devdbg(dev, "link_reset() speed: %d duplex: %d",`
556			`ecmd.speed, ecmd.duplex);`
557
558			`return 0;`
559			`}`
560
561			`static const struct driver_info dm9601_info = {`
562			`.description = "Davicom DM9601 USB Ethernet",`
563			`.flags = FLAG_ETHER,`
564			`.bind = dm9601_bind,`
565			`.rx_fixup = dm9601_rx_fixup,`
566			`.tx_fixup = dm9601_tx_fixup,`
567			`.status = dm9601_status,`
568			`.link_reset = dm9601_link_reset,`
569			`.reset = dm9601_link_reset,`
570			`};`
571
572			`static const struct usb_device_id products[] = {`
573			`{`
574			`USB_DEVICE(0x07aa, 0x9601), /* Corega FEther USB-TXC */`
575			`.driver_info = (unsigned long)&dm9601_info,`
576			`},`
577			`{`
578			`USB_DEVICE(0x0a46, 0x9601), /* Davicom USB-100 */`
579			`.driver_info = (unsigned long)&dm9601_info,`
580			`},`
581			`{`
582			`USB_DEVICE(0x0a46, 0x6688), /* ZT6688 USB NIC */`
583			`.driver_info = (unsigned long)&dm9601_info,`
584			`},`
585			`{`
586			`USB_DEVICE(0x0a46, 0x0268), /* ShanTou ST268 USB NIC */`
587			`.driver_info = (unsigned long)&dm9601_info,`
588			`},`
589			`{`
590			`USB_DEVICE(0x0a46, 0x8515), /* ADMtek ADM8515 USB NIC */`
591			`.driver_info = (unsigned long)&dm9601_info,`
592			`},`
593			`{}, // END`
594			`};`
595
596			`MODULE_DEVICE_TABLE(usb, products);`
597
598			`static struct usb_driver dm9601_driver = {`
599			`.name = "dm9601",`
600			`.id_table = products,`
601			`.probe = usbnet_probe,`
602			`.disconnect = usbnet_disconnect,`
603			`.suspend = usbnet_suspend,`
604			`.resume = usbnet_resume,`
605			`};`
606
607			`static int __init dm9601_init(void)`
608			`{`
609			`return usb_register(&dm9601_driver);`
610			`}`
611
612			`static void __exit dm9601_exit(void)`
613			`{`
614			`usb_deregister(&dm9601_driver);`
615			`}`
616
617			`module_init(dm9601_init);`
618			`module_exit(dm9601_exit);`
619
620			`MODULE_AUTHOR("Peter Korsgaard <jacmet@sunsite.dk>");`
621			`MODULE_DESCRIPTION("Davicom DM9601 USB 1.1 ethernet devices");`
622			`MODULE_LICENSE("GPL");`