Annotation of sys/dev/usb/if_udav.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_udav.c,v 1.34 2007/06/14 10:11:15 mbalmer Exp $ */
! 2: /* $NetBSD: if_udav.c,v 1.3 2004/04/23 17:25:25 itojun Exp $ */
! 3: /* $nabe: if_udav.c,v 1.3 2003/08/21 16:57:19 nabe Exp $ */
! 4: /*
! 5: * Copyright (c) 2003
! 6: * Shingo WATANABE <nabe@nabechan.org>. All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. Neither the name of the author nor the names of any co-contributors
! 17: * may be used to endorse or promote products derived from this software
! 18: * without specific prior written permission.
! 19: *
! 20: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 23: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
! 24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 30: * SUCH DAMAGE.
! 31: *
! 32: */
! 33:
! 34: /*
! 35: * DM9601(DAVICOM USB to Ethernet MAC Controller with Integrated 10/100 PHY)
! 36: * The spec can be found at the following url.
! 37: * http://www.davicom.com.tw/big5/download/Data%20Sheet/DM9601-DS-P01-930914.pdf
! 38: */
! 39:
! 40: /*
! 41: * TODO:
! 42: * Interrupt Endpoint support
! 43: * External PHYs
! 44: * powerhook() support?
! 45: */
! 46:
! 47: #include <sys/cdefs.h>
! 48:
! 49: #include "bpfilter.h"
! 50:
! 51: #include <sys/param.h>
! 52: #include <sys/systm.h>
! 53: #include <sys/rwlock.h>
! 54: #include <sys/mbuf.h>
! 55: #include <sys/kernel.h>
! 56: #include <sys/proc.h>
! 57: #include <sys/socket.h>
! 58:
! 59: #include <sys/device.h>
! 60:
! 61: #include <net/if.h>
! 62: #include <net/if_arp.h>
! 63: #include <net/if_dl.h>
! 64: #include <net/if_media.h>
! 65:
! 66: #if NBPFILTER > 0
! 67: #include <net/bpf.h>
! 68: #endif
! 69:
! 70: #ifdef INET
! 71: #include <netinet/in.h>
! 72: #include <netinet/in_systm.h>
! 73: #include <netinet/in_var.h>
! 74: #include <netinet/ip.h>
! 75: #include <netinet/if_ether.h>
! 76: #endif
! 77:
! 78: #include <dev/mii/mii.h>
! 79: #include <dev/mii/miivar.h>
! 80:
! 81: #include <dev/usb/usb.h>
! 82: #include <dev/usb/usbdi.h>
! 83: #include <dev/usb/usbdi_util.h>
! 84: #include <dev/usb/usbdevs.h>
! 85:
! 86: #include <dev/usb/if_udavreg.h>
! 87:
! 88:
! 89: /* Function declarations */
! 90: int udav_match(struct device *, void *, void *);
! 91: void udav_attach(struct device *, struct device *, void *);
! 92: int udav_detach(struct device *, int);
! 93: int udav_activate(struct device *, enum devact);
! 94:
! 95: struct cfdriver udav_cd = {
! 96: NULL, "udav", DV_IFNET
! 97: };
! 98:
! 99: const struct cfattach udav_ca = {
! 100: sizeof(struct udav_softc),
! 101: udav_match,
! 102: udav_attach,
! 103: udav_detach,
! 104: udav_activate,
! 105: };
! 106:
! 107: int udav_openpipes(struct udav_softc *);
! 108: int udav_rx_list_init(struct udav_softc *);
! 109: int udav_tx_list_init(struct udav_softc *);
! 110: int udav_newbuf(struct udav_softc *, struct udav_chain *, struct mbuf *);
! 111: void udav_start(struct ifnet *);
! 112: int udav_send(struct udav_softc *, struct mbuf *, int);
! 113: void udav_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
! 114: void udav_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
! 115: void udav_tick(void *);
! 116: void udav_tick_task(void *);
! 117: int udav_ioctl(struct ifnet *, u_long, caddr_t);
! 118: void udav_stop_task(struct udav_softc *);
! 119: void udav_stop(struct ifnet *, int);
! 120: void udav_watchdog(struct ifnet *);
! 121: int udav_ifmedia_change(struct ifnet *);
! 122: void udav_ifmedia_status(struct ifnet *, struct ifmediareq *);
! 123: void udav_lock_mii(struct udav_softc *);
! 124: void udav_unlock_mii(struct udav_softc *);
! 125: int udav_miibus_readreg(struct device *, int, int);
! 126: void udav_miibus_writereg(struct device *, int, int, int);
! 127: void udav_miibus_statchg(struct device *);
! 128: int udav_init(struct ifnet *);
! 129: void udav_setmulti(struct udav_softc *);
! 130: void udav_reset(struct udav_softc *);
! 131:
! 132: int udav_csr_read(struct udav_softc *, int, void *, int);
! 133: int udav_csr_write(struct udav_softc *, int, void *, int);
! 134: int udav_csr_read1(struct udav_softc *, int);
! 135: int udav_csr_write1(struct udav_softc *, int, unsigned char);
! 136:
! 137: #if 0
! 138: int udav_mem_read(struct udav_softc *, int, void *, int);
! 139: int udav_mem_write(struct udav_softc *, int, void *, int);
! 140: int udav_mem_write1(struct udav_softc *, int, unsigned char);
! 141: #endif
! 142:
! 143: /* Macros */
! 144: #ifdef UDAV_DEBUG
! 145: #define DPRINTF(x) do { if (udavdebug) printf x; } while(0)
! 146: #define DPRINTFN(n,x) do { if (udavdebug >= (n)) printf x; } while(0)
! 147: int udavdebug = 0;
! 148: #else
! 149: #define DPRINTF(x)
! 150: #define DPRINTFN(n,x)
! 151: #endif
! 152:
! 153: #define UDAV_SETBIT(sc, reg, x) \
! 154: udav_csr_write1(sc, reg, udav_csr_read1(sc, reg) | (x))
! 155:
! 156: #define UDAV_CLRBIT(sc, reg, x) \
! 157: udav_csr_write1(sc, reg, udav_csr_read1(sc, reg) & ~(x))
! 158:
! 159: static const struct udav_type {
! 160: struct usb_devno udav_dev;
! 161: u_int16_t udav_flags;
! 162: #define UDAV_EXT_PHY 0x0001
! 163: } udav_devs [] = {
! 164: {{ USB_VENDOR_COREGA, USB_PRODUCT_COREGA_FETHER_USB_TXC }, 0 },
! 165: {{ USB_VENDOR_DAVICOM, USB_PRODUCT_DAVICOM_DM9601 }, 0 },
! 166: {{ USB_VENDOR_DAVICOM, USB_PRODUCT_DAVICOM_WK668 }, 0 },
! 167: {{ USB_VENDOR_SHANTOU, USB_PRODUCT_SHANTOU_DM9601 }, 0 },
! 168: {{ USB_VENDOR_SHANTOU, USB_PRODUCT_SHANTOU_ST268 }, 0 }
! 169: };
! 170: #define udav_lookup(v, p) ((struct udav_type *)usb_lookup(udav_devs, v, p))
! 171:
! 172:
! 173: /* Probe */
! 174: int
! 175: udav_match(struct device *parent, void *match, void *aux)
! 176: {
! 177: struct usb_attach_arg *uaa = aux;
! 178:
! 179: if (uaa->iface != NULL)
! 180: return (UMATCH_NONE);
! 181:
! 182: return (udav_lookup(uaa->vendor, uaa->product) != NULL ?
! 183: UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
! 184: }
! 185:
! 186: /* Attach */
! 187: void
! 188: udav_attach(struct device *parent, struct device *self, void *aux)
! 189: {
! 190: struct udav_softc *sc = (struct udav_softc *)self;
! 191: struct usb_attach_arg *uaa = aux;
! 192: usbd_device_handle dev = uaa->device;
! 193: usbd_interface_handle iface;
! 194: usbd_status err;
! 195: usb_interface_descriptor_t *id;
! 196: usb_endpoint_descriptor_t *ed;
! 197: char *devinfop;
! 198: char *devname = sc->sc_dev.dv_xname;
! 199: struct ifnet *ifp;
! 200: struct mii_data *mii;
! 201: u_char eaddr[ETHER_ADDR_LEN];
! 202: int i, s;
! 203:
! 204: devinfop = usbd_devinfo_alloc(dev, 0);
! 205: printf("\n%s: %s", devname, devinfop);
! 206: usbd_devinfo_free(devinfop);
! 207:
! 208: /* Move the device into the configured state. */
! 209: err = usbd_set_config_no(dev, UDAV_CONFIG_NO, 1);
! 210: if (err) {
! 211: printf(", setting config no failed\n");
! 212: goto bad;
! 213: }
! 214:
! 215: usb_init_task(&sc->sc_tick_task, udav_tick_task, sc);
! 216: rw_init(&sc->sc_mii_lock, "udavmii");
! 217: usb_init_task(&sc->sc_stop_task, (void (*)(void *)) udav_stop_task, sc);
! 218:
! 219: /* get control interface */
! 220: err = usbd_device2interface_handle(dev, UDAV_IFACE_INDEX, &iface);
! 221: if (err) {
! 222: printf(", failed to get interface, err=%s\n", usbd_errstr(err));
! 223: goto bad;
! 224: }
! 225:
! 226: sc->sc_udev = dev;
! 227: sc->sc_ctl_iface = iface;
! 228: sc->sc_flags = udav_lookup(uaa->vendor, uaa->product)->udav_flags;
! 229:
! 230: /* get interface descriptor */
! 231: id = usbd_get_interface_descriptor(sc->sc_ctl_iface);
! 232:
! 233: /* find endpoints */
! 234: sc->sc_bulkin_no = sc->sc_bulkout_no = sc->sc_intrin_no = -1;
! 235: for (i = 0; i < id->bNumEndpoints; i++) {
! 236: ed = usbd_interface2endpoint_descriptor(sc->sc_ctl_iface, i);
! 237: if (ed == NULL) {
! 238: printf(", couldn't get endpoint %d\n", i);
! 239: goto bad;
! 240: }
! 241: if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK &&
! 242: UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
! 243: sc->sc_bulkin_no = ed->bEndpointAddress; /* RX */
! 244: else if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK &&
! 245: UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT)
! 246: sc->sc_bulkout_no = ed->bEndpointAddress; /* TX */
! 247: else if ((ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT &&
! 248: UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
! 249: sc->sc_intrin_no = ed->bEndpointAddress; /* Status */
! 250: }
! 251:
! 252: if (sc->sc_bulkin_no == -1 || sc->sc_bulkout_no == -1 ||
! 253: sc->sc_intrin_no == -1) {
! 254: printf(", missing endpoint\n");
! 255: goto bad;
! 256: }
! 257:
! 258: s = splnet();
! 259:
! 260: /* reset the adapter */
! 261: udav_reset(sc);
! 262:
! 263: /* Get Ethernet Address */
! 264: err = udav_csr_read(sc, UDAV_PAR, (void *)eaddr, ETHER_ADDR_LEN);
! 265: if (err) {
! 266: printf(", read MAC address failed\n");
! 267: splx(s);
! 268: goto bad;
! 269: }
! 270:
! 271: /* Print Ethernet Address */
! 272: printf(" address %s\n", ether_sprintf(eaddr));
! 273:
! 274: bcopy(eaddr, (char *)&sc->sc_ac.ac_enaddr, ETHER_ADDR_LEN);
! 275:
! 276: /* initialize interface information */
! 277: ifp = GET_IFP(sc);
! 278: ifp->if_softc = sc;
! 279: strlcpy(ifp->if_xname, devname, IFNAMSIZ);
! 280: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
! 281: ifp->if_start = udav_start;
! 282: ifp->if_ioctl = udav_ioctl;
! 283: ifp->if_watchdog = udav_watchdog;
! 284:
! 285: IFQ_SET_READY(&ifp->if_snd);
! 286:
! 287: /*
! 288: * Do ifmedia setup.
! 289: */
! 290: mii = &sc->sc_mii;
! 291: mii->mii_ifp = ifp;
! 292: mii->mii_readreg = udav_miibus_readreg;
! 293: mii->mii_writereg = udav_miibus_writereg;
! 294: mii->mii_statchg = udav_miibus_statchg;
! 295: mii->mii_flags = MIIF_AUTOTSLEEP;
! 296: ifmedia_init(&mii->mii_media, 0,
! 297: udav_ifmedia_change, udav_ifmedia_status);
! 298: mii_attach(self, mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, 0);
! 299: if (LIST_FIRST(&mii->mii_phys) == NULL) {
! 300: ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL);
! 301: ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE);
! 302: } else
! 303: ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);
! 304:
! 305: /* attach the interface */
! 306: if_attach(ifp);
! 307: ether_ifattach(ifp);
! 308:
! 309: timeout_set(&sc->sc_stat_ch, NULL, NULL);
! 310: sc->sc_attached = 1;
! 311: splx(s);
! 312:
! 313: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, dev, &sc->sc_dev);
! 314:
! 315: return;
! 316:
! 317: bad:
! 318: sc->sc_dying = 1;
! 319: }
! 320:
! 321: /* detach */
! 322: int
! 323: udav_detach(struct device *self, int flags)
! 324: {
! 325: struct udav_softc *sc = (struct udav_softc *)self;
! 326: struct ifnet *ifp = GET_IFP(sc);
! 327: int s;
! 328:
! 329: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 330:
! 331: /* Detached before attached finished */
! 332: if (!sc->sc_attached)
! 333: return (0);
! 334:
! 335: timeout_del(&sc->sc_stat_ch);
! 336:
! 337: /* Remove any pending tasks */
! 338: usb_rem_task(sc->sc_udev, &sc->sc_tick_task);
! 339: usb_rem_task(sc->sc_udev, &sc->sc_stop_task);
! 340:
! 341: s = splusb();
! 342:
! 343: if (--sc->sc_refcnt >= 0) {
! 344: /* Wait for processes to go away */
! 345: usb_detach_wait(&sc->sc_dev);
! 346: }
! 347: if (ifp->if_flags & IFF_RUNNING)
! 348: udav_stop(GET_IFP(sc), 1);
! 349:
! 350: mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);
! 351: ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);
! 352: ether_ifdetach(ifp);
! 353: if_detach(ifp);
! 354:
! 355: #ifdef DIAGNOSTIC
! 356: if (sc->sc_pipe_tx != NULL)
! 357: printf("%s: detach has active tx endpoint.\n",
! 358: sc->sc_dev.dv_xname);
! 359: if (sc->sc_pipe_rx != NULL)
! 360: printf("%s: detach has active rx endpoint.\n",
! 361: sc->sc_dev.dv_xname);
! 362: if (sc->sc_pipe_intr != NULL)
! 363: printf("%s: detach has active intr endpoint.\n",
! 364: sc->sc_dev.dv_xname);
! 365: #endif
! 366: sc->sc_attached = 0;
! 367:
! 368: splx(s);
! 369:
! 370: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
! 371: &sc->sc_dev);
! 372:
! 373: return (0);
! 374: }
! 375:
! 376: #if 0
! 377: /* read memory */
! 378: int
! 379: udav_mem_read(struct udav_softc *sc, int offset, void *buf, int len)
! 380: {
! 381: usb_device_request_t req;
! 382: usbd_status err;
! 383:
! 384: if (sc == NULL)
! 385: return (0);
! 386:
! 387: DPRINTFN(0x200,
! 388: ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 389:
! 390: if (sc->sc_dying)
! 391: return (0);
! 392:
! 393: offset &= 0xffff;
! 394: len &= 0xff;
! 395:
! 396: req.bmRequestType = UT_READ_VENDOR_DEVICE;
! 397: req.bRequest = UDAV_REQ_MEM_READ;
! 398: USETW(req.wValue, 0x0000);
! 399: USETW(req.wIndex, offset);
! 400: USETW(req.wLength, len);
! 401:
! 402: sc->sc_refcnt++;
! 403: err = usbd_do_request(sc->sc_udev, &req, buf);
! 404: if (--sc->sc_refcnt < 0)
! 405: usb_detach_wakeup(&sc->sc_dev);
! 406: if (err) {
! 407: DPRINTF(("%s: %s: read failed. off=%04x, err=%d\n",
! 408: sc->sc_dev.dv_xname, __func__, offset, err));
! 409: }
! 410:
! 411: return (err);
! 412: }
! 413:
! 414: /* write memory */
! 415: int
! 416: udav_mem_write(struct udav_softc *sc, int offset, void *buf, int len)
! 417: {
! 418: usb_device_request_t req;
! 419: usbd_status err;
! 420:
! 421: if (sc == NULL)
! 422: return (0);
! 423:
! 424: DPRINTFN(0x200,
! 425: ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 426:
! 427: if (sc->sc_dying)
! 428: return (0);
! 429:
! 430: offset &= 0xffff;
! 431: len &= 0xff;
! 432:
! 433: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
! 434: req.bRequest = UDAV_REQ_MEM_WRITE;
! 435: USETW(req.wValue, 0x0000);
! 436: USETW(req.wIndex, offset);
! 437: USETW(req.wLength, len);
! 438:
! 439: sc->sc_refcnt++;
! 440: err = usbd_do_request(sc->sc_udev, &req, buf);
! 441: if (--sc->sc_refcnt < 0)
! 442: usb_detach_wakeup(&sc->sc_dev);
! 443: if (err) {
! 444: DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
! 445: sc->sc_dev.dv_xname, __func__, offset, err));
! 446: }
! 447:
! 448: return (err);
! 449: }
! 450:
! 451: /* write memory */
! 452: int
! 453: udav_mem_write1(struct udav_softc *sc, int offset, unsigned char ch)
! 454: {
! 455: usb_device_request_t req;
! 456: usbd_status err;
! 457:
! 458: if (sc == NULL)
! 459: return (0);
! 460:
! 461: DPRINTFN(0x200,
! 462: ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 463:
! 464: if (sc->sc_dying)
! 465: return (0);
! 466:
! 467: offset &= 0xffff;
! 468:
! 469: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
! 470: req.bRequest = UDAV_REQ_MEM_WRITE1;
! 471: USETW(req.wValue, ch);
! 472: USETW(req.wIndex, offset);
! 473: USETW(req.wLength, 0x0000);
! 474:
! 475: sc->sc_refcnt++;
! 476: err = usbd_do_request(sc->sc_udev, &req, NULL);
! 477: if (--sc->sc_refcnt < 0)
! 478: usb_detach_wakeup(&sc->sc_dev);
! 479: if (err) {
! 480: DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
! 481: sc->sc_dev.dv_xname, __func__, offset, err));
! 482: }
! 483:
! 484: return (err);
! 485: }
! 486: #endif
! 487:
! 488: /* read register(s) */
! 489: int
! 490: udav_csr_read(struct udav_softc *sc, int offset, void *buf, int len)
! 491: {
! 492: usb_device_request_t req;
! 493: usbd_status err;
! 494:
! 495: if (sc == NULL)
! 496: return (0);
! 497:
! 498: DPRINTFN(0x200,
! 499: ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 500:
! 501: if (sc->sc_dying)
! 502: return (0);
! 503:
! 504: offset &= 0xff;
! 505: len &= 0xff;
! 506:
! 507: req.bmRequestType = UT_READ_VENDOR_DEVICE;
! 508: req.bRequest = UDAV_REQ_REG_READ;
! 509: USETW(req.wValue, 0x0000);
! 510: USETW(req.wIndex, offset);
! 511: USETW(req.wLength, len);
! 512:
! 513: sc->sc_refcnt++;
! 514: err = usbd_do_request(sc->sc_udev, &req, buf);
! 515: if (--sc->sc_refcnt < 0)
! 516: usb_detach_wakeup(&sc->sc_dev);
! 517: if (err) {
! 518: DPRINTF(("%s: %s: read failed. off=%04x, err=%d\n",
! 519: sc->sc_dev.dv_xname, __func__, offset, err));
! 520: }
! 521:
! 522: return (err);
! 523: }
! 524:
! 525: /* write register(s) */
! 526: int
! 527: udav_csr_write(struct udav_softc *sc, int offset, void *buf, int len)
! 528: {
! 529: usb_device_request_t req;
! 530: usbd_status err;
! 531:
! 532: if (sc == NULL)
! 533: return (0);
! 534:
! 535: DPRINTFN(0x200,
! 536: ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 537:
! 538: if (sc->sc_dying)
! 539: return (0);
! 540:
! 541: offset &= 0xff;
! 542: len &= 0xff;
! 543:
! 544: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
! 545: req.bRequest = UDAV_REQ_REG_WRITE;
! 546: USETW(req.wValue, 0x0000);
! 547: USETW(req.wIndex, offset);
! 548: USETW(req.wLength, len);
! 549:
! 550: sc->sc_refcnt++;
! 551: err = usbd_do_request(sc->sc_udev, &req, buf);
! 552: if (--sc->sc_refcnt < 0)
! 553: usb_detach_wakeup(&sc->sc_dev);
! 554: if (err) {
! 555: DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
! 556: sc->sc_dev.dv_xname, __func__, offset, err));
! 557: }
! 558:
! 559: return (err);
! 560: }
! 561:
! 562: int
! 563: udav_csr_read1(struct udav_softc *sc, int offset)
! 564: {
! 565: u_int8_t val = 0;
! 566:
! 567: if (sc == NULL)
! 568: return (0);
! 569:
! 570: DPRINTFN(0x200,
! 571: ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 572:
! 573: if (sc->sc_dying)
! 574: return (0);
! 575:
! 576: return (udav_csr_read(sc, offset, &val, 1) ? 0 : val);
! 577: }
! 578:
! 579: /* write a register */
! 580: int
! 581: udav_csr_write1(struct udav_softc *sc, int offset, unsigned char ch)
! 582: {
! 583: usb_device_request_t req;
! 584: usbd_status err;
! 585:
! 586: if (sc == NULL)
! 587: return (0);
! 588:
! 589: DPRINTFN(0x200,
! 590: ("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 591:
! 592: if (sc->sc_dying)
! 593: return (0);
! 594:
! 595: offset &= 0xff;
! 596:
! 597: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
! 598: req.bRequest = UDAV_REQ_REG_WRITE1;
! 599: USETW(req.wValue, ch);
! 600: USETW(req.wIndex, offset);
! 601: USETW(req.wLength, 0x0000);
! 602:
! 603: sc->sc_refcnt++;
! 604: err = usbd_do_request(sc->sc_udev, &req, NULL);
! 605: if (--sc->sc_refcnt < 0)
! 606: usb_detach_wakeup(&sc->sc_dev);
! 607: if (err) {
! 608: DPRINTF(("%s: %s: write failed. off=%04x, err=%d\n",
! 609: sc->sc_dev.dv_xname, __func__, offset, err));
! 610: }
! 611:
! 612: return (err);
! 613: }
! 614:
! 615: int
! 616: udav_init(struct ifnet *ifp)
! 617: {
! 618: struct udav_softc *sc = ifp->if_softc;
! 619: struct mii_data *mii = GET_MII(sc);
! 620: u_char *eaddr;
! 621: int s;
! 622:
! 623: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 624:
! 625: if (sc->sc_dying)
! 626: return (EIO);
! 627:
! 628: s = splnet();
! 629:
! 630: /* Cancel pending I/O and free all TX/RX buffers */
! 631: udav_stop(ifp, 1);
! 632:
! 633: eaddr = sc->sc_ac.ac_enaddr;
! 634: udav_csr_write(sc, UDAV_PAR, eaddr, ETHER_ADDR_LEN);
! 635:
! 636: /* Initialize network control register */
! 637: /* Disable loopback */
! 638: UDAV_CLRBIT(sc, UDAV_NCR, UDAV_NCR_LBK0 | UDAV_NCR_LBK1);
! 639:
! 640: /* Initialize RX control register */
! 641: UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_DIS_LONG | UDAV_RCR_DIS_CRC);
! 642:
! 643: /* If we want promiscuous mode, accept all physical frames. */
! 644: if (ifp->if_flags & IFF_PROMISC)
! 645: UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_ALL|UDAV_RCR_PRMSC);
! 646: else
! 647: UDAV_CLRBIT(sc, UDAV_RCR, UDAV_RCR_ALL|UDAV_RCR_PRMSC);
! 648:
! 649: /* Initialize transmit ring */
! 650: if (udav_tx_list_init(sc) == ENOBUFS) {
! 651: printf("%s: tx list init failed\n", sc->sc_dev.dv_xname);
! 652: splx(s);
! 653: return (EIO);
! 654: }
! 655:
! 656: /* Initialize receive ring */
! 657: if (udav_rx_list_init(sc) == ENOBUFS) {
! 658: printf("%s: rx list init failed\n", sc->sc_dev.dv_xname);
! 659: splx(s);
! 660: return (EIO);
! 661: }
! 662:
! 663: /* Load the multicast filter */
! 664: udav_setmulti(sc);
! 665:
! 666: /* Enable RX */
! 667: UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_RXEN);
! 668:
! 669: /* clear POWER_DOWN state of internal PHY */
! 670: UDAV_SETBIT(sc, UDAV_GPCR, UDAV_GPCR_GEP_CNTL0);
! 671: UDAV_CLRBIT(sc, UDAV_GPR, UDAV_GPR_GEPIO0);
! 672:
! 673: mii_mediachg(mii);
! 674:
! 675: if (sc->sc_pipe_tx == NULL || sc->sc_pipe_rx == NULL) {
! 676: if (udav_openpipes(sc)) {
! 677: splx(s);
! 678: return (EIO);
! 679: }
! 680: }
! 681:
! 682: ifp->if_flags |= IFF_RUNNING;
! 683: ifp->if_flags &= ~IFF_OACTIVE;
! 684:
! 685: splx(s);
! 686:
! 687: timeout_del(&sc->sc_stat_ch);
! 688: timeout_set(&sc->sc_stat_ch, udav_tick, sc);
! 689: timeout_add(&sc->sc_stat_ch, hz);
! 690:
! 691: return (0);
! 692: }
! 693:
! 694: void
! 695: udav_reset(struct udav_softc *sc)
! 696: {
! 697: int i;
! 698:
! 699: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 700:
! 701: if (sc->sc_dying)
! 702: return;
! 703:
! 704: /* Select PHY */
! 705: #if 1
! 706: /*
! 707: * XXX: force select internal phy.
! 708: * external phy routines are not tested.
! 709: */
! 710: UDAV_CLRBIT(sc, UDAV_NCR, UDAV_NCR_EXT_PHY);
! 711: #else
! 712: if (sc->sc_flags & UDAV_EXT_PHY) {
! 713: UDAV_SETBIT(sc, UDAV_NCR, UDAV_NCR_EXT_PHY);
! 714: } else {
! 715: UDAV_CLRBIT(sc, UDAV_NCR, UDAV_NCR_EXT_PHY);
! 716: }
! 717: #endif
! 718:
! 719: UDAV_SETBIT(sc, UDAV_NCR, UDAV_NCR_RST);
! 720:
! 721: for (i = 0; i < UDAV_TX_TIMEOUT; i++) {
! 722: if (!(udav_csr_read1(sc, UDAV_NCR) & UDAV_NCR_RST))
! 723: break;
! 724: delay(10); /* XXX */
! 725: }
! 726: delay(10000); /* XXX */
! 727: }
! 728:
! 729: int
! 730: udav_activate(struct device *self, enum devact act)
! 731: {
! 732: struct udav_softc *sc = (struct udav_softc *)self;
! 733:
! 734: DPRINTF(("%s: %s: enter, act=%d\n", sc->sc_dev.dv_xname,
! 735: __func__, act));
! 736: switch (act) {
! 737: case DVACT_ACTIVATE:
! 738: break;
! 739:
! 740: case DVACT_DEACTIVATE:
! 741: sc->sc_dying = 1;
! 742: break;
! 743: }
! 744: return (0);
! 745: }
! 746:
! 747: #define UDAV_BITS 6
! 748:
! 749: #define UDAV_CALCHASH(addr) \
! 750: (ether_crc32_le((addr), ETHER_ADDR_LEN) & ((1 << UDAV_BITS) - 1))
! 751:
! 752: void
! 753: udav_setmulti(struct udav_softc *sc)
! 754: {
! 755: struct ifnet *ifp;
! 756: struct ether_multi *enm;
! 757: struct ether_multistep step;
! 758: u_int8_t hashes[8];
! 759: int h = 0;
! 760:
! 761: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 762:
! 763: if (sc->sc_dying)
! 764: return;
! 765:
! 766: ifp = GET_IFP(sc);
! 767:
! 768: if (ifp->if_flags & IFF_PROMISC) {
! 769: UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_ALL|UDAV_RCR_PRMSC);
! 770: return;
! 771: } else if (ifp->if_flags & IFF_ALLMULTI) {
! 772: allmulti:
! 773: ifp->if_flags |= IFF_ALLMULTI;
! 774: UDAV_SETBIT(sc, UDAV_RCR, UDAV_RCR_ALL);
! 775: UDAV_CLRBIT(sc, UDAV_RCR, UDAV_RCR_PRMSC);
! 776: return;
! 777: }
! 778:
! 779: /* first, zot all the existing hash bits */
! 780: memset(hashes, 0x00, sizeof(hashes));
! 781: hashes[7] |= 0x80; /* broadcast address */
! 782: udav_csr_write(sc, UDAV_MAR, hashes, sizeof(hashes));
! 783:
! 784: /* now program new ones */
! 785: ETHER_FIRST_MULTI(step, &sc->sc_ac, enm);
! 786: while (enm != NULL) {
! 787: if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
! 788: ETHER_ADDR_LEN) != 0)
! 789: goto allmulti;
! 790:
! 791: h = UDAV_CALCHASH(enm->enm_addrlo);
! 792: hashes[h>>3] |= 1 << (h & 0x7);
! 793: ETHER_NEXT_MULTI(step, enm);
! 794: }
! 795:
! 796: /* disable all multicast */
! 797: ifp->if_flags &= ~IFF_ALLMULTI;
! 798: UDAV_CLRBIT(sc, UDAV_RCR, UDAV_RCR_ALL);
! 799:
! 800: /* write hash value to the register */
! 801: udav_csr_write(sc, UDAV_MAR, hashes, sizeof(hashes));
! 802: }
! 803:
! 804: int
! 805: udav_openpipes(struct udav_softc *sc)
! 806: {
! 807: struct udav_chain *c;
! 808: usbd_status err;
! 809: int i;
! 810: int error = 0;
! 811:
! 812: if (sc->sc_dying)
! 813: return (EIO);
! 814:
! 815: sc->sc_refcnt++;
! 816:
! 817: /* Open RX pipe */
! 818: err = usbd_open_pipe(sc->sc_ctl_iface, sc->sc_bulkin_no,
! 819: USBD_EXCLUSIVE_USE, &sc->sc_pipe_rx);
! 820: if (err) {
! 821: printf("%s: open rx pipe failed: %s\n",
! 822: sc->sc_dev.dv_xname, usbd_errstr(err));
! 823: error = EIO;
! 824: goto done;
! 825: }
! 826:
! 827: /* Open TX pipe */
! 828: err = usbd_open_pipe(sc->sc_ctl_iface, sc->sc_bulkout_no,
! 829: USBD_EXCLUSIVE_USE, &sc->sc_pipe_tx);
! 830: if (err) {
! 831: printf("%s: open tx pipe failed: %s\n",
! 832: sc->sc_dev.dv_xname, usbd_errstr(err));
! 833: error = EIO;
! 834: goto done;
! 835: }
! 836:
! 837: #if 0
! 838: /* XXX: interrupt endpoint is not yet supported */
! 839: /* Open Interrupt pipe */
! 840: err = usbd_open_pipe_intr(sc->sc_ctl_iface, sc->sc_intrin_no,
! 841: USBD_EXCLUSIVE_USE, &sc->sc_pipe_intr, sc,
! 842: &sc->sc_cdata.udav_ibuf, UDAV_INTR_PKGLEN,
! 843: udav_intr, UDAV_INTR_INTERVAL);
! 844: if (err) {
! 845: printf("%s: open intr pipe failed: %s\n",
! 846: sc->sc_dev.dv_xname, usbd_errstr(err));
! 847: error = EIO;
! 848: goto done;
! 849: }
! 850: #endif
! 851:
! 852:
! 853: /* Start up the receive pipe. */
! 854: for (i = 0; i < UDAV_RX_LIST_CNT; i++) {
! 855: c = &sc->sc_cdata.udav_rx_chain[i];
! 856: usbd_setup_xfer(c->udav_xfer, sc->sc_pipe_rx,
! 857: c, c->udav_buf, UDAV_BUFSZ,
! 858: USBD_SHORT_XFER_OK | USBD_NO_COPY,
! 859: USBD_NO_TIMEOUT, udav_rxeof);
! 860: (void)usbd_transfer(c->udav_xfer);
! 861: DPRINTF(("%s: %s: start read\n", sc->sc_dev.dv_xname,
! 862: __func__));
! 863: }
! 864:
! 865: done:
! 866: if (--sc->sc_refcnt < 0)
! 867: usb_detach_wakeup(&sc->sc_dev);
! 868:
! 869: return (error);
! 870: }
! 871:
! 872: int
! 873: udav_newbuf(struct udav_softc *sc, struct udav_chain *c, struct mbuf *m)
! 874: {
! 875: struct mbuf *m_new = NULL;
! 876:
! 877: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 878:
! 879: if (m == NULL) {
! 880: MGETHDR(m_new, M_DONTWAIT, MT_DATA);
! 881: if (m_new == NULL) {
! 882: printf("%s: no memory for rx list "
! 883: "-- packet dropped!\n", sc->sc_dev.dv_xname);
! 884: return (ENOBUFS);
! 885: }
! 886: MCLGET(m_new, M_DONTWAIT);
! 887: if (!(m_new->m_flags & M_EXT)) {
! 888: printf("%s: no memory for rx list "
! 889: "-- packet dropped!\n", sc->sc_dev.dv_xname);
! 890: m_freem(m_new);
! 891: return (ENOBUFS);
! 892: }
! 893: m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
! 894: } else {
! 895: m_new = m;
! 896: m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
! 897: m_new->m_data = m_new->m_ext.ext_buf;
! 898: }
! 899:
! 900: m_adj(m_new, ETHER_ALIGN);
! 901: c->udav_mbuf = m_new;
! 902:
! 903: return (0);
! 904: }
! 905:
! 906:
! 907: int
! 908: udav_rx_list_init(struct udav_softc *sc)
! 909: {
! 910: struct udav_cdata *cd;
! 911: struct udav_chain *c;
! 912: int i;
! 913:
! 914: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 915:
! 916: cd = &sc->sc_cdata;
! 917: for (i = 0; i < UDAV_RX_LIST_CNT; i++) {
! 918: c = &cd->udav_rx_chain[i];
! 919: c->udav_sc = sc;
! 920: c->udav_idx = i;
! 921: if (udav_newbuf(sc, c, NULL) == ENOBUFS)
! 922: return (ENOBUFS);
! 923: if (c->udav_xfer == NULL) {
! 924: c->udav_xfer = usbd_alloc_xfer(sc->sc_udev);
! 925: if (c->udav_xfer == NULL)
! 926: return (ENOBUFS);
! 927: c->udav_buf = usbd_alloc_buffer(c->udav_xfer, UDAV_BUFSZ);
! 928: if (c->udav_buf == NULL) {
! 929: usbd_free_xfer(c->udav_xfer);
! 930: return (ENOBUFS);
! 931: }
! 932: }
! 933: }
! 934:
! 935: return (0);
! 936: }
! 937:
! 938: int
! 939: udav_tx_list_init(struct udav_softc *sc)
! 940: {
! 941: struct udav_cdata *cd;
! 942: struct udav_chain *c;
! 943: int i;
! 944:
! 945: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 946:
! 947: cd = &sc->sc_cdata;
! 948: for (i = 0; i < UDAV_TX_LIST_CNT; i++) {
! 949: c = &cd->udav_tx_chain[i];
! 950: c->udav_sc = sc;
! 951: c->udav_idx = i;
! 952: c->udav_mbuf = NULL;
! 953: if (c->udav_xfer == NULL) {
! 954: c->udav_xfer = usbd_alloc_xfer(sc->sc_udev);
! 955: if (c->udav_xfer == NULL)
! 956: return (ENOBUFS);
! 957: c->udav_buf = usbd_alloc_buffer(c->udav_xfer, UDAV_BUFSZ);
! 958: if (c->udav_buf == NULL) {
! 959: usbd_free_xfer(c->udav_xfer);
! 960: return (ENOBUFS);
! 961: }
! 962: }
! 963: }
! 964:
! 965: return (0);
! 966: }
! 967:
! 968: void
! 969: udav_start(struct ifnet *ifp)
! 970: {
! 971: struct udav_softc *sc = ifp->if_softc;
! 972: struct mbuf *m_head = NULL;
! 973:
! 974: DPRINTF(("%s: %s: enter, link=%d\n", sc->sc_dev.dv_xname,
! 975: __func__, sc->sc_link));
! 976:
! 977: if (sc->sc_dying)
! 978: return;
! 979:
! 980: if (!sc->sc_link)
! 981: return;
! 982:
! 983: if (ifp->if_flags & IFF_OACTIVE)
! 984: return;
! 985:
! 986: IFQ_POLL(&ifp->if_snd, m_head);
! 987: if (m_head == NULL)
! 988: return;
! 989:
! 990: if (udav_send(sc, m_head, 0)) {
! 991: ifp->if_flags |= IFF_OACTIVE;
! 992: return;
! 993: }
! 994:
! 995: IFQ_DEQUEUE(&ifp->if_snd, m_head);
! 996:
! 997: #if NBPFILTER > 0
! 998: if (ifp->if_bpf)
! 999: bpf_mtap(ifp->if_bpf, m_head, BPF_DIRECTION_OUT);
! 1000: #endif
! 1001:
! 1002: ifp->if_flags |= IFF_OACTIVE;
! 1003:
! 1004: /* Set a timeout in case the chip goes out to lunch. */
! 1005: ifp->if_timer = 5;
! 1006: }
! 1007:
! 1008: int
! 1009: udav_send(struct udav_softc *sc, struct mbuf *m, int idx)
! 1010: {
! 1011: int total_len;
! 1012: struct udav_chain *c;
! 1013: usbd_status err;
! 1014:
! 1015: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname,__func__));
! 1016:
! 1017: c = &sc->sc_cdata.udav_tx_chain[idx];
! 1018:
! 1019: /* Copy the mbuf data into a contiguous buffer */
! 1020: /* first 2 bytes are packet length */
! 1021: m_copydata(m, 0, m->m_pkthdr.len, c->udav_buf + 2);
! 1022: c->udav_mbuf = m;
! 1023: total_len = m->m_pkthdr.len;
! 1024: if (total_len < UDAV_MIN_FRAME_LEN) {
! 1025: memset(c->udav_buf + 2 + total_len, 0,
! 1026: UDAV_MIN_FRAME_LEN - total_len);
! 1027: total_len = UDAV_MIN_FRAME_LEN;
! 1028: }
! 1029:
! 1030: /* Frame length is specified in the first 2bytes of the buffer */
! 1031: c->udav_buf[0] = (u_int8_t)total_len;
! 1032: c->udav_buf[1] = (u_int8_t)(total_len >> 8);
! 1033: total_len += 2;
! 1034:
! 1035: usbd_setup_xfer(c->udav_xfer, sc->sc_pipe_tx, c, c->udav_buf, total_len,
! 1036: USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
! 1037: UDAV_TX_TIMEOUT, udav_txeof);
! 1038:
! 1039: /* Transmit */
! 1040: sc->sc_refcnt++;
! 1041: err = usbd_transfer(c->udav_xfer);
! 1042: if (--sc->sc_refcnt < 0)
! 1043: usb_detach_wakeup(&sc->sc_dev);
! 1044: if (err != USBD_IN_PROGRESS) {
! 1045: printf("%s: udav_send error=%s\n", sc->sc_dev.dv_xname,
! 1046: usbd_errstr(err));
! 1047: /* Stop the interface */
! 1048: usb_add_task(sc->sc_udev, &sc->sc_stop_task);
! 1049: return (EIO);
! 1050: }
! 1051:
! 1052: DPRINTF(("%s: %s: send %d bytes\n", sc->sc_dev.dv_xname,
! 1053: __func__, total_len));
! 1054:
! 1055: sc->sc_cdata.udav_tx_cnt++;
! 1056:
! 1057: return (0);
! 1058: }
! 1059:
! 1060: void
! 1061: udav_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
! 1062: {
! 1063: struct udav_chain *c = priv;
! 1064: struct udav_softc *sc = c->udav_sc;
! 1065: struct ifnet *ifp = GET_IFP(sc);
! 1066: int s;
! 1067:
! 1068: if (sc->sc_dying)
! 1069: return;
! 1070:
! 1071: s = splnet();
! 1072:
! 1073: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 1074:
! 1075: ifp->if_timer = 0;
! 1076: ifp->if_flags &= ~IFF_OACTIVE;
! 1077:
! 1078: if (status != USBD_NORMAL_COMPLETION) {
! 1079: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
! 1080: splx(s);
! 1081: return;
! 1082: }
! 1083: ifp->if_oerrors++;
! 1084: printf("%s: usb error on tx: %s\n", sc->sc_dev.dv_xname,
! 1085: usbd_errstr(status));
! 1086: if (status == USBD_STALLED) {
! 1087: sc->sc_refcnt++;
! 1088: usbd_clear_endpoint_stall_async(sc->sc_pipe_tx);
! 1089: if (--sc->sc_refcnt < 0)
! 1090: usb_detach_wakeup(&sc->sc_dev);
! 1091: }
! 1092: splx(s);
! 1093: return;
! 1094: }
! 1095:
! 1096: ifp->if_opackets++;
! 1097:
! 1098: m_freem(c->udav_mbuf);
! 1099: c->udav_mbuf = NULL;
! 1100:
! 1101: if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
! 1102: udav_start(ifp);
! 1103:
! 1104: splx(s);
! 1105: }
! 1106:
! 1107: void
! 1108: udav_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
! 1109: {
! 1110: struct udav_chain *c = priv;
! 1111: struct udav_softc *sc = c->udav_sc;
! 1112: struct ifnet *ifp = GET_IFP(sc);
! 1113: struct udav_rx_hdr *h;
! 1114: struct mbuf *m;
! 1115: u_int32_t total_len;
! 1116: int s;
! 1117:
! 1118: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname,__func__));
! 1119:
! 1120: if (sc->sc_dying)
! 1121: return;
! 1122:
! 1123: if (status != USBD_NORMAL_COMPLETION) {
! 1124: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
! 1125: return;
! 1126: sc->sc_rx_errs++;
! 1127: if (usbd_ratecheck(&sc->sc_rx_notice)) {
! 1128: printf("%s: %u usb errors on rx: %s\n",
! 1129: sc->sc_dev.dv_xname, sc->sc_rx_errs,
! 1130: usbd_errstr(status));
! 1131: sc->sc_rx_errs = 0;
! 1132: }
! 1133: if (status == USBD_STALLED) {
! 1134: sc->sc_refcnt++;
! 1135: usbd_clear_endpoint_stall_async(sc->sc_pipe_rx);
! 1136: if (--sc->sc_refcnt < 0)
! 1137: usb_detach_wakeup(&sc->sc_dev);
! 1138: }
! 1139: goto done;
! 1140: }
! 1141:
! 1142: usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
! 1143:
! 1144: h = (struct udav_rx_hdr *)c->udav_buf;
! 1145: total_len = UGETW(h->length) - ETHER_CRC_LEN;
! 1146:
! 1147: DPRINTF(("%s: RX Status: 0x%02x\n", h->pktstat));
! 1148:
! 1149: if (h->pktstat & UDAV_RSR_LCS) {
! 1150: ifp->if_collisions++;
! 1151: goto done;
! 1152: }
! 1153:
! 1154: if (total_len < sizeof(struct ether_header) ||
! 1155: h->pktstat & UDAV_RSR_ERR) {
! 1156: ifp->if_ierrors++;
! 1157: goto done;
! 1158: }
! 1159:
! 1160: /* copy data to mbuf */
! 1161: m = c->udav_mbuf;
! 1162: memcpy(mtod(m, char *), c->udav_buf + UDAV_RX_HDRLEN, total_len);
! 1163:
! 1164: ifp->if_ipackets++;
! 1165:
! 1166: m->m_pkthdr.len = m->m_len = total_len;
! 1167: m->m_pkthdr.rcvif = ifp;
! 1168:
! 1169: s = splnet();
! 1170:
! 1171: if (udav_newbuf(sc, c, NULL) == ENOBUFS) {
! 1172: ifp->if_ierrors++;
! 1173: goto done1;
! 1174: }
! 1175:
! 1176: #if NBPFILTER > 0
! 1177: if (ifp->if_bpf)
! 1178: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
! 1179: #endif
! 1180:
! 1181: DPRINTF(("%s: %s: deliver %d\n", sc->sc_dev.dv_xname,
! 1182: __func__, m->m_len));
! 1183: ether_input_mbuf(ifp, m);
! 1184:
! 1185: done1:
! 1186: splx(s);
! 1187:
! 1188: done:
! 1189: /* Setup new transfer */
! 1190: usbd_setup_xfer(xfer, sc->sc_pipe_rx, c, c->udav_buf, UDAV_BUFSZ,
! 1191: USBD_SHORT_XFER_OK | USBD_NO_COPY,
! 1192: USBD_NO_TIMEOUT, udav_rxeof);
! 1193: sc->sc_refcnt++;
! 1194: usbd_transfer(xfer);
! 1195: if (--sc->sc_refcnt < 0)
! 1196: usb_detach_wakeup(&sc->sc_dev);
! 1197:
! 1198: DPRINTF(("%s: %s: start rx\n", sc->sc_dev.dv_xname, __func__));
! 1199: }
! 1200:
! 1201: #if 0
! 1202: void udav_intr()
! 1203: {
! 1204: }
! 1205: #endif
! 1206:
! 1207: int
! 1208: udav_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
! 1209: {
! 1210: struct udav_softc *sc = ifp->if_softc;
! 1211: struct ifaddr *ifa = (struct ifaddr *)data;
! 1212: struct ifreq *ifr = (struct ifreq *)data;
! 1213: struct mii_data *mii;
! 1214: int s, error = 0;
! 1215:
! 1216: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 1217:
! 1218: if (sc->sc_dying)
! 1219: return (EIO);
! 1220:
! 1221: s = splnet();
! 1222:
! 1223: switch (cmd) {
! 1224: case SIOCGIFMEDIA:
! 1225: case SIOCSIFMEDIA:
! 1226: mii = GET_MII(sc);
! 1227: error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
! 1228: break;
! 1229: case SIOCSIFADDR:
! 1230: ifp->if_flags |= IFF_UP;
! 1231: udav_init(ifp);
! 1232:
! 1233: switch (ifa->ifa_addr->sa_family) {
! 1234: #ifdef INET
! 1235: case AF_INET:
! 1236: arp_ifinit(&sc->sc_ac, ifa);
! 1237: break;
! 1238: #endif /* INET */
! 1239: }
! 1240: break;
! 1241:
! 1242: case SIOCSIFMTU:
! 1243: if (ifr->ifr_mtu > ETHERMTU)
! 1244: error = EINVAL;
! 1245: else
! 1246: ifp->if_mtu = ifr->ifr_mtu;
! 1247: break;
! 1248: case SIOCSIFFLAGS:
! 1249: if (ifp->if_flags & IFF_UP) {
! 1250: if (ifp->if_flags & IFF_RUNNING &&
! 1251: ifp->if_flags & IFF_PROMISC) {
! 1252: UDAV_SETBIT(sc, UDAV_RCR,
! 1253: UDAV_RCR_ALL|UDAV_RCR_PRMSC);
! 1254: } else if (ifp->if_flags & IFF_RUNNING &&
! 1255: !(ifp->if_flags & IFF_PROMISC)) {
! 1256: UDAV_CLRBIT(sc, UDAV_RCR,
! 1257: UDAV_RCR_PRMSC);
! 1258: } else if (!(ifp->if_flags & IFF_RUNNING))
! 1259: udav_init(ifp);
! 1260: } else {
! 1261: if (ifp->if_flags & IFF_RUNNING)
! 1262: udav_stop(ifp, 1);
! 1263: }
! 1264: error = 0;
! 1265: break;
! 1266: case SIOCADDMULTI:
! 1267: case SIOCDELMULTI:
! 1268: error = (cmd == SIOCADDMULTI) ?
! 1269: ether_addmulti(ifr, &sc->sc_ac) :
! 1270: ether_delmulti(ifr, &sc->sc_ac);
! 1271:
! 1272: if (error == ENETRESET) {
! 1273: if (ifp->if_flags & IFF_RUNNING)
! 1274: udav_setmulti(sc);
! 1275: error = 0;
! 1276: }
! 1277: break;
! 1278: default:
! 1279: error = EINVAL;
! 1280: break;
! 1281: }
! 1282:
! 1283: splx(s);
! 1284:
! 1285: return (error);
! 1286: }
! 1287:
! 1288: void
! 1289: udav_watchdog(struct ifnet *ifp)
! 1290: {
! 1291: struct udav_softc *sc = ifp->if_softc;
! 1292: struct udav_chain *c;
! 1293: usbd_status stat;
! 1294: int s;
! 1295:
! 1296: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 1297:
! 1298: ifp->if_oerrors++;
! 1299: printf("%s: watchdog timeout\n", sc->sc_dev.dv_xname);
! 1300:
! 1301: s = splusb();
! 1302: c = &sc->sc_cdata.udav_tx_chain[0];
! 1303: usbd_get_xfer_status(c->udav_xfer, NULL, NULL, NULL, &stat);
! 1304: udav_txeof(c->udav_xfer, c, stat);
! 1305:
! 1306: if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
! 1307: udav_start(ifp);
! 1308: splx(s);
! 1309: }
! 1310:
! 1311: void
! 1312: udav_stop_task(struct udav_softc *sc)
! 1313: {
! 1314: udav_stop(GET_IFP(sc), 1);
! 1315: }
! 1316:
! 1317: /* Stop the adapter and free any mbufs allocated to the RX and TX lists. */
! 1318: void
! 1319: udav_stop(struct ifnet *ifp, int disable)
! 1320: {
! 1321: struct udav_softc *sc = ifp->if_softc;
! 1322: usbd_status err;
! 1323: int i;
! 1324:
! 1325: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 1326:
! 1327: ifp->if_timer = 0;
! 1328: ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
! 1329:
! 1330: udav_reset(sc);
! 1331:
! 1332: timeout_del(&sc->sc_stat_ch);
! 1333:
! 1334: /* Stop transfers */
! 1335: /* RX endpoint */
! 1336: if (sc->sc_pipe_rx != NULL) {
! 1337: err = usbd_abort_pipe(sc->sc_pipe_rx);
! 1338: if (err)
! 1339: printf("%s: abort rx pipe failed: %s\n",
! 1340: sc->sc_dev.dv_xname, usbd_errstr(err));
! 1341: err = usbd_close_pipe(sc->sc_pipe_rx);
! 1342: if (err)
! 1343: printf("%s: close rx pipe failed: %s\n",
! 1344: sc->sc_dev.dv_xname, usbd_errstr(err));
! 1345: sc->sc_pipe_rx = NULL;
! 1346: }
! 1347:
! 1348: /* TX endpoint */
! 1349: if (sc->sc_pipe_tx != NULL) {
! 1350: err = usbd_abort_pipe(sc->sc_pipe_tx);
! 1351: if (err)
! 1352: printf("%s: abort tx pipe failed: %s\n",
! 1353: sc->sc_dev.dv_xname, usbd_errstr(err));
! 1354: err = usbd_close_pipe(sc->sc_pipe_tx);
! 1355: if (err)
! 1356: printf("%s: close tx pipe failed: %s\n",
! 1357: sc->sc_dev.dv_xname, usbd_errstr(err));
! 1358: sc->sc_pipe_tx = NULL;
! 1359: }
! 1360:
! 1361: #if 0
! 1362: /* XXX: Interrupt endpoint is not yet supported!! */
! 1363: /* Interrupt endpoint */
! 1364: if (sc->sc_pipe_intr != NULL) {
! 1365: err = usbd_abort_pipe(sc->sc_pipe_intr);
! 1366: if (err)
! 1367: printf("%s: abort intr pipe failed: %s\n",
! 1368: sc->sc_dev.dv_xname, usbd_errstr(err));
! 1369: err = usbd_close_pipe(sc->sc_pipe_intr);
! 1370: if (err)
! 1371: printf("%s: close intr pipe failed: %s\n",
! 1372: sc->sc_dev.dv_xname, usbd_errstr(err));
! 1373: sc->sc_pipe_intr = NULL;
! 1374: }
! 1375: #endif
! 1376:
! 1377: /* Free RX resources. */
! 1378: for (i = 0; i < UDAV_RX_LIST_CNT; i++) {
! 1379: if (sc->sc_cdata.udav_rx_chain[i].udav_mbuf != NULL) {
! 1380: m_freem(sc->sc_cdata.udav_rx_chain[i].udav_mbuf);
! 1381: sc->sc_cdata.udav_rx_chain[i].udav_mbuf = NULL;
! 1382: }
! 1383: if (sc->sc_cdata.udav_rx_chain[i].udav_xfer != NULL) {
! 1384: usbd_free_xfer(sc->sc_cdata.udav_rx_chain[i].udav_xfer);
! 1385: sc->sc_cdata.udav_rx_chain[i].udav_xfer = NULL;
! 1386: }
! 1387: }
! 1388:
! 1389: /* Free TX resources. */
! 1390: for (i = 0; i < UDAV_TX_LIST_CNT; i++) {
! 1391: if (sc->sc_cdata.udav_tx_chain[i].udav_mbuf != NULL) {
! 1392: m_freem(sc->sc_cdata.udav_tx_chain[i].udav_mbuf);
! 1393: sc->sc_cdata.udav_tx_chain[i].udav_mbuf = NULL;
! 1394: }
! 1395: if (sc->sc_cdata.udav_tx_chain[i].udav_xfer != NULL) {
! 1396: usbd_free_xfer(sc->sc_cdata.udav_tx_chain[i].udav_xfer);
! 1397: sc->sc_cdata.udav_tx_chain[i].udav_xfer = NULL;
! 1398: }
! 1399: }
! 1400:
! 1401: sc->sc_link = 0;
! 1402: }
! 1403:
! 1404: /* Set media options */
! 1405: int
! 1406: udav_ifmedia_change(struct ifnet *ifp)
! 1407: {
! 1408: struct udav_softc *sc = ifp->if_softc;
! 1409: struct mii_data *mii = GET_MII(sc);
! 1410:
! 1411: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 1412:
! 1413: if (sc->sc_dying)
! 1414: return (0);
! 1415:
! 1416: sc->sc_link = 0;
! 1417: if (mii->mii_instance) {
! 1418: struct mii_softc *miisc;
! 1419: for (miisc = LIST_FIRST(&mii->mii_phys); miisc != NULL;
! 1420: miisc = LIST_NEXT(miisc, mii_list))
! 1421: mii_phy_reset(miisc);
! 1422: }
! 1423:
! 1424: return (mii_mediachg(mii));
! 1425: }
! 1426:
! 1427: /* Report current media status. */
! 1428: void
! 1429: udav_ifmedia_status(struct ifnet *ifp, struct ifmediareq *ifmr)
! 1430: {
! 1431: struct udav_softc *sc = ifp->if_softc;
! 1432: struct mii_data *mii = GET_MII(sc);
! 1433:
! 1434: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 1435:
! 1436: if (sc->sc_dying)
! 1437: return;
! 1438:
! 1439: if ((ifp->if_flags & IFF_RUNNING) == 0) {
! 1440: ifmr->ifm_active = IFM_ETHER | IFM_NONE;
! 1441: ifmr->ifm_status = 0;
! 1442: return;
! 1443: }
! 1444:
! 1445: mii_pollstat(mii);
! 1446: ifmr->ifm_active = mii->mii_media_active;
! 1447: ifmr->ifm_status = mii->mii_media_status;
! 1448: }
! 1449:
! 1450: void
! 1451: udav_tick(void *xsc)
! 1452: {
! 1453: struct udav_softc *sc = xsc;
! 1454:
! 1455: if (sc == NULL)
! 1456: return;
! 1457:
! 1458: DPRINTFN(0xff, ("%s: %s: enter\n", sc->sc_dev.dv_xname,
! 1459: __func__));
! 1460:
! 1461: if (sc->sc_dying)
! 1462: return;
! 1463:
! 1464: /* Perform periodic stuff in process context */
! 1465: usb_add_task(sc->sc_udev, &sc->sc_tick_task);
! 1466: }
! 1467:
! 1468: void
! 1469: udav_tick_task(void *xsc)
! 1470: {
! 1471: struct udav_softc *sc = xsc;
! 1472: struct ifnet *ifp;
! 1473: struct mii_data *mii;
! 1474: int s;
! 1475:
! 1476: if (sc == NULL)
! 1477: return;
! 1478:
! 1479: DPRINTFN(0xff, ("%s: %s: enter\n", sc->sc_dev.dv_xname,
! 1480: __func__));
! 1481:
! 1482: if (sc->sc_dying)
! 1483: return;
! 1484:
! 1485: ifp = GET_IFP(sc);
! 1486: mii = GET_MII(sc);
! 1487:
! 1488: if (mii == NULL)
! 1489: return;
! 1490:
! 1491: s = splnet();
! 1492:
! 1493: mii_tick(mii);
! 1494: if (!sc->sc_link && mii->mii_media_status & IFM_ACTIVE &&
! 1495: IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
! 1496: DPRINTF(("%s: %s: got link\n",
! 1497: sc->sc_dev.dv_xname, __func__));
! 1498: sc->sc_link++;
! 1499: if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
! 1500: udav_start(ifp);
! 1501: }
! 1502:
! 1503: timeout_del(&sc->sc_stat_ch);
! 1504: timeout_set(&sc->sc_stat_ch, udav_tick, sc);
! 1505: timeout_add(&sc->sc_stat_ch, hz);
! 1506:
! 1507: splx(s);
! 1508: }
! 1509:
! 1510: /* Get exclusive access to the MII registers */
! 1511: void
! 1512: udav_lock_mii(struct udav_softc *sc)
! 1513: {
! 1514: DPRINTFN(0xff, ("%s: %s: enter\n", sc->sc_dev.dv_xname,
! 1515: __func__));
! 1516:
! 1517: sc->sc_refcnt++;
! 1518: rw_enter_write(&sc->sc_mii_lock);
! 1519: }
! 1520:
! 1521: void
! 1522: udav_unlock_mii(struct udav_softc *sc)
! 1523: {
! 1524: DPRINTFN(0xff, ("%s: %s: enter\n", sc->sc_dev.dv_xname,
! 1525: __func__));
! 1526:
! 1527: rw_exit_write(&sc->sc_mii_lock);
! 1528: if (--sc->sc_refcnt < 0)
! 1529: usb_detach_wakeup(&sc->sc_dev);
! 1530: }
! 1531:
! 1532: int
! 1533: udav_miibus_readreg(struct device *dev, int phy, int reg)
! 1534: {
! 1535: struct udav_softc *sc;
! 1536: u_int8_t val[2];
! 1537: u_int16_t data16;
! 1538:
! 1539: if (dev == NULL)
! 1540: return (0);
! 1541:
! 1542: sc = (void *)dev;
! 1543:
! 1544: DPRINTFN(0xff, ("%s: %s: enter, phy=%d reg=0x%04x\n",
! 1545: sc->sc_dev.dv_xname, __func__, phy, reg));
! 1546:
! 1547: if (sc->sc_dying) {
! 1548: #ifdef DIAGNOSTIC
! 1549: printf("%s: %s: dying\n", sc->sc_dev.dv_xname,
! 1550: __func__);
! 1551: #endif
! 1552: return (0);
! 1553: }
! 1554:
! 1555: /* XXX: one PHY only for the internal PHY */
! 1556: if (phy != 0) {
! 1557: DPRINTFN(0xff, ("%s: %s: phy=%d is not supported\n",
! 1558: sc->sc_dev.dv_xname, __func__, phy));
! 1559: return (0);
! 1560: }
! 1561:
! 1562: udav_lock_mii(sc);
! 1563:
! 1564: /* select internal PHY and set PHY register address */
! 1565: udav_csr_write1(sc, UDAV_EPAR,
! 1566: UDAV_EPAR_PHY_ADR0 | (reg & UDAV_EPAR_EROA_MASK));
! 1567:
! 1568: /* select PHY operation and start read command */
! 1569: udav_csr_write1(sc, UDAV_EPCR, UDAV_EPCR_EPOS | UDAV_EPCR_ERPRR);
! 1570:
! 1571: /* XXX: should be wait? */
! 1572:
! 1573: /* end read command */
! 1574: UDAV_CLRBIT(sc, UDAV_EPCR, UDAV_EPCR_ERPRR);
! 1575:
! 1576: /* retrieve the result from data registers */
! 1577: udav_csr_read(sc, UDAV_EPDRL, val, 2);
! 1578:
! 1579: udav_unlock_mii(sc);
! 1580:
! 1581: data16 = val[0] | (val[1] << 8);
! 1582:
! 1583: DPRINTFN(0xff, ("%s: %s: phy=%d reg=0x%04x => 0x%04x\n",
! 1584: sc->sc_dev.dv_xname, __func__, phy, reg, data16));
! 1585:
! 1586: return (data16);
! 1587: }
! 1588:
! 1589: void
! 1590: udav_miibus_writereg(struct device *dev, int phy, int reg, int data)
! 1591: {
! 1592: struct udav_softc *sc;
! 1593: u_int8_t val[2];
! 1594:
! 1595: if (dev == NULL)
! 1596: return;
! 1597:
! 1598: sc = (void *)dev;
! 1599:
! 1600: DPRINTFN(0xff, ("%s: %s: enter, phy=%d reg=0x%04x data=0x%04x\n",
! 1601: sc->sc_dev.dv_xname, __func__, phy, reg, data));
! 1602:
! 1603: if (sc->sc_dying) {
! 1604: #ifdef DIAGNOSTIC
! 1605: printf("%s: %s: dying\n", sc->sc_dev.dv_xname,
! 1606: __func__);
! 1607: #endif
! 1608: return;
! 1609: }
! 1610:
! 1611: /* XXX: one PHY only for the internal PHY */
! 1612: if (phy != 0) {
! 1613: DPRINTFN(0xff, ("%s: %s: phy=%d is not supported\n",
! 1614: sc->sc_dev.dv_xname, __func__, phy));
! 1615: return;
! 1616: }
! 1617:
! 1618: udav_lock_mii(sc);
! 1619:
! 1620: /* select internal PHY and set PHY register address */
! 1621: udav_csr_write1(sc, UDAV_EPAR,
! 1622: UDAV_EPAR_PHY_ADR0 | (reg & UDAV_EPAR_EROA_MASK));
! 1623:
! 1624: /* put the value to the data registers */
! 1625: val[0] = data & 0xff;
! 1626: val[1] = (data >> 8) & 0xff;
! 1627: udav_csr_write(sc, UDAV_EPDRL, val, 2);
! 1628:
! 1629: /* select PHY operation and start write command */
! 1630: udav_csr_write1(sc, UDAV_EPCR, UDAV_EPCR_EPOS | UDAV_EPCR_ERPRW);
! 1631:
! 1632: /* XXX: should be wait? */
! 1633:
! 1634: /* end write command */
! 1635: UDAV_CLRBIT(sc, UDAV_EPCR, UDAV_EPCR_ERPRW);
! 1636:
! 1637: udav_unlock_mii(sc);
! 1638:
! 1639: return;
! 1640: }
! 1641:
! 1642: void
! 1643: udav_miibus_statchg(struct device *dev)
! 1644: {
! 1645: #ifdef UDAV_DEBUG
! 1646: struct udav_softc *sc;
! 1647:
! 1648: if (dev == NULL)
! 1649: return;
! 1650:
! 1651: sc = (void *)dev;
! 1652: DPRINTF(("%s: %s: enter\n", sc->sc_dev.dv_xname, __func__));
! 1653: #endif
! 1654: /* Nothing to do */
! 1655: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_udav.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb