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