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