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