2 * Copyright (c) 1997, 1998, 1999, 2000
3 * Bill Paul <wpaul@ee.columbia.edu>. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Bill Paul.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30 * THE POSSIBILITY OF SUCH DAMAGE.
32 * $FreeBSD: head/sys/dev/usb/net/if_cue.c 271832 2014-09-18 21:09:22Z glebius $
36 * CATC USB-EL1210A USB to ethernet driver. Used in the CATC Netmate
37 * adapters and others.
39 * Written by Bill Paul <wpaul@ee.columbia.edu>
40 * Electrical Engineering Department
41 * Columbia University, New York City
45 * The CATC USB-EL1210A provides USB ethernet support at 10Mbps. The
46 * RX filter uses a 512-bit multicast hash table, single perfect entry
47 * for the station address, and promiscuous mode. Unlike the ADMtek
48 * and KLSI chips, the CATC ASIC supports read and write combining
49 * mode where multiple packets can be transfered using a single bulk
50 * transaction, which helps performance a great deal.
53 #include <sys/stdint.h>
54 #include <sys/param.h>
55 #include <sys/queue.h>
56 #include <sys/types.h>
57 #include <sys/systm.h>
58 #include <sys/socket.h>
59 #include <sys/kernel.h>
61 #include <sys/module.h>
63 #include <sys/condvar.h>
64 #include <sys/sysctl.h>
65 #include <sys/unistd.h>
66 #include <sys/callout.h>
67 #include <sys/malloc.h>
71 #include <net/if_var.h>
72 #include <net/ifq_var.h>
74 #include <bus/u4b/usb.h>
75 #include <bus/u4b/usbdi.h>
76 #include <bus/u4b/usbdi_util.h>
79 #define USB_DEBUG_VAR cue_debug
80 #include <bus/u4b/usb_debug.h>
81 #include <bus/u4b/usb_process.h>
83 #include <bus/u4b/net/usb_ethernet.h>
84 #include <bus/u4b/net/if_cuereg.h>
87 * Various supported device vendors/products.
90 /* Belkin F5U111 adapter covered by NETMATE entry */
92 static const STRUCT_USB_HOST_ID cue_devs
[] = {
93 #define CUE_DEV(v,p) { USB_VP(USB_VENDOR_##v, USB_PRODUCT_##v##_##p) }
94 CUE_DEV(CATC
, NETMATE
),
95 CUE_DEV(CATC
, NETMATE2
),
96 CUE_DEV(SMARTBRIDGES
, SMARTLINK
),
102 static device_probe_t cue_probe
;
103 static device_attach_t cue_attach
;
104 static device_detach_t cue_detach
;
106 static usb_callback_t cue_bulk_read_callback
;
107 static usb_callback_t cue_bulk_write_callback
;
109 static uether_fn_t cue_attach_post
;
110 static uether_fn_t cue_init
;
111 static uether_fn_t cue_stop
;
112 static uether_fn_t cue_start
;
113 static uether_fn_t cue_tick
;
114 static uether_fn_t cue_setmulti
;
115 static uether_fn_t cue_setpromisc
;
117 static uint8_t cue_csr_read_1(struct cue_softc
*, uint16_t);
118 static uint16_t cue_csr_read_2(struct cue_softc
*, uint8_t);
119 static int cue_csr_write_1(struct cue_softc
*, uint16_t, uint16_t);
120 static int cue_mem(struct cue_softc
*, uint8_t, uint16_t, void *, int);
121 static int cue_getmac(struct cue_softc
*, void *);
122 static uint32_t cue_mchash(const uint8_t *);
123 static void cue_reset(struct cue_softc
*);
126 static int cue_debug
= 0;
128 static SYSCTL_NODE(_hw_usb
, OID_AUTO
, cue
, CTLFLAG_RW
, 0, "USB cue");
129 SYSCTL_INT(_hw_usb_cue
, OID_AUTO
, debug
, CTLFLAG_RW
, &cue_debug
, 0,
133 static const struct usb_config cue_config
[CUE_N_TRANSFER
] = {
137 .endpoint
= UE_ADDR_ANY
,
138 .direction
= UE_DIR_OUT
,
139 .bufsize
= (MCLBYTES
+ 2),
140 .flags
= {.pipe_bof
= 1,},
141 .callback
= cue_bulk_write_callback
,
142 .timeout
= 10000, /* 10 seconds */
147 .endpoint
= UE_ADDR_ANY
,
148 .direction
= UE_DIR_IN
,
149 .bufsize
= (MCLBYTES
+ 2),
150 .flags
= {.pipe_bof
= 1,.short_xfer_ok
= 1,},
151 .callback
= cue_bulk_read_callback
,
155 static device_method_t cue_methods
[] = {
156 /* Device interface */
157 DEVMETHOD(device_probe
, cue_probe
),
158 DEVMETHOD(device_attach
, cue_attach
),
159 DEVMETHOD(device_detach
, cue_detach
),
164 static driver_t cue_driver
= {
166 .methods
= cue_methods
,
167 .size
= sizeof(struct cue_softc
),
170 static devclass_t cue_devclass
;
172 DRIVER_MODULE(cue
, uhub
, cue_driver
, cue_devclass
, NULL
, NULL
);
173 MODULE_DEPEND(cue
, uether
, 1, 1, 1);
174 MODULE_DEPEND(cue
, usb
, 1, 1, 1);
175 MODULE_DEPEND(cue
, ether
, 1, 1, 1);
176 MODULE_VERSION(cue
, 1);
178 static const struct usb_ether_methods cue_ue_methods
= {
179 .ue_attach_post
= cue_attach_post
,
180 .ue_start
= cue_start
,
184 .ue_setmulti
= cue_setmulti
,
185 .ue_setpromisc
= cue_setpromisc
,
188 #define CUE_SETBIT(sc, reg, x) \
189 cue_csr_write_1(sc, reg, cue_csr_read_1(sc, reg) | (x))
191 #define CUE_CLRBIT(sc, reg, x) \
192 cue_csr_write_1(sc, reg, cue_csr_read_1(sc, reg) & ~(x))
195 cue_csr_read_1(struct cue_softc
*sc
, uint16_t reg
)
197 struct usb_device_request req
;
200 req
.bmRequestType
= UT_READ_VENDOR_DEVICE
;
201 req
.bRequest
= CUE_CMD_READREG
;
202 USETW(req
.wValue
, 0);
203 USETW(req
.wIndex
, reg
);
204 USETW(req
.wLength
, 1);
206 if (uether_do_request(&sc
->sc_ue
, &req
, &val
, 1000)) {
207 /* ignore any errors */
213 cue_csr_read_2(struct cue_softc
*sc
, uint8_t reg
)
215 struct usb_device_request req
;
218 req
.bmRequestType
= UT_READ_VENDOR_DEVICE
;
219 req
.bRequest
= CUE_CMD_READREG
;
220 USETW(req
.wValue
, 0);
221 USETW(req
.wIndex
, reg
);
222 USETW(req
.wLength
, 2);
224 (void)uether_do_request(&sc
->sc_ue
, &req
, &val
, 1000);
225 return (le16toh(val
));
229 cue_csr_write_1(struct cue_softc
*sc
, uint16_t reg
, uint16_t val
)
231 struct usb_device_request req
;
233 req
.bmRequestType
= UT_WRITE_VENDOR_DEVICE
;
234 req
.bRequest
= CUE_CMD_WRITEREG
;
235 USETW(req
.wValue
, val
);
236 USETW(req
.wIndex
, reg
);
237 USETW(req
.wLength
, 0);
239 return (uether_do_request(&sc
->sc_ue
, &req
, NULL
, 1000));
243 cue_mem(struct cue_softc
*sc
, uint8_t cmd
, uint16_t addr
, void *buf
, int len
)
245 struct usb_device_request req
;
247 if (cmd
== CUE_CMD_READSRAM
)
248 req
.bmRequestType
= UT_READ_VENDOR_DEVICE
;
250 req
.bmRequestType
= UT_WRITE_VENDOR_DEVICE
;
252 USETW(req
.wValue
, 0);
253 USETW(req
.wIndex
, addr
);
254 USETW(req
.wLength
, len
);
256 return (uether_do_request(&sc
->sc_ue
, &req
, buf
, 1000));
260 cue_getmac(struct cue_softc
*sc
, void *buf
)
262 struct usb_device_request req
;
264 req
.bmRequestType
= UT_READ_VENDOR_DEVICE
;
265 req
.bRequest
= CUE_CMD_GET_MACADDR
;
266 USETW(req
.wValue
, 0);
267 USETW(req
.wIndex
, 0);
268 USETW(req
.wLength
, ETHER_ADDR_LEN
);
270 return (uether_do_request(&sc
->sc_ue
, &req
, buf
, 1000));
276 cue_mchash(const uint8_t *addr
)
280 /* Compute CRC for the address value. */
281 crc
= ether_crc32_le(addr
, ETHER_ADDR_LEN
);
283 return (crc
& ((1 << CUE_BITS
) - 1));
287 cue_setpromisc(struct usb_ether
*ue
)
289 struct cue_softc
*sc
= uether_getsc(ue
);
290 struct ifnet
*ifp
= uether_getifp(ue
);
294 /* if we want promiscuous mode, set the allframes bit */
295 if (ifp
->if_flags
& IFF_PROMISC
)
296 CUE_SETBIT(sc
, CUE_ETHCTL
, CUE_ETHCTL_PROMISC
);
298 CUE_CLRBIT(sc
, CUE_ETHCTL
, CUE_ETHCTL_PROMISC
);
300 /* write multicast hash-bits */
305 cue_setmulti(struct usb_ether
*ue
)
307 struct cue_softc
*sc
= uether_getsc(ue
);
308 struct ifnet
*ifp
= uether_getifp(ue
);
309 struct ifmultiaddr
*ifma
;
311 uint8_t hashtbl
[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
315 if (ifp
->if_flags
& IFF_ALLMULTI
|| ifp
->if_flags
& IFF_PROMISC
) {
316 for (i
= 0; i
< 8; i
++)
318 cue_mem(sc
, CUE_CMD_WRITESRAM
, CUE_MCAST_TABLE_ADDR
,
323 /* now program new ones */
324 TAILQ_FOREACH(ifma
, &ifp
->if_multiaddrs
, ifma_link
)
326 if (ifma
->ifma_addr
->sa_family
!= AF_LINK
)
328 h
= cue_mchash(LLADDR((struct sockaddr_dl
*)ifma
->ifma_addr
));
329 hashtbl
[h
>> 3] |= 1 << (h
& 0x7);
333 * Also include the broadcast address in the filter
334 * so we can receive broadcast frames.
336 if (ifp
->if_flags
& IFF_BROADCAST
) {
337 h
= cue_mchash(ifp
->if_broadcastaddr
);
338 hashtbl
[h
>> 3] |= 1 << (h
& 0x7);
341 cue_mem(sc
, CUE_CMD_WRITESRAM
, CUE_MCAST_TABLE_ADDR
, &hashtbl
, 8);
345 cue_reset(struct cue_softc
*sc
)
347 struct usb_device_request req
;
349 req
.bmRequestType
= UT_WRITE_VENDOR_DEVICE
;
350 req
.bRequest
= CUE_CMD_RESET
;
351 USETW(req
.wValue
, 0);
352 USETW(req
.wIndex
, 0);
353 USETW(req
.wLength
, 0);
355 if (uether_do_request(&sc
->sc_ue
, &req
, NULL
, 1000)) {
356 /* ignore any errors */
360 * wait a little while for the chip to get its brains in order:
362 uether_pause(&sc
->sc_ue
, hz
/ 100);
366 cue_attach_post(struct usb_ether
*ue
)
368 struct cue_softc
*sc
= uether_getsc(ue
);
370 cue_getmac(sc
, ue
->ue_eaddr
);
374 cue_probe(device_t dev
)
376 struct usb_attach_arg
*uaa
= device_get_ivars(dev
);
378 if (uaa
->usb_mode
!= USB_MODE_HOST
)
380 if (uaa
->info
.bConfigIndex
!= CUE_CONFIG_IDX
)
382 if (uaa
->info
.bIfaceIndex
!= CUE_IFACE_IDX
)
385 return (usbd_lookup_id_by_uaa(cue_devs
, sizeof(cue_devs
), uaa
));
389 * Attach the interface. Allocate softc structures, do ifmedia
390 * setup and ethernet/BPF attach.
393 cue_attach(device_t dev
)
395 struct usb_attach_arg
*uaa
= device_get_ivars(dev
);
396 struct cue_softc
*sc
= device_get_softc(dev
);
397 struct usb_ether
*ue
= &sc
->sc_ue
;
401 device_set_usb_desc(dev
);
402 lockinit(&sc
->sc_lock
, device_get_nameunit(dev
), 0, LK_CANRECURSE
);
404 iface_index
= CUE_IFACE_IDX
;
405 error
= usbd_transfer_setup(uaa
->device
, &iface_index
,
406 sc
->sc_xfer
, cue_config
, CUE_N_TRANSFER
, sc
, &sc
->sc_lock
);
408 device_printf(dev
, "allocating USB transfers failed\n");
414 ue
->ue_udev
= uaa
->device
;
415 ue
->ue_lock
= &sc
->sc_lock
;
416 ue
->ue_methods
= &cue_ue_methods
;
418 error
= uether_ifattach(ue
);
420 device_printf(dev
, "could not attach interface\n");
423 return (0); /* success */
427 return (ENXIO
); /* failure */
431 cue_detach(device_t dev
)
433 struct cue_softc
*sc
= device_get_softc(dev
);
434 struct usb_ether
*ue
= &sc
->sc_ue
;
436 usbd_transfer_unsetup(sc
->sc_xfer
, CUE_N_TRANSFER
);
438 lockuninit(&sc
->sc_lock
);
444 cue_bulk_read_callback(struct usb_xfer
*xfer
, usb_error_t error
)
446 struct cue_softc
*sc
= usbd_xfer_softc(xfer
);
447 struct usb_ether
*ue
= &sc
->sc_ue
;
448 struct ifnet
*ifp
= uether_getifp(ue
);
449 struct usb_page_cache
*pc
;
454 usbd_xfer_status(xfer
, &actlen
, NULL
, NULL
, NULL
);
456 switch (USB_GET_STATE(xfer
)) {
457 case USB_ST_TRANSFERRED
:
459 if (actlen
<= (int)(2 + sizeof(struct ether_header
))) {
460 IFNET_STAT_INC(ifp
, ierrors
, 1);
463 pc
= usbd_xfer_get_frame(xfer
, 0);
464 usbd_copy_out(pc
, 0, buf
, 2);
466 len
= buf
[0] | (buf
[1] << 8);
467 len
= min(actlen
, len
);
469 uether_rxbuf(ue
, pc
, 2, len
);
473 usbd_xfer_set_frame_len(xfer
, 0, usbd_xfer_max_len(xfer
));
474 usbd_transfer_submit(xfer
);
479 DPRINTF("bulk read error, %s\n",
482 if (error
!= USB_ERR_CANCELLED
) {
483 /* try to clear stall first */
484 usbd_xfer_set_stall(xfer
);
493 cue_bulk_write_callback(struct usb_xfer
*xfer
, usb_error_t error
)
495 struct cue_softc
*sc
= usbd_xfer_softc(xfer
);
496 struct ifnet
*ifp
= uether_getifp(&sc
->sc_ue
);
497 struct usb_page_cache
*pc
;
501 switch (USB_GET_STATE(xfer
)) {
502 case USB_ST_TRANSFERRED
:
503 DPRINTFN(11, "transfer complete\n");
504 IFNET_STAT_INC(ifp
, opackets
, 1);
509 m
= ifq_dequeue(&ifp
->if_snd
);
513 if (m
->m_pkthdr
.len
> MCLBYTES
)
514 m
->m_pkthdr
.len
= MCLBYTES
;
515 usbd_xfer_set_frame_len(xfer
, 0, (m
->m_pkthdr
.len
+ 2));
517 /* the first two bytes are the frame length */
519 buf
[0] = (uint8_t)(m
->m_pkthdr
.len
);
520 buf
[1] = (uint8_t)(m
->m_pkthdr
.len
>> 8);
522 pc
= usbd_xfer_get_frame(xfer
, 0);
523 usbd_copy_in(pc
, 0, buf
, 2);
524 usbd_m_copy_in(pc
, 2, m
, 0, m
->m_pkthdr
.len
);
527 * If there's a BPF listener, bounce a copy of this frame
534 usbd_transfer_submit(xfer
);
539 DPRINTFN(11, "transfer error, %s\n",
542 IFNET_STAT_INC(ifp
, oerrors
, 1);
544 if (error
!= USB_ERR_CANCELLED
) {
545 /* try to clear stall first */
546 usbd_xfer_set_stall(xfer
);
554 cue_tick(struct usb_ether
*ue
)
556 struct cue_softc
*sc
= uether_getsc(ue
);
557 struct ifnet
*ifp
= uether_getifp(ue
);
561 IFNET_STAT_INC(ifp
, collisions
, cue_csr_read_2(sc
, CUE_TX_SINGLECOLL
));
562 IFNET_STAT_INC(ifp
, collisions
, cue_csr_read_2(sc
, CUE_TX_MULTICOLL
));
563 IFNET_STAT_INC(ifp
, collisions
, cue_csr_read_2(sc
, CUE_TX_EXCESSCOLL
));
565 if (cue_csr_read_2(sc
, CUE_RX_FRAMEERR
))
566 IFNET_STAT_INC(ifp
, ierrors
, 1);
570 cue_start(struct usb_ether
*ue
)
572 struct cue_softc
*sc
= uether_getsc(ue
);
575 * start the USB transfers, if not already started:
577 usbd_transfer_start(sc
->sc_xfer
[CUE_BULK_DT_RD
]);
578 usbd_transfer_start(sc
->sc_xfer
[CUE_BULK_DT_WR
]);
582 cue_init(struct usb_ether
*ue
)
584 struct cue_softc
*sc
= uether_getsc(ue
);
585 struct ifnet
*ifp
= uether_getifp(ue
);
591 * Cancel pending I/O and free all RX/TX buffers.
597 /* Set MAC address */
598 for (i
= 0; i
< ETHER_ADDR_LEN
; i
++)
599 cue_csr_write_1(sc
, CUE_PAR0
- i
, IF_LLADDR(ifp
)[i
]);
601 /* Enable RX logic. */
602 cue_csr_write_1(sc
, CUE_ETHCTL
, CUE_ETHCTL_RX_ON
| CUE_ETHCTL_MCAST_ON
);
604 /* Load the multicast filter */
608 * Set the number of RX and TX buffers that we want
609 * to reserve inside the ASIC.
611 cue_csr_write_1(sc
, CUE_RX_BUFPKTS
, CUE_RX_FRAMES
);
612 cue_csr_write_1(sc
, CUE_TX_BUFPKTS
, CUE_TX_FRAMES
);
614 /* Set advanced operation modes. */
615 cue_csr_write_1(sc
, CUE_ADVANCED_OPMODES
,
616 CUE_AOP_EMBED_RXLEN
| 0x01);/* 1 wait state */
618 /* Program the LED operation. */
619 cue_csr_write_1(sc
, CUE_LEDCTL
, CUE_LEDCTL_FOLLOW_LINK
);
621 usbd_xfer_set_stall(sc
->sc_xfer
[CUE_BULK_DT_WR
]);
623 ifp
->if_flags
|= IFF_RUNNING
;
628 * Stop the adapter and free any mbufs allocated to the
632 cue_stop(struct usb_ether
*ue
)
634 struct cue_softc
*sc
= uether_getsc(ue
);
635 struct ifnet
*ifp
= uether_getifp(ue
);
639 ifp
->if_flags
&= ~IFF_RUNNING
;
642 * stop all the transfers, if not already stopped:
644 usbd_transfer_stop(sc
->sc_xfer
[CUE_BULK_DT_WR
]);
645 usbd_transfer_stop(sc
->sc_xfer
[CUE_BULK_DT_RD
]);
647 cue_csr_write_1(sc
, CUE_ETHCTL
, 0);