Annotation of sys/dev/usb/ueagle.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ueagle.c,v 1.21 2007/06/14 10:11:15 mbalmer Exp $ */
! 2:
! 3: /*-
! 4: * Copyright (c) 2003-2006
! 5: * Damien Bergamini <damien.bergamini@free.fr>
! 6: *
! 7: * Permission to use, copy, modify, and distribute this software for any
! 8: * purpose with or without fee is hereby granted, provided that the above
! 9: * copyright notice and this permission notice appear in all copies.
! 10: *
! 11: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 12: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 13: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 14: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 15: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 16: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 17: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 18: */
! 19:
! 20: /*-
! 21: * Driver for Analog Devices Eagle chipset.
! 22: * http://www.analog.com/
! 23: */
! 24:
! 25: #include "bpfilter.h"
! 26:
! 27: #include <sys/param.h>
! 28: #include <sys/sysctl.h>
! 29: #include <sys/sockio.h>
! 30: #include <sys/mbuf.h>
! 31: #include <sys/kernel.h>
! 32: #include <sys/socket.h>
! 33: #include <sys/systm.h>
! 34: #include <sys/malloc.h>
! 35: #include <sys/device.h>
! 36: #include <sys/kthread.h>
! 37:
! 38: #include <net/bpf.h>
! 39: #include <net/if.h>
! 40: #include <net/if_atm.h>
! 41: #include <net/if_media.h>
! 42:
! 43: #ifdef INET
! 44: #include <netinet/in.h>
! 45: #include <netinet/if_atm.h>
! 46: #include <netinet/if_ether.h>
! 47: #endif
! 48:
! 49: #include <dev/usb/usb.h>
! 50: #include <dev/usb/usbdi.h>
! 51: #include <dev/usb/usbdi_util.h>
! 52: #include <dev/usb/ezload.h>
! 53: #include <dev/usb/usbdevs.h>
! 54:
! 55: #include <dev/usb/ueaglereg.h>
! 56: #include <dev/usb/ueaglevar.h>
! 57:
! 58: #ifdef USB_DEBUG
! 59: #define DPRINTF(x) do { if (ueagledebug > 0) printf x; } while (0)
! 60: #define DPRINTFN(n, x) do { if (ueagledebug >= (n)) printf x; } while (0)
! 61: int ueagledebug = 0;
! 62: #else
! 63: #define DPRINTF(x)
! 64: #define DPRINTFN(n, x)
! 65: #endif
! 66:
! 67: /* various supported device vendors/products */
! 68: static const struct ueagle_type {
! 69: struct usb_devno dev;
! 70: const char *fw;
! 71: } ueagle_devs[] = {
! 72: { { USB_VENDOR_ANALOG, USB_PRODUCT_ANALOG_EAGLEI }, NULL },
! 73: { { USB_VENDOR_ANALOG, USB_PRODUCT_ANALOG_EAGLEI_NF }, "ueagleI" },
! 74: { { USB_VENDOR_ANALOG, USB_PRODUCT_ANALOG_EAGLEII }, NULL },
! 75: { { USB_VENDOR_ANALOG, USB_PRODUCT_ANALOG_EAGLEII_NF }, "ueagleII" },
! 76: { { USB_VENDOR_ANALOG, USB_PRODUCT_ANALOG_EAGLEIIC }, NULL },
! 77: { { USB_VENDOR_ANALOG, USB_PRODUCT_ANALOG_EAGLEIIC_NF }, "ueagleII" },
! 78: { { USB_VENDOR_ANALOG, USB_PRODUCT_ANALOG_EAGLEIII }, NULL },
! 79: { { USB_VENDOR_ANALOG, USB_PRODUCT_ANALOG_EAGLEIII_NF }, "ueagleIII" },
! 80: { { USB_VENDOR_USR, USB_PRODUCT_USR_HEINEKEN_A }, NULL },
! 81: { { USB_VENDOR_USR, USB_PRODUCT_USR_HEINEKEN_A_NF }, "ueagleI" },
! 82: { { USB_VENDOR_USR, USB_PRODUCT_USR_HEINEKEN_B }, NULL },
! 83: { { USB_VENDOR_USR, USB_PRODUCT_USR_HEINEKEN_B_NF }, "ueagleI" },
! 84: { { USB_VENDOR_USR, USB_PRODUCT_USR_MILLER_A }, NULL },
! 85: { { USB_VENDOR_USR, USB_PRODUCT_USR_MILLER_A_NF }, "ueagleI" },
! 86: { { USB_VENDOR_USR, USB_PRODUCT_USR_MILLER_B }, NULL },
! 87: { { USB_VENDOR_USR, USB_PRODUCT_USR_MILLER_B_NF }, "ueagleI" }
! 88: };
! 89: #define ueagle_lookup(v, p) \
! 90: ((struct ueagle_type *)usb_lookup(ueagle_devs, v, p))
! 91:
! 92: void ueagle_attachhook(void *);
! 93: int ueagle_getesi(struct ueagle_softc *, uint8_t *);
! 94: void ueagle_loadpage(void *);
! 95: void ueagle_request(struct ueagle_softc *, uint16_t, uint16_t,
! 96: void *, int);
! 97: #ifdef USB_DEBUG
! 98: void ueagle_dump_cmv(struct ueagle_softc *, struct ueagle_cmv *);
! 99: #endif
! 100: int ueagle_cr(struct ueagle_softc *, uint32_t, uint16_t,
! 101: uint32_t *);
! 102: int ueagle_cw(struct ueagle_softc *, uint32_t, uint16_t, uint32_t);
! 103: int ueagle_stat(struct ueagle_softc *);
! 104: void ueagle_stat_thread(void *);
! 105: int ueagle_boot(struct ueagle_softc *);
! 106: void ueagle_swap_intr(struct ueagle_softc *, struct ueagle_swap *);
! 107: void ueagle_cmv_intr(struct ueagle_softc *, struct ueagle_cmv *);
! 108: void ueagle_intr(usbd_xfer_handle, usbd_private_handle,
! 109: usbd_status);
! 110: uint32_t ueagle_crc_update(uint32_t, uint8_t *, int);
! 111: void ueagle_push_cell(struct ueagle_softc *, uint8_t *);
! 112: void ueagle_rxeof(usbd_xfer_handle, usbd_private_handle,
! 113: usbd_status);
! 114: void ueagle_txeof(usbd_xfer_handle, usbd_private_handle,
! 115: usbd_status);
! 116: int ueagle_encap(struct ueagle_softc *, struct mbuf *);
! 117: void ueagle_start(struct ifnet *);
! 118: int ueagle_open_vcc(struct ueagle_softc *,
! 119: struct atm_pseudoioctl *);
! 120: int ueagle_close_vcc(struct ueagle_softc *,
! 121: struct atm_pseudoioctl *);
! 122: int ueagle_ioctl(struct ifnet *, u_long, caddr_t);
! 123: int ueagle_open_pipes(struct ueagle_softc *);
! 124: void ueagle_close_pipes(struct ueagle_softc *);
! 125: int ueagle_init(struct ifnet *);
! 126: void ueagle_stop(struct ifnet *, int);
! 127:
! 128: int ueagle_match(struct device *, void *, void *);
! 129: void ueagle_attach(struct device *, struct device *, void *);
! 130: int ueagle_detach(struct device *, int);
! 131: int ueagle_activate(struct device *, enum devact);
! 132:
! 133: struct cfdriver ueagle_cd = {
! 134: NULL, "ueagle", DV_DULL
! 135: };
! 136:
! 137: const struct cfattach ueagle_ca = {
! 138: sizeof(struct ueagle_softc),
! 139: ueagle_match,
! 140: ueagle_attach,
! 141: ueagle_detach,
! 142: ueagle_activate,
! 143: };
! 144:
! 145: int
! 146: ueagle_match(struct device *parent, void *match, void *aux)
! 147: {
! 148: struct usb_attach_arg *uaa = aux;
! 149:
! 150: if (uaa->iface != NULL)
! 151: return UMATCH_NONE;
! 152:
! 153: return (ueagle_lookup(uaa->vendor, uaa->product) != NULL) ?
! 154: UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
! 155: }
! 156:
! 157: void
! 158: ueagle_attachhook(void *xsc)
! 159: {
! 160: char *firmwares[2];
! 161: struct ueagle_softc *sc = xsc;
! 162:
! 163: firmwares[0] = (char *)sc->fw;
! 164: firmwares[1] = NULL;
! 165:
! 166: if (ezload_downloads_and_reset(sc->sc_udev, firmwares) != 0) {
! 167: printf("%s: could not download firmware\n",
! 168: sc->sc_dev.dv_xname);
! 169: return;
! 170: }
! 171: }
! 172:
! 173: void
! 174: ueagle_attach(struct device *parent, struct device *self, void *aux)
! 175: {
! 176: struct ueagle_softc *sc = (struct ueagle_softc *)self;
! 177: struct usb_attach_arg *uaa = aux;
! 178: struct ifnet *ifp = &sc->sc_if;
! 179: char *devinfop;
! 180: uint8_t addr[ETHER_ADDR_LEN];
! 181:
! 182: sc->sc_udev = uaa->device;
! 183: printf("\n");
! 184:
! 185: /*
! 186: * Pre-firmware modems must be flashed and reset first. They will
! 187: * automatically detach themselves from the bus and reattach later
! 188: * with a new product Id.
! 189: */
! 190: sc->fw = ueagle_lookup(uaa->vendor, uaa->product)->fw;
! 191: if (sc->fw != NULL) {
! 192: if (rootvp == NULL)
! 193: mountroothook_establish(ueagle_attachhook, sc);
! 194: else
! 195: ueagle_attachhook(sc);
! 196:
! 197: /* processing of pre-firmware modems ends here */
! 198: return;
! 199: }
! 200:
! 201: devinfop = usbd_devinfo_alloc(sc->sc_udev, 0);
! 202: printf("%s: %s\n", sc->sc_dev.dv_xname, devinfop);
! 203: usbd_devinfo_free(devinfop);
! 204:
! 205: if (usbd_set_config_no(sc->sc_udev, UEAGLE_CONFIG_NO, 0) != 0) {
! 206: printf("%s: could not set configuration no\n",
! 207: sc->sc_dev.dv_xname);
! 208: return;
! 209: }
! 210:
! 211: if (ueagle_getesi(sc, addr) != 0) {
! 212: printf("%s: could not read end system identifier\n",
! 213: sc->sc_dev.dv_xname);
! 214: return;
! 215: }
! 216:
! 217: printf("%s: address: %02x:%02x:%02x:%02x:%02x:%02x\n",
! 218: sc->sc_dev.dv_xname, addr[0], addr[1], addr[2], addr[3],
! 219: addr[4], addr[5]);
! 220:
! 221: usb_init_task(&sc->sc_swap_task, ueagle_loadpage, sc);
! 222:
! 223: ifp->if_softc = sc;
! 224: ifp->if_flags = IFF_SIMPLEX;
! 225: ifp->if_init = ueagle_init;
! 226: ifp->if_ioctl = ueagle_ioctl;
! 227: ifp->if_start = ueagle_start;
! 228: IFQ_SET_READY(&ifp->if_snd);
! 229: memcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);
! 230:
! 231: if_attach(ifp);
! 232: atm_ifattach(ifp);
! 233:
! 234: /* override default MTU value (9180 is too large for us) */
! 235: ifp->if_mtu = UEAGLE_IFMTU;
! 236:
! 237: #if NBPFILTER > 0
! 238: bpfattach(&ifp->if_bpf, ifp, DLT_RAW, 0);
! 239: #endif
! 240:
! 241: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
! 242: &sc->sc_dev);
! 243: }
! 244:
! 245: int
! 246: ueagle_detach(struct device *self, int flags)
! 247: {
! 248: struct ueagle_softc *sc = (struct ueagle_softc *)self;
! 249: struct ifnet *ifp = &sc->sc_if;
! 250:
! 251: if (sc->fw != NULL)
! 252: return 0; /* shortcut for pre-firmware devices */
! 253:
! 254: sc->gone = 1;
! 255: ueagle_stop(ifp, 1);
! 256:
! 257: /* wait for stat thread to exit properly */
! 258: if (sc->stat_thread != NULL) {
! 259: DPRINTFN(3, ("%s: waiting for stat thread to exit\n",
! 260: sc->sc_dev.dv_xname));
! 261:
! 262: tsleep(sc->stat_thread, PZERO, "ueaglestat", 0);
! 263:
! 264: DPRINTFN(3, ("%s: stat thread exited properly\n",
! 265: sc->sc_dev.dv_xname));
! 266: }
! 267:
! 268: if_detach(ifp);
! 269:
! 270: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
! 271: &sc->sc_dev);
! 272:
! 273: return 0;
! 274: }
! 275:
! 276: /*
! 277: * Retrieve the device End System Identifier (MAC address).
! 278: */
! 279: int
! 280: ueagle_getesi(struct ueagle_softc *sc, uint8_t *addr)
! 281: {
! 282: usb_string_descriptor_t us;
! 283: usbd_status error;
! 284: uint16_t c;
! 285: int i, len;
! 286:
! 287: error = usbd_get_string_desc(sc->sc_udev, UEAGLE_ESISTR, 0, &us, &len);
! 288: if (error != 0)
! 289: return error;
! 290:
! 291: if (us.bLength < (6 + 1) * 2)
! 292: return 1;
! 293:
! 294: for (i = 0; i < 6 * 2; i++) {
! 295: if ((c = UGETW(us.bString[i])) & 0xff00)
! 296: return 1; /* not 8-bit clean */
! 297:
! 298: if (i & 1)
! 299: addr[i / 2] <<= 4;
! 300: else
! 301: addr[i / 2] = 0;
! 302:
! 303: if (c >= '0' && c <= '9')
! 304: addr[i / 2] |= c - '0';
! 305: else if (c >= 'a' && c <= 'f')
! 306: addr[i / 2] |= c - 'a' + 10;
! 307: else if (c >= 'A' && c <= 'F')
! 308: addr[i / 2] |= c - 'A' + 10;
! 309: else
! 310: return 1;
! 311: }
! 312:
! 313: return 0;
! 314: }
! 315:
! 316: void
! 317: ueagle_loadpage(void *xsc)
! 318: {
! 319: struct ueagle_softc *sc = xsc;
! 320: usbd_xfer_handle xfer;
! 321: struct ueagle_block_info bi;
! 322: uint16_t pageno = sc->pageno;
! 323: uint16_t ovl = sc->ovl;
! 324: uint8_t pagecount, blockcount;
! 325: uint16_t blockaddr, blocksize;
! 326: uint32_t pageoffset;
! 327: uint8_t *p;
! 328: int i;
! 329:
! 330: p = sc->dsp;
! 331: pagecount = *p++;
! 332:
! 333: if (pageno >= pagecount) {
! 334: printf("%s: invalid page number %u requested\n",
! 335: sc->sc_dev.dv_xname, pageno);
! 336: return;
! 337: }
! 338:
! 339: p += 4 * pageno;
! 340: pageoffset = UGETDW(p);
! 341: if (pageoffset == 0)
! 342: return;
! 343:
! 344: p = sc->dsp + pageoffset;
! 345: blockcount = *p++;
! 346:
! 347: DPRINTF(("%s: sending %u blocks for fw page %u\n",
! 348: sc->sc_dev.dv_xname, blockcount, pageno));
! 349:
! 350: if ((xfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) {
! 351: printf("%s: could not allocate xfer\n",
! 352: sc->sc_dev.dv_xname);
! 353: return;
! 354: }
! 355:
! 356: USETW(bi.wHdr, UEAGLE_BLOCK_INFO_HDR);
! 357: USETW(bi.wOvl, ovl);
! 358: USETW(bi.wOvlOffset, ovl | 0x8000);
! 359:
! 360: for (i = 0; i < blockcount; i++) {
! 361: blockaddr = UGETW(p); p += 2;
! 362: blocksize = UGETW(p); p += 2;
! 363:
! 364: USETW(bi.wSize, blocksize);
! 365: USETW(bi.wAddress, blockaddr);
! 366: USETW(bi.wLast, (i == blockcount - 1) ? 1 : 0);
! 367:
! 368: /* send block info through the IDMA pipe */
! 369: usbd_setup_xfer(xfer, sc->pipeh_idma, sc, &bi, sizeof bi, 0,
! 370: UEAGLE_IDMA_TIMEOUT, NULL);
! 371: if (usbd_sync_transfer(xfer) != 0) {
! 372: printf("%s: could not transfer block info\n",
! 373: sc->sc_dev.dv_xname);
! 374: break;
! 375: }
! 376:
! 377: /* send block data through the IDMA pipe */
! 378: usbd_setup_xfer(xfer, sc->pipeh_idma, sc, p, blocksize, 0,
! 379: UEAGLE_IDMA_TIMEOUT, NULL);
! 380: if (usbd_sync_transfer(xfer) != 0) {
! 381: printf("%s: could not transfer block data\n",
! 382: sc->sc_dev.dv_xname);
! 383: break;
! 384: }
! 385:
! 386: p += blocksize;
! 387: }
! 388:
! 389: usbd_free_xfer(xfer);
! 390: }
! 391:
! 392: void
! 393: ueagle_request(struct ueagle_softc *sc, uint16_t val, uint16_t index,
! 394: void *data, int len)
! 395: {
! 396: usb_device_request_t req;
! 397: usbd_status error;
! 398:
! 399: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
! 400: req.bRequest = UEAGLE_REQUEST;
! 401: USETW(req.wValue, val);
! 402: USETW(req.wIndex, index);
! 403: USETW(req.wLength, len);
! 404:
! 405: error = usbd_do_request_async(sc->sc_udev, &req, data);
! 406: if (error != USBD_NORMAL_COMPLETION && error != USBD_IN_PROGRESS)
! 407: printf("%s: could not send request\n", sc->sc_dev.dv_xname);
! 408: }
! 409:
! 410: #ifdef USB_DEBUG
! 411: void
! 412: ueagle_dump_cmv(struct ueagle_softc *sc, struct ueagle_cmv *cmv)
! 413: {
! 414: printf(" Preamble: 0x%04x\n", UGETW(cmv->wPreamble));
! 415: printf(" Destination: %s (0x%02x)\n",
! 416: (cmv->bDst == UEAGLE_HOST) ? "Host" : "Modem", cmv->bDst);
! 417: printf(" Type: %u\n", cmv->bFunction >> 4);
! 418: printf(" Subtype: %u\n", cmv->bFunction & 0xf);
! 419: printf(" Index: %u\n", UGETW(cmv->wIndex));
! 420: printf(" Address: %c%c%c%c.%u\n",
! 421: cmv->dwSymbolicAddress[1], cmv->dwSymbolicAddress[0],
! 422: cmv->dwSymbolicAddress[3], cmv->dwSymbolicAddress[2],
! 423: UGETW(cmv->wOffsetAddress));
! 424: printf(" Data: 0x%08x\n", UGETDATA(cmv->dwData));
! 425: }
! 426: #endif
! 427:
! 428: int
! 429: ueagle_cr(struct ueagle_softc *sc, uint32_t address, uint16_t offset,
! 430: uint32_t *data)
! 431: {
! 432: struct ueagle_cmv cmv;
! 433: usbd_status error;
! 434: int s;
! 435:
! 436: USETW(cmv.wPreamble, UEAGLE_CMV_PREAMBLE);
! 437: cmv.bDst = UEAGLE_MODEM;
! 438: cmv.bFunction = UEAGLE_CR;
! 439: USETW(cmv.wIndex, sc->index);
! 440: USETW(cmv.wOffsetAddress, offset);
! 441: USETDW(cmv.dwSymbolicAddress, address);
! 442: USETDATA(cmv.dwData, 0);
! 443:
! 444: #ifdef USB_DEBUG
! 445: if (ueagledebug >= 15) {
! 446: printf("%s: reading CMV\n", sc->sc_dev.dv_xname);
! 447: ueagle_dump_cmv(sc, &cmv);
! 448: }
! 449: #endif
! 450:
! 451: s = splusb();
! 452:
! 453: ueagle_request(sc, UEAGLE_SETBLOCK, UEAGLE_MPTXSTART, &cmv, sizeof cmv);
! 454:
! 455: /* wait at most 2 seconds for an answer */
! 456: error = tsleep(UEAGLE_COND_CMV(sc), PZERO, "cmv", 2 * hz);
! 457: if (error != 0) {
! 458: printf("%s: timeout waiting for CMV ack\n",
! 459: sc->sc_dev.dv_xname);
! 460: splx(s);
! 461: return error;
! 462: }
! 463:
! 464: *data = sc->data;
! 465: splx(s);
! 466:
! 467: return 0;
! 468: }
! 469:
! 470: int
! 471: ueagle_cw(struct ueagle_softc *sc, uint32_t address, uint16_t offset,
! 472: uint32_t data)
! 473: {
! 474: struct ueagle_cmv cmv;
! 475: usbd_status error;
! 476: int s;
! 477:
! 478: USETW(cmv.wPreamble, UEAGLE_CMV_PREAMBLE);
! 479: cmv.bDst = UEAGLE_MODEM;
! 480: cmv.bFunction = UEAGLE_CW;
! 481: USETW(cmv.wIndex, sc->index);
! 482: USETW(cmv.wOffsetAddress, offset);
! 483: USETDW(cmv.dwSymbolicAddress, address);
! 484: USETDATA(cmv.dwData, data);
! 485:
! 486: #ifdef USB_DEBUG
! 487: if (ueagledebug >= 15) {
! 488: printf("%s: writing CMV\n", sc->sc_dev.dv_xname);
! 489: ueagle_dump_cmv(sc, &cmv);
! 490: }
! 491: #endif
! 492:
! 493: s = splusb();
! 494:
! 495: ueagle_request(sc, UEAGLE_SETBLOCK, UEAGLE_MPTXSTART, &cmv, sizeof cmv);
! 496:
! 497: /* wait at most 2 seconds for an answer */
! 498: error = tsleep(UEAGLE_COND_CMV(sc), PZERO, "cmv", 2 * hz);
! 499: if (error != 0) {
! 500: printf("%s: timeout waiting for CMV ack\n",
! 501: sc->sc_dev.dv_xname);
! 502: splx(s);
! 503: return error;
! 504: }
! 505:
! 506: splx(s);
! 507:
! 508: return 0;
! 509: }
! 510:
! 511: int
! 512: ueagle_stat(struct ueagle_softc *sc)
! 513: {
! 514: struct ifnet *ifp = &sc->sc_if;
! 515: uint32_t data;
! 516: usbd_status error;
! 517: #define CR(sc, address, offset, data) do { \
! 518: if ((error = ueagle_cr(sc, address, offset, data)) != 0) \
! 519: return error; \
! 520: } while (0)
! 521:
! 522: CR(sc, UEAGLE_CMV_STAT, 0, &sc->stats.phy.status);
! 523: switch ((sc->stats.phy.status >> 8) & 0xf) {
! 524: case 0: /* idle */
! 525: DPRINTFN(3, ("%s: waiting for synchronization\n",
! 526: sc->sc_dev.dv_xname));
! 527: return ueagle_cw(sc, UEAGLE_CMV_CNTL, 0, 2);
! 528:
! 529: case 1: /* initialization */
! 530: DPRINTFN(3, ("%s: initializing\n", sc->sc_dev.dv_xname));
! 531: return ueagle_cw(sc, UEAGLE_CMV_CNTL, 0, 2);
! 532:
! 533: case 2: /* operational */
! 534: DPRINTFN(4, ("%s: operational\n", sc->sc_dev.dv_xname));
! 535: break;
! 536:
! 537: default: /* fail ... */
! 538: DPRINTFN(3, ("%s: synchronization failed\n",
! 539: sc->sc_dev.dv_xname));
! 540: ueagle_init(ifp);
! 541: return 1;
! 542: }
! 543:
! 544: CR(sc, UEAGLE_CMV_DIAG, 1, &sc->stats.phy.flags);
! 545: if (sc->stats.phy.flags & 0x10) {
! 546: DPRINTF(("%s: delineation LOSS\n", sc->sc_dev.dv_xname));
! 547: sc->stats.phy.status = 0;
! 548: ueagle_init(ifp);
! 549: return 1;
! 550: }
! 551:
! 552: CR(sc, UEAGLE_CMV_RATE, 0, &data);
! 553: sc->stats.phy.dsrate = ((data >> 16) & 0x1ff) * 32;
! 554: sc->stats.phy.usrate = (data & 0xff) * 32;
! 555:
! 556: CR(sc, UEAGLE_CMV_DIAG, 23, &data);
! 557: sc->stats.phy.attenuation = (data & 0xff) / 2;
! 558:
! 559: CR(sc, UEAGLE_CMV_DIAG, 3, &sc->stats.atm.cells_crc_errors);
! 560: CR(sc, UEAGLE_CMV_DIAG, 22, &sc->stats.phy.dserror);
! 561: CR(sc, UEAGLE_CMV_DIAG, 25, &sc->stats.phy.dsmargin);
! 562: CR(sc, UEAGLE_CMV_DIAG, 46, &sc->stats.phy.userror);
! 563: CR(sc, UEAGLE_CMV_DIAG, 49, &sc->stats.phy.usmargin);
! 564: CR(sc, UEAGLE_CMV_DIAG, 51, &sc->stats.phy.rxflow);
! 565: CR(sc, UEAGLE_CMV_DIAG, 52, &sc->stats.phy.txflow);
! 566: CR(sc, UEAGLE_CMV_DIAG, 54, &sc->stats.phy.dsunc);
! 567: CR(sc, UEAGLE_CMV_DIAG, 58, &sc->stats.phy.usunc);
! 568: CR(sc, UEAGLE_CMV_INFO, 8, &sc->stats.phy.vidco);
! 569: CR(sc, UEAGLE_CMV_INFO, 14, &sc->stats.phy.vidcpe);
! 570:
! 571: if (sc->pipeh_tx != NULL)
! 572: return 0;
! 573:
! 574: return ueagle_open_pipes(sc);
! 575: #undef CR
! 576: }
! 577:
! 578: void
! 579: ueagle_stat_thread(void *arg)
! 580: {
! 581: struct ueagle_softc *sc = arg;
! 582:
! 583: for (;;) {
! 584: if (ueagle_stat(sc) != 0)
! 585: break;
! 586:
! 587: usbd_delay_ms(sc->sc_udev, 5000);
! 588: }
! 589:
! 590: wakeup(sc->stat_thread);
! 591:
! 592: kthread_exit(0);
! 593: }
! 594:
! 595: int
! 596: ueagle_boot(struct ueagle_softc *sc)
! 597: {
! 598: uint16_t zero = 0; /* ;-) */
! 599: usbd_status error;
! 600: #define CW(sc, address, offset, data) do { \
! 601: if ((error = ueagle_cw(sc, address, offset, data)) != 0) \
! 602: return error; \
! 603: } while (0)
! 604:
! 605: ueagle_request(sc, UEAGLE_SETMODE, UEAGLE_BOOTIDMA, NULL, 0);
! 606: ueagle_request(sc, UEAGLE_SETMODE, UEAGLE_STARTRESET, NULL, 0);
! 607:
! 608: usbd_delay_ms(sc->sc_udev, 200);
! 609:
! 610: ueagle_request(sc, UEAGLE_SETMODE, UEAGLE_ENDRESET, NULL, 0);
! 611: ueagle_request(sc, UEAGLE_SET2183DATA, UEAGLE_MPTXMAILBOX, &zero, 2);
! 612: ueagle_request(sc, UEAGLE_SET2183DATA, UEAGLE_MPRXMAILBOX, &zero, 2);
! 613: ueagle_request(sc, UEAGLE_SET2183DATA, UEAGLE_SWAPMAILBOX, &zero, 2);
! 614:
! 615: usbd_delay_ms(sc->sc_udev, 1000);
! 616:
! 617: sc->pageno = 0;
! 618: sc->ovl = 0;
! 619: ueagle_loadpage(sc);
! 620:
! 621: /* wait until modem reaches operationnal state */
! 622: error = tsleep(UEAGLE_COND_READY(sc), PZERO | PCATCH, "boot", 10 * hz);
! 623: if (error != 0) {
! 624: printf("%s: timeout waiting for operationnal state\n",
! 625: sc->sc_dev.dv_xname);
! 626: return error;
! 627: }
! 628:
! 629: CW(sc, UEAGLE_CMV_CNTL, 0, 1);
! 630:
! 631: /* send configuration options */
! 632: CW(sc, UEAGLE_CMV_OPTN, 0, UEAGLE_OPTN0);
! 633: CW(sc, UEAGLE_CMV_OPTN, 2, UEAGLE_OPTN2);
! 634: CW(sc, UEAGLE_CMV_OPTN, 7, UEAGLE_OPTN7);
! 635:
! 636: /* continue with synchronization */
! 637: CW(sc, UEAGLE_CMV_CNTL, 0, 2);
! 638:
! 639: return kthread_create(ueagle_stat_thread, sc, &sc->stat_thread,
! 640: sc->sc_dev.dv_xname);
! 641: #undef CW
! 642: }
! 643:
! 644: void
! 645: ueagle_swap_intr(struct ueagle_softc *sc, struct ueagle_swap *swap)
! 646: {
! 647: #define rotbr(v, n) ((v) >> (n) | (v) << (8 - (n)))
! 648: sc->pageno = swap->bPageNo;
! 649: sc->ovl = rotbr(swap->bOvl, 4);
! 650:
! 651: usb_add_task(sc->sc_udev, &sc->sc_swap_task);
! 652: #undef rotbr
! 653: }
! 654:
! 655: /*
! 656: * This function handles spontaneous CMVs and CMV acknowledgements sent by the
! 657: * modem on the interrupt pipe.
! 658: */
! 659: void
! 660: ueagle_cmv_intr(struct ueagle_softc *sc, struct ueagle_cmv *cmv)
! 661: {
! 662: #ifdef USB_DEBUG
! 663: if (ueagledebug >= 15) {
! 664: printf("%s: receiving CMV\n", sc->sc_dev.dv_xname);
! 665: ueagle_dump_cmv(sc, cmv);
! 666: }
! 667: #endif
! 668:
! 669: if (UGETW(cmv->wPreamble) != UEAGLE_CMV_PREAMBLE) {
! 670: printf("%s: received CMV with invalid preamble\n",
! 671: sc->sc_dev.dv_xname);
! 672: return;
! 673: }
! 674:
! 675: if (cmv->bDst != UEAGLE_HOST) {
! 676: printf("%s: received CMV with bad direction\n",
! 677: sc->sc_dev.dv_xname);
! 678: return;
! 679: }
! 680:
! 681: /* synchronize our current CMV index with the modem */
! 682: sc->index = UGETW(cmv->wIndex) + 1;
! 683:
! 684: switch (cmv->bFunction) {
! 685: case UEAGLE_MODEMREADY:
! 686: wakeup(UEAGLE_COND_READY(sc));
! 687: break;
! 688:
! 689: case UEAGLE_CR_ACK:
! 690: sc->data = UGETDATA(cmv->dwData);
! 691: /* FALLTHROUGH */
! 692: case UEAGLE_CW_ACK:
! 693: wakeup(UEAGLE_COND_CMV(sc));
! 694: break;
! 695: }
! 696: }
! 697:
! 698: void
! 699: ueagle_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
! 700: {
! 701: struct ueagle_softc *sc = priv;
! 702: struct ueagle_intr *intr;
! 703:
! 704: if (status != USBD_NORMAL_COMPLETION) {
! 705: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
! 706: return;
! 707:
! 708: printf("%s: abnormal interrupt status: %s\n",
! 709: sc->sc_dev.dv_xname, usbd_errstr(status));
! 710:
! 711: if (status == USBD_STALLED)
! 712: usbd_clear_endpoint_stall_async(sc->pipeh_intr);
! 713:
! 714: return;
! 715: }
! 716:
! 717: intr = (struct ueagle_intr *)sc->ibuf;
! 718: switch (UGETW(intr->wInterrupt)) {
! 719: case UEAGLE_INTR_SWAP:
! 720: ueagle_swap_intr(sc, (struct ueagle_swap *)(intr + 1));
! 721: break;
! 722:
! 723: case UEAGLE_INTR_CMV:
! 724: ueagle_cmv_intr(sc, (struct ueagle_cmv *)(intr + 1));
! 725: break;
! 726:
! 727: default:
! 728: printf("%s: caught unknown interrupt\n",
! 729: sc->sc_dev.dv_xname);
! 730: }
! 731: }
! 732:
! 733: static const uint32_t ueagle_crc32_table[256] = {
! 734: 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc,
! 735: 0x17c56b6b, 0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f,
! 736: 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a,
! 737: 0x384fbdbd, 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
! 738: 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 0x6a1936c8,
! 739: 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3,
! 740: 0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e,
! 741: 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
! 742: 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84,
! 743: 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 0xd4326d90, 0xd0f37027,
! 744: 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022,
! 745: 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
! 746: 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077,
! 747: 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c,
! 748: 0x2e003dc5, 0x2ac12072, 0x128e9dcf, 0x164f8078, 0x1b0ca6a1,
! 749: 0x1fcdbb16, 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
! 750: 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb,
! 751: 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08,
! 752: 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d,
! 753: 0x40d816ba, 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
! 754: 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 0x8aad2b2f,
! 755: 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044,
! 756: 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050, 0xe9362689,
! 757: 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
! 758: 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683,
! 759: 0xd1799b34, 0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59,
! 760: 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c,
! 761: 0x774bb0eb, 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
! 762: 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, 0x251d3b9e,
! 763: 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5,
! 764: 0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48,
! 765: 0x0e56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
! 766: 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2,
! 767: 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 0xd727bbb6, 0xd3e6a601,
! 768: 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604,
! 769: 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
! 770: 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6,
! 771: 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad,
! 772: 0x81b02d74, 0x857130c3, 0x5d8a9099, 0x594b8d2e, 0x5408abf7,
! 773: 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
! 774: 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd,
! 775: 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e,
! 776: 0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b,
! 777: 0x0fdc1bec, 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
! 778: 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 0xc5a92679,
! 779: 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12,
! 780: 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676, 0xea23f0af,
! 781: 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
! 782: 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5,
! 783: 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06,
! 784: 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03,
! 785: 0xb1f740b4
! 786: };
! 787:
! 788: uint32_t
! 789: ueagle_crc_update(uint32_t crc, uint8_t *buf, int len)
! 790: {
! 791: for (; len != 0; len--, buf++)
! 792: crc = ueagle_crc32_table[(crc >> 24) ^ *buf] ^ (crc << 8);
! 793:
! 794: return crc;
! 795: }
! 796:
! 797: /*
! 798: * Reassembly part of the software ATM AAL5 SAR.
! 799: */
! 800: void
! 801: ueagle_push_cell(struct ueagle_softc *sc, uint8_t *cell)
! 802: {
! 803: struct ueagle_vcc *vcc = &sc->vcc;
! 804: struct ifnet *ifp;
! 805: struct mbuf *m;
! 806: uint32_t crc;
! 807: uint16_t pdulen, totlen;
! 808: int s;
! 809:
! 810: sc->stats.atm.cells_received++;
! 811:
! 812: if (!(vcc->flags & UEAGLE_VCC_ACTIVE) ||
! 813: ATM_CH_GETVPI(cell) != vcc->vpi ||
! 814: ATM_CH_GETVCI(cell) != vcc->vci) {
! 815: sc->stats.atm.vcc_no_conn++;
! 816: return;
! 817: }
! 818:
! 819: if (vcc->flags & UEAGLE_VCC_DROP) {
! 820: if (ATM_CH_ISLASTCELL(cell)) {
! 821: vcc->flags &= ~UEAGLE_VCC_DROP;
! 822: sc->stats.atm.cspdus_dropped++;
! 823: }
! 824:
! 825: sc->stats.atm.cells_dropped++;
! 826: return;
! 827: }
! 828:
! 829: if (vcc->m == NULL) {
! 830: MGETHDR(m, M_DONTWAIT, MT_DATA);
! 831: if (m == NULL) {
! 832: vcc->flags |= UEAGLE_VCC_DROP;
! 833: return;
! 834: }
! 835:
! 836: MCLGET(m, M_DONTWAIT);
! 837: if (!(m->m_flags & M_EXT)) {
! 838: vcc->flags |= UEAGLE_VCC_DROP;
! 839: m_freem(m);
! 840: return;
! 841: }
! 842:
! 843: vcc->m = m;
! 844: vcc->dst = mtod(m, uint8_t *);
! 845: vcc->limit = vcc->dst + MCLBYTES - ATM_CELL_PAYLOAD_SIZE;
! 846: }
! 847:
! 848: if (vcc->dst > vcc->limit) {
! 849: vcc->flags |= UEAGLE_VCC_DROP;
! 850: sc->stats.atm.cells_dropped++;
! 851: goto fail;
! 852: }
! 853:
! 854: memcpy(vcc->dst, cell + ATM_CELL_HEADER_SIZE, ATM_CELL_PAYLOAD_SIZE);
! 855: vcc->dst += ATM_CELL_PAYLOAD_SIZE;
! 856:
! 857: if (!ATM_CH_ISLASTCELL(cell))
! 858: return;
! 859:
! 860: /*
! 861: * Handle the last cell of the AAL5 CPCS-PDU.
! 862: */
! 863: m = vcc->m;
! 864:
! 865: totlen = vcc->dst - mtod(m, uint8_t *);
! 866: pdulen = AAL5_TR_GETPDULEN(cell);
! 867:
! 868: if (totlen < pdulen + AAL5_TRAILER_SIZE) {
! 869: sc->stats.atm.cspdus_dropped++;
! 870: goto fail;
! 871: }
! 872:
! 873: if (totlen >= pdulen + ATM_CELL_PAYLOAD_SIZE + AAL5_TRAILER_SIZE) {
! 874: sc->stats.atm.cspdus_dropped++;
! 875: goto fail;
! 876: }
! 877:
! 878: crc = ueagle_crc_update(CRC_INITIAL, mtod(m, uint8_t *), totlen);
! 879: if (crc != CRC_MAGIC) {
! 880: sc->stats.atm.cspdus_crc_errors++;
! 881: goto fail;
! 882: }
! 883:
! 884: /* finalize mbuf */
! 885: ifp = &sc->sc_if;
! 886: m->m_pkthdr.rcvif = ifp;
! 887: m->m_pkthdr.len = m->m_len = pdulen;
! 888:
! 889: sc->stats.atm.cspdus_received++;
! 890:
! 891: s = splnet();
! 892:
! 893: #if NBPFILTER > 0
! 894: if (ifp->if_bpf != NULL)
! 895: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
! 896: #endif
! 897:
! 898: /* send the AAL5 CPCS-PDU to the ATM layer */
! 899: ifp->if_ipackets++;
! 900: atm_input(ifp, &vcc->aph, m, vcc->rxhand);
! 901: vcc->m = NULL;
! 902:
! 903: splx(s);
! 904:
! 905: return;
! 906:
! 907: fail: m_freem(vcc->m);
! 908: vcc->m = NULL;
! 909: }
! 910:
! 911: void
! 912: ueagle_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv,
! 913: usbd_status status)
! 914: {
! 915: struct ueagle_isoreq *req = priv;
! 916: struct ueagle_softc *sc = req->sc;
! 917: uint32_t count;
! 918: uint8_t *p;
! 919: int i;
! 920:
! 921: if (status == USBD_CANCELLED)
! 922: return;
! 923:
! 924: for (i = 0; i < UEAGLE_NISOFRMS; i++) {
! 925: count = req->frlengths[i];
! 926: p = req->offsets[i];
! 927:
! 928: while (count >= ATM_CELL_SIZE) {
! 929: ueagle_push_cell(sc, p);
! 930: p += ATM_CELL_SIZE;
! 931: count -= ATM_CELL_SIZE;
! 932: }
! 933: #ifdef DIAGNOSTIC
! 934: if (count > 0) {
! 935: printf("%s: truncated cell (%u bytes)\n",
! 936: sc->sc_dev.dv_xname, count);
! 937: }
! 938: #endif
! 939: req->frlengths[i] = sc->isize;
! 940: }
! 941:
! 942: usbd_setup_isoc_xfer(req->xfer, sc->pipeh_rx, req, req->frlengths,
! 943: UEAGLE_NISOFRMS, USBD_NO_COPY, ueagle_rxeof);
! 944: usbd_transfer(xfer);
! 945: }
! 946:
! 947: void
! 948: ueagle_txeof(usbd_xfer_handle xfer, usbd_private_handle priv,
! 949: usbd_status status)
! 950: {
! 951: struct ueagle_txreq *req = priv;
! 952: struct ueagle_softc *sc = req->sc;
! 953: struct ifnet *ifp = &sc->sc_if;
! 954: int s;
! 955:
! 956: if (status != USBD_NORMAL_COMPLETION) {
! 957: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
! 958: return;
! 959:
! 960: printf("%s: could not transmit buffer: %s\n",
! 961: sc->sc_dev.dv_xname, usbd_errstr(status));
! 962:
! 963: if (status == USBD_STALLED)
! 964: usbd_clear_endpoint_stall_async(sc->pipeh_tx);
! 965:
! 966: ifp->if_oerrors++;
! 967: return;
! 968: }
! 969:
! 970: s = splnet();
! 971:
! 972: ifp->if_opackets++;
! 973: ifp->if_flags &= ~IFF_OACTIVE;
! 974: ueagle_start(ifp);
! 975:
! 976: splx(s);
! 977: }
! 978:
! 979: /*
! 980: * Segmentation part of the software ATM AAL5 SAR.
! 981: */
! 982: int
! 983: ueagle_encap(struct ueagle_softc *sc, struct mbuf *m0)
! 984: {
! 985: struct ueagle_vcc *vcc = &sc->vcc;
! 986: struct ueagle_txreq *req;
! 987: struct mbuf *m;
! 988: uint8_t *src, *dst;
! 989: uint32_t crc;
! 990: int n, cellleft, mleft;
! 991: usbd_status error;
! 992:
! 993: req = &sc->txreqs[0];
! 994:
! 995: m_adj(m0, sizeof (struct atm_pseudohdr));
! 996:
! 997: dst = req->buf;
! 998: cellleft = 0;
! 999: crc = CRC_INITIAL;
! 1000:
! 1001: for (m = m0; m != NULL; m = m->m_next) {
! 1002: src = mtod(m, uint8_t *);
! 1003: mleft = m->m_len;
! 1004:
! 1005: crc = ueagle_crc_update(crc, src, mleft);
! 1006:
! 1007: if (cellleft != 0) {
! 1008: n = min(mleft, cellleft);
! 1009:
! 1010: memcpy(dst, src, n);
! 1011: dst += n;
! 1012: src += n;
! 1013: cellleft -= n;
! 1014: mleft -= n;
! 1015: }
! 1016:
! 1017: while (mleft >= ATM_CELL_PAYLOAD_SIZE) {
! 1018: memcpy(dst, vcc->ch, ATM_CELL_HEADER_SIZE);
! 1019: dst += ATM_CELL_HEADER_SIZE;
! 1020: memcpy(dst, src, ATM_CELL_PAYLOAD_SIZE);
! 1021: dst += ATM_CELL_PAYLOAD_SIZE;
! 1022: src += ATM_CELL_PAYLOAD_SIZE;
! 1023: mleft -= ATM_CELL_PAYLOAD_SIZE;
! 1024: sc->stats.atm.cells_transmitted++;
! 1025: }
! 1026:
! 1027: if (mleft != 0) {
! 1028: memcpy(dst, vcc->ch, ATM_CELL_HEADER_SIZE);
! 1029: dst += ATM_CELL_HEADER_SIZE;
! 1030: memcpy(dst, src, mleft);
! 1031: dst += mleft;
! 1032: cellleft = ATM_CELL_PAYLOAD_SIZE - mleft;
! 1033: sc->stats.atm.cells_transmitted++;
! 1034: }
! 1035: }
! 1036:
! 1037: /*
! 1038: * If there is not enough space to put the AAL5 trailer into this cell,
! 1039: * pad the content of this cell with zeros and create a new cell which
! 1040: * will contain no data except the AAL5 trailer itself.
! 1041: */
! 1042: if (cellleft < AAL5_TRAILER_SIZE) {
! 1043: memset(dst, 0, cellleft);
! 1044: crc = ueagle_crc_update(crc, dst, cellleft);
! 1045: dst += cellleft;
! 1046:
! 1047: memcpy(dst, vcc->ch, ATM_CELL_HEADER_SIZE);
! 1048: dst += ATM_CELL_HEADER_SIZE;
! 1049: cellleft = ATM_CELL_PAYLOAD_SIZE;
! 1050: sc->stats.atm.cells_transmitted++;
! 1051: }
! 1052:
! 1053: /*
! 1054: * Fill the AAL5 CPCS-PDU trailer.
! 1055: */
! 1056: memset(dst, 0, cellleft - AAL5_TRAILER_SIZE);
! 1057:
! 1058: /* src now points to the beginning of the last cell */
! 1059: src = dst + cellleft - ATM_CELL_SIZE;
! 1060: ATM_CH_SETPTFLAGS(src, 1);
! 1061:
! 1062: AAL5_TR_SETCPSUU(src, 0);
! 1063: AAL5_TR_SETCPI(src, 0);
! 1064: AAL5_TR_SETPDULEN(src, m0->m_pkthdr.len);
! 1065:
! 1066: crc = ~ueagle_crc_update(crc, dst, cellleft - 4);
! 1067: AAL5_TR_SETCRC(src, crc);
! 1068:
! 1069: usbd_setup_xfer(req->xfer, sc->pipeh_tx, req, req->buf,
! 1070: dst + cellleft - req->buf, USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
! 1071: UEAGLE_TX_TIMEOUT, ueagle_txeof);
! 1072:
! 1073: error = usbd_transfer(req->xfer);
! 1074: if (error != USBD_NORMAL_COMPLETION && error != USBD_IN_PROGRESS)
! 1075: return error;
! 1076:
! 1077: sc->stats.atm.cspdus_transmitted++;
! 1078:
! 1079: return 0;
! 1080: }
! 1081:
! 1082: void
! 1083: ueagle_start(struct ifnet *ifp)
! 1084: {
! 1085: struct ueagle_softc *sc = ifp->if_softc;
! 1086: struct mbuf *m0;
! 1087:
! 1088: /* nothing goes out until modem is synchronized and VCC is opened */
! 1089: if (!(sc->vcc.flags & UEAGLE_VCC_ACTIVE))
! 1090: return;
! 1091:
! 1092: if (sc->pipeh_tx == NULL)
! 1093: return;
! 1094:
! 1095: IFQ_POLL(&ifp->if_snd, m0);
! 1096: if (m0 == NULL)
! 1097: return;
! 1098: IFQ_DEQUEUE(&ifp->if_snd, m0);
! 1099:
! 1100: if (ueagle_encap(sc, m0) != 0) {
! 1101: m_freem(m0);
! 1102: return;
! 1103: }
! 1104:
! 1105: #if NBPFILTER > 0
! 1106: if (ifp->if_bpf != NULL)
! 1107: bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
! 1108: #endif
! 1109:
! 1110: m_freem(m0);
! 1111:
! 1112: ifp->if_flags |= IFF_OACTIVE;
! 1113: }
! 1114:
! 1115: int
! 1116: ueagle_open_vcc(struct ueagle_softc *sc, struct atm_pseudoioctl *api)
! 1117: {
! 1118: struct ueagle_vcc *vcc = &sc->vcc;
! 1119:
! 1120: DPRINTF(("%s: opening ATM VCC\n", sc->sc_dev.dv_xname));
! 1121:
! 1122: vcc->vpi = ATM_PH_VPI(&api->aph);
! 1123: vcc->vci = ATM_PH_VCI(&api->aph);
! 1124: vcc->rxhand = api->rxhand;
! 1125: vcc->m = NULL;
! 1126: vcc->aph = api->aph;
! 1127: vcc->flags = UEAGLE_VCC_ACTIVE;
! 1128:
! 1129: /* pre-calculate cell headers (HEC field is set by hardware) */
! 1130: ATM_CH_FILL(vcc->ch, 0, vcc->vpi, vcc->vci, 0, 0, 0);
! 1131:
! 1132: return 0;
! 1133: }
! 1134:
! 1135: int
! 1136: ueagle_close_vcc(struct ueagle_softc *sc, struct atm_pseudoioctl *api)
! 1137: {
! 1138: DPRINTF(("%s: closing ATM VCC\n", sc->sc_dev.dv_xname));
! 1139:
! 1140: sc->vcc.flags &= ~UEAGLE_VCC_ACTIVE;
! 1141:
! 1142: return 0;
! 1143: }
! 1144:
! 1145: int
! 1146: ueagle_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
! 1147: {
! 1148: struct ueagle_softc *sc = ifp->if_softc;
! 1149: struct atm_pseudoioctl *api;
! 1150: struct ifaddr *ifa;
! 1151: struct ifreq *ifr;
! 1152: int s, error = 0;
! 1153:
! 1154: s = splnet();
! 1155:
! 1156: switch (cmd) {
! 1157: case SIOCSIFADDR:
! 1158: ifa = (struct ifaddr *)data;
! 1159: ifp->if_flags |= IFF_UP;
! 1160:
! 1161: ueagle_init(ifp);
! 1162: #ifdef INET
! 1163: ifa->ifa_rtrequest = atm_rtrequest;
! 1164: #endif
! 1165: break;
! 1166:
! 1167: case SIOCSIFFLAGS:
! 1168: if (ifp->if_flags & IFF_UP) {
! 1169: if (!(ifp->if_flags & IFF_RUNNING))
! 1170: ueagle_init(ifp);
! 1171: } else {
! 1172: if (ifp->if_flags & IFF_RUNNING)
! 1173: ueagle_stop(ifp, 1);
! 1174: }
! 1175: break;
! 1176:
! 1177: case SIOCSIFMTU:
! 1178: ifr = (struct ifreq *)data;
! 1179:
! 1180: if (ifr->ifr_mtu > UEAGLE_IFMTU)
! 1181: error = EINVAL;
! 1182: else
! 1183: ifp->if_mtu = ifr->ifr_mtu;
! 1184: break;
! 1185:
! 1186: case SIOCATMENA:
! 1187: api = (struct atm_pseudoioctl *)data;
! 1188: error = ueagle_open_vcc(sc, api);
! 1189: break;
! 1190:
! 1191: case SIOCATMDIS:
! 1192: api = (struct atm_pseudoioctl *)data;
! 1193: error = ueagle_close_vcc(sc, api);
! 1194: break;
! 1195:
! 1196: default:
! 1197: error = EINVAL;
! 1198: }
! 1199:
! 1200: splx(s);
! 1201:
! 1202: return error;
! 1203: }
! 1204:
! 1205: int
! 1206: ueagle_open_pipes(struct ueagle_softc *sc)
! 1207: {
! 1208: usb_endpoint_descriptor_t *edesc;
! 1209: usbd_interface_handle iface;
! 1210: struct ueagle_txreq *txreq;
! 1211: struct ueagle_isoreq *isoreq;
! 1212: usbd_status error;
! 1213: uint8_t *buf;
! 1214: int i, j;
! 1215:
! 1216: error = usbd_device2interface_handle(sc->sc_udev, UEAGLE_US_IFACE_NO,
! 1217: &iface);
! 1218: if (error != 0) {
! 1219: printf("%s: could not get tx interface handle\n",
! 1220: sc->sc_dev.dv_xname);
! 1221: goto fail;
! 1222: }
! 1223:
! 1224: error = usbd_open_pipe(iface, UEAGLE_TX_PIPE, USBD_EXCLUSIVE_USE,
! 1225: &sc->pipeh_tx);
! 1226: if (error != 0) {
! 1227: printf("%s: could not open tx pipe\n", sc->sc_dev.dv_xname);
! 1228: goto fail;
! 1229: }
! 1230:
! 1231: for (i = 0; i < UEAGLE_TX_LIST_CNT; i++) {
! 1232: txreq = &sc->txreqs[i];
! 1233:
! 1234: txreq->sc = sc;
! 1235:
! 1236: txreq->xfer = usbd_alloc_xfer(sc->sc_udev);
! 1237: if (txreq->xfer == NULL) {
! 1238: printf("%s: could not allocate tx xfer\n",
! 1239: sc->sc_dev.dv_xname);
! 1240: error = ENOMEM;
! 1241: goto fail;
! 1242: }
! 1243:
! 1244: txreq->buf = usbd_alloc_buffer(txreq->xfer, UEAGLE_TXBUFLEN);
! 1245: if (txreq->buf == NULL) {
! 1246: printf("%s: could not allocate tx buffer\n",
! 1247: sc->sc_dev.dv_xname);
! 1248: error = ENOMEM;
! 1249: goto fail;
! 1250: }
! 1251: }
! 1252:
! 1253: error = usbd_device2interface_handle(sc->sc_udev, UEAGLE_DS_IFACE_NO,
! 1254: &iface);
! 1255: if (error != 0) {
! 1256: printf("%s: could not get rx interface handle\n",
! 1257: sc->sc_dev.dv_xname);
! 1258: goto fail;
! 1259: }
! 1260:
! 1261: /* XXX: alternative interface number sould depend on downrate */
! 1262: error = usbd_set_interface(iface, 8);
! 1263: if (error != 0) {
! 1264: printf("%s: could not set rx alternative interface\n",
! 1265: sc->sc_dev.dv_xname);
! 1266: goto fail;
! 1267: }
! 1268:
! 1269: edesc = usbd_get_endpoint_descriptor(iface, UEAGLE_RX_PIPE);
! 1270: if (edesc == NULL) {
! 1271: printf("%s: could not get rx endpoint descriptor\n",
! 1272: sc->sc_dev.dv_xname);
! 1273: error = EIO;
! 1274: goto fail;
! 1275: }
! 1276:
! 1277: sc->isize = UGETW(edesc->wMaxPacketSize);
! 1278:
! 1279: error = usbd_open_pipe(iface, UEAGLE_RX_PIPE, USBD_EXCLUSIVE_USE,
! 1280: &sc->pipeh_rx);
! 1281: if (error != 0) {
! 1282: printf("%s: could not open rx pipe\n", sc->sc_dev.dv_xname);
! 1283: goto fail;
! 1284: }
! 1285:
! 1286: for (i = 0; i < UEAGLE_NISOREQS; i++) {
! 1287: isoreq = &sc->isoreqs[i];
! 1288:
! 1289: isoreq->sc = sc;
! 1290:
! 1291: isoreq->xfer = usbd_alloc_xfer(sc->sc_udev);
! 1292: if (isoreq->xfer == NULL) {
! 1293: printf("%s: could not allocate rx xfer\n",
! 1294: sc->sc_dev.dv_xname);
! 1295: error = ENOMEM;
! 1296: goto fail;
! 1297: }
! 1298:
! 1299: buf = usbd_alloc_buffer(isoreq->xfer,
! 1300: sc->isize * UEAGLE_NISOFRMS);
! 1301: if (buf == NULL) {
! 1302: printf("%s: could not allocate rx buffer\n",
! 1303: sc->sc_dev.dv_xname);
! 1304: error = ENOMEM;
! 1305: goto fail;
! 1306: }
! 1307:
! 1308: for (j = 0; j < UEAGLE_NISOFRMS; j++) {
! 1309: isoreq->frlengths[j] = sc->isize;
! 1310: isoreq->offsets[j] = buf + j * sc->isize;
! 1311: }
! 1312:
! 1313: usbd_setup_isoc_xfer(isoreq->xfer, sc->pipeh_rx, isoreq,
! 1314: isoreq->frlengths, UEAGLE_NISOFRMS, USBD_NO_COPY,
! 1315: ueagle_rxeof);
! 1316: usbd_transfer(isoreq->xfer);
! 1317: }
! 1318:
! 1319: ueagle_request(sc, UEAGLE_SETMODE, UEAGLE_LOOPBACKOFF, NULL, 0);
! 1320:
! 1321: return 0;
! 1322:
! 1323: fail: ueagle_close_pipes(sc);
! 1324: return error;
! 1325: }
! 1326:
! 1327: void
! 1328: ueagle_close_pipes(struct ueagle_softc *sc)
! 1329: {
! 1330: int i;
! 1331:
! 1332: ueagle_request(sc, UEAGLE_SETMODE, UEAGLE_LOOPBACKON, NULL, 0);
! 1333:
! 1334: /* free Tx resources */
! 1335: if (sc->pipeh_tx != NULL) {
! 1336: usbd_abort_pipe(sc->pipeh_tx);
! 1337: usbd_close_pipe(sc->pipeh_tx);
! 1338: sc->pipeh_tx = NULL;
! 1339: }
! 1340:
! 1341: for (i = 0; i < UEAGLE_TX_LIST_CNT; i++) {
! 1342: if (sc->txreqs[i].xfer != NULL) {
! 1343: usbd_free_xfer(sc->txreqs[i].xfer);
! 1344: sc->txreqs[i].xfer = NULL;
! 1345: }
! 1346: }
! 1347:
! 1348: /* free Rx resources */
! 1349: if (sc->pipeh_rx != NULL) {
! 1350: usbd_abort_pipe(sc->pipeh_rx);
! 1351: usbd_close_pipe(sc->pipeh_rx);
! 1352: sc->pipeh_rx = NULL;
! 1353: }
! 1354:
! 1355: for (i = 0; i < UEAGLE_NISOREQS; i++) {
! 1356: if (sc->isoreqs[i].xfer != NULL) {
! 1357: usbd_free_xfer(sc->isoreqs[i].xfer);
! 1358: sc->isoreqs[i].xfer = NULL;
! 1359: }
! 1360: }
! 1361: }
! 1362:
! 1363: int
! 1364: ueagle_init(struct ifnet *ifp)
! 1365: {
! 1366: struct ueagle_softc *sc = ifp->if_softc;
! 1367: usbd_interface_handle iface;
! 1368: usbd_status error;
! 1369: size_t len;
! 1370:
! 1371: ueagle_stop(ifp, 0);
! 1372:
! 1373: error = usbd_device2interface_handle(sc->sc_udev, UEAGLE_US_IFACE_NO,
! 1374: &iface);
! 1375: if (error != 0) {
! 1376: printf("%s: could not get idma interface handle\n",
! 1377: sc->sc_dev.dv_xname);
! 1378: goto fail;
! 1379: }
! 1380:
! 1381: error = usbd_open_pipe(iface, UEAGLE_IDMA_PIPE, USBD_EXCLUSIVE_USE,
! 1382: &sc->pipeh_idma);
! 1383: if (error != 0) {
! 1384: printf("%s: could not open idma pipe\n",
! 1385: sc->sc_dev.dv_xname);
! 1386: goto fail;
! 1387: }
! 1388:
! 1389: error = usbd_device2interface_handle(sc->sc_udev, UEAGLE_INTR_IFACE_NO,
! 1390: &iface);
! 1391: if (error != 0) {
! 1392: printf("%s: could not get interrupt interface handle\n",
! 1393: sc->sc_dev.dv_xname);
! 1394: goto fail;
! 1395: }
! 1396:
! 1397: error = loadfirmware("ueagle-dsp", &sc->dsp, &len);
! 1398: if (error != 0) {
! 1399: printf("%s: could not load firmware\n", sc->sc_dev.dv_xname);
! 1400: goto fail;
! 1401: }
! 1402:
! 1403: error = usbd_open_pipe_intr(iface, UEAGLE_INTR_PIPE, USBD_SHORT_XFER_OK,
! 1404: &sc->pipeh_intr, sc, sc->ibuf, UEAGLE_INTR_MAXSIZE, ueagle_intr,
! 1405: UEAGLE_INTR_INTERVAL);
! 1406: if (error != 0) {
! 1407: printf("%s: could not open interrupt pipe\n",
! 1408: sc->sc_dev.dv_xname);
! 1409: goto fail;
! 1410: }
! 1411:
! 1412: error = ueagle_boot(sc);
! 1413: if (error != 0) {
! 1414: printf("%s: could not boot modem\n", sc->sc_dev.dv_xname);
! 1415: goto fail;
! 1416: }
! 1417:
! 1418: /*
! 1419: * Opening of tx and rx pipes if deferred after synchronization is
! 1420: * established.
! 1421: */
! 1422:
! 1423: ifp->if_flags |= IFF_RUNNING;
! 1424: ifp->if_flags &= ~IFF_OACTIVE;
! 1425:
! 1426: return 0;
! 1427:
! 1428: fail: ueagle_stop(ifp, 1);
! 1429: return error;
! 1430: }
! 1431:
! 1432: void
! 1433: ueagle_stop(struct ifnet *ifp, int disable)
! 1434: {
! 1435: struct ueagle_softc *sc = ifp->if_softc;
! 1436:
! 1437: /* stop any pending task */
! 1438: usb_rem_task(sc->sc_udev, &sc->sc_swap_task);
! 1439:
! 1440: /* free Tx and Rx resources */
! 1441: ueagle_close_pipes(sc);
! 1442:
! 1443: /* free firmware */
! 1444: if (sc->dsp != NULL) {
! 1445: free(sc->dsp, M_DEVBUF);
! 1446: sc->dsp = NULL;
! 1447: }
! 1448:
! 1449: /* free interrupt resources */
! 1450: if (sc->pipeh_intr != NULL) {
! 1451: usbd_abort_pipe(sc->pipeh_intr);
! 1452: usbd_close_pipe(sc->pipeh_intr);
! 1453: sc->pipeh_intr = NULL;
! 1454: }
! 1455:
! 1456: /* free IDMA resources */
! 1457: if (sc->pipeh_idma != NULL) {
! 1458: usbd_abort_pipe(sc->pipeh_idma);
! 1459: usbd_close_pipe(sc->pipeh_idma);
! 1460: sc->pipeh_idma = NULL;
! 1461: }
! 1462:
! 1463: /* reset statistics */
! 1464: memset(&sc->stats, 0, sizeof (struct ueagle_stats));
! 1465:
! 1466: ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
! 1467: }
! 1468:
! 1469: int
! 1470: ueagle_activate(struct device *self, enum devact act)
! 1471: {
! 1472: struct ueagle_softc *sc = (struct ueagle_softc *)self;
! 1473:
! 1474: switch (act) {
! 1475: case DVACT_ACTIVATE:
! 1476: break;
! 1477:
! 1478: case DVACT_DEACTIVATE:
! 1479: sc->gone = 1;
! 1480: break;
! 1481: }
! 1482:
! 1483: return 0;
! 1484: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ueagle.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb