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