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: src/sys/dev/usb/if_kue.c,v 1.17.2.9 2003/04/13 02:39:25 murray Exp $
33 * $DragonFly: src/sys/dev/netif/kue/if_kue.c,v 1.24 2007/06/28 06:32:32 hasso Exp $
37 * Kawasaki LSI KL5KUSB101B USB to ethernet adapter driver.
39 * Written by Bill Paul <wpaul@ee.columbia.edu>
40 * Electrical Engineering Department
41 * Columbia University, New York City
45 * The KLSI USB to ethernet adapter chip contains an USB serial interface,
46 * ethernet MAC and embedded microcontroller (called the QT Engine).
47 * The chip must have firmware loaded into it before it will operate.
48 * Packets are passed between the chip and host via bulk transfers.
49 * There is an interrupt endpoint mentioned in the software spec, however
50 * it's currently unused. This device is 10Mbps half-duplex only, hence
51 * there is no media selection logic. The MAC supports a 128 entry
52 * multicast filter, though the exact size of the filter can depend
53 * on the firmware. Curiously, while the software spec describes various
54 * ethernet statistics counters, my sample adapter and firmware combination
55 * claims not to support any statistics counters at all.
57 * Note that once we load the firmware in the device, we have to be
58 * careful not to load it again: if you restart your computer but
59 * leave the adapter attached to the USB controller, it may remain
60 * powered on and retain its firmware. In this case, we don't need
61 * to load the firmware a second time.
63 * Special thanks to Rob Furr for providing an ADS Technologies
64 * adapter for development and testing. No monkeys were harmed during
65 * the development of this driver.
68 #include <sys/param.h>
69 #include <sys/systm.h>
70 #include <sys/sockio.h>
72 #include <sys/malloc.h>
73 #include <sys/kernel.h>
74 #include <sys/socket.h>
78 #include <net/ifq_var.h>
79 #include <net/if_arp.h>
80 #include <net/ethernet.h>
81 #include <net/if_dl.h>
82 #include <net/if_media.h>
85 #include <machine/clock.h>
87 #include <bus/usb/usb.h>
88 #include <bus/usb/usbdi.h>
89 #include <bus/usb/usbdi_util.h>
90 #include <bus/usb/usbdivar.h>
91 #include <bus/usb/usbdevs.h>
92 #include <bus/usb/usb_ethersubr.h>
94 #include "if_kuereg.h"
95 #include <bus/usb/kue_fw.h>
97 MODULE_DEPEND(kue
, usb
, 1, 1, 1);
100 * Various supported device vendors/products.
102 static struct kue_type kue_devs
[] = {
103 { USB_VENDOR_AOX
, USB_PRODUCT_AOX_USB101
},
104 { USB_VENDOR_KLSI
, USB_PRODUCT_AOX_USB101
},
105 { USB_VENDOR_ADS
, USB_PRODUCT_ADS_UBS10BT
},
106 { USB_VENDOR_ATEN
, USB_PRODUCT_ATEN_UC10T
},
107 { USB_VENDOR_NETGEAR
, USB_PRODUCT_NETGEAR_EA101
},
108 { USB_VENDOR_PERACOM
, USB_PRODUCT_PERACOM_ENET
},
109 { USB_VENDOR_PERACOM
, USB_PRODUCT_PERACOM_ENET2
},
110 { USB_VENDOR_ENTREGA
, USB_PRODUCT_ENTREGA_E45
},
111 { USB_VENDOR_3COM
, USB_PRODUCT_3COM_3C19250
},
112 { USB_VENDOR_COREGA
, USB_PRODUCT_COREGA_ETHER_USB_T
},
113 { USB_VENDOR_DLINK
, USB_PRODUCT_DLINK_DSB650C
},
114 { USB_VENDOR_SMC
, USB_PRODUCT_SMC_2102USB
},
115 { USB_VENDOR_LINKSYS
, USB_PRODUCT_LINKSYS_USB10T
},
116 { USB_VENDOR_KLSI
, USB_PRODUCT_KLSI_DUH3E10BT
},
117 { USB_VENDOR_KLSI
, USB_PRODUCT_KLSI_DUH3E10BTN
},
118 { USB_VENDOR_PERACOM
, USB_PRODUCT_PERACOM_ENET3
},
119 { USB_VENDOR_IODATA
, USB_PRODUCT_IODATA_USBETT
},
120 { USB_VENDOR_ABOCOM
, USB_PRODUCT_ABOCOM_URE450
},
124 static int kue_match(device_t
);
125 static int kue_attach(device_t
);
126 static int kue_detach(device_t
);
127 static void kue_shutdown(device_t
);
128 static int kue_tx_list_init(struct kue_softc
*);
129 static int kue_rx_list_init(struct kue_softc
*);
130 static int kue_newbuf(struct kue_softc
*, struct kue_chain
*, struct mbuf
*);
131 static int kue_encap(struct kue_softc
*, struct mbuf
*, int);
132 static void kue_rxeof(usbd_xfer_handle
, usbd_private_handle
, usbd_status
);
133 static void kue_txeof(usbd_xfer_handle
, usbd_private_handle
, usbd_status
);
134 static void kue_start(struct ifnet
*);
135 static void kue_rxstart(struct ifnet
*);
136 static int kue_ioctl(struct ifnet
*, u_long
, caddr_t
, struct ucred
*);
137 static void kue_init(void *);
138 static void kue_stop(struct kue_softc
*);
139 static void kue_watchdog(struct ifnet
*);
141 static void kue_setmulti(struct kue_softc
*);
142 static void kue_reset(struct kue_softc
*);
144 static usbd_status
kue_do_request(usbd_device_handle
,
145 usb_device_request_t
*, void *);
146 static usbd_status
kue_ctl(struct kue_softc
*, int, u_int8_t
,
147 u_int16_t
, char *, int);
148 static usbd_status
kue_setword(struct kue_softc
*, u_int8_t
, u_int16_t
);
149 static int kue_load_fw(struct kue_softc
*);
151 static device_method_t kue_methods
[] = {
152 /* Device interface */
153 DEVMETHOD(device_probe
, kue_match
),
154 DEVMETHOD(device_attach
, kue_attach
),
155 DEVMETHOD(device_detach
, kue_detach
),
156 DEVMETHOD(device_shutdown
, kue_shutdown
),
161 static driver_t kue_driver
= {
164 sizeof(struct kue_softc
)
167 static devclass_t kue_devclass
;
169 DECLARE_DUMMY_MODULE(if_kue
);
170 DRIVER_MODULE(kue
, uhub
, kue_driver
, kue_devclass
, usbd_driver_load
, 0);
173 * We have a custom do_request function which is almost like the
174 * regular do_request function, except it has a much longer timeout.
175 * Why? Because we need to make requests over the control endpoint
176 * to download the firmware to the device, which can take longer
177 * than the default timeout.
180 kue_do_request(usbd_device_handle dev
, usb_device_request_t
*req
, void *data
)
182 usbd_xfer_handle xfer
;
185 xfer
= usbd_alloc_xfer(dev
);
186 usbd_setup_default_xfer(xfer
, dev
, 0, 500000, req
,
187 data
, UGETW(req
->wLength
), USBD_SHORT_XFER_OK
, 0);
188 err
= usbd_sync_transfer(xfer
);
189 usbd_free_xfer(xfer
);
194 kue_setword(struct kue_softc
*sc
, u_int8_t breq
, u_int16_t word
)
196 usbd_device_handle dev
;
197 usb_device_request_t req
;
201 return(USBD_NORMAL_COMPLETION
);
207 req
.bmRequestType
= UT_WRITE_VENDOR_DEVICE
;
210 USETW(req
.wValue
, word
);
211 USETW(req
.wIndex
, 0);
212 USETW(req
.wLength
, 0);
214 err
= kue_do_request(dev
, &req
, NULL
);
222 kue_ctl(struct kue_softc
*sc
, int rw
, u_int8_t breq
, u_int16_t val
,
225 usbd_device_handle dev
;
226 usb_device_request_t req
;
232 return(USBD_NORMAL_COMPLETION
);
236 if (rw
== KUE_CTL_WRITE
)
237 req
.bmRequestType
= UT_WRITE_VENDOR_DEVICE
;
239 req
.bmRequestType
= UT_READ_VENDOR_DEVICE
;
242 USETW(req
.wValue
, val
);
243 USETW(req
.wIndex
, 0);
244 USETW(req
.wLength
, len
);
246 err
= kue_do_request(dev
, &req
, data
);
254 kue_load_fw(struct kue_softc
*sc
)
257 usb_device_descriptor_t
*dd
;
260 dd
= &sc
->kue_udev
->ddesc
;
261 hwrev
= UGETW(dd
->bcdDevice
);
264 * First, check if we even need to load the firmware.
265 * If the device was still attached when the system was
266 * rebooted, it may already have firmware loaded in it.
267 * If this is the case, we don't need to do it again.
268 * And in fact, if we try to load it again, we'll hang,
269 * so we have to avoid this condition if we don't want
272 * We can test this quickly by checking the bcdRevision
273 * code. The NIC will return a different revision code if
274 * it's probed while the firmware is still loaded and
280 /* Load code segment */
281 err
= kue_ctl(sc
, KUE_CTL_WRITE
, KUE_CMD_SEND_SCAN
,
282 0, kue_code_seg
, sizeof(kue_code_seg
));
284 kprintf("kue%d: failed to load code segment: %s\n",
285 sc
->kue_unit
, usbd_errstr(err
));
289 /* Load fixup segment */
290 err
= kue_ctl(sc
, KUE_CTL_WRITE
, KUE_CMD_SEND_SCAN
,
291 0, kue_fix_seg
, sizeof(kue_fix_seg
));
293 kprintf("kue%d: failed to load fixup segment: %s\n",
294 sc
->kue_unit
, usbd_errstr(err
));
298 /* Send trigger command. */
299 err
= kue_ctl(sc
, KUE_CTL_WRITE
, KUE_CMD_SEND_SCAN
,
300 0, kue_trig_seg
, sizeof(kue_trig_seg
));
302 kprintf("kue%d: failed to load trigger segment: %s\n",
303 sc
->kue_unit
, usbd_errstr(err
));
311 kue_setmulti(struct kue_softc
*sc
)
314 struct ifmultiaddr
*ifma
;
317 ifp
= &sc
->arpcom
.ac_if
;
319 if (ifp
->if_flags
& IFF_ALLMULTI
|| ifp
->if_flags
& IFF_PROMISC
) {
320 sc
->kue_rxfilt
|= KUE_RXFILT_ALLMULTI
;
321 sc
->kue_rxfilt
&= ~KUE_RXFILT_MULTICAST
;
322 kue_setword(sc
, KUE_CMD_SET_PKT_FILTER
, sc
->kue_rxfilt
);
326 sc
->kue_rxfilt
&= ~KUE_RXFILT_ALLMULTI
;
328 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
329 TAILQ_FOREACH(ifma
, &ifp
->if_multiaddrs
, ifma_link
)
331 LIST_FOREACH(ifma
, &ifp
->if_multiaddrs
, ifma_link
)
334 if (ifma
->ifma_addr
->sa_family
!= AF_LINK
)
337 * If there are too many addresses for the
338 * internal filter, switch over to allmulti mode.
340 if (i
== KUE_MCFILTCNT(sc
))
342 bcopy(LLADDR((struct sockaddr_dl
*)ifma
->ifma_addr
),
343 KUE_MCFILT(sc
, i
), ETHER_ADDR_LEN
);
347 if (i
== KUE_MCFILTCNT(sc
))
348 sc
->kue_rxfilt
|= KUE_RXFILT_ALLMULTI
;
350 sc
->kue_rxfilt
|= KUE_RXFILT_MULTICAST
;
351 kue_ctl(sc
, KUE_CTL_WRITE
, KUE_CMD_SET_MCAST_FILTERS
,
352 i
, sc
->kue_mcfilters
, i
* ETHER_ADDR_LEN
);
355 kue_setword(sc
, KUE_CMD_SET_PKT_FILTER
, sc
->kue_rxfilt
);
361 * Issue a SET_CONFIGURATION command to reset the MAC. This should be
362 * done after the firmware is loaded into the adapter in order to
363 * bring it into proper operation.
366 kue_reset(struct kue_softc
*sc
)
368 if (usbd_set_config_no(sc
->kue_udev
, KUE_CONFIG_NO
, 0) ||
369 usbd_device2interface_handle(sc
->kue_udev
, KUE_IFACE_IDX
,
371 kprintf("kue%d: getting interface handle failed\n",
375 /* Wait a little while for the chip to get its brains in order. */
381 * Probe for a KLSI chip.
385 USB_MATCH_START(kue
, uaa
);
393 if (uaa
->vendor
== t
->kue_vid
&&
394 uaa
->product
== t
->kue_did
) {
395 return(UMATCH_VENDOR_PRODUCT
);
404 * Attach the interface. Allocate softc structures, do
405 * setup and ethernet/BPF attach.
409 USB_ATTACH_START(kue
, sc
, uaa
);
413 usb_interface_descriptor_t
*id
;
414 usb_endpoint_descriptor_t
*ed
;
417 sc
->kue_iface
= uaa
->iface
;
418 sc
->kue_udev
= uaa
->device
;
419 sc
->kue_unit
= device_get_unit(self
);
421 id
= usbd_get_interface_descriptor(uaa
->iface
);
423 usbd_devinfo(uaa
->device
, 0, devinfo
);
424 device_set_desc_copy(self
, devinfo
);
425 kprintf("%s: %s\n", device_get_nameunit(self
), devinfo
);
427 /* Find endpoints. */
428 for (i
= 0; i
< id
->bNumEndpoints
; i
++) {
429 ed
= usbd_interface2endpoint_descriptor(uaa
->iface
, i
);
431 kprintf("kue%d: couldn't get ep %d\n",
433 USB_ATTACH_ERROR_RETURN
;
435 if (UE_GET_DIR(ed
->bEndpointAddress
) == UE_DIR_IN
&&
436 UE_GET_XFERTYPE(ed
->bmAttributes
) == UE_BULK
) {
437 sc
->kue_ed
[KUE_ENDPT_RX
] = ed
->bEndpointAddress
;
438 } else if (UE_GET_DIR(ed
->bEndpointAddress
) == UE_DIR_OUT
&&
439 UE_GET_XFERTYPE(ed
->bmAttributes
) == UE_BULK
) {
440 sc
->kue_ed
[KUE_ENDPT_TX
] = ed
->bEndpointAddress
;
441 } else if (UE_GET_DIR(ed
->bEndpointAddress
) == UE_DIR_IN
&&
442 UE_GET_XFERTYPE(ed
->bmAttributes
) == UE_INTERRUPT
) {
443 sc
->kue_ed
[KUE_ENDPT_INTR
] = ed
->bEndpointAddress
;
447 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
448 mtx_init(&sc
->kue_mtx
, device_get_nameunit(self
), MTX_NETWORK_LOCK
,
449 MTX_DEF
| MTX_RECURSE
);
453 /* Load the firmware into the NIC. */
454 if (kue_load_fw(sc
)) {
456 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
457 mtx_destroy(&sc
->kue_mtx
);
459 USB_ATTACH_ERROR_RETURN
;
462 /* Reset the adapter. */
465 /* Read ethernet descriptor */
466 err
= kue_ctl(sc
, KUE_CTL_READ
, KUE_CMD_GET_ETHER_DESCRIPTOR
,
467 0, (char *)&sc
->kue_desc
, sizeof(sc
->kue_desc
));
469 sc
->kue_mcfilters
= kmalloc(KUE_MCFILTCNT(sc
) * ETHER_ADDR_LEN
,
472 ifp
= &sc
->arpcom
.ac_if
;
474 if_initname(ifp
, "kue", sc
->kue_unit
);
475 ifp
->if_mtu
= ETHERMTU
;
476 ifp
->if_flags
= IFF_BROADCAST
| IFF_SIMPLEX
| IFF_MULTICAST
;
477 ifp
->if_ioctl
= kue_ioctl
;
478 ifp
->if_start
= kue_start
;
479 ifp
->if_watchdog
= kue_watchdog
;
480 ifp
->if_init
= kue_init
;
481 ifp
->if_baudrate
= 10000000;
482 ifq_set_maxlen(&ifp
->if_snd
, IFQ_MAXLEN
);
483 ifq_set_ready(&ifp
->if_snd
);
486 * Call MI attach routine.
488 ether_ifattach(ifp
, sc
->kue_desc
.kue_macaddr
, NULL
);
489 usb_register_netisr();
494 USB_ATTACH_SUCCESS_RETURN
;
498 kue_detach(device_t dev
)
500 struct kue_softc
*sc
;
503 sc
= device_get_softc(dev
);
505 ifp
= &sc
->arpcom
.ac_if
;
512 if (sc
->kue_ep
[KUE_ENDPT_TX
] != NULL
)
513 usbd_abort_pipe(sc
->kue_ep
[KUE_ENDPT_TX
]);
514 if (sc
->kue_ep
[KUE_ENDPT_RX
] != NULL
)
515 usbd_abort_pipe(sc
->kue_ep
[KUE_ENDPT_RX
]);
516 if (sc
->kue_ep
[KUE_ENDPT_INTR
] != NULL
)
517 usbd_abort_pipe(sc
->kue_ep
[KUE_ENDPT_INTR
]);
519 if (sc
->kue_mcfilters
!= NULL
)
520 kfree(sc
->kue_mcfilters
, M_USBDEV
);
523 #if defined(__FreeBSD__) && __FreeBSD_version >= 500000
524 mtx_destroy(&sc
->kue_mtx
);
531 * Initialize an RX descriptor and attach an MBUF cluster.
534 kue_newbuf(struct kue_softc
*sc
, struct kue_chain
*c
, struct mbuf
*m
)
536 struct mbuf
*m_new
= NULL
;
539 MGETHDR(m_new
, MB_DONTWAIT
, MT_DATA
);
541 kprintf("kue%d: no memory for rx list "
542 "-- packet dropped!\n", sc
->kue_unit
);
546 MCLGET(m_new
, MB_DONTWAIT
);
547 if (!(m_new
->m_flags
& M_EXT
)) {
548 kprintf("kue%d: no memory for rx list "
549 "-- packet dropped!\n", sc
->kue_unit
);
553 m_new
->m_len
= m_new
->m_pkthdr
.len
= MCLBYTES
;
556 m_new
->m_len
= m_new
->m_pkthdr
.len
= MCLBYTES
;
557 m_new
->m_data
= m_new
->m_ext
.ext_buf
;
566 kue_rx_list_init(struct kue_softc
*sc
)
568 struct kue_cdata
*cd
;
573 for (i
= 0; i
< KUE_RX_LIST_CNT
; i
++) {
574 c
= &cd
->kue_rx_chain
[i
];
577 if (kue_newbuf(sc
, c
, NULL
) == ENOBUFS
)
579 if (c
->kue_xfer
== NULL
) {
580 c
->kue_xfer
= usbd_alloc_xfer(sc
->kue_udev
);
581 if (c
->kue_xfer
== NULL
)
590 kue_tx_list_init(struct kue_softc
*sc
)
592 struct kue_cdata
*cd
;
597 for (i
= 0; i
< KUE_TX_LIST_CNT
; i
++) {
598 c
= &cd
->kue_tx_chain
[i
];
602 if (c
->kue_xfer
== NULL
) {
603 c
->kue_xfer
= usbd_alloc_xfer(sc
->kue_udev
);
604 if (c
->kue_xfer
== NULL
)
607 c
->kue_buf
= kmalloc(KUE_BUFSZ
, M_USBDEV
, M_WAITOK
);
608 if (c
->kue_buf
== NULL
)
616 kue_rxstart(struct ifnet
*ifp
)
618 struct kue_softc
*sc
;
623 c
= &sc
->kue_cdata
.kue_rx_chain
[sc
->kue_cdata
.kue_rx_prod
];
625 if (kue_newbuf(sc
, c
, NULL
) == ENOBUFS
) {
630 /* Setup new transfer. */
631 usbd_setup_xfer(c
->kue_xfer
, sc
->kue_ep
[KUE_ENDPT_RX
],
632 c
, mtod(c
->kue_mbuf
, char *), KUE_BUFSZ
, USBD_SHORT_XFER_OK
,
633 USBD_NO_TIMEOUT
, kue_rxeof
);
634 usbd_transfer(c
->kue_xfer
);
642 * A frame has been uploaded: pass the resulting mbuf chain up to
643 * the higher level protocols.
646 kue_rxeof(usbd_xfer_handle xfer
, usbd_private_handle priv
, usbd_status status
)
648 struct kue_softc
*sc
;
658 ifp
= &sc
->arpcom
.ac_if
;
660 if (!(ifp
->if_flags
& IFF_RUNNING
)) {
665 if (status
!= USBD_NORMAL_COMPLETION
) {
666 if (status
== USBD_NOT_STARTED
|| status
== USBD_CANCELLED
) {
670 if (usbd_ratecheck(&sc
->kue_rx_notice
))
671 kprintf("kue%d: usb error on rx: %s\n", sc
->kue_unit
,
672 usbd_errstr(status
));
673 if (status
== USBD_STALLED
)
674 usbd_clear_endpoint_stall(sc
->kue_ep
[KUE_ENDPT_RX
]);
678 usbd_get_xfer_status(xfer
, NULL
, NULL
, &total_len
, NULL
);
683 len
= *mtod(m
, u_int16_t
*);
684 m_adj(m
, sizeof(u_int16_t
));
686 /* No errors; receive the packet. */
689 if (len
< sizeof(struct ether_header
)) {
695 m
->m_pkthdr
.rcvif
= ifp
;
696 m
->m_pkthdr
.len
= m
->m_len
= total_len
;
698 /* Put the packet on the special USB input queue. */
707 /* Setup new transfer. */
708 usbd_setup_xfer(c
->kue_xfer
, sc
->kue_ep
[KUE_ENDPT_RX
],
709 c
, mtod(c
->kue_mbuf
, char *), KUE_BUFSZ
, USBD_SHORT_XFER_OK
,
710 USBD_NO_TIMEOUT
, kue_rxeof
);
711 usbd_transfer(c
->kue_xfer
);
718 * A frame was downloaded to the chip. It's safe for us to clean up
723 kue_txeof(usbd_xfer_handle xfer
, usbd_private_handle priv
, usbd_status status
)
725 struct kue_softc
*sc
;
734 ifp
= &sc
->arpcom
.ac_if
;
736 ifp
->if_flags
&= ~IFF_OACTIVE
;
738 if (status
!= USBD_NORMAL_COMPLETION
) {
739 if (status
== USBD_NOT_STARTED
|| status
== USBD_CANCELLED
) {
743 kprintf("kue%d: usb error on tx: %s\n", sc
->kue_unit
,
744 usbd_errstr(status
));
745 if (status
== USBD_STALLED
)
746 usbd_clear_endpoint_stall(sc
->kue_ep
[KUE_ENDPT_TX
]);
751 usbd_get_xfer_status(c
->kue_xfer
, NULL
, NULL
, NULL
, &err
);
753 if (c
->kue_mbuf
!= NULL
) {
754 m_freem(c
->kue_mbuf
);
763 if (!ifq_is_empty(&ifp
->if_snd
))
764 (*ifp
->if_start
)(ifp
);
772 kue_encap(struct kue_softc
*sc
, struct mbuf
*m
, int idx
)
778 c
= &sc
->kue_cdata
.kue_tx_chain
[idx
];
781 * Copy the mbuf data into a contiguous buffer, leaving two
782 * bytes at the beginning to hold the frame length.
784 m_copydata(m
, 0, m
->m_pkthdr
.len
, c
->kue_buf
+ 2);
787 total_len
= m
->m_pkthdr
.len
+ 2;
788 total_len
+= 64 - (total_len
% 64);
790 /* Frame length is specified in the first 2 bytes of the buffer. */
791 c
->kue_buf
[0] = (u_int8_t
)m
->m_pkthdr
.len
;
792 c
->kue_buf
[1] = (u_int8_t
)(m
->m_pkthdr
.len
>> 8);
794 usbd_setup_xfer(c
->kue_xfer
, sc
->kue_ep
[KUE_ENDPT_TX
],
795 c
, c
->kue_buf
, total_len
, 0, 10000, kue_txeof
);
798 err
= usbd_transfer(c
->kue_xfer
);
799 if (err
!= USBD_IN_PROGRESS
) {
804 sc
->kue_cdata
.kue_tx_cnt
++;
810 kue_start(struct ifnet
*ifp
)
812 struct kue_softc
*sc
;
813 struct mbuf
*m_head
= NULL
;
818 if (ifp
->if_flags
& IFF_OACTIVE
) {
823 m_head
= ifq_poll(&ifp
->if_snd
);
824 if (m_head
== NULL
) {
829 if (kue_encap(sc
, m_head
, 0)) {
830 ifp
->if_flags
|= IFF_OACTIVE
;
834 ifq_dequeue(&ifp
->if_snd
, m_head
);
837 * If there's a BPF listener, bounce a copy of this frame
840 BPF_MTAP(ifp
, m_head
);
842 ifp
->if_flags
|= IFF_OACTIVE
;
845 * Set a timeout in case the chip goes out to lunch.
856 struct kue_softc
*sc
= xsc
;
857 struct ifnet
*ifp
= &sc
->arpcom
.ac_if
;
864 if (ifp
->if_flags
& IFF_RUNNING
) {
869 /* Set MAC address */
870 kue_ctl(sc
, KUE_CTL_WRITE
, KUE_CMD_SET_MAC
,
871 0, sc
->arpcom
.ac_enaddr
, ETHER_ADDR_LEN
);
873 sc
->kue_rxfilt
= KUE_RXFILT_UNICAST
|KUE_RXFILT_BROADCAST
;
875 /* If we want promiscuous mode, set the allframes bit. */
876 if (ifp
->if_flags
& IFF_PROMISC
)
877 sc
->kue_rxfilt
|= KUE_RXFILT_PROMISC
;
879 kue_setword(sc
, KUE_CMD_SET_PKT_FILTER
, sc
->kue_rxfilt
);
881 /* I'm not sure how to tune these. */
884 * Leave this one alone for now; setting it
885 * wrong causes lockups on some machines/controllers.
887 kue_setword(sc
, KUE_CMD_SET_SOFS
, 1);
889 kue_setword(sc
, KUE_CMD_SET_URB_SIZE
, 64);
892 if (kue_tx_list_init(sc
) == ENOBUFS
) {
893 kprintf("kue%d: tx list init failed\n", sc
->kue_unit
);
899 if (kue_rx_list_init(sc
) == ENOBUFS
) {
900 kprintf("kue%d: rx list init failed\n", sc
->kue_unit
);
905 /* Load the multicast filter. */
908 /* Open RX and TX pipes. */
909 err
= usbd_open_pipe(sc
->kue_iface
, sc
->kue_ed
[KUE_ENDPT_RX
],
910 USBD_EXCLUSIVE_USE
, &sc
->kue_ep
[KUE_ENDPT_RX
]);
912 kprintf("kue%d: open rx pipe failed: %s\n",
913 sc
->kue_unit
, usbd_errstr(err
));
918 err
= usbd_open_pipe(sc
->kue_iface
, sc
->kue_ed
[KUE_ENDPT_TX
],
919 USBD_EXCLUSIVE_USE
, &sc
->kue_ep
[KUE_ENDPT_TX
]);
921 kprintf("kue%d: open tx pipe failed: %s\n",
922 sc
->kue_unit
, usbd_errstr(err
));
927 /* Start up the receive pipe. */
928 for (i
= 0; i
< KUE_RX_LIST_CNT
; i
++) {
929 c
= &sc
->kue_cdata
.kue_rx_chain
[i
];
930 usbd_setup_xfer(c
->kue_xfer
, sc
->kue_ep
[KUE_ENDPT_RX
],
931 c
, mtod(c
->kue_mbuf
, char *), KUE_BUFSZ
,
932 USBD_SHORT_XFER_OK
, USBD_NO_TIMEOUT
, kue_rxeof
);
933 usbd_transfer(c
->kue_xfer
);
936 ifp
->if_flags
|= IFF_RUNNING
;
937 ifp
->if_flags
&= ~IFF_OACTIVE
;
945 kue_ioctl(struct ifnet
*ifp
, u_long command
, caddr_t data
, struct ucred
*cr
)
947 struct kue_softc
*sc
= ifp
->if_softc
;
954 if (ifp
->if_flags
& IFF_UP
) {
955 if (ifp
->if_flags
& IFF_RUNNING
&&
956 ifp
->if_flags
& IFF_PROMISC
&&
957 !(sc
->kue_if_flags
& IFF_PROMISC
)) {
958 sc
->kue_rxfilt
|= KUE_RXFILT_PROMISC
;
959 kue_setword(sc
, KUE_CMD_SET_PKT_FILTER
,
961 } else if (ifp
->if_flags
& IFF_RUNNING
&&
962 !(ifp
->if_flags
& IFF_PROMISC
) &&
963 sc
->kue_if_flags
& IFF_PROMISC
) {
964 sc
->kue_rxfilt
&= ~KUE_RXFILT_PROMISC
;
965 kue_setword(sc
, KUE_CMD_SET_PKT_FILTER
,
967 } else if (!(ifp
->if_flags
& IFF_RUNNING
))
970 if (ifp
->if_flags
& IFF_RUNNING
)
973 sc
->kue_if_flags
= ifp
->if_flags
;
982 error
= ether_ioctl(ifp
, command
, data
);
992 kue_watchdog(struct ifnet
*ifp
)
994 struct kue_softc
*sc
;
1001 kprintf("kue%d: watchdog timeout\n", sc
->kue_unit
);
1003 c
= &sc
->kue_cdata
.kue_tx_chain
[0];
1004 usbd_get_xfer_status(c
->kue_xfer
, NULL
, NULL
, NULL
, &stat
);
1005 kue_txeof(c
->kue_xfer
, c
, stat
);
1007 if (ifq_is_empty(&ifp
->if_snd
))
1015 * Stop the adapter and free any mbufs allocated to the
1019 kue_stop(struct kue_softc
*sc
)
1026 ifp
= &sc
->arpcom
.ac_if
;
1029 /* Stop transfers. */
1030 if (sc
->kue_ep
[KUE_ENDPT_RX
] != NULL
) {
1031 err
= usbd_abort_pipe(sc
->kue_ep
[KUE_ENDPT_RX
]);
1033 kprintf("kue%d: abort rx pipe failed: %s\n",
1034 sc
->kue_unit
, usbd_errstr(err
));
1036 err
= usbd_close_pipe(sc
->kue_ep
[KUE_ENDPT_RX
]);
1038 kprintf("kue%d: close rx pipe failed: %s\n",
1039 sc
->kue_unit
, usbd_errstr(err
));
1041 sc
->kue_ep
[KUE_ENDPT_RX
] = NULL
;
1044 if (sc
->kue_ep
[KUE_ENDPT_TX
] != NULL
) {
1045 err
= usbd_abort_pipe(sc
->kue_ep
[KUE_ENDPT_TX
]);
1047 kprintf("kue%d: abort tx pipe failed: %s\n",
1048 sc
->kue_unit
, usbd_errstr(err
));
1050 err
= usbd_close_pipe(sc
->kue_ep
[KUE_ENDPT_TX
]);
1052 kprintf("kue%d: close tx pipe failed: %s\n",
1053 sc
->kue_unit
, usbd_errstr(err
));
1055 sc
->kue_ep
[KUE_ENDPT_TX
] = NULL
;
1058 if (sc
->kue_ep
[KUE_ENDPT_INTR
] != NULL
) {
1059 err
= usbd_abort_pipe(sc
->kue_ep
[KUE_ENDPT_INTR
]);
1061 kprintf("kue%d: abort intr pipe failed: %s\n",
1062 sc
->kue_unit
, usbd_errstr(err
));
1064 err
= usbd_close_pipe(sc
->kue_ep
[KUE_ENDPT_INTR
]);
1066 kprintf("kue%d: close intr pipe failed: %s\n",
1067 sc
->kue_unit
, usbd_errstr(err
));
1069 sc
->kue_ep
[KUE_ENDPT_INTR
] = NULL
;
1072 /* Free RX resources. */
1073 for (i
= 0; i
< KUE_RX_LIST_CNT
; i
++) {
1074 if (sc
->kue_cdata
.kue_rx_chain
[i
].kue_buf
!= NULL
) {
1075 kfree(sc
->kue_cdata
.kue_rx_chain
[i
].kue_buf
, M_USBDEV
);
1076 sc
->kue_cdata
.kue_rx_chain
[i
].kue_buf
= NULL
;
1078 if (sc
->kue_cdata
.kue_rx_chain
[i
].kue_mbuf
!= NULL
) {
1079 m_freem(sc
->kue_cdata
.kue_rx_chain
[i
].kue_mbuf
);
1080 sc
->kue_cdata
.kue_rx_chain
[i
].kue_mbuf
= NULL
;
1082 if (sc
->kue_cdata
.kue_rx_chain
[i
].kue_xfer
!= NULL
) {
1083 usbd_free_xfer(sc
->kue_cdata
.kue_rx_chain
[i
].kue_xfer
);
1084 sc
->kue_cdata
.kue_rx_chain
[i
].kue_xfer
= NULL
;
1088 /* Free TX resources. */
1089 for (i
= 0; i
< KUE_TX_LIST_CNT
; i
++) {
1090 if (sc
->kue_cdata
.kue_tx_chain
[i
].kue_buf
!= NULL
) {
1091 kfree(sc
->kue_cdata
.kue_tx_chain
[i
].kue_buf
, M_USBDEV
);
1092 sc
->kue_cdata
.kue_tx_chain
[i
].kue_buf
= NULL
;
1094 if (sc
->kue_cdata
.kue_tx_chain
[i
].kue_mbuf
!= NULL
) {
1095 m_freem(sc
->kue_cdata
.kue_tx_chain
[i
].kue_mbuf
);
1096 sc
->kue_cdata
.kue_tx_chain
[i
].kue_mbuf
= NULL
;
1098 if (sc
->kue_cdata
.kue_tx_chain
[i
].kue_xfer
!= NULL
) {
1099 usbd_free_xfer(sc
->kue_cdata
.kue_tx_chain
[i
].kue_xfer
);
1100 sc
->kue_cdata
.kue_tx_chain
[i
].kue_xfer
= NULL
;
1104 ifp
->if_flags
&= ~(IFF_RUNNING
| IFF_OACTIVE
);
1111 * Stop all chip I/O so that the kernel's probe routines don't
1112 * get confused by errant DMAs when rebooting.
1115 kue_shutdown(device_t dev
)
1117 struct kue_softc
*sc
;
1119 sc
= device_get_softc(dev
);