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)
58 static int loopback
= 0;
59 static int mii_mode
= 0;
60 static char *devid
=NULL
;
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},
71 static struct usb_device_id pegasus_ids
[] = {
72 #define PEGASUS_DEV(pn, vid, pid, flags) \
73 {.match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = vid, .idProduct = pid},
80 MODULE_AUTHOR(DRIVER_AUTHOR
);
81 MODULE_DESCRIPTION(DRIVER_DESC
);
82 MODULE_LICENSE("GPL");
83 module_param(loopback
, bool, 0);
84 module_param(mii_mode
, bool, 0);
85 module_param(devid
, charp
, 0);
86 MODULE_PARM_DESC(loopback
, "Enable MAC loopback mode (bit 0)");
87 MODULE_PARM_DESC(mii_mode
, "Enable HomePNA mode (bit 0),default=MII mode = 0");
88 MODULE_PARM_DESC(devid
, "The format is: 'DEV_name:VendorID:DeviceID:Flags'");
90 /* use ethtool to change the level for any given device */
91 static int msg_level
= -1;
92 module_param (msg_level
, int, 0);
93 MODULE_PARM_DESC (msg_level
, "Override default message level");
95 MODULE_DEVICE_TABLE(usb
, pegasus_ids
);
97 static int update_eth_regs_async(pegasus_t
*);
98 /* Aargh!!! I _really_ hate such tweaks */
99 static void ctrl_callback(struct urb
*urb
)
101 pegasus_t
*pegasus
= urb
->context
;
106 switch (urb
->status
) {
108 if (pegasus
->flags
& ETH_REGS_CHANGE
) {
109 pegasus
->flags
&= ~ETH_REGS_CHANGE
;
110 pegasus
->flags
|= ETH_REGS_CHANGED
;
111 update_eth_regs_async(pegasus
);
120 if (netif_msg_drv(pegasus
))
121 dev_dbg(&pegasus
->intf
->dev
, "%s, status %d\n",
122 __FUNCTION__
, urb
->status
);
124 pegasus
->flags
&= ~ETH_REGS_CHANGED
;
125 wake_up(&pegasus
->ctrl_wait
);
128 static int get_registers(pegasus_t
* pegasus
, __u16 indx
, __u16 size
,
133 DECLARE_WAITQUEUE(wait
, current
);
135 buffer
= kmalloc(size
, GFP_KERNEL
);
137 if (netif_msg_drv(pegasus
))
138 dev_warn(&pegasus
->intf
->dev
, "out of memory in %s\n",
142 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
143 set_current_state(TASK_UNINTERRUPTIBLE
);
144 while (pegasus
->flags
& ETH_REGS_CHANGED
)
146 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
147 set_current_state(TASK_RUNNING
);
149 pegasus
->dr
.bRequestType
= PEGASUS_REQT_READ
;
150 pegasus
->dr
.bRequest
= PEGASUS_REQ_GET_REGS
;
151 pegasus
->dr
.wValue
= cpu_to_le16(0);
152 pegasus
->dr
.wIndex
= cpu_to_le16p(&indx
);
153 pegasus
->dr
.wLength
= cpu_to_le16p(&size
);
154 pegasus
->ctrl_urb
->transfer_buffer_length
= size
;
156 usb_fill_control_urb(pegasus
->ctrl_urb
, pegasus
->usb
,
157 usb_rcvctrlpipe(pegasus
->usb
, 0),
158 (char *) &pegasus
->dr
,
159 buffer
, size
, ctrl_callback
, pegasus
);
161 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
162 set_current_state(TASK_UNINTERRUPTIBLE
);
164 /* using ATOMIC, we'd never wake up if we slept */
165 if ((ret
= usb_submit_urb(pegasus
->ctrl_urb
, GFP_ATOMIC
))) {
167 netif_device_detach(pegasus
->net
);
168 if (netif_msg_drv(pegasus
))
169 dev_err(&pegasus
->intf
->dev
, "%s, status %d\n",
176 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
177 memcpy(data
, buffer
, size
);
183 static int set_registers(pegasus_t
* pegasus
, __u16 indx
, __u16 size
,
188 DECLARE_WAITQUEUE(wait
, current
);
190 buffer
= kmalloc(size
, GFP_KERNEL
);
192 if (netif_msg_drv(pegasus
))
193 dev_warn(&pegasus
->intf
->dev
, "out of memory in %s\n",
197 memcpy(buffer
, data
, size
);
199 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
200 set_current_state(TASK_UNINTERRUPTIBLE
);
201 while (pegasus
->flags
& ETH_REGS_CHANGED
)
203 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
204 set_current_state(TASK_RUNNING
);
206 pegasus
->dr
.bRequestType
= PEGASUS_REQT_WRITE
;
207 pegasus
->dr
.bRequest
= PEGASUS_REQ_SET_REGS
;
208 pegasus
->dr
.wValue
= cpu_to_le16(0);
209 pegasus
->dr
.wIndex
= cpu_to_le16p(&indx
);
210 pegasus
->dr
.wLength
= cpu_to_le16p(&size
);
211 pegasus
->ctrl_urb
->transfer_buffer_length
= size
;
213 usb_fill_control_urb(pegasus
->ctrl_urb
, pegasus
->usb
,
214 usb_sndctrlpipe(pegasus
->usb
, 0),
215 (char *) &pegasus
->dr
,
216 buffer
, size
, ctrl_callback
, pegasus
);
218 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
219 set_current_state(TASK_UNINTERRUPTIBLE
);
221 if ((ret
= usb_submit_urb(pegasus
->ctrl_urb
, GFP_ATOMIC
))) {
223 netif_device_detach(pegasus
->net
);
224 if (netif_msg_drv(pegasus
))
225 dev_err(&pegasus
->intf
->dev
, "%s, status %d\n",
232 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
238 static int set_register(pegasus_t
* pegasus
, __u16 indx
, __u8 data
)
242 DECLARE_WAITQUEUE(wait
, current
);
244 tmp
= kmalloc(1, GFP_KERNEL
);
246 if (netif_msg_drv(pegasus
))
247 dev_warn(&pegasus
->intf
->dev
, "out of memory in %s\n",
251 memcpy(tmp
, &data
, 1);
252 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
253 set_current_state(TASK_UNINTERRUPTIBLE
);
254 while (pegasus
->flags
& ETH_REGS_CHANGED
)
256 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
257 set_current_state(TASK_RUNNING
);
259 pegasus
->dr
.bRequestType
= PEGASUS_REQT_WRITE
;
260 pegasus
->dr
.bRequest
= PEGASUS_REQ_SET_REG
;
261 pegasus
->dr
.wValue
= cpu_to_le16(data
);
262 pegasus
->dr
.wIndex
= cpu_to_le16p(&indx
);
263 pegasus
->dr
.wLength
= cpu_to_le16(1);
264 pegasus
->ctrl_urb
->transfer_buffer_length
= 1;
266 usb_fill_control_urb(pegasus
->ctrl_urb
, pegasus
->usb
,
267 usb_sndctrlpipe(pegasus
->usb
, 0),
268 (char *) &pegasus
->dr
,
269 tmp
, 1, ctrl_callback
, pegasus
);
271 add_wait_queue(&pegasus
->ctrl_wait
, &wait
);
272 set_current_state(TASK_UNINTERRUPTIBLE
);
274 if ((ret
= usb_submit_urb(pegasus
->ctrl_urb
, GFP_ATOMIC
))) {
276 netif_device_detach(pegasus
->net
);
277 if (netif_msg_drv(pegasus
))
278 dev_err(&pegasus
->intf
->dev
, "%s, status %d\n",
285 remove_wait_queue(&pegasus
->ctrl_wait
, &wait
);
291 static int update_eth_regs_async(pegasus_t
* pegasus
)
295 pegasus
->dr
.bRequestType
= PEGASUS_REQT_WRITE
;
296 pegasus
->dr
.bRequest
= PEGASUS_REQ_SET_REGS
;
297 pegasus
->dr
.wValue
= 0;
298 pegasus
->dr
.wIndex
= cpu_to_le16(EthCtrl0
);
299 pegasus
->dr
.wLength
= cpu_to_le16(3);
300 pegasus
->ctrl_urb
->transfer_buffer_length
= 3;
302 usb_fill_control_urb(pegasus
->ctrl_urb
, pegasus
->usb
,
303 usb_sndctrlpipe(pegasus
->usb
, 0),
304 (char *) &pegasus
->dr
,
305 pegasus
->eth_regs
, 3, ctrl_callback
, pegasus
);
307 if ((ret
= usb_submit_urb(pegasus
->ctrl_urb
, GFP_ATOMIC
))) {
309 netif_device_detach(pegasus
->net
);
310 if (netif_msg_drv(pegasus
))
311 dev_err(&pegasus
->intf
->dev
, "%s, status %d\n",
318 static int read_mii_word(pegasus_t
* pegasus
, __u8 phy
, __u8 indx
, __u16
* regd
)
321 __u8 data
[4] = { phy
, 0, 0, indx
};
325 set_register(pegasus
, PhyCtrl
, 0);
326 set_registers(pegasus
, PhyAddr
, sizeof (data
), data
);
327 set_register(pegasus
, PhyCtrl
, (indx
| PHY_READ
));
328 for (i
= 0; i
< REG_TIMEOUT
; i
++) {
329 ret
= get_registers(pegasus
, PhyCtrl
, 1, data
);
330 if (ret
== -ESHUTDOWN
)
332 if (data
[0] & PHY_DONE
)
335 if (i
< REG_TIMEOUT
) {
336 ret
= get_registers(pegasus
, PhyData
, 2, ®di
);
337 *regd
= le16_to_cpu(regdi
);
341 if (netif_msg_drv(pegasus
))
342 dev_warn(&pegasus
->intf
->dev
, "%s failed\n", __FUNCTION__
);
347 static int mdio_read(struct net_device
*dev
, int phy_id
, int loc
)
349 pegasus_t
*pegasus
= (pegasus_t
*) netdev_priv(dev
);
352 read_mii_word(pegasus
, phy_id
, loc
, &res
);
356 static int write_mii_word(pegasus_t
* pegasus
, __u8 phy
, __u8 indx
, __u16 regd
)
359 __u8 data
[4] = { phy
, 0, 0, indx
};
363 data
[2] = (u8
) (regd
>> 8);
364 set_register(pegasus
, PhyCtrl
, 0);
365 set_registers(pegasus
, PhyAddr
, sizeof(data
), data
);
366 set_register(pegasus
, PhyCtrl
, (indx
| PHY_WRITE
));
367 for (i
= 0; i
< REG_TIMEOUT
; i
++) {
368 ret
= get_registers(pegasus
, PhyCtrl
, 1, data
);
369 if (ret
== -ESHUTDOWN
)
371 if (data
[0] & PHY_DONE
)
378 if (netif_msg_drv(pegasus
))
379 dev_warn(&pegasus
->intf
->dev
, "%s failed\n", __FUNCTION__
);
383 static void mdio_write(struct net_device
*dev
, int phy_id
, int loc
, int val
)
385 pegasus_t
*pegasus
= (pegasus_t
*) netdev_priv(dev
);
387 write_mii_word(pegasus
, phy_id
, loc
, val
);
390 static int read_eprom_word(pegasus_t
* pegasus
, __u8 index
, __u16
* retdata
)
397 set_register(pegasus
, EpromCtrl
, 0);
398 set_register(pegasus
, EpromOffset
, index
);
399 set_register(pegasus
, EpromCtrl
, EPROM_READ
);
401 for (i
= 0; i
< REG_TIMEOUT
; i
++) {
402 ret
= get_registers(pegasus
, EpromCtrl
, 1, &tmp
);
403 if (tmp
& EPROM_DONE
)
405 if (ret
== -ESHUTDOWN
)
408 if (i
< REG_TIMEOUT
) {
409 ret
= get_registers(pegasus
, EpromData
, 2, &retdatai
);
410 *retdata
= le16_to_cpu(retdatai
);
415 if (netif_msg_drv(pegasus
))
416 dev_warn(&pegasus
->intf
->dev
, "%s failed\n", __FUNCTION__
);
420 #ifdef PEGASUS_WRITE_EEPROM
421 static inline void enable_eprom_write(pegasus_t
* pegasus
)
426 get_registers(pegasus
, EthCtrl2
, 1, &tmp
);
427 set_register(pegasus
, EthCtrl2
, tmp
| EPROM_WR_ENABLE
);
430 static inline void disable_eprom_write(pegasus_t
* pegasus
)
435 get_registers(pegasus
, EthCtrl2
, 1, &tmp
);
436 set_register(pegasus
, EpromCtrl
, 0);
437 set_register(pegasus
, EthCtrl2
, tmp
& ~EPROM_WR_ENABLE
);
440 static int write_eprom_word(pegasus_t
* pegasus
, __u8 index
, __u16 data
)
443 __u8 tmp
, d
[4] = { 0x3f, 0, 0, EPROM_WRITE
};
446 set_registers(pegasus
, EpromOffset
, 4, d
);
447 enable_eprom_write(pegasus
);
448 set_register(pegasus
, EpromOffset
, index
);
449 set_registers(pegasus
, EpromData
, 2, &data
);
450 set_register(pegasus
, EpromCtrl
, EPROM_WRITE
);
452 for (i
= 0; i
< REG_TIMEOUT
; i
++) {
453 ret
= get_registers(pegasus
, EpromCtrl
, 1, &tmp
);
454 if (ret
== -ESHUTDOWN
)
456 if (tmp
& EPROM_DONE
)
459 disable_eprom_write(pegasus
);
463 if (netif_msg_drv(pegasus
))
464 dev_warn(&pegasus
->intf
->dev
, "%s failed\n", __FUNCTION__
);
467 #endif /* PEGASUS_WRITE_EEPROM */
469 static inline void get_node_id(pegasus_t
* pegasus
, __u8
* id
)
474 for (i
= 0; i
< 3; i
++) {
475 read_eprom_word(pegasus
, i
, &w16
);
476 ((__le16
*) id
)[i
] = cpu_to_le16p(&w16
);
480 static void set_ethernet_addr(pegasus_t
* pegasus
)
484 if (pegasus
->features
& PEGASUS_II
) {
485 get_registers(pegasus
, 0x10, sizeof(node_id
), node_id
);
487 get_node_id(pegasus
, node_id
);
488 set_registers(pegasus
, EthID
, sizeof (node_id
), node_id
);
490 memcpy(pegasus
->net
->dev_addr
, node_id
, sizeof (node_id
));
493 static inline int reset_mac(pegasus_t
* pegasus
)
498 set_register(pegasus
, EthCtrl1
, data
);
499 for (i
= 0; i
< REG_TIMEOUT
; i
++) {
500 get_registers(pegasus
, EthCtrl1
, 1, &data
);
504 if (mii_mode
&& (pegasus
->features
& HAS_HOME_PNA
))
505 set_register(pegasus
, Gpio1
, 0x34);
507 set_register(pegasus
, Gpio1
, 0x26);
508 set_register(pegasus
, Gpio0
, pegasus
->features
);
509 set_register(pegasus
, Gpio0
, DEFAULT_GPIO_SET
);
513 if (i
== REG_TIMEOUT
)
516 if (usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_LINKSYS
||
517 usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_DLINK
) {
518 set_register(pegasus
, Gpio0
, 0x24);
519 set_register(pegasus
, Gpio0
, 0x26);
521 if (usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_ELCON
) {
523 read_mii_word(pegasus
, 3, 0x1b, &auxmode
);
524 write_mii_word(pegasus
, 3, 0x1b, auxmode
| 4);
530 static int enable_net_traffic(struct net_device
*dev
, struct usb_device
*usb
)
534 pegasus_t
*pegasus
= netdev_priv(dev
);
537 read_mii_word(pegasus
, pegasus
->phy
, MII_LPA
, &linkpart
);
540 if (linkpart
& (ADVERTISE_100FULL
| ADVERTISE_10FULL
))
541 data
[1] |= 0x20; /* set full duplex */
542 if (linkpart
& (ADVERTISE_100FULL
| ADVERTISE_100HALF
))
543 data
[1] |= 0x10; /* set 100 Mbps */
546 data
[2] = (loopback
& 1) ? 0x09 : 0x01;
548 memcpy(pegasus
->eth_regs
, data
, sizeof (data
));
549 ret
= set_registers(pegasus
, EthCtrl0
, 3, data
);
551 if (usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_LINKSYS
||
552 usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_LINKSYS2
||
553 usb_dev_id
[pegasus
->dev_index
].vendor
== VENDOR_DLINK
) {
555 read_mii_word(pegasus
, 0, 0x1b, &auxmode
);
556 write_mii_word(pegasus
, 0, 0x1b, auxmode
| 4);
562 static void fill_skb_pool(pegasus_t
* pegasus
)
566 for (i
= 0; i
< RX_SKBS
; i
++) {
567 if (pegasus
->rx_pool
[i
])
569 pegasus
->rx_pool
[i
] = dev_alloc_skb(PEGASUS_MTU
+ 2);
571 ** we give up if the allocation fail. the tasklet will be
572 ** rescheduled again anyway...
574 if (pegasus
->rx_pool
[i
] == NULL
)
576 pegasus
->rx_pool
[i
]->dev
= pegasus
->net
;
577 skb_reserve(pegasus
->rx_pool
[i
], 2);
581 static void free_skb_pool(pegasus_t
* pegasus
)
585 for (i
= 0; i
< RX_SKBS
; i
++) {
586 if (pegasus
->rx_pool
[i
]) {
587 dev_kfree_skb(pegasus
->rx_pool
[i
]);
588 pegasus
->rx_pool
[i
] = NULL
;
593 static inline struct sk_buff
*pull_skb(pegasus_t
* pegasus
)
598 for (i
= 0; i
< RX_SKBS
; i
++) {
599 if (likely(pegasus
->rx_pool
[i
] != NULL
)) {
600 skb
= pegasus
->rx_pool
[i
];
601 pegasus
->rx_pool
[i
] = NULL
;
608 static void read_bulk_callback(struct urb
*urb
)
610 pegasus_t
*pegasus
= urb
->context
;
611 struct net_device
*net
;
612 int rx_status
, count
= urb
->actual_length
;
613 u8
*buf
= urb
->transfer_buffer
;
620 if (!netif_device_present(net
) || !netif_running(net
))
623 switch (urb
->status
) {
627 if (netif_msg_rx_err(pegasus
))
628 pr_debug("%s: reset MAC\n", net
->name
);
629 pegasus
->flags
&= ~PEGASUS_RX_BUSY
;
631 case -EPIPE
: /* stall, or disconnect from TT */
632 /* FIXME schedule work to clear the halt */
633 if (netif_msg_rx_err(pegasus
))
634 printk(KERN_WARNING
"%s: no rx stall recovery\n",
640 if (netif_msg_ifdown(pegasus
))
641 pr_debug("%s: rx unlink, %d\n", net
->name
, urb
->status
);
644 if (netif_msg_rx_err(pegasus
))
645 pr_debug("%s: RX status %d\n", net
->name
, urb
->status
);
649 if (!count
|| count
< 4)
652 rx_status
= buf
[count
- 2];
653 if (rx_status
& 0x1e) {
654 if (netif_msg_rx_err(pegasus
))
655 pr_debug("%s: RX packet error %x\n",
656 net
->name
, rx_status
);
657 pegasus
->stats
.rx_errors
++;
658 if (rx_status
& 0x06) // long or runt
659 pegasus
->stats
.rx_length_errors
++;
660 if (rx_status
& 0x08)
661 pegasus
->stats
.rx_crc_errors
++;
662 if (rx_status
& 0x10) // extra bits
663 pegasus
->stats
.rx_frame_errors
++;
666 if (pegasus
->chip
== 0x8513) {
667 pkt_len
= le32_to_cpu(*(__le32
*)urb
->transfer_buffer
);
669 pegasus
->rx_skb
->data
+= 2;
671 pkt_len
= buf
[count
- 3] << 8;
672 pkt_len
+= buf
[count
- 4];
678 * If the packet is unreasonably long, quietly drop it rather than
679 * kernel panicing by calling skb_put.
681 if (pkt_len
> PEGASUS_MTU
)
685 * at this point we are sure pegasus->rx_skb != NULL
686 * so we go ahead and pass up the packet.
688 skb_put(pegasus
->rx_skb
, pkt_len
);
689 pegasus
->rx_skb
->protocol
= eth_type_trans(pegasus
->rx_skb
, net
);
690 netif_rx(pegasus
->rx_skb
);
691 pegasus
->stats
.rx_packets
++;
692 pegasus
->stats
.rx_bytes
+= pkt_len
;
694 if (pegasus
->flags
& PEGASUS_UNPLUG
)
697 spin_lock(&pegasus
->rx_pool_lock
);
698 pegasus
->rx_skb
= pull_skb(pegasus
);
699 spin_unlock(&pegasus
->rx_pool_lock
);
701 if (pegasus
->rx_skb
== NULL
)
704 usb_fill_bulk_urb(pegasus
->rx_urb
, pegasus
->usb
,
705 usb_rcvbulkpipe(pegasus
->usb
, 1),
706 pegasus
->rx_skb
->data
, PEGASUS_MTU
+ 8,
707 read_bulk_callback
, pegasus
);
708 rx_status
= usb_submit_urb(pegasus
->rx_urb
, GFP_ATOMIC
);
709 if (rx_status
== -ENODEV
)
710 netif_device_detach(pegasus
->net
);
711 else if (rx_status
) {
712 pegasus
->flags
|= PEGASUS_RX_URB_FAIL
;
715 pegasus
->flags
&= ~PEGASUS_RX_URB_FAIL
;
721 tasklet_schedule(&pegasus
->rx_tl
);
724 static void rx_fixup(unsigned long data
)
730 pegasus
= (pegasus_t
*) data
;
731 if (pegasus
->flags
& PEGASUS_UNPLUG
)
734 spin_lock_irqsave(&pegasus
->rx_pool_lock
, flags
);
735 fill_skb_pool(pegasus
);
736 if (pegasus
->flags
& PEGASUS_RX_URB_FAIL
)
739 if (pegasus
->rx_skb
== NULL
) {
740 pegasus
->rx_skb
= pull_skb(pegasus
);
742 if (pegasus
->rx_skb
== NULL
) {
743 if (netif_msg_rx_err(pegasus
))
744 printk(KERN_WARNING
"%s: low on memory\n",
746 tasklet_schedule(&pegasus
->rx_tl
);
749 usb_fill_bulk_urb(pegasus
->rx_urb
, pegasus
->usb
,
750 usb_rcvbulkpipe(pegasus
->usb
, 1),
751 pegasus
->rx_skb
->data
, PEGASUS_MTU
+ 8,
752 read_bulk_callback
, pegasus
);
754 status
= usb_submit_urb(pegasus
->rx_urb
, GFP_ATOMIC
);
755 if (status
== -ENODEV
)
756 netif_device_detach(pegasus
->net
);
758 pegasus
->flags
|= PEGASUS_RX_URB_FAIL
;
759 tasklet_schedule(&pegasus
->rx_tl
);
761 pegasus
->flags
&= ~PEGASUS_RX_URB_FAIL
;
764 spin_unlock_irqrestore(&pegasus
->rx_pool_lock
, flags
);
767 static void write_bulk_callback(struct urb
*urb
)
769 pegasus_t
*pegasus
= urb
->context
;
770 struct net_device
*net
= pegasus
->net
;
775 if (!netif_device_present(net
) || !netif_running(net
))
778 switch (urb
->status
) {
780 /* FIXME schedule_work() to clear the tx halt */
781 netif_stop_queue(net
);
782 if (netif_msg_tx_err(pegasus
))
783 printk(KERN_WARNING
"%s: no tx stall recovery\n",
789 if (netif_msg_ifdown(pegasus
))
790 pr_debug("%s: tx unlink, %d\n", net
->name
, urb
->status
);
793 if (netif_msg_tx_err(pegasus
))
794 pr_info("%s: TX status %d\n", net
->name
, urb
->status
);
800 net
->trans_start
= jiffies
;
801 netif_wake_queue(net
);
804 static void intr_callback(struct urb
*urb
)
806 pegasus_t
*pegasus
= urb
->context
;
807 struct net_device
*net
;
814 switch (urb
->status
) {
817 case -ECONNRESET
: /* unlink */
822 /* some Pegasus-I products report LOTS of data
823 * toggle errors... avoid log spamming
825 if (netif_msg_timer(pegasus
))
826 pr_debug("%s: intr status %d\n", net
->name
,
830 if (urb
->actual_length
>= 6) {
831 u8
* d
= urb
->transfer_buffer
;
833 /* byte 0 == tx_status1, reg 2B */
834 if (d
[0] & (TX_UNDERRUN
|EXCESSIVE_COL
835 |LATE_COL
|JABBER_TIMEOUT
)) {
836 pegasus
->stats
.tx_errors
++;
837 if (d
[0] & TX_UNDERRUN
)
838 pegasus
->stats
.tx_fifo_errors
++;
839 if (d
[0] & (EXCESSIVE_COL
| JABBER_TIMEOUT
))
840 pegasus
->stats
.tx_aborted_errors
++;
842 pegasus
->stats
.tx_window_errors
++;
845 /* d[5].LINK_STATUS lies on some adapters.
846 * d[0].NO_CARRIER kicks in only with failed TX.
847 * ... so monitoring with MII may be safest.
849 if (d
[0] & NO_CARRIER
)
850 netif_carrier_off(net
);
852 netif_carrier_on(net
);
854 /* bytes 3-4 == rx_lostpkt, reg 2E/2F */
855 pegasus
->stats
.rx_missed_errors
+= ((d
[3] & 0x7f) << 8) | d
[4];
858 status
= usb_submit_urb(urb
, SLAB_ATOMIC
);
859 if (status
== -ENODEV
)
860 netif_device_detach(pegasus
->net
);
861 if (status
&& netif_msg_timer(pegasus
))
862 printk(KERN_ERR
"%s: can't resubmit interrupt urb, %d\n",
866 static void pegasus_tx_timeout(struct net_device
*net
)
868 pegasus_t
*pegasus
= netdev_priv(net
);
869 if (netif_msg_timer(pegasus
))
870 printk(KERN_WARNING
"%s: tx timeout\n", net
->name
);
871 usb_unlink_urb(pegasus
->tx_urb
);
872 pegasus
->stats
.tx_errors
++;
875 static int pegasus_start_xmit(struct sk_buff
*skb
, struct net_device
*net
)
877 pegasus_t
*pegasus
= netdev_priv(net
);
878 int count
= ((skb
->len
+ 2) & 0x3f) ? skb
->len
+ 2 : skb
->len
+ 3;
880 __u16 l16
= skb
->len
;
882 netif_stop_queue(net
);
884 ((__le16
*) pegasus
->tx_buff
)[0] = cpu_to_le16(l16
);
885 memcpy(pegasus
->tx_buff
+ 2, skb
->data
, skb
->len
);
886 usb_fill_bulk_urb(pegasus
->tx_urb
, pegasus
->usb
,
887 usb_sndbulkpipe(pegasus
->usb
, 2),
888 pegasus
->tx_buff
, count
,
889 write_bulk_callback
, pegasus
);
890 if ((res
= usb_submit_urb(pegasus
->tx_urb
, GFP_ATOMIC
))) {
891 if (netif_msg_tx_err(pegasus
))
892 printk(KERN_WARNING
"%s: fail tx, %d\n",
895 case -EPIPE
: /* stall, or disconnect from TT */
896 /* cleanup should already have been scheduled */
898 case -ENODEV
: /* disconnect() upcoming */
899 netif_device_detach(pegasus
->net
);
902 pegasus
->stats
.tx_errors
++;
903 netif_start_queue(net
);
906 pegasus
->stats
.tx_packets
++;
907 pegasus
->stats
.tx_bytes
+= skb
->len
;
908 net
->trans_start
= jiffies
;
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
)
924 set_registers(pegasus
, EthCtrl0
, 2, &tmp
);
927 static inline void get_interrupt_interval(pegasus_t
* pegasus
)
931 read_eprom_word(pegasus
, 4, (__u16
*) data
);
932 if (pegasus
->usb
->speed
!= USB_SPEED_HIGH
) {
933 if (data
[1] < 0x80) {
934 if (netif_msg_timer(pegasus
))
935 dev_info(&pegasus
->intf
->dev
, "intr interval "
936 "changed from %ums to %ums\n",
939 #ifdef PEGASUS_WRITE_EEPROM
940 write_eprom_word(pegasus
, 4, *(__u16
*) data
);
944 pegasus
->intr_interval
= data
[1];
947 static void set_carrier(struct net_device
*net
)
949 pegasus_t
*pegasus
= netdev_priv(net
);
952 if (!read_mii_word(pegasus
, pegasus
->phy
, MII_BMSR
, &tmp
))
955 if (tmp
& BMSR_LSTATUS
)
956 netif_carrier_on(net
);
958 netif_carrier_off(net
);
961 static void free_all_urbs(pegasus_t
* pegasus
)
963 usb_free_urb(pegasus
->intr_urb
);
964 usb_free_urb(pegasus
->tx_urb
);
965 usb_free_urb(pegasus
->rx_urb
);
966 usb_free_urb(pegasus
->ctrl_urb
);
969 static void unlink_all_urbs(pegasus_t
* pegasus
)
971 usb_kill_urb(pegasus
->intr_urb
);
972 usb_kill_urb(pegasus
->tx_urb
);
973 usb_kill_urb(pegasus
->rx_urb
);
974 usb_kill_urb(pegasus
->ctrl_urb
);
977 static int alloc_urbs(pegasus_t
* pegasus
)
979 pegasus
->ctrl_urb
= usb_alloc_urb(0, GFP_KERNEL
);
980 if (!pegasus
->ctrl_urb
) {
983 pegasus
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
984 if (!pegasus
->rx_urb
) {
985 usb_free_urb(pegasus
->ctrl_urb
);
988 pegasus
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
989 if (!pegasus
->tx_urb
) {
990 usb_free_urb(pegasus
->rx_urb
);
991 usb_free_urb(pegasus
->ctrl_urb
);
994 pegasus
->intr_urb
= usb_alloc_urb(0, GFP_KERNEL
);
995 if (!pegasus
->intr_urb
) {
996 usb_free_urb(pegasus
->tx_urb
);
997 usb_free_urb(pegasus
->rx_urb
);
998 usb_free_urb(pegasus
->ctrl_urb
);
1005 static int pegasus_open(struct net_device
*net
)
1007 pegasus_t
*pegasus
= netdev_priv(net
);
1010 if (pegasus
->rx_skb
== NULL
)
1011 pegasus
->rx_skb
= pull_skb(pegasus
);
1013 ** Note: no point to free the pool. it is empty :-)
1015 if (!pegasus
->rx_skb
)
1018 res
= set_registers(pegasus
, EthID
, 6, net
->dev_addr
);
1020 usb_fill_bulk_urb(pegasus
->rx_urb
, pegasus
->usb
,
1021 usb_rcvbulkpipe(pegasus
->usb
, 1),
1022 pegasus
->rx_skb
->data
, PEGASUS_MTU
+ 8,
1023 read_bulk_callback
, pegasus
);
1024 if ((res
= usb_submit_urb(pegasus
->rx_urb
, GFP_KERNEL
))) {
1026 netif_device_detach(pegasus
->net
);
1027 if (netif_msg_ifup(pegasus
))
1028 pr_debug("%s: failed rx_urb, %d", net
->name
, 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 if (netif_msg_ifup(pegasus
))
1040 pr_debug("%s: failed intr_urb, %d\n", net
->name
, res
);
1041 usb_kill_urb(pegasus
->rx_urb
);
1044 if ((res
= enable_net_traffic(net
, pegasus
->usb
))) {
1045 if (netif_msg_ifup(pegasus
))
1046 pr_debug("%s: can't enable_net_traffic() - %d\n",
1049 usb_kill_urb(pegasus
->rx_urb
);
1050 usb_kill_urb(pegasus
->intr_urb
);
1051 free_skb_pool(pegasus
);
1055 netif_start_queue(net
);
1056 if (netif_msg_ifup(pegasus
))
1057 pr_debug("%s: open\n", net
->name
);
1063 static int pegasus_close(struct net_device
*net
)
1065 pegasus_t
*pegasus
= netdev_priv(net
);
1067 netif_stop_queue(net
);
1068 if (!(pegasus
->flags
& PEGASUS_UNPLUG
))
1069 disable_net_traffic(pegasus
);
1070 tasklet_kill(&pegasus
->rx_tl
);
1071 unlink_all_urbs(pegasus
);
1076 static void pegasus_get_drvinfo(struct net_device
*dev
,
1077 struct ethtool_drvinfo
*info
)
1079 pegasus_t
*pegasus
= netdev_priv(dev
);
1080 strncpy(info
->driver
, driver_name
, sizeof (info
->driver
) - 1);
1081 strncpy(info
->version
, DRIVER_VERSION
, sizeof (info
->version
) - 1);
1082 usb_make_path(pegasus
->usb
, info
->bus_info
, sizeof (info
->bus_info
));
1085 /* also handles three patterns of some kind in hardware */
1086 #define WOL_SUPPORTED (WAKE_MAGIC|WAKE_PHY)
1089 pegasus_get_wol(struct net_device
*dev
, struct ethtool_wolinfo
*wol
)
1091 pegasus_t
*pegasus
= netdev_priv(dev
);
1093 wol
->supported
= WAKE_MAGIC
| WAKE_PHY
;
1094 wol
->wolopts
= pegasus
->wolopts
;
1098 pegasus_set_wol(struct net_device
*dev
, struct ethtool_wolinfo
*wol
)
1100 pegasus_t
*pegasus
= netdev_priv(dev
);
1103 if (wol
->wolopts
& ~WOL_SUPPORTED
)
1106 if (wol
->wolopts
& WAKE_MAGIC
)
1108 if (wol
->wolopts
& WAKE_PHY
)
1110 /* FIXME this 0x10 bit still needs to get set in the chip... */
1112 pegasus
->eth_regs
[0] |= 0x10;
1114 pegasus
->eth_regs
[0] &= ~0x10;
1115 pegasus
->wolopts
= wol
->wolopts
;
1116 return set_register(pegasus
, WakeupControl
, reg78
);
1119 static inline void pegasus_reset_wol(struct net_device
*dev
)
1121 struct ethtool_wolinfo wol
;
1123 memset(&wol
, 0, sizeof wol
);
1124 (void) pegasus_set_wol(dev
, &wol
);
1128 pegasus_get_settings(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1135 pegasus
= netdev_priv(dev
);
1136 mii_ethtool_gset(&pegasus
->mii
, ecmd
);
1142 pegasus_set_settings(struct net_device
*dev
, struct ethtool_cmd
*ecmd
)
1144 pegasus_t
*pegasus
= netdev_priv(dev
);
1145 return mii_ethtool_sset(&pegasus
->mii
, ecmd
);
1148 static int pegasus_nway_reset(struct net_device
*dev
)
1150 pegasus_t
*pegasus
= netdev_priv(dev
);
1151 return mii_nway_restart(&pegasus
->mii
);
1154 static u32
pegasus_get_link(struct net_device
*dev
)
1156 pegasus_t
*pegasus
= netdev_priv(dev
);
1157 return mii_link_ok(&pegasus
->mii
);
1160 static u32
pegasus_get_msglevel(struct net_device
*dev
)
1162 pegasus_t
*pegasus
= netdev_priv(dev
);
1163 return pegasus
->msg_enable
;
1166 static void pegasus_set_msglevel(struct net_device
*dev
, u32 v
)
1168 pegasus_t
*pegasus
= netdev_priv(dev
);
1169 pegasus
->msg_enable
= v
;
1172 static struct ethtool_ops ops
= {
1173 .get_drvinfo
= pegasus_get_drvinfo
,
1174 .get_settings
= pegasus_get_settings
,
1175 .set_settings
= pegasus_set_settings
,
1176 .nway_reset
= pegasus_nway_reset
,
1177 .get_link
= pegasus_get_link
,
1178 .get_msglevel
= pegasus_get_msglevel
,
1179 .set_msglevel
= pegasus_set_msglevel
,
1180 .get_wol
= pegasus_get_wol
,
1181 .set_wol
= pegasus_set_wol
,
1184 static int pegasus_ioctl(struct net_device
*net
, struct ifreq
*rq
, int cmd
)
1186 __u16
*data
= (__u16
*) & rq
->ifr_ifru
;
1187 pegasus_t
*pegasus
= netdev_priv(net
);
1191 case SIOCDEVPRIVATE
:
1192 data
[0] = pegasus
->phy
;
1193 case SIOCDEVPRIVATE
+ 1:
1194 read_mii_word(pegasus
, data
[0], data
[1] & 0x1f, &data
[3]);
1197 case SIOCDEVPRIVATE
+ 2:
1198 if (!capable(CAP_NET_ADMIN
))
1200 write_mii_word(pegasus
, pegasus
->phy
, data
[1] & 0x1f, data
[2]);
1209 static void pegasus_set_multicast(struct net_device
*net
)
1211 pegasus_t
*pegasus
= netdev_priv(net
);
1213 if (net
->flags
& IFF_PROMISC
) {
1214 pegasus
->eth_regs
[EthCtrl2
] |= RX_PROMISCUOUS
;
1215 if (netif_msg_link(pegasus
))
1216 pr_info("%s: Promiscuous mode enabled.\n", net
->name
);
1217 } else if (net
->mc_count
||
1218 (net
->flags
& IFF_ALLMULTI
)) {
1219 pegasus
->eth_regs
[EthCtrl0
] |= RX_MULTICAST
;
1220 pegasus
->eth_regs
[EthCtrl2
] &= ~RX_PROMISCUOUS
;
1221 if (netif_msg_link(pegasus
))
1222 pr_info("%s: set allmulti\n", net
->name
);
1224 pegasus
->eth_regs
[EthCtrl0
] &= ~RX_MULTICAST
;
1225 pegasus
->eth_regs
[EthCtrl2
] &= ~RX_PROMISCUOUS
;
1228 pegasus
->flags
|= ETH_REGS_CHANGE
;
1229 ctrl_callback(pegasus
->ctrl_urb
);
1232 static __u8
mii_phy_probe(pegasus_t
* pegasus
)
1237 for (i
= 0; i
< 32; i
++) {
1238 read_mii_word(pegasus
, i
, MII_BMSR
, &tmp
);
1239 if (tmp
== 0 || tmp
== 0xffff || (tmp
& BMSR_MEDIA
) == 0)
1248 static inline void setup_pegasus_II(pegasus_t
* pegasus
)
1252 set_register(pegasus
, Reg1d
, 0);
1253 set_register(pegasus
, Reg7b
, 1);
1255 if ((pegasus
->features
& HAS_HOME_PNA
) && mii_mode
)
1256 set_register(pegasus
, Reg7b
, 0);
1258 set_register(pegasus
, Reg7b
, 2);
1260 set_register(pegasus
, 0x83, data
);
1261 get_registers(pegasus
, 0x83, 1, &data
);
1264 pegasus
->chip
= 0x8513;
1269 set_register(pegasus
, 0x80, 0xc0);
1270 set_register(pegasus
, 0x83, 0xff);
1271 set_register(pegasus
, 0x84, 0x01);
1273 if (pegasus
->features
& HAS_HOME_PNA
&& mii_mode
)
1274 set_register(pegasus
, Reg81
, 6);
1276 set_register(pegasus
, Reg81
, 2);
1280 static struct workqueue_struct
*pegasus_workqueue
= NULL
;
1281 #define CARRIER_CHECK_DELAY (2 * HZ)
1283 static void check_carrier(struct work_struct
*work
)
1285 pegasus_t
*pegasus
= container_of(work
, pegasus_t
, carrier_check
.work
);
1286 set_carrier(pegasus
->net
);
1287 if (!(pegasus
->flags
& PEGASUS_UNPLUG
)) {
1288 queue_delayed_work(pegasus_workqueue
, &pegasus
->carrier_check
,
1289 CARRIER_CHECK_DELAY
);
1293 static int pegasus_probe(struct usb_interface
*intf
,
1294 const struct usb_device_id
*id
)
1296 struct usb_device
*dev
= interface_to_usbdev(intf
);
1297 struct net_device
*net
;
1299 int dev_index
= id
- pegasus_ids
;
1303 net
= alloc_etherdev(sizeof(struct pegasus
));
1305 dev_err(&intf
->dev
, "can't allocate %s\n", "device");
1309 pegasus
= netdev_priv(net
);
1310 memset(pegasus
, 0, sizeof (struct pegasus
));
1311 pegasus
->dev_index
= dev_index
;
1312 init_waitqueue_head(&pegasus
->ctrl_wait
);
1314 if (!alloc_urbs(pegasus
)) {
1315 dev_err(&intf
->dev
, "can't allocate %s\n", "urbs");
1319 tasklet_init(&pegasus
->rx_tl
, rx_fixup
, (unsigned long) pegasus
);
1321 INIT_DELAYED_WORK(&pegasus
->carrier_check
, check_carrier
);
1323 pegasus
->intf
= intf
;
1326 SET_MODULE_OWNER(net
);
1327 net
->open
= pegasus_open
;
1328 net
->stop
= pegasus_close
;
1329 net
->watchdog_timeo
= PEGASUS_TX_TIMEOUT
;
1330 net
->tx_timeout
= pegasus_tx_timeout
;
1331 net
->do_ioctl
= pegasus_ioctl
;
1332 net
->hard_start_xmit
= pegasus_start_xmit
;
1333 net
->set_multicast_list
= pegasus_set_multicast
;
1334 net
->get_stats
= pegasus_netdev_stats
;
1335 SET_ETHTOOL_OPS(net
, &ops
);
1336 pegasus
->mii
.dev
= net
;
1337 pegasus
->mii
.mdio_read
= mdio_read
;
1338 pegasus
->mii
.mdio_write
= mdio_write
;
1339 pegasus
->mii
.phy_id_mask
= 0x1f;
1340 pegasus
->mii
.reg_num_mask
= 0x1f;
1341 spin_lock_init(&pegasus
->rx_pool_lock
);
1342 pegasus
->msg_enable
= netif_msg_init (msg_level
, NETIF_MSG_DRV
1343 | NETIF_MSG_PROBE
| NETIF_MSG_LINK
);
1345 pegasus
->features
= usb_dev_id
[dev_index
].private;
1346 get_interrupt_interval(pegasus
);
1347 if (reset_mac(pegasus
)) {
1348 dev_err(&intf
->dev
, "can't reset MAC\n");
1352 set_ethernet_addr(pegasus
);
1353 fill_skb_pool(pegasus
);
1354 if (pegasus
->features
& PEGASUS_II
) {
1355 dev_info(&intf
->dev
, "setup Pegasus II specific registers\n");
1356 setup_pegasus_II(pegasus
);
1358 pegasus
->phy
= mii_phy_probe(pegasus
);
1359 if (pegasus
->phy
== 0xff) {
1360 dev_warn(&intf
->dev
, "can't locate MII phy, using default\n");
1363 pegasus
->mii
.phy_id
= pegasus
->phy
;
1364 usb_set_intfdata(intf
, pegasus
);
1365 SET_NETDEV_DEV(net
, &intf
->dev
);
1366 pegasus_reset_wol(net
);
1367 res
= register_netdev(net
);
1370 queue_delayed_work(pegasus_workqueue
, &pegasus
->carrier_check
,
1371 CARRIER_CHECK_DELAY
);
1373 dev_info(&intf
->dev
, "%s, %s, %02x:%02x:%02x:%02x:%02x:%02x\n",
1375 usb_dev_id
[dev_index
].name
,
1376 net
->dev_addr
[0], net
->dev_addr
[1],
1377 net
->dev_addr
[2], net
->dev_addr
[3],
1378 net
->dev_addr
[4], net
->dev_addr
[5]);
1382 usb_set_intfdata(intf
, NULL
);
1383 free_skb_pool(pegasus
);
1385 free_all_urbs(pegasus
);
1393 static void pegasus_disconnect(struct usb_interface
*intf
)
1395 struct pegasus
*pegasus
= usb_get_intfdata(intf
);
1397 usb_set_intfdata(intf
, NULL
);
1399 dev_dbg(&intf
->dev
, "unregistering non-bound device?\n");
1403 pegasus
->flags
|= PEGASUS_UNPLUG
;
1404 cancel_delayed_work(&pegasus
->carrier_check
);
1405 unregister_netdev(pegasus
->net
);
1406 usb_put_dev(interface_to_usbdev(intf
));
1407 unlink_all_urbs(pegasus
);
1408 free_all_urbs(pegasus
);
1409 free_skb_pool(pegasus
);
1410 if (pegasus
->rx_skb
)
1411 dev_kfree_skb(pegasus
->rx_skb
);
1412 free_netdev(pegasus
->net
);
1415 static int pegasus_suspend (struct usb_interface
*intf
, pm_message_t message
)
1417 struct pegasus
*pegasus
= usb_get_intfdata(intf
);
1419 netif_device_detach (pegasus
->net
);
1420 cancel_delayed_work(&pegasus
->carrier_check
);
1421 if (netif_running(pegasus
->net
)) {
1422 usb_kill_urb(pegasus
->rx_urb
);
1423 usb_kill_urb(pegasus
->intr_urb
);
1428 static int pegasus_resume (struct usb_interface
*intf
)
1430 struct pegasus
*pegasus
= usb_get_intfdata(intf
);
1432 netif_device_attach (pegasus
->net
);
1433 if (netif_running(pegasus
->net
)) {
1434 pegasus
->rx_urb
->status
= 0;
1435 pegasus
->rx_urb
->actual_length
= 0;
1436 read_bulk_callback(pegasus
->rx_urb
);
1438 pegasus
->intr_urb
->status
= 0;
1439 pegasus
->intr_urb
->actual_length
= 0;
1440 intr_callback(pegasus
->intr_urb
);
1442 queue_delayed_work(pegasus_workqueue
, &pegasus
->carrier_check
,
1443 CARRIER_CHECK_DELAY
);
1447 static struct usb_driver pegasus_driver
= {
1448 .name
= driver_name
,
1449 .probe
= pegasus_probe
,
1450 .disconnect
= pegasus_disconnect
,
1451 .id_table
= pegasus_ids
,
1452 .suspend
= pegasus_suspend
,
1453 .resume
= pegasus_resume
,
1456 static void parse_id(char *id
)
1458 unsigned int vendor_id
=0, device_id
=0, flags
=0, i
=0;
1459 char *token
, *name
=NULL
;
1461 if ((token
= strsep(&id
, ":")) != NULL
)
1463 /* name now points to a null terminated string*/
1464 if ((token
= strsep(&id
, ":")) != NULL
)
1465 vendor_id
= simple_strtoul(token
, NULL
, 16);
1466 if ((token
= strsep(&id
, ":")) != NULL
)
1467 device_id
= simple_strtoul(token
, NULL
, 16);
1468 flags
= simple_strtoul(id
, NULL
, 16);
1469 pr_info("%s: new device %s, vendor ID 0x%04x, device ID 0x%04x, flags: 0x%x\n",
1470 driver_name
, name
, vendor_id
, device_id
, flags
);
1472 if (vendor_id
> 0x10000 || vendor_id
== 0)
1474 if (device_id
> 0x10000 || device_id
== 0)
1477 for (i
=0; usb_dev_id
[i
].name
; i
++);
1478 usb_dev_id
[i
].name
= name
;
1479 usb_dev_id
[i
].vendor
= vendor_id
;
1480 usb_dev_id
[i
].device
= device_id
;
1481 usb_dev_id
[i
].private = flags
;
1482 pegasus_ids
[i
].match_flags
= USB_DEVICE_ID_MATCH_DEVICE
;
1483 pegasus_ids
[i
].idVendor
= vendor_id
;
1484 pegasus_ids
[i
].idProduct
= device_id
;
1487 static int __init
pegasus_init(void)
1489 pr_info("%s: %s, " DRIVER_DESC
"\n", driver_name
, DRIVER_VERSION
);
1492 pegasus_workqueue
= create_singlethread_workqueue("pegasus");
1493 if (!pegasus_workqueue
)
1495 return usb_register(&pegasus_driver
);
1498 static void __exit
pegasus_exit(void)
1500 destroy_workqueue(pegasus_workqueue
);
1501 usb_deregister(&pegasus_driver
);
1504 module_init(pegasus_init
);
1505 module_exit(pegasus_exit
);