[deliverable/linux.git] / drivers / net / usb / ch9200.c

/*
 * USB 10M/100M ethernet adapter
 *
 * This file is licensed under the terms of the GNU General Public License
 * version 2. This program is licensed "as is" without any warranty of any
 * kind, whether express or implied
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/stddef.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/mii.h>
#include <linux/usb.h>
#include <linux/crc32.h>
#include <linux/usb/usbnet.h>
#include <linux/slab.h>

#define CH9200_VID		0x1A86
#define CH9200_PID_E092		0xE092

#define CTRL_TIMEOUT_MS		1000

#define CONTROL_TIMEOUT_MS 1000

#define REQUEST_READ	0x0E
#define REQUEST_WRITE	0x0F

/* Address space:
 * 00-63 : MII
 * 64-128: MAC
 *
 * Note: all accesses must be 16-bit
 */

#define MAC_REG_CTRL 64
#define MAC_REG_STATUS 66
#define MAC_REG_INTERRUPT_MASK 68
#define MAC_REG_PHY_COMMAND 70
#define MAC_REG_PHY_DATA 72
#define MAC_REG_STATION_L 74
#define MAC_REG_STATION_M 76
#define MAC_REG_STATION_H 78
#define MAC_REG_HASH_L 80
#define MAC_REG_HASH_M1 82
#define MAC_REG_HASH_M2 84
#define MAC_REG_HASH_H 86
#define MAC_REG_THRESHOLD 88
#define MAC_REG_FIFO_DEPTH 90
#define MAC_REG_PAUSE 92
#define MAC_REG_FLOW_CONTROL 94

/* Control register bits
 *
 * Note: bits 13 and 15 are reserved
 */
#define LOOPBACK		(0x01 << 14)
#define BASE100X		(0x01 << 12)
#define MBPS_10			(0x01 << 11)
#define DUPLEX_MODE		(0x01 << 10)
#define PAUSE_FRAME		(0x01 << 9)
#define PROMISCUOUS		(0x01 << 8)
#define MULTICAST		(0x01 << 7)
#define BROADCAST		(0x01 << 6)
#define HASH			(0x01 << 5)
#define APPEND_PAD		(0x01 << 4)
#define APPEND_CRC		(0x01 << 3)
#define TRANSMITTER_ACTION	(0x01 << 2)
#define RECEIVER_ACTION		(0x01 << 1)
#define DMA_ACTION		(0x01 << 0)

/* Status register bits
 *
 * Note: bits 7-15 are reserved
 */
#define ALIGNMENT		(0x01 << 6)
#define FIFO_OVER_RUN		(0x01 << 5)
#define FIFO_UNDER_RUN		(0x01 << 4)
#define RX_ERROR		(0x01 << 3)
#define RX_COMPLETE		(0x01 << 2)
#define TX_ERROR		(0x01 << 1)
#define TX_COMPLETE		(0x01 << 0)

/* FIFO depth register bits
 *
 * Note: bits 6 and 14 are reserved
 */

#define ETH_TXBD		(0x01 << 15)
#define ETN_TX_FIFO_DEPTH	(0x01 << 8)
#define ETH_RXBD		(0x01 << 7)
#define ETH_RX_FIFO_DEPTH	(0x01 << 0)

static int control_read(struct usbnet *dev,
			unsigned char request, unsigned short value,
			unsigned short index, void *data, unsigned short size,
			int timeout)
{
	unsigned char *buf = NULL;
	unsigned char request_type;
	int err = 0;

	if (request == REQUEST_READ)
		request_type = (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER);
	else
		request_type = (USB_DIR_IN | USB_TYPE_VENDOR |
				USB_RECIP_DEVICE);

	netdev_dbg(dev->net, "Control_read() index=0x%02x size=%d\n",
		   index, size);

	buf = kmalloc(size, GFP_KERNEL);
	if (!buf) {
		err = -ENOMEM;
		goto err_out;
	}

	err = usb_control_msg(dev->udev,
			      usb_rcvctrlpipe(dev->udev, 0),
			      request, request_type, value, index, buf, size,
			      timeout);
	if (err == size)
		memcpy(data, buf, size);
	else if (err >= 0)
		err = -EINVAL;
	kfree(buf);

	return err;

err_out:
	return err;
}

