2 * MOSCHIP MCS7830 based (7730/7830/7832) USB 2.0 Ethernet Devices
4 * based on usbnet.c, asix.c and the vendor provided mcs7830 driver
6 * Copyright (C) 2010 Andreas Mohr <andi@lisas.de>
7 * Copyright (C) 2006 Arnd Bergmann <arnd@arndb.de>
8 * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
9 * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
10 * Copyright (c) 2002-2003 TiVo Inc.
12 * Definitions gathered from MOSCHIP, Data Sheet_7830DA.pdf (thanks!).
14 * 2010-12-19: add 7832 USB PID ("functionality same as MCS7830"),
15 * per active notification by manufacturer
18 * - support HIF_REG_CONFIG_SLEEPMODE/HIF_REG_CONFIG_TXENABLE (via autopm?)
19 * - implement ethtool_ops get_pauseparam/set_pauseparam
20 * via HIF_REG_PAUSE_THRESHOLD (>= revision C only!)
21 * - implement get_eeprom/[set_eeprom]
22 * - switch PHY on/off on ifup/ifdown (perhaps in usbnet.c, via MII)
23 * - mcs7830_get_regs() handling is weird: for rev 2 we return 32 regs,
24 * can access only ~ 24, remaining user buffer is uninitialized garbage
28 * This program is free software; you can redistribute it and/or modify
29 * it under the terms of the GNU General Public License as published by
30 * the Free Software Foundation; either version 2 of the License, or
31 * (at your option) any later version.
33 * This program is distributed in the hope that it will be useful,
34 * but WITHOUT ANY WARRANTY; without even the implied warranty of
35 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
36 * GNU General Public License for more details.
38 * You should have received a copy of the GNU General Public License
39 * along with this program; if not, write to the Free Software
40 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
43 #include <linux/crc32.h>
44 #include <linux/etherdevice.h>
45 #include <linux/ethtool.h>
46 #include <linux/init.h>
47 #include <linux/mii.h>
48 #include <linux/module.h>
49 #include <linux/netdevice.h>
50 #include <linux/slab.h>
51 #include <linux/usb.h>
52 #include <linux/usb/usbnet.h>
55 #define MCS7830_RD_BMREQ (USB_DIR_IN | USB_TYPE_VENDOR | \
57 #define MCS7830_WR_BMREQ (USB_DIR_OUT | USB_TYPE_VENDOR | \
59 #define MCS7830_RD_BREQ 0x0E
60 #define MCS7830_WR_BREQ 0x0D
62 #define MCS7830_CTRL_TIMEOUT 1000
63 #define MCS7830_MAX_MCAST 64
65 #define MCS7830_VENDOR_ID 0x9710
66 #define MCS7832_PRODUCT_ID 0x7832
67 #define MCS7830_PRODUCT_ID 0x7830
68 #define MCS7730_PRODUCT_ID 0x7730
70 #define SITECOM_VENDOR_ID 0x0DF6
71 #define LN_030_PRODUCT_ID 0x0021
73 #define MCS7830_MII_ADVERTISE (ADVERTISE_PAUSE_CAP | ADVERTISE_100FULL | \
74 ADVERTISE_100HALF | ADVERTISE_10FULL | \
75 ADVERTISE_10HALF | ADVERTISE_CSMA)
77 /* HIF_REG_XX corresponding index value */
79 HIF_REG_MULTICAST_HASH
= 0x00,
80 HIF_REG_PACKET_GAP1
= 0x08,
81 HIF_REG_PACKET_GAP2
= 0x09,
82 HIF_REG_PHY_DATA
= 0x0a,
83 HIF_REG_PHY_CMD1
= 0x0c,
84 HIF_REG_PHY_CMD1_READ
= 0x40,
85 HIF_REG_PHY_CMD1_WRITE
= 0x20,
86 HIF_REG_PHY_CMD1_PHYADDR
= 0x01,
87 HIF_REG_PHY_CMD2
= 0x0d,
88 HIF_REG_PHY_CMD2_PEND_FLAG_BIT
= 0x80,
89 HIF_REG_PHY_CMD2_READY_FLAG_BIT
= 0x40,
90 HIF_REG_CONFIG
= 0x0e,
91 /* hmm, spec sez: "R/W", "Except bit 3" (likely TXENABLE). */
92 HIF_REG_CONFIG_CFG
= 0x80,
93 HIF_REG_CONFIG_SPEED100
= 0x40,
94 HIF_REG_CONFIG_FULLDUPLEX_ENABLE
= 0x20,
95 HIF_REG_CONFIG_RXENABLE
= 0x10,
96 HIF_REG_CONFIG_TXENABLE
= 0x08,
97 HIF_REG_CONFIG_SLEEPMODE
= 0x04,
98 HIF_REG_CONFIG_ALLMULTICAST
= 0x02,
99 HIF_REG_CONFIG_PROMISCUOUS
= 0x01,
100 HIF_REG_ETHERNET_ADDR
= 0x0f,
101 HIF_REG_FRAME_DROP_COUNTER
= 0x15, /* 0..ff; reset: 0 */
102 HIF_REG_PAUSE_THRESHOLD
= 0x16,
103 HIF_REG_PAUSE_THRESHOLD_DEFAULT
= 0,
106 /* Trailing status byte in Ethernet Rx frame */
108 MCS7830_RX_SHORT_FRAME
= 0x01, /* < 64 bytes */
109 MCS7830_RX_LENGTH_ERROR
= 0x02, /* framelen != Ethernet length field */
110 MCS7830_RX_ALIGNMENT_ERROR
= 0x04, /* non-even number of nibbles */
111 MCS7830_RX_CRC_ERROR
= 0x08,
112 MCS7830_RX_LARGE_FRAME
= 0x10, /* > 1518 bytes */
113 MCS7830_RX_FRAME_CORRECT
= 0x20, /* frame is correct */
117 struct mcs7830_data
{
122 static const char driver_name
[] = "MOSCHIP usb-ethernet driver";
124 static int mcs7830_get_reg(struct usbnet
*dev
, u16 index
, u16 size
, void *data
)
126 struct usb_device
*xdev
= dev
->udev
;
130 buffer
= kmalloc(size
, GFP_NOIO
);
134 ret
= usb_control_msg(xdev
, usb_rcvctrlpipe(xdev
, 0), MCS7830_RD_BREQ
,
135 MCS7830_RD_BMREQ
, 0x0000, index
, buffer
,
136 size
, MCS7830_CTRL_TIMEOUT
);
137 memcpy(data
, buffer
, size
);
143 static int mcs7830_set_reg(struct usbnet
*dev
, u16 index
, u16 size
, const void *data
)
145 struct usb_device
*xdev
= dev
->udev
;
149 buffer
= kmemdup(data
, size
, GFP_NOIO
);
153 ret
= usb_control_msg(xdev
, usb_sndctrlpipe(xdev
, 0), MCS7830_WR_BREQ
,
154 MCS7830_WR_BMREQ
, 0x0000, index
, buffer
,
155 size
, MCS7830_CTRL_TIMEOUT
);
160 static void mcs7830_async_cmd_callback(struct urb
*urb
)
162 struct usb_ctrlrequest
*req
= (struct usb_ctrlrequest
*)urb
->context
;
163 int status
= urb
->status
;
166 printk(KERN_DEBUG
"%s() failed with %d\n",
173 static void mcs7830_set_reg_async(struct usbnet
*dev
, u16 index
, u16 size
, void *data
)
175 struct usb_ctrlrequest
*req
;
179 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
181 dev_dbg(&dev
->udev
->dev
,
182 "Error allocating URB in write_cmd_async!\n");
186 req
= kmalloc(sizeof *req
, GFP_ATOMIC
);
188 dev_err(&dev
->udev
->dev
,
189 "Failed to allocate memory for control request\n");
192 req
->bRequestType
= MCS7830_WR_BMREQ
;
193 req
->bRequest
= MCS7830_WR_BREQ
;
195 req
->wIndex
= cpu_to_le16(index
);
196 req
->wLength
= cpu_to_le16(size
);
198 usb_fill_control_urb(urb
, dev
->udev
,
199 usb_sndctrlpipe(dev
->udev
, 0),
200 (void *)req
, data
, size
,
201 mcs7830_async_cmd_callback
, req
);
203 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
205 dev_err(&dev
->udev
->dev
,
206 "Error submitting the control message: ret=%d\n", ret
);
215 static int mcs7830_hif_get_mac_address(struct usbnet
*dev
, unsigned char *addr
)
217 int ret
= mcs7830_get_reg(dev
, HIF_REG_ETHERNET_ADDR
, ETH_ALEN
, addr
);
223 static int mcs7830_hif_set_mac_address(struct usbnet
*dev
, unsigned char *addr
)
225 int ret
= mcs7830_set_reg(dev
, HIF_REG_ETHERNET_ADDR
, ETH_ALEN
, addr
);
232 static int mcs7830_set_mac_address(struct net_device
*netdev
, void *p
)
235 struct usbnet
*dev
= netdev_priv(netdev
);
236 struct sockaddr
*addr
= p
;
238 if (netif_running(netdev
))
241 if (!is_valid_ether_addr(addr
->sa_data
))
244 ret
= mcs7830_hif_set_mac_address(dev
, addr
->sa_data
);
249 /* it worked --> adopt it on netdev side */
250 memcpy(netdev
->dev_addr
, addr
->sa_data
, netdev
->addr_len
);
255 static int mcs7830_read_phy(struct usbnet
*dev
, u8 index
)
262 HIF_REG_PHY_CMD1_READ
| HIF_REG_PHY_CMD1_PHYADDR
,
263 HIF_REG_PHY_CMD2_PEND_FLAG_BIT
| index
,
266 mutex_lock(&dev
->phy_mutex
);
267 /* write the MII command */
268 ret
= mcs7830_set_reg(dev
, HIF_REG_PHY_CMD1
, 2, cmd
);
272 /* wait for the data to become valid, should be within < 1ms */
273 for (i
= 0; i
< 10; i
++) {
274 ret
= mcs7830_get_reg(dev
, HIF_REG_PHY_CMD1
, 2, cmd
);
275 if ((ret
< 0) || (cmd
[1] & HIF_REG_PHY_CMD2_READY_FLAG_BIT
))
283 /* read actual register contents */
284 ret
= mcs7830_get_reg(dev
, HIF_REG_PHY_DATA
, 2, &val
);
287 ret
= le16_to_cpu(val
);
288 dev_dbg(&dev
->udev
->dev
, "read PHY reg %02x: %04x (%d tries)\n",
291 mutex_unlock(&dev
->phy_mutex
);
295 static int mcs7830_write_phy(struct usbnet
*dev
, u8 index
, u16 val
)
302 HIF_REG_PHY_CMD1_WRITE
| HIF_REG_PHY_CMD1_PHYADDR
,
303 HIF_REG_PHY_CMD2_PEND_FLAG_BIT
| (index
& 0x1F),
306 mutex_lock(&dev
->phy_mutex
);
308 /* write the new register contents */
309 le_val
= cpu_to_le16(val
);
310 ret
= mcs7830_set_reg(dev
, HIF_REG_PHY_DATA
, 2, &le_val
);
314 /* write the MII command */
315 ret
= mcs7830_set_reg(dev
, HIF_REG_PHY_CMD1
, 2, cmd
);
319 /* wait for the command to be accepted by the PHY */
320 for (i
= 0; i
< 10; i
++) {
321 ret
= mcs7830_get_reg(dev
, HIF_REG_PHY_CMD1
, 2, cmd
);
322 if ((ret
< 0) || (cmd
[1] & HIF_REG_PHY_CMD2_READY_FLAG_BIT
))
331 dev_dbg(&dev
->udev
->dev
, "write PHY reg %02x: %04x (%d tries)\n",
334 mutex_unlock(&dev
->phy_mutex
);
339 * This algorithm comes from the original mcs7830 version 1.4 driver,
340 * not sure if it is needed.
342 static int mcs7830_set_autoneg(struct usbnet
*dev
, int ptrUserPhyMode
)
345 /* Enable all media types */
346 ret
= mcs7830_write_phy(dev
, MII_ADVERTISE
, MCS7830_MII_ADVERTISE
);
348 /* First reset BMCR */
350 ret
= mcs7830_write_phy(dev
, MII_BMCR
, 0x0000);
351 /* Enable Auto Neg */
353 ret
= mcs7830_write_phy(dev
, MII_BMCR
, BMCR_ANENABLE
);
354 /* Restart Auto Neg (Keep the Enable Auto Neg Bit Set) */
356 ret
= mcs7830_write_phy(dev
, MII_BMCR
,
357 BMCR_ANENABLE
| BMCR_ANRESTART
);
363 * if we can read register 22, the chip revision is C or higher
365 static int mcs7830_get_rev(struct usbnet
*dev
)
369 ret
= mcs7830_get_reg(dev
, HIF_REG_FRAME_DROP_COUNTER
, 2, dummy
);
371 return 2; /* Rev C or later */
372 return 1; /* earlier revision */
376 * On rev. C we need to set the pause threshold
378 static void mcs7830_rev_C_fixup(struct usbnet
*dev
)
380 u8 pause_threshold
= HIF_REG_PAUSE_THRESHOLD_DEFAULT
;
383 for (retry
= 0; retry
< 2; retry
++) {
384 if (mcs7830_get_rev(dev
) == 2) {
385 dev_info(&dev
->udev
->dev
, "applying rev.C fixup\n");
386 mcs7830_set_reg(dev
, HIF_REG_PAUSE_THRESHOLD
,
387 1, &pause_threshold
);
393 static int mcs7830_mdio_read(struct net_device
*netdev
, int phy_id
,
396 struct usbnet
*dev
= netdev_priv(netdev
);
397 return mcs7830_read_phy(dev
, location
);
400 static void mcs7830_mdio_write(struct net_device
*netdev
, int phy_id
,
401 int location
, int val
)
403 struct usbnet
*dev
= netdev_priv(netdev
);
404 mcs7830_write_phy(dev
, location
, val
);
407 static int mcs7830_ioctl(struct net_device
*net
, struct ifreq
*rq
, int cmd
)
409 struct usbnet
*dev
= netdev_priv(net
);
410 return generic_mii_ioctl(&dev
->mii
, if_mii(rq
), cmd
, NULL
);
413 static inline struct mcs7830_data
*mcs7830_get_data(struct usbnet
*dev
)
415 return (struct mcs7830_data
*)&dev
->data
;
418 static void mcs7830_hif_update_multicast_hash(struct usbnet
*dev
)
420 struct mcs7830_data
*data
= mcs7830_get_data(dev
);
421 mcs7830_set_reg_async(dev
, HIF_REG_MULTICAST_HASH
,
422 sizeof data
->multi_filter
,
426 static void mcs7830_hif_update_config(struct usbnet
*dev
)
428 /* implementation specific to data->config
429 (argument needs to be heap-based anyway - USB DMA!) */
430 struct mcs7830_data
*data
= mcs7830_get_data(dev
);
431 mcs7830_set_reg_async(dev
, HIF_REG_CONFIG
, 1, &data
->config
);
434 static void mcs7830_data_set_multicast(struct net_device
*net
)
436 struct usbnet
*dev
= netdev_priv(net
);
437 struct mcs7830_data
*data
= mcs7830_get_data(dev
);
439 memset(data
->multi_filter
, 0, sizeof data
->multi_filter
);
441 data
->config
= HIF_REG_CONFIG_TXENABLE
;
443 /* this should not be needed, but it doesn't work otherwise */
444 data
->config
|= HIF_REG_CONFIG_ALLMULTICAST
;
446 if (net
->flags
& IFF_PROMISC
) {
447 data
->config
|= HIF_REG_CONFIG_PROMISCUOUS
;
448 } else if (net
->flags
& IFF_ALLMULTI
||
449 netdev_mc_count(net
) > MCS7830_MAX_MCAST
) {
450 data
->config
|= HIF_REG_CONFIG_ALLMULTICAST
;
451 } else if (netdev_mc_empty(net
)) {
452 /* just broadcast and directed */
454 /* We use the 20 byte dev->data
455 * for our 8 byte filter buffer
456 * to avoid allocating memory that
457 * is tricky to free later */
458 struct netdev_hw_addr
*ha
;
461 /* Build the multicast hash filter. */
462 netdev_for_each_mc_addr(ha
, net
) {
463 crc_bits
= ether_crc(ETH_ALEN
, ha
->addr
) >> 26;
464 data
->multi_filter
[crc_bits
>> 3] |= 1 << (crc_bits
& 7);
469 static int mcs7830_apply_base_config(struct usbnet
*dev
)
473 /* re-configure known MAC (suspend case etc.) */
474 ret
= mcs7830_hif_set_mac_address(dev
, dev
->net
->dev_addr
);
476 dev_info(&dev
->udev
->dev
, "Cannot set MAC address\n");
481 ret
= mcs7830_set_autoneg(dev
, 0);
483 dev_info(&dev
->udev
->dev
, "Cannot set autoneg\n");
487 mcs7830_hif_update_multicast_hash(dev
);
488 mcs7830_hif_update_config(dev
);
490 mcs7830_rev_C_fixup(dev
);
496 /* credits go to asix_set_multicast */
497 static void mcs7830_set_multicast(struct net_device
*net
)
499 struct usbnet
*dev
= netdev_priv(net
);
501 mcs7830_data_set_multicast(net
);
503 mcs7830_hif_update_multicast_hash(dev
);
504 mcs7830_hif_update_config(dev
);
507 static int mcs7830_get_regs_len(struct net_device
*net
)
509 struct usbnet
*dev
= netdev_priv(net
);
511 switch (mcs7830_get_rev(dev
)) {
520 static void mcs7830_get_drvinfo(struct net_device
*net
, struct ethtool_drvinfo
*drvinfo
)
522 usbnet_get_drvinfo(net
, drvinfo
);
523 drvinfo
->regdump_len
= mcs7830_get_regs_len(net
);
526 static void mcs7830_get_regs(struct net_device
*net
, struct ethtool_regs
*regs
, void *data
)
528 struct usbnet
*dev
= netdev_priv(net
);
530 regs
->version
= mcs7830_get_rev(dev
);
531 mcs7830_get_reg(dev
, 0, regs
->len
, data
);
534 static const struct ethtool_ops mcs7830_ethtool_ops
= {
535 .get_drvinfo
= mcs7830_get_drvinfo
,
536 .get_regs_len
= mcs7830_get_regs_len
,
537 .get_regs
= mcs7830_get_regs
,
539 /* common usbnet calls */
540 .get_link
= usbnet_get_link
,
541 .get_msglevel
= usbnet_get_msglevel
,
542 .set_msglevel
= usbnet_set_msglevel
,
543 .get_settings
= usbnet_get_settings
,
544 .set_settings
= usbnet_set_settings
,
545 .nway_reset
= usbnet_nway_reset
,
548 static const struct net_device_ops mcs7830_netdev_ops
= {
549 .ndo_open
= usbnet_open
,
550 .ndo_stop
= usbnet_stop
,
551 .ndo_start_xmit
= usbnet_start_xmit
,
552 .ndo_tx_timeout
= usbnet_tx_timeout
,
553 .ndo_change_mtu
= usbnet_change_mtu
,
554 .ndo_validate_addr
= eth_validate_addr
,
555 .ndo_do_ioctl
= mcs7830_ioctl
,
556 .ndo_set_rx_mode
= mcs7830_set_multicast
,
557 .ndo_set_mac_address
= mcs7830_set_mac_address
,
560 static int mcs7830_bind(struct usbnet
*dev
, struct usb_interface
*udev
)
562 struct net_device
*net
= dev
->net
;
566 /* Initial startup: Gather MAC address setting from EEPROM */
568 for (retry
= 0; retry
< 5 && ret
; retry
++)
569 ret
= mcs7830_hif_get_mac_address(dev
, net
->dev_addr
);
571 dev_warn(&dev
->udev
->dev
, "Cannot read MAC address\n");
575 mcs7830_data_set_multicast(net
);
577 ret
= mcs7830_apply_base_config(dev
);
581 net
->ethtool_ops
= &mcs7830_ethtool_ops
;
582 net
->netdev_ops
= &mcs7830_netdev_ops
;
584 /* reserve space for the status byte on rx */
585 dev
->rx_urb_size
= ETH_FRAME_LEN
+ 1;
587 dev
->mii
.mdio_read
= mcs7830_mdio_read
;
588 dev
->mii
.mdio_write
= mcs7830_mdio_write
;
590 dev
->mii
.phy_id_mask
= 0x3f;
591 dev
->mii
.reg_num_mask
= 0x1f;
592 dev
->mii
.phy_id
= *((u8
*) net
->dev_addr
+ 1);
594 ret
= usbnet_get_endpoints(dev
, udev
);
599 /* The chip always appends a status byte that we need to strip */
600 static int mcs7830_rx_fixup(struct usbnet
*dev
, struct sk_buff
*skb
)
605 dev_err(&dev
->udev
->dev
, "unexpected empty rx frame\n");
609 skb_trim(skb
, skb
->len
- 1);
610 status
= skb
->data
[skb
->len
];
612 if (status
!= MCS7830_RX_FRAME_CORRECT
) {
613 dev_dbg(&dev
->udev
->dev
, "rx fixup status %x\n", status
);
615 /* hmm, perhaps usbnet.c already sees a globally visible
616 frame error and increments rx_errors on its own already? */
617 dev
->net
->stats
.rx_errors
++;
619 if (status
& (MCS7830_RX_SHORT_FRAME
620 |MCS7830_RX_LENGTH_ERROR
621 |MCS7830_RX_LARGE_FRAME
))
622 dev
->net
->stats
.rx_length_errors
++;
623 if (status
& MCS7830_RX_ALIGNMENT_ERROR
)
624 dev
->net
->stats
.rx_frame_errors
++;
625 if (status
& MCS7830_RX_CRC_ERROR
)
626 dev
->net
->stats
.rx_crc_errors
++;
632 static const struct driver_info moschip_info
= {
633 .description
= "MOSCHIP 7830/7832/7730 usb-NET adapter",
634 .bind
= mcs7830_bind
,
635 .rx_fixup
= mcs7830_rx_fixup
,
641 static const struct driver_info sitecom_info
= {
642 .description
= "Sitecom LN-30 usb-NET adapter",
643 .bind
= mcs7830_bind
,
644 .rx_fixup
= mcs7830_rx_fixup
,
650 static const struct usb_device_id products
[] = {
652 USB_DEVICE(MCS7830_VENDOR_ID
, MCS7832_PRODUCT_ID
),
653 .driver_info
= (unsigned long) &moschip_info
,
656 USB_DEVICE(MCS7830_VENDOR_ID
, MCS7830_PRODUCT_ID
),
657 .driver_info
= (unsigned long) &moschip_info
,
660 USB_DEVICE(MCS7830_VENDOR_ID
, MCS7730_PRODUCT_ID
),
661 .driver_info
= (unsigned long) &moschip_info
,
664 USB_DEVICE(SITECOM_VENDOR_ID
, LN_030_PRODUCT_ID
),
665 .driver_info
= (unsigned long) &sitecom_info
,
669 MODULE_DEVICE_TABLE(usb
, products
);
671 static int mcs7830_reset_resume (struct usb_interface
*intf
)
673 /* YES, this function is successful enough that ethtool -d
674 does show same output pre-/post-suspend */
676 struct usbnet
*dev
= usb_get_intfdata(intf
);
678 mcs7830_apply_base_config(dev
);
685 static struct usb_driver mcs7830_driver
= {
687 .id_table
= products
,
688 .probe
= usbnet_probe
,
689 .disconnect
= usbnet_disconnect
,
690 .suspend
= usbnet_suspend
,
691 .resume
= usbnet_resume
,
692 .reset_resume
= mcs7830_reset_resume
,
695 module_usb_driver(mcs7830_driver
);
697 MODULE_DESCRIPTION("USB to network adapter MCS7830)");
698 MODULE_LICENSE("GPL");