rtl8150.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 *  Copyright (c) 2002 Petko Manolov (petkan@users.sourceforge.net)
  4 */
  5
  6#include <linux/signal.h>
  7#include <linux/slab.h>
  8#include <linux/module.h>
  9#include <linux/netdevice.h>
 10#include <linux/etherdevice.h>
 11#include <linux/mii.h>
 12#include <linux/ethtool.h>
 13#include <linux/usb.h>
 14#include <linux/uaccess.h>
 15
 16/* Version Information */
 17#define DRIVER_VERSION "v0.6.2 (2004/08/27)"
 18#define DRIVER_AUTHOR "Petko Manolov <petkan@users.sourceforge.net>"
 19#define DRIVER_DESC "rtl8150 based usb-ethernet driver"
 20
 21#define	IDR			0x0120
 22#define	MAR			0x0126
 23#define	CR			0x012e
 24#define	TCR			0x012f
 25#define	RCR			0x0130
 26#define	TSR			0x0132
 27#define	RSR			0x0133
 28#define	CON0			0x0135
 29#define	CON1			0x0136
 30#define	MSR			0x0137
 31#define	PHYADD			0x0138
 32#define	PHYDAT			0x0139
 33#define	PHYCNT			0x013b
 34#define	GPPC			0x013d
 35#define	BMCR			0x0140
 36#define	BMSR			0x0142
 37#define	ANAR			0x0144
 38#define	ANLP			0x0146
 39#define	AER			0x0148
 40#define CSCR			0x014C  /* This one has the link status */
 41#define CSCR_LINK_STATUS	(1 << 3)
 42
 43#define	IDR_EEPROM		0x1202
 44
 45#define	PHY_READ		0
 46#define	PHY_WRITE		0x20
 47#define	PHY_GO			0x40
 48
 49#define	MII_TIMEOUT		10
 50#define	INTBUFSIZE		8
 51
 52#define	RTL8150_REQT_READ	0xc0
 53#define	RTL8150_REQT_WRITE	0x40
 54#define	RTL8150_REQ_GET_REGS	0x05
 55#define	RTL8150_REQ_SET_REGS	0x05
 56
 57
 58/* Transmit status register errors */
 59#define TSR_ECOL		(1<<5)
 60#define TSR_LCOL		(1<<4)
 61#define TSR_LOSS_CRS		(1<<3)
 62#define TSR_JBR			(1<<2)
 63#define TSR_ERRORS		(TSR_ECOL | TSR_LCOL | TSR_LOSS_CRS | TSR_JBR)
 64/* Receive status register errors */
 65#define RSR_CRC			(1<<2)
 66#define RSR_FAE			(1<<1)
 67#define RSR_ERRORS		(RSR_CRC | RSR_FAE)
 68
 69/* Media status register definitions */
 70#define MSR_DUPLEX		(1<<4)
 71#define MSR_SPEED		(1<<3)
 72#define MSR_LINK		(1<<2)
 73
 74/* USB endpoints */
 75enum rtl8150_usb_ep {
 76	RTL8150_USB_EP_CONTROL = 0,
 77	RTL8150_USB_EP_BULK_IN = 1,
 78	RTL8150_USB_EP_BULK_OUT = 2,
 79	RTL8150_USB_EP_INT_IN = 3,
 80};
 81
 82/* Interrupt pipe data */
 83#define INT_TSR			0x00
 84#define INT_RSR			0x01
 85#define INT_MSR			0x02
 86#define INT_WAKSR		0x03
 87#define INT_TXOK_CNT		0x04
 88#define INT_RXLOST_CNT		0x05
 89#define INT_CRERR_CNT		0x06
 90#define INT_COL_CNT		0x07
 91
 92
 93#define	RTL8150_MTU		1540
 94#define	RTL8150_TX_TIMEOUT	(HZ)
 95#define	RX_SKB_POOL_SIZE	4
 96
 97/* rtl8150 flags */
 98#define	RTL8150_HW_CRC		0
 99#define	RX_REG_SET		1
