2 * USB 10M/100M ethernet adapter
4 * This file is licensed under the terms of the GNU General Public License
5 * version 2. This program is licensed "as is" without any warranty of any
6 * kind, whether express or implied
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/sched.h>
13 #include <linux/stddef.h>
14 #include <linux/init.h>
15 #include <linux/netdevice.h>
16 #include <linux/etherdevice.h>
17 #include <linux/ethtool.h>
18 #include <linux/mii.h>
19 #include <linux/usb.h>
20 #include <linux/crc32.h>
21 #include <linux/usb/usbnet.h>
22 #include <linux/slab.h>
24 #define CH9200_VID 0x1A86
25 #define CH9200_PID_E092 0xE092
27 #define CTRL_TIMEOUT_MS 1000
29 #define CONTROL_TIMEOUT_MS 1000
31 #define REQUEST_READ 0x0E
32 #define REQUEST_WRITE 0x0F
38 * Note: all accesses must be 16-bit
41 #define MAC_REG_CTRL 64
42 #define MAC_REG_STATUS 66
43 #define MAC_REG_INTERRUPT_MASK 68
44 #define MAC_REG_PHY_COMMAND 70
45 #define MAC_REG_PHY_DATA 72
46 #define MAC_REG_STATION_L 74
47 #define MAC_REG_STATION_M 76
48 #define MAC_REG_STATION_H 78
49 #define MAC_REG_HASH_L 80
50 #define MAC_REG_HASH_M1 82
51 #define MAC_REG_HASH_M2 84
52 #define MAC_REG_HASH_H 86
53 #define MAC_REG_THRESHOLD 88
54 #define MAC_REG_FIFO_DEPTH 90
55 #define MAC_REG_PAUSE 92
56 #define MAC_REG_FLOW_CONTROL 94
58 /* Control register bits
60 * Note: bits 13 and 15 are reserved
62 #define LOOPBACK (0x01 << 14)
63 #define BASE100X (0x01 << 12)
64 #define MBPS_10 (0x01 << 11)
65 #define DUPLEX_MODE (0x01 << 10)
66 #define PAUSE_FRAME (0x01 << 9)
67 #define PROMISCUOUS (0x01 << 8)
68 #define MULTICAST (0x01 << 7)
69 #define BROADCAST (0x01 << 6)
70 #define HASH (0x01 << 5)
71 #define APPEND_PAD (0x01 << 4)
72 #define APPEND_CRC (0x01 << 3)
73 #define TRANSMITTER_ACTION (0x01 << 2)
74 #define RECEIVER_ACTION (0x01 << 1)
75 #define DMA_ACTION (0x01 << 0)
77 /* Status register bits
79 * Note: bits 7-15 are reserved
81 #define ALIGNMENT (0x01 << 6)
82 #define FIFO_OVER_RUN (0x01 << 5)
83 #define FIFO_UNDER_RUN (0x01 << 4)
84 #define RX_ERROR (0x01 << 3)
85 #define RX_COMPLETE (0x01 << 2)
86 #define TX_ERROR (0x01 << 1)
87 #define TX_COMPLETE (0x01 << 0)
89 /* FIFO depth register bits
91 * Note: bits 6 and 14 are reserved
94 #define ETH_TXBD (0x01 << 15)
95 #define ETN_TX_FIFO_DEPTH (0x01 << 8)
96 #define ETH_RXBD (0x01 << 7)
97 #define ETH_RX_FIFO_DEPTH (0x01 << 0)
99 static int control_read(struct usbnet *dev,
100 unsigned char request, unsigned short value,
101 unsigned short index, void *data, unsigned short size,
104 unsigned char *buf = NULL;
105 unsigned char request_type;
108 if (request == REQUEST_READ)
109 request_type = (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER);
111 request_type = (USB_DIR_IN | USB_TYPE_VENDOR |
114 netdev_dbg(dev->net, "Control_read() index=0x%02x size=%d\n",
117 buf = kmalloc(size, GFP_KERNEL);
123 err = usb_control_msg(dev->udev,
124 usb_rcvctrlpipe(dev->udev, 0),
125 request, request_type, value, index, buf, size,
128 memcpy(data, buf, size);
139 static int control_write(struct usbnet *dev, unsigned char request,
140 unsigned short value, unsigned short index,
141 void *data, unsigned short size, int timeout)
143 unsigned char *buf = NULL;
144 unsigned char request_type;
147 if (request == REQUEST_WRITE)
148 request_type = (USB_DIR_OUT | USB_TYPE_VENDOR |
151 request_type = (USB_DIR_OUT | USB_TYPE_VENDOR |
154 netdev_dbg(dev->net, "Control_write() index=0x%02x size=%d\n",
158 buf = kmalloc(size, GFP_KERNEL);
163 memcpy(buf, data, size);
166 err = usb_control_msg(dev->udev,
167 usb_sndctrlpipe(dev->udev, 0),
168 request, request_type, value, index, buf, size,
170 if (err >= 0 && err < size)
180 static int ch9200_mdio_read(struct net_device *netdev, int phy_id, int loc)
182 struct usbnet *dev = netdev_priv(netdev);
183 unsigned char buff[2];
185 netdev_dbg(netdev, "ch9200_mdio_read phy_id:%02x loc:%02x\n",
191 control_read(dev, REQUEST_READ, 0, loc * 2, buff, 0x02,
194 return (buff[0] | buff[1] << 8);
197 static void ch9200_mdio_write(struct net_device *netdev,
198 int phy_id, int loc, int val)
200 struct usbnet *dev = netdev_priv(netdev);
201 unsigned char buff[2];
203 netdev_dbg(netdev, "ch9200_mdio_write() phy_id=%02x loc:%02x\n",
209 buff[0] = (unsigned char)val;
210 buff[1] = (unsigned char)(val >> 8);
212 control_write(dev, REQUEST_WRITE, 0, loc * 2, buff, 0x02,
216 static int ch9200_link_reset(struct usbnet *dev)
218 struct ethtool_cmd ecmd;
220 mii_check_media(&dev->mii, 1, 1);
221 mii_ethtool_gset(&dev->mii, &ecmd);
223 netdev_dbg(dev->net, "link_reset() speed:%d duplex:%d\n",
224 ecmd.speed, ecmd.duplex);
229 static void ch9200_status(struct usbnet *dev, struct urb *urb)
234 if (urb->actual_length < 16)
237 buf = urb->transfer_buffer;
238 link = !!(buf[0] & 0x01);
241 netif_carrier_on(dev->net);
242 usbnet_defer_kevent(dev, EVENT_LINK_RESET);
244 netif_carrier_off(dev->net);
248 static struct sk_buff *ch9200_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
258 if (skb_headroom(skb) < tx_overhead) {
259 struct sk_buff *skb2;
261 skb2 = skb_copy_expand(skb, tx_overhead, 0, flags);
262 dev_kfree_skb_any(skb);
268 __skb_push(skb, tx_overhead);
269 /* usbnet adds padding if length is a multiple of packet size
270 * if so, adjust length value in header
272 if ((skb->len % dev->maxpacket) == 0)
276 skb->data[1] = len >> 8;
280 for (i = 4; i < 48; i++)
284 skb->data[49] = len >> 8;
285 skb->data[50] = 0x00;
286 skb->data[51] = 0x80;
288 for (i = 52; i < 64; i++)
294 static int ch9200_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
301 if (unlikely(skb->len < rx_overhead)) {
302 dev_err(&dev->udev->dev, "unexpected tiny rx frame\n");
306 len = (skb->data[skb->len - 16] | skb->data[skb->len - 15] << 8);
312 static int get_mac_address(struct usbnet *dev, unsigned char *data)
315 unsigned char mac_addr[0x06];
318 netdev_dbg(dev->net, "get_mac_address:\n\tusbnet VID:%0x PID:%0x\n",
319 dev->udev->descriptor.idVendor,
320 dev->udev->descriptor.idProduct);
322 memset(mac_addr, 0, sizeof(mac_addr));
323 rd_mac_len = control_read(dev, REQUEST_READ, 0,
324 MAC_REG_STATION_L, mac_addr, 0x02,
326 rd_mac_len += control_read(dev, REQUEST_READ, 0, MAC_REG_STATION_M,
327 mac_addr + 2, 0x02, CONTROL_TIMEOUT_MS);
328 rd_mac_len += control_read(dev, REQUEST_READ, 0, MAC_REG_STATION_H,
329 mac_addr + 4, 0x02, CONTROL_TIMEOUT_MS);
330 if (rd_mac_len != ETH_ALEN)
333 data[0] = mac_addr[5];
334 data[1] = mac_addr[4];
335 data[2] = mac_addr[3];
336 data[3] = mac_addr[2];
337 data[4] = mac_addr[1];
338 data[5] = mac_addr[0];
343 static int ch9200_bind(struct usbnet *dev, struct usb_interface *intf)
346 unsigned char data[2];
348 retval = usbnet_get_endpoints(dev, intf);
352 dev->mii.dev = dev->net;
353 dev->mii.mdio_read = ch9200_mdio_read;
354 dev->mii.mdio_write = ch9200_mdio_write;
355 dev->mii.reg_num_mask = 0x1f;
357 dev->mii.phy_id_mask = 0x1f;
359 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
360 dev->rx_urb_size = 24 * 64 + 16;
361 mii_nway_restart(&dev->mii);
365 retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_THRESHOLD, data,
366 0x02, CONTROL_TIMEOUT_MS);
370 retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_FIFO_DEPTH, data,
371 0x02, CONTROL_TIMEOUT_MS);
375 retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_PAUSE, data,
376 0x02, CONTROL_TIMEOUT_MS);
380 retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_FLOW_CONTROL,
381 data, 0x02, CONTROL_TIMEOUT_MS);
383 /* Undocumented register */
386 retval = control_write(dev, REQUEST_WRITE, 0, 254, data, 0x02,
391 retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_CTRL, data, 0x02,
394 retval = get_mac_address(dev, dev->net->dev_addr);
399 static const struct driver_info ch9200_info = {
400 .description = "CH9200 USB to Network Adaptor",
403 .rx_fixup = ch9200_rx_fixup,
404 .tx_fixup = ch9200_tx_fixup,
405 .status = ch9200_status,
406 .link_reset = ch9200_link_reset,
407 .reset = ch9200_link_reset,
410 static const struct usb_device_id ch9200_products[] = {
412 USB_DEVICE(0x1A86, 0xE092),
413 .driver_info = (unsigned long)&ch9200_info,
418 MODULE_DEVICE_TABLE(usb, ch9200_products);
420 static struct usb_driver ch9200_driver = {
422 .id_table = ch9200_products,
423 .probe = usbnet_probe,
424 .disconnect = usbnet_disconnect,
425 .suspend = usbnet_suspend,
426 .resume = usbnet_resume,
429 module_usb_driver(ch9200_driver);
431 MODULE_DESCRIPTION("QinHeng CH9200 USB Network device");
432 MODULE_LICENSE("GPL");