2 * Copyright (c) 1999-2005 Petko Manolov (petkan@users.sourceforge.net)
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
9 * .... Most of the time spent on reading sources & docs.
10 * v0.2.x First official release for the Linux kernel.
11 * v0.3.0 Beutified and structured, some bugs fixed.
12 * v0.3.x URBifying bulk requests and bugfixing. First relatively
13 * stable release. Still can touch device's registers only
15 * v0.4.0 Control messages remained unurbified are now URBs.
16 * Now we can touch the HW at any time.
17 * v0.4.9 Control urbs again use process context to wait. Argh...
18 * Some long standing bugs (enable_net_traffic) fixed.
19 * Also nasty trick about resubmiting control urb from
20 * interrupt context used. Please let me know how it
21 * behaves. Pegasus II support added since this version.
22 * TODO: suppressing HCD warnings spewage on disconnect.
23 * v0.4.13 Ethernet address is now set at probe(), not at open()
24 * time as this seems to break dhcpd.
25 * v0.5.0 branch to 2.5.x kernels
26 * v0.5.1 ethtool support added
27 * v0.5.5 rx socket buffers are in a pool and the their allocation
28 * is out of the interrupt routine.
31 #include <linux/sched.h>
32 #include <linux/slab.h>
33 #include <linux/init.h>
34 #include <linux/delay.h>
35 #include <linux/netdevice.h>
36 #include <linux/etherdevice.h>
37 #include <linux/ethtool.h>
38 #include <linux/mii.h>
39 #include <linux/usb.h>
40 #include <linux/module.h>
41 #include <asm/byteorder.h>
42 #include <asm/uaccess.h>
48 #define DRIVER_VERSION "v0.6.14 (2006/09/27)"
49 #define DRIVER_AUTHOR "Petko Manolov <petkan@users.sourceforge.net>"
50 #define DRIVER_DESC "Pegasus/Pegasus II USB Ethernet driver"
52 static const char driver_name
[] = "pegasus";
54 #undef PEGASUS_WRITE_EEPROM
55 #define BMSR_MEDIA (BMSR_10HALF | BMSR_10FULL | BMSR_100HALF | \
56 BMSR_100FULL | BMSR_ANEGCAPABLE)
62 static struct usb_eth_dev usb_dev_id
[] = {
63 #define PEGASUS_DEV(pn, vid, pid, flags) \
64 {.name = pn, .vendor = vid, .device = pid, .private = flags},
65 #define PEGASUS_DEV_CLASS(pn, vid, pid, dclass, flags) \
66 PEGASUS_DEV(pn, vid, pid, flags)
69 #undef PEGASUS_DEV_CLASS
74 static struct usb_device_id pegasus_ids
[] = {
75 #define PEGASUS_DEV(pn, vid, pid, flags) \
76 {.match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = vid, .idProduct = pid},
78 * The Belkin F8T012xx1 bluetooth adaptor has the same vendor and product
79 * IDs as the Belkin F5D5050, so we need to teach the pegasus driver to
80 * ignore adaptors belonging to the "Wireless" class 0xE0. For this one
81 * case anyway, seeing as the pegasus is for "Wired" adaptors.
83 #define PEGASUS_DEV_CLASS(pn, vid, pid, dclass, flags) \
84 {.match_flags = (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_CLASS), \
85 .idVendor = vid, .idProduct = pid, .bDeviceClass = dclass},
88 #undef PEGASUS_DEV_CLASS
93 MODULE_AUTHOR(DRIVER_AUTHOR
);
94 MODULE_DESCRIPTION(DRIVER_DESC
);
95 MODULE_LICENSE("GPL");
96 module_param(loopback
, bool, 0);
97 module_param(mii_mode
, bool, 0);
98 module_param(devid
, charp
, 0);
99 MODULE_PARM_DESC(loopback
, "Enable MAC loopback mode (bit 0)");
100 MODULE_PARM_DESC(mii_mode
, "Enable HomePNA mode (bit 0),default=MII mode = 0");
101 MODULE_PARM_DESC(devid
, "The format is: 'DEV_name:VendorID:DeviceID:Flags'");
103 /* use ethtool to change the level for any given device */
104 static int msg_level
= -1;
105 module_param(msg_level
, int, 0);
106 MODULE_PARM_DESC(msg_level
, "Override default message level");
108 MODULE_DEVICE_TABLE(usb
, pegasus_ids
);
109 static const struct net_device_ops pegasus_netdev_ops
;
111 static int update_eth_regs_async(pegasus_t
*);
112 /* Aargh!!! I _really_ hate such tweaks */
113 static void ctrl_callback(struct urb
*urb
)
115 pegasus_t
*pegasus
= urb
->context
;
116 int status
= urb
->status
;
123 if (pegasus
->flags
& ETH_REGS_CHANGE
) {
124 pegasus
->flags
&= ~ETH_REGS_CHANGE
;
125 pegasus
->flags
|= ETH_REGS_CHANGED
;
126 update_eth_regs_async(pegasus
);
136 netif_dbg(pegasus
, drv
, pegasus
->net
,
137 "%s, status %d\n", __func__
, status
);
140 pegasus
->flags
&= ~ETH_REGS_CHANGED
;
141 wake_up(&pegasus
->ctrl_wait
);
144 static int get_registers(pegasus_t
*pegasus
, __u16 indx
, __u16 size
,
149 DECLARE_WAITQUEUE(wait
, current
);
151 buffer
= kmalloc(size
, GFP_KERNEL
);
153 netif_warn(pegasus
, drv
, pegasus
->net
,
154 "out of memory in %s\n", __func__
);
157 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
158 set_current_state(TASK_UNINTERRUPTIBLE
);
159 while (pegasus
->flags
& ETH_REGS_CHANGED
)
161 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
162 set_current_state(TASK_RUNNING
);
164 pegasus
->dr
.bRequestType
= PEGASUS_REQT_READ
;
165 pegasus
->dr
.bRequest
= PEGASUS_REQ_GET_REGS
;
166 pegasus
->dr
.wValue
= cpu_to_le16(0);
167 pegasus
->dr
.wIndex
= cpu_to_le16(indx
);
168 pegasus
->dr
.wLength
= cpu_to_le16(size
);
169 pegasus
->ctrl_urb
->transfer_buffer_length
= size
;
171 usb_fill_control_urb(pegasus
->ctrl_urb
, pegasus
->usb
,
172 usb_rcvctrlpipe(pegasus
->usb
, 0),
173 (char *) &pegasus
->dr
,
174 buffer
, size
, ctrl_callback
, pegasus
);
176 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
177 set_current_state(TASK_UNINTERRUPTIBLE
);
179 /* using ATOMIC, we'd never wake up if we slept */
180 if ((ret
= usb_submit_urb(pegasus
->ctrl_urb
, GFP_ATOMIC
))) {
181 set_current_state(TASK_RUNNING
);
183 netif_device_detach(pegasus
->net
);
185 netif_err(pegasus
, drv
, pegasus
->net
,
186 "%s, status %d\n", __func__
, ret
);
192 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
193 memcpy(data
, buffer
, size
);
199 static int set_registers(pegasus_t
*pegasus
, __u16 indx
, __u16 size
,
204 DECLARE_WAITQUEUE(wait
, current
);
206 buffer
= kmemdup(data
, size
, GFP_KERNEL
);
208 netif_warn(pegasus
, drv
, pegasus
->net
,
209 "out of memory in %s\n", __func__
);
213 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
214 set_current_state(TASK_UNINTERRUPTIBLE
);
215 while (pegasus
->flags
& ETH_REGS_CHANGED
)
217 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
218 set_current_state(TASK_RUNNING
);
220 pegasus
->dr
.bRequestType
= PEGASUS_REQT_WRITE
;
221 pegasus
->dr
.bRequest
= PEGASUS_REQ_SET_REGS
;
222 pegasus
->dr
.wValue
= cpu_to_le16(0);
223 pegasus
->dr
.wIndex
= cpu_to_le16(indx
);
224 pegasus
->dr
.wLength
= cpu_to_le16(size
);
225 pegasus
->ctrl_urb
->transfer_buffer_length
= size
;
227 usb_fill_control_urb(pegasus
->ctrl_urb
, pegasus
->usb
,
228 usb_sndctrlpipe(pegasus
->usb
, 0),
229 (char *) &pegasus
->dr
,
230 buffer
, size
, ctrl_callback
, pegasus
);
232 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
233 set_current_state(TASK_UNINTERRUPTIBLE
);
235 if ((ret
= usb_submit_urb(pegasus
->ctrl_urb
, GFP_ATOMIC
))) {
237 netif_device_detach(pegasus
->net
);
238 netif_err(pegasus
, drv
, pegasus
->net
,
239 "%s, status %d\n", __func__
, ret
);
245 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
251 static int set_register(pegasus_t
*pegasus
, __u16 indx
, __u8 data
)
255 DECLARE_WAITQUEUE(wait
, current
);
257 tmp
= kmemdup(&data
, 1, GFP_KERNEL
);
259 netif_warn(pegasus
, drv
, pegasus
->net
,
260 "out of memory in %s\n", __func__
);
263 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
264 set_current_state(TASK_UNINTERRUPTIBLE
);
265 while (pegasus
->flags
& ETH_REGS_CHANGED
)
267 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
268 set_current_state(TASK_RUNNING
);
270 pegasus
->dr
.bRequestType
= PEGASUS_REQT_WRITE
;
271 pegasus
->dr
.bRequest
= PEGASUS_REQ_SET_REG
;
272 pegasus
->dr
.wValue
= cpu_to_le16(data
);
273 pegasus
->dr
.wIndex
= cpu_to_le16(indx
);
274 pegasus
->dr
.wLength
= cpu_to_le16(1);
275 pegasus
->ctrl_urb
->transfer_buffer_length
= 1;
277 usb_fill_control_urb(pegasus
->ctrl_urb
, pegasus
->usb
,
278 usb_sndctrlpipe(pegasus
->usb
, 0),
279 (char *) &pegasus
->dr
,
280 tmp
, 1, ctrl_callback
, pegasus
);
282 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
283 set_current_state(TASK_UNINTERRUPTIBLE
);
285 if ((ret
= usb_submit_urb(pegasus
->ctrl_urb
, GFP_ATOMIC
))) {
287 netif_device_detach(pegasus
->net
);
289 netif_err(pegasus
, drv
, pegasus
->net
,
290 "%s, status %d\n", __func__
, ret
);
296 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
302 static int update_eth_regs_async(pegasus_t
*pegasus
)
306 pegasus
->dr
.bRequestType
= PEGASUS_REQT_WRITE
;
307 pegasus
->dr
.bRequest
= PEGASUS_REQ_SET_REGS
;
308 pegasus
->dr
.wValue
= cpu_to_le16(0);
309 pegasus
->dr
.wIndex
= cpu_to_le16(EthCtrl0
);
310 pegasus
->dr
.wLength
= cpu_to_le16(3);
311 pegasus
->ctrl_urb
->transfer_buffer_length
= 3;
313 usb_fill_control_urb(pegasus
->ctrl_urb
, pegasus
->usb
,
314 usb_sndctrlpipe(pegasus
->usb
, 0),
315 (char *) &pegasus
->dr
,
316 pegasus
->eth_regs
, 3, ctrl_callback
, pegasus
);
318 if ((ret
= usb_submit_urb(pegasus
->ctrl_urb
, GFP_ATOMIC
))) {
320 netif_device_detach(pegasus
->net
);
321 netif_err(pegasus
, drv
, pegasus
->net
,
322 "%s, status %d\n", __func__
, ret
);
328 /* Returns 0 on success, error on failure */
329 static int read_mii_word(pegasus_t
*pegasus
, __u8 phy
, __u8 indx
, __u16
*regd
)
332 __u8 data
[4] = { phy
, 0, 0, indx
};
336 set_register(pegasus
, PhyCtrl
, 0);
337 set_registers(pegasus
, PhyAddr
, sizeof(data
), data
);
338 set_register(pegasus
, PhyCtrl
, (indx
| PHY_READ
));
339 for (i
= 0; i
< REG_TIMEOUT
; i
++) {
340 ret
= get_registers(pegasus
, PhyCtrl
, 1, data
);
341 if (ret
== -ESHUTDOWN
)
343 if (data
[0] & PHY_DONE
)
347 if (i
>= REG_TIMEOUT
)
350 ret
= get_registers(pegasus
, PhyData
, 2, ®di
);
351 *regd
= le16_to_cpu(regdi
);
355 netif_warn(pegasus
, drv
, pegasus
->net
, "%s failed\n", __func__
);
360 static int mdio_read(struct net_device
*dev
, int phy_id
, int loc
)
362 pegasus_t
*pegasus
= netdev_priv(dev
);
365 read_mii_word(pegasus
, phy_id
, loc
, &res
);
369 static int write_mii_word(pegasus_t
*pegasus
, __u8 phy
, __u8 indx
, __u16 regd
)
372 __u8 data
[4] = { phy
, 0, 0, indx
};
376 data
[2] = (u8
) (regd
>> 8);
377 set_register(pegasus
, PhyCtrl
, 0);
378 set_registers(pegasus
, PhyAddr
, sizeof(data
), data
);
379 set_register(pegasus
, PhyCtrl
, (indx
| PHY_WRITE
));
380 for (i
= 0; i
< REG_TIMEOUT
; i
++) {
381 ret
= get_registers(pegasus
, PhyCtrl
, 1, data
);
382 if (ret
== -ESHUTDOWN
)
384 if (data
[0] & PHY_DONE
)
388 if (i
>= REG_TIMEOUT
)
394 netif_warn(pegasus
, drv
, pegasus
->net
, "%s failed\n", __func__
);
398 static void mdio_write(struct net_device
*dev
, int phy_id
, int loc
, int val
)
400 pegasus_t
*pegasus
= netdev_priv(dev
);
402 write_mii_word(pegasus
, phy_id
, loc
, val
);
405 static int read_eprom_word(pegasus_t
*pegasus
, __u8 index
, __u16
*retdata
)
412 set_register(pegasus
, EpromCtrl
, 0);
413 set_register(pegasus
, EpromOffset
, index
);
414 set_register(pegasus
, EpromCtrl
, EPROM_READ
);
416 for (i
= 0; i
< REG_TIMEOUT
; i
++) {
417 ret
= get_registers(pegasus
, EpromCtrl
, 1, &tmp
);
418 if (tmp
& EPROM_DONE
)
420 if (ret
== -ESHUTDOWN
)
423 if (i
>= REG_TIMEOUT
)
426 ret
= get_registers(pegasus
, EpromData
, 2, &retdatai
);
427 *retdata
= le16_to_cpu(retdatai
);
431 netif_warn(pegasus
, drv
, pegasus
->net
, "%s failed\n", __func__
);
435 #ifdef PEGASUS_WRITE_EEPROM
436 static inline void enable_eprom_write(pegasus_t
*pegasus
)
441 get_registers(pegasus
, EthCtrl2
, 1, &tmp
);
442 set_register(pegasus
, EthCtrl2
, tmp
| EPROM_WR_ENABLE
);
445 static inline void disable_eprom_write(pegasus_t
*pegasus
)
450 get_registers(pegasus
, EthCtrl2
, 1, &tmp
);
451 set_register(pegasus
, EpromCtrl
, 0);
452 set_register(pegasus
, EthCtrl2
, tmp
& ~EPROM_WR_ENABLE
);
455 static int write_eprom_word(pegasus_t
*pegasus
, __u8 index
, __u16 data
)
458 __u8 tmp
, d
[4] = { 0x3f, 0, 0, EPROM_WRITE
};
460 __le16 le_data
= cpu_to_le16(data
);
462 set_registers(pegasus
, EpromOffset
, 4, d
);
463 enable_eprom_write(pegasus
);
464 set_register(pegasus
, EpromOffset
, index
);
465 set_registers(pegasus
, EpromData
, 2, &le_data
);
466 set_register(pegasus
, EpromCtrl
, EPROM_WRITE
);
468 for (i
= 0; i
< REG_TIMEOUT
; i
++) {
469 ret
= get_registers(pegasus
, EpromCtrl
, 1, &tmp
);
470 if (ret
== -ESHUTDOWN
)
472 if (tmp
& EPROM_DONE
)
475 disable_eprom_write(pegasus
);
476 if (i
>= REG_TIMEOUT
)
482 netif_warn(pegasus
, drv
, pegasus
->net
, "%s failed\n", __func__
);
485 #endif /* PEGASUS_WRITE_EEPROM */
487 static inline void get_node_id(pegasus_t
*pegasus
, __u8
*id
)
492 for (i
= 0; i
< 3; i
++) {
493 read_eprom_word(pegasus
, i
, &w16
);
494 ((__le16
*) id
)[i
] = cpu_to_le16(w16
);
498 static void set_ethernet_addr(pegasus_t
*pegasus
)
502 if (pegasus
->features
& PEGASUS_II
) {
503 get_registers(pegasus
, 0x10, sizeof(node_id
), node_id
);
505 get_node_id(pegasus
, node_id
);
506 set_registers(pegasus
, EthID
, sizeof(node_id
), node_id
);
508 memcpy(pegasus
->net
->dev_addr
, node_id
, sizeof(node_id
));
511 static inline int reset_mac(pegasus_t
*pegasus
)
516 set_register(pegasus
, EthCtrl1
, data
);
517 for (i
= 0; i
< REG_TIMEOUT
; i
++) {
518 get_registers(pegasus
, EthCtrl1
, 1, &data
);
522 if (mii_mode
&& (pegasus
->features
& HAS_HOME_PNA
))
523 set_register(pegasus
, Gpio1
, 0x34);
525 set_register(pegasus
, Gpio1
, 0x26);
526 set_register(pegasus
, Gpio0
, pegasus
->features
);
527 set_register(pegasus
, Gpio0
, DEFAULT_GPIO_SET
);
531 if (i
== REG_TIMEOUT
)
534 if (usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_LINKSYS
||
535 usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_DLINK
) {
536 set_register(pegasus
, Gpio0
, 0x24);
537 set_register(pegasus
, Gpio0
, 0x26);
539 if (usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_ELCON
) {
541 read_mii_word(pegasus
, 3, 0x1b, &auxmode
);
542 write_mii_word(pegasus
, 3, 0x1b, auxmode
| 4);
548 static int enable_net_traffic(struct net_device
*dev
, struct usb_device
*usb
)
552 pegasus_t
*pegasus
= netdev_priv(dev
);
555 read_mii_word(pegasus
, pegasus
->phy
, MII_LPA
, &linkpart
);
558 if (linkpart
& (ADVERTISE_100FULL
| ADVERTISE_10FULL
))
559 data
[1] |= 0x20; /* set full duplex */
560 if (linkpart
& (ADVERTISE_100FULL
| ADVERTISE_100HALF
))
561 data
[1] |= 0x10; /* set 100 Mbps */
564 data
[2] = loopback
? 0x09 : 0x01;
566 memcpy(pegasus
->eth_regs
, data
, sizeof(data
));
567 ret
= set_registers(pegasus
, EthCtrl0
, 3, data
);
569 if (usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_LINKSYS
||
570 usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_LINKSYS2
||
571 usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_DLINK
) {
573 read_mii_word(pegasus
, 0, 0x1b, &auxmode
);
574 write_mii_word(pegasus
, 0, 0x1b, auxmode
| 4);
580 static void fill_skb_pool(pegasus_t
*pegasus
)
584 for (i
= 0; i
< RX_SKBS
; i
++) {
585 if (pegasus
->rx_pool
[i
])
587 pegasus
->rx_pool
[i
] = dev_alloc_skb(PEGASUS_MTU
+ 2);
589 ** we give up if the allocation fail. the tasklet will be
590 ** rescheduled again anyway...
592 if (pegasus
->rx_pool
[i
] == NULL
)
594 skb_reserve(pegasus
->rx_pool
[i
], 2);
598 static void free_skb_pool(pegasus_t
*pegasus
)
602 for (i
= 0; i
< RX_SKBS
; i
++) {
603 if (pegasus
->rx_pool
[i
]) {
604 dev_kfree_skb(pegasus
->rx_pool
[i
]);
605 pegasus
->rx_pool
[i
] = NULL
;
610 static inline struct sk_buff
*pull_skb(pegasus_t
* pegasus
)
615 for (i
= 0; i
< RX_SKBS
; i
++) {
616 if (likely(pegasus
->rx_pool
[i
] != NULL
)) {
617 skb
= pegasus
->rx_pool
[i
];
618 pegasus
->rx_pool
[i
] = NULL
;
625 static void read_bulk_callback(struct urb
*urb
)
627 pegasus_t
*pegasus
= urb
->context
;
628 struct net_device
*net
;
629 int rx_status
, count
= urb
->actual_length
;
630 int status
= urb
->status
;
631 u8
*buf
= urb
->transfer_buffer
;
638 if (!netif_device_present(net
) || !netif_running(net
))
645 netif_dbg(pegasus
, rx_err
, net
, "reset MAC\n");
646 pegasus
->flags
&= ~PEGASUS_RX_BUSY
;
648 case -EPIPE
: /* stall, or disconnect from TT */
649 /* FIXME schedule work to clear the halt */
650 netif_warn(pegasus
, rx_err
, net
, "no rx stall recovery\n");
655 netif_dbg(pegasus
, ifdown
, net
, "rx unlink, %d\n", status
);
658 netif_dbg(pegasus
, rx_err
, net
, "RX status %d\n", status
);
662 if (!count
|| count
< 4)
665 rx_status
= buf
[count
- 2];
666 if (rx_status
& 0x1e) {
667 netif_dbg(pegasus
, rx_err
, net
,
668 "RX packet error %x\n", rx_status
);
669 pegasus
->stats
.rx_errors
++;
670 if (rx_status
& 0x06) /* long or runt */
671 pegasus
->stats
.rx_length_errors
++;
672 if (rx_status
& 0x08)
673 pegasus
->stats
.rx_crc_errors
++;
674 if (rx_status
& 0x10) /* extra bits */
675 pegasus
->stats
.rx_frame_errors
++;
678 if (pegasus
->chip
== 0x8513) {
679 pkt_len
= le32_to_cpu(*(__le32
*)urb
->transfer_buffer
);
681 pegasus
->rx_skb
->data
+= 2;
683 pkt_len
= buf
[count
- 3] << 8;
684 pkt_len
+= buf
[count
- 4];
690 * If the packet is unreasonably long, quietly drop it rather than
691 * kernel panicing by calling skb_put.
693 if (pkt_len
> PEGASUS_MTU
)
697 * at this point we are sure pegasus->rx_skb != NULL
698 * so we go ahead and pass up the packet.
700 skb_put(pegasus
->rx_skb
, pkt_len
);
701 pegasus
->rx_skb
->protocol
= eth_type_trans(pegasus
->rx_skb
, net
);
702 netif_rx(pegasus
->rx_skb
);
703 pegasus
->stats
.rx_packets
++;
704 pegasus
->stats
.rx_bytes
+= pkt_len
;
706 if (pegasus
->flags
& PEGASUS_UNPLUG
)
709 spin_lock(&pegasus
->rx_pool_lock
);
710 pegasus
->rx_skb
= pull_skb(pegasus
);
711 spin_unlock(&pegasus
->rx_pool_lock
);
713 if (pegasus
->rx_skb
== NULL
)
716 usb_fill_bulk_urb(pegasus
->rx_urb
, pegasus
->usb
,
717 usb_rcvbulkpipe(pegasus
->usb
, 1),
718 pegasus
->rx_skb
->data
, PEGASUS_MTU
+ 8,
719 read_bulk_callback
, pegasus
);
720 rx_status
= usb_submit_urb(pegasus
->rx_urb
, GFP_ATOMIC
);
721 if (rx_status
== -ENODEV
)
722 netif_device_detach(pegasus
->net
);
723 else if (rx_status
) {
724 pegasus
->flags
|= PEGASUS_RX_URB_FAIL
;
727 pegasus
->flags
&= ~PEGASUS_RX_URB_FAIL
;
733 tasklet_schedule(&pegasus
->rx_tl
);
736 static void rx_fixup(unsigned long data
)
742 pegasus
= (pegasus_t
*) data
;
743 if (pegasus
->flags
& PEGASUS_UNPLUG
)
746 spin_lock_irqsave(&pegasus
->rx_pool_lock
, flags
);
747 fill_skb_pool(pegasus
);
748 if (pegasus
->flags
& PEGASUS_RX_URB_FAIL
)
751 if (pegasus
->rx_skb
== NULL
)
752 pegasus
->rx_skb
= pull_skb(pegasus
);
753 if (pegasus
->rx_skb
== NULL
) {
754 netif_warn(pegasus
, rx_err
, pegasus
->net
, "low on memory\n");
755 tasklet_schedule(&pegasus
->rx_tl
);
758 usb_fill_bulk_urb(pegasus
->rx_urb
, pegasus
->usb
,
759 usb_rcvbulkpipe(pegasus
->usb
, 1),
760 pegasus
->rx_skb
->data
, PEGASUS_MTU
+ 8,
761 read_bulk_callback
, pegasus
);
763 status
= usb_submit_urb(pegasus
->rx_urb
, GFP_ATOMIC
);
764 if (status
== -ENODEV
)
765 netif_device_detach(pegasus
->net
);
767 pegasus
->flags
|= PEGASUS_RX_URB_FAIL
;
768 tasklet_schedule(&pegasus
->rx_tl
);
770 pegasus
->flags
&= ~PEGASUS_RX_URB_FAIL
;
773 spin_unlock_irqrestore(&pegasus
->rx_pool_lock
, flags
);
776 static void write_bulk_callback(struct urb
*urb
)
778 pegasus_t
*pegasus
= urb
->context
;
779 struct net_device
*net
;
780 int status
= urb
->status
;
787 if (!netif_device_present(net
) || !netif_running(net
))
792 /* FIXME schedule_work() to clear the tx halt */
793 netif_stop_queue(net
);
794 netif_warn(pegasus
, tx_err
, net
, "no tx stall recovery\n");
799 netif_dbg(pegasus
, ifdown
, net
, "tx unlink, %d\n", status
);
802 netif_info(pegasus
, tx_err
, net
, "TX status %d\n", status
);
808 net
->trans_start
= jiffies
; /* prevent tx timeout */
809 netif_wake_queue(net
);
812 static void intr_callback(struct urb
*urb
)
814 pegasus_t
*pegasus
= urb
->context
;
815 struct net_device
*net
;
816 int res
, status
= urb
->status
;
825 case -ECONNRESET
: /* unlink */
830 /* some Pegasus-I products report LOTS of data
831 * toggle errors... avoid log spamming
833 netif_dbg(pegasus
, timer
, net
, "intr status %d\n", status
);
836 if (urb
->actual_length
>= 6) {
837 u8
*d
= urb
->transfer_buffer
;
839 /* byte 0 == tx_status1, reg 2B */
840 if (d
[0] & (TX_UNDERRUN
|EXCESSIVE_COL
841 |LATE_COL
|JABBER_TIMEOUT
)) {
842 pegasus
->stats
.tx_errors
++;
843 if (d
[0] & TX_UNDERRUN
)
844 pegasus
->stats
.tx_fifo_errors
++;
845 if (d
[0] & (EXCESSIVE_COL
| JABBER_TIMEOUT
))
846 pegasus
->stats
.tx_aborted_errors
++;
848 pegasus
->stats
.tx_window_errors
++;
851 /* d[5].LINK_STATUS lies on some adapters.
852 * d[0].NO_CARRIER kicks in only with failed TX.
853 * ... so monitoring with MII may be safest.
856 /* bytes 3-4 == rx_lostpkt, reg 2E/2F */
857 pegasus
->stats
.rx_missed_errors
+= ((d
[3] & 0x7f) << 8) | d
[4];
860 res
= usb_submit_urb(urb
, GFP_ATOMIC
);
862 netif_device_detach(pegasus
->net
);
864 netif_err(pegasus
, timer
, net
,
865 "can't resubmit interrupt urb, %d\n", res
);
868 static void pegasus_tx_timeout(struct net_device
*net
)
870 pegasus_t
*pegasus
= netdev_priv(net
);
871 netif_warn(pegasus
, timer
, net
, "tx timeout\n");
872 usb_unlink_urb(pegasus
->tx_urb
);
873 pegasus
->stats
.tx_errors
++;
876 static netdev_tx_t
pegasus_start_xmit(struct sk_buff
*skb
,
877 struct net_device
*net
)
879 pegasus_t
*pegasus
= netdev_priv(net
);
880 int count
= ((skb
->len
+ 2) & 0x3f) ? skb
->len
+ 2 : skb
->len
+ 3;
882 __u16 l16
= skb
->len
;
884 netif_stop_queue(net
);
886 ((__le16
*) pegasus
->tx_buff
)[0] = cpu_to_le16(l16
);
887 skb_copy_from_linear_data(skb
, pegasus
->tx_buff
+ 2, skb
->len
);
888 usb_fill_bulk_urb(pegasus
->tx_urb
, pegasus
->usb
,
889 usb_sndbulkpipe(pegasus
->usb
, 2),
890 pegasus
->tx_buff
, count
,
891 write_bulk_callback
, pegasus
);
892 if ((res
= usb_submit_urb(pegasus
->tx_urb
, GFP_ATOMIC
))) {
893 netif_warn(pegasus
, tx_err
, net
, "fail tx, %d\n", res
);
895 case -EPIPE
: /* stall, or disconnect from TT */
896 /* cleanup should already have been scheduled */
898 case -ENODEV
: /* disconnect() upcoming */
900 netif_device_detach(pegasus
->net
);
903 pegasus
->stats
.tx_errors
++;
904 netif_start_queue(net
);
907 pegasus
->stats
.tx_packets
++;
908 pegasus
->stats
.tx_bytes
+= skb
->len
;
915 static struct net_device_stats
*pegasus_netdev_stats(struct net_device
*dev
)
917 return &((pegasus_t
*) netdev_priv(dev
))->stats
;
920 static inline void disable_net_traffic(pegasus_t
*pegasus
)
922 __le16 tmp
= cpu_to_le16(0);
924 set_registers(pegasus
, EthCtrl0
, sizeof(tmp
), &tmp
);
927 static inline void get_interrupt_interval(pegasus_t
*pegasus
)
932 read_eprom_word(pegasus
, 4, &data
);
933 interval
= data
>> 8;
934 if (pegasus
->usb
->speed
!= USB_SPEED_HIGH
) {
935 if (interval
< 0x80) {
936 netif_info(pegasus
, timer
, pegasus
->net
,
937 "intr interval changed from %ums to %ums\n",
940 data
= (data
& 0x00FF) | ((u16
)interval
<< 8);
941 #ifdef PEGASUS_WRITE_EEPROM
942 write_eprom_word(pegasus
, 4, data
);
946 pegasus
->intr_interval
= interval
;
949 static void set_carrier(struct net_device
*net
)
951 pegasus_t
*pegasus
= netdev_priv(net
);
954 if (read_mii_word(pegasus
, pegasus
->phy
, MII_BMSR
, &tmp
))
957 if (tmp
& BMSR_LSTATUS
)
958 netif_carrier_on(net
);
960 netif_carrier_off(net
);
963 static void free_all_urbs(pegasus_t
*pegasus
)
965 usb_free_urb(pegasus
->intr_urb
);
966 usb_free_urb(pegasus
->tx_urb
);
967 usb_free_urb(pegasus
->rx_urb
);
968 usb_free_urb(pegasus
->ctrl_urb
);
971 static void unlink_all_urbs(pegasus_t
*pegasus
)
973 usb_kill_urb(pegasus
->intr_urb
);
974 usb_kill_urb(pegasus
->tx_urb
);
975 usb_kill_urb(pegasus
->rx_urb
);
976 usb_kill_urb(pegasus
->ctrl_urb
);
979 static int alloc_urbs(pegasus_t
*pegasus
)
981 pegasus
->ctrl_urb
= usb_alloc_urb(0, GFP_KERNEL
);
982 if (!pegasus
->ctrl_urb
)
984 pegasus
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
985 if (!pegasus
->rx_urb
) {
986 usb_free_urb(pegasus
->ctrl_urb
);
989 pegasus
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
990 if (!pegasus
->tx_urb
) {
991 usb_free_urb(pegasus
->rx_urb
);
992 usb_free_urb(pegasus
->ctrl_urb
);
995 pegasus
->intr_urb
= usb_alloc_urb(0, GFP_KERNEL
);
996 if (!pegasus
->intr_urb
) {
997 usb_free_urb(pegasus
->tx_urb
);
998 usb_free_urb(pegasus
->rx_urb
);
999 usb_free_urb(pegasus
->ctrl_urb
);
1006 static int pegasus_open(struct net_device
*net
)
1008 pegasus_t
*pegasus
= netdev_priv(net
);
1011 if (pegasus
->rx_skb
== NULL
)
1012 pegasus
->rx_skb
= pull_skb(pegasus
);
1014 ** Note: no point to free the pool. it is empty :-)
1016 if (!pegasus
->rx_skb
)
1019 res
= set_registers(pegasus
, EthID
, 6, net
->dev_addr
);
1021 usb_fill_bulk_urb(pegasus
->rx_urb
, pegasus
->usb
,
1022 usb_rcvbulkpipe(pegasus
->usb
, 1),
1023 pegasus
->rx_skb
->data
, PEGASUS_MTU
+ 8,
1024 read_bulk_callback
, pegasus
);
1025 if ((res
= usb_submit_urb(pegasus
->rx_urb
, GFP_KERNEL
))) {
1027 netif_device_detach(pegasus
->net
);
1028 netif_dbg(pegasus
, ifup
, net
, "failed rx_urb, %d\n", res
);
1032 usb_fill_int_urb(pegasus
->intr_urb
, pegasus
->usb
,
1033 usb_rcvintpipe(pegasus
->usb
, 3),
1034 pegasus
->intr_buff
, sizeof(pegasus
->intr_buff
),
1035 intr_callback
, pegasus
, pegasus
->intr_interval
);
1036 if ((res
= usb_submit_urb(pegasus
->intr_urb
, GFP_KERNEL
))) {
1038 netif_device_detach(pegasus
->net
);
1039 netif_dbg(pegasus
, ifup
, net
, "failed intr_urb, %d\n", res
);
1040 usb_kill_urb(pegasus
->rx_urb
);
1043 if ((res
= enable_net_traffic(net
, pegasus
->usb
))) {
1044 netif_dbg(pegasus
, ifup
, net
,
1045 "can't enable_net_traffic() - %d\n", res
);
1047 usb_kill_urb(pegasus
->rx_urb
);
1048 usb_kill_urb(pegasus
->intr_urb
);
1049 free_skb_pool(pegasus
);
1053 netif_start_queue(net
);
1054 netif_dbg(pegasus
, ifup
, net
, "open\n");
1060 static int pegasus_close(struct net_device
*net
)
1062 pegasus_t
*pegasus
= netdev_priv(net
);
1064 netif_stop_queue(net
);
1065 if (!(pegasus
->flags
& PEGASUS_UNPLUG
))
1066 disable_net_traffic(pegasus
);
1067 tasklet_kill(&pegasus
->rx_tl
);
1068 unlink_all_urbs(pegasus
);
1073 static void pegasus_get_drvinfo(struct net_device
*dev
,
1074 struct ethtool_drvinfo
*info
)
1076 pegasus_t
*pegasus
= netdev_priv(dev
);
1077 strncpy(info
->driver
, driver_name
, sizeof(info
->driver
) - 1);
1078 strncpy(info
->version
, DRIVER_VERSION
, sizeof(info
->version
) - 1);
1079 usb_make_path(pegasus
->usb
, info
->bus_info
, sizeof(info
->bus_info
));
1082 /* also handles three patterns of some kind in hardware */
1083 #define WOL_SUPPORTED (WAKE_MAGIC|WAKE_PHY)
1086 pegasus_get_wol(struct net_device
*dev
, struct ethtool_wolinfo
*wol
)
1088 pegasus_t
*pegasus
= netdev_priv(dev
);
1090 wol
->supported
= WAKE_MAGIC
| WAKE_PHY
;
1091 wol
->wolopts
= pegasus
->wolopts
;
1095 pegasus_set_wol(struct net_device
*dev
, struct ethtool_wolinfo
*wol
)
1097 pegasus_t
*pegasus
= netdev_priv(dev
);
1100 if (wol
->wolopts
& ~WOL_SUPPORTED
)
1103 if (wol
->wolopts
& WAKE_MAGIC
)
1105 if (wol
->wolopts
& WAKE_PHY
)
1107 /* FIXME this 0x10 bit still needs to get set in the chip... */
1109 pegasus
->eth_regs
[0] |= 0x10;
1111 pegasus
->eth_regs
[0] &= ~0x10;
1112 pegasus
->wolopts
= wol
->wolopts
;
1113 return set_register(pegasus
, WakeupControl
, reg78
);
1116 static inline void pegasus_reset_wol(struct net_device
*dev
)
1118 struct ethtool_wolinfo wol
;
1120 memset(&wol
, 0, sizeof wol
);
1121 (void) pegasus_set_wol(dev
, &wol
);
1125 pegasus_get_settings(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1129 pegasus
= netdev_priv(dev
);
1130 mii_ethtool_gset(&pegasus
->mii
, ecmd
);
1135 pegasus_set_settings(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1137 pegasus_t
*pegasus
= netdev_priv(dev
);
1138 return mii_ethtool_sset(&pegasus
->mii
, ecmd
);
1141 static int pegasus_nway_reset(struct net_device
*dev
)
1143 pegasus_t
*pegasus
= netdev_priv(dev
);
1144 return mii_nway_restart(&pegasus
->mii
);
1147 static u32
pegasus_get_link(struct net_device
*dev
)
1149 pegasus_t
*pegasus
= netdev_priv(dev
);
1150 return mii_link_ok(&pegasus
->mii
);
1153 static u32
pegasus_get_msglevel(struct net_device
*dev
)
1155 pegasus_t
*pegasus
= netdev_priv(dev
);
1156 return pegasus
->msg_enable
;
1159 static void pegasus_set_msglevel(struct net_device
*dev
, u32 v
)
1161 pegasus_t
*pegasus
= netdev_priv(dev
);
1162 pegasus
->msg_enable
= v
;
1165 static const struct ethtool_ops ops
= {
1166 .get_drvinfo
= pegasus_get_drvinfo
,
1167 .get_settings
= pegasus_get_settings
,
1168 .set_settings
= pegasus_set_settings
,
1169 .nway_reset
= pegasus_nway_reset
,
1170 .get_link
= pegasus_get_link
,
1171 .get_msglevel
= pegasus_get_msglevel
,
1172 .set_msglevel
= pegasus_set_msglevel
,
1173 .get_wol
= pegasus_get_wol
,
1174 .set_wol
= pegasus_set_wol
,
1177 static int pegasus_ioctl(struct net_device
*net
, struct ifreq
*rq
, int cmd
)
1179 __u16
*data
= (__u16
*) &rq
->ifr_ifru
;
1180 pegasus_t
*pegasus
= netdev_priv(net
);
1184 case SIOCDEVPRIVATE
:
1185 data
[0] = pegasus
->phy
;
1186 case SIOCDEVPRIVATE
+ 1:
1187 read_mii_word(pegasus
, data
[0], data
[1] & 0x1f, &data
[3]);
1190 case SIOCDEVPRIVATE
+ 2:
1191 if (!capable(CAP_NET_ADMIN
))
1193 write_mii_word(pegasus
, pegasus
->phy
, data
[1] & 0x1f, data
[2]);
1202 static void pegasus_set_multicast(struct net_device
*net
)
1204 pegasus_t
*pegasus
= netdev_priv(net
);
1206 if (net
->flags
& IFF_PROMISC
) {
1207 pegasus
->eth_regs
[EthCtrl2
] |= RX_PROMISCUOUS
;
1208 netif_info(pegasus
, link
, net
, "Promiscuous mode enabled\n");
1209 } else if (!netdev_mc_empty(net
) || (net
->flags
& IFF_ALLMULTI
)) {
1210 pegasus
->eth_regs
[EthCtrl0
] |= RX_MULTICAST
;
1211 pegasus
->eth_regs
[EthCtrl2
] &= ~RX_PROMISCUOUS
;
1212 netif_dbg(pegasus
, link
, net
, "set allmulti\n");
1214 pegasus
->eth_regs
[EthCtrl0
] &= ~RX_MULTICAST
;
1215 pegasus
->eth_regs
[EthCtrl2
] &= ~RX_PROMISCUOUS
;
1218 pegasus
->ctrl_urb
->status
= 0;
1220 pegasus
->flags
|= ETH_REGS_CHANGE
;
1221 ctrl_callback(pegasus
->ctrl_urb
);
1224 static __u8
mii_phy_probe(pegasus_t
*pegasus
)
1229 for (i
= 0; i
< 32; i
++) {
1230 read_mii_word(pegasus
, i
, MII_BMSR
, &tmp
);
1231 if (tmp
== 0 || tmp
== 0xffff || (tmp
& BMSR_MEDIA
) == 0)
1240 static inline void setup_pegasus_II(pegasus_t
*pegasus
)
1244 set_register(pegasus
, Reg1d
, 0);
1245 set_register(pegasus
, Reg7b
, 1);
1247 if ((pegasus
->features
& HAS_HOME_PNA
) && mii_mode
)
1248 set_register(pegasus
, Reg7b
, 0);
1250 set_register(pegasus
, Reg7b
, 2);
1252 set_register(pegasus
, 0x83, data
);
1253 get_registers(pegasus
, 0x83, 1, &data
);
1256 pegasus
->chip
= 0x8513;
1260 set_register(pegasus
, 0x80, 0xc0);
1261 set_register(pegasus
, 0x83, 0xff);
1262 set_register(pegasus
, 0x84, 0x01);
1264 if (pegasus
->features
& HAS_HOME_PNA
&& mii_mode
)
1265 set_register(pegasus
, Reg81
, 6);
1267 set_register(pegasus
, Reg81
, 2);
1271 static int pegasus_count
;
1272 static struct workqueue_struct
*pegasus_workqueue
;
1273 #define CARRIER_CHECK_DELAY (2 * HZ)
1275 static void check_carrier(struct work_struct
*work
)
1277 pegasus_t
*pegasus
= container_of(work
, pegasus_t
, carrier_check
.work
);
1278 set_carrier(pegasus
->net
);
1279 if (!(pegasus
->flags
& PEGASUS_UNPLUG
)) {
1280 queue_delayed_work(pegasus_workqueue
, &pegasus
->carrier_check
,
1281 CARRIER_CHECK_DELAY
);
1285 static int pegasus_blacklisted(struct usb_device
*udev
)
1287 struct usb_device_descriptor
*udd
= &udev
->descriptor
;
1289 /* Special quirk to keep the driver from handling the Belkin Bluetooth
1290 * dongle which happens to have the same ID.
1292 if ((udd
->idVendor
== cpu_to_le16(VENDOR_BELKIN
)) &&
1293 (udd
->idProduct
== cpu_to_le16(0x0121)) &&
1294 (udd
->bDeviceClass
== USB_CLASS_WIRELESS_CONTROLLER
) &&
1295 (udd
->bDeviceProtocol
== 1))
1301 /* we rely on probe() and remove() being serialized so we
1302 * don't need extra locking on pegasus_count.
1304 static void pegasus_dec_workqueue(void)
1307 if (pegasus_count
== 0) {
1308 destroy_workqueue(pegasus_workqueue
);
1309 pegasus_workqueue
= NULL
;
1313 static int pegasus_probe(struct usb_interface
*intf
,
1314 const struct usb_device_id
*id
)
1316 struct usb_device
*dev
= interface_to_usbdev(intf
);
1317 struct net_device
*net
;
1319 int dev_index
= id
- pegasus_ids
;
1322 if (pegasus_blacklisted(dev
))
1325 if (pegasus_count
== 0) {
1326 pegasus_workqueue
= create_singlethread_workqueue("pegasus");
1327 if (!pegasus_workqueue
)
1334 net
= alloc_etherdev(sizeof(struct pegasus
));
1336 dev_err(&intf
->dev
, "can't allocate %s\n", "device");
1340 pegasus
= netdev_priv(net
);
1341 pegasus
->dev_index
= dev_index
;
1342 init_waitqueue_head(&pegasus
->ctrl_wait
);
1344 if (!alloc_urbs(pegasus
)) {
1345 dev_err(&intf
->dev
, "can't allocate %s\n", "urbs");
1349 tasklet_init(&pegasus
->rx_tl
, rx_fixup
, (unsigned long) pegasus
);
1351 INIT_DELAYED_WORK(&pegasus
->carrier_check
, check_carrier
);
1353 pegasus
->intf
= intf
;
1358 net
->watchdog_timeo
= PEGASUS_TX_TIMEOUT
;
1359 net
->netdev_ops
= &pegasus_netdev_ops
;
1360 SET_ETHTOOL_OPS(net
, &ops
);
1361 pegasus
->mii
.dev
= net
;
1362 pegasus
->mii
.mdio_read
= mdio_read
;
1363 pegasus
->mii
.mdio_write
= mdio_write
;
1364 pegasus
->mii
.phy_id_mask
= 0x1f;
1365 pegasus
->mii
.reg_num_mask
= 0x1f;
1366 spin_lock_init(&pegasus
->rx_pool_lock
);
1367 pegasus
->msg_enable
= netif_msg_init(msg_level
, NETIF_MSG_DRV
1368 | NETIF_MSG_PROBE
| NETIF_MSG_LINK
);
1370 pegasus
->features
= usb_dev_id
[dev_index
].private;
1371 get_interrupt_interval(pegasus
);
1372 if (reset_mac(pegasus
)) {
1373 dev_err(&intf
->dev
, "can't reset MAC\n");
1377 set_ethernet_addr(pegasus
);
1378 fill_skb_pool(pegasus
);
1379 if (pegasus
->features
& PEGASUS_II
) {
1380 dev_info(&intf
->dev
, "setup Pegasus II specific registers\n");
1381 setup_pegasus_II(pegasus
);
1383 pegasus
->phy
= mii_phy_probe(pegasus
);
1384 if (pegasus
->phy
== 0xff) {
1385 dev_warn(&intf
->dev
, "can't locate MII phy, using default\n");
1388 pegasus
->mii
.phy_id
= pegasus
->phy
;
1389 usb_set_intfdata(intf
, pegasus
);
1390 SET_NETDEV_DEV(net
, &intf
->dev
);
1391 pegasus_reset_wol(net
);
1392 res
= register_netdev(net
);
1395 queue_delayed_work(pegasus_workqueue
, &pegasus
->carrier_check
,
1396 CARRIER_CHECK_DELAY
);
1398 dev_info(&intf
->dev
, "%s, %s, %pM\n",
1400 usb_dev_id
[dev_index
].name
,
1405 usb_set_intfdata(intf
, NULL
);
1406 free_skb_pool(pegasus
);
1408 free_all_urbs(pegasus
);
1413 pegasus_dec_workqueue();
1417 static void pegasus_disconnect(struct usb_interface
*intf
)
1419 struct pegasus
*pegasus
= usb_get_intfdata(intf
);
1421 usb_set_intfdata(intf
, NULL
);
1423 dev_dbg(&intf
->dev
, "unregistering non-bound device?\n");
1427 pegasus
->flags
|= PEGASUS_UNPLUG
;
1428 cancel_delayed_work(&pegasus
->carrier_check
);
1429 unregister_netdev(pegasus
->net
);
1430 usb_put_dev(interface_to_usbdev(intf
));
1431 unlink_all_urbs(pegasus
);
1432 free_all_urbs(pegasus
);
1433 free_skb_pool(pegasus
);
1434 if (pegasus
->rx_skb
!= NULL
) {
1435 dev_kfree_skb(pegasus
->rx_skb
);
1436 pegasus
->rx_skb
= NULL
;
1438 free_netdev(pegasus
->net
);
1439 pegasus_dec_workqueue();
1442 static int pegasus_suspend(struct usb_interface
*intf
, pm_message_t message
)
1444 struct pegasus
*pegasus
= usb_get_intfdata(intf
);
1446 netif_device_detach(pegasus
->net
);
1447 cancel_delayed_work(&pegasus
->carrier_check
);
1448 if (netif_running(pegasus
->net
)) {
1449 usb_kill_urb(pegasus
->rx_urb
);
1450 usb_kill_urb(pegasus
->intr_urb
);
1455 static int pegasus_resume(struct usb_interface
*intf
)
1457 struct pegasus
*pegasus
= usb_get_intfdata(intf
);
1459 netif_device_attach(pegasus
->net
);
1460 if (netif_running(pegasus
->net
)) {
1461 pegasus
->rx_urb
->status
= 0;
1462 pegasus
->rx_urb
->actual_length
= 0;
1463 read_bulk_callback(pegasus
->rx_urb
);
1465 pegasus
->intr_urb
->status
= 0;
1466 pegasus
->intr_urb
->actual_length
= 0;
1467 intr_callback(pegasus
->intr_urb
);
1469 queue_delayed_work(pegasus_workqueue
, &pegasus
->carrier_check
,
1470 CARRIER_CHECK_DELAY
);
1474 static const struct net_device_ops pegasus_netdev_ops
= {
1475 .ndo_open
= pegasus_open
,
1476 .ndo_stop
= pegasus_close
,
1477 .ndo_do_ioctl
= pegasus_ioctl
,
1478 .ndo_start_xmit
= pegasus_start_xmit
,
1479 .ndo_set_rx_mode
= pegasus_set_multicast
,
1480 .ndo_get_stats
= pegasus_netdev_stats
,
1481 .ndo_tx_timeout
= pegasus_tx_timeout
,
1482 .ndo_change_mtu
= eth_change_mtu
,
1483 .ndo_set_mac_address
= eth_mac_addr
,
1484 .ndo_validate_addr
= eth_validate_addr
,
1487 static struct usb_driver pegasus_driver
= {
1488 .name
= driver_name
,
1489 .probe
= pegasus_probe
,
1490 .disconnect
= pegasus_disconnect
,
1491 .id_table
= pegasus_ids
,
1492 .suspend
= pegasus_suspend
,
1493 .resume
= pegasus_resume
,
1496 static void __init
parse_id(char *id
)
1498 unsigned int vendor_id
= 0, device_id
= 0, flags
= 0, i
= 0;
1499 char *token
, *name
= NULL
;
1501 if ((token
= strsep(&id
, ":")) != NULL
)
1503 /* name now points to a null terminated string*/
1504 if ((token
= strsep(&id
, ":")) != NULL
)
1505 vendor_id
= simple_strtoul(token
, NULL
, 16);
1506 if ((token
= strsep(&id
, ":")) != NULL
)
1507 device_id
= simple_strtoul(token
, NULL
, 16);
1508 flags
= simple_strtoul(id
, NULL
, 16);
1509 pr_info("%s: new device %s, vendor ID 0x%04x, device ID 0x%04x, flags: 0x%x\n",
1510 driver_name
, name
, vendor_id
, device_id
, flags
);
1512 if (vendor_id
> 0x10000 || vendor_id
== 0)
1514 if (device_id
> 0x10000 || device_id
== 0)
1517 for (i
= 0; usb_dev_id
[i
].name
; i
++);
1518 usb_dev_id
[i
].name
= name
;
1519 usb_dev_id
[i
].vendor
= vendor_id
;
1520 usb_dev_id
[i
].device
= device_id
;
1521 usb_dev_id
[i
].private = flags
;
1522 pegasus_ids
[i
].match_flags
= USB_DEVICE_ID_MATCH_DEVICE
;
1523 pegasus_ids
[i
].idVendor
= vendor_id
;
1524 pegasus_ids
[i
].idProduct
= device_id
;
1527 static int __init
pegasus_init(void)
1529 pr_info("%s: %s, " DRIVER_DESC
"\n", driver_name
, DRIVER_VERSION
);
1532 return usb_register(&pegasus_driver
);
1535 static void __exit
pegasus_exit(void)
1537 usb_deregister(&pegasus_driver
);
1540 module_init(pegasus_init
);
1541 module_exit(pegasus_exit
);