xref: /openbmc/linux/drivers/net/usb/pegasus.c (revision fb3ceec1)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  Copyright (c) 1999-2021 Petko Manolov (petkan@nucleusys.com)
4  *
5  */
6 
7 #include <linux/sched.h>
8 #include <linux/slab.h>
9 #include <linux/init.h>
10 #include <linux/delay.h>
11 #include <linux/netdevice.h>
12 #include <linux/etherdevice.h>
13 #include <linux/ethtool.h>
14 #include <linux/mii.h>
15 #include <linux/usb.h>
16 #include <linux/module.h>
17 #include <asm/byteorder.h>
18 #include <linux/uaccess.h>
19 #include "pegasus.h"
20 
21 /*
22  * Version Information
23  */
24 #define DRIVER_AUTHOR "Petko Manolov <petkan@nucleusys.com>"
25 #define DRIVER_DESC "Pegasus/Pegasus II USB Ethernet driver"
26 
27 static const char driver_name[] = "pegasus";
28 
29 #undef	PEGASUS_WRITE_EEPROM
30 #define	BMSR_MEDIA	(BMSR_10HALF | BMSR_10FULL | BMSR_100HALF | \
31 			BMSR_100FULL | BMSR_ANEGCAPABLE)
32 #define CARRIER_CHECK_DELAY (2 * HZ)
33 
34 static bool loopback;
35 static bool mii_mode;
36 static char *devid;
37 
38 static struct usb_eth_dev usb_dev_id[] = {
39 #define	PEGASUS_DEV(pn, vid, pid, flags)	\
40 	{.name = pn, .vendor = vid, .device = pid, .private = flags},
41 #define PEGASUS_DEV_CLASS(pn, vid, pid, dclass, flags) \
42 	PEGASUS_DEV(pn, vid, pid, flags)
43 #include "pegasus.h"
44 #undef	PEGASUS_DEV
45 #undef	PEGASUS_DEV_CLASS
46 	{NULL, 0, 0, 0},
47 	{NULL, 0, 0, 0}
48 };
49 
50 static struct usb_device_id pegasus_ids[] = {
51 #define	PEGASUS_DEV(pn, vid, pid, flags) \
52 	{.match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = vid, .idProduct = pid},
53 /*
54  * The Belkin F8T012xx1 bluetooth adaptor has the same vendor and product
55  * IDs as the Belkin F5D5050, so we need to teach the pegasus driver to
56  * ignore adaptors belonging to the "Wireless" class 0xE0. For this one
57  * case anyway, seeing as the pegasus is for "Wired" adaptors.
58  */
59 #define PEGASUS_DEV_CLASS(pn, vid, pid, dclass, flags) \
60 	{.match_flags = (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_CLASS), \
61 	.idVendor = vid, .idProduct = pid, .bDeviceClass = dclass},
62 #include "pegasus.h"
63 #undef	PEGASUS_DEV
64 #undef	PEGASUS_DEV_CLASS
65 	{},
66 	{}
67 };
68 
69 MODULE_AUTHOR(DRIVER_AUTHOR);
70 MODULE_DESCRIPTION(DRIVER_DESC);
71 MODULE_LICENSE("GPL");
72 module_param(loopback, bool, 0);
73 module_param(mii_mode, bool, 0);
74 module_param(devid, charp, 0);
75 MODULE_PARM_DESC(loopback, "Enable MAC loopback mode (bit 0)");
76 MODULE_PARM_DESC(mii_mode, "Enable HomePNA mode (bit 0),default=MII mode = 0");
77 MODULE_PARM_DESC(devid, "The format is: 'DEV_name:VendorID:DeviceID:Flags'");
78 
79 /* use ethtool to change the level for any given device */
80 static int msg_level = -1;
81 module_param(msg_level, int, 0);
82 MODULE_PARM_DESC(msg_level, "Override default message level");
83 
84 MODULE_DEVICE_TABLE(usb, pegasus_ids);
85 static const struct net_device_ops pegasus_netdev_ops;
86 
87 /*****/
88 
async_ctrl_callback(struct urb * urb)89 static void async_ctrl_callback(struct urb *urb)
90 {
91 	struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
92 	int status = urb->status;
93 
94 	if (status < 0)
95 		dev_dbg(&urb->dev->dev, "%s failed with %d", __func__, status);
96 	kfree(req);
97 	usb_free_urb(urb);
98 }
99 
get_registers(pegasus_t * pegasus,__u16 indx,__u16 size,void * data)100 static int get_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data)
101 {
102 	return usb_control_msg_recv(pegasus->usb, 0, PEGASUS_REQ_GET_REGS,
103 				   PEGASUS_REQT_READ, 0, indx, data, size,
104 				   1000, GFP_NOIO);
105 }
106 
set_registers(pegasus_t * pegasus,__u16 indx,__u16 size,const void * data)107 static int set_registers(pegasus_t *pegasus, __u16 indx, __u16 size,
108 			 const void *data)
109 {
110 	int ret;
111 
112 	ret = usb_control_msg_send(pegasus->usb, 0, PEGASUS_REQ_SET_REGS,
113 				    PEGASUS_REQT_WRITE, 0, indx, data, size,
114 				    1000, GFP_NOIO);
115 	if (ret < 0)
116 		netif_dbg(pegasus, drv, pegasus->net, "%s failed with %d\n", __func__, ret);
117 
118 	return ret;
119 }
120 
121 /*
122  * There is only one way to write to a single ADM8511 register and this is via
123  * specific control request.  'data' is ignored by the device, but it is here to
124  * not break the API.
125  */
set_register(pegasus_t * pegasus,__u16 indx,__u8 data)126 static int set_register(pegasus_t *pegasus, __u16 indx, __u8 data)
127 {
128 	void *buf = &data;
129 	int ret;
130 
131 	ret = usb_control_msg_send(pegasus->usb, 0, PEGASUS_REQ_SET_REG,
132 				    PEGASUS_REQT_WRITE, data, indx, buf, 1,
133 				    1000, GFP_NOIO);
134 	if (ret < 0)
135 		netif_dbg(pegasus, drv, pegasus->net, "%s failed with %d\n", __func__, ret);
136 
137 	return ret;
138 }
139 
update_eth_regs_async(pegasus_t * pegasus)140 static int update_eth_regs_async(pegasus_t *pegasus)
141 {
142 	int ret = -ENOMEM;
143 	struct urb *async_urb;
144 	struct usb_ctrlrequest *req;
145 
146 	req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
147 	if (req == NULL)
148 		return ret;
149 
150 	async_urb = usb_alloc_urb(0, GFP_ATOMIC);
151 	if (async_urb == NULL) {
152 		kfree(req);
153 		return ret;
154 	}
155 	req->bRequestType = PEGASUS_REQT_WRITE;
156 	req->bRequest = PEGASUS_REQ_SET_REGS;
157 	req->wValue = cpu_to_le16(0);
158 	req->wIndex = cpu_to_le16(EthCtrl0);
159 	req->wLength = cpu_to_le16(3);
160 
161 	usb_fill_control_urb(async_urb, pegasus->usb,
162 			     usb_sndctrlpipe(pegasus->usb, 0), (void *)req,
163 			     pegasus->eth_regs, 3, async_ctrl_callback, req);
164 
165 	ret = usb_submit_urb(async_urb, GFP_ATOMIC);
166 	if (ret) {
167 		if (ret == -ENODEV)
168 			netif_device_detach(pegasus->net);
169 		netif_err(pegasus, drv, pegasus->net,
170 			  "%s returned %d\n", __func__, ret);
171 	}
172 	return ret;
173 }
174 
__mii_op(pegasus_t * p,__u8 phy,__u8 indx,__u16 * regd,__u8 cmd)175 static int __mii_op(pegasus_t *p, __u8 phy, __u8 indx, __u16 *regd, __u8 cmd)
176 {
177 	int i, ret;
178 	__le16 regdi;
179 	__u8 data[4] = { phy, 0, 0, indx };
180 
181 	if (cmd & PHY_WRITE) {
182 		__le16 *t = (__le16 *) & data[1];
183 		*t = cpu_to_le16(*regd);
184 	}
185 	set_register(p, PhyCtrl, 0);
186 	set_registers(p, PhyAddr, sizeof(data), data);
187 	set_register(p, PhyCtrl, (indx | cmd));
188 	for (i = 0; i < REG_TIMEOUT; i++) {
189 		ret = get_registers(p, PhyCtrl, 1, data);
190 		if (ret < 0)
191 			goto fail;
192 		if (data[0] & PHY_DONE)
193 			break;
194 	}
195 	if (i >= REG_TIMEOUT) {
196 		ret = -ETIMEDOUT;
197 		goto fail;
198 	}
199 	if (cmd & PHY_READ) {
200 		ret = get_registers(p, PhyData, 2, &regdi);
201 		if (ret < 0)
202 			goto fail;
203 		*regd = le16_to_cpu(regdi);
204 	}
205 	return 0;
206 fail:
207 	netif_dbg(p, drv, p->net, "%s failed\n", __func__);
208 	return ret;
209 }
210 
211 /* Returns non-negative int on success, error on failure */
read_mii_word(pegasus_t * pegasus,__u8 phy,__u8 indx,__u16 * regd)212 static int read_mii_word(pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd)
213 {
214 	return __mii_op(pegasus, phy, indx, regd, PHY_READ);
215 }
216 
217 /* Returns zero on success, error on failure */
write_mii_word(pegasus_t * pegasus,__u8 phy,__u8 indx,__u16 * regd)218 static int write_mii_word(pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd)
219 {
220 	return __mii_op(pegasus, phy, indx, regd, PHY_WRITE);
221 }
222 
mdio_read(struct net_device * dev,int phy_id,int loc)223 static int mdio_read(struct net_device *dev, int phy_id, int loc)
224 {
225 	pegasus_t *pegasus = netdev_priv(dev);
226 	int ret;
227 	u16 res;
228 
229 	ret = read_mii_word(pegasus, phy_id, loc, &res);
230 	if (ret < 0)
231 		return ret;
232 
233 	return (int)res;
234 }
235 
mdio_write(struct net_device * dev,int phy_id,int loc,int val)236 static void mdio_write(struct net_device *dev, int phy_id, int loc, int val)
237 {
238 	pegasus_t *pegasus = netdev_priv(dev);
239 	u16 data = val;
240 
241 	write_mii_word(pegasus, phy_id, loc, &data);
242 }
243 
read_eprom_word(pegasus_t * pegasus,__u8 index,__u16 * retdata)244 static int read_eprom_word(pegasus_t *pegasus, __u8 index, __u16 *retdata)
245 {
246 	int ret, i;
247 	__le16 retdatai;
248 	__u8 tmp = 0;
249 
250 	set_register(pegasus, EpromCtrl, 0);
251 	set_register(pegasus, EpromOffset, index);
252 	set_register(pegasus, EpromCtrl, EPROM_READ);
253 
254 	for (i = 0; i < REG_TIMEOUT; i++) {
255 		ret = get_registers(pegasus, EpromCtrl, 1, &tmp);
256 		if (ret < 0)
257 			goto fail;
258 		if (tmp & EPROM_DONE)
259 			break;
260 	}
261 	if (i >= REG_TIMEOUT) {
262 		ret = -ETIMEDOUT;
263 		goto fail;
264 	}
265 
266 	ret = get_registers(pegasus, EpromData, 2, &retdatai);
267 	if (ret < 0)
268 		goto fail;
269 	*retdata = le16_to_cpu(retdatai);
270 	return ret;
271 
272 fail:
273 	netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
274 	return ret;
275 }
276 
277 #ifdef	PEGASUS_WRITE_EEPROM
enable_eprom_write(pegasus_t * pegasus)278 static inline void enable_eprom_write(pegasus_t *pegasus)
279 {
280 	__u8 tmp;
281 
282 	get_registers(pegasus, EthCtrl2, 1, &tmp);
283 	set_register(pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE);
284 }
285 
disable_eprom_write(pegasus_t * pegasus)286 static inline void disable_eprom_write(pegasus_t *pegasus)
287 {
288 	__u8 tmp;
289 
290 	get_registers(pegasus, EthCtrl2, 1, &tmp);
291 	set_register(pegasus, EpromCtrl, 0);
292 	set_register(pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE);
293 }
294 
write_eprom_word(pegasus_t * pegasus,__u8 index,__u16 data)295 static int write_eprom_word(pegasus_t *pegasus, __u8 index, __u16 data)
296 {
297 	int i;
298 	__u8 tmp, d[4] = { 0x3f, 0, 0, EPROM_WRITE };
299 	int ret;
300 	__le16 le_data = cpu_to_le16(data);
301 
302 	set_registers(pegasus, EpromOffset, 4, d);
303 	enable_eprom_write(pegasus);
304 	set_register(pegasus, EpromOffset, index);
305 	set_registers(pegasus, EpromData, 2, &le_data);
306 	set_register(pegasus, EpromCtrl, EPROM_WRITE);
307 
308 	for (i = 0; i < REG_TIMEOUT; i++) {
309 		ret = get_registers(pegasus, EpromCtrl, 1, &tmp);
310 		if (ret == -ESHUTDOWN)
311 			goto fail;
312 		if (tmp & EPROM_DONE)
313 			break;
314 	}
315 	disable_eprom_write(pegasus);
316 	if (i >= REG_TIMEOUT)
317 		goto fail;
318 
319 	return ret;
320 
321 fail:
322 	netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
323 	return -ETIMEDOUT;
324 }
325 #endif	/* PEGASUS_WRITE_EEPROM */
326 
get_node_id(pegasus_t * pegasus,u8 * id)327 static inline int get_node_id(pegasus_t *pegasus, u8 *id)
328 {
329 	int i, ret;
330 	u16 w16;
331 
332 	for (i = 0; i < 3; i++) {
333 		ret = read_eprom_word(pegasus, i, &w16);
334 		if (ret < 0)
335 			return ret;
336 		((__le16 *) id)[i] = cpu_to_le16(w16);
337 	}
338 
339 	return 0;
340 }
341 
set_ethernet_addr(pegasus_t * pegasus)342 static void set_ethernet_addr(pegasus_t *pegasus)
343 {
344 	int ret;
345 	u8 node_id[6];
346 
347 	if (pegasus->features & PEGASUS_II) {
348 		ret = get_registers(pegasus, 0x10, sizeof(node_id), node_id);
349 		if (ret < 0)
350 			goto err;
351 	} else {
352 		ret = get_node_id(pegasus, node_id);
353 		if (ret < 0)
354 			goto err;
355 		ret = set_registers(pegasus, EthID, sizeof(node_id), node_id);
356 		if (ret < 0)
357 			goto err;
358 	}
359 
360 	eth_hw_addr_set(pegasus->net, node_id);
361 
362 	return;
363 err:
364 	eth_hw_addr_random(pegasus->net);
365 	netif_dbg(pegasus, drv, pegasus->net, "software assigned MAC address.\n");
366 
367 	return;
368 }
369 
reset_mac(pegasus_t * pegasus)370 static inline int reset_mac(pegasus_t *pegasus)
371 {
372 	int ret, i;
373 	__u8 data = 0x8;
374 
375 	set_register(pegasus, EthCtrl1, data);
376 	for (i = 0; i < REG_TIMEOUT; i++) {
377 		ret = get_registers(pegasus, EthCtrl1, 1, &data);
378 		if (ret < 0)
379 			goto fail;
380 		if (~data & 0x08) {
381 			if (loopback)
382 				break;
383 			if (mii_mode && (pegasus->features & HAS_HOME_PNA))
384 				set_register(pegasus, Gpio1, 0x34);
385 			else
386 				set_register(pegasus, Gpio1, 0x26);
387 			set_register(pegasus, Gpio0, pegasus->features);
388 			set_register(pegasus, Gpio0, DEFAULT_GPIO_SET);
389 			break;
390 		}
391 	}
392 	if (i == REG_TIMEOUT)
393 		return -ETIMEDOUT;
394 
395 	if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
396 	    usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
397 		set_register(pegasus, Gpio0, 0x24);
398 		set_register(pegasus, Gpio0, 0x26);
399 	}
400 	if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_ELCON) {
401 		__u16 auxmode;
402 		ret = read_mii_word(pegasus, 3, 0x1b, &auxmode);
403 		if (ret < 0)
404 			goto fail;
405 		auxmode |= 4;
406 		write_mii_word(pegasus, 3, 0x1b, &auxmode);
407 	}
408 
409 	return 0;
410 fail:
411 	netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
412 	return ret;
413 }
414 
enable_net_traffic(struct net_device * dev,struct usb_device * usb)415 static int enable_net_traffic(struct net_device *dev, struct usb_device *usb)
416 {
417 	pegasus_t *pegasus = netdev_priv(dev);
418 	int ret;
419 	__u16 linkpart;
420 	__u8 data[4];
421 
422 	ret = read_mii_word(pegasus, pegasus->phy, MII_LPA, &linkpart);
423 	if (ret < 0)
424 		goto fail;
425 	data[0] = 0xc8; /* TX & RX enable, append status, no CRC */
426 	data[1] = 0;
427 	if (linkpart & (ADVERTISE_100FULL | ADVERTISE_10FULL))
428 		data[1] |= 0x20;	/* set full duplex */
429 	if (linkpart & (ADVERTISE_100FULL | ADVERTISE_100HALF))
430 		data[1] |= 0x10;	/* set 100 Mbps */
431 	if (mii_mode)
432 		data[1] = 0;
433 	data[2] = loopback ? 0x09 : 0x01;
434 
435 	memcpy(pegasus->eth_regs, data, sizeof(data));
436 	ret = set_registers(pegasus, EthCtrl0, 3, data);
437 
438 	if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
439 	    usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS2 ||
440 	    usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
441 		u16 auxmode;
442 		ret = read_mii_word(pegasus, 0, 0x1b, &auxmode);
443 		if (ret < 0)
444 			goto fail;
445 		auxmode |= 4;
446 		write_mii_word(pegasus, 0, 0x1b, &auxmode);
447 	}
448 
449 	return ret;
450 fail:
451 	netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
452 	return ret;
453 }
454 
read_bulk_callback(struct urb * urb)455 static void read_bulk_callback(struct urb *urb)
456 {
457 	pegasus_t *pegasus = urb->context;
458 	struct net_device *net;
459 	u8 *buf = urb->transfer_buffer;
460 	int rx_status, count = urb->actual_length;
461 	int status = urb->status;
462 	__u16 pkt_len;
463 
464 	if (!pegasus)
465 		return;
466 
467 	net = pegasus->net;
468 	if (!netif_device_present(net) || !netif_running(net))
469 		return;
470 
471 	switch (status) {
472 	case 0:
473 		break;
474 	case -ETIME:
475 		netif_dbg(pegasus, rx_err, net, "reset MAC\n");
476 		pegasus->flags &= ~PEGASUS_RX_BUSY;
477 		break;
478 	case -EPIPE:		/* stall, or disconnect from TT */
479 		/* FIXME schedule work to clear the halt */
480 		netif_warn(pegasus, rx_err, net, "no rx stall recovery\n");
481 		return;
482 	case -ENOENT:
483 	case -ECONNRESET:
484 	case -ESHUTDOWN:
485 		netif_dbg(pegasus, ifdown, net, "rx unlink, %d\n", status);
486 		return;
487 	default:
488 		netif_dbg(pegasus, rx_err, net, "RX status %d\n", status);
489 		goto goon;
490 	}
491 
492 	if (count < 4)
493 		goto goon;
494 
495 	rx_status = buf[count - 2];
496 	if (rx_status & 0x1c) {
497 		netif_dbg(pegasus, rx_err, net,
498 			  "RX packet error %x\n", rx_status);
499 		net->stats.rx_errors++;
500 		if (rx_status & 0x04)	/* runt	*/
501 			net->stats.rx_length_errors++;
502 		if (rx_status & 0x08)
503 			net->stats.rx_crc_errors++;
504 		if (rx_status & 0x10)	/* extra bits	*/
505 			net->stats.rx_frame_errors++;
506 		goto goon;
507 	}
508 	if (pegasus->chip == 0x8513) {
509 		pkt_len = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
510 		pkt_len &= 0x0fff;
511 		pegasus->rx_skb->data += 2;
512 	} else {
513 		pkt_len = buf[count - 3] << 8;
514 		pkt_len += buf[count - 4];
515 		pkt_len &= 0xfff;
516 		pkt_len -= 4;
517 	}
518 
519 	/*
520 	 * If the packet is unreasonably long, quietly drop it rather than
521 	 * kernel panicing by calling skb_put.
522 	 */
523 	if (pkt_len > PEGASUS_MTU)
524 		goto goon;
525 
526 	/*
527 	 * at this point we are sure pegasus->rx_skb != NULL
528 	 * so we go ahead and pass up the packet.
529 	 */
530 	skb_put(pegasus->rx_skb, pkt_len);
531 	pegasus->rx_skb->protocol = eth_type_trans(pegasus->rx_skb, net);
532 	netif_rx(pegasus->rx_skb);
533 	net->stats.rx_packets++;
534 	net->stats.rx_bytes += pkt_len;
535 
536 	if (pegasus->flags & PEGASUS_UNPLUG)
537 		return;
538 
539 	pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net, PEGASUS_MTU,
540 						      GFP_ATOMIC);
541 
542 	if (pegasus->rx_skb == NULL)
543 		goto tl_sched;
544 goon:
545 	usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
546 			  usb_rcvbulkpipe(pegasus->usb, 1),
547 			  pegasus->rx_skb->data, PEGASUS_MTU,
548 			  read_bulk_callback, pegasus);
549 	rx_status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC);
550 	if (rx_status == -ENODEV)
551 		netif_device_detach(pegasus->net);
552 	else if (rx_status) {
553 		pegasus->flags |= PEGASUS_RX_URB_FAIL;
554 		goto tl_sched;
555 	} else {
556 		pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
557 	}
558 
559 	return;
560 
561 tl_sched:
562 	tasklet_schedule(&pegasus->rx_tl);
563 }
564 
rx_fixup(struct tasklet_struct * t)565 static void rx_fixup(struct tasklet_struct *t)
566 {
567 	pegasus_t *pegasus = from_tasklet(pegasus, t, rx_tl);
568 	int status;
569 
570 	if (pegasus->flags & PEGASUS_UNPLUG)
571 		return;
572 
573 	if (pegasus->flags & PEGASUS_RX_URB_FAIL)
574 		if (pegasus->rx_skb)
575 			goto try_again;
576 	if (pegasus->rx_skb == NULL)
577 		pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net,
578 							      PEGASUS_MTU,
579 							      GFP_ATOMIC);
580 	if (pegasus->rx_skb == NULL) {
581 		netif_warn(pegasus, rx_err, pegasus->net, "low on memory\n");
582 		tasklet_schedule(&pegasus->rx_tl);
583 		return;
584 	}
585 	usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
586 			  usb_rcvbulkpipe(pegasus->usb, 1),
587 			  pegasus->rx_skb->data, PEGASUS_MTU,
588 			  read_bulk_callback, pegasus);
589 try_again:
590 	status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC);
591 	if (status == -ENODEV)
592 		netif_device_detach(pegasus->net);
593 	else if (status) {
594 		pegasus->flags |= PEGASUS_RX_URB_FAIL;
595 		tasklet_schedule(&pegasus->rx_tl);
596 	} else {
597 		pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
598 	}
599 }
600 
write_bulk_callback(struct urb * urb)601 static void write_bulk_callback(struct urb *urb)
602 {
603 	pegasus_t *pegasus = urb->context;
604 	struct net_device *net;
605 	int status = urb->status;
606 
607 	if (!pegasus)
608 		return;
609 
610 	net = pegasus->net;
611 
612 	if (!netif_device_present(net) || !netif_running(net))
613 		return;
614 
615 	switch (status) {
616 	case -EPIPE:
617 		/* FIXME schedule_work() to clear the tx halt */
618 		netif_stop_queue(net);
619 		netif_warn(pegasus, tx_err, net, "no tx stall recovery\n");
620 		return;
621 	case -ENOENT:
622 	case -ECONNRESET:
623 	case -ESHUTDOWN:
624 		netif_dbg(pegasus, ifdown, net, "tx unlink, %d\n", status);
625 		return;
626 	default:
627 		netif_info(pegasus, tx_err, net, "TX status %d\n", status);
628 		fallthrough;
629 	case 0:
630 		break;
631 	}
632 
633 	netif_trans_update(net); /* prevent tx timeout */
634 	netif_wake_queue(net);
635 }
636 
intr_callback(struct urb * urb)637 static void intr_callback(struct urb *urb)
638 {
639 	pegasus_t *pegasus = urb->context;
640 	struct net_device *net;
641 	int res, status = urb->status;
642 
643 	if (!pegasus)
644 		return;
645 	net = pegasus->net;
646 
647 	switch (status) {
648 	case 0:
649 		break;
650 	case -ECONNRESET:	/* unlink */
651 	case -ENOENT:
652 	case -ESHUTDOWN:
653 		return;
654 	default:
655 		/* some Pegasus-I products report LOTS of data
656 		 * toggle errors... avoid log spamming
657 		 */
658 		netif_dbg(pegasus, timer, net, "intr status %d\n", status);
659 	}
660 
661 	if (urb->actual_length >= 6) {
662 		u8 *d = urb->transfer_buffer;
663 
664 		/* byte 0 == tx_status1, reg 2B */
665 		if (d[0] & (TX_UNDERRUN|EXCESSIVE_COL
666 					|LATE_COL|JABBER_TIMEOUT)) {
667 			net->stats.tx_errors++;
668 			if (d[0] & TX_UNDERRUN)
669 				net->stats.tx_fifo_errors++;
670 			if (d[0] & (EXCESSIVE_COL | JABBER_TIMEOUT))
671 				net->stats.tx_aborted_errors++;
672 			if (d[0] & LATE_COL)
673 				net->stats.tx_window_errors++;
674 		}
675 
676 		/* d[5].LINK_STATUS lies on some adapters.
677 		 * d[0].NO_CARRIER kicks in only with failed TX.
678 		 * ... so monitoring with MII may be safest.
679 		 */
680 
681 		/* bytes 3-4 == rx_lostpkt, reg 2E/2F */
682 		net->stats.rx_missed_errors += ((d[3] & 0x7f) << 8) | d[4];
683 	}
684 
685 	res = usb_submit_urb(urb, GFP_ATOMIC);
686 	if (res == -ENODEV)
687 		netif_device_detach(pegasus->net);
688 	if (res)
689 		netif_err(pegasus, timer, net,
690 			  "can't resubmit interrupt urb, %d\n", res);
691 }
692 
pegasus_tx_timeout(struct net_device * net,unsigned int txqueue)693 static void pegasus_tx_timeout(struct net_device *net, unsigned int txqueue)
694 {
695 	pegasus_t *pegasus = netdev_priv(net);
696 	netif_warn(pegasus, timer, net, "tx timeout\n");
697 	usb_unlink_urb(pegasus->tx_urb);
698 	net->stats.tx_errors++;
699 }
700 
pegasus_start_xmit(struct sk_buff * skb,struct net_device * net)701 static netdev_tx_t pegasus_start_xmit(struct sk_buff *skb,
702 					    struct net_device *net)
703 {
704 	pegasus_t *pegasus = netdev_priv(net);
705 	int count = ((skb->len + 2) & 0x3f) ? skb->len + 2 : skb->len + 3;
706 	int res;
707 	__u16 l16 = skb->len;
708 
709 	netif_stop_queue(net);
710 
711 	((__le16 *) pegasus->tx_buff)[0] = cpu_to_le16(l16);
712 	skb_copy_from_linear_data(skb, pegasus->tx_buff + 2, skb->len);
713 	usb_fill_bulk_urb(pegasus->tx_urb, pegasus->usb,
714 			  usb_sndbulkpipe(pegasus->usb, 2),
715 			  pegasus->tx_buff, count,
716 			  write_bulk_callback, pegasus);
717 	if ((res = usb_submit_urb(pegasus->tx_urb, GFP_ATOMIC))) {
718 		netif_warn(pegasus, tx_err, net, "fail tx, %d\n", res);
719 		switch (res) {
720 		case -EPIPE:		/* stall, or disconnect from TT */
721 			/* cleanup should already have been scheduled */
722 			break;
723 		case -ENODEV:		/* disconnect() upcoming */
724 		case -EPERM:
725 			netif_device_detach(pegasus->net);
726 			break;
727 		default:
728 			net->stats.tx_errors++;
729 			netif_start_queue(net);
730 		}
731 	} else {
732 		net->stats.tx_packets++;
733 		net->stats.tx_bytes += skb->len;
734 	}
735 	dev_kfree_skb(skb);
736 
737 	return NETDEV_TX_OK;
738 }
739 
disable_net_traffic(pegasus_t * pegasus)740 static inline void disable_net_traffic(pegasus_t *pegasus)
741 {
742 	__le16 tmp = cpu_to_le16(0);
743 
744 	set_registers(pegasus, EthCtrl0, sizeof(tmp), &tmp);
745 }
746 
get_interrupt_interval(pegasus_t * pegasus)747 static inline int get_interrupt_interval(pegasus_t *pegasus)
748 {
749 	u16 data;
750 	u8 interval;
751 	int ret;
752 
753 	ret = read_eprom_word(pegasus, 4, &data);
754 	if (ret < 0)
755 		return ret;
756 
757 	interval = data >> 8;
758 	if (pegasus->usb->speed != USB_SPEED_HIGH) {
759 		if (interval < 0x80) {
760 			netif_info(pegasus, timer, pegasus->net,
761 				   "intr interval changed from %ums to %ums\n",
762 				   interval, 0x80);
763 			interval = 0x80;
764 			data = (data & 0x00FF) | ((u16)interval << 8);
765 #ifdef PEGASUS_WRITE_EEPROM
766 			write_eprom_word(pegasus, 4, data);
767 #endif
768 		}
769 	}
770 	pegasus->intr_interval = interval;
771 
772 	return 0;
773 }
774 
set_carrier(struct net_device * net)775 static void set_carrier(struct net_device *net)
776 {
777 	pegasus_t *pegasus = netdev_priv(net);
778 	u16 tmp;
779 
780 	if (read_mii_word(pegasus, pegasus->phy, MII_BMSR, &tmp))
781 		return;
782 
783 	if (tmp & BMSR_LSTATUS)
784 		netif_carrier_on(net);
785 	else
786 		netif_carrier_off(net);
787 }
788 
free_all_urbs(pegasus_t * pegasus)789 static void free_all_urbs(pegasus_t *pegasus)
790 {
791 	usb_free_urb(pegasus->intr_urb);
792 	usb_free_urb(pegasus->tx_urb);
793 	usb_free_urb(pegasus->rx_urb);
794 }
795 
unlink_all_urbs(pegasus_t * pegasus)796 static void unlink_all_urbs(pegasus_t *pegasus)
797 {
798 	usb_kill_urb(pegasus->intr_urb);
799 	usb_kill_urb(pegasus->tx_urb);
800 	usb_kill_urb(pegasus->rx_urb);
801 }
802 
alloc_urbs(pegasus_t * pegasus)803 static int alloc_urbs(pegasus_t *pegasus)
804 {
805 	int res = -ENOMEM;
806 
807 	pegasus->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
808 	if (!pegasus->rx_urb) {
809 		return res;
810 	}
811 	pegasus->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
812 	if (!pegasus->tx_urb) {
813 		usb_free_urb(pegasus->rx_urb);
814 		return res;
815 	}
816 	pegasus->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
817 	if (!pegasus->intr_urb) {
818 		usb_free_urb(pegasus->tx_urb);
819 		usb_free_urb(pegasus->rx_urb);
820 		return res;
821 	}
822 
823 	return 0;
824 }
825 
pegasus_open(struct net_device * net)826 static int pegasus_open(struct net_device *net)
827 {
828 	pegasus_t *pegasus = netdev_priv(net);
829 	int res=-ENOMEM;
830 
831 	if (pegasus->rx_skb == NULL)
832 		pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net,
833 							      PEGASUS_MTU,
834 							      GFP_KERNEL);
835 	if (!pegasus->rx_skb)
836 		goto exit;
837 
838 	set_registers(pegasus, EthID, 6, net->dev_addr);
839 
840 	usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
841 			  usb_rcvbulkpipe(pegasus->usb, 1),
842 			  pegasus->rx_skb->data, PEGASUS_MTU,
843 			  read_bulk_callback, pegasus);
844 	if ((res = usb_submit_urb(pegasus->rx_urb, GFP_KERNEL))) {
845 		if (res == -ENODEV)
846 			netif_device_detach(pegasus->net);
847 		netif_dbg(pegasus, ifup, net, "failed rx_urb, %d\n", res);
848 		goto exit;
849 	}
850 
851 	usb_fill_int_urb(pegasus->intr_urb, pegasus->usb,
852 			 usb_rcvintpipe(pegasus->usb, 3),
853 			 pegasus->intr_buff, sizeof(pegasus->intr_buff),
854 			 intr_callback, pegasus, pegasus->intr_interval);
855 	if ((res = usb_submit_urb(pegasus->intr_urb, GFP_KERNEL))) {
856 		if (res == -ENODEV)
857 			netif_device_detach(pegasus->net);
858 		netif_dbg(pegasus, ifup, net, "failed intr_urb, %d\n", res);
859 		usb_kill_urb(pegasus->rx_urb);
860 		goto exit;
861 	}
862 	res = enable_net_traffic(net, pegasus->usb);
863 	if (res < 0) {
864 		netif_dbg(pegasus, ifup, net,
865 			  "can't enable_net_traffic() - %d\n", res);
866 		res = -EIO;
867 		usb_kill_urb(pegasus->rx_urb);
868 		usb_kill_urb(pegasus->intr_urb);
869 		goto exit;
870 	}
871 	set_carrier(net);
872 	netif_start_queue(net);
873 	netif_dbg(pegasus, ifup, net, "open\n");
874 	res = 0;
875 exit:
876 	return res;
877 }
878 
pegasus_close(struct net_device * net)879 static int pegasus_close(struct net_device *net)
880 {
881 	pegasus_t *pegasus = netdev_priv(net);
882 
883 	netif_stop_queue(net);
884 	if (!(pegasus->flags & PEGASUS_UNPLUG))
885 		disable_net_traffic(pegasus);
886 	tasklet_kill(&pegasus->rx_tl);
887 	unlink_all_urbs(pegasus);
888 
889 	return 0;
890 }
891 
pegasus_get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * info)892 static void pegasus_get_drvinfo(struct net_device *dev,
893 				struct ethtool_drvinfo *info)
894 {
895 	pegasus_t *pegasus = netdev_priv(dev);
896 
897 	strscpy(info->driver, driver_name, sizeof(info->driver));
898 	usb_make_path(pegasus->usb, info->bus_info, sizeof(info->bus_info));
899 }
900 
901 /* also handles three patterns of some kind in hardware */
902 #define	WOL_SUPPORTED	(WAKE_MAGIC|WAKE_PHY)
903 
904 static void
pegasus_get_wol(struct net_device * dev,struct ethtool_wolinfo * wol)905 pegasus_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
906 {
907 	pegasus_t	*pegasus = netdev_priv(dev);
908 
909 	wol->supported = WAKE_MAGIC | WAKE_PHY;
910 	wol->wolopts = pegasus->wolopts;
911 }
912 
913 static int
pegasus_set_wol(struct net_device * dev,struct ethtool_wolinfo * wol)914 pegasus_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
915 {
916 	pegasus_t	*pegasus = netdev_priv(dev);
917 	u8		reg78 = 0x04;
918 	int		ret;
919 
920 	if (wol->wolopts & ~WOL_SUPPORTED)
921 		return -EINVAL;
922 
923 	if (wol->wolopts & WAKE_MAGIC)
924 		reg78 |= 0x80;
925 	if (wol->wolopts & WAKE_PHY)
926 		reg78 |= 0x40;
927 	/* FIXME this 0x10 bit still needs to get set in the chip... */
928 	if (wol->wolopts)
929 		pegasus->eth_regs[0] |= 0x10;
930 	else
931 		pegasus->eth_regs[0] &= ~0x10;
932 	pegasus->wolopts = wol->wolopts;
933 
934 	ret = set_register(pegasus, WakeupControl, reg78);
935 	if (!ret)
936 		ret = device_set_wakeup_enable(&pegasus->usb->dev,
937 						wol->wolopts);
938 	return ret;
939 }
940 
pegasus_reset_wol(struct net_device * dev)941 static inline void pegasus_reset_wol(struct net_device *dev)
942 {
943 	struct ethtool_wolinfo wol;
944 
945 	memset(&wol, 0, sizeof wol);
946 	(void) pegasus_set_wol(dev, &wol);
947 }
948 
949 static int
pegasus_get_link_ksettings(struct net_device * dev,struct ethtool_link_ksettings * ecmd)950 pegasus_get_link_ksettings(struct net_device *dev,
951 			   struct ethtool_link_ksettings *ecmd)
952 {
953 	pegasus_t *pegasus;
954 
955 	pegasus = netdev_priv(dev);
956 	mii_ethtool_get_link_ksettings(&pegasus->mii, ecmd);
957 	return 0;
958 }
959 
960 static int
pegasus_set_link_ksettings(struct net_device * dev,const struct ethtool_link_ksettings * ecmd)961 pegasus_set_link_ksettings(struct net_device *dev,
962 			   const struct ethtool_link_ksettings *ecmd)
963 {
964 	pegasus_t *pegasus = netdev_priv(dev);
965 	return mii_ethtool_set_link_ksettings(&pegasus->mii, ecmd);
966 }
967 
pegasus_nway_reset(struct net_device * dev)968 static int pegasus_nway_reset(struct net_device *dev)
969 {
970 	pegasus_t *pegasus = netdev_priv(dev);
971 	return mii_nway_restart(&pegasus->mii);
972 }
973 
pegasus_get_link(struct net_device * dev)974 static u32 pegasus_get_link(struct net_device *dev)
975 {
976 	pegasus_t *pegasus = netdev_priv(dev);
977 	return mii_link_ok(&pegasus->mii);
978 }
979 
pegasus_get_msglevel(struct net_device * dev)980 static u32 pegasus_get_msglevel(struct net_device *dev)
981 {
982 	pegasus_t *pegasus = netdev_priv(dev);
983 	return pegasus->msg_enable;
984 }
985 
pegasus_set_msglevel(struct net_device * dev,u32 v)986 static void pegasus_set_msglevel(struct net_device *dev, u32 v)
987 {
988 	pegasus_t *pegasus = netdev_priv(dev);
989 	pegasus->msg_enable = v;
990 }
991 
992 static const struct ethtool_ops ops = {
993 	.get_drvinfo = pegasus_get_drvinfo,
994 	.nway_reset = pegasus_nway_reset,
995 	.get_link = pegasus_get_link,
996 	.get_msglevel = pegasus_get_msglevel,
997 	.set_msglevel = pegasus_set_msglevel,
998 	.get_wol = pegasus_get_wol,
999 	.set_wol = pegasus_set_wol,
1000 	.get_link_ksettings = pegasus_get_link_ksettings,
1001 	.set_link_ksettings = pegasus_set_link_ksettings,
1002 };
1003 
pegasus_siocdevprivate(struct net_device * net,struct ifreq * rq,void __user * udata,int cmd)1004 static int pegasus_siocdevprivate(struct net_device *net, struct ifreq *rq,
1005 				  void __user *udata, int cmd)
1006 {
1007 	__u16 *data = (__u16 *) &rq->ifr_ifru;
1008 	pegasus_t *pegasus = netdev_priv(net);
1009 	int res;
1010 
1011 	switch (cmd) {
1012 	case SIOCDEVPRIVATE:
1013 		data[0] = pegasus->phy;
1014 		fallthrough;
1015 	case SIOCDEVPRIVATE + 1:
1016 		res = read_mii_word(pegasus, data[0], data[1] & 0x1f, &data[3]);
1017 		break;
1018 	case SIOCDEVPRIVATE + 2:
1019 		if (!capable(CAP_NET_ADMIN))
1020 			return -EPERM;
1021 		write_mii_word(pegasus, pegasus->phy, data[1] & 0x1f, &data[2]);
1022 		res = 0;
1023 		break;
1024 	default:
1025 		res = -EOPNOTSUPP;
1026 	}
1027 	return res;
1028 }
1029 
pegasus_set_multicast(struct net_device * net)1030 static void pegasus_set_multicast(struct net_device *net)
1031 {
1032 	pegasus_t *pegasus = netdev_priv(net);
1033 
1034 	if (net->flags & IFF_PROMISC) {
1035 		pegasus->eth_regs[EthCtrl2] |= RX_PROMISCUOUS;
1036 		netif_info(pegasus, link, net, "Promiscuous mode enabled\n");
1037 	} else if (!netdev_mc_empty(net) || (net->flags & IFF_ALLMULTI)) {
1038 		pegasus->eth_regs[EthCtrl0] |= RX_MULTICAST;
1039 		pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
1040 		netif_dbg(pegasus, link, net, "set allmulti\n");
1041 	} else {
1042 		pegasus->eth_regs[EthCtrl0] &= ~RX_MULTICAST;
1043 		pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
1044 	}
1045 	update_eth_regs_async(pegasus);
1046 }
1047 
mii_phy_probe(pegasus_t * pegasus)1048 static __u8 mii_phy_probe(pegasus_t *pegasus)
1049 {
1050 	int i, ret;
1051 	__u16 tmp;
1052 
1053 	for (i = 0; i < 32; i++) {
1054 		ret = read_mii_word(pegasus, i, MII_BMSR, &tmp);
1055 		if (ret < 0)
1056 			goto fail;
1057 		if (tmp == 0 || tmp == 0xffff || (tmp & BMSR_MEDIA) == 0)
1058 			continue;
1059 		else
1060 			return i;
1061 	}
1062 fail:
1063 	return 0xff;
1064 }
1065 
setup_pegasus_II(pegasus_t * pegasus)1066 static inline void setup_pegasus_II(pegasus_t *pegasus)
1067 {
1068 	int ret;
1069 	__u8 data = 0xa5;
1070 
1071 	set_register(pegasus, Reg1d, 0);
1072 	set_register(pegasus, Reg7b, 1);
1073 	msleep(100);
1074 	if ((pegasus->features & HAS_HOME_PNA) && mii_mode)
1075 		set_register(pegasus, Reg7b, 0);
1076 	else
1077 		set_register(pegasus, Reg7b, 2);
1078 
1079 	set_register(pegasus, 0x83, data);
1080 	ret = get_registers(pegasus, 0x83, 1, &data);
1081 	if (ret < 0)
1082 		goto fail;
1083 
1084 	if (data == 0xa5)
1085 		pegasus->chip = 0x8513;
1086 	else
1087 		pegasus->chip = 0;
1088 
1089 	set_register(pegasus, 0x80, 0xc0);
1090 	set_register(pegasus, 0x83, 0xff);
1091 	set_register(pegasus, 0x84, 0x01);
1092 
1093 	if (pegasus->features & HAS_HOME_PNA && mii_mode)
1094 		set_register(pegasus, Reg81, 6);
1095 	else
1096 		set_register(pegasus, Reg81, 2);
1097 
1098 	return;
1099 fail:
1100 	netif_dbg(pegasus, drv, pegasus->net, "%s failed\n", __func__);
1101 }
1102 
check_carrier(struct work_struct * work)1103 static void check_carrier(struct work_struct *work)
1104 {
1105 	pegasus_t *pegasus = container_of(work, pegasus_t, carrier_check.work);
1106 	set_carrier(pegasus->net);
1107 	if (!(pegasus->flags & PEGASUS_UNPLUG)) {
1108 		queue_delayed_work(system_long_wq, &pegasus->carrier_check,
1109 			CARRIER_CHECK_DELAY);
1110 	}
1111 }
1112 
pegasus_blacklisted(struct usb_device * udev)1113 static int pegasus_blacklisted(struct usb_device *udev)
1114 {
1115 	struct usb_device_descriptor *udd = &udev->descriptor;
1116 
1117 	/* Special quirk to keep the driver from handling the Belkin Bluetooth
1118 	 * dongle which happens to have the same ID.
1119 	 */
1120 	if ((udd->idVendor == cpu_to_le16(VENDOR_BELKIN)) &&
1121 	    (udd->idProduct == cpu_to_le16(0x0121)) &&
1122 	    (udd->bDeviceClass == USB_CLASS_WIRELESS_CONTROLLER) &&
1123 	    (udd->bDeviceProtocol == 1))
1124 		return 1;
1125 
1126 	return 0;
1127 }
1128 
pegasus_probe(struct usb_interface * intf,const struct usb_device_id * id)1129 static int pegasus_probe(struct usb_interface *intf,
1130 			 const struct usb_device_id *id)
1131 {
1132 	struct usb_device *dev = interface_to_usbdev(intf);
1133 	struct net_device *net;
1134 	pegasus_t *pegasus;
1135 	int dev_index = id - pegasus_ids;
1136 	int res = -ENOMEM;
1137 
1138 	if (pegasus_blacklisted(dev))
1139 		return -ENODEV;
1140 
1141 	net = alloc_etherdev(sizeof(struct pegasus));
1142 	if (!net)
1143 		goto out;
1144 
1145 	pegasus = netdev_priv(net);
1146 	pegasus->dev_index = dev_index;
1147 
1148 	res = alloc_urbs(pegasus);
1149 	if (res < 0) {
1150 		dev_err(&intf->dev, "can't allocate %s\n", "urbs");
1151 		goto out1;
1152 	}
1153 
1154 	tasklet_setup(&pegasus->rx_tl, rx_fixup);
1155 
1156 	INIT_DELAYED_WORK(&pegasus->carrier_check, check_carrier);
1157 
1158 	pegasus->intf = intf;
1159 	pegasus->usb = dev;
1160 	pegasus->net = net;
1161 
1162 
1163 	net->watchdog_timeo = PEGASUS_TX_TIMEOUT;
1164 	net->netdev_ops = &pegasus_netdev_ops;
1165 	net->ethtool_ops = &ops;
1166 	pegasus->mii.dev = net;
1167 	pegasus->mii.mdio_read = mdio_read;
1168 	pegasus->mii.mdio_write = mdio_write;
1169 	pegasus->mii.phy_id_mask = 0x1f;
1170 	pegasus->mii.reg_num_mask = 0x1f;
1171 	pegasus->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
1172 				| NETIF_MSG_PROBE | NETIF_MSG_LINK);
1173 
1174 	pegasus->features = usb_dev_id[dev_index].private;
1175 	res = get_interrupt_interval(pegasus);
1176 	if (res)
1177 		goto out2;
1178 	if (reset_mac(pegasus)) {
1179 		dev_err(&intf->dev, "can't reset MAC\n");
1180 		res = -EIO;
1181 		goto out2;
1182 	}
1183 	set_ethernet_addr(pegasus);
1184 	if (pegasus->features & PEGASUS_II) {
1185 		dev_info(&intf->dev, "setup Pegasus II specific registers\n");
1186 		setup_pegasus_II(pegasus);
1187 	}
1188 	pegasus->phy = mii_phy_probe(pegasus);
1189 	if (pegasus->phy == 0xff) {
1190 		dev_warn(&intf->dev, "can't locate MII phy, using default\n");
1191 		pegasus->phy = 1;
1192 	}
1193 	pegasus->mii.phy_id = pegasus->phy;
1194 	usb_set_intfdata(intf, pegasus);
1195 	SET_NETDEV_DEV(net, &intf->dev);
1196 	pegasus_reset_wol(net);
1197 	res = register_netdev(net);
1198 	if (res)
1199 		goto out3;
1200 	queue_delayed_work(system_long_wq, &pegasus->carrier_check,
1201 			   CARRIER_CHECK_DELAY);
1202 	dev_info(&intf->dev, "%s, %s, %pM\n", net->name,
1203 		 usb_dev_id[dev_index].name, net->dev_addr);
1204 	return 0;
1205 
1206 out3:
1207 	usb_set_intfdata(intf, NULL);
1208 out2:
1209 	free_all_urbs(pegasus);
1210 out1:
1211 	free_netdev(net);
1212 out:
1213 	return res;
1214 }
1215 
pegasus_disconnect(struct usb_interface * intf)1216 static void pegasus_disconnect(struct usb_interface *intf)
1217 {
1218 	struct pegasus *pegasus = usb_get_intfdata(intf);
1219 
1220 	usb_set_intfdata(intf, NULL);
1221 	if (!pegasus) {
1222 		dev_dbg(&intf->dev, "unregistering non-bound device?\n");
1223 		return;
1224 	}
1225 
1226 	pegasus->flags |= PEGASUS_UNPLUG;
1227 	cancel_delayed_work_sync(&pegasus->carrier_check);
1228 	unregister_netdev(pegasus->net);
1229 	unlink_all_urbs(pegasus);
1230 	free_all_urbs(pegasus);
1231 	if (pegasus->rx_skb != NULL) {
1232 		dev_kfree_skb(pegasus->rx_skb);
1233 		pegasus->rx_skb = NULL;
1234 	}
1235 	free_netdev(pegasus->net);
1236 }
1237 
pegasus_suspend(struct usb_interface * intf,pm_message_t message)1238 static int pegasus_suspend(struct usb_interface *intf, pm_message_t message)
1239 {
1240 	struct pegasus *pegasus = usb_get_intfdata(intf);
1241 
1242 	netif_device_detach(pegasus->net);
1243 	cancel_delayed_work_sync(&pegasus->carrier_check);
1244 	if (netif_running(pegasus->net)) {
1245 		usb_kill_urb(pegasus->rx_urb);
1246 		usb_kill_urb(pegasus->intr_urb);
1247 	}
1248 	return 0;
1249 }
1250 
pegasus_resume(struct usb_interface * intf)1251 static int pegasus_resume(struct usb_interface *intf)
1252 {
1253 	struct pegasus *pegasus = usb_get_intfdata(intf);
1254 
1255 	netif_device_attach(pegasus->net);
1256 	if (netif_running(pegasus->net)) {
1257 		pegasus->rx_urb->status = 0;
1258 		pegasus->rx_urb->actual_length = 0;
1259 		read_bulk_callback(pegasus->rx_urb);
1260 
1261 		pegasus->intr_urb->status = 0;
1262 		pegasus->intr_urb->actual_length = 0;
1263 		intr_callback(pegasus->intr_urb);
1264 	}
1265 	queue_delayed_work(system_long_wq, &pegasus->carrier_check,
1266 				CARRIER_CHECK_DELAY);
1267 	return 0;
1268 }
1269 
1270 static const struct net_device_ops pegasus_netdev_ops = {
1271 	.ndo_open =			pegasus_open,
1272 	.ndo_stop =			pegasus_close,
1273 	.ndo_siocdevprivate =		pegasus_siocdevprivate,
1274 	.ndo_start_xmit =		pegasus_start_xmit,
1275 	.ndo_set_rx_mode =		pegasus_set_multicast,
1276 	.ndo_tx_timeout =		pegasus_tx_timeout,
1277 	.ndo_set_mac_address =		eth_mac_addr,
1278 	.ndo_validate_addr =		eth_validate_addr,
1279 };
1280 
1281 static struct usb_driver pegasus_driver = {
1282 	.name = driver_name,
1283 	.probe = pegasus_probe,
1284 	.disconnect = pegasus_disconnect,
1285 	.id_table = pegasus_ids,
1286 	.suspend = pegasus_suspend,
1287 	.resume = pegasus_resume,
1288 	.disable_hub_initiated_lpm = 1,
1289 };
1290 
parse_id(char * id)1291 static void __init parse_id(char *id)
1292 {
1293 	unsigned int vendor_id = 0, device_id = 0, flags = 0, i = 0;
1294 	char *token, *name = NULL;
1295 
1296 	if ((token = strsep(&id, ":")) != NULL)
1297 		name = token;
1298 	/* name now points to a null terminated string*/
1299 	if ((token = strsep(&id, ":")) != NULL)
1300 		vendor_id = simple_strtoul(token, NULL, 16);
1301 	if ((token = strsep(&id, ":")) != NULL)
1302 		device_id = simple_strtoul(token, NULL, 16);
1303 	flags = simple_strtoul(id, NULL, 16);
1304 	pr_info("%s: new device %s, vendor ID 0x%04x, device ID 0x%04x, flags: 0x%x\n",
1305 		driver_name, name, vendor_id, device_id, flags);
1306 
1307 	if (vendor_id > 0x10000 || vendor_id == 0)
1308 		return;
1309 	if (device_id > 0x10000 || device_id == 0)
1310 		return;
1311 
1312 	for (i = 0; usb_dev_id[i].name; i++);
1313 	usb_dev_id[i].name = name;
1314 	usb_dev_id[i].vendor = vendor_id;
1315 	usb_dev_id[i].device = device_id;
1316 	usb_dev_id[i].private = flags;
1317 	pegasus_ids[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
1318 	pegasus_ids[i].idVendor = vendor_id;
1319 	pegasus_ids[i].idProduct = device_id;
1320 }
1321 
pegasus_init(void)1322 static int __init pegasus_init(void)
1323 {
1324 	pr_info("%s: " DRIVER_DESC "\n", driver_name);
1325 	if (devid)
1326 		parse_id(devid);
1327 	return usb_register(&pegasus_driver);
1328 }
1329 
pegasus_exit(void)1330 static void __exit pegasus_exit(void)
1331 {
1332 	usb_deregister(&pegasus_driver);
1333 }
1334 
1335 module_init(pegasus_init);
1336 module_exit(pegasus_exit);
1337