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");