if_kue.c revision 1.36
1 /* $NetBSD: if_kue.c,v 1.36 2001/01/21 02:33:52 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 /* 73 * TODO: 74 * only use kue_do_request for downloading firmware. 75 * more DPRINTF 76 * proper cleanup on errors 77 */ 78 #if defined(__NetBSD__) 79 #include "opt_inet.h" 80 #include "opt_ns.h" 81 #include "bpfilter.h" 82 #include "rnd.h" 83 #elif defined(__OpenBSD__) 84 #include "bpfilter.h" 85 #endif 86 87 #include <sys/param.h> 88 #include <sys/systm.h> 89 #include <sys/sockio.h> 90 #include <sys/mbuf.h> 91 #include <sys/malloc.h> 92 #include <sys/kernel.h> 93 #include <sys/socket.h> 94 95 #if defined(__FreeBSD__) 96 97 #include <net/ethernet.h> 98 #include <machine/clock.h> /* for DELAY */ 99 #include <sys/bus.h> 100 101 #elif defined(__NetBSD__) || defined(__OpenBSD__) 102 103 #include <sys/device.h> 104 #if NRND > 0 105 #include <sys/rnd.h> 106 #endif 107 108 #endif 109 110 #include <net/if.h> 111 #if defined(__NetBSD__) || defined(__FreeBSD__) 112 #include <net/if_arp.h> 113 #endif 114 #include <net/if_dl.h> 115 116 #if defined(__NetBSD__) || defined(__OpenBSD__) 117 #define BPF_MTAP(ifp, m) bpf_mtap((ifp)->if_bpf, (m)) 118 #else 119 #define BPF_MTAP(ifp, m) bpf_mtap((ifp), (m)) 120 #endif 121 122 #if defined(__FreeBSD__) || NBPFILTER > 0 123 #include <net/bpf.h> 124 #endif 125 126 #if defined(__NetBSD__) 127 #include <net/if_ether.h> 128 #ifdef INET 129 #include <netinet/in.h> 130 #include <netinet/if_inarp.h> 131 #endif 132 #endif /* defined (__NetBSD__) */ 133 134 #if defined(__OpenBSD__) 135 #ifdef INET 136 #include <netinet/in.h> 137 #include <netinet/in_systm.h> 138 #include <netinet/in_var.h> 139 #include <netinet/ip.h> 140 #include <netinet/if_ether.h> 141 #endif 142 #endif /* defined (__OpenBSD__) */ 143 144 #if defined(__NetBSD__) || defined(__OpenBSD__) 145 #ifdef NS 146 #include <netns/ns.h> 147 #include <netns/ns_if.h> 148 #endif 149 #endif /* defined(__NetBSD__) || defined(__OpenBSD__) */ 150 151 #include <dev/usb/usb.h> 152 #include <dev/usb/usbdi.h> 153 #include <dev/usb/usbdi_util.h> 154 #include <dev/usb/usbdevs.h> 155 156 #ifdef __FreeBSD__ 157 #include <dev/usb/usb_ethersubr.h> 158 #endif 159 160 #include <dev/usb/if_kuereg.h> 161 #include <dev/usb/kue_fw.h> 162 163 #ifdef KUE_DEBUG 164 #define DPRINTF(x) if (kuedebug) logprintf x 165 #define DPRINTFN(n,x) if (kuedebug >= (n)) logprintf x 166 int kuedebug = 0; 167 #else 168 #define DPRINTF(x) 169 #define DPRINTFN(n,x) 170 #endif 171 172 /* 173 * Various supported device vendors/products. 174 */ 175 Static const struct kue_type kue_devs[] = { 176 { USB_VENDOR_AOX, USB_PRODUCT_AOX_USB101 }, 177 { USB_VENDOR_ADS, USB_PRODUCT_ADS_UBS10BT }, 178 { USB_VENDOR_ATEN, USB_PRODUCT_ATEN_UC10T }, 179 { USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_EA101 }, 180 { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET }, 181 { USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET2 }, 182 { USB_VENDOR_ENTREGA, USB_PRODUCT_ENTREGA_E45 }, 183 { USB_VENDOR_3COM, USB_PRODUCT_3COM_3C19250 }, 184 { USB_VENDOR_3COM, USB_PRODUCT_3COM_3C460 }, 185 { USB_VENDOR_COREGA, USB_PRODUCT_COREGA_ETHER_USB_T }, 186 { USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650C }, 187 { USB_VENDOR_SMC, USB_PRODUCT_SMC_2102USB }, 188 { USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_USB10T }, 189 { USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BT }, 190 { USB_VENDOR_IODATA, USB_PRODUCT_IODATA_USBETT }, 191 { 0, 0 } 192 }; 193 194 USB_DECLARE_DRIVER(kue); 195 196 Static int kue_tx_list_init(struct kue_softc *); 197 Static int kue_rx_list_init(struct kue_softc *); 198 Static int kue_newbuf(struct kue_softc *, struct kue_chain *,struct mbuf *); 199 Static int kue_send(struct kue_softc *, struct mbuf *, int); 200 Static int kue_open_pipes(struct kue_softc *); 201 Static void kue_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status); 202 Static void kue_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status); 203 Static void kue_start(struct ifnet *); 204 Static int kue_ioctl(struct ifnet *, u_long, caddr_t); 205 Static void kue_init(void *); 206 Static void kue_stop(struct kue_softc *); 207 Static void kue_watchdog(struct ifnet *); 208 209 Static void kue_setmulti(struct kue_softc *); 210 Static void kue_reset(struct kue_softc *); 211 212 Static usbd_status kue_ctl(struct kue_softc *, int, u_int8_t, 213 u_int16_t, const void *, u_int32_t); 214 Static usbd_status kue_setword(struct kue_softc *, u_int8_t, u_int16_t); 215 Static int kue_load_fw(struct kue_softc *); 216 217 #if defined(__FreeBSD__) 218 #ifndef lint 219 static const char rcsid[] = 220 "$FreeBSD: src/sys/dev/usb/if_kue.c,v 1.14 2000/01/14 01:36:15 wpaul Exp $"; 221 #endif 222 223 Static void kue_rxstart(struct ifnet *); 224 Static void kue_shutdown(device_t); 225 226 Static struct usb_qdat kue_qdat; 227 228 Static const device_method_t kue_methods[] = { 229 /* Device interface */ 230 DEVMETHOD(device_probe, kue_match), 231 DEVMETHOD(device_attach, kue_attach), 232 DEVMETHOD(device_detach, kue_detach), 233 DEVMETHOD(device_shutdown, kue_shutdown), 234 235 { 0, 0 } 236 }; 237 238 Static driver_t kue_driver = { 239 "kue", 240 kue_methods, 241 sizeof(struct kue_softc) 242 }; 243 244 Static devclass_t kue_devclass; 245 246 DRIVER_MODULE(if_kue, uhub, kue_driver, kue_devclass, usbd_driver_load, 0); 247 248 #endif /* __FreeBSD__ */ 249 250 #define KUE_DO_REQUEST(dev, req, data) \ 251 usbd_do_request_flags(dev, req, data, USBD_NO_TSLEEP, NULL) 252 253 Static usbd_status 254 kue_setword(struct kue_softc *sc, u_int8_t breq, u_int16_t word) 255 { 256 usb_device_request_t req; 257 usbd_status err; 258 int s; 259 260 DPRINTFN(10,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 261 262 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 263 req.bRequest = breq; 264 USETW(req.wValue, word); 265 USETW(req.wIndex, 0); 266 USETW(req.wLength, 0); 267 268 s = splusb(); 269 err = KUE_DO_REQUEST(sc->kue_udev, &req, NULL); 270 splx(s); 271 272 return (err); 273 } 274 275 Static usbd_status 276 kue_ctl(struct kue_softc *sc, int rw, u_int8_t breq, u_int16_t val, 277 const void *data, u_int32_t len) 278 { 279 usb_device_request_t req; 280 usbd_status err; 281 int s; 282 283 DPRINTFN(10,("%s: %s: enter, len=%d\n", USBDEVNAME(sc->kue_dev), 284 __FUNCTION__, len)); 285 286 if (rw == KUE_CTL_WRITE) 287 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 288 else 289 req.bmRequestType = UT_READ_VENDOR_DEVICE; 290 291 req.bRequest = breq; 292 USETW(req.wValue, val); 293 USETW(req.wIndex, 0); 294 USETW(req.wLength, len); 295 296 s = splusb(); 297 err = KUE_DO_REQUEST(sc->kue_udev, &req, (void *)data); 298 splx(s); 299 300 return (err); 301 } 302 303 Static int 304 kue_load_fw(struct kue_softc *sc) 305 { 306 usb_device_descriptor_t dd; 307 usbd_status err; 308 309 DPRINTFN(1,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 310 311 /* 312 * First, check if we even need to load the firmware. 313 * If the device was still attached when the system was 314 * rebooted, it may already have firmware loaded in it. 315 * If this is the case, we don't need to do it again. 316 * And in fact, if we try to load it again, we'll hang, 317 * so we have to avoid this condition if we don't want 318 * to look stupid. 319 * 320 * We can test this quickly by checking the bcdRevision 321 * code. The NIC will return a different revision code if 322 * it's probed while the firmware is still loaded and 323 * running. 324 */ 325 if (usbd_get_device_desc(sc->kue_udev, &dd)) 326 return (EIO); 327 if (UGETW(dd.bcdDevice) == KUE_WARM_REV) { 328 printf("%s: warm boot, no firmware download\n", 329 USBDEVNAME(sc->kue_dev)); 330 return (0); 331 } 332 333 printf("%s: cold boot, downloading firmware\n", 334 USBDEVNAME(sc->kue_dev)); 335 336 /* Load code segment */ 337 DPRINTFN(1,("%s: kue_load_fw: download code_seg\n", 338 USBDEVNAME(sc->kue_dev))); 339 err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN, 340 0, kue_code_seg, sizeof(kue_code_seg)); 341 if (err) { 342 printf("%s: failed to load code segment: %s\n", 343 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 344 return (EIO); 345 } 346 347 /* Load fixup segment */ 348 DPRINTFN(1,("%s: kue_load_fw: download fix_seg\n", 349 USBDEVNAME(sc->kue_dev))); 350 err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN, 351 0, kue_fix_seg, sizeof(kue_fix_seg)); 352 if (err) { 353 printf("%s: failed to load fixup segment: %s\n", 354 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 355 return (EIO); 356 } 357 358 /* Send trigger command. */ 359 DPRINTFN(1,("%s: kue_load_fw: download trig_seg\n", 360 USBDEVNAME(sc->kue_dev))); 361 err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN, 362 0, kue_trig_seg, sizeof(kue_trig_seg)); 363 if (err) { 364 printf("%s: failed to load trigger segment: %s\n", 365 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 366 return (EIO); 367 } 368 369 usbd_delay_ms(sc->kue_udev, 10); 370 371 /* 372 * Reload device descriptor. 373 * Why? The chip without the firmware loaded returns 374 * one revision code. The chip with the firmware 375 * loaded and running returns a *different* revision 376 * code. This confuses the quirk mechanism, which is 377 * dependent on the revision data. 378 */ 379 (void)usbd_reload_device_desc(sc->kue_udev); 380 381 DPRINTFN(1,("%s: %s: done\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 382 383 /* Reset the adapter. */ 384 kue_reset(sc); 385 386 return (0); 387 } 388 389 Static void 390 kue_setmulti(struct kue_softc *sc) 391 { 392 struct ifnet *ifp = GET_IFP(sc); 393 #if defined(__FreeBSD__) 394 struct ifmultiaddr *ifma; 395 #elif defined(__NetBSD__) || defined(__OpenBSD__) 396 struct ether_multi *enm; 397 struct ether_multistep step; 398 #endif 399 int i; 400 401 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 402 403 if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) { 404 sc->kue_rxfilt |= KUE_RXFILT_ALLMULTI; 405 sc->kue_rxfilt &= ~KUE_RXFILT_MULTICAST; 406 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt); 407 return; 408 } 409 410 sc->kue_rxfilt &= ~KUE_RXFILT_ALLMULTI; 411 412 i = 0; 413 #if defined(__FreeBSD__) 414 for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL; 415 ifma = ifma->ifma_link.le_next) { 416 if (ifma->ifma_addr->sa_family != AF_LINK) 417 continue; 418 /* 419 * If there are too many addresses for the 420 * internal filter, switch over to allmulti mode. 421 */ 422 if (i == KUE_MCFILTCNT(sc)) 423 break; 424 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 425 KUE_MCFILT(sc, i), ETHER_ADDR_LEN); 426 i++; 427 } 428 #elif defined(__NetBSD__) || defined(__OpenBSD__) 429 #if defined (__NetBSD__) 430 ETHER_FIRST_MULTI(step, &sc->kue_ec, enm); 431 #else 432 ETHER_FIRST_MULTI(step, &sc->arpcom, enm); 433 #endif 434 while (enm != NULL) { 435 if (i == KUE_MCFILTCNT(sc)) 436 break; 437 #if 0 438 if (memcmp(enm->enm_addrlo, 439 enm->enm_addrhi, ETHER_ADDR_LEN) != 0) { 440 ifp->if_flags |= IFF_ALLMULTI; 441 /* XXX what now? */ 442 return; 443 } 444 #endif 445 memcpy(KUE_MCFILT(sc, i), enm->enm_addrlo, ETHER_ADDR_LEN); 446 ETHER_NEXT_MULTI(step, enm); 447 i++; 448 } 449 #endif 450 451 if (i == KUE_MCFILTCNT(sc)) 452 sc->kue_rxfilt |= KUE_RXFILT_ALLMULTI; 453 else { 454 sc->kue_rxfilt |= KUE_RXFILT_MULTICAST; 455 kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MCAST_FILTERS, 456 i, sc->kue_mcfilters, i * ETHER_ADDR_LEN); 457 } 458 459 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt); 460 } 461 462 /* 463 * Issue a SET_CONFIGURATION command to reset the MAC. This should be 464 * done after the firmware is loaded into the adapter in order to 465 * bring it into proper operation. 466 */ 467 Static void 468 kue_reset(struct kue_softc *sc) 469 { 470 usbd_status err; 471 472 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 473 474 err = usbd_set_config_no(sc->kue_udev, KUE_CONFIG_NO, 1); 475 if (err) 476 printf("%s: reset failed\n", USBDEVNAME(sc->kue_dev)); 477 478 /* Wait a little while for the chip to get its brains in order. */ 479 usbd_delay_ms(sc->kue_udev, 10); 480 } 481 482 /* 483 * Probe for a KLSI chip. 484 */ 485 USB_MATCH(kue) 486 { 487 USB_MATCH_START(kue, uaa); 488 const struct kue_type *t; 489 490 DPRINTFN(25,("kue_match: enter\n")); 491 492 if (uaa->iface != NULL) 493 return (UMATCH_NONE); 494 495 for (t = kue_devs; t->kue_vid != 0; t++) 496 if (uaa->vendor == t->kue_vid && uaa->product == t->kue_did) 497 return (UMATCH_VENDOR_PRODUCT); 498 499 return (UMATCH_NONE); 500 } 501 502 /* 503 * Attach the interface. Allocate softc structures, do 504 * setup and ethernet/BPF attach. 505 */ 506 USB_ATTACH(kue) 507 { 508 USB_ATTACH_START(kue, sc, uaa); 509 char devinfo[1024]; 510 int s; 511 struct ifnet *ifp; 512 usbd_device_handle dev = uaa->device; 513 usbd_interface_handle iface; 514 usbd_status err; 515 usb_interface_descriptor_t *id; 516 usb_endpoint_descriptor_t *ed; 517 int i; 518 519 #ifdef __FreeBSD__ 520 bzero(sc, sizeof(struct kue_softc)); 521 #endif 522 523 DPRINTFN(5,(" : kue_attach: sc=%p, dev=%p", sc, dev)); 524 525 usbd_devinfo(dev, 0, devinfo); 526 USB_ATTACH_SETUP; 527 printf("%s: %s\n", USBDEVNAME(sc->kue_dev), devinfo); 528 529 err = usbd_set_config_no(dev, KUE_CONFIG_NO, 1); 530 if (err) { 531 printf("%s: setting config no failed\n", 532 USBDEVNAME(sc->kue_dev)); 533 USB_ATTACH_ERROR_RETURN; 534 } 535 536 sc->kue_udev = dev; 537 sc->kue_product = uaa->product; 538 sc->kue_vendor = uaa->vendor; 539 540 /* Load the firmware into the NIC. */ 541 if (kue_load_fw(sc)) { 542 printf("%s: loading firmware failed\n", 543 USBDEVNAME(sc->kue_dev)); 544 USB_ATTACH_ERROR_RETURN; 545 } 546 547 err = usbd_device2interface_handle(dev, KUE_IFACE_IDX, &iface); 548 if (err) { 549 printf("%s: getting interface handle failed\n", 550 USBDEVNAME(sc->kue_dev)); 551 USB_ATTACH_ERROR_RETURN; 552 } 553 554 sc->kue_iface = iface; 555 id = usbd_get_interface_descriptor(iface); 556 557 /* Find endpoints. */ 558 for (i = 0; i < id->bNumEndpoints; i++) { 559 ed = usbd_interface2endpoint_descriptor(iface, i); 560 if (ed == NULL) { 561 printf("%s: couldn't get ep %d\n", 562 USBDEVNAME(sc->kue_dev), i); 563 USB_ATTACH_ERROR_RETURN; 564 } 565 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 566 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 567 sc->kue_ed[KUE_ENDPT_RX] = ed->bEndpointAddress; 568 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 569 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 570 sc->kue_ed[KUE_ENDPT_TX] = ed->bEndpointAddress; 571 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 572 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) { 573 sc->kue_ed[KUE_ENDPT_INTR] = ed->bEndpointAddress; 574 } 575 } 576 577 if (sc->kue_ed[KUE_ENDPT_RX] == 0 || sc->kue_ed[KUE_ENDPT_TX] == 0) { 578 printf("%s: missing endpoint\n", USBDEVNAME(sc->kue_dev)); 579 USB_ATTACH_ERROR_RETURN; 580 } 581 582 /* Read ethernet descriptor */ 583 err = kue_ctl(sc, KUE_CTL_READ, KUE_CMD_GET_ETHER_DESCRIPTOR, 584 0, &sc->kue_desc, sizeof(sc->kue_desc)); 585 if (err) { 586 printf("%s: could not read Ethernet descriptor\n", 587 USBDEVNAME(sc->kue_dev)); 588 USB_ATTACH_ERROR_RETURN; 589 } 590 591 sc->kue_mcfilters = malloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN, 592 M_USBDEV, M_NOWAIT); 593 if (sc->kue_mcfilters == NULL) { 594 printf("%s: no memory for multicast filter buffer\n", 595 USBDEVNAME(sc->kue_dev)); 596 USB_ATTACH_ERROR_RETURN; 597 } 598 599 s = splimp(); 600 601 /* 602 * A KLSI chip was detected. Inform the world. 603 */ 604 #if defined(__FreeBSD__) 605 printf("%s: Ethernet address: %6D\n", USBDEVNAME(sc->kue_dev), 606 sc->kue_desc.kue_macaddr, ":"); 607 608 bcopy(sc->kue_desc.kue_macaddr, 609 (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN); 610 611 ifp = GET_IFP(sc); 612 ifp->if_softc = sc; 613 ifp->if_unit = sc->kue_unit; 614 ifp->if_name = "kue"; 615 ifp->if_mtu = ETHERMTU; 616 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 617 ifp->if_ioctl = kue_ioctl; 618 ifp->if_output = ether_output; 619 ifp->if_start = kue_start; 620 ifp->if_watchdog = kue_watchdog; 621 ifp->if_init = kue_init; 622 ifp->if_snd.ifq_maxlen = IFQ_MAXLEN; 623 624 kue_qdat.ifp = ifp; 625 kue_qdat.if_rxstart = kue_rxstart; 626 627 /* 628 * Call MI attach routines. 629 */ 630 if_attach(ifp); 631 ether_ifattach(ifp); 632 bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header)); 633 usb_register_netisr(); 634 635 #elif defined(__NetBSD__) || defined(__OpenBSD__) 636 637 printf("%s: Ethernet address %s\n", USBDEVNAME(sc->kue_dev), 638 ether_sprintf(sc->kue_desc.kue_macaddr)); 639 640 /* Initialize interface info.*/ 641 ifp = GET_IFP(sc); 642 ifp->if_softc = sc; 643 ifp->if_mtu = ETHERMTU; 644 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 645 ifp->if_ioctl = kue_ioctl; 646 ifp->if_start = kue_start; 647 ifp->if_watchdog = kue_watchdog; 648 #if defined(__OpenBSD__) 649 ifp->if_snd.ifq_maxlen = IFQ_MAXLEN; 650 #endif 651 strncpy(ifp->if_xname, USBDEVNAME(sc->kue_dev), IFNAMSIZ); 652 653 IFQ_SET_READY(&ifp->if_snd); 654 655 /* Attach the interface. */ 656 if_attach(ifp); 657 Ether_ifattach(ifp, sc->kue_desc.kue_macaddr); 658 #if NRND > 0 659 rnd_attach_source(&sc->rnd_source, USBDEVNAME(sc->kue_dev), 660 RND_TYPE_NET, 0); 661 #endif 662 663 #endif /* __NetBSD__ */ 664 sc->kue_attached = 1; 665 splx(s); 666 667 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->kue_udev, 668 USBDEV(sc->kue_dev)); 669 670 USB_ATTACH_SUCCESS_RETURN; 671 } 672 673 USB_DETACH(kue) 674 { 675 USB_DETACH_START(kue, sc); 676 struct ifnet *ifp = GET_IFP(sc); 677 int s; 678 679 s = splusb(); /* XXX why? */ 680 681 if (sc->kue_mcfilters != NULL) { 682 free(sc->kue_mcfilters, M_USBDEV); 683 sc->kue_mcfilters = NULL; 684 } 685 686 if (!sc->kue_attached) { 687 /* Detached before attached finished, so just bail out. */ 688 splx(s); 689 return (0); 690 } 691 692 if (ifp->if_flags & IFF_RUNNING) 693 kue_stop(sc); 694 695 #if defined(__NetBSD__) 696 #if NRND > 0 697 rnd_detach_source(&sc->rnd_source); 698 #endif 699 ether_ifdetach(ifp); 700 #endif /* __NetBSD__ */ 701 702 if_detach(ifp); 703 704 #ifdef DIAGNOSTIC 705 if (sc->kue_ep[KUE_ENDPT_TX] != NULL || 706 sc->kue_ep[KUE_ENDPT_RX] != NULL || 707 sc->kue_ep[KUE_ENDPT_INTR] != NULL) 708 printf("%s: detach has active endpoints\n", 709 USBDEVNAME(sc->kue_dev)); 710 #endif 711 712 sc->kue_attached = 0; 713 splx(s); 714 715 return (0); 716 } 717 718 #if defined(__NetBSD__) || defined(__OpenBSD__) 719 int 720 kue_activate(device_ptr_t self, enum devact act) 721 { 722 struct kue_softc *sc = (struct kue_softc *)self; 723 724 DPRINTFN(2,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 725 726 switch (act) { 727 case DVACT_ACTIVATE: 728 return (EOPNOTSUPP); 729 break; 730 731 case DVACT_DEACTIVATE: 732 #if defined(__NetBSD__) 733 /* Deactivate the interface. */ 734 if_deactivate(&sc->kue_ec.ec_if); 735 #endif 736 sc->kue_dying = 1; 737 break; 738 } 739 return (0); 740 } 741 #endif /* defined(__NetBSD__) || defined(__OpenBSD__) */ 742 743 /* 744 * Initialize an RX descriptor and attach an MBUF cluster. 745 */ 746 Static int 747 kue_newbuf(struct kue_softc *sc, struct kue_chain *c, struct mbuf *m) 748 { 749 struct mbuf *m_new = NULL; 750 751 DPRINTFN(10,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 752 753 if (m == NULL) { 754 MGETHDR(m_new, M_DONTWAIT, MT_DATA); 755 if (m_new == NULL) { 756 printf("%s: no memory for rx list " 757 "-- packet dropped!\n", USBDEVNAME(sc->kue_dev)); 758 return (ENOBUFS); 759 } 760 761 MCLGET(m_new, M_DONTWAIT); 762 if (!(m_new->m_flags & M_EXT)) { 763 printf("%s: no memory for rx list " 764 "-- packet dropped!\n", USBDEVNAME(sc->kue_dev)); 765 m_freem(m_new); 766 return (ENOBUFS); 767 } 768 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES; 769 } else { 770 m_new = m; 771 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES; 772 m_new->m_data = m_new->m_ext.ext_buf; 773 } 774 775 c->kue_mbuf = m_new; 776 777 return (0); 778 } 779 780 Static int 781 kue_rx_list_init(struct kue_softc *sc) 782 { 783 struct kue_cdata *cd; 784 struct kue_chain *c; 785 int i; 786 787 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 788 789 cd = &sc->kue_cdata; 790 for (i = 0; i < KUE_RX_LIST_CNT; i++) { 791 c = &cd->kue_rx_chain[i]; 792 c->kue_sc = sc; 793 c->kue_idx = i; 794 if (kue_newbuf(sc, c, NULL) == ENOBUFS) 795 return (ENOBUFS); 796 if (c->kue_xfer == NULL) { 797 c->kue_xfer = usbd_alloc_xfer(sc->kue_udev); 798 if (c->kue_xfer == NULL) 799 return (ENOBUFS); 800 c->kue_buf = usbd_alloc_buffer(c->kue_xfer, KUE_BUFSZ); 801 if (c->kue_buf == NULL) 802 return (ENOBUFS); /* XXX free xfer */ 803 } 804 } 805 806 return (0); 807 } 808 809 Static int 810 kue_tx_list_init(struct kue_softc *sc) 811 { 812 struct kue_cdata *cd; 813 struct kue_chain *c; 814 int i; 815 816 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __FUNCTION__)); 817 818 cd = &sc->kue_cdata; 819 for (i = 0; i < KUE_TX_LIST_CNT; i++) { 820 c = &cd->kue_tx_chain[i]; 821 c->kue_sc = sc; 822 c->kue_idx = i; 823 c->kue_mbuf = NULL; 824 if (c->kue_xfer == NULL) { 825 c->kue_xfer = usbd_alloc_xfer(sc->kue_udev); 826 if (c->kue_xfer == NULL) 827 return (ENOBUFS); 828 c->kue_buf = usbd_alloc_buffer(c->kue_xfer, KUE_BUFSZ); 829 if (c->kue_buf == NULL) 830 return (ENOBUFS); 831 } 832 } 833 834 return (0); 835 } 836 837 #ifdef __FreeBSD__ 838 Static void 839 kue_rxstart(struct ifnet *ifp) 840 { 841 struct kue_softc *sc; 842 struct kue_chain *c; 843 844 sc = ifp->if_softc; 845 c = &sc->kue_cdata.kue_rx_chain[sc->kue_cdata.kue_rx_prod]; 846 847 if (kue_newbuf(sc, c, NULL) == ENOBUFS) { 848 ifp->if_ierrors++; 849 return; 850 } 851 852 /* Setup new transfer. */ 853 usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX], 854 c, c->kue_buf, KUE_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY, 855 USBD_NO_TIMEOUT, kue_rxeof); 856 usbd_transfer(c->kue_xfer); 857 } 858 #endif 859 860 /* 861 * A frame has been uploaded: pass the resulting mbuf chain up to 862 * the higher level protocols. 863 */ 864 Static void 865 kue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 866 { 867 struct kue_chain *c = priv; 868 struct kue_softc *sc = c->kue_sc; 869 struct ifnet *ifp = GET_IFP(sc); 870 struct mbuf *m; 871 int total_len = 0; 872 #if defined(__NetBSD__) || defined(__OpenBSD__) 873 int s; 874 #endif /* defined(__NetBSD__) || defined(__OpenBSD__) */ 875 876 DPRINTFN(10,("%s: %s: enter status=%d\n", USBDEVNAME(sc->kue_dev), 877 __FUNCTION__, status)); 878 879 if (sc->kue_dying) 880 return; 881 882 if (!(ifp->if_flags & IFF_RUNNING)) 883 return; 884 885 if (status != USBD_NORMAL_COMPLETION) { 886 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) 887 return; 888 sc->kue_rx_errs++; 889 if (usbd_ratecheck(&sc->kue_rx_notice)) { 890 printf("%s: %u usb errors on rx: %s\n", 891 USBDEVNAME(sc->kue_dev), sc->kue_rx_errs, 892 usbd_errstr(status)); 893 sc->kue_rx_errs = 0; 894 } 895 if (status == USBD_STALLED) 896 usbd_clear_endpoint_stall(sc->kue_ep[KUE_ENDPT_RX]); 897 goto done; 898 } 899 900 usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL); 901 902 DPRINTFN(10,("%s: %s: total_len=%d len=%d\n", USBDEVNAME(sc->kue_dev), 903 __FUNCTION__, total_len, 904 UGETW(mtod(c->kue_mbuf, u_int8_t *)))); 905 906 if (total_len <= 1) 907 goto done; 908 909 m = c->kue_mbuf; 910 /* copy data to mbuf */ 911 memcpy(mtod(m, char*), c->kue_buf, total_len); 912 913 /* No errors; receive the packet. */ 914 total_len = UGETW(mtod(m, u_int8_t *)); 915 m_adj(m, sizeof(u_int16_t)); 916 917 if (total_len < sizeof(struct ether_header)) { 918 ifp->if_ierrors++; 919 goto done; 920 } 921 922 ifp->if_ipackets++; 923 m->m_pkthdr.len = m->m_len = total_len; 924 925 #if defined(__FreeBSD__) 926 m->m_pkthdr.rcvif = (struct ifnet *)&kue_qdat; 927 /* Put the packet on the special USB input queue. */ 928 usb_ether_input(m); 929 930 return; 931 932 #elif defined(__NetBSD__) || defined(__OpenBSD__) 933 m->m_pkthdr.rcvif = ifp; 934 935 s = splimp(); 936 937 /* XXX ugly */ 938 if (kue_newbuf(sc, c, NULL) == ENOBUFS) { 939 ifp->if_ierrors++; 940 goto done1; 941 } 942 943 #if NBPFILTER > 0 944 /* 945 * Handle BPF listeners. Let the BPF user see the packet, but 946 * don't pass it up to the ether_input() layer unless it's 947 * a broadcast packet, multicast packet, matches our ethernet 948 * address or the interface is in promiscuous mode. 949 */ 950 if (ifp->if_bpf) 951 BPF_MTAP(ifp, m); 952 #endif 953 954 DPRINTFN(10,("%s: %s: deliver %d\n", USBDEVNAME(sc->kue_dev), 955 __FUNCTION__, m->m_len)); 956 IF_INPUT(ifp, m); 957 done1: 958 splx(s); 959 #endif /* defined(__NetBSD__) || defined(__OpenBSD__) */ 960 961 done: 962 963 /* Setup new transfer. */ 964 usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX], 965 c, c->kue_buf, KUE_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY, 966 USBD_NO_TIMEOUT, kue_rxeof); 967 usbd_transfer(c->kue_xfer); 968 969 DPRINTFN(10,("%s: %s: start rx\n", USBDEVNAME(sc->kue_dev), 970 __FUNCTION__)); 971 } 972 973 /* 974 * A frame was downloaded to the chip. It's safe for us to clean up 975 * the list buffers. 976 */ 977 978 Static void 979 kue_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 980 { 981 struct kue_chain *c = priv; 982 struct kue_softc *sc = c->kue_sc; 983 struct ifnet *ifp = GET_IFP(sc); 984 int s; 985 986 if (sc->kue_dying) 987 return; 988 989 s = splimp(); 990 991 DPRINTFN(10,("%s: %s: enter status=%d\n", USBDEVNAME(sc->kue_dev), 992 __FUNCTION__, status)); 993 994 ifp->if_timer = 0; 995 ifp->if_flags &= ~IFF_OACTIVE; 996 997 if (status != USBD_NORMAL_COMPLETION) { 998 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) { 999 splx(s); 1000 return; 1001 } 1002 ifp->if_oerrors++; 1003 printf("%s: usb error on tx: %s\n", USBDEVNAME(sc->kue_dev), 1004 usbd_errstr(status)); 1005 if (status == USBD_STALLED) 1006 usbd_clear_endpoint_stall(sc->kue_ep[KUE_ENDPT_TX]); 1007 splx(s); 1008 return; 1009 } 1010 1011 ifp->if_opackets++; 1012 1013 #if defined(__FreeBSD__) 1014 c->kue_mbuf->m_pkthdr.rcvif = ifp; 1015 usb_tx_done(c->kue_mbuf); 1016 c->kue_mbuf = NULL; 1017 #elif defined(__NetBSD__) || defined(__OpenBSD__) 1018 m_freem(c->kue_mbuf); 1019 c->kue_mbuf = NULL; 1020 1021 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0) 1022 kue_start(ifp); 1023 #endif /* defined(__NetBSD__) || defined(__OpenBSD__) */ 1024 1025 splx(s); 1026 } 1027 1028 Static int 1029 kue_send(struct kue_softc *sc, struct mbuf *m, int idx) 1030 { 1031 int total_len; 1032 struct kue_chain *c; 1033 usbd_status err; 1034 1035 DPRINTFN(10,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 1036 1037 c = &sc->kue_cdata.kue_tx_chain[idx]; 1038 1039 /* 1040 * Copy the mbuf data into a contiguous buffer, leaving two 1041 * bytes at the beginning to hold the frame length. 1042 */ 1043 m_copydata(m, 0, m->m_pkthdr.len, c->kue_buf + 2); 1044 c->kue_mbuf = m; 1045 1046 total_len = m->m_pkthdr.len + 2; 1047 /* XXX what's this? */ 1048 total_len += 64 - (total_len % 64); 1049 1050 /* Frame length is specified in the first 2 bytes of the buffer. */ 1051 c->kue_buf[0] = (u_int8_t)m->m_pkthdr.len; 1052 c->kue_buf[1] = (u_int8_t)(m->m_pkthdr.len >> 8); 1053 1054 usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_TX], 1055 c, c->kue_buf, total_len, USBD_NO_COPY, USBD_DEFAULT_TIMEOUT, kue_txeof); 1056 1057 /* Transmit */ 1058 err = usbd_transfer(c->kue_xfer); 1059 if (err != USBD_IN_PROGRESS) { 1060 printf("%s: kue_send error=%s\n", USBDEVNAME(sc->kue_dev), 1061 usbd_errstr(err)); 1062 kue_stop(sc); 1063 return (EIO); 1064 } 1065 1066 sc->kue_cdata.kue_tx_cnt++; 1067 1068 return (0); 1069 } 1070 1071 Static void 1072 kue_start(struct ifnet *ifp) 1073 { 1074 struct kue_softc *sc = ifp->if_softc; 1075 struct mbuf *m_head = NULL; 1076 1077 DPRINTFN(10,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 1078 1079 if (sc->kue_dying) 1080 return; 1081 1082 if (ifp->if_flags & IFF_OACTIVE) 1083 return; 1084 1085 IFQ_POLL(&ifp->if_snd, m_head); 1086 if (m_head == NULL) 1087 return; 1088 1089 if (kue_send(sc, m_head, 0)) { 1090 ifp->if_flags |= IFF_OACTIVE; 1091 return; 1092 } 1093 1094 IFQ_DEQUEUE(&ifp->if_snd, m_head); 1095 1096 #if NBPFILTER > 0 1097 /* 1098 * If there's a BPF listener, bounce a copy of this frame 1099 * to him. 1100 */ 1101 if (ifp->if_bpf) 1102 BPF_MTAP(ifp, m_head); 1103 #endif 1104 1105 ifp->if_flags |= IFF_OACTIVE; 1106 1107 /* 1108 * Set a timeout in case the chip goes out to lunch. 1109 */ 1110 ifp->if_timer = 5; 1111 } 1112 1113 Static void 1114 kue_init(void *xsc) 1115 { 1116 struct kue_softc *sc = xsc; 1117 struct ifnet *ifp = GET_IFP(sc); 1118 int s; 1119 u_char *eaddr; 1120 1121 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 1122 1123 if (ifp->if_flags & IFF_RUNNING) 1124 return; 1125 1126 s = splimp(); 1127 1128 #if defined(__FreeBSD__) || defined(__OpenBSD__) 1129 eaddr = sc->arpcom.ac_enaddr; 1130 #elif defined(__NetBSD__) 1131 eaddr = LLADDR(ifp->if_sadl); 1132 #endif /* defined(__NetBSD__) */ 1133 /* Set MAC address */ 1134 kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MAC, 0, eaddr, ETHER_ADDR_LEN); 1135 1136 sc->kue_rxfilt = KUE_RXFILT_UNICAST | KUE_RXFILT_BROADCAST; 1137 1138 /* If we want promiscuous mode, set the allframes bit. */ 1139 if (ifp->if_flags & IFF_PROMISC) 1140 sc->kue_rxfilt |= KUE_RXFILT_PROMISC; 1141 1142 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt); 1143 1144 /* I'm not sure how to tune these. */ 1145 #if 0 1146 /* 1147 * Leave this one alone for now; setting it 1148 * wrong causes lockups on some machines/controllers. 1149 */ 1150 kue_setword(sc, KUE_CMD_SET_SOFS, 1); 1151 #endif 1152 kue_setword(sc, KUE_CMD_SET_URB_SIZE, 64); 1153 1154 /* Init TX ring. */ 1155 if (kue_tx_list_init(sc) == ENOBUFS) { 1156 printf("%s: tx list init failed\n", USBDEVNAME(sc->kue_dev)); 1157 splx(s); 1158 return; 1159 } 1160 1161 /* Init RX ring. */ 1162 if (kue_rx_list_init(sc) == ENOBUFS) { 1163 printf("%s: rx list init failed\n", USBDEVNAME(sc->kue_dev)); 1164 splx(s); 1165 return; 1166 } 1167 1168 /* Load the multicast filter. */ 1169 kue_setmulti(sc); 1170 1171 if (sc->kue_ep[KUE_ENDPT_RX] == NULL) { 1172 if (kue_open_pipes(sc)) { 1173 splx(s); 1174 return; 1175 } 1176 } 1177 1178 ifp->if_flags |= IFF_RUNNING; 1179 ifp->if_flags &= ~IFF_OACTIVE; 1180 1181 splx(s); 1182 } 1183 1184 Static int 1185 kue_open_pipes(struct kue_softc *sc) 1186 { 1187 usbd_status err; 1188 struct kue_chain *c; 1189 int i; 1190 1191 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 1192 1193 /* Open RX and TX pipes. */ 1194 err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_RX], 1195 USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_RX]); 1196 if (err) { 1197 printf("%s: open rx pipe failed: %s\n", 1198 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1199 return (EIO); 1200 } 1201 1202 err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_TX], 1203 USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_TX]); 1204 if (err) { 1205 printf("%s: open tx pipe failed: %s\n", 1206 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1207 return (EIO); 1208 } 1209 1210 /* Start up the receive pipe. */ 1211 for (i = 0; i < KUE_RX_LIST_CNT; i++) { 1212 c = &sc->kue_cdata.kue_rx_chain[i]; 1213 usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX], 1214 c, c->kue_buf, KUE_BUFSZ, 1215 USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT, 1216 kue_rxeof); 1217 DPRINTFN(5,("%s: %s: start read\n", USBDEVNAME(sc->kue_dev), 1218 __FUNCTION__)); 1219 usbd_transfer(c->kue_xfer); 1220 } 1221 1222 return (0); 1223 } 1224 1225 Static int 1226 kue_ioctl(struct ifnet *ifp, u_long command, caddr_t data) 1227 { 1228 struct kue_softc *sc = ifp->if_softc; 1229 #if defined(__NetBSD__) || defined(__OpenBSD__) 1230 struct ifaddr *ifa = (struct ifaddr *)data; 1231 struct ifreq *ifr = (struct ifreq *)data; 1232 #endif 1233 int s, error = 0; 1234 1235 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 1236 1237 if (sc->kue_dying) 1238 return (EIO); 1239 1240 s = splimp(); 1241 1242 switch(command) { 1243 #if defined(__FreeBSD__) 1244 case SIOCSIFADDR: 1245 case SIOCGIFADDR: 1246 case SIOCSIFMTU: 1247 error = ether_ioctl(ifp, command, data); 1248 break; 1249 #elif defined(__NetBSD__) || defined(__OpenBSD__) 1250 case SIOCSIFADDR: 1251 ifp->if_flags |= IFF_UP; 1252 kue_init(sc); 1253 1254 switch (ifa->ifa_addr->sa_family) { 1255 #ifdef INET 1256 case AF_INET: 1257 #if defined(__NetBSD__) 1258 arp_ifinit(ifp, ifa); 1259 #else 1260 arp_ifinit(&sc->arpcom, ifa); 1261 #endif 1262 break; 1263 #endif /* INET */ 1264 #ifdef NS 1265 case AF_NS: 1266 { 1267 struct ns_addr *ina = &IA_SNS(ifa)->sns_addr; 1268 1269 if (ns_nullhost(*ina)) 1270 ina->x_host = *(union ns_host *) 1271 LLADDR(ifp->if_sadl); 1272 else 1273 memcpy(LLADDR(ifp->if_sadl), 1274 ina->x_host.c_host, 1275 ifp->if_addrlen); 1276 break; 1277 } 1278 #endif /* NS */ 1279 } 1280 break; 1281 1282 case SIOCSIFMTU: 1283 if (ifr->ifr_mtu > ETHERMTU) 1284 error = EINVAL; 1285 else 1286 ifp->if_mtu = ifr->ifr_mtu; 1287 break; 1288 1289 #endif /* defined(__NetBSD__) || defined(__OpenBSD__) */ 1290 1291 case SIOCSIFFLAGS: 1292 if (ifp->if_flags & IFF_UP) { 1293 if (ifp->if_flags & IFF_RUNNING && 1294 ifp->if_flags & IFF_PROMISC && 1295 !(sc->kue_if_flags & IFF_PROMISC)) { 1296 sc->kue_rxfilt |= KUE_RXFILT_PROMISC; 1297 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, 1298 sc->kue_rxfilt); 1299 } else if (ifp->if_flags & IFF_RUNNING && 1300 !(ifp->if_flags & IFF_PROMISC) && 1301 sc->kue_if_flags & IFF_PROMISC) { 1302 sc->kue_rxfilt &= ~KUE_RXFILT_PROMISC; 1303 kue_setword(sc, KUE_CMD_SET_PKT_FILTER, 1304 sc->kue_rxfilt); 1305 } else if (!(ifp->if_flags & IFF_RUNNING)) 1306 kue_init(sc); 1307 } else { 1308 if (ifp->if_flags & IFF_RUNNING) 1309 kue_stop(sc); 1310 } 1311 sc->kue_if_flags = ifp->if_flags; 1312 error = 0; 1313 break; 1314 case SIOCADDMULTI: 1315 case SIOCDELMULTI: 1316 kue_setmulti(sc); 1317 error = 0; 1318 break; 1319 default: 1320 error = EINVAL; 1321 break; 1322 } 1323 1324 splx(s); 1325 1326 return (error); 1327 } 1328 1329 Static void 1330 kue_watchdog(struct ifnet *ifp) 1331 { 1332 struct kue_softc *sc = ifp->if_softc; 1333 1334 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 1335 1336 if (sc->kue_dying) 1337 return; 1338 1339 ifp->if_oerrors++; 1340 printf("%s: watchdog timeout\n", USBDEVNAME(sc->kue_dev)); 1341 1342 /* 1343 * The polling business is a kludge to avoid allowing the 1344 * USB code to call tsleep() in usbd_delay_ms(), which will 1345 * kill us since the watchdog routine is invoked from 1346 * interrupt context. 1347 */ 1348 usbd_set_polling(sc->kue_udev, 1); 1349 kue_stop(sc); 1350 kue_init(sc); 1351 usbd_set_polling(sc->kue_udev, 0); 1352 1353 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0) 1354 kue_start(ifp); 1355 } 1356 1357 /* 1358 * Stop the adapter and free any mbufs allocated to the 1359 * RX and TX lists. 1360 */ 1361 Static void 1362 kue_stop(struct kue_softc *sc) 1363 { 1364 usbd_status err; 1365 struct ifnet *ifp; 1366 int i; 1367 1368 DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__FUNCTION__)); 1369 1370 ifp = GET_IFP(sc); 1371 ifp->if_timer = 0; 1372 1373 /* Stop transfers. */ 1374 if (sc->kue_ep[KUE_ENDPT_RX] != NULL) { 1375 err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_RX]); 1376 if (err) { 1377 printf("%s: abort rx pipe failed: %s\n", 1378 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1379 } 1380 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_RX]); 1381 if (err) { 1382 printf("%s: close rx pipe failed: %s\n", 1383 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1384 } 1385 sc->kue_ep[KUE_ENDPT_RX] = NULL; 1386 } 1387 1388 if (sc->kue_ep[KUE_ENDPT_TX] != NULL) { 1389 err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_TX]); 1390 if (err) { 1391 printf("%s: abort tx pipe failed: %s\n", 1392 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1393 } 1394 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_TX]); 1395 if (err) { 1396 printf("%s: close tx pipe failed: %s\n", 1397 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1398 } 1399 sc->kue_ep[KUE_ENDPT_TX] = NULL; 1400 } 1401 1402 if (sc->kue_ep[KUE_ENDPT_INTR] != NULL) { 1403 err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_INTR]); 1404 if (err) { 1405 printf("%s: abort intr pipe failed: %s\n", 1406 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1407 } 1408 err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_INTR]); 1409 if (err) { 1410 printf("%s: close intr pipe failed: %s\n", 1411 USBDEVNAME(sc->kue_dev), usbd_errstr(err)); 1412 } 1413 sc->kue_ep[KUE_ENDPT_INTR] = NULL; 1414 } 1415 1416 /* Free RX resources. */ 1417 for (i = 0; i < KUE_RX_LIST_CNT; i++) { 1418 if (sc->kue_cdata.kue_rx_chain[i].kue_mbuf != NULL) { 1419 m_freem(sc->kue_cdata.kue_rx_chain[i].kue_mbuf); 1420 sc->kue_cdata.kue_rx_chain[i].kue_mbuf = NULL; 1421 } 1422 if (sc->kue_cdata.kue_rx_chain[i].kue_xfer != NULL) { 1423 usbd_free_xfer(sc->kue_cdata.kue_rx_chain[i].kue_xfer); 1424 sc->kue_cdata.kue_rx_chain[i].kue_xfer = NULL; 1425 } 1426 } 1427 1428 /* Free TX resources. */ 1429 for (i = 0; i < KUE_TX_LIST_CNT; i++) { 1430 if (sc->kue_cdata.kue_tx_chain[i].kue_mbuf != NULL) { 1431 m_freem(sc->kue_cdata.kue_tx_chain[i].kue_mbuf); 1432 sc->kue_cdata.kue_tx_chain[i].kue_mbuf = NULL; 1433 } 1434 if (sc->kue_cdata.kue_tx_chain[i].kue_xfer != NULL) { 1435 usbd_free_xfer(sc->kue_cdata.kue_tx_chain[i].kue_xfer); 1436 sc->kue_cdata.kue_tx_chain[i].kue_xfer = NULL; 1437 } 1438 } 1439 1440 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 1441 } 1442 1443 #ifdef __FreeBSD__ 1444 /* 1445 * Stop all chip I/O so that the kernel's probe routines don't 1446 * get confused by errant DMAs when rebooting. 1447 */ 1448 Static void 1449 kue_shutdown(device_t dev) 1450 { 1451 struct kue_softc *sc; 1452 1453 sc = device_get_softc(dev); 1454 1455 kue_stop(sc); 1456 } 1457 #endif 1458
Indexes created Thu Oct 02 14:10:14 GMT 2025