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