net/usb/dm9601.c

0001 /*
0002  * Davicom DM96xx USB 10/100Mbps ethernet devices
0003  *
0004  * Peter Korsgaard <jacmet@sunsite.dk>
0005  *
0006  * This file is licensed under the terms of the GNU General Public License
0007  * version 2.  This program is licensed "as is" without any warranty of any
0008  * kind, whether express or implied.
0009  */
0010
0011 //#define DEBUG
0012
0013 #include <linux/module.h>
0014 #include <linux/sched.h>
0015 #include <linux/stddef.h>
0016 #include <linux/netdevice.h>
0017 #include <linux/etherdevice.h>
0018 #include <linux/ethtool.h>
0019 #include <linux/mii.h>
0020 #include <linux/usb.h>
0021 #include <linux/crc32.h>
0022 #include <linux/usb/usbnet.h>
0023 #include <linux/slab.h>
0024
0025 /* datasheet:
0026  http://ptm2.cc.utu.fi/ftp/network/cards/DM9601/From_NET/DM9601-DS-P01-930914.pdf
0027 */
0028
0029 /* control requests */
0030 #define DM_READ_REGS    0x00
0031 #define DM_WRITE_REGS   0x01
0032 #define DM_READ_MEMS    0x02
0033 #define DM_WRITE_REG    0x03
0034 #define DM_WRITE_MEMS   0x05
0035 #define DM_WRITE_MEM    0x07
0036
0037 /* registers */
0038 #define DM_NET_CTRL 0x00
0039 #define DM_RX_CTRL  0x05
0040 #define DM_SHARED_CTRL  0x0b
0041 #define DM_SHARED_ADDR  0x0c
0042 #define DM_SHARED_DATA  0x0d    /* low + high */
0043 #define DM_PHY_ADDR 0x10    /* 6 bytes */
0044 #define DM_MCAST_ADDR   0x16    /* 8 bytes */
0045 #define DM_GPR_CTRL 0x1e
0046 #define DM_GPR_DATA 0x1f
0047 #define DM_CHIP_ID  0x2c
0048 #define DM_MODE_CTRL    0x91    /* only on dm9620 */
0049
0050 /* chip id values */
0051 #define ID_DM9601   0
0052 #define ID_DM9620   1
0053
0054 #define DM_MAX_MCAST    64
0055 #define DM_MCAST_SIZE   8
0056 #define DM_EEPROM_LEN   256
0057 #define DM_TX_OVERHEAD  2   /* 2 byte header */
0058 #define DM_RX_OVERHEAD  7   /* 3 byte header + 4 byte crc tail */
0059 #define DM_TIMEOUT  1000
0060
0061 static int dm_read(struct usbnet *dev, u8 reg, u16 length, void *data)
0062 {
0063     int err;
0064     err = usbnet_read_cmd(dev, DM_READ_REGS,
0065                    USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0066                    0, reg, data, length);
0067     if(err != length && err >= 0)
0068         err = -EINVAL;
0069     return err;
0070 }
0071
0072 static int dm_read_reg(struct usbnet *dev, u8 reg, u8 *value)
0073 {
0074     return dm_read(dev, reg, 1, value);
0075 }
0076
0077 static int dm_write(struct usbnet *dev, u8 reg, u16 length, void *data)
0078 {
0079     int err;
0080     err = usbnet_write_cmd(dev, DM_WRITE_REGS,
0081                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0082                 0, reg, data, length);
0083
0084     if (err >= 0 && err < length)
0085         err = -EINVAL;
0086     return err;
0087 }
0088
0089 static int dm_write_reg(struct usbnet *dev, u8 reg, u8 value)
0090 {
0091     return usbnet_write_cmd(dev, DM_WRITE_REG,
0092                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0093                 value, reg, NULL, 0);
0094 }
0095
0096 static void dm_write_async(struct usbnet *dev, u8 reg, u16 length,
0097                const void *data)
0098 {
0099     usbnet_write_cmd_async(dev, DM_WRITE_REGS,
0100                    USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0101                    0, reg, data, length);
0102 }
0103
0104 static void dm_write_reg_async(struct usbnet *dev, u8 reg, u8 value)
0105 {
0106     usbnet_write_cmd_async(dev, DM_WRITE_REG,
0107                    USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
0108                    value, reg, NULL, 0);
0109 }
0110
0111 static int dm_read_shared_word(struct usbnet *dev, int phy, u8 reg, __le16 *value)
0112 {
0113     int ret, i;
0114
0115     mutex_lock(&dev->phy_mutex);
0116
0117     dm_write_reg(dev, DM_SHARED_ADDR, phy ? (reg | 0x40) : reg);
0118     dm_write_reg(dev, DM_SHARED_CTRL, phy ? 0xc : 0x4);
0119
0120     for (i = 0; i < DM_TIMEOUT; i++) {
0121         u8 tmp = 0;
0122
0123         udelay(1);
0124         ret = dm_read_reg(dev, DM_SHARED_CTRL, &tmp);
0125         if (ret < 0)
0126             goto out;
0127
0128         /* ready */
0129         if ((tmp & 1) == 0)
0130             break;
0131     }
0132
0133     if (i == DM_TIMEOUT) {
0134         netdev_err(dev->net, "%s read timed out!\n", phy ? "phy" : "eeprom");
0135         ret = -EIO;
0136         goto out;
0137     }
0138
0139     dm_write_reg(dev, DM_SHARED_CTRL, 0x0);
0140     ret = dm_read(dev, DM_SHARED_DATA, 2, value);
0141
0142     netdev_dbg(dev->net, "read shared %d 0x%02x returned 0x%04x, %d\n",
0143            phy, reg, *value, ret);
0144
0145  out:
0146     mutex_unlock(&dev->phy_mutex);
0147     return ret;
0148 }
0149
0150 static int dm_write_shared_word(struct usbnet *dev, int phy, u8 reg, __le16 value)
0151 {
0152     int ret, i;
0153
0154     mutex_lock(&dev->phy_mutex);
0155
0156     ret = dm_write(dev, DM_SHARED_DATA, 2, &value);
0157     if (ret < 0)
0158         goto out;
0159
0160     dm_write_reg(dev, DM_SHARED_ADDR, phy ? (reg | 0x40) : reg);
0161     dm_write_reg(dev, DM_SHARED_CTRL, phy ? 0x1a : 0x12);
0162
0163     for (i = 0; i < DM_TIMEOUT; i++) {
0164         u8 tmp = 0;
0165
0166         udelay(1);
0167         ret = dm_read_reg(dev, DM_SHARED_CTRL, &tmp);
0168         if (ret < 0)
0169             goto out;
0170
0171         /* ready */
0172         if ((tmp & 1) == 0)
0173             break;
0174     }
0175
0176     if (i == DM_TIMEOUT) {
0177         netdev_err(dev->net, "%s write timed out!\n", phy ? "phy" : "eeprom");
0178         ret = -EIO;
0179         goto out;
0180     }
0181
0182     dm_write_reg(dev, DM_SHARED_CTRL, 0x0);
0183
0184 out:
0185     mutex_unlock(&dev->phy_mutex);
0186     return ret;
0187 }
0188
0189 static int dm_read_eeprom_word(struct usbnet *dev, u8 offset, void *value)
0190 {
0191     return dm_read_shared_word(dev, 0, offset, value);
0192 }
0193
0194
0195
0196 static int dm9601_get_eeprom_len(struct net_device *dev)
0197 {
0198     return DM_EEPROM_LEN;
0199 }
0200
0201 static int dm9601_get_eeprom(struct net_device *net,
0202                  struct ethtool_eeprom *eeprom, u8 * data)
0203 {
0204     struct usbnet *dev = netdev_priv(net);
0205     __le16 *ebuf = (__le16 *) data;
0206     int i;
0207
0208     /* access is 16bit */
0209     if ((eeprom->offset % 2) || (eeprom->len % 2))
0210         return -EINVAL;
0211
0212     for (i = 0; i < eeprom->len / 2; i++) {
0213         if (dm_read_eeprom_word(dev, eeprom->offset / 2 + i,
0214                     &ebuf[i]) < 0)
0215             return -EINVAL;
0216     }
0217     return 0;
0218 }
0219
0220 static int dm9601_mdio_read(struct net_device *netdev, int phy_id, int loc)
0221 {
0222     struct usbnet *dev = netdev_priv(netdev);
0223
0224     __le16 res;
0225
0226     if (phy_id) {
0227         netdev_dbg(dev->net, "Only internal phy supported\n");
0228         return 0;
0229     }
0230
0231     dm_read_shared_word(dev, 1, loc, &res);
0232
0233     netdev_dbg(dev->net,
0234            "dm9601_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
0235            phy_id, loc, le16_to_cpu(res));
0236
0237     return le16_to_cpu(res);
0238 }
0239
0240 static void dm9601_mdio_write(struct net_device *netdev, int phy_id, int loc,
0241                   int val)
0242 {
0243     struct usbnet *dev = netdev_priv(netdev);
0244     __le16 res = cpu_to_le16(val);
0245
0246     if (phy_id) {
0247         netdev_dbg(dev->net, "Only internal phy supported\n");
0248         return;
0249     }
0250
0251     netdev_dbg(dev->net, "dm9601_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
0252            phy_id, loc, val);
0253
0254     dm_write_shared_word(dev, 1, loc, res);
0255 }
0256
0257 static void dm9601_get_drvinfo(struct net_device *net,
0258                    struct ethtool_drvinfo *info)
0259 {
0260     /* Inherit standard device info */
0261     usbnet_get_drvinfo(net, info);
0262 }
0263
0264 static u32 dm9601_get_link(struct net_device *net)
0265 {
0266     struct usbnet *dev = netdev_priv(net);
0267
0268     return mii_link_ok(&dev->mii);
0269 }
0270
0271 static int dm9601_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
0272 {
0273     struct usbnet *dev = netdev_priv(net);
0274
0275     return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
0276 }
0277
0278 static const struct ethtool_ops dm9601_ethtool_ops = {
0279     .get_drvinfo    = dm9601_get_drvinfo,
0280     .get_link   = dm9601_get_link,
0281     .get_msglevel   = usbnet_get_msglevel,
0282     .set_msglevel   = usbnet_set_msglevel,
0283     .get_eeprom_len = dm9601_get_eeprom_len,
0284     .get_eeprom = dm9601_get_eeprom,
0285     .nway_reset = usbnet_nway_reset,
0286     .get_link_ksettings = usbnet_get_link_ksettings_mii,
0287     .set_link_ksettings = usbnet_set_link_ksettings_mii,
0288 };
0289
0290 static void dm9601_set_multicast(struct net_device *net)
0291 {
0292     struct usbnet *dev = netdev_priv(net);
0293     /* We use the 20 byte dev->data for our 8 byte filter buffer
0294      * to avoid allocating memory that is tricky to free later */
0295     u8 *hashes = (u8 *) & dev->data;
0296     u8 rx_ctl = 0x31;
0297
0298     memset(hashes, 0x00, DM_MCAST_SIZE);
0299     hashes[DM_MCAST_SIZE - 1] |= 0x80;  /* broadcast address */
0300
0301     if (net->flags & IFF_PROMISC) {
0302         rx_ctl |= 0x02;
0303     } else if (net->flags & IFF_ALLMULTI ||
0304            netdev_mc_count(net) > DM_MAX_MCAST) {
0305         rx_ctl |= 0x08;
0306     } else if (!netdev_mc_empty(net)) {
0307         struct netdev_hw_addr *ha;
0308
0309         netdev_for_each_mc_addr(ha, net) {
0310             u32 crc = ether_crc(ETH_ALEN, ha->addr) >> 26;
0311             hashes[crc >> 3] |= 1 << (crc & 0x7);
0312         }
0313     }
0314
0315     dm_write_async(dev, DM_MCAST_ADDR, DM_MCAST_SIZE, hashes);
0316     dm_write_reg_async(dev, DM_RX_CTRL, rx_ctl);
0317 }
0318
0319 static void __dm9601_set_mac_address(struct usbnet *dev)
0320 {
0321     dm_write_async(dev, DM_PHY_ADDR, ETH_ALEN, dev->net->dev_addr);
0322 }
0323
0324 static int dm9601_set_mac_address(struct net_device *net, void *p)
0325 {
0326     struct sockaddr *addr = p;
0327     struct usbnet *dev = netdev_priv(net);
0328
0329     if (!is_valid_ether_addr(addr->sa_data)) {
0330         dev_err(&net->dev, "not setting invalid mac address %pM\n",
0331                                 addr->sa_data);
0332         return -EINVAL;
0333     }
0334
0335     eth_hw_addr_set(net, addr->sa_data);
0336     __dm9601_set_mac_address(dev);
0337
0338     return 0;
0339 }
0340
0341 static const struct net_device_ops dm9601_netdev_ops = {
0342     .ndo_open       = usbnet_open,
0343     .ndo_stop       = usbnet_stop,
0344     .ndo_start_xmit     = usbnet_start_xmit,
0345     .ndo_tx_timeout     = usbnet_tx_timeout,
0346     .ndo_change_mtu     = usbnet_change_mtu,
0347     .ndo_get_stats64    = dev_get_tstats64,
0348     .ndo_validate_addr  = eth_validate_addr,
0349     .ndo_eth_ioctl      = dm9601_ioctl,
0350     .ndo_set_rx_mode    = dm9601_set_multicast,
0351     .ndo_set_mac_address    = dm9601_set_mac_address,
0352 };
0353
0354 static int dm9601_bind(struct usbnet *dev, struct usb_interface *intf)
0355 {
0356     int ret;
0357     u8 mac[ETH_ALEN], id;
0358
0359     ret = usbnet_get_endpoints(dev, intf);
0360     if (ret)
0361         goto out;
0362
0363     dev->net->netdev_ops = &dm9601_netdev_ops;
0364     dev->net->ethtool_ops = &dm9601_ethtool_ops;
0365     dev->net->hard_header_len += DM_TX_OVERHEAD;
0366     dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
0367
0368     /* dm9620/21a require room for 4 byte padding, even in dm9601
0369      * mode, so we need +1 to be able to receive full size
0370      * ethernet frames.
0371      */
0372     dev->rx_urb_size = dev->net->mtu + ETH_HLEN + DM_RX_OVERHEAD + 1;
0373
0374     dev->mii.dev = dev->net;
0375     dev->mii.mdio_read = dm9601_mdio_read;
0376     dev->mii.mdio_write = dm9601_mdio_write;
0377     dev->mii.phy_id_mask = 0x1f;
0378     dev->mii.reg_num_mask = 0x1f;
0379
0380     /* reset */
0381     dm_write_reg(dev, DM_NET_CTRL, 1);
0382     udelay(20);
0383
0384     /* read MAC */
0385     if (dm_read(dev, DM_PHY_ADDR, ETH_ALEN, mac) < 0) {
0386         printk(KERN_ERR "Error reading MAC address\n");
0387         ret = -ENODEV;
0388         goto out;
0389     }
0390
0391     /*
0392      * Overwrite the auto-generated address only with good ones.
0393      */
0394     if (is_valid_ether_addr(mac))
0395         eth_hw_addr_set(dev->net, mac);
0396     else {
0397         printk(KERN_WARNING
0398             "dm9601: No valid MAC address in EEPROM, using %pM\n",
0399             dev->net->dev_addr);
0400         __dm9601_set_mac_address(dev);
0401     }
0402
0403     if (dm_read_reg(dev, DM_CHIP_ID, &id) < 0) {
0404         netdev_err(dev->net, "Error reading chip ID\n");
0405         ret = -ENODEV;
0406         goto out;
0407     }
0408
0409     /* put dm9620 devices in dm9601 mode */
0410     if (id == ID_DM9620) {
0411         u8 mode;
0412
0413         if (dm_read_reg(dev, DM_MODE_CTRL, &mode) < 0) {
0414             netdev_err(dev->net, "Error reading MODE_CTRL\n");
0415             ret = -ENODEV;
0416             goto out;
0417         }
0418         dm_write_reg(dev, DM_MODE_CTRL, mode & 0x7f);
0419     }
0420
0421     /* power up phy */
0422     dm_write_reg(dev, DM_GPR_CTRL, 1);
0423     dm_write_reg(dev, DM_GPR_DATA, 0);
0424
0425     /* receive broadcast packets */
0426     dm9601_set_multicast(dev->net);
0427
0428     dm9601_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
0429     dm9601_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
0430               ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
0431     mii_nway_restart(&dev->mii);
0432
0433 out:
0434     return ret;
0435 }
0436
0437 static int dm9601_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
0438 {
0439     u8 status;
0440     int len;
0441
0442     /* format:
0443        b1: rx status
0444        b2: packet length (incl crc) low
0445        b3: packet length (incl crc) high
0446        b4..n-4: packet data
0447        bn-3..bn: ethernet crc
0448      */
0449
0450     if (unlikely(skb->len < DM_RX_OVERHEAD)) {
0451         dev_err(&dev->udev->dev, "unexpected tiny rx frame\n");
0452         return 0;
0453     }
0454
0455     status = skb->data[0];
0456     len = (skb->data[1] | (skb->data[2] << 8)) - 4;
0457
0458     if (unlikely(status & 0xbf)) {
0459         if (status & 0x01) dev->net->stats.rx_fifo_errors++;
0460         if (status & 0x02) dev->net->stats.rx_crc_errors++;
0461         if (status & 0x04) dev->net->stats.rx_frame_errors++;
0462         if (status & 0x20) dev->net->stats.rx_missed_errors++;
0463         if (status & 0x90) dev->net->stats.rx_length_errors++;
0464         return 0;
0465     }
0466
0467     skb_pull(skb, 3);
0468     skb_trim(skb, len);
0469
0470     return 1;
0471 }
0472
0473 static struct sk_buff *dm9601_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
0474                        gfp_t flags)
0475 {
0476     int len, pad;
0477
0478     /* format:
0479        b1: packet length low
0480        b2: packet length high
0481        b3..n: packet data
0482     */
0483
0484     len = skb->len + DM_TX_OVERHEAD;
0485
0486     /* workaround for dm962x errata with tx fifo getting out of
0487      * sync if a USB bulk transfer retry happens right after a
0488      * packet with odd / maxpacket length by adding up to 3 bytes
0489      * padding.
0490      */
0491     while ((len & 1) || !(len % dev->maxpacket))
0492         len++;
0493
0494     len -= DM_TX_OVERHEAD; /* hw header doesn't count as part of length */
0495     pad = len - skb->len;
0496
0497     if (skb_headroom(skb) < DM_TX_OVERHEAD || skb_tailroom(skb) < pad) {
0498         struct sk_buff *skb2;
0499
0500         skb2 = skb_copy_expand(skb, DM_TX_OVERHEAD, pad, flags);
0501         dev_kfree_skb_any(skb);
0502         skb = skb2;
0503         if (!skb)
0504             return NULL;
0505     }
0506
0507     __skb_push(skb, DM_TX_OVERHEAD);
0508
0509     if (pad) {
0510         memset(skb->data + skb->len, 0, pad);
0511         __skb_put(skb, pad);
0512     }
0513
0514     skb->data[0] = len;
0515     skb->data[1] = len >> 8;
0516
0517     return skb;
0518 }
0519
0520 static void dm9601_status(struct usbnet *dev, struct urb *urb)
0521 {
0522     int link;
0523     u8 *buf;
0524
0525     /* format:
0526        b0: net status
0527        b1: tx status 1
0528        b2: tx status 2
0529        b3: rx status
0530        b4: rx overflow
0531        b5: rx count
0532        b6: tx count
0533        b7: gpr
0534     */
0535
0536     if (urb->actual_length < 8)
0537         return;
0538
0539     buf = urb->transfer_buffer;
0540
0541     link = !!(buf[0] & 0x40);
0542     if (netif_carrier_ok(dev->net) != link) {
0543         usbnet_link_change(dev, link, 1);
0544         netdev_dbg(dev->net, "Link Status is: %d\n", link);
0545     }
0546 }
0547
0548 static int dm9601_link_reset(struct usbnet *dev)
0549 {
0550     struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
0551
0552     mii_check_media(&dev->mii, 1, 1);
0553     mii_ethtool_gset(&dev->mii, &ecmd);
0554
0555     netdev_dbg(dev->net, "link_reset() speed: %u duplex: %d\n",
0556            ethtool_cmd_speed(&ecmd), ecmd.duplex);
0557
0558     return 0;
0559 }
0560
0561 static const struct driver_info dm9601_info = {
0562     .description    = "Davicom DM96xx USB 10/100 Ethernet",
0563     .flags      = FLAG_ETHER | FLAG_LINK_INTR,
0564     .bind       = dm9601_bind,
0565     .rx_fixup   = dm9601_rx_fixup,
0566     .tx_fixup   = dm9601_tx_fixup,
0567     .status     = dm9601_status,
0568     .link_reset = dm9601_link_reset,
0569     .reset      = dm9601_link_reset,
0570 };
0571
0572 static const struct usb_device_id products[] = {
0573     {
0574      USB_DEVICE(0x07aa, 0x9601),    /* Corega FEther USB-TXC */
0575      .driver_info = (unsigned long)&dm9601_info,
0576      },
0577     {
0578      USB_DEVICE(0x0a46, 0x9601),    /* Davicom USB-100 */
0579      .driver_info = (unsigned long)&dm9601_info,
0580      },
0581     {
0582      USB_DEVICE(0x0a46, 0x6688),    /* ZT6688 USB NIC */
0583      .driver_info = (unsigned long)&dm9601_info,
0584      },
0585     {
0586      USB_DEVICE(0x0a46, 0x0268),    /* ShanTou ST268 USB NIC */
0587      .driver_info = (unsigned long)&dm9601_info,
0588      },
0589     {
0590      USB_DEVICE(0x0a46, 0x8515),    /* ADMtek ADM8515 USB NIC */
0591      .driver_info = (unsigned long)&dm9601_info,
0592      },
0593     {
0594     USB_DEVICE(0x0a47, 0x9601), /* Hirose USB-100 */
0595     .driver_info = (unsigned long)&dm9601_info,
0596      },
0597     {
0598     USB_DEVICE(0x0fe6, 0x8101), /* DM9601 USB to Fast Ethernet Adapter */
0599     .driver_info = (unsigned long)&dm9601_info,
0600      },
0601     {
0602      USB_DEVICE(0x0fe6, 0x9700),    /* DM9601 USB to Fast Ethernet Adapter */
0603      .driver_info = (unsigned long)&dm9601_info,
0604      },
0605     {
0606      USB_DEVICE(0x0a46, 0x9000),    /* DM9000E */
0607      .driver_info = (unsigned long)&dm9601_info,
0608      },
0609     {
0610      USB_DEVICE(0x0a46, 0x9620),    /* DM9620 USB to Fast Ethernet Adapter */
0611      .driver_info = (unsigned long)&dm9601_info,
0612      },
0613     {
0614      USB_DEVICE(0x0a46, 0x9621),    /* DM9621A USB to Fast Ethernet Adapter */
0615      .driver_info = (unsigned long)&dm9601_info,
0616     },
0617     {
0618      USB_DEVICE(0x0a46, 0x9622),    /* DM9622 USB to Fast Ethernet Adapter */
0619      .driver_info = (unsigned long)&dm9601_info,
0620     },
0621     {
0622      USB_DEVICE(0x0a46, 0x0269),    /* DM962OA USB to Fast Ethernet Adapter */
0623      .driver_info = (unsigned long)&dm9601_info,
0624     },
0625     {
0626      USB_DEVICE(0x0a46, 0x1269),    /* DM9621A USB to Fast Ethernet Adapter */
0627      .driver_info = (unsigned long)&dm9601_info,
0628     },
0629     {
0630      USB_DEVICE(0x0586, 0x3427),    /* ZyXEL Keenetic Plus DSL xDSL modem */
0631      .driver_info = (unsigned long)&dm9601_info,
0632     },
0633     {},         // END
0634 };
0635
0636 MODULE_DEVICE_TABLE(usb, products);
0637
0638 static struct usb_driver dm9601_driver = {
0639     .name = "dm9601",
0640     .id_table = products,
0641     .probe = usbnet_probe,
0642     .disconnect = usbnet_disconnect,
0643     .suspend = usbnet_suspend,
0644     .resume = usbnet_resume,
0645     .disable_hub_initiated_lpm = 1,
0646 };
0647
0648 module_usb_driver(dm9601_driver);
0649
0650 MODULE_AUTHOR("Peter Korsgaard <jacmet@sunsite.dk>");
0651 MODULE_DESCRIPTION("Davicom DM96xx USB 10/100 ethernet devices");
0652 MODULE_LICENSE("GPL");