2 * Copyright (c) 2001 Vojtech Pavlik
4 * CATC EL1210A NetMate USB Ethernet driver
11 * Old chipset support added by Simon Evans <spse@secret.org.uk> 2002
12 * - adds support for Belkin F5U011
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 * Should you need to contact me, the author, you can do so either by
31 * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
32 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
35 #include <linux/init.h>
36 #include <linux/module.h>
37 #include <linux/kernel.h>
38 #include <linux/string.h>
39 #include <linux/netdevice.h>
40 #include <linux/etherdevice.h>
41 #include <linux/skbuff.h>
42 #include <linux/spinlock.h>
43 #include <linux/ethtool.h>
44 #include <linux/crc32.h>
45 #include <linux/bitops.h>
46 #include <linux/gfp.h>
47 #include <asm/uaccess.h>
51 #include <linux/usb.h>
54 * Version information.
57 #define DRIVER_VERSION "v2.8"
58 #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@suse.cz>"
59 #define DRIVER_DESC "CATC EL1210A NetMate USB Ethernet driver"
60 #define SHORT_DRIVER_DESC "EL1210A NetMate USB Ethernet"
62 MODULE_AUTHOR(DRIVER_AUTHOR
);
63 MODULE_DESCRIPTION(DRIVER_DESC
);
64 MODULE_LICENSE("GPL");
66 static const char driver_name
[] = "catc";
72 #define STATS_UPDATE (HZ) /* Time between stats updates */
73 #define TX_TIMEOUT (5*HZ) /* Max time the queue can be stopped */
74 #define PKT_SZ 1536 /* Max Ethernet packet size */
75 #define RX_MAX_BURST 15 /* Max packets per rx buffer (> 0, < 16) */
76 #define TX_MAX_BURST 15 /* Max full sized packets per tx buffer (> 0) */
77 #define CTRL_QUEUE 16 /* Max control requests in flight (power of two) */
78 #define RX_PKT_SZ 1600 /* Max size of receive packet for F5U011 */
84 enum control_requests
{
89 SetRxMode
= 0xf5, /* F5U011 only */
101 enum register_offsets
{
127 OpWin95bugfix
= 0x40,
131 enum rx_filter_bits
{
137 AltRxPromisc
= 0x20, /* F5U011 uses different bit */
158 #define CTRL_RUNNING 0
163 struct net_device
*netdev
;
164 struct usb_device
*usbdev
;
168 unsigned int tx_ptr
, tx_idx
;
169 unsigned int ctrl_head
, ctrl_tail
;
170 spinlock_t tx_lock
, ctrl_lock
;
172 u8 tx_buf
[2][TX_MAX_BURST
* (PKT_SZ
+ 2)];
173 u8 rx_buf
[RX_MAX_BURST
* (PKT_SZ
+ 2)];
176 struct usb_ctrlrequest ctrl_dr
;
178 struct timer_list timer
;
181 unsigned long last_stats
;
192 void (*callback
)(struct catc
*catc
, struct ctrl_queue
*q
);
193 } ctrl_queue
[CTRL_QUEUE
];
195 struct urb
*tx_urb
, *rx_urb
, *irq_urb
, *ctrl_urb
;
197 u8 is_f5u011
; /* Set if device is an F5U011 */
198 u8 rxmode
[2]; /* Used for F5U011 */
199 atomic_t recq_sz
; /* Used for F5U011 - counter of waiting rx packets */
206 #define catc_get_mac(catc, mac) catc_ctrl_msg(catc, USB_DIR_IN, GetMac, 0, 0, mac, 6)
207 #define catc_reset(catc) catc_ctrl_msg(catc, USB_DIR_OUT, Reset, 0, 0, NULL, 0)
208 #define catc_set_reg(catc, reg, val) catc_ctrl_msg(catc, USB_DIR_OUT, SetReg, val, reg, NULL, 0)
209 #define catc_get_reg(catc, reg, buf) catc_ctrl_msg(catc, USB_DIR_IN, GetReg, 0, reg, buf, 1)
210 #define catc_write_mem(catc, addr, buf, size) catc_ctrl_msg(catc, USB_DIR_OUT, WriteMem, 0, addr, buf, size)
211 #define catc_read_mem(catc, addr, buf, size) catc_ctrl_msg(catc, USB_DIR_IN, ReadMem, 0, addr, buf, size)
213 #define f5u011_rxmode(catc, rxmode) catc_ctrl_msg(catc, USB_DIR_OUT, SetRxMode, 0, 1, rxmode, 2)
214 #define f5u011_rxmode_async(catc, rxmode) catc_ctrl_async(catc, USB_DIR_OUT, SetRxMode, 0, 1, &rxmode, 2, NULL)
215 #define f5u011_mchash_async(catc, hash) catc_ctrl_async(catc, USB_DIR_OUT, SetRxMode, 0, 2, &hash, 8, NULL)
217 #define catc_set_reg_async(catc, reg, val) catc_ctrl_async(catc, USB_DIR_OUT, SetReg, val, reg, NULL, 0, NULL)
218 #define catc_get_reg_async(catc, reg, cb) catc_ctrl_async(catc, USB_DIR_IN, GetReg, 0, reg, NULL, 1, cb)
219 #define catc_write_mem_async(catc, addr, buf, size) catc_ctrl_async(catc, USB_DIR_OUT, WriteMem, 0, addr, buf, size, NULL)
225 static void catc_rx_done(struct urb
*urb
)
227 struct catc
*catc
= urb
->context
;
228 u8
*pkt_start
= urb
->transfer_buffer
;
230 int pkt_len
, pkt_offset
= 0;
231 int status
= urb
->status
;
233 if (!catc
->is_f5u011
) {
234 clear_bit(RX_RUNNING
, &catc
->flags
);
239 dbg("rx_done, status %d, length %d", status
, urb
->actual_length
);
244 if(!catc
->is_f5u011
) {
245 pkt_len
= le16_to_cpup((__le16
*)pkt_start
);
246 if (pkt_len
> urb
->actual_length
) {
247 catc
->netdev
->stats
.rx_length_errors
++;
248 catc
->netdev
->stats
.rx_errors
++;
252 pkt_len
= urb
->actual_length
;
255 if (!(skb
= dev_alloc_skb(pkt_len
)))
258 skb_copy_to_linear_data(skb
, pkt_start
+ pkt_offset
, pkt_len
);
259 skb_put(skb
, pkt_len
);
261 skb
->protocol
= eth_type_trans(skb
, catc
->netdev
);
264 catc
->netdev
->stats
.rx_packets
++;
265 catc
->netdev
->stats
.rx_bytes
+= pkt_len
;
267 /* F5U011 only does one packet per RX */
270 pkt_start
+= (((pkt_len
+ 1) >> 6) + 1) << 6;
272 } while (pkt_start
- (u8
*) urb
->transfer_buffer
< urb
->actual_length
);
274 if (catc
->is_f5u011
) {
275 if (atomic_read(&catc
->recq_sz
)) {
277 atomic_dec(&catc
->recq_sz
);
278 dbg("getting extra packet");
279 urb
->dev
= catc
->usbdev
;
280 if ((state
= usb_submit_urb(urb
, GFP_ATOMIC
)) < 0) {
281 dbg("submit(rx_urb) status %d", state
);
284 clear_bit(RX_RUNNING
, &catc
->flags
);
289 static void catc_irq_done(struct urb
*urb
)
291 struct catc
*catc
= urb
->context
;
292 u8
*data
= urb
->transfer_buffer
;
293 int status
= urb
->status
;
294 unsigned int hasdata
= 0, linksts
= LinkNoChange
;
297 if (!catc
->is_f5u011
) {
298 hasdata
= data
[1] & 0x80;
301 else if (data
[1] & 0x20)
304 hasdata
= (unsigned int)(be16_to_cpup((__be16
*)data
) & 0x0fff);
307 else if (data
[0] == 0xA0)
312 case 0: /* success */
314 case -ECONNRESET
: /* unlink */
318 /* -EPIPE: should clear the halt */
320 dbg("irq_done, status %d, data %02x %02x.", status
, data
[0], data
[1]);
324 if (linksts
== LinkGood
) {
325 netif_carrier_on(catc
->netdev
);
329 if (linksts
== LinkBad
) {
330 netif_carrier_off(catc
->netdev
);
335 if (test_and_set_bit(RX_RUNNING
, &catc
->flags
)) {
337 atomic_inc(&catc
->recq_sz
);
339 catc
->rx_urb
->dev
= catc
->usbdev
;
340 if ((res
= usb_submit_urb(catc
->rx_urb
, GFP_ATOMIC
)) < 0) {
341 dev_err(&catc
->usbdev
->dev
,
342 "submit(rx_urb) status %d\n", res
);
347 res
= usb_submit_urb (urb
, GFP_ATOMIC
);
349 dev_err(&catc
->usbdev
->dev
,
350 "can't resubmit intr, %s-%s, status %d\n",
351 catc
->usbdev
->bus
->bus_name
,
352 catc
->usbdev
->devpath
, res
);
359 static int catc_tx_run(struct catc
*catc
)
364 catc
->tx_ptr
= (catc
->tx_ptr
+ 63) & ~63;
366 catc
->tx_urb
->transfer_buffer_length
= catc
->tx_ptr
;
367 catc
->tx_urb
->transfer_buffer
= catc
->tx_buf
[catc
->tx_idx
];
368 catc
->tx_urb
->dev
= catc
->usbdev
;
370 if ((status
= usb_submit_urb(catc
->tx_urb
, GFP_ATOMIC
)) < 0)
371 dev_err(&catc
->usbdev
->dev
, "submit(tx_urb), status %d\n",
374 catc
->tx_idx
= !catc
->tx_idx
;
377 catc
->netdev
->trans_start
= jiffies
;
381 static void catc_tx_done(struct urb
*urb
)
383 struct catc
*catc
= urb
->context
;
385 int r
, status
= urb
->status
;
387 if (status
== -ECONNRESET
) {
390 catc
->netdev
->trans_start
= jiffies
;
391 catc
->netdev
->stats
.tx_errors
++;
392 clear_bit(TX_RUNNING
, &catc
->flags
);
393 netif_wake_queue(catc
->netdev
);
398 dbg("tx_done, status %d, length %d", status
, urb
->actual_length
);
402 spin_lock_irqsave(&catc
->tx_lock
, flags
);
405 r
= catc_tx_run(catc
);
407 clear_bit(TX_RUNNING
, &catc
->flags
);
409 clear_bit(TX_RUNNING
, &catc
->flags
);
412 netif_wake_queue(catc
->netdev
);
414 spin_unlock_irqrestore(&catc
->tx_lock
, flags
);
417 static netdev_tx_t
catc_start_xmit(struct sk_buff
*skb
,
418 struct net_device
*netdev
)
420 struct catc
*catc
= netdev_priv(netdev
);
425 spin_lock_irqsave(&catc
->tx_lock
, flags
);
427 catc
->tx_ptr
= (((catc
->tx_ptr
- 1) >> 6) + 1) << 6;
428 tx_buf
= catc
->tx_buf
[catc
->tx_idx
] + catc
->tx_ptr
;
430 *(__be16
*)tx_buf
= cpu_to_be16(skb
->len
);
432 *(__le16
*)tx_buf
= cpu_to_le16(skb
->len
);
433 skb_copy_from_linear_data(skb
, tx_buf
+ 2, skb
->len
);
434 catc
->tx_ptr
+= skb
->len
+ 2;
436 if (!test_and_set_bit(TX_RUNNING
, &catc
->flags
)) {
437 r
= catc_tx_run(catc
);
439 clear_bit(TX_RUNNING
, &catc
->flags
);
442 if ((catc
->is_f5u011
&& catc
->tx_ptr
) ||
443 (catc
->tx_ptr
>= ((TX_MAX_BURST
- 1) * (PKT_SZ
+ 2))))
444 netif_stop_queue(netdev
);
446 spin_unlock_irqrestore(&catc
->tx_lock
, flags
);
449 catc
->netdev
->stats
.tx_bytes
+= skb
->len
;
450 catc
->netdev
->stats
.tx_packets
++;
458 static void catc_tx_timeout(struct net_device
*netdev
)
460 struct catc
*catc
= netdev_priv(netdev
);
462 dev_warn(&netdev
->dev
, "Transmit timed out.\n");
463 usb_unlink_urb(catc
->tx_urb
);
470 static int catc_ctrl_msg(struct catc
*catc
, u8 dir
, u8 request
, u16 value
, u16 index
, void *buf
, int len
)
472 int retval
= usb_control_msg(catc
->usbdev
,
473 dir
? usb_rcvctrlpipe(catc
->usbdev
, 0) : usb_sndctrlpipe(catc
->usbdev
, 0),
474 request
, 0x40 | dir
, value
, index
, buf
, len
, 1000);
475 return retval
< 0 ? retval
: 0;
478 static void catc_ctrl_run(struct catc
*catc
)
480 struct ctrl_queue
*q
= catc
->ctrl_queue
+ catc
->ctrl_tail
;
481 struct usb_device
*usbdev
= catc
->usbdev
;
482 struct urb
*urb
= catc
->ctrl_urb
;
483 struct usb_ctrlrequest
*dr
= &catc
->ctrl_dr
;
486 dr
->bRequest
= q
->request
;
487 dr
->bRequestType
= 0x40 | q
->dir
;
488 dr
->wValue
= cpu_to_le16(q
->value
);
489 dr
->wIndex
= cpu_to_le16(q
->index
);
490 dr
->wLength
= cpu_to_le16(q
->len
);
492 urb
->pipe
= q
->dir
? usb_rcvctrlpipe(usbdev
, 0) : usb_sndctrlpipe(usbdev
, 0);
493 urb
->transfer_buffer_length
= q
->len
;
494 urb
->transfer_buffer
= catc
->ctrl_buf
;
495 urb
->setup_packet
= (void *) dr
;
498 if (!q
->dir
&& q
->buf
&& q
->len
)
499 memcpy(catc
->ctrl_buf
, q
->buf
, q
->len
);
501 if ((status
= usb_submit_urb(catc
->ctrl_urb
, GFP_ATOMIC
)))
502 dev_err(&catc
->usbdev
->dev
, "submit(ctrl_urb) status %d\n",
506 static void catc_ctrl_done(struct urb
*urb
)
508 struct catc
*catc
= urb
->context
;
509 struct ctrl_queue
*q
;
511 int status
= urb
->status
;
514 dbg("ctrl_done, status %d, len %d.", status
, urb
->actual_length
);
516 spin_lock_irqsave(&catc
->ctrl_lock
, flags
);
518 q
= catc
->ctrl_queue
+ catc
->ctrl_tail
;
521 if (q
->buf
&& q
->len
)
522 memcpy(q
->buf
, catc
->ctrl_buf
, q
->len
);
524 q
->buf
= catc
->ctrl_buf
;
528 q
->callback(catc
, q
);
530 catc
->ctrl_tail
= (catc
->ctrl_tail
+ 1) & (CTRL_QUEUE
- 1);
532 if (catc
->ctrl_head
!= catc
->ctrl_tail
)
535 clear_bit(CTRL_RUNNING
, &catc
->flags
);
537 spin_unlock_irqrestore(&catc
->ctrl_lock
, flags
);
540 static int catc_ctrl_async(struct catc
*catc
, u8 dir
, u8 request
, u16 value
,
541 u16 index
, void *buf
, int len
, void (*callback
)(struct catc
*catc
, struct ctrl_queue
*q
))
543 struct ctrl_queue
*q
;
547 spin_lock_irqsave(&catc
->ctrl_lock
, flags
);
549 q
= catc
->ctrl_queue
+ catc
->ctrl_head
;
552 q
->request
= request
;
557 q
->callback
= callback
;
559 catc
->ctrl_head
= (catc
->ctrl_head
+ 1) & (CTRL_QUEUE
- 1);
561 if (catc
->ctrl_head
== catc
->ctrl_tail
) {
562 dev_err(&catc
->usbdev
->dev
, "ctrl queue full\n");
563 catc
->ctrl_tail
= (catc
->ctrl_tail
+ 1) & (CTRL_QUEUE
- 1);
567 if (!test_and_set_bit(CTRL_RUNNING
, &catc
->flags
))
570 spin_unlock_irqrestore(&catc
->ctrl_lock
, flags
);
579 static void catc_stats_done(struct catc
*catc
, struct ctrl_queue
*q
)
581 int index
= q
->index
- EthStats
;
584 catc
->stats_buf
[index
] = *((char *)q
->buf
);
589 data
= ((u16
)catc
->stats_buf
[index
] << 8) | catc
->stats_buf
[index
+ 1];
590 last
= catc
->stats_vals
[index
>> 1];
595 catc
->netdev
->stats
.collisions
+= data
- last
;
598 catc
->netdev
->stats
.tx_aborted_errors
+= data
- last
;
599 catc
->netdev
->stats
.tx_errors
+= data
- last
;
602 catc
->netdev
->stats
.rx_frame_errors
+= data
- last
;
603 catc
->netdev
->stats
.rx_errors
+= data
- last
;
607 catc
->stats_vals
[index
>> 1] = data
;
610 static void catc_stats_timer(unsigned long data
)
612 struct catc
*catc
= (void *) data
;
615 for (i
= 0; i
< 8; i
++)
616 catc_get_reg_async(catc
, EthStats
+ 7 - i
, catc_stats_done
);
618 mod_timer(&catc
->timer
, jiffies
+ STATS_UPDATE
);
622 * Receive modes. Broadcast, Multicast, Promisc.
625 static void catc_multicast(unsigned char *addr
, u8
*multicast
)
629 crc
= ether_crc_le(6, addr
);
630 multicast
[(crc
>> 3) & 0x3f] |= 1 << (crc
& 7);
633 static void catc_set_multicast_list(struct net_device
*netdev
)
635 struct catc
*catc
= netdev_priv(netdev
);
636 struct netdev_hw_addr
*ha
;
638 u8 rx
= RxEnable
| RxPolarity
| RxMultiCast
;
640 memset(broadcast
, 0xff, 6);
641 memset(catc
->multicast
, 0, 64);
643 catc_multicast(broadcast
, catc
->multicast
);
644 catc_multicast(netdev
->dev_addr
, catc
->multicast
);
646 if (netdev
->flags
& IFF_PROMISC
) {
647 memset(catc
->multicast
, 0xff, 64);
648 rx
|= (!catc
->is_f5u011
) ? RxPromisc
: AltRxPromisc
;
651 if (netdev
->flags
& IFF_ALLMULTI
) {
652 memset(catc
->multicast
, 0xff, 64);
654 netdev_for_each_mc_addr(ha
, netdev
) {
655 u32 crc
= ether_crc_le(6, ha
->addr
);
656 if (!catc
->is_f5u011
) {
657 catc
->multicast
[(crc
>> 3) & 0x3f] |= 1 << (crc
& 7);
659 catc
->multicast
[7-(crc
>> 29)] |= 1 << ((crc
>> 26) & 7);
663 if (!catc
->is_f5u011
) {
664 catc_set_reg_async(catc
, RxUnit
, rx
);
665 catc_write_mem_async(catc
, 0xfa80, catc
->multicast
, 64);
667 f5u011_mchash_async(catc
, catc
->multicast
);
668 if (catc
->rxmode
[0] != rx
) {
669 catc
->rxmode
[0] = rx
;
670 dbg("Setting RX mode to %2.2X %2.2X", catc
->rxmode
[0], catc
->rxmode
[1]);
671 f5u011_rxmode_async(catc
, catc
->rxmode
);
676 static void catc_get_drvinfo(struct net_device
*dev
,
677 struct ethtool_drvinfo
*info
)
679 struct catc
*catc
= netdev_priv(dev
);
680 strncpy(info
->driver
, driver_name
, ETHTOOL_BUSINFO_LEN
);
681 strncpy(info
->version
, DRIVER_VERSION
, ETHTOOL_BUSINFO_LEN
);
682 usb_make_path (catc
->usbdev
, info
->bus_info
, sizeof info
->bus_info
);
685 static int catc_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
687 struct catc
*catc
= netdev_priv(dev
);
688 if (!catc
->is_f5u011
)
691 cmd
->supported
= SUPPORTED_10baseT_Half
| SUPPORTED_TP
;
692 cmd
->advertising
= ADVERTISED_10baseT_Half
| ADVERTISED_TP
;
693 ethtool_cmd_speed_set(cmd
, SPEED_10
);
694 cmd
->duplex
= DUPLEX_HALF
;
696 cmd
->phy_address
= 0;
697 cmd
->transceiver
= XCVR_INTERNAL
;
698 cmd
->autoneg
= AUTONEG_DISABLE
;
704 static const struct ethtool_ops ops
= {
705 .get_drvinfo
= catc_get_drvinfo
,
706 .get_settings
= catc_get_settings
,
707 .get_link
= ethtool_op_get_link
714 static int catc_open(struct net_device
*netdev
)
716 struct catc
*catc
= netdev_priv(netdev
);
719 catc
->irq_urb
->dev
= catc
->usbdev
;
720 if ((status
= usb_submit_urb(catc
->irq_urb
, GFP_KERNEL
)) < 0) {
721 dev_err(&catc
->usbdev
->dev
, "submit(irq_urb) status %d\n",
726 netif_start_queue(netdev
);
728 if (!catc
->is_f5u011
)
729 mod_timer(&catc
->timer
, jiffies
+ STATS_UPDATE
);
734 static int catc_stop(struct net_device
*netdev
)
736 struct catc
*catc
= netdev_priv(netdev
);
738 netif_stop_queue(netdev
);
740 if (!catc
->is_f5u011
)
741 del_timer_sync(&catc
->timer
);
743 usb_kill_urb(catc
->rx_urb
);
744 usb_kill_urb(catc
->tx_urb
);
745 usb_kill_urb(catc
->irq_urb
);
746 usb_kill_urb(catc
->ctrl_urb
);
751 static const struct net_device_ops catc_netdev_ops
= {
752 .ndo_open
= catc_open
,
753 .ndo_stop
= catc_stop
,
754 .ndo_start_xmit
= catc_start_xmit
,
756 .ndo_tx_timeout
= catc_tx_timeout
,
757 .ndo_set_rx_mode
= catc_set_multicast_list
,
758 .ndo_change_mtu
= eth_change_mtu
,
759 .ndo_set_mac_address
= eth_mac_addr
,
760 .ndo_validate_addr
= eth_validate_addr
,
764 * USB probe, disconnect.
767 static int catc_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
769 struct usb_device
*usbdev
= interface_to_usbdev(intf
);
770 struct net_device
*netdev
;
775 if (usb_set_interface(usbdev
,
776 intf
->altsetting
->desc
.bInterfaceNumber
, 1)) {
777 dev_err(&intf
->dev
, "Can't set altsetting 1.\n");
781 netdev
= alloc_etherdev(sizeof(struct catc
));
785 catc
= netdev_priv(netdev
);
787 netdev
->netdev_ops
= &catc_netdev_ops
;
788 netdev
->watchdog_timeo
= TX_TIMEOUT
;
789 SET_ETHTOOL_OPS(netdev
, &ops
);
791 catc
->usbdev
= usbdev
;
792 catc
->netdev
= netdev
;
794 spin_lock_init(&catc
->tx_lock
);
795 spin_lock_init(&catc
->ctrl_lock
);
797 init_timer(&catc
->timer
);
798 catc
->timer
.data
= (long) catc
;
799 catc
->timer
.function
= catc_stats_timer
;
801 catc
->ctrl_urb
= usb_alloc_urb(0, GFP_KERNEL
);
802 catc
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
803 catc
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
804 catc
->irq_urb
= usb_alloc_urb(0, GFP_KERNEL
);
805 if ((!catc
->ctrl_urb
) || (!catc
->tx_urb
) ||
806 (!catc
->rx_urb
) || (!catc
->irq_urb
)) {
807 dev_err(&intf
->dev
, "No free urbs available.\n");
808 usb_free_urb(catc
->ctrl_urb
);
809 usb_free_urb(catc
->tx_urb
);
810 usb_free_urb(catc
->rx_urb
);
811 usb_free_urb(catc
->irq_urb
);
816 /* The F5U011 has the same vendor/product as the netmate but a device version of 0x130 */
817 if (le16_to_cpu(usbdev
->descriptor
.idVendor
) == 0x0423 &&
818 le16_to_cpu(usbdev
->descriptor
.idProduct
) == 0xa &&
819 le16_to_cpu(catc
->usbdev
->descriptor
.bcdDevice
) == 0x0130) {
820 dbg("Testing for f5u011");
822 atomic_set(&catc
->recq_sz
, 0);
825 pktsz
= RX_MAX_BURST
* (PKT_SZ
+ 2);
828 usb_fill_control_urb(catc
->ctrl_urb
, usbdev
, usb_sndctrlpipe(usbdev
, 0),
829 NULL
, NULL
, 0, catc_ctrl_done
, catc
);
831 usb_fill_bulk_urb(catc
->tx_urb
, usbdev
, usb_sndbulkpipe(usbdev
, 1),
832 NULL
, 0, catc_tx_done
, catc
);
834 usb_fill_bulk_urb(catc
->rx_urb
, usbdev
, usb_rcvbulkpipe(usbdev
, 1),
835 catc
->rx_buf
, pktsz
, catc_rx_done
, catc
);
837 usb_fill_int_urb(catc
->irq_urb
, usbdev
, usb_rcvintpipe(usbdev
, 2),
838 catc
->irq_buf
, 2, catc_irq_done
, catc
, 1);
840 if (!catc
->is_f5u011
) {
841 dbg("Checking memory size\n");
844 catc_write_mem(catc
, 0x7a80, &i
, 4);
846 catc_write_mem(catc
, 0xfa80, &i
, 4);
847 catc_read_mem(catc
, 0x7a80, &i
, 4);
851 catc_set_reg(catc
, TxBufCount
, 8);
852 catc_set_reg(catc
, RxBufCount
, 32);
857 "Couldn't detect memory size, assuming 32k\n");
859 catc_set_reg(catc
, TxBufCount
, 4);
860 catc_set_reg(catc
, RxBufCount
, 16);
865 dbg("Getting MAC from SEEROM.");
867 catc_get_mac(catc
, netdev
->dev_addr
);
869 dbg("Setting MAC into registers.");
871 for (i
= 0; i
< 6; i
++)
872 catc_set_reg(catc
, StationAddr0
- i
, netdev
->dev_addr
[i
]);
874 dbg("Filling the multicast list.");
876 memset(broadcast
, 0xff, 6);
877 catc_multicast(broadcast
, catc
->multicast
);
878 catc_multicast(netdev
->dev_addr
, catc
->multicast
);
879 catc_write_mem(catc
, 0xfa80, catc
->multicast
, 64);
881 dbg("Clearing error counters.");
883 for (i
= 0; i
< 8; i
++)
884 catc_set_reg(catc
, EthStats
+ i
, 0);
885 catc
->last_stats
= jiffies
;
889 catc_set_reg(catc
, MaxBurst
, RX_MAX_BURST
);
890 catc_set_reg(catc
, OpModes
, OpTxMerge
| OpRxMerge
| OpLenInclude
| Op3MemWaits
);
891 catc_set_reg(catc
, LEDCtrl
, LEDLink
);
892 catc_set_reg(catc
, RxUnit
, RxEnable
| RxPolarity
| RxMultiCast
);
894 dbg("Performing reset\n");
896 catc_get_mac(catc
, netdev
->dev_addr
);
898 dbg("Setting RX Mode");
899 catc
->rxmode
[0] = RxEnable
| RxPolarity
| RxMultiCast
;
901 f5u011_rxmode(catc
, catc
->rxmode
);
904 printk(KERN_INFO
"%s: %s USB Ethernet at usb-%s-%s, %pM.\n",
905 netdev
->name
, (catc
->is_f5u011
) ? "Belkin F5U011" : "CATC EL1210A NetMate",
906 usbdev
->bus
->bus_name
, usbdev
->devpath
, netdev
->dev_addr
);
907 usb_set_intfdata(intf
, catc
);
909 SET_NETDEV_DEV(netdev
, &intf
->dev
);
910 if (register_netdev(netdev
) != 0) {
911 usb_set_intfdata(intf
, NULL
);
912 usb_free_urb(catc
->ctrl_urb
);
913 usb_free_urb(catc
->tx_urb
);
914 usb_free_urb(catc
->rx_urb
);
915 usb_free_urb(catc
->irq_urb
);
922 static void catc_disconnect(struct usb_interface
*intf
)
924 struct catc
*catc
= usb_get_intfdata(intf
);
926 usb_set_intfdata(intf
, NULL
);
928 unregister_netdev(catc
->netdev
);
929 usb_free_urb(catc
->ctrl_urb
);
930 usb_free_urb(catc
->tx_urb
);
931 usb_free_urb(catc
->rx_urb
);
932 usb_free_urb(catc
->irq_urb
);
933 free_netdev(catc
->netdev
);
938 * Module functions and tables.
941 static struct usb_device_id catc_id_table
[] = {
942 { USB_DEVICE(0x0423, 0xa) }, /* CATC Netmate, Belkin F5U011 */
943 { USB_DEVICE(0x0423, 0xc) }, /* CATC Netmate II, Belkin F5U111 */
944 { USB_DEVICE(0x08d1, 0x1) }, /* smartBridges smartNIC */
948 MODULE_DEVICE_TABLE(usb
, catc_id_table
);
950 static struct usb_driver catc_driver
= {
953 .disconnect
= catc_disconnect
,
954 .id_table
= catc_id_table
,
955 .disable_hub_initiated_lpm
= 1,
958 module_usb_driver(catc_driver
);