100#define	RTL8150_UNPLUG		2
101#define	RX_URB_FAIL		3
102
103/* Define these values to match your device */
104#define	VENDOR_ID_REALTEK		0x0bda
105#define	VENDOR_ID_MELCO			0x0411
106#define	VENDOR_ID_MICRONET		0x3980
107#define	VENDOR_ID_LONGSHINE		0x07b8
108#define	VENDOR_ID_OQO			0x1557
109#define	VENDOR_ID_ZYXEL			0x0586
110
111#define PRODUCT_ID_RTL8150		0x8150
112#define	PRODUCT_ID_LUAKTX		0x0012
113#define	PRODUCT_ID_LCS8138TX		0x401a
114#define PRODUCT_ID_SP128AR		0x0003
115#define	PRODUCT_ID_PRESTIGE		0x401a
116
117#undef	EEPROM_WRITE
118
119/* table of devices that work with this driver */
120static const struct usb_device_id rtl8150_table[] = {
121	{USB_DEVICE(VENDOR_ID_REALTEK, PRODUCT_ID_RTL8150)},
122	{USB_DEVICE(VENDOR_ID_MELCO, PRODUCT_ID_LUAKTX)},
123	{USB_DEVICE(VENDOR_ID_MICRONET, PRODUCT_ID_SP128AR)},
124	{USB_DEVICE(VENDOR_ID_LONGSHINE, PRODUCT_ID_LCS8138TX)},
125	{USB_DEVICE(VENDOR_ID_OQO, PRODUCT_ID_RTL8150)},
126	{USB_DEVICE(VENDOR_ID_ZYXEL, PRODUCT_ID_PRESTIGE)},
127	{}
128};
129
130MODULE_DEVICE_TABLE(usb, rtl8150_table);
131
132struct rtl8150 {
133	unsigned long flags;
134	struct usb_device *udev;
135	struct tasklet_struct tl;
136	struct net_device *netdev;
137	struct urb *rx_urb, *tx_urb, *intr_urb;
138	struct sk_buff *tx_skb, *rx_skb;
139	struct sk_buff *rx_skb_pool[RX_SKB_POOL_SIZE];
140	spinlock_t rx_pool_lock;
141	struct usb_ctrlrequest dr;
142	int intr_interval;
143	u8 *intr_buff;
144	u8 phy;
145};
146
147typedef struct rtl8150 rtl8150_t;
148
149struct async_req {
150	struct usb_ctrlrequest dr;
151	u16 rx_creg;
152};
153
154static const char driver_name [] = "rtl8150";
155
156/*
157**
158**	device related part of the code
159**
160*/
161static int get_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
162{
163	return usb_control_msg_recv(dev->udev, 0, RTL8150_REQ_GET_REGS,
164				    RTL8150_REQT_READ, indx, 0, data, size,
165				    1000, GFP_NOIO);
166}
167
168static int set_registers(rtl8150_t * dev, u16 indx, u16 size, const void *data)
169{
170	return usb_control_msg_send(dev->udev, 0, RTL8150_REQ_SET_REGS,
171				    RTL8150_REQT_WRITE, indx, 0, data, size,
172				    1000, GFP_NOIO);
173}
174
175static void async_set_reg_cb(struct urb *urb)
176{
177	struct async_req *req = (struct async_req *)urb->context;
178	int status = urb->status;
179
180	if (status < 0)
181		dev_dbg(&urb->dev->dev, "%s failed with %d", __func__, status);
182	kfree(req);
183	usb_free_urb(urb);
184}
185
186static int async_set_registers(rtl8150_t *dev, u16 indx, u16 size, u16 reg)
187{
188	int res = -ENOMEM;
189	struct urb *async_urb;
190	struct async_req *req;
191
192	req = kmalloc(sizeof(struct async_req), GFP_ATOMIC);
193	if (req == NULL)
194		return res;
195	async_urb = usb_alloc_urb(0, GFP_ATOMIC);
196	if (async_urb == NULL) {
197		kfree(req);
198		return res;
199	}
200	req->rx_creg = cpu_to_le16(reg);
201	req->dr.bRequestType = RTL8150_REQT_WRITE;
202	req->dr.bRequest = RTL8150_REQ_SET_REGS;
203	req->dr.wIndex = 0;
204	req->dr.wValue = cpu_to_le16(indx);
205	req->dr.wLength = cpu_to_le16(size);
206	usb_fill_control_urb(async_urb, dev->udev,
207	                     usb_sndctrlpipe(dev->udev, 0), (void *)&req->dr,
208			     &req->rx_creg, size, async_set_reg_cb, req);
209	res = usb_submit_urb(async_urb, GFP_ATOMIC);
210	if (res) {
211		if (res == -ENODEV)
212			netif_device_detach(dev->netdev);
213		dev_err(&dev->udev->dev, "%s failed with %d\n", __func__, res);
214		kfree(req);
215		usb_free_urb(async_urb);
216	}
217	return res;
218}
219
220static int read_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 * reg)
221{
222	int i;
223	u8 data[3], tmp;
224
225	data[0] = phy;
226	data[1] = data[2] = 0;
227	tmp = indx | PHY_READ | PHY_GO;
228	i = 0;
229
230	set_registers(dev, PHYADD, sizeof(data), data);
231	set_registers(dev, PHYCNT, 1, &tmp);
232	do {
233		get_registers(dev, PHYCNT, 1, data);
234	} while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
235
236	if (i <= MII_TIMEOUT) {
237		get_registers(dev, PHYDAT, 2, data);
238		*reg = data[0] | (data[1] << 8);
239		return 0;
240	} else
241		return 1;
242}
243
244static int write_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 reg)
245{
246	int i;
247	u8 data[3], tmp;
248
249	data[0] = phy;
250	data[1] = reg & 0xff;
251	data[2] = (reg >> 8) & 0xff;
252	tmp = indx | PHY_WRITE | PHY_GO;
253	i = 0;
254
255	set_registers(dev, PHYADD, sizeof(data), data);
256	set_registers(dev, PHYCNT, 1, &tmp);
257	do {
258		get_registers(dev, PHYCNT, 1, data);
259	} while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
260
261	if (i <= MII_TIMEOUT)
262		return 0;
263	else
264		return 1;
265}
266
267static void set_ethernet_addr(rtl8150_t *dev)
268{
269	u8 node_id[ETH_ALEN];
270	int ret;
271
272	ret = get_registers(dev, IDR, sizeof(node_id), node_id);
273
274	if (!ret) {
275		eth_hw_addr_set(dev->netdev, node_id);
276	} else {
277		eth_hw_addr_random(dev->netdev);
278		netdev_notice(dev->netdev, "Assigned a random MAC address: %pM\n",
279			      dev->netdev->dev_addr);
280	}
281}
282
283static int rtl8150_set_mac_address(struct net_device *netdev, void *p)
284{
285	struct sockaddr *addr = p;
286	rtl8150_t *dev = netdev_priv(netdev);
287
288	if (netif_running(netdev))
289		return -EBUSY;
290
291	eth_hw_addr_set(netdev, addr->sa_data);
292	netdev_dbg(netdev, "Setting MAC address to %pM\n", netdev->dev_addr);
293	/* Set the IDR registers. */
294	set_registers(dev, IDR, netdev->addr_len, netdev->dev_addr);
295#ifdef EEPROM_WRITE
296	{
297	int i;
298	u8 cr;
299	/* Get the CR contents. */
300	get_registers(dev, CR, 1, &cr);
301	/* Set the WEPROM bit (eeprom write enable). */
302	cr |= 0x20;
303	set_registers(dev, CR, 1, &cr);
304	/* Write the MAC address into eeprom. Eeprom writes must be word-sized,
305	   so we need to split them up. */
306	for (i = 0; i * 2 < netdev->addr_len; i++) {
307		set_registers(dev, IDR_EEPROM + (i * 2), 2,
308		netdev->dev_addr + (i * 2));
309	}
310	/* Clear the WEPROM bit (preventing accidental eeprom writes). */
311	cr &= 0xdf;
312	set_registers(dev, CR, 1, &cr);
313	}
314#endif
315	return 0;
316}
317
318static int rtl8150_reset(rtl8150_t * dev)
319{
320	u8 data = 0x10;
321	int i = HZ;
322
323	set_registers(dev, CR, 1, &data);
324	do {
325		get_registers(dev, CR, 1, &data);
326	} while ((data & 0x10) && --i);
327
328	return (i > 0) ? 1 : 0;
329}
330
331static int alloc_all_urbs(rtl8150_t * dev)
332{
333	dev->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
334	if (!dev->rx_urb)
335		return 0;
336	dev->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
337	if (!dev->tx_urb) {
338		usb_free_urb(dev->rx_urb);
339		return 0;
340	}
341	dev->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
342	if (!dev->intr_urb) {
343		usb_free_urb(dev->rx_urb);
344		usb_free_urb(dev->tx_urb);
345		return 0;
346	}
347
348	return 1;
349}
350
351static void free_all_urbs(rtl8150_t * dev)
352{
353	usb_free_urb(dev->rx_urb);
354	usb_free_urb(dev->tx_urb);
355	usb_free_urb(dev->intr_urb);
356}
357
358static void unlink_all_urbs(rtl8150_t * dev)
359{
360	usb_kill_urb(dev->rx_urb);
361	usb_kill_urb(dev->tx_urb);
362	usb_kill_urb(dev->intr_urb);
363}
364
365static inline struct sk_buff *pull_skb(rtl8150_t *dev)
366{
367	struct sk_buff *skb;
368	int i;
369
370	for (i = 0; i < RX_SKB_POOL_SIZE; i++) {
371		if (dev->rx_skb_pool[i]) {
372			skb = dev->rx_skb_pool[i];
373			dev->rx_skb_pool[i] = NULL;
374			return skb;
375		}
376	}
377	return NULL;
378}
379
380static void read_bulk_callback(struct urb *urb)
381{
382	rtl8150_t *dev;
383	unsigned pkt_len, res;
384	struct sk_buff *skb;
385	struct net_device *netdev;
386	int status = urb->status;
387	int result;
388	unsigned long flags;
389
390	dev = urb->context;
391	if (!dev)
392		return;
393	if (test_bit(RTL8150_UNPLUG, &dev->flags))
394		return;
395	netdev = dev->netdev;
396	if (!netif_device_present(netdev))
397		return;
398
399	switch (status) {
400	case 0:
401		break;
402	case -ENOENT:
403		return;	/* the urb is in unlink state */
404	case -ETIME:
405		if (printk_ratelimit())
406			dev_warn(&urb->dev->dev, "may be reset is needed?..\n");
407		goto goon;
408	default:
409		if (printk_ratelimit())
410			dev_warn(&urb->dev->dev, "Rx status %d\n", status);
411		goto goon;
412	}
413
414	if (!dev->rx_skb)
415		goto resched;
416	/* protect against short packets (tell me why we got some?!?) */
417	if (urb->actual_length < 4)
418		goto goon;
419
420	res = urb->actual_length;
421	pkt_len = res - 4;
422
423	skb_put(dev->rx_skb, pkt_len);
424	dev->rx_skb->protocol = eth_type_trans(dev->rx_skb, netdev);
425	netif_rx(dev->rx_skb);
426	netdev->stats.rx_packets++;
427	netdev->stats.rx_bytes += pkt_len;
428
429	spin_lock_irqsave(&dev->rx_pool_lock, flags);
430	skb = pull_skb(dev);
431	spin_unlock_irqrestore(&dev->rx_pool_lock, flags);
432	if (!skb)
433		goto resched;
434
435	dev->rx_skb = skb;
436goon:
437	usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
438		      dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
439	result = usb_submit_urb(dev->rx_urb, GFP_ATOMIC);
440	if (result == -ENODEV)
441		netif_device_detach(dev->netdev);
442	else if (result) {
443		set_bit(RX_URB_FAIL, &dev->flags);
444		goto resched;
445	} else {
446		clear_bit(RX_URB_FAIL, &dev->flags);
447	}
448
449	return;
450resched:
451	tasklet_schedule(&dev->tl);
452}
453
454static void write_bulk_callback(struct urb *urb)
455{
456	rtl8150_t *dev;
457	int status = urb->status;
458
459	dev = urb->context;
460	if (!dev)
461		return;
462	dev_kfree_skb_irq(dev->tx_skb);
463	if (!netif_device_present(dev->netdev))
464		return;
465	if (status)
466		dev_info(&urb->dev->dev, "%s: Tx status %d\n",
467			 dev->netdev->name, status);
468	netif_trans_update(dev->netdev);
469	netif_wake_queue(dev->netdev);
470}
471
472static void intr_callback(struct urb *urb)
473{
474	rtl8150_t *dev;
475	__u8 *d;
476	int status = urb->status;
477	int res;
478
479	dev = urb->context;
480	if (!dev)
481		return;
482	switch (status) {
483	case 0:			/* success */
484		break;
485	case -ECONNRESET:	/* unlink */
486	case -ENOENT:
487	case -ESHUTDOWN:
488		return;
489	/* -EPIPE:  should clear the halt */
490	default:
491		dev_info(&urb->dev->dev, "%s: intr status %d\n",
492			 dev->netdev->name, status);
493		goto resubmit;
494	}
495
496	d = urb->transfer_buffer;
497	if (d[0] & TSR_ERRORS) {
498		dev->netdev->stats.tx_errors++;
499		if (d[INT_TSR] & (TSR_ECOL | TSR_JBR))
500			dev->netdev->stats.tx_aborted_errors++;
501		if (d[INT_TSR] & TSR_LCOL)
502			dev->netdev->stats.tx_window_errors++;
503		if (d[INT_TSR] & TSR_LOSS_CRS)
504			dev->netdev->stats.tx_carrier_errors++;
505	}
506	/* Report link status changes to the network stack */
507	if ((d[INT_MSR] & MSR_LINK) == 0) {
508		if (netif_carrier_ok(dev->netdev)) {
509			netif_carrier_off(dev->netdev);
510			netdev_dbg(dev->netdev, "%s: LINK LOST\n", __func__);
511		}
512	} else {
513		if (!netif_carrier_ok(dev->netdev)) {
514			netif_carrier_on(dev->netdev);
515			netdev_dbg(dev->netdev, "%s: LINK CAME BACK\n", __func__);
516		}
517	}
518
519resubmit:
520	res = usb_submit_urb (urb, GFP_ATOMIC);
521	if (res == -ENODEV)
522		netif_device_detach(dev->netdev);
523	else if (res)
524		dev_err(&dev->udev->dev,
525			"can't resubmit intr, %s-%s/input0, status %d\n",
526			dev->udev->bus->bus_name, dev->udev->devpath, res);
527}
528
529static int rtl8150_suspend(struct usb_interface *intf, pm_message_t message)
530{
531	rtl8150_t *dev = usb_get_intfdata(intf);
532
533	netif_device_detach(dev->netdev);
534
535	if (netif_running(dev->netdev)) {
536		usb_kill_urb(dev->rx_urb);
537		usb_kill_urb(dev->intr_urb);
538	}
539	return 0;
540}
541
542static int rtl8150_resume(struct usb_interface *intf)
543{
544	rtl8150_t *dev = usb_get_intfdata(intf);
545
546	netif_device_attach(dev->netdev);
547	if (netif_running(dev->netdev)) {
548		dev->rx_urb->status = 0;
549		dev->rx_urb->actual_length = 0;
550		read_bulk_callback(dev->rx_urb);
551
552		dev->intr_urb->status = 0;
553		dev->intr_urb->actual_length = 0;
554		intr_callback(dev->intr_urb);
555	}
556	return 0;
557}
558
559/*
560**
561**	network related part of the code
562**
563*/
564
565static void fill_skb_pool(rtl8150_t *dev)
566{
567	struct sk_buff *skb;
568	int i;
569
570	for (i = 0; i < RX_SKB_POOL_SIZE; i++) {
571		if (dev->rx_skb_pool[i])
572			continue;
573		skb = dev_alloc_skb(RTL8150_MTU + 2);
574		if (!skb) {
575			return;
576		}
577		skb_reserve(skb, 2);
578		dev->rx_skb_pool[i] = skb;
579	}
580}
581
582static void free_skb_pool(rtl8150_t *dev)
583{
584	int i;
585
586	for (i = 0; i < RX_SKB_POOL_SIZE; i++)
587		dev_kfree_skb(dev->rx_skb_pool[i]);
588}
589
590static void rx_fixup(struct tasklet_struct *t)
591{
592	struct rtl8150 *dev = from_tasklet(dev, t, tl);
593	struct sk_buff *skb;
594	int status;
595
596	spin_lock_irq(&dev->rx_pool_lock);
597	fill_skb_pool(dev);
598	spin_unlock_irq(&dev->rx_pool_lock);
599	if (test_bit(RX_URB_FAIL, &dev->flags))
600		if (dev->rx_skb)
601			goto try_again;
602	spin_lock_irq(&dev->rx_pool_lock);
603	skb = pull_skb(dev);
604	spin_unlock_irq(&dev->rx_pool_lock);
605	if (skb == NULL)
606		goto tlsched;
607	dev->rx_skb = skb;
608	usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
609		      dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
610try_again:
611	status = usb_submit_urb(dev->rx_urb, GFP_ATOMIC);
612	if (status == -ENODEV) {
613		netif_device_detach(dev->netdev);
614	} else if (status) {
615		set_bit(RX_URB_FAIL, &dev->flags);
616		goto tlsched;
617	} else {
618		clear_bit(RX_URB_FAIL, &dev->flags);
619	}
620
621	return;
622tlsched:
623	tasklet_schedule(&dev->tl);
624}
625
626static int enable_net_traffic(rtl8150_t * dev)
627{
628	u8 cr, tcr, rcr, msr;
629
630	if (!rtl8150_reset(dev)) {
631		dev_warn(&dev->udev->dev, "device reset failed\n");
632	}
633	/* RCR bit7=1 attach Rx info at the end;  =0 HW CRC (which is broken) */
634	rcr = 0x9e;
635	tcr = 0xd8;
636	cr = 0x0c;
637	if (!(rcr & 0x80))
638		set_bit(RTL8150_HW_CRC, &dev->flags);
639	set_registers(dev, RCR, 1, &rcr);
640	set_registers(dev, TCR, 1, &tcr);
641	set_registers(dev, CR, 1, &cr);
642	get_registers(dev, MSR, 1, &msr);
643
644	return 0;
645}
646
647static void disable_net_traffic(rtl8150_t * dev)
648{
649	u8 cr;
650
651	get_registers(dev, CR, 1, &cr);
652	cr &= 0xf3;
653	set_registers(dev, CR, 1, &cr);
654}
655
656static void rtl8150_tx_timeout(struct net_device *netdev, unsigned int txqueue)
657{
658	rtl8150_t *dev = netdev_priv(netdev);
659	dev_warn(&netdev->dev, "Tx timeout.\n");
660	usb_unlink_urb(dev->tx_urb);
661	netdev->stats.tx_errors++;
662}
663
664static void rtl8150_set_multicast(struct net_device *netdev)
665{
666	rtl8150_t *dev = netdev_priv(netdev);
667	u16 rx_creg = 0x9e;
668
669	if (netdev->flags & IFF_PROMISC) {
670		rx_creg |= 0x0001;
671		dev_info(&netdev->dev, "%s: promiscuous mode\n", netdev->name);
672	} else if (!netdev_mc_empty(netdev) ||
673		   (netdev->flags & IFF_ALLMULTI)) {
674		rx_creg &= 0xfffe;
675		rx_creg |= 0x0002;
676		dev_dbg(&netdev->dev, "%s: allmulti set\n", netdev->name);
677	} else {
678		/* ~RX_MULTICAST, ~RX_PROMISCUOUS */
679		rx_creg &= 0x00fc;
680	}
681	async_set_registers(dev, RCR, sizeof(rx_creg), rx_creg);
682}
683
684static netdev_tx_t rtl8150_start_xmit(struct sk_buff *skb,
685					    struct net_device *netdev)
686{
687	rtl8150_t *dev = netdev_priv(netdev);
688	int count, res;
689
690	/* pad the frame and ensure terminating USB packet, datasheet 9.2.3 */
691	count = max(skb->len, ETH_ZLEN);
692	if (count % 64 == 0)
693		count++;
694	if (skb_padto(skb, count)) {
695		netdev->stats.tx_dropped++;
696		return NETDEV_TX_OK;
697	}
698
699	netif_stop_queue(netdev);
700	dev->tx_skb = skb;
701	usb_fill_bulk_urb(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev, 2),
702		      skb->data, count, write_bulk_callback, dev);
703	if ((res = usb_submit_urb(dev->tx_urb, GFP_ATOMIC))) {
704		/* Can we get/handle EPIPE here? */
705		if (res == -ENODEV)
706			netif_device_detach(dev->netdev);
707		else {
708			dev_warn(&netdev->dev, "failed tx_urb %d\n", res);
709			netdev->stats.tx_errors++;
710			netif_start_queue(netdev);
711		}
712	} else {
713		netdev->stats.tx_packets++;
714		netdev->stats.tx_bytes += skb->len;
715		netif_trans_update(netdev);
716	}
717
718	return NETDEV_TX_OK;
719}
720
721
722static void set_carrier(struct net_device *netdev)
723{
724	rtl8150_t *dev = netdev_priv(netdev);
725	short tmp;
726
727	get_registers(dev, CSCR, 2, &tmp);
728	if (tmp & CSCR_LINK_STATUS)
729		netif_carrier_on(netdev);
730	else
731		netif_carrier_off(netdev);
732}
733
734static int rtl8150_open(struct net_device *netdev)
735{
736	rtl8150_t *dev = netdev_priv(netdev);
737	int res;
738
739	if (dev->rx_skb == NULL)
740		dev->rx_skb = pull_skb(dev);
741	if (!dev->rx_skb)
742		return -ENOMEM;
743
744	set_registers(dev, IDR, 6, netdev->dev_addr);
745
746	usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
747		      dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
748	if ((res = usb_submit_urb(dev->rx_urb, GFP_KERNEL))) {
749		if (res == -ENODEV)
750			netif_device_detach(dev->netdev);
751		dev_warn(&netdev->dev, "rx_urb submit failed: %d\n", res);
752		return res;
753	}
754	usb_fill_int_urb(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3),
755		     dev->intr_buff, INTBUFSIZE, intr_callback,
756		     dev, dev->intr_interval);
757	if ((res = usb_submit_urb(dev->intr_urb, GFP_KERNEL))) {
758		if (res == -ENODEV)
759			netif_device_detach(dev->netdev);
760		dev_warn(&netdev->dev, "intr_urb submit failed: %d\n", res);
761		usb_kill_urb(dev->rx_urb);
762		return res;
763	}
764	enable_net_traffic(dev);
765	set_carrier(netdev);
766	netif_start_queue(netdev);
767
768	return res;
769}
770
771static int rtl8150_close(struct net_device *netdev)
772{
773	rtl8150_t *dev = netdev_priv(netdev);
774
775	netif_stop_queue(netdev);
776	if (!test_bit(RTL8150_UNPLUG, &dev->flags))
777		disable_net_traffic(dev);
778	unlink_all_urbs(dev);
779
780	return 0;
781}
782
783static void rtl8150_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *info)
784{
785	rtl8150_t *dev = netdev_priv(netdev);
786
787	strscpy(info->driver, driver_name, sizeof(info->driver));
788	strscpy(info->version, DRIVER_VERSION, sizeof(info->version));
789	usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
790}
791
792static int rtl8150_get_link_ksettings(struct net_device *netdev,
793				      struct ethtool_link_ksettings *ecmd)
794{
795	rtl8150_t *dev = netdev_priv(netdev);
796	short lpa = 0;
797	short bmcr = 0;
798	u32 supported;
799
800	supported = (SUPPORTED_10baseT_Half |
801			  SUPPORTED_10baseT_Full |
802			  SUPPORTED_100baseT_Half |
803			  SUPPORTED_100baseT_Full |
804			  SUPPORTED_Autoneg |
805			  SUPPORTED_TP | SUPPORTED_MII);
806	ecmd->base.port = PORT_TP;
807	ecmd->base.phy_address = dev->phy;
808	get_registers(dev, BMCR, 2, &bmcr);
809	get_registers(dev, ANLP, 2, &lpa);
810	if (bmcr & BMCR_ANENABLE) {
811		u32 speed = ((lpa & (LPA_100HALF | LPA_100FULL)) ?
812			     SPEED_100 : SPEED_10);
813		ecmd->base.speed = speed;
814		ecmd->base.autoneg = AUTONEG_ENABLE;
815		if (speed == SPEED_100)
816			ecmd->base.duplex = (lpa & LPA_100FULL) ?
817			    DUPLEX_FULL : DUPLEX_HALF;
818		else
819			ecmd->base.duplex = (lpa & LPA_10FULL) ?
820			    DUPLEX_FULL : DUPLEX_HALF;
821	} else {
822		ecmd->base.autoneg = AUTONEG_DISABLE;
823		ecmd->base.speed = ((bmcr & BMCR_SPEED100) ?
824					     SPEED_100 : SPEED_10);
825		ecmd->base.duplex = (bmcr & BMCR_FULLDPLX) ?
826		    DUPLEX_FULL : DUPLEX_HALF;
827	}
828
829	ethtool_convert_legacy_u32_to_link_mode(ecmd->link_modes.supported,
830						supported);
831
832	return 0;
833}
834
835static const struct ethtool_ops ops = {
836	.get_drvinfo = rtl8150_get_drvinfo,
837	.get_link = ethtool_op_get_link,
838	.get_link_ksettings = rtl8150_get_link_ksettings,
839};
840
841static int rtl8150_siocdevprivate(struct net_device *netdev, struct ifreq *rq,
842				  void __user *udata, int cmd)
843{
844	rtl8150_t *dev = netdev_priv(netdev);
845	u16 *data = (u16 *) & rq->ifr_ifru;
846	int res = 0;
847
848	switch (cmd) {
849	case SIOCDEVPRIVATE:
850		data[0] = dev->phy;
851		fallthrough;
852	case SIOCDEVPRIVATE + 1:
853		read_mii_word(dev, dev->phy, (data[1] & 0x1f), &data[3]);
854		break;
855	case SIOCDEVPRIVATE + 2:
856		if (!capable(CAP_NET_ADMIN))
857			return -EPERM;
858		write_mii_word(dev, dev->phy, (data[1] & 0x1f), data[2]);
859		break;
860	default:
861		res = -EOPNOTSUPP;
862	}
863
864	return res;
865}
866
867static const struct net_device_ops rtl8150_netdev_ops = {
868	.ndo_open		= rtl8150_open,
869	.ndo_stop		= rtl8150_close,
870	.ndo_siocdevprivate	= rtl8150_siocdevprivate,
871	.ndo_start_xmit		= rtl8150_start_xmit,
872	.ndo_tx_timeout		= rtl8150_tx_timeout,
873	.ndo_set_rx_mode	= rtl8150_set_multicast,
874	.ndo_set_mac_address	= rtl8150_set_mac_address,
875
876	.ndo_validate_addr	= eth_validate_addr,
877};
878
879static int rtl8150_probe(struct usb_interface *intf,
880			 const struct usb_device_id *id)
881{
882	struct usb_device *udev = interface_to_usbdev(intf);
883	rtl8150_t *dev;
884	struct net_device *netdev;
885	static const u8 bulk_ep_addr[] = {
886		RTL8150_USB_EP_BULK_IN | USB_DIR_IN,
887		RTL8150_USB_EP_BULK_OUT | USB_DIR_OUT,
888		0};
889	static const u8 int_ep_addr[] = {
890		RTL8150_USB_EP_INT_IN | USB_DIR_IN,
891		0};
892
893	netdev = alloc_etherdev(sizeof(rtl8150_t));
894	if (!netdev)
895		return -ENOMEM;
896
897	dev = netdev_priv(netdev);
898
899	dev->intr_buff = kmalloc(INTBUFSIZE, GFP_KERNEL);
900	if (!dev->intr_buff) {
901		free_netdev(netdev);
902		return -ENOMEM;
903	}
904
905	/* Verify that all required endpoints are present */
906	if (!usb_check_bulk_endpoints(intf, bulk_ep_addr) ||
907	    !usb_check_int_endpoints(intf, int_ep_addr)) {
908		dev_err(&intf->dev, "couldn't find required endpoints\n");
909		goto out;
910	}
911
912	tasklet_setup(&dev->tl, rx_fixup);
913	spin_lock_init(&dev->rx_pool_lock);
914
915	dev->udev = udev;
916	dev->netdev = netdev;
917	netdev->netdev_ops = &rtl8150_netdev_ops;
918	netdev->watchdog_timeo = RTL8150_TX_TIMEOUT;
919	netdev->ethtool_ops = &ops;
920	dev->intr_interval = 100;	/* 100ms */
921
922	if (!alloc_all_urbs(dev)) {
923		dev_err(&intf->dev, "out of memory\n");
924		goto out;
925	}
926	if (!rtl8150_reset(dev)) {
927		dev_err(&intf->dev, "couldn't reset the device\n");
928		goto out1;
929	}
930	fill_skb_pool(dev);
931	set_ethernet_addr(dev);
932
933	usb_set_intfdata(intf, dev);
934	SET_NETDEV_DEV(netdev, &intf->dev);
935	if (register_netdev(netdev) != 0) {
936		dev_err(&intf->dev, "couldn't register the device\n");
937		goto out2;
938	}
939
940	dev_info(&intf->dev, "%s: rtl8150 is detected\n", netdev->name);
941
942	return 0;
943
944out2:
945	usb_set_intfdata(intf, NULL);
946	free_skb_pool(dev);
947out1:
948	free_all_urbs(dev);
949out:
950	kfree(dev->intr_buff);
951	free_netdev(netdev);
952	return -EIO;
953}
954
955static void rtl8150_disconnect(struct usb_interface *intf)
956{
957	rtl8150_t *dev = usb_get_intfdata(intf);
958
959	usb_set_intfdata(intf, NULL);
960	if (dev) {
961		set_bit(RTL8150_UNPLUG, &dev->flags);
962		tasklet_kill(&dev->tl);
963		unregister_netdev(dev->netdev);
964		unlink_all_urbs(dev);
965		free_all_urbs(dev);
966		free_skb_pool(dev);
967		dev_kfree_skb(dev->rx_skb);
968		kfree(dev->intr_buff);
969		free_netdev(dev->netdev);
970	}
971}
972
973static struct usb_driver rtl8150_driver = {
974	.name		= driver_name,
975	.probe		= rtl8150_probe,
976	.disconnect	= rtl8150_disconnect,
977	.id_table	= rtl8150_table,
978	.suspend	= rtl8150_suspend,
979	.resume		= rtl8150_resume,
980	.disable_hub_initiated_lpm = 1,
981};
982
983module_usb_driver(rtl8150_driver);
984
985MODULE_AUTHOR(DRIVER_AUTHOR);
986MODULE_DESCRIPTION(DRIVER_DESC);
987MODULE_LICENSE("GPL");