static int control_write(struct usbnet *dev, unsigned char request,
			 unsigned short value, unsigned short index,
			 void *data, unsigned short size, int timeout)
{
	unsigned char *buf = NULL;
	unsigned char request_type;
	int err = 0;

	if (request == REQUEST_WRITE)
		request_type = (USB_DIR_OUT | USB_TYPE_VENDOR |
				USB_RECIP_OTHER);
	else
		request_type = (USB_DIR_OUT | USB_TYPE_VENDOR |
				USB_RECIP_DEVICE);

	netdev_dbg(dev->net, "Control_write() index=0x%02x size=%d\n",
		   index, size);

	if (data) {
		buf = kmalloc(size, GFP_KERNEL);
		if (!buf) {
			err = -ENOMEM;
			goto err_out;
		}
		memcpy(buf, data, size);
	}

	err = usb_control_msg(dev->udev,
			      usb_sndctrlpipe(dev->udev, 0),
			      request, request_type, value, index, buf, size,
			      timeout);
	if (err >= 0 && err < size)
		err = -EINVAL;
	kfree(buf);

	return 0;

err_out:
	return err;
}

static int ch9200_mdio_read(struct net_device *netdev, int phy_id, int loc)
{
	struct usbnet *dev = netdev_priv(netdev);
	unsigned char buff[2];

	netdev_dbg(netdev, "ch9200_mdio_read phy_id:%02x loc:%02x\n",
		   phy_id, loc);

	if (phy_id != 0)
		return -ENODEV;

	control_read(dev, REQUEST_READ, 0, loc * 2, buff, 0x02,
		     CONTROL_TIMEOUT_MS);

	return (buff[0] | buff[1] << 8);
}

static void ch9200_mdio_write(struct net_device *netdev,
			      int phy_id, int loc, int val)
{
	struct usbnet *dev = netdev_priv(netdev);
	unsigned char buff[2];

	netdev_dbg(netdev, "ch9200_mdio_write() phy_id=%02x loc:%02x\n",
		   phy_id, loc);

	if (phy_id != 0)
		return;

	buff[0] = (unsigned char)val;
	buff[1] = (unsigned char)(val >> 8);

	control_write(dev, REQUEST_WRITE, 0, loc * 2, buff, 0x02,
		      CONTROL_TIMEOUT_MS);
}

static int ch9200_link_reset(struct usbnet *dev)
{
	struct ethtool_cmd ecmd;

	mii_check_media(&dev->mii, 1, 1);
	mii_ethtool_gset(&dev->mii, &ecmd);

	netdev_dbg(dev->net, "link_reset() speed:%d duplex:%d\n",
		   ecmd.speed, ecmd.duplex);

	return 0;
}

static void ch9200_status(struct usbnet *dev, struct urb *urb)
{
	int link;
	unsigned char *buf;

	if (urb->actual_length < 16)
		return;

	buf = urb->transfer_buffer;
	link = !!(buf[0] & 0x01);

	if (link) {
		netif_carrier_on(dev->net);
		usbnet_defer_kevent(dev, EVENT_LINK_RESET);
	} else {
		netif_carrier_off(dev->net);
	}
}

