2 * Davicom DM9601 USB 1.1 10/100Mbps ethernet devices
4 * Peter Korsgaard <jacmet@sunsite.dk>
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.
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 #include <linux/usb/usbnet.h>
24 #include <linux/slab.h>
27 http://ptm2.cc.utu.fi/ftp/network/cards/DM9601/From_NET/DM9601-DS-P01-930914.pdf
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
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
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
57 static int dm_read(struct usbnet
*dev
, u8 reg
, u16 length
, void *data
)
62 netdev_dbg(dev
->net
, "dm_read() reg=0x%02x length=%d\n", reg
, length
);
64 buf
= kmalloc(length
, GFP_KERNEL
);
68 err
= usb_control_msg(dev
->udev
,
69 usb_rcvctrlpipe(dev
->udev
, 0),
71 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
72 0, reg
, buf
, length
, USB_CTRL_SET_TIMEOUT
);
74 memcpy(data
, buf
, length
);
83 static int dm_read_reg(struct usbnet
*dev
, u8 reg
, u8
*value
)
85 return dm_read(dev
, reg
, 1, value
);
88 static int dm_write(struct usbnet
*dev
, u8 reg
, u16 length
, void *data
)
93 netdev_dbg(dev
->net
, "dm_write() reg=0x%02x, length=%d\n", reg
, length
);
96 buf
= kmalloc(length
, GFP_KERNEL
);
99 memcpy(buf
, data
, length
);
102 err
= usb_control_msg(dev
->udev
,
103 usb_sndctrlpipe(dev
->udev
, 0),
105 USB_DIR_OUT
| USB_TYPE_VENDOR
|USB_RECIP_DEVICE
,
106 0, reg
, buf
, length
, USB_CTRL_SET_TIMEOUT
);
108 if (err
>= 0 && err
< length
)
114 static int dm_write_reg(struct usbnet
*dev
, u8 reg
, u8 value
)
116 netdev_dbg(dev
->net
, "dm_write_reg() reg=0x%02x, value=0x%02x\n",
118 return usb_control_msg(dev
->udev
,
119 usb_sndctrlpipe(dev
->udev
, 0),
121 USB_DIR_OUT
| USB_TYPE_VENDOR
|USB_RECIP_DEVICE
,
122 value
, reg
, NULL
, 0, USB_CTRL_SET_TIMEOUT
);
125 static void dm_write_async_callback(struct urb
*urb
)
127 struct usb_ctrlrequest
*req
= (struct usb_ctrlrequest
*)urb
->context
;
128 int status
= urb
->status
;
131 printk(KERN_DEBUG
"dm_write_async_callback() failed with %d\n",
138 static void dm_write_async_helper(struct usbnet
*dev
, u8 reg
, u8 value
,
139 u16 length
, void *data
)
141 struct usb_ctrlrequest
*req
;
145 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
147 netdev_err(dev
->net
, "Error allocating URB in dm_write_async_helper!\n");
151 req
= kmalloc(sizeof(struct usb_ctrlrequest
), GFP_ATOMIC
);
153 netdev_err(dev
->net
, "Failed to allocate memory for control request\n");
158 req
->bRequestType
= USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
;
159 req
->bRequest
= length
? DM_WRITE_REGS
: DM_WRITE_REG
;
160 req
->wValue
= cpu_to_le16(value
);
161 req
->wIndex
= cpu_to_le16(reg
);
162 req
->wLength
= cpu_to_le16(length
);
164 usb_fill_control_urb(urb
, dev
->udev
,
165 usb_sndctrlpipe(dev
->udev
, 0),
166 (void *)req
, data
, length
,
167 dm_write_async_callback
, req
);
169 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
171 netdev_err(dev
->net
, "Error submitting the control message: status=%d\n",
178 static void dm_write_async(struct usbnet
*dev
, u8 reg
, u16 length
, void *data
)
180 netdev_dbg(dev
->net
, "dm_write_async() reg=0x%02x length=%d\n", reg
, length
);
182 dm_write_async_helper(dev
, reg
, 0, length
, data
);
185 static void dm_write_reg_async(struct usbnet
*dev
, u8 reg
, u8 value
)
187 netdev_dbg(dev
->net
, "dm_write_reg_async() reg=0x%02x value=0x%02x\n",
190 dm_write_async_helper(dev
, reg
, value
, 0, NULL
);
193 static int dm_read_shared_word(struct usbnet
*dev
, int phy
, u8 reg
, __le16
*value
)
197 mutex_lock(&dev
->phy_mutex
);
199 dm_write_reg(dev
, DM_SHARED_ADDR
, phy
? (reg
| 0x40) : reg
);
200 dm_write_reg(dev
, DM_SHARED_CTRL
, phy
? 0xc : 0x4);
202 for (i
= 0; i
< DM_TIMEOUT
; i
++) {
206 ret
= dm_read_reg(dev
, DM_SHARED_CTRL
, &tmp
);
215 if (i
== DM_TIMEOUT
) {
216 netdev_err(dev
->net
, "%s read timed out!\n", phy
? "phy" : "eeprom");
221 dm_write_reg(dev
, DM_SHARED_CTRL
, 0x0);
222 ret
= dm_read(dev
, DM_SHARED_DATA
, 2, value
);
224 netdev_dbg(dev
->net
, "read shared %d 0x%02x returned 0x%04x, %d\n",
225 phy
, reg
, *value
, ret
);
228 mutex_unlock(&dev
->phy_mutex
);
232 static int dm_write_shared_word(struct usbnet
*dev
, int phy
, u8 reg
, __le16 value
)
236 mutex_lock(&dev
->phy_mutex
);
238 ret
= dm_write(dev
, DM_SHARED_DATA
, 2, &value
);
242 dm_write_reg(dev
, DM_SHARED_ADDR
, phy
? (reg
| 0x40) : reg
);
243 dm_write_reg(dev
, DM_SHARED_CTRL
, phy
? 0x1a : 0x12);
245 for (i
= 0; i
< DM_TIMEOUT
; i
++) {
249 ret
= dm_read_reg(dev
, DM_SHARED_CTRL
, &tmp
);
258 if (i
== DM_TIMEOUT
) {
259 netdev_err(dev
->net
, "%s write timed out!\n", phy
? "phy" : "eeprom");
264 dm_write_reg(dev
, DM_SHARED_CTRL
, 0x0);
267 mutex_unlock(&dev
->phy_mutex
);
271 static int dm_read_eeprom_word(struct usbnet
*dev
, u8 offset
, void *value
)
273 return dm_read_shared_word(dev
, 0, offset
, value
);
278 static int dm9601_get_eeprom_len(struct net_device
*dev
)
280 return DM_EEPROM_LEN
;
283 static int dm9601_get_eeprom(struct net_device
*net
,
284 struct ethtool_eeprom
*eeprom
, u8
* data
)
286 struct usbnet
*dev
= netdev_priv(net
);
287 __le16
*ebuf
= (__le16
*) data
;
290 /* access is 16bit */
291 if ((eeprom
->offset
% 2) || (eeprom
->len
% 2))
294 for (i
= 0; i
< eeprom
->len
/ 2; i
++) {
295 if (dm_read_eeprom_word(dev
, eeprom
->offset
/ 2 + i
,
302 static int dm9601_mdio_read(struct net_device
*netdev
, int phy_id
, int loc
)
304 struct usbnet
*dev
= netdev_priv(netdev
);
309 netdev_dbg(dev
->net
, "Only internal phy supported\n");
313 dm_read_shared_word(dev
, 1, loc
, &res
);
316 "dm9601_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
317 phy_id
, loc
, le16_to_cpu(res
));
319 return le16_to_cpu(res
);
322 static void dm9601_mdio_write(struct net_device
*netdev
, int phy_id
, int loc
,
325 struct usbnet
*dev
= netdev_priv(netdev
);
326 __le16 res
= cpu_to_le16(val
);
329 netdev_dbg(dev
->net
, "Only internal phy supported\n");
333 netdev_dbg(dev
->net
, "dm9601_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
336 dm_write_shared_word(dev
, 1, loc
, res
);
339 static void dm9601_get_drvinfo(struct net_device
*net
,
340 struct ethtool_drvinfo
*info
)
342 /* Inherit standard device info */
343 usbnet_get_drvinfo(net
, info
);
344 info
->eedump_len
= DM_EEPROM_LEN
;
347 static u32
dm9601_get_link(struct net_device
*net
)
349 struct usbnet
*dev
= netdev_priv(net
);
351 return mii_link_ok(&dev
->mii
);
354 static int dm9601_ioctl(struct net_device
*net
, struct ifreq
*rq
, int cmd
)
356 struct usbnet
*dev
= netdev_priv(net
);
358 return generic_mii_ioctl(&dev
->mii
, if_mii(rq
), cmd
, NULL
);
361 static const struct ethtool_ops dm9601_ethtool_ops
= {
362 .get_drvinfo
= dm9601_get_drvinfo
,
363 .get_link
= dm9601_get_link
,
364 .get_msglevel
= usbnet_get_msglevel
,
365 .set_msglevel
= usbnet_set_msglevel
,
366 .get_eeprom_len
= dm9601_get_eeprom_len
,
367 .get_eeprom
= dm9601_get_eeprom
,
368 .get_settings
= usbnet_get_settings
,
369 .set_settings
= usbnet_set_settings
,
370 .nway_reset
= usbnet_nway_reset
,
373 static void dm9601_set_multicast(struct net_device
*net
)
375 struct usbnet
*dev
= netdev_priv(net
);
376 /* We use the 20 byte dev->data for our 8 byte filter buffer
377 * to avoid allocating memory that is tricky to free later */
378 u8
*hashes
= (u8
*) & dev
->data
;
381 memset(hashes
, 0x00, DM_MCAST_SIZE
);
382 hashes
[DM_MCAST_SIZE
- 1] |= 0x80; /* broadcast address */
384 if (net
->flags
& IFF_PROMISC
) {
386 } else if (net
->flags
& IFF_ALLMULTI
||
387 netdev_mc_count(net
) > DM_MAX_MCAST
) {
389 } else if (!netdev_mc_empty(net
)) {
390 struct dev_mc_list
*mc_list
;
392 netdev_for_each_mc_addr(mc_list
, net
) {
393 u32 crc
= ether_crc(ETH_ALEN
, mc_list
->dmi_addr
) >> 26;
394 hashes
[crc
>> 3] |= 1 << (crc
& 0x7);
398 dm_write_async(dev
, DM_MCAST_ADDR
, DM_MCAST_SIZE
, hashes
);
399 dm_write_reg_async(dev
, DM_RX_CTRL
, rx_ctl
);
402 static void __dm9601_set_mac_address(struct usbnet
*dev
)
404 dm_write_async(dev
, DM_PHY_ADDR
, ETH_ALEN
, dev
->net
->dev_addr
);
407 static int dm9601_set_mac_address(struct net_device
*net
, void *p
)
409 struct sockaddr
*addr
= p
;
410 struct usbnet
*dev
= netdev_priv(net
);
412 if (!is_valid_ether_addr(addr
->sa_data
)) {
413 dev_err(&net
->dev
, "not setting invalid mac address %pM\n",
418 memcpy(net
->dev_addr
, addr
->sa_data
, net
->addr_len
);
419 __dm9601_set_mac_address(dev
);
424 static const struct net_device_ops dm9601_netdev_ops
= {
425 .ndo_open
= usbnet_open
,
426 .ndo_stop
= usbnet_stop
,
427 .ndo_start_xmit
= usbnet_start_xmit
,
428 .ndo_tx_timeout
= usbnet_tx_timeout
,
429 .ndo_change_mtu
= usbnet_change_mtu
,
430 .ndo_validate_addr
= eth_validate_addr
,
431 .ndo_do_ioctl
= dm9601_ioctl
,
432 .ndo_set_multicast_list
= dm9601_set_multicast
,
433 .ndo_set_mac_address
= dm9601_set_mac_address
,
436 static int dm9601_bind(struct usbnet
*dev
, struct usb_interface
*intf
)
441 ret
= usbnet_get_endpoints(dev
, intf
);
445 dev
->net
->netdev_ops
= &dm9601_netdev_ops
;
446 dev
->net
->ethtool_ops
= &dm9601_ethtool_ops
;
447 dev
->net
->hard_header_len
+= DM_TX_OVERHEAD
;
448 dev
->hard_mtu
= dev
->net
->mtu
+ dev
->net
->hard_header_len
;
449 dev
->rx_urb_size
= dev
->net
->mtu
+ ETH_HLEN
+ DM_RX_OVERHEAD
;
451 dev
->mii
.dev
= dev
->net
;
452 dev
->mii
.mdio_read
= dm9601_mdio_read
;
453 dev
->mii
.mdio_write
= dm9601_mdio_write
;
454 dev
->mii
.phy_id_mask
= 0x1f;
455 dev
->mii
.reg_num_mask
= 0x1f;
458 dm_write_reg(dev
, DM_NET_CTRL
, 1);
462 if (dm_read(dev
, DM_PHY_ADDR
, ETH_ALEN
, mac
) < 0) {
463 printk(KERN_ERR
"Error reading MAC address\n");
469 * Overwrite the auto-generated address only with good ones.
471 if (is_valid_ether_addr(mac
))
472 memcpy(dev
->net
->dev_addr
, mac
, ETH_ALEN
);
475 "dm9601: No valid MAC address in EEPROM, using %pM\n",
477 __dm9601_set_mac_address(dev
);
481 dm_write_reg(dev
, DM_GPR_CTRL
, 1);
482 dm_write_reg(dev
, DM_GPR_DATA
, 0);
484 /* receive broadcast packets */
485 dm9601_set_multicast(dev
->net
);
487 dm9601_mdio_write(dev
->net
, dev
->mii
.phy_id
, MII_BMCR
, BMCR_RESET
);
488 dm9601_mdio_write(dev
->net
, dev
->mii
.phy_id
, MII_ADVERTISE
,
489 ADVERTISE_ALL
| ADVERTISE_CSMA
| ADVERTISE_PAUSE_CAP
);
490 mii_nway_restart(&dev
->mii
);
496 static int dm9601_rx_fixup(struct usbnet
*dev
, struct sk_buff
*skb
)
503 b2: packet length (incl crc) low
504 b3: packet length (incl crc) high
506 bn-3..bn: ethernet crc
509 if (unlikely(skb
->len
< DM_RX_OVERHEAD
)) {
510 dev_err(&dev
->udev
->dev
, "unexpected tiny rx frame\n");
514 status
= skb
->data
[0];
515 len
= (skb
->data
[1] | (skb
->data
[2] << 8)) - 4;
517 if (unlikely(status
& 0xbf)) {
518 if (status
& 0x01) dev
->net
->stats
.rx_fifo_errors
++;
519 if (status
& 0x02) dev
->net
->stats
.rx_crc_errors
++;
520 if (status
& 0x04) dev
->net
->stats
.rx_frame_errors
++;
521 if (status
& 0x20) dev
->net
->stats
.rx_missed_errors
++;
522 if (status
& 0x90) dev
->net
->stats
.rx_length_errors
++;
532 static struct sk_buff
*dm9601_tx_fixup(struct usbnet
*dev
, struct sk_buff
*skb
,
538 b1: packet length low
539 b2: packet length high
545 if (skb_headroom(skb
) < DM_TX_OVERHEAD
) {
546 struct sk_buff
*skb2
;
548 skb2
= skb_copy_expand(skb
, DM_TX_OVERHEAD
, 0, flags
);
549 dev_kfree_skb_any(skb
);
555 __skb_push(skb
, DM_TX_OVERHEAD
);
557 /* usbnet adds padding if length is a multiple of packet size
558 if so, adjust length value in header */
559 if ((skb
->len
% dev
->maxpacket
) == 0)
563 skb
->data
[1] = len
>> 8;
568 static void dm9601_status(struct usbnet
*dev
, struct urb
*urb
)
584 if (urb
->actual_length
< 8)
587 buf
= urb
->transfer_buffer
;
589 link
= !!(buf
[0] & 0x40);
590 if (netif_carrier_ok(dev
->net
) != link
) {
592 netif_carrier_on(dev
->net
);
593 usbnet_defer_kevent (dev
, EVENT_LINK_RESET
);
596 netif_carrier_off(dev
->net
);
597 netdev_dbg(dev
->net
, "Link Status is: %d\n", link
);
601 static int dm9601_link_reset(struct usbnet
*dev
)
603 struct ethtool_cmd ecmd
;
605 mii_check_media(&dev
->mii
, 1, 1);
606 mii_ethtool_gset(&dev
->mii
, &ecmd
);
608 netdev_dbg(dev
->net
, "link_reset() speed: %d duplex: %d\n",
609 ecmd
.speed
, ecmd
.duplex
);
614 static const struct driver_info dm9601_info
= {
615 .description
= "Davicom DM9601 USB Ethernet",
616 .flags
= FLAG_ETHER
| FLAG_LINK_INTR
,
618 .rx_fixup
= dm9601_rx_fixup
,
619 .tx_fixup
= dm9601_tx_fixup
,
620 .status
= dm9601_status
,
621 .link_reset
= dm9601_link_reset
,
622 .reset
= dm9601_link_reset
,
625 static const struct usb_device_id products
[] = {
627 USB_DEVICE(0x07aa, 0x9601), /* Corega FEther USB-TXC */
628 .driver_info
= (unsigned long)&dm9601_info
,
631 USB_DEVICE(0x0a46, 0x9601), /* Davicom USB-100 */
632 .driver_info
= (unsigned long)&dm9601_info
,
635 USB_DEVICE(0x0a46, 0x6688), /* ZT6688 USB NIC */
636 .driver_info
= (unsigned long)&dm9601_info
,
639 USB_DEVICE(0x0a46, 0x0268), /* ShanTou ST268 USB NIC */
640 .driver_info
= (unsigned long)&dm9601_info
,
643 USB_DEVICE(0x0a46, 0x8515), /* ADMtek ADM8515 USB NIC */
644 .driver_info
= (unsigned long)&dm9601_info
,
647 USB_DEVICE(0x0a47, 0x9601), /* Hirose USB-100 */
648 .driver_info
= (unsigned long)&dm9601_info
,
651 USB_DEVICE(0x0fe6, 0x8101), /* DM9601 USB to Fast Ethernet Adapter */
652 .driver_info
= (unsigned long)&dm9601_info
,
655 USB_DEVICE(0x0a46, 0x9000), /* DM9000E */
656 .driver_info
= (unsigned long)&dm9601_info
,
661 MODULE_DEVICE_TABLE(usb
, products
);
663 static struct usb_driver dm9601_driver
= {
665 .id_table
= products
,
666 .probe
= usbnet_probe
,
667 .disconnect
= usbnet_disconnect
,
668 .suspend
= usbnet_suspend
,
669 .resume
= usbnet_resume
,
672 static int __init
dm9601_init(void)
674 return usb_register(&dm9601_driver
);
677 static void __exit
dm9601_exit(void)
679 usb_deregister(&dm9601_driver
);
682 module_init(dm9601_init
);
683 module_exit(dm9601_exit
);
685 MODULE_AUTHOR("Peter Korsgaard <jacmet@sunsite.dk>");
686 MODULE_DESCRIPTION("Davicom DM9601 USB 1.1 ethernet devices");
687 MODULE_LICENSE("GPL");