1 /* $OpenBSD: if_kue.c,v 1.15 2001/12/17 02:18:18 deraadt Exp $ */ 2 /* $NetBSD: if_kue.c,v 1.43 2001/10/08 03:37:53 augustss Exp $ */ 3 /* 4 * Copyright (c) 1997, 1998, 1999, 2000 5 * Bill Paul <wpaul@ee.columbia.edu>. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Bill Paul. 18 * 4. Neither the name of the author nor the names of any co-contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD 26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 32 * THE POSSIBILITY OF SUCH DAMAGE. 33 * 34 * $FreeBSD: src/sys/dev/usb/if_kue.c,v 1.14 2000/01/14 01:36:15 wpaul Exp $ 35 */ 36 37 /* 38 * Kawasaki LSI KL5KUSB101B USB to ethernet adapter driver. 39 * 40 * Written by Bill Paul <wpaul@ee.columbia.edu> 41 * Electrical Engineering Department 42 * Columbia University, New York City 43 */ 44 45 /* 46 * The KLSI USB to ethernet adapter chip contains an USB serial interface, 47 * ethernet MAC and embedded microcontroller (called the QT Engine). 48 * The chip must have firmware loaded into it before it will operate. 49 * Packets are passed between the chip and host via bulk transfers. 50 * There is an interrupt endpoint mentioned in the software spec, however 51 * it's currently unused. This device is 10Mbps half-duplex only, hence 52 * there is no media selection logic. The MAC supports a 128 entry 53 * multicast filter, though the exact size of the filter can depend 54 * on the firmware. Curiously, while the software spec describes various 55 * ethernet statistics counters, my sample adapter and firmware combination 56 * claims not to support any statistics counters at all. 57 * 58 * Note that once we load the firmware in the device, we have to be 59 * careful not to load it again: if you restart your computer but 60 * leave the adapter attached to the USB controller, it may remain 61 * powered on and retain its firmware. In this case, we don't need 62 * to load the firmware a second time. 63 * 64 * Special thanks to Rob Furr for providing an ADS Technologies 65 * adapter for development and testing. No monkeys were harmed during 66 * the development of this driver. 67 */ 68 69 /* 70 * Ported to NetBSD and somewhat rewritten by Lennart Augustsson. 71 */ 72 73 #if defined(__NetBSD__) 74 #include "opt_inet.h" 75 #include "opt_ns.h" 76 #include "bpfilter.h" 77 #include "rnd.h" 78 #elif defined(__OpenBSD__) 79 #include "bpfilter.h" 80 #endif 81 82 #include <sys/param.h> 83 #include <sys/systm.h> 84 #include <sys/sockio.h> 85 #include <sys/mbuf.h> 86 #include <sys/malloc.h> 87 #include <sys/kernel.h> 88 #include <sys/socket.h> 89 #include <sys/device.h> 90 #include <sys/proc.h> 91 92 #include <sys/device.h> 93 #if NRND > 0 94 #include <sys/rnd.h> 95 #endif 96 97 #include <net/if.h> 98 #if defined(__NetBSD__) 99 #include <net/if_arp.h> 100 #endif 101 #include <net/if_dl.h> 102 103 #define BPF_MTAP(ifp, m) bpf_mtap((ifp)->if_bpf, (m)) 104 105 #if NBPFILTER > 0 106 #include <net/bpf.h> 107 #endif 108 109 #if defined(__NetBSD__) 110 #include <net/if_ether.h> 111 #ifdef INET 112 #include <netinet/in.h> 113 #include <netinet/if_inarp.h> 114 #endif 115 #endif /* defined (__NetBSD__) */ 116 117 #if defined(__OpenBSD__) 118 #ifdef INET 119 #include <netinet/in.h> 120 #include <netinet/in_systm.h> 121 #include <netinet/in_var.h> 122 #include <netinet/ip.h> 123 #include <netinet/if_ether.h> 124 #endif 125 #endif /* defined (__OpenBSD__) */ 126 127 #ifdef NS 128 #include <netns/ns.h> 129 #include <netns/ns_if.h> 130 #endif 131 132 #include <dev/usb/usb.h> 133 #include <dev/usb/usbdi.h> 134 #include <dev/usb/usbdi_util.h> 135 #include <dev/usb/usbdevs.h> 136 137 #include <dev/usb/if_kuereg.h> 138 #include <dev/microcode/kue/kue_fw.h> 139 140 #ifdef KUE_DEBUG 141 #define DPRINTF(x) if (kuedebug) logprintf x 142 #define DPRINTFN(n,x) if (kuedebug >= (n)) logprintf x 143 int kuedebug = 0; 144 #else 145 #define DPRINTF(x) 146 #define DPRINTFN(n,x) 147 #endif 148 149 /* 150 * Various supported device vendors/products. 151 */ 152 Static const struct kue_type kue_devs[] = { 153 { USB_VENDOR_3COM, USB_PRODUCT_3COM_3C19250 }, 154 { USB_VENDOR_3COM, USB_PRODUCT_3COM_3C460 }, 155 { USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_URE450 }, 156 { USB_VENDOR_ADS, USB_PRODUCT_ADS_UBS10BT }, 157 { USB_VENDOR_ADS, USB_PRODUCT_ADS_UBS10BTX }, 158 { USB_VENDOR_AOX, USB_PRODUCT_AOX_USB101 }, 159 { USB_VENDOR_ASANTE, USB_PRODUCT_ASANTE_EA }, 160 { USB_VENDOR_ATEN, USB_PRODUCT_ATEN_UC10T }, 161 { USB_VENDOR_ATEN, USB_PRODUCT_ATEN_DSB650C }, 162 { USB_VENDOR_COREGA, USB_PRODUCT_COREGA_ETHER_USB_T }, 163 { USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650C }, 164 { USB_VENDOR_ENTREGA, USB_PRODUCT_ENTREGA_E45 }, 165 { USB_VENDOR_ENTREGA, USB_PRODUCT_ENTREGA_XX1 }, 166 { USB_VENDOR_ENTREGA, USB_PRODUCT_ENTREGA_XX2 }, 167 { USB_VENDOR_IODATA, USB_PRODUCT_IODATA_USBETT }, 168 { USB_VENDOR_JATON, USB_PRODUCT_JATON_EDA }, 169 { USB_VENDOR_KINGSTON, USB_PRODUCT_KINGSTON_XX1 }, 170 { USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BT }, 171 { USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BTN }, 172 { USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_USB10T }, 173 { USB_VENDOR_MOBILITY, USB_PRODUCT_MOBILITY_EA }, 174 { USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_EA101 }, 175 { USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_EA101X }, 176 { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET }, 177 { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET2 }, 178 { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET3 }, 179 { USB_VENDOR_PORTGEAR, USB_PRODUCT_PORTGEAR_EA8 }, 180 { USB_VENDOR_PORTGEAR, USB_PRODUCT_PORTGEAR_EA9 }, 181 { USB_VENDOR_PORTSMITH, USB_PRODUCT_PORTSMITH_EEA }, 182 { USB_VENDOR_SHARK, USB_PRODUCT_SHARK_PA }, 183 { USB_VENDOR_SMC, USB_PRODUCT_SMC_2102USB }, 184 { 0, 0 } 185 }; 186 187 USB_DECLARE_DRIVER(kue); 188 189 Static int kue_tx_list_init(struct kue_softc *); 190 Static int kue_rx_list_init(struct kue_softc *); 191 Static int kue_newbuf(struct kue_softc *, struct kue_chain *,struct mbuf *); 192 Static int kue_send(struct kue_softc *, struct mbuf *, int); 193 Static int kue_open_pipes(struct kue_softc *); 194 Static void kue_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status); 195 Static void kue_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status); 196 Static void kue_start(struct ifnet *); 197 Static int kue_ioctl(struct ifnet *, u_long, caddr_t); 198 Static void kue_init(void *); 199 Static void kue_stop(struct kue_softc *); 200 Static void kue_watchdog(struct ifnet *); 201 202 Static void kue_setmulti(struct kue_softc *); 203 Static void kue_reset(struct kue_softc *); 204 205 Static usbd_status kue_ctl(struct kue_softc *, int, u_int8_t, 206 u_int16_t, void *, u_int32_t); 207 Static usbd_status kue_setword(struct kue_softc *, u_int8_t, u_int16_t); 208 Static int kue_load_fw(struct kue_softc *); 209 210 Static usbd_status 211 kue_setword(struct kue_softc *sc, u_int8_t breq, u_int16_t word) 212 { 213 usb_device_request_t req; 214 215 DPRINTFN(10,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 216 217 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 218 req.bRequest = breq; 219 USETW(req.wValue, word); 220 USETW(req.wIndex, 0); 221 USETW(req.wLength, 0); 222 223 return (usbd_do_request(sc->kue_udev, &req, NULL)); 224 } 225 226 Static usbd_status 227 kue_ctl(struct kue_softc *sc, int rw, u_int8_t breq, u_int16_t val, 228 void *data, u_int32_t len) 229 { 230 usb_device_request_t req; 231 232 DPRINTFN(10,("%s: %s: enter, len=%d\n", USBDEVNAME(sc->kue_dev), 233 __FUNCTION__, len)); 234 235 if (rw == KUE_CTL_WRITE) 236 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 237 else 238 req.bmRequestType = UT_READ_VENDOR_DEVICE; 239 240 req.bRequest = breq; 241 USETW(req.wValue, val); 242 USETW(req.wIndex, 0); 243 USETW(req.wLength, len); 244 245 return (usbd_do_request(sc->kue_udev, &req, data)); 246 } 247 248 Static int 249 kue_load_fw(struct kue_softc *sc) 250 { 251 usb_device_descriptor_t dd; 252 usbd_status err; 253 254 DPRINTFN(1,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 255 256 /* 257 * First, check if we even need to load the firmware. 258 * If the device was still attached when the system was 259 * rebooted, it may already have firmware loaded in it. 260 * If this is the case, we don't need to do it again. 261 * And in fact, if we try to load it again, we'll hang, 262 * so we have to avoid this condition if we don't want 263 * to look stupid. 264 * 265 * We can test this quickly by checking the bcdRevision 266 * code. The NIC will return a different revision code if 267 * it's probed while the firmware is still loaded and 268 * running. 269 */ 270 if (usbd_get_device_desc(sc->kue_udev, &dd)) 271 return (EIO); 272 if (UGETW(dd.bcdDevice) == KUE_WARM_REV) { 273 printf("%s: warm boot, no firmware download\n", 274 USBDEVNAME(sc->kue_dev)); 275 return (0); 276 } 277 278 printf("%s: cold boot, downloading firmware\n", 279 USBDEVNAME(sc->kue_dev)); 280 281 /* Load code segment */ 282 DPRINTFN(1,("%s: kue_load_fw: download code_seg\n", 283 USBDEVNAME(sc->kue_dev))); 284 err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN, 285 0, (void *)kue_code_seg, sizeof(kue_code_seg)); 286 if (err) { 287 printf("%s: failed to load code segment: %s\n", 288 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 289 return (EIO); 290 } 291 292 /* Load fixup segment */ 293 DPRINTFN(1,("%s: kue_load_fw: download fix_seg\n", 294 USBDEVNAME(sc->kue_dev))); 295 err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN, 296 0, (void *)kue_fix_seg, sizeof(kue_fix_seg)); 297 if (err) { 298 printf("%s: failed to load fixup segment: %s\n", 299 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 300 return (EIO); 301 } 302 303 /* Send trigger command. */ 304 DPRINTFN(1,("%s: kue_load_fw: download trig_seg\n", 305 USBDEVNAME(sc->kue_dev))); 306 err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN, 307 0, (void *)kue_trig_seg, sizeof(kue_trig_seg)); 308 if (err) { 309 printf("%s: failed to load trigger segment: %s\n", 310 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 311 return (EIO); 312 } 313 314 usbd_delay_ms(sc->kue_udev, 10); 315 316 /* 317 * Reload device descriptor. 318 * Why? The chip without the firmware loaded returns 319 * one revision code. The chip with the firmware 320 * loaded and running returns a *different* revision 321 * code. This confuses the quirk mechanism, which is 322 * dependent on the revision data. 323 */ 324 (void)usbd_reload_device_desc(sc->kue_udev); 325 326 DPRINTFN(1,("%s: %s: done\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 327 328 /* Reset the adapter. */ 329 kue_reset(sc); 330 331 return (0); 332 } 333 334 Static void 335 kue_setmulti(struct kue_softc *sc) 336 { 337 struct ifnet *ifp = GET_IFP(sc); 338 struct ether_multi *enm; 339 struct ether_multistep step; 340 int i; 341 342 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 343 344 if (ifp->if_flags & IFF_PROMISC) { 345 allmulti: 346 ifp->if_flags |= IFF_ALLMULTI; 347 sc->kue_rxfilt |= KUE_RXFILT_ALLMULTI; 348 sc->kue_rxfilt &= ~KUE_RXFILT_MULTICAST; 349 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt); 350 return; 351 } 352 353 sc->kue_rxfilt &= ~KUE_RXFILT_ALLMULTI; 354 355 i = 0; 356 #if defined (__NetBSD__) 357 ETHER_FIRST_MULTI(step, &sc->kue_ec, enm); 358 #else 359 ETHER_FIRST_MULTI(step, &sc->arpcom, enm); 360 #endif 361 while (enm != NULL) { 362 if (i == KUE_MCFILTCNT(sc) || 363 memcmp(enm->enm_addrlo, enm->enm_addrhi, 364 ETHER_ADDR_LEN) != 0) 365 goto allmulti; 366 367 memcpy(KUE_MCFILT(sc, i), enm->enm_addrlo, ETHER_ADDR_LEN); 368 ETHER_NEXT_MULTI(step, enm); 369 i++; 370 } 371 372 ifp->if_flags &= ~IFF_ALLMULTI; 373 374 sc->kue_rxfilt |= KUE_RXFILT_MULTICAST; 375 kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MCAST_FILTERS, 376 i, sc->kue_mcfilters, i * ETHER_ADDR_LEN); 377 378 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt); 379 } 380 381 /* 382 * Issue a SET_CONFIGURATION command to reset the MAC. This should be 383 * done after the firmware is loaded into the adapter in order to 384 * bring it into proper operation. 385 */ 386 Static void 387 kue_reset(struct kue_softc *sc) 388 { 389 usbd_status err; 390 391 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 392 393 err = usbd_set_config_no(sc->kue_udev, KUE_CONFIG_NO, 1); 394 if (err) 395 printf("%s: reset failed\n", USBDEVNAME(sc->kue_dev)); 396 397 /* Wait a little while for the chip to get its brains in order. */ 398 usbd_delay_ms(sc->kue_udev, 10); 399 } 400 401 /* 402 * Probe for a KLSI chip. 403 */ 404 USB_MATCH(kue) 405 { 406 USB_MATCH_START(kue, uaa); 407 const struct kue_type *t; 408 409 DPRINTFN(25,("kue_match: enter\n")); 410 411 if (uaa->iface != NULL) 412 return (UMATCH_NONE); 413 414 for (t = kue_devs; t->kue_vid != 0; t++) 415 if (uaa->vendor == t->kue_vid && uaa->product == t->kue_did) 416 return (UMATCH_VENDOR_PRODUCT); 417 418 return (UMATCH_NONE); 419 } 420 421 /* 422 * Attach the interface. Allocate softc structures, do 423 * setup and ethernet/BPF attach. 424 */ 425 USB_ATTACH(kue) 426 { 427 USB_ATTACH_START(kue, sc, uaa); 428 char devinfo[1024]; 429 int s; 430 struct ifnet *ifp; 431 usbd_device_handle dev = uaa->device; 432 usbd_interface_handle iface; 433 usbd_status err; 434 usb_interface_descriptor_t *id; 435 usb_endpoint_descriptor_t *ed; 436 int i; 437 438 DPRINTFN(5,(" : kue_attach: sc=%p, dev=%p", sc, dev)); 439 440 usbd_devinfo(dev, 0, devinfo); 441 USB_ATTACH_SETUP; 442 printf("%s: %s\n", USBDEVNAME(sc->kue_dev), devinfo); 443 444 err = usbd_set_config_no(dev, KUE_CONFIG_NO, 1); 445 if (err) { 446 printf("%s: setting config no failed\n", 447 USBDEVNAME(sc->kue_dev)); 448 USB_ATTACH_ERROR_RETURN; 449 } 450 451 sc->kue_udev = dev; 452 sc->kue_product = uaa->product; 453 sc->kue_vendor = uaa->vendor; 454 455 /* Load the firmware into the NIC. */ 456 if (kue_load_fw(sc)) { 457 printf("%s: loading firmware failed\n", 458 USBDEVNAME(sc->kue_dev)); 459 USB_ATTACH_ERROR_RETURN; 460 } 461 462 err = usbd_device2interface_handle(dev, KUE_IFACE_IDX, &iface); 463 if (err) { 464 printf("%s: getting interface handle failed\n", 465 USBDEVNAME(sc->kue_dev)); 466 USB_ATTACH_ERROR_RETURN; 467 } 468 469 sc->kue_iface = iface; 470 id = usbd_get_interface_descriptor(iface); 471 472 /* Find endpoints. */ 473 for (i = 0; i < id->bNumEndpoints; i++) { 474 ed = usbd_interface2endpoint_descriptor(iface, i); 475 if (ed == NULL) { 476 printf("%s: couldn't get ep %d\n", 477 USBDEVNAME(sc->kue_dev), i); 478 USB_ATTACH_ERROR_RETURN; 479 } 480 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 481 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 482 sc->kue_ed[KUE_ENDPT_RX] = ed->bEndpointAddress; 483 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 484 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 485 sc->kue_ed[KUE_ENDPT_TX] = ed->bEndpointAddress; 486 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 487 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) { 488 sc->kue_ed[KUE_ENDPT_INTR] = ed->bEndpointAddress; 489 } 490 } 491 492 if (sc->kue_ed[KUE_ENDPT_RX] == 0 || sc->kue_ed[KUE_ENDPT_TX] == 0) { 493 printf("%s: missing endpoint\n", USBDEVNAME(sc->kue_dev)); 494 USB_ATTACH_ERROR_RETURN; 495 } 496 497 /* Read ethernet descriptor */ 498 err = kue_ctl(sc, KUE_CTL_READ, KUE_CMD_GET_ETHER_DESCRIPTOR, 499 0, &sc->kue_desc, sizeof(sc->kue_desc)); 500 if (err) { 501 printf("%s: could not read Ethernet descriptor\n", 502 USBDEVNAME(sc->kue_dev)); 503 USB_ATTACH_ERROR_RETURN; 504 } 505 506 sc->kue_mcfilters = malloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN, 507 M_USBDEV, M_NOWAIT); 508 if (sc->kue_mcfilters == NULL) { 509 printf("%s: no memory for multicast filter buffer\n", 510 USBDEVNAME(sc->kue_dev)); 511 USB_ATTACH_ERROR_RETURN; 512 } 513 514 s = splnet(); 515 516 /* 517 * A KLSI chip was detected. Inform the world. 518 */ 519 printf("%s: Ethernet address %s\n", USBDEVNAME(sc->kue_dev), 520 ether_sprintf(sc->kue_desc.kue_macaddr)); 521 522 #if defined(__OpenBSD__) 523 bcopy(sc->kue_desc.kue_macaddr, 524 (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN); 525 #endif 526 527 /* Initialize interface info.*/ 528 ifp = GET_IFP(sc); 529 ifp->if_softc = sc; 530 ifp->if_mtu = ETHERMTU; 531 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 532 ifp->if_ioctl = kue_ioctl; 533 ifp->if_start = kue_start; 534 ifp->if_watchdog = kue_watchdog; 535 strncpy(ifp->if_xname, USBDEVNAME(sc->kue_dev), IFNAMSIZ); 536 537 IFQ_SET_READY(&ifp->if_snd); 538 539 /* Attach the interface. */ 540 if_attach(ifp); 541 Ether_ifattach(ifp, sc->kue_desc.kue_macaddr); 542 #if NRND > 0 543 rnd_attach_source(&sc->rnd_source, USBDEVNAME(sc->kue_dev), 544 RND_TYPE_NET, 0); 545 #endif 546 547 sc->kue_attached = 1; 548 splx(s); 549 550 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->kue_udev, 551 USBDEV(sc->kue_dev)); 552 553 USB_ATTACH_SUCCESS_RETURN; 554 } 555 556 USB_DETACH(kue) 557 { 558 USB_DETACH_START(kue, sc); 559 struct ifnet *ifp = GET_IFP(sc); 560 int s; 561 562 s = splusb(); /* XXX why? */ 563 564 if (sc->kue_mcfilters != NULL) { 565 free(sc->kue_mcfilters, M_USBDEV); 566 sc->kue_mcfilters = NULL; 567 } 568 569 if (!sc->kue_attached) { 570 /* Detached before attached finished, so just bail out. */ 571 splx(s); 572 return (0); 573 } 574 575 if (ifp->if_flags & IFF_RUNNING) 576 kue_stop(sc); 577 578 #if defined(__NetBSD__) 579 #if NRND > 0 580 rnd_detach_source(&sc->rnd_source); 581 #endif 582 #if NBPFILTER > 0 583 bpfdetach(ifp); 584 #endif 585 #endif /* __NetBSD__ */ 586 ether_ifdetach(ifp); 587 588 if_detach(ifp); 589 590 #ifdef DIAGNOSTIC 591 if (sc->kue_ep[KUE_ENDPT_TX] != NULL || 592 sc->kue_ep[KUE_ENDPT_RX] != NULL || 593 sc->kue_ep[KUE_ENDPT_INTR] != NULL) 594 printf("%s: detach has active endpoints\n", 595 USBDEVNAME(sc->kue_dev)); 596 #endif 597 598 sc->kue_attached = 0; 599 splx(s); 600 601 return (0); 602 } 603 604 int 605 kue_activate(device_ptr_t self, enum devact act) 606 { 607 struct kue_softc *sc = (struct kue_softc *)self; 608 609 DPRINTFN(2,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 610 611 switch (act) { 612 case DVACT_ACTIVATE: 613 return (EOPNOTSUPP); 614 break; 615 616 case DVACT_DEACTIVATE: 617 #if defined(__NetBSD__) 618 /* Deactivate the interface. */ 619 if_deactivate(&sc->kue_ec.ec_if); 620 #endif 621 sc->kue_dying = 1; 622 break; 623 } 624 return (0); 625 } 626 627 /* 628 * Initialize an RX descriptor and attach an MBUF cluster. 629 */ 630 Static int 631 kue_newbuf(struct kue_softc *sc, struct kue_chain *c, struct mbuf *m) 632 { 633 struct mbuf *m_new = NULL; 634 635 DPRINTFN(10,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 636 637 if (m == NULL) { 638 MGETHDR(m_new, M_DONTWAIT, MT_DATA); 639 if (m_new == NULL) { 640 printf("%s: no memory for rx list " 641 "-- packet dropped!\n", USBDEVNAME(sc->kue_dev)); 642 return (ENOBUFS); 643 } 644 645 MCLGET(m_new, M_DONTWAIT); 646 if (!(m_new->m_flags & M_EXT)) { 647 printf("%s: no memory for rx list " 648 "-- packet dropped!\n", USBDEVNAME(sc->kue_dev)); 649 m_freem(m_new); 650 return (ENOBUFS); 651 } 652 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES; 653 } else { 654 m_new = m; 655 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES; 656 m_new->m_data = m_new->m_ext.ext_buf; 657 } 658 659 c->kue_mbuf = m_new; 660 661 return (0); 662 } 663 664 Static int 665 kue_rx_list_init(struct kue_softc *sc) 666 { 667 struct kue_cdata *cd; 668 struct kue_chain *c; 669 int i; 670 671 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 672 673 cd = &sc->kue_cdata; 674 for (i = 0; i < KUE_RX_LIST_CNT; i++) { 675 c = &cd->kue_rx_chain[i]; 676 c->kue_sc = sc; 677 c->kue_idx = i; 678 if (kue_newbuf(sc, c, NULL) == ENOBUFS) 679 return (ENOBUFS); 680 if (c->kue_xfer == NULL) { 681 c->kue_xfer = usbd_alloc_xfer(sc->kue_udev); 682 if (c->kue_xfer == NULL) 683 return (ENOBUFS); 684 c->kue_buf = usbd_alloc_buffer(c->kue_xfer, KUE_BUFSZ); 685 if (c->kue_buf == NULL) 686 return (ENOBUFS); /* XXX free xfer */ 687 } 688 } 689 690 return (0); 691 } 692 693 Static int 694 kue_tx_list_init(struct kue_softc *sc) 695 { 696 struct kue_cdata *cd; 697 struct kue_chain *c; 698 int i; 699 700 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 701 702 cd = &sc->kue_cdata; 703 for (i = 0; i < KUE_TX_LIST_CNT; i++) { 704 c = &cd->kue_tx_chain[i]; 705 c->kue_sc = sc; 706 c->kue_idx = i; 707 c->kue_mbuf = NULL; 708 if (c->kue_xfer == NULL) { 709 c->kue_xfer = usbd_alloc_xfer(sc->kue_udev); 710 if (c->kue_xfer == NULL) 711 return (ENOBUFS); 712 c->kue_buf = usbd_alloc_buffer(c->kue_xfer, KUE_BUFSZ); 713 if (c->kue_buf == NULL) 714 return (ENOBUFS); 715 } 716 } 717 718 return (0); 719 } 720 721 /* 722 * A frame has been uploaded: pass the resulting mbuf chain up to 723 * the higher level protocols. 724 */ 725 Static void 726 kue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 727 { 728 struct kue_chain *c = priv; 729 struct kue_softc *sc = c->kue_sc; 730 struct ifnet *ifp = GET_IFP(sc); 731 struct mbuf *m; 732 int total_len = 0; 733 int s; 734 735 DPRINTFN(10,("%s: %s: enter status=%d\n", USBDEVNAME(sc->kue_dev), 736 __FUNCTION__, status)); 737 738 if (sc->kue_dying) 739 return; 740 741 if (!(ifp->if_flags & IFF_RUNNING)) 742 return; 743 744 if (status != USBD_NORMAL_COMPLETION) { 745 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) 746 return; 747 sc->kue_rx_errs++; 748 if (usbd_ratecheck(&sc->kue_rx_notice)) { 749 printf("%s: %u usb errors on rx: %s\n", 750 USBDEVNAME(sc->kue_dev), sc->kue_rx_errs, 751 usbd_errstr(status)); 752 sc->kue_rx_errs = 0; 753 } 754 if (status == USBD_STALLED) 755 usbd_clear_endpoint_stall(sc->kue_ep[KUE_ENDPT_RX]); 756 goto done; 757 } 758 759 usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL); 760 761 DPRINTFN(10,("%s: %s: total_len=%d len=%d\n", USBDEVNAME(sc->kue_dev), 762 __FUNCTION__, total_len, 763 UGETW(mtod(c->kue_mbuf, u_int8_t *)))); 764 765 if (total_len <= 1) 766 goto done; 767 768 m = c->kue_mbuf; 769 /* copy data to mbuf */ 770 memcpy(mtod(m, char*), c->kue_buf, total_len); 771 772 /* No errors; receive the packet. */ 773 total_len = UGETW(mtod(m, u_int8_t *)); 774 m_adj(m, sizeof(u_int16_t)); 775 776 if (total_len < sizeof(struct ether_header)) { 777 ifp->if_ierrors++; 778 goto done; 779 } 780 781 ifp->if_ipackets++; 782 m->m_pkthdr.len = m->m_len = total_len; 783 784 m->m_pkthdr.rcvif = ifp; 785 786 s = splnet(); 787 788 /* XXX ugly */ 789 if (kue_newbuf(sc, c, NULL) == ENOBUFS) { 790 ifp->if_ierrors++; 791 goto done1; 792 } 793 794 #if NBPFILTER > 0 795 /* 796 * Handle BPF listeners. Let the BPF user see the packet, but 797 * don't pass it up to the ether_input() layer unless it's 798 * a broadcast packet, multicast packet, matches our ethernet 799 * address or the interface is in promiscuous mode. 800 */ 801 if (ifp->if_bpf) 802 BPF_MTAP(ifp, m); 803 #endif 804 805 DPRINTFN(10,("%s: %s: deliver %d\n", USBDEVNAME(sc->kue_dev), 806 __FUNCTION__, m->m_len)); 807 IF_INPUT(ifp, m); 808 done1: 809 splx(s); 810 811 done: 812 813 /* Setup new transfer. */ 814 usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX], 815 c, c->kue_buf, KUE_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY, 816 USBD_NO_TIMEOUT, kue_rxeof); 817 usbd_transfer(c->kue_xfer); 818 819 DPRINTFN(10,("%s: %s: start rx\n", USBDEVNAME(sc->kue_dev), 820 __FUNCTION__)); 821 } 822 823 /* 824 * A frame was downloaded to the chip. It's safe for us to clean up 825 * the list buffers. 826 */ 827 828 Static void 829 kue_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 830 { 831 struct kue_chain *c = priv; 832 struct kue_softc *sc = c->kue_sc; 833 struct ifnet *ifp = GET_IFP(sc); 834 int s; 835 836 if (sc->kue_dying) 837 return; 838 839 s = splnet(); 840 841 DPRINTFN(10,("%s: %s: enter status=%d\n", USBDEVNAME(sc->kue_dev), 842 __FUNCTION__, status)); 843 844 ifp->if_timer = 0; 845 ifp->if_flags &= ~IFF_OACTIVE; 846 847 if (status != USBD_NORMAL_COMPLETION) { 848 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) { 849 splx(s); 850 return; 851 } 852 ifp->if_oerrors++; 853 printf("%s: usb error on tx: %s\n", USBDEVNAME(sc->kue_dev), 854 usbd_errstr(status)); 855 if (status == USBD_STALLED) 856 usbd_clear_endpoint_stall(sc->kue_ep[KUE_ENDPT_TX]); 857 splx(s); 858 return; 859 } 860 861 ifp->if_opackets++; 862 863 m_freem(c->kue_mbuf); 864 c->kue_mbuf = NULL; 865 866 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0) 867 kue_start(ifp); 868 869 splx(s); 870 } 871 872 Static int 873 kue_send(struct kue_softc *sc, struct mbuf *m, int idx) 874 { 875 int total_len; 876 struct kue_chain *c; 877 usbd_status err; 878 879 DPRINTFN(10,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 880 881 c = &sc->kue_cdata.kue_tx_chain[idx]; 882 883 /* 884 * Copy the mbuf data into a contiguous buffer, leaving two 885 * bytes at the beginning to hold the frame length. 886 */ 887 m_copydata(m, 0, m->m_pkthdr.len, c->kue_buf + 2); 888 c->kue_mbuf = m; 889 890 total_len = m->m_pkthdr.len + 2; 891 /* XXX what's this? */ 892 total_len += 64 - (total_len % 64); 893 894 /* Frame length is specified in the first 2 bytes of the buffer. */ 895 c->kue_buf[0] = (u_int8_t)m->m_pkthdr.len; 896 c->kue_buf[1] = (u_int8_t)(m->m_pkthdr.len >> 8); 897 898 usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_TX], 899 c, c->kue_buf, total_len, USBD_NO_COPY, USBD_DEFAULT_TIMEOUT, 900 kue_txeof); 901 902 /* Transmit */ 903 err = usbd_transfer(c->kue_xfer); 904 if (err != USBD_IN_PROGRESS) { 905 printf("%s: kue_send error=%s\n", USBDEVNAME(sc->kue_dev), 906 usbd_errstr(err)); 907 kue_stop(sc); 908 return (EIO); 909 } 910 911 sc->kue_cdata.kue_tx_cnt++; 912 913 return (0); 914 } 915 916 Static void 917 kue_start(struct ifnet *ifp) 918 { 919 struct kue_softc *sc = ifp->if_softc; 920 struct mbuf *m_head = NULL; 921 922 DPRINTFN(10,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 923 924 if (sc->kue_dying) 925 return; 926 927 if (ifp->if_flags & IFF_OACTIVE) 928 return; 929 930 IFQ_POLL(&ifp->if_snd, m_head); 931 if (m_head == NULL) 932 return; 933 934 if (kue_send(sc, m_head, 0)) { 935 ifp->if_flags |= IFF_OACTIVE; 936 return; 937 } 938 939 IFQ_DEQUEUE(&ifp->if_snd, m_head); 940 941 #if NBPFILTER > 0 942 /* 943 * If there's a BPF listener, bounce a copy of this frame 944 * to him. 945 */ 946 if (ifp->if_bpf) 947 BPF_MTAP(ifp, m_head); 948 #endif 949 950 ifp->if_flags |= IFF_OACTIVE; 951 952 /* 953 * Set a timeout in case the chip goes out to lunch. 954 */ 955 ifp->if_timer = 6; 956 } 957 958 Static void 959 kue_init(void *xsc) 960 { 961 struct kue_softc *sc = xsc; 962 struct ifnet *ifp = GET_IFP(sc); 963 int s; 964 u_char *eaddr; 965 966 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 967 968 if (ifp->if_flags & IFF_RUNNING) 969 return; 970 971 s = splnet(); 972 973 #if defined(__NetBSD__) 974 eaddr = LLADDR(ifp->if_sadl); 975 #else 976 eaddr = sc->arpcom.ac_enaddr; 977 #endif /* defined(__NetBSD__) */ 978 /* Set MAC address */ 979 kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MAC, 0, eaddr, ETHER_ADDR_LEN); 980 981 sc->kue_rxfilt = KUE_RXFILT_UNICAST | KUE_RXFILT_BROADCAST; 982 983 /* If we want promiscuous mode, set the allframes bit. */ 984 if (ifp->if_flags & IFF_PROMISC) 985 sc->kue_rxfilt |= KUE_RXFILT_PROMISC; 986 987 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt); 988 989 /* I'm not sure how to tune these. */ 990 #if 0 991 /* 992 * Leave this one alone for now; setting it 993 * wrong causes lockups on some machines/controllers. 994 */ 995 kue_setword(sc, KUE_CMD_SET_SOFS, 1); 996 #endif 997 kue_setword(sc, KUE_CMD_SET_URB_SIZE, 64); 998 999 /* Init TX ring. */ 1000 if (kue_tx_list_init(sc) == ENOBUFS) { 1001 printf("%s: tx list init failed\n", USBDEVNAME(sc->kue_dev)); 1002 splx(s); 1003 return; 1004 } 1005 1006 /* Init RX ring. */ 1007 if (kue_rx_list_init(sc) == ENOBUFS) { 1008 printf("%s: rx list init failed\n", USBDEVNAME(sc->kue_dev)); 1009 splx(s); 1010 return; 1011 } 1012 1013 /* Load the multicast filter. */ 1014 kue_setmulti(sc); 1015 1016 if (sc->kue_ep[KUE_ENDPT_RX] == NULL) { 1017 if (kue_open_pipes(sc)) { 1018 splx(s); 1019 return; 1020 } 1021 } 1022 1023 ifp->if_flags |= IFF_RUNNING; 1024 ifp->if_flags &= ~IFF_OACTIVE; 1025 1026 splx(s); 1027 } 1028 1029 Static int 1030 kue_open_pipes(struct kue_softc *sc) 1031 { 1032 usbd_status err; 1033 struct kue_chain *c; 1034 int i; 1035 1036 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 1037 1038 /* Open RX and TX pipes. */ 1039 err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_RX], 1040 USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_RX]); 1041 if (err) { 1042 printf("%s: open rx pipe failed: %s\n", 1043 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1044 return (EIO); 1045 } 1046 1047 err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_TX], 1048 USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_TX]); 1049 if (err) { 1050 printf("%s: open tx pipe failed: %s\n", 1051 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1052 return (EIO); 1053 } 1054 1055 /* Start up the receive pipe. */ 1056 for (i = 0; i < KUE_RX_LIST_CNT; i++) { 1057 c = &sc->kue_cdata.kue_rx_chain[i]; 1058 usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX], 1059 c, c->kue_buf, KUE_BUFSZ, 1060 USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, 1061 kue_rxeof); 1062 DPRINTFN(5,("%s: %s: start read\n", USBDEVNAME(sc->kue_dev), 1063 __FUNCTION__)); 1064 usbd_transfer(c->kue_xfer); 1065 } 1066 1067 return (0); 1068 } 1069 1070 Static int 1071 kue_ioctl(struct ifnet *ifp, u_long command, caddr_t data) 1072 { 1073 struct kue_softc *sc = ifp->if_softc; 1074 struct ifaddr *ifa = (struct ifaddr *)data; 1075 struct ifreq *ifr = (struct ifreq *)data; 1076 int s, error = 0; 1077 1078 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 1079 1080 if (sc->kue_dying) 1081 return (EIO); 1082 1083 #ifdef DIAGNOSTIC 1084 if (!curproc) { 1085 printf("%s: no proc!!\n", USBDEVNAME(sc->kue_dev)); 1086 return EIO; 1087 } 1088 #endif 1089 1090 s = splnet(); 1091 1092 switch(command) { 1093 case SIOCSIFADDR: 1094 ifp->if_flags |= IFF_UP; 1095 kue_init(sc); 1096 1097 switch (ifa->ifa_addr->sa_family) { 1098 #ifdef INET 1099 case AF_INET: 1100 #if defined(__NetBSD__) 1101 arp_ifinit(ifp, ifa); 1102 #else 1103 arp_ifinit(&sc->arpcom, ifa); 1104 #endif 1105 break; 1106 #endif /* INET */ 1107 #ifdef NS 1108 case AF_NS: 1109 { 1110 struct ns_addr *ina = &IA_SNS(ifa)->sns_addr; 1111 1112 if (ns_nullhost(*ina)) 1113 ina->x_host = *(union ns_host *) 1114 LLADDR(ifp->if_sadl); 1115 else 1116 memcpy(LLADDR(ifp->if_sadl), 1117 ina->x_host.c_host, 1118 ifp->if_addrlen); 1119 break; 1120 } 1121 #endif /* NS */ 1122 } 1123 break; 1124 1125 case SIOCSIFMTU: 1126 if (ifr->ifr_mtu > ETHERMTU) 1127 error = EINVAL; 1128 else 1129 ifp->if_mtu = ifr->ifr_mtu; 1130 break; 1131 1132 case SIOCSIFFLAGS: 1133 if (ifp->if_flags & IFF_UP) { 1134 if (ifp->if_flags & IFF_RUNNING && 1135 ifp->if_flags & IFF_PROMISC && 1136 !(sc->kue_if_flags & IFF_PROMISC)) { 1137 sc->kue_rxfilt |= KUE_RXFILT_PROMISC; 1138 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, 1139 sc->kue_rxfilt); 1140 } else if (ifp->if_flags & IFF_RUNNING && 1141 !(ifp->if_flags & IFF_PROMISC) && 1142 sc->kue_if_flags & IFF_PROMISC) { 1143 sc->kue_rxfilt &= ~KUE_RXFILT_PROMISC; 1144 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, 1145 sc->kue_rxfilt); 1146 } else if (!(ifp->if_flags & IFF_RUNNING)) 1147 kue_init(sc); 1148 } else { 1149 if (ifp->if_flags & IFF_RUNNING) 1150 kue_stop(sc); 1151 } 1152 sc->kue_if_flags = ifp->if_flags; 1153 error = 0; 1154 break; 1155 case SIOCADDMULTI: 1156 case SIOCDELMULTI: 1157 kue_setmulti(sc); 1158 error = 0; 1159 break; 1160 default: 1161 error = EINVAL; 1162 break; 1163 } 1164 1165 splx(s); 1166 1167 return (error); 1168 } 1169 1170 Static void 1171 kue_watchdog(struct ifnet *ifp) 1172 { 1173 struct kue_softc *sc = ifp->if_softc; 1174 struct kue_chain *c; 1175 usbd_status stat; 1176 int s; 1177 1178 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 1179 1180 if (sc->kue_dying) 1181 return; 1182 1183 ifp->if_oerrors++; 1184 printf("%s: watchdog timeout\n", USBDEVNAME(sc->kue_dev)); 1185 1186 s = splusb(); 1187 c = &sc->kue_cdata.kue_tx_chain[0]; 1188 usbd_get_xfer_status(c->kue_xfer, NULL, NULL, NULL, &stat); 1189 kue_txeof(c->kue_xfer, c, stat); 1190 1191 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0) 1192 kue_start(ifp); 1193 splx(s); 1194 } 1195 1196 /* 1197 * Stop the adapter and free any mbufs allocated to the 1198 * RX and TX lists. 1199 */ 1200 Static void 1201 kue_stop(struct kue_softc *sc) 1202 { 1203 usbd_status err; 1204 struct ifnet *ifp; 1205 int i; 1206 1207 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 1208 1209 ifp = GET_IFP(sc); 1210 ifp->if_timer = 0; 1211 1212 /* Stop transfers. */ 1213 if (sc->kue_ep[KUE_ENDPT_RX] != NULL) { 1214 err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_RX]); 1215 if (err) { 1216 printf("%s: abort rx pipe failed: %s\n", 1217 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1218 } 1219 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_RX]); 1220 if (err) { 1221 printf("%s: close rx pipe failed: %s\n", 1222 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1223 } 1224 sc->kue_ep[KUE_ENDPT_RX] = NULL; 1225 } 1226 1227 if (sc->kue_ep[KUE_ENDPT_TX] != NULL) { 1228 err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_TX]); 1229 if (err) { 1230 printf("%s: abort tx pipe failed: %s\n", 1231 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1232 } 1233 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_TX]); 1234 if (err) { 1235 printf("%s: close tx pipe failed: %s\n", 1236 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1237 } 1238 sc->kue_ep[KUE_ENDPT_TX] = NULL; 1239 } 1240 1241 if (sc->kue_ep[KUE_ENDPT_INTR] != NULL) { 1242 err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_INTR]); 1243 if (err) { 1244 printf("%s: abort intr pipe failed: %s\n", 1245 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1246 } 1247 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_INTR]); 1248 if (err) { 1249 printf("%s: close intr pipe failed: %s\n", 1250 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1251 } 1252 sc->kue_ep[KUE_ENDPT_INTR] = NULL; 1253 } 1254 1255 /* Free RX resources. */ 1256 for (i = 0; i < KUE_RX_LIST_CNT; i++) { 1257 if (sc->kue_cdata.kue_rx_chain[i].kue_mbuf != NULL) { 1258 m_freem(sc->kue_cdata.kue_rx_chain[i].kue_mbuf); 1259 sc->kue_cdata.kue_rx_chain[i].kue_mbuf = NULL; 1260 } 1261 if (sc->kue_cdata.kue_rx_chain[i].kue_xfer != NULL) { 1262 usbd_free_xfer(sc->kue_cdata.kue_rx_chain[i].kue_xfer); 1263 sc->kue_cdata.kue_rx_chain[i].kue_xfer = NULL; 1264 } 1265 } 1266 1267 /* Free TX resources. */ 1268 for (i = 0; i < KUE_TX_LIST_CNT; i++) { 1269 if (sc->kue_cdata.kue_tx_chain[i].kue_mbuf != NULL) { 1270 m_freem(sc->kue_cdata.kue_tx_chain[i].kue_mbuf); 1271 sc->kue_cdata.kue_tx_chain[i].kue_mbuf = NULL; 1272 } 1273 if (sc->kue_cdata.kue_tx_chain[i].kue_xfer != NULL) { 1274 usbd_free_xfer(sc->kue_cdata.kue_tx_chain[i].kue_xfer); 1275 sc->kue_cdata.kue_tx_chain[i].kue_xfer = NULL; 1276 } 1277 } 1278 1279 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 1280 } 1281