2 * Copyright (c) 1999-2003 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.5.12 (2003/06/06)"
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 int multicast_filter_limit = 32;
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},
70 static struct usb_device_id pegasus_ids[] = {
71 #define PEGASUS_DEV(pn, vid, pid, flags) \
72 {.match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = vid, .idProduct = pid},
78 MODULE_AUTHOR(DRIVER_AUTHOR);
79 MODULE_DESCRIPTION(DRIVER_DESC);
80 MODULE_LICENSE("GPL");
81 module_param(loopback, bool, 0);
82 module_param(mii_mode, bool, 0);
83 MODULE_PARM_DESC(loopback, "Enable MAC loopback mode (bit 0)");
84 MODULE_PARM_DESC(mii_mode, "Enable HomePNA mode (bit 0),default=MII mode = 0");
86 MODULE_DEVICE_TABLE(usb, pegasus_ids);
88 static int update_eth_regs_async(pegasus_t *);
89 /* Aargh!!! I _really_ hate such tweaks */
90 static void ctrl_callback(struct urb *urb, struct pt_regs *regs)
92 pegasus_t *pegasus = urb->context;
97 switch (urb->status) {
99 if (pegasus->flags & ETH_REGS_CHANGE) {
100 pegasus->flags &= ~ETH_REGS_CHANGE;
101 pegasus->flags |= ETH_REGS_CHANGED;
102 update_eth_regs_async(pegasus);
111 warn("%s: status %d", __FUNCTION__, urb->status);
113 pegasus->flags &= ~ETH_REGS_CHANGED;
114 wake_up(&pegasus->ctrl_wait);
117 static int get_registers(pegasus_t * pegasus, __u16 indx, __u16 size,
122 DECLARE_WAITQUEUE(wait, current);
124 buffer = kmalloc(size, GFP_KERNEL);
126 warn("%s: looks like we're out of memory", __FUNCTION__);
129 add_wait_queue(&pegasus->ctrl_wait, &wait);
130 set_current_state(TASK_UNINTERRUPTIBLE);
131 while (pegasus->flags & ETH_REGS_CHANGED)
133 remove_wait_queue(&pegasus->ctrl_wait, &wait);
134 set_current_state(TASK_RUNNING);
136 pegasus->dr.bRequestType = PEGASUS_REQT_READ;
137 pegasus->dr.bRequest = PEGASUS_REQ_GET_REGS;
138 pegasus->dr.wValue = cpu_to_le16(0);
139 pegasus->dr.wIndex = cpu_to_le16p(&indx);
140 pegasus->dr.wLength = cpu_to_le16p(&size);
141 pegasus->ctrl_urb->transfer_buffer_length = size;
143 usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
144 usb_rcvctrlpipe(pegasus->usb, 0),
145 (char *) &pegasus->dr,
146 buffer, size, ctrl_callback, pegasus);
148 add_wait_queue(&pegasus->ctrl_wait, &wait);
149 set_current_state(TASK_UNINTERRUPTIBLE);
151 /* using ATOMIC, we'd never wake up if we slept */
152 if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC))) {
153 err("%s: BAD CTRLs %d", __FUNCTION__, ret);
159 remove_wait_queue(&pegasus->ctrl_wait, &wait);
160 memcpy(data, buffer, size);
166 static int set_registers(pegasus_t * pegasus, __u16 indx, __u16 size,
171 DECLARE_WAITQUEUE(wait, current);
173 buffer = kmalloc(size, GFP_KERNEL);
175 warn("%s: looks like we're out of memory", __FUNCTION__);
178 memcpy(buffer, data, size);
180 add_wait_queue(&pegasus->ctrl_wait, &wait);
181 set_current_state(TASK_UNINTERRUPTIBLE);
182 while (pegasus->flags & ETH_REGS_CHANGED)
184 remove_wait_queue(&pegasus->ctrl_wait, &wait);
185 set_current_state(TASK_RUNNING);
187 pegasus->dr.bRequestType = PEGASUS_REQT_WRITE;
188 pegasus->dr.bRequest = PEGASUS_REQ_SET_REGS;
189 pegasus->dr.wValue = cpu_to_le16(0);
190 pegasus->dr.wIndex = cpu_to_le16p(&indx);
191 pegasus->dr.wLength = cpu_to_le16p(&size);
192 pegasus->ctrl_urb->transfer_buffer_length = size;
194 usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
195 usb_sndctrlpipe(pegasus->usb, 0),
196 (char *) &pegasus->dr,
197 buffer, size, ctrl_callback, pegasus);
199 add_wait_queue(&pegasus->ctrl_wait, &wait);
200 set_current_state(TASK_UNINTERRUPTIBLE);
202 if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC))) {
203 err("%s: BAD CTRL %d", __FUNCTION__, ret);
209 remove_wait_queue(&pegasus->ctrl_wait, &wait);
215 static int set_register(pegasus_t * pegasus, __u16 indx, __u8 data)
219 DECLARE_WAITQUEUE(wait, current);
221 tmp = kmalloc(1, GFP_KERNEL);
223 warn("%s: looks like we're out of memory", __FUNCTION__);
226 memcpy(tmp, &data, 1);
227 add_wait_queue(&pegasus->ctrl_wait, &wait);
228 set_current_state(TASK_UNINTERRUPTIBLE);
229 while (pegasus->flags & ETH_REGS_CHANGED)
231 remove_wait_queue(&pegasus->ctrl_wait, &wait);
232 set_current_state(TASK_RUNNING);
234 pegasus->dr.bRequestType = PEGASUS_REQT_WRITE;
235 pegasus->dr.bRequest = PEGASUS_REQ_SET_REG;
236 pegasus->dr.wValue = cpu_to_le16(data);
237 pegasus->dr.wIndex = cpu_to_le16p(&indx);
238 pegasus->dr.wLength = cpu_to_le16(1);
239 pegasus->ctrl_urb->transfer_buffer_length = 1;
241 usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
242 usb_sndctrlpipe(pegasus->usb, 0),
243 (char *) &pegasus->dr,
244 &tmp, 1, ctrl_callback, pegasus);
246 add_wait_queue(&pegasus->ctrl_wait, &wait);
247 set_current_state(TASK_UNINTERRUPTIBLE);
249 if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC))) {
250 err("%s: BAD CTRL %d", __FUNCTION__, ret);
256 remove_wait_queue(&pegasus->ctrl_wait, &wait);
262 static int update_eth_regs_async(pegasus_t * pegasus)
266 pegasus->dr.bRequestType = PEGASUS_REQT_WRITE;
267 pegasus->dr.bRequest = PEGASUS_REQ_SET_REGS;
268 pegasus->dr.wValue = 0;
269 pegasus->dr.wIndex = cpu_to_le16(EthCtrl0);
270 pegasus->dr.wLength = cpu_to_le16(3);
271 pegasus->ctrl_urb->transfer_buffer_length = 3;
273 usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
274 usb_sndctrlpipe(pegasus->usb, 0),
275 (char *) &pegasus->dr,
276 pegasus->eth_regs, 3, ctrl_callback, pegasus);
278 if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC)))
279 err("%s: BAD CTRL %d, flgs %x", __FUNCTION__, ret,
285 static int read_mii_word(pegasus_t * pegasus, __u8 phy, __u8 indx, __u16 * regd)
288 __u8 data[4] = { phy, 0, 0, indx };
291 set_register(pegasus, PhyCtrl, 0);
292 set_registers(pegasus, PhyAddr, sizeof (data), data);
293 set_register(pegasus, PhyCtrl, (indx | PHY_READ));
294 for (i = 0; i < REG_TIMEOUT; i++) {
295 get_registers(pegasus, PhyCtrl, 1, data);
296 if (data[0] & PHY_DONE)
299 if (i < REG_TIMEOUT) {
300 get_registers(pegasus, PhyData, 2, ®di);
301 *regd = le16_to_cpu(regdi);
304 warn("%s: failed", __FUNCTION__);
309 static int mdio_read(struct net_device *dev, int phy_id, int loc)
311 pegasus_t *pegasus = (pegasus_t *) dev->priv;
314 read_mii_word(pegasus, phy_id, loc, (u16 *) & res);
318 static int write_mii_word(pegasus_t * pegasus, __u8 phy, __u8 indx, __u16 regd)
321 __u8 data[4] = { phy, 0, 0, indx };
323 *(data + 1) = cpu_to_le16p(®d);
324 set_register(pegasus, PhyCtrl, 0);
325 set_registers(pegasus, PhyAddr, 4, data);
326 set_register(pegasus, PhyCtrl, (indx | PHY_WRITE));
327 for (i = 0; i < REG_TIMEOUT; i++) {
328 get_registers(pegasus, PhyCtrl, 1, data);
329 if (data[0] & PHY_DONE)
334 warn("%s: failed", __FUNCTION__);
339 static void mdio_write(struct net_device *dev, int phy_id, int loc, int val)
341 pegasus_t *pegasus = (pegasus_t *) dev->priv;
343 write_mii_word(pegasus, phy_id, loc, val);
346 static int read_eprom_word(pegasus_t * pegasus, __u8 index, __u16 * retdata)
352 set_register(pegasus, EpromCtrl, 0);
353 set_register(pegasus, EpromOffset, index);
354 set_register(pegasus, EpromCtrl, EPROM_READ);
356 for (i = 0; i < REG_TIMEOUT; i++) {
357 get_registers(pegasus, EpromCtrl, 1, &tmp);
358 if (tmp & EPROM_DONE)
361 if (i < REG_TIMEOUT) {
362 get_registers(pegasus, EpromData, 2, &retdatai);
363 *retdata = le16_to_cpu(retdatai);
366 warn("%s: failed", __FUNCTION__);
371 #ifdef PEGASUS_WRITE_EEPROM
372 static inline void enable_eprom_write(pegasus_t * pegasus)
376 get_registers(pegasus, EthCtrl2, 1, &tmp);
377 set_register(pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE);
380 static inline void disable_eprom_write(pegasus_t * pegasus)
384 get_registers(pegasus, EthCtrl2, 1, &tmp);
385 set_register(pegasus, EpromCtrl, 0);
386 set_register(pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE);
389 static int write_eprom_word(pegasus_t * pegasus, __u8 index, __u16 data)
392 __u8 d[4] = { 0x3f, 0, 0, EPROM_WRITE };
394 set_registers(pegasus, EpromOffset, 4, d);
395 enable_eprom_write(pegasus);
396 set_register(pegasus, EpromOffset, index);
397 set_registers(pegasus, EpromData, 2, &data);
398 set_register(pegasus, EpromCtrl, EPROM_WRITE);
400 for (i = 0; i < REG_TIMEOUT; i++) {
401 get_registers(pegasus, EpromCtrl, 1, &tmp);
402 if (tmp & EPROM_DONE)
405 disable_eprom_write(pegasus);
408 warn("%s: failed", __FUNCTION__);
411 #endif /* PEGASUS_WRITE_EEPROM */
413 static inline void get_node_id(pegasus_t * pegasus, __u8 * id)
418 for (i = 0; i < 3; i++) {
419 read_eprom_word(pegasus, i, &w16);
420 ((__le16 *) id)[i] = cpu_to_le16p(&w16);
424 static void set_ethernet_addr(pegasus_t * pegasus)
428 get_node_id(pegasus, node_id);
429 set_registers(pegasus, EthID, sizeof (node_id), node_id);
430 memcpy(pegasus->net->dev_addr, node_id, sizeof (node_id));
433 static inline int reset_mac(pegasus_t * pegasus)
438 set_register(pegasus, EthCtrl1, data);
439 for (i = 0; i < REG_TIMEOUT; i++) {
440 get_registers(pegasus, EthCtrl1, 1, &data);
444 if (mii_mode && (pegasus->features & HAS_HOME_PNA))
445 set_register(pegasus, Gpio1, 0x34);
447 set_register(pegasus, Gpio1, 0x26);
448 set_register(pegasus, Gpio0, pegasus->features);
449 set_register(pegasus, Gpio0, DEFAULT_GPIO_SET);
453 if (i == REG_TIMEOUT)
456 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
457 usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
458 set_register(pegasus, Gpio0, 0x24);
459 set_register(pegasus, Gpio0, 0x26);
461 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_ELCON) {
463 read_mii_word(pegasus, 3, 0x1b, &auxmode);
464 write_mii_word(pegasus, 3, 0x1b, auxmode | 4);
470 static int enable_net_traffic(struct net_device *dev, struct usb_device *usb)
474 pegasus_t *pegasus = dev->priv;
476 read_mii_word(pegasus, pegasus->phy, MII_LPA, &linkpart);
479 if (linkpart & (ADVERTISE_100FULL | ADVERTISE_10FULL))
480 data[1] |= 0x20; /* set full duplex */
481 if (linkpart & (ADVERTISE_100FULL | ADVERTISE_100HALF))
482 data[1] |= 0x10; /* set 100 Mbps */
485 data[2] = (loopback & 1) ? 0x09 : 0x01;
487 memcpy(pegasus->eth_regs, data, sizeof (data));
488 set_registers(pegasus, EthCtrl0, 3, data);
490 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
491 usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
493 read_mii_word(pegasus, 0, 0x1b, &auxmode);
494 write_mii_word(pegasus, 0, 0x1b, auxmode | 4);
500 static void fill_skb_pool(pegasus_t * pegasus)
504 for (i = 0; i < RX_SKBS; i++) {
505 if (pegasus->rx_pool[i])
507 pegasus->rx_pool[i] = dev_alloc_skb(PEGASUS_MTU + 2);
509 ** we give up if the allocation fail. the tasklet will be
510 ** rescheduled again anyway...
512 if (pegasus->rx_pool[i] == NULL)
514 pegasus->rx_pool[i]->dev = pegasus->net;
515 skb_reserve(pegasus->rx_pool[i], 2);
519 static void free_skb_pool(pegasus_t * pegasus)
523 for (i = 0; i < RX_SKBS; i++) {
524 if (pegasus->rx_pool[i]) {
525 dev_kfree_skb(pegasus->rx_pool[i]);
526 pegasus->rx_pool[i] = NULL;
531 static inline struct sk_buff *pull_skb(pegasus_t * pegasus)
536 for (i = 0; i < RX_SKBS; i++) {
537 if (likely(pegasus->rx_pool[i] != NULL)) {
538 skb = pegasus->rx_pool[i];
539 pegasus->rx_pool[i] = NULL;
546 static void read_bulk_callback(struct urb *urb, struct pt_regs *regs)
548 pegasus_t *pegasus = urb->context;
549 struct net_device *net;
550 int rx_status, count = urb->actual_length;
553 if (!pegasus || !(pegasus->flags & PEGASUS_RUNNING))
557 if (!netif_device_present(net))
560 switch (urb->status) {
564 dbg("%s: reset MAC", net->name);
565 pegasus->flags &= ~PEGASUS_RX_BUSY;
567 case -EPIPE: /* stall, or disconnect from TT */
568 /* FIXME schedule work to clear the halt */
569 warn("%s: no rx stall recovery", net->name);
574 dbg("%s: rx unlink, %d", net->name, urb->status);
577 dbg("%s: RX status %d", net->name, urb->status);
584 rx_status = le32_to_cpu(*(__le32 *) (urb->transfer_buffer + count - 4));
585 if (rx_status & 0x000e0000) {
586 dbg("%s: RX packet error %x", net->name, rx_status & 0xe0000);
587 pegasus->stats.rx_errors++;
588 if (rx_status & 0x060000)
589 pegasus->stats.rx_length_errors++;
590 if (rx_status & 0x080000)
591 pegasus->stats.rx_crc_errors++;
592 if (rx_status & 0x100000)
593 pegasus->stats.rx_frame_errors++;
596 if (pegasus->chip == 0x8513) {
597 pkt_len = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
599 pegasus->rx_skb->data += 2;
601 pkt_len = (rx_status & 0xfff) - 8;
605 * at this point we are sure pegasus->rx_skb != NULL
606 * so we go ahead and pass up the packet.
608 skb_put(pegasus->rx_skb, pkt_len);
609 pegasus->rx_skb->protocol = eth_type_trans(pegasus->rx_skb, net);
610 netif_rx(pegasus->rx_skb);
611 pegasus->stats.rx_packets++;
612 pegasus->stats.rx_bytes += pkt_len;
614 if (pegasus->flags & PEGASUS_UNPLUG)
617 spin_lock(&pegasus->rx_pool_lock);
618 pegasus->rx_skb = pull_skb(pegasus);
619 spin_unlock(&pegasus->rx_pool_lock);
621 if (pegasus->rx_skb == NULL)
624 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
625 usb_rcvbulkpipe(pegasus->usb, 1),
626 pegasus->rx_skb->data, PEGASUS_MTU + 8,
627 read_bulk_callback, pegasus);
628 if (usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC)) {
629 pegasus->flags |= PEGASUS_RX_URB_FAIL;
632 pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
638 tasklet_schedule(&pegasus->rx_tl);
641 static void rx_fixup(unsigned long data)
646 pegasus = (pegasus_t *) data;
647 if (pegasus->flags & PEGASUS_UNPLUG)
650 spin_lock_irqsave(&pegasus->rx_pool_lock, flags);
651 fill_skb_pool(pegasus);
652 if (pegasus->flags & PEGASUS_RX_URB_FAIL)
655 if (pegasus->rx_skb == NULL) {
656 pegasus->rx_skb = pull_skb(pegasus);
658 if (pegasus->rx_skb == NULL) {
659 warn("wow, low on memory");
660 tasklet_schedule(&pegasus->rx_tl);
663 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
664 usb_rcvbulkpipe(pegasus->usb, 1),
665 pegasus->rx_skb->data, PEGASUS_MTU + 8,
666 read_bulk_callback, pegasus);
668 if (usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC)) {
669 pegasus->flags |= PEGASUS_RX_URB_FAIL;
670 tasklet_schedule(&pegasus->rx_tl);
672 pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
675 spin_unlock_irqrestore(&pegasus->rx_pool_lock, flags);
678 static void write_bulk_callback(struct urb *urb, struct pt_regs *regs)
680 pegasus_t *pegasus = urb->context;
681 struct net_device *net = pegasus->net;
683 if (!pegasus || !(pegasus->flags & PEGASUS_RUNNING))
686 if (!netif_device_present(net))
689 switch (urb->status) {
691 /* FIXME schedule_work() to clear the tx halt */
692 netif_stop_queue(net);
693 warn("%s: no tx stall recovery", net->name);
698 dbg("%s: tx unlink, %d", net->name, urb->status);
701 info("%s: TX status %d", net->name, urb->status);
707 net->trans_start = jiffies;
708 netif_wake_queue(net);
711 static void intr_callback(struct urb *urb, struct pt_regs *regs)
713 pegasus_t *pegasus = urb->context;
714 struct net_device *net;
721 switch (urb->status) {
724 case -ECONNRESET: /* unlink */
729 info("intr status %d", urb->status);
732 d = urb->transfer_buffer;
735 pegasus->stats.tx_errors++;
736 if (d[0] & TX_UNDERRUN)
737 pegasus->stats.tx_fifo_errors++;
738 if (d[0] & (EXCESSIVE_COL | JABBER_TIMEOUT))
739 pegasus->stats.tx_aborted_errors++;
741 pegasus->stats.tx_window_errors++;
742 if (d[5] & LINK_STATUS) {
743 netif_carrier_on(net);
745 pegasus->stats.tx_carrier_errors++;
746 netif_carrier_off(net);
750 status = usb_submit_urb(urb, SLAB_ATOMIC);
752 err("%s: can't resubmit interrupt urb, %d", net->name, status);
755 static void pegasus_tx_timeout(struct net_device *net)
757 pegasus_t *pegasus = net->priv;
762 warn("%s: Tx timed out.", net->name);
763 pegasus->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
764 usb_unlink_urb(pegasus->tx_urb);
765 pegasus->stats.tx_errors++;
768 static int pegasus_start_xmit(struct sk_buff *skb, struct net_device *net)
770 pegasus_t *pegasus = net->priv;
771 int count = ((skb->len + 2) & 0x3f) ? skb->len + 2 : skb->len + 3;
773 __u16 l16 = skb->len;
775 netif_stop_queue(net);
777 ((__le16 *) pegasus->tx_buff)[0] = cpu_to_le16(l16);
778 memcpy(pegasus->tx_buff + 2, skb->data, skb->len);
779 usb_fill_bulk_urb(pegasus->tx_urb, pegasus->usb,
780 usb_sndbulkpipe(pegasus->usb, 2),
781 pegasus->tx_buff, count,
782 write_bulk_callback, pegasus);
783 if ((res = usb_submit_urb(pegasus->tx_urb, GFP_ATOMIC))) {
784 warn("failed tx_urb %d", res);
786 case -EPIPE: /* stall, or disconnect from TT */
787 /* cleanup should already have been scheduled */
789 case -ENODEV: /* disconnect() upcoming */
792 pegasus->stats.tx_errors++;
793 netif_start_queue(net);
796 pegasus->stats.tx_packets++;
797 pegasus->stats.tx_bytes += skb->len;
798 net->trans_start = jiffies;
805 static struct net_device_stats *pegasus_netdev_stats(struct net_device *dev)
807 return &((pegasus_t *) dev->priv)->stats;
810 static inline void disable_net_traffic(pegasus_t * pegasus)
814 set_registers(pegasus, EthCtrl0, 2, &tmp);
817 static inline void get_interrupt_interval(pegasus_t * pegasus)
821 read_eprom_word(pegasus, 4, (__u16 *) data);
822 if (data[1] < 0x80) {
823 info("intr interval will be changed from %ums to %ums",
826 #ifdef PEGASUS_WRITE_EEPROM
827 write_eprom_word(pegasus, 4, *(__u16 *) data);
830 pegasus->intr_interval = data[1];
833 static void set_carrier(struct net_device *net)
839 read_mii_word(pegasus, pegasus->phy, MII_BMSR, &tmp);
840 if (tmp & BMSR_LSTATUS)
841 netif_carrier_on(net);
843 netif_carrier_off(net);
847 static void free_all_urbs(pegasus_t * pegasus)
849 usb_free_urb(pegasus->intr_urb);
850 usb_free_urb(pegasus->tx_urb);
851 usb_free_urb(pegasus->rx_urb);
852 usb_free_urb(pegasus->ctrl_urb);
855 static void unlink_all_urbs(pegasus_t * pegasus)
857 usb_unlink_urb(pegasus->intr_urb);
858 usb_unlink_urb(pegasus->tx_urb);
859 usb_unlink_urb(pegasus->rx_urb);
860 usb_unlink_urb(pegasus->ctrl_urb);
863 static int alloc_urbs(pegasus_t * pegasus)
865 pegasus->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL);
866 if (!pegasus->ctrl_urb) {
869 pegasus->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
870 if (!pegasus->rx_urb) {
871 usb_free_urb(pegasus->ctrl_urb);
874 pegasus->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
875 if (!pegasus->tx_urb) {
876 usb_free_urb(pegasus->rx_urb);
877 usb_free_urb(pegasus->ctrl_urb);
880 pegasus->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
881 if (!pegasus->intr_urb) {
882 usb_free_urb(pegasus->tx_urb);
883 usb_free_urb(pegasus->rx_urb);
884 usb_free_urb(pegasus->ctrl_urb);
891 static int pegasus_open(struct net_device *net)
893 pegasus_t *pegasus = (pegasus_t *) net->priv;
896 if (pegasus->rx_skb == NULL)
897 pegasus->rx_skb = pull_skb(pegasus);
899 ** Note: no point to free the pool. it is empty :-)
901 if (!pegasus->rx_skb)
904 set_registers(pegasus, EthID, 6, net->dev_addr);
906 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
907 usb_rcvbulkpipe(pegasus->usb, 1),
908 pegasus->rx_skb->data, PEGASUS_MTU + 8,
909 read_bulk_callback, pegasus);
910 if ((res = usb_submit_urb(pegasus->rx_urb, GFP_KERNEL)))
911 warn("%s: failed rx_urb %d", __FUNCTION__, res);
912 usb_fill_int_urb(pegasus->intr_urb, pegasus->usb,
913 usb_rcvintpipe(pegasus->usb, 3),
914 pegasus->intr_buff, sizeof (pegasus->intr_buff),
915 intr_callback, pegasus, pegasus->intr_interval);
916 if ((res = usb_submit_urb(pegasus->intr_urb, GFP_KERNEL)))
917 warn("%s: failed intr_urb %d", __FUNCTION__, res);
918 netif_start_queue(net);
919 pegasus->flags |= PEGASUS_RUNNING;
920 if ((res = enable_net_traffic(net, pegasus->usb))) {
921 err("can't enable_net_traffic() - %d", res);
923 usb_unlink_urb(pegasus->rx_urb);
924 usb_unlink_urb(pegasus->intr_urb);
925 free_skb_pool(pegasus);
934 static int pegasus_close(struct net_device *net)
936 pegasus_t *pegasus = net->priv;
938 pegasus->flags &= ~PEGASUS_RUNNING;
939 netif_stop_queue(net);
940 if (!(pegasus->flags & PEGASUS_UNPLUG))
941 disable_net_traffic(pegasus);
942 tasklet_kill(&pegasus->rx_tl);
943 unlink_all_urbs(pegasus);
948 static int pegasus_ethtool_ioctl(struct net_device *dev, void __user *useraddr)
952 pegasus_t *pegasus = dev->priv;
954 if (copy_from_user(ðcmd, useraddr, sizeof (ethcmd)))
958 /* get driver-specific version/etc. info */
959 case ETHTOOL_GDRVINFO:{
960 struct ethtool_drvinfo info;
961 memset (&info, 0, sizeof (info));
962 info.cmd = ETHTOOL_GDRVINFO;
963 strncpy(info.driver, driver_name,
964 sizeof (info.driver) - 1);
965 strncpy(info.version, DRIVER_VERSION,
966 sizeof (info.version) - 1);
967 usb_make_path(pegasus->usb, info.bus_info,
968 sizeof (info.bus_info));
969 if (copy_to_user(useraddr, &info, sizeof (info)))
976 struct ethtool_cmd ecmd = { ETHTOOL_GSET };
977 mii_ethtool_gset(&pegasus->mii, &ecmd);
978 if (copy_to_user(useraddr, &ecmd, sizeof (ecmd)))
985 struct ethtool_cmd ecmd;
986 if (copy_from_user(&ecmd, useraddr, sizeof (ecmd)))
988 r = mii_ethtool_sset(&pegasus->mii, &ecmd);
991 /* restart autonegotiation */
992 case ETHTOOL_NWAY_RST:{
993 return mii_nway_restart(&pegasus->mii);
996 /* get link status */
998 struct ethtool_value edata = { ETHTOOL_GLINK };
999 edata.data = mii_link_ok(&pegasus->mii);
1000 if (copy_to_user(useraddr, &edata, sizeof (edata)))
1004 /* get message-level */
1005 case ETHTOOL_GMSGLVL:{
1006 struct ethtool_value edata = { ETHTOOL_GMSGLVL };
1007 /* edata.data = pegasus->msg_enable; FIXME */
1008 if (copy_to_user(useraddr, &edata, sizeof (edata)))
1012 /* set message-level */
1013 case ETHTOOL_SMSGLVL:{
1014 struct ethtool_value edata;
1015 if (copy_from_user(&edata, useraddr, sizeof (edata)))
1017 /* sp->msg_enable = edata.data; FIXME */
1027 static int pegasus_ethtool_ioctl(struct net_device *net, void __user *uaddr)
1032 pegasus = net->priv;
1033 if (get_user(cmd, (int __user *) uaddr))
1036 case ETHTOOL_GDRVINFO:{
1037 struct ethtool_drvinfo info;
1038 memset (&info, 0, sizeof (info));
1039 info.cmd = ETHTOOL_GDRVINFO;
1040 strncpy(info.driver, driver_name,
1041 sizeof (info.driver) - 1);
1042 strncpy(info.version, DRIVER_VERSION,
1043 sizeof (info.version) - 1);
1044 usb_make_path(pegasus->usb, info.bus_info,
1045 sizeof (info.bus_info));
1046 if (copy_to_user(uaddr, &info, sizeof (info)))
1051 struct ethtool_cmd ecmd;
1055 memset(&ecmd, 0, sizeof (ecmd));
1056 ecmd.supported = (SUPPORTED_10baseT_Half |
1057 SUPPORTED_10baseT_Full |
1058 SUPPORTED_100baseT_Half |
1059 SUPPORTED_100baseT_Full |
1061 SUPPORTED_TP | SUPPORTED_MII);
1062 get_registers(pegasus, Reg7b, 1, &port);
1064 ecmd.port = PORT_MII;
1066 ecmd.port = PORT_TP;
1067 ecmd.transceiver = XCVR_INTERNAL;
1068 ecmd.phy_address = pegasus->phy;
1069 read_mii_word(pegasus, pegasus->phy, MII_BMCR, &bmcr);
1070 read_mii_word(pegasus, pegasus->phy, MII_LPA, &lpa);
1071 if (bmcr & BMCR_ANENABLE) {
1072 ecmd.autoneg = AUTONEG_ENABLE;
1073 ecmd.speed = lpa & (LPA_100HALF | LPA_100FULL) ?
1074 SPEED_100 : SPEED_10;
1075 if (ecmd.speed == SPEED_100)
1076 ecmd.duplex = lpa & LPA_100FULL ?
1077 DUPLEX_FULL : DUPLEX_HALF;
1079 ecmd.duplex = lpa & LPA_10FULL ?
1080 DUPLEX_FULL : DUPLEX_HALF;
1082 ecmd.autoneg = AUTONEG_DISABLE;
1083 ecmd.speed = bmcr & BMCR_SPEED100 ?
1084 SPEED_100 : SPEED_10;
1085 ecmd.duplex = bmcr & BMCR_FULLDPLX ?
1086 DUPLEX_FULL : DUPLEX_HALF;
1088 if (copy_to_user(uaddr, &ecmd, sizeof (ecmd)))
1096 case ETHTOOL_GLINK:{
1097 struct ethtool_value edata = { ETHTOOL_GLINK };
1098 edata.data = netif_carrier_ok(net);
1099 if (copy_to_user(uaddr, &edata, sizeof (edata)))
1108 static int pegasus_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
1110 __u16 *data = (__u16 *) & rq->ifr_ifru;
1111 pegasus_t *pegasus = net->priv;
1116 res = pegasus_ethtool_ioctl(net, rq->ifr_data);
1118 case SIOCDEVPRIVATE:
1119 data[0] = pegasus->phy;
1120 case SIOCDEVPRIVATE + 1:
1121 read_mii_word(pegasus, data[0], data[1] & 0x1f, &data[3]);
1124 case SIOCDEVPRIVATE + 2:
1125 if (!capable(CAP_NET_ADMIN))
1127 write_mii_word(pegasus, pegasus->phy, data[1] & 0x1f, data[2]);
1136 static void pegasus_set_multicast(struct net_device *net)
1138 pegasus_t *pegasus = net->priv;
1140 if (net->flags & IFF_PROMISC) {
1141 pegasus->eth_regs[EthCtrl2] |= RX_PROMISCUOUS;
1142 info("%s: Promiscuous mode enabled", net->name);
1143 } else if ((net->mc_count > multicast_filter_limit) ||
1144 (net->flags & IFF_ALLMULTI)) {
1145 pegasus->eth_regs[EthCtrl0] |= RX_MULTICAST;
1146 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
1147 info("%s set allmulti", net->name);
1149 pegasus->eth_regs[EthCtrl0] &= ~RX_MULTICAST;
1150 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
1153 pegasus->flags |= ETH_REGS_CHANGE;
1154 ctrl_callback(pegasus->ctrl_urb, NULL);
1157 static __u8 mii_phy_probe(pegasus_t * pegasus)
1162 for (i = 0; i < 32; i++) {
1163 read_mii_word(pegasus, i, MII_BMSR, &tmp);
1164 if (tmp == 0 || tmp == 0xffff || (tmp & BMSR_MEDIA) == 0)
1173 static inline void setup_pegasus_II(pegasus_t * pegasus)
1177 set_register(pegasus, Reg1d, 0);
1178 set_register(pegasus, Reg7b, 1);
1180 if ((pegasus->features & HAS_HOME_PNA) && mii_mode)
1181 set_register(pegasus, Reg7b, 0);
1183 set_register(pegasus, Reg7b, 2);
1185 set_register(pegasus, 0x83, data);
1186 get_registers(pegasus, 0x83, 1, &data);
1189 pegasus->chip = 0x8513;
1194 set_register(pegasus, 0x80, 0xc0);
1195 set_register(pegasus, 0x83, 0xff);
1196 set_register(pegasus, 0x84, 0x01);
1198 if (pegasus->features & HAS_HOME_PNA && mii_mode)
1199 set_register(pegasus, Reg81, 6);
1201 set_register(pegasus, Reg81, 2);
1204 static int pegasus_probe(struct usb_interface *intf,
1205 const struct usb_device_id *id)
1207 struct usb_device *dev = interface_to_usbdev(intf);
1208 struct net_device *net;
1210 int dev_index = id - pegasus_ids;
1214 if (!(pegasus = kmalloc(sizeof (struct pegasus), GFP_KERNEL))) {
1215 err("out of memory allocating device structure");
1219 memset(pegasus, 0, sizeof (struct pegasus));
1220 pegasus->dev_index = dev_index;
1221 init_waitqueue_head(&pegasus->ctrl_wait);
1223 if (!alloc_urbs(pegasus))
1226 net = alloc_etherdev(0);
1230 tasklet_init(&pegasus->rx_tl, rx_fixup, (unsigned long) pegasus);
1234 SET_MODULE_OWNER(net);
1235 net->priv = pegasus;
1236 net->open = pegasus_open;
1237 net->stop = pegasus_close;
1238 net->watchdog_timeo = PEGASUS_TX_TIMEOUT;
1239 net->tx_timeout = pegasus_tx_timeout;
1240 net->do_ioctl = pegasus_ioctl;
1241 net->hard_start_xmit = pegasus_start_xmit;
1242 net->set_multicast_list = pegasus_set_multicast;
1243 net->get_stats = pegasus_netdev_stats;
1244 net->mtu = PEGASUS_MTU;
1245 pegasus->mii.dev = net;
1246 pegasus->mii.mdio_read = mdio_read;
1247 pegasus->mii.mdio_write = mdio_write;
1248 pegasus->mii.phy_id_mask = 0x1f;
1249 pegasus->mii.reg_num_mask = 0x1f;
1250 spin_lock_init(&pegasus->rx_pool_lock);
1252 pegasus->features = usb_dev_id[dev_index].private;
1253 get_interrupt_interval(pegasus);
1254 if (reset_mac(pegasus)) {
1255 err("can't reset MAC");
1259 set_ethernet_addr(pegasus);
1260 fill_skb_pool(pegasus);
1261 if (pegasus->features & PEGASUS_II) {
1262 info("setup Pegasus II specific registers");
1263 setup_pegasus_II(pegasus);
1265 pegasus->phy = mii_phy_probe(pegasus);
1266 if (pegasus->phy == 0xff) {
1267 warn("can't locate MII phy, using default");
1270 usb_set_intfdata(intf, pegasus);
1271 SET_NETDEV_DEV(net, &intf->dev);
1272 res = register_netdev(net);
1275 printk("%s: %s\n", net->name, usb_dev_id[dev_index].name);
1279 usb_set_intfdata(intf, NULL);
1280 free_skb_pool(pegasus);
1284 free_all_urbs(pegasus);
1292 static void pegasus_disconnect(struct usb_interface *intf)
1294 struct pegasus *pegasus = usb_get_intfdata(intf);
1296 usb_set_intfdata(intf, NULL);
1298 warn("unregistering non-existant device");
1302 pegasus->flags |= PEGASUS_UNPLUG;
1303 unregister_netdev(pegasus->net);
1304 usb_put_dev(interface_to_usbdev(intf));
1305 free_all_urbs(pegasus);
1306 free_skb_pool(pegasus);
1307 if (pegasus->rx_skb)
1308 dev_kfree_skb(pegasus->rx_skb);
1309 free_netdev(pegasus->net);
1313 static struct usb_driver pegasus_driver = {
1314 .name = driver_name,
1315 .probe = pegasus_probe,
1316 .disconnect = pegasus_disconnect,
1317 .id_table = pegasus_ids,
1320 static int __init pegasus_init(void)
1322 info(DRIVER_VERSION ":" DRIVER_DESC);
1323 return usb_register(&pegasus_driver);
1326 static void __exit pegasus_exit(void)
1328 usb_deregister(&pegasus_driver);
1331 module_init(pegasus_init);
1332 module_exit(pegasus_exit);