static struct sk_buff *ch9200_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
				       gfp_t flags)
{
	int i = 0;
	int len = 0;
	int tx_overhead = 0;

	tx_overhead = 0x40;

	len = skb->len;
	if (skb_headroom(skb) < tx_overhead) {
		struct sk_buff *skb2;

		skb2 = skb_copy_expand(skb, tx_overhead, 0, flags);
		dev_kfree_skb_any(skb);
		skb = skb2;
		if (!skb)
			return NULL;
	}

	__skb_push(skb, tx_overhead);
	/* usbnet adds padding if length is a multiple of packet size
	 * if so, adjust length value in header
	 */
	if ((skb->len % dev->maxpacket) == 0)
		len++;

	skb->data[0] = len;
	skb->data[1] = len >> 8;
	skb->data[2] = 0x00;
	skb->data[3] = 0x80;

	for (i = 4; i < 48; i++)
		skb->data[i] = 0x00;

	skb->data[48] = len;
	skb->data[49] = len >> 8;
	skb->data[50] = 0x00;
	skb->data[51] = 0x80;

	for (i = 52; i < 64; i++)
		skb->data[i] = 0x00;

	return skb;
}

static int ch9200_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
{
	int len = 0;
	int rx_overhead = 0;

	rx_overhead = 64;

	if (unlikely(skb->len < rx_overhead)) {
		dev_err(&dev->udev->dev, "unexpected tiny rx frame\n");
		return 0;
	}

	len = (skb->data[skb->len - 16] | skb->data[skb->len - 15] << 8);
	skb_trim(skb, len);

	return 1;
}

static int get_mac_address(struct usbnet *dev, unsigned char *data)
{
	int err = 0;
	unsigned char mac_addr[0x06];
	int rd_mac_len = 0;

	netdev_dbg(dev->net, "get_mac_address:\n\tusbnet VID:%0x PID:%0x\n",
		   dev->udev->descriptor.idVendor,
		   dev->udev->descriptor.idProduct);

	memset(mac_addr, 0, sizeof(mac_addr));
	rd_mac_len = control_read(dev, REQUEST_READ, 0,
				  MAC_REG_STATION_L, mac_addr, 0x02,
				  CONTROL_TIMEOUT_MS);
	rd_mac_len += control_read(dev, REQUEST_READ, 0, MAC_REG_STATION_M,
				   mac_addr + 2, 0x02, CONTROL_TIMEOUT_MS);
	rd_mac_len += control_read(dev, REQUEST_READ, 0, MAC_REG_STATION_H,
				   mac_addr + 4, 0x02, CONTROL_TIMEOUT_MS);
	if (rd_mac_len != ETH_ALEN)
		err = -EINVAL;

	data[0] = mac_addr[5];
	data[1] = mac_addr[4];
	data[2] = mac_addr[3];
	data[3] = mac_addr[2];
	data[4] = mac_addr[1];
	data[5] = mac_addr[0];

	return err;
}

static int ch9200_bind(struct usbnet *dev, struct usb_interface *intf)
{
	int retval = 0;
	unsigned char data[2];

	retval = usbnet_get_endpoints(dev, intf);
	if (retval)
		return retval;

	dev->mii.dev = dev->net;
	dev->mii.mdio_read = ch9200_mdio_read;
	dev->mii.mdio_write = ch9200_mdio_write;
	dev->mii.reg_num_mask = 0x1f;

	dev->mii.phy_id_mask = 0x1f;

	dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
	dev->rx_urb_size = 24 * 64 + 16;
	mii_nway_restart(&dev->mii);

	data[0] = 0x01;
	data[1] = 0x0F;
	retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_THRESHOLD, data,
			       0x02, CONTROL_TIMEOUT_MS);

	data[0] = 0xA0;
	data[1] = 0x90;
	retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_FIFO_DEPTH, data,
			       0x02, CONTROL_TIMEOUT_MS);

	data[0] = 0x30;
	data[1] = 0x00;
	retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_PAUSE, data,
			       0x02, CONTROL_TIMEOUT_MS);

	data[0] = 0x17;
	data[1] = 0xD8;
	retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_FLOW_CONTROL,
			       data, 0x02, CONTROL_TIMEOUT_MS);

	/* Undocumented register */
	data[0] = 0x01;
	data[1] = 0x00;
	retval = control_write(dev, REQUEST_WRITE, 0, 254, data, 0x02,
			       CONTROL_TIMEOUT_MS);

	data[0] = 0x5F;
	data[1] = 0x0D;
	retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_CTRL, data, 0x02,
			       CONTROL_TIMEOUT_MS);

	retval = get_mac_address(dev, dev->net->dev_addr);

	return retval;
}

static const struct driver_info ch9200_info = {
	.description = "CH9200 USB to Network Adaptor",
	.flags = FLAG_ETHER,
	.bind = ch9200_bind,
	.rx_fixup = ch9200_rx_fixup,
	.tx_fixup = ch9200_tx_fixup,
	.status = ch9200_status,
	.link_reset = ch9200_link_reset,
	.reset = ch9200_link_reset,
};

static const struct usb_device_id ch9200_products[] = {
	{
	 USB_DEVICE(0x1A86, 0xE092),
	 .driver_info = (unsigned long)&ch9200_info,
	 },
	{},
};

MODULE_DEVICE_TABLE(usb, ch9200_products);

static struct usb_driver ch9200_driver = {
	.name = "ch9200",
	.id_table = ch9200_products,
	.probe = usbnet_probe,
	.disconnect = usbnet_disconnect,
	.suspend = usbnet_suspend,
	.resume = usbnet_resume,
};

module_usb_driver(ch9200_driver);

MODULE_DESCRIPTION("QinHeng CH9200 USB Network device");
MODULE_LICENSE("GPL");
Commit	Line	Data
4a476bd6 MG	1	/*
	2	* USB 10M/100M ethernet adapter
	3	*
	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
	7	*
	8	*/
	9
	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>
	23
	24	#define CH9200_VID 0x1A86
	25	#define CH9200_PID_E092 0xE092
	26
	27	#define CTRL_TIMEOUT_MS 1000
	28
	29	#define CONTROL_TIMEOUT_MS 1000
	30
	31	#define REQUEST_READ 0x0E
	32	#define REQUEST_WRITE 0x0F
	33
	34	/* Address space:
	35	* 00-63 : MII
	36	* 64-128: MAC
	37	*
	38	* Note: all accesses must be 16-bit
	39	*/
	40
	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
	57
	58	/* Control register bits
	59	*
	60	* Note: bits 13 and 15 are reserved
	61	*/
	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)
76
77	/* Status register bits
78	*
79	* Note: bits 7-15 are reserved
80	*/
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)
88
89	/* FIFO depth register bits
90	*
91	* Note: bits 6 and 14 are reserved
92	*/
93
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)
98
99	static int control_read(struct usbnet *dev,
100	unsigned char request, unsigned short value,
101	unsigned short index, void *data, unsigned short size,
102	int timeout)
103	{
104	unsigned char *buf = NULL;
105	unsigned char request_type;
106	int err = 0;
107
108	if (request == REQUEST_READ)
109	request_type = (USB_DIR_IN \| USB_TYPE_VENDOR \| USB_RECIP_OTHER);
110	else
111	request_type = (USB_DIR_IN \| USB_TYPE_VENDOR \|
112	USB_RECIP_DEVICE);
113
114	netdev_dbg(dev->net, "Control_read() index=0x%02x size=%d\n",
115	index, size);
116
117	buf = kmalloc(size, GFP_KERNEL);
118	if (!buf) {
119	err = -ENOMEM;
120	goto err_out;
121	}
122
123	err = usb_control_msg(dev->udev,
124	usb_rcvctrlpipe(dev->udev, 0),
125	request, request_type, value, index, buf, size,
126	timeout);
127	if (err == size)
128	memcpy(data, buf, size);
129	else if (err >= 0)
130	err = -EINVAL;
131	kfree(buf);
132
133	return err;
134
135	err_out:
136	return err;
137	}
138
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)
142	{
143	unsigned char *buf = NULL;
144	unsigned char request_type;
145	int err = 0;
146
147	if (request == REQUEST_WRITE)
148	request_type = (USB_DIR_OUT \| USB_TYPE_VENDOR \|
149	USB_RECIP_OTHER);
150	else
151	request_type = (USB_DIR_OUT \| USB_TYPE_VENDOR \|
152	USB_RECIP_DEVICE);
153
154	netdev_dbg(dev->net, "Control_write() index=0x%02x size=%d\n",
155	index, size);
156
157	if (data) {
158	buf = kmalloc(size, GFP_KERNEL);
159	if (!buf) {
160	err = -ENOMEM;
161	goto err_out;
162	}
163	memcpy(buf, data, size);
164	}
165
166	err = usb_control_msg(dev->udev,
167	usb_sndctrlpipe(dev->udev, 0),
168	request, request_type, value, index, buf, size,
169	timeout);
170	if (err >= 0 && err < size)
171	err = -EINVAL;
172	kfree(buf);
173
174	return 0;
175
176	err_out:
177	return err;
178	}
179
180	static int ch9200_mdio_read(struct net_device *netdev, int phy_id, int loc)
181	{
182	struct usbnet *dev = netdev_priv(netdev);
183	unsigned char buff[2];
184
185	netdev_dbg(netdev, "ch9200_mdio_read phy_id:%02x loc:%02x\n",
186	phy_id, loc);
187
188	if (phy_id != 0)
189	return -ENODEV;
190
191	control_read(dev, REQUEST_READ, 0, loc * 2, buff, 0x02,
192	CONTROL_TIMEOUT_MS);
193
194	return (buff[0] \| buff[1] << 8);
195	}
196
197	static void ch9200_mdio_write(struct net_device *netdev,
198	int phy_id, int loc, int val)
199	{
200	struct usbnet *dev = netdev_priv(netdev);
201	unsigned char buff[2];
202
203	netdev_dbg(netdev, "ch9200_mdio_write() phy_id=%02x loc:%02x\n",
204	phy_id, loc);
205
206	if (phy_id != 0)
207	return;
208
209	buff[0] = (unsigned char)val;
210	buff[1] = (unsigned char)(val >> 8);
211
212	control_write(dev, REQUEST_WRITE, 0, loc * 2, buff, 0x02,
213	CONTROL_TIMEOUT_MS);
214	}
215
216	static int ch9200_link_reset(struct usbnet *dev)
217	{
218	struct ethtool_cmd ecmd;
219
220	mii_check_media(&dev->mii, 1, 1);
221	mii_ethtool_gset(&dev->mii, &ecmd);
222
223	netdev_dbg(dev->net, "link_reset() speed:%d duplex:%d\n",
224	ecmd.speed, ecmd.duplex);
225
226	return 0;
227	}
228
229	static void ch9200_status(struct usbnet dev, struct urb urb)
230	{
231	int link;
232	unsigned char *buf;
233
234	if (urb->actual_length < 16)
235	return;
236
237	buf = urb->transfer_buffer;
238	link = !!(buf[0] & 0x01);
239
240	if (link) {
241	netif_carrier_on(dev->net);
242	usbnet_defer_kevent(dev, EVENT_LINK_RESET);
243	} else {
244	netif_carrier_off(dev->net);
245	}
246	}
247
248	static struct sk_buff ch9200_tx_fixup(struct usbnet dev, struct sk_buff *skb,
249	gfp_t flags)
250	{
251	int i = 0;
252	int len = 0;
253	int tx_overhead = 0;
254
255	tx_overhead = 0x40;
256
257	len = skb->len;
258	if (skb_headroom(skb) < tx_overhead) {
259	struct sk_buff *skb2;
260
261	skb2 = skb_copy_expand(skb, tx_overhead, 0, flags);
262	dev_kfree_skb_any(skb);
263	skb = skb2;
264	if (!skb)
265	return NULL;
266	}
267
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
271	*/
272	if ((skb->len % dev->maxpacket) == 0)
273	len++;
274
275	skb->data[0] = len;
276	skb->data[1] = len >> 8;
277	skb->data[2] = 0x00;
278	skb->data[3] = 0x80;
279
280	for (i = 4; i < 48; i++)
281	skb->data[i] = 0x00;
282
283	skb->data[48] = len;
284	skb->data[49] = len >> 8;
285	skb->data[50] = 0x00;
286	skb->data[51] = 0x80;
287
288	for (i = 52; i < 64; i++)
289	skb->data[i] = 0x00;
290
291	return skb;
292	}
293
294	static int ch9200_rx_fixup(struct usbnet dev, struct sk_buff skb)
295	{
296	int len = 0;
297	int rx_overhead = 0;
298
299	rx_overhead = 64;
300
301	if (unlikely(skb->len < rx_overhead)) {
302	dev_err(&dev->udev->dev, "unexpected tiny rx frame\n");
303	return 0;
304	}
305
306	len = (skb->data[skb->len - 16] \| skb->data[skb->len - 15] << 8);
307	skb_trim(skb, len);
308
309	return 1;
310	}
311
312	static int get_mac_address(struct usbnet dev, unsigned char data)
313	{
314	int err = 0;
315	unsigned char mac_addr[0x06];
316	int rd_mac_len = 0;
317
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);
321
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,
325	CONTROL_TIMEOUT_MS);
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)
331	err = -EINVAL;
332
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];
339
340	return err;
341	}
342
343	static int ch9200_bind(struct usbnet dev, struct usb_interface intf)
344	{
345	int retval = 0;
346	unsigned char data[2];
347
348	retval = usbnet_get_endpoints(dev, intf);
349	if (retval)
350	return retval;
351
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;
356
357	dev->mii.phy_id_mask = 0x1f;
358
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);
362
363	data[0] = 0x01;
364	data[1] = 0x0F;
365	retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_THRESHOLD, data,
366	0x02, CONTROL_TIMEOUT_MS);
367
368	data[0] = 0xA0;
369	data[1] = 0x90;
370	retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_FIFO_DEPTH, data,
371	0x02, CONTROL_TIMEOUT_MS);
372
373	data[0] = 0x30;
374	data[1] = 0x00;
375	retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_PAUSE, data,
376	0x02, CONTROL_TIMEOUT_MS);
377
378	data[0] = 0x17;
379	data[1] = 0xD8;
380	retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_FLOW_CONTROL,
381	data, 0x02, CONTROL_TIMEOUT_MS);
382
383	/* Undocumented register */
384	data[0] = 0x01;
385	data[1] = 0x00;
386	retval = control_write(dev, REQUEST_WRITE, 0, 254, data, 0x02,
387	CONTROL_TIMEOUT_MS);
388
389	data[0] = 0x5F;
390	data[1] = 0x0D;
391	retval = control_write(dev, REQUEST_WRITE, 0, MAC_REG_CTRL, data, 0x02,
392	CONTROL_TIMEOUT_MS);
393
394	retval = get_mac_address(dev, dev->net->dev_addr);
395
396	return retval;
397	}
398
399	static const struct driver_info ch9200_info = {
400	.description = "CH9200 USB to Network Adaptor",
401	.flags = FLAG_ETHER,
402	.bind = ch9200_bind,
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,
408	};
409
410	static const struct usb_device_id ch9200_products[] = {
411	{
412	USB_DEVICE(0x1A86, 0xE092),
413	.driver_info = (unsigned long)&ch9200_info,
414	},
415	{},
416	};
417
418	MODULE_DEVICE_TABLE(usb, ch9200_products);
419
420	static struct usb_driver ch9200_driver = {
421	.name = "ch9200",
422	.id_table = ch9200_products,
423	.probe = usbnet_probe,
424	.disconnect = usbnet_disconnect,
425	.suspend = usbnet_suspend,
426	.resume = usbnet_resume,
427	};
428
23eedbc2	429	module_usb_driver(ch9200_driver);
4a476bd6 MG	430
	431	MODULE_DESCRIPTION("QinHeng CH9200 USB Network device");
	432	MODULE_LICENSE("GPL");