Annotation of sys/dev/usb/if_wi_usb.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_wi_usb.c,v 1.42 2007/06/14 10:11:15 mbalmer Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2003 Dale Rahn. All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: *
! 15: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 16: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 17: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 18: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 19: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 20: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 21: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 22: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 23: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 24: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 25: *
! 26: * Effort sponsored in part by the Defense Advanced Research Projects
! 27: * Agency (DARPA) and Air Force Research Laboratory, Air Force
! 28: * Materiel Command, USAF, under agreement number F30602-01-2-0537.
! 29: */
! 30: #include "bpfilter.h"
! 31:
! 32: #include <sys/param.h>
! 33: #include <sys/systm.h>
! 34: #include <sys/sockio.h>
! 35: #include <sys/mbuf.h>
! 36: #include <sys/malloc.h>
! 37: #include <sys/kernel.h>
! 38: #include <sys/proc.h>
! 39: #include <sys/socket.h>
! 40: #include <sys/device.h>
! 41: #include <sys/kthread.h>
! 42: #include <sys/tree.h>
! 43:
! 44: #include <net/if.h>
! 45: #include <net/if_dl.h>
! 46: #include <net/if_media.h>
! 47: #include <net/if_types.h>
! 48:
! 49: #ifdef INET
! 50: #include <netinet/in.h>
! 51: #include <netinet/in_systm.h>
! 52: #include <netinet/in_var.h>
! 53: #include <netinet/ip.h>
! 54: #include <netinet/if_ether.h>
! 55: #endif
! 56:
! 57: #include <dev/usb/usb.h>
! 58: #include <dev/usb/usbdi.h>
! 59: #include <dev/usb/usbdi_util.h>
! 60: #include <dev/usb/usbdevs.h>
! 61:
! 62: #define ROUNDUP64(x) (((x)+63) & ~63)
! 63:
! 64: #include <net80211/ieee80211_var.h>
! 65: #include <net80211/ieee80211_ioctl.h>
! 66:
! 67: #if NBPFILTER > 0
! 68: #include <net/bpf.h>
! 69: #endif
! 70:
! 71: #include <machine/bus.h>
! 72:
! 73: #include <dev/rndvar.h>
! 74:
! 75: #include <dev/ic/if_wireg.h>
! 76: #include <dev/ic/if_wi_ieee.h>
! 77: #include <dev/ic/if_wivar.h>
! 78:
! 79: #include <dev/usb/if_wi_usb.h>
! 80:
! 81: int wi_usb_do_transmit_sync(struct wi_usb_softc *wsc, struct wi_usb_chain *c,
! 82: void *ident);
! 83: void wi_usb_txeof(usbd_xfer_handle xfer, usbd_private_handle priv,
! 84: usbd_status status);
! 85: void wi_usb_txeof_frm(usbd_xfer_handle xfer, usbd_private_handle priv,
! 86: usbd_status status);
! 87: void wi_usb_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv,
! 88: usbd_status status);
! 89: void wi_usb_intr(usbd_xfer_handle xfer, usbd_private_handle priv,
! 90: usbd_status status);
! 91: void wi_usb_stop(struct wi_usb_softc *usc);
! 92: int wi_usb_tx_list_init(struct wi_usb_softc *usc);
! 93: int wi_usb_rx_list_init(struct wi_usb_softc *usc);
! 94: int wi_usb_open_pipes(struct wi_usb_softc *usc);
! 95: void wi_usb_cmdresp(struct wi_usb_chain *c);
! 96: void wi_usb_rridresp(struct wi_usb_chain *c);
! 97: void wi_usb_wridresp(struct wi_usb_chain *c);
! 98: void wi_usb_infofrm(struct wi_usb_chain *c, int len);
! 99: int wi_send_packet(struct wi_usb_softc *sc, int id);
! 100: void wi_usb_rxfrm(struct wi_usb_softc *usc, wi_usb_usbin *uin, int total_len);
! 101: void wi_usb_txfrm(struct wi_usb_softc *usc, wi_usb_usbin *uin, int total_len);
! 102: void wi_usb_start_thread(void *);
! 103:
! 104: int wi_usb_tx_lock_try(struct wi_usb_softc *sc);
! 105: void wi_usb_tx_lock(struct wi_usb_softc *usc);
! 106: void wi_usb_tx_unlock(struct wi_usb_softc *usc);
! 107: void wi_usb_ctl_lock(struct wi_usb_softc *usc);
! 108: void wi_usb_ctl_unlock(struct wi_usb_softc *usc);
! 109:
! 110: void wi_dump_data(void *buffer, int len);
! 111:
! 112: void wi_usb_thread(void *arg);
! 113:
! 114: #ifdef WI_USB_DEBUG
! 115: #define DPRINTF(x) do { if (wi_usbdebug) printf x; } while (0)
! 116: #define DPRINTFN(n,x) do { if (wi_usbdebug >= (n)) printf x; } while (0)
! 117: int wi_usbdebug = 1;
! 118: #else
! 119: #define DPRINTF(x)
! 120: #define DPRINTFN(n,x)
! 121: #endif
! 122:
! 123: struct wi_usb_thread_info {
! 124: int status;
! 125: int dying;
! 126: int idle;
! 127: };
! 128:
! 129: /* thread status flags */
! 130: #define WI_START 0x01
! 131: #define WI_DYING 0x02
! 132: #define WI_INQUIRE 0x04
! 133: #define WI_WATCHDOG 0x08
! 134:
! 135:
! 136: struct wi_usb_softc {
! 137: struct wi_softc sc_wi;
! 138: #define wi_usb_dev sc_wi.sc_dev
! 139:
! 140: struct timeout wi_usb_stat_ch;
! 141:
! 142: usbd_device_handle wi_usb_udev;
! 143: usbd_interface_handle wi_usb_iface;
! 144: u_int16_t wi_usb_vendor;
! 145: u_int16_t wi_usb_product;
! 146: int wi_usb_ed[WI_USB_ENDPT_MAX];
! 147: usbd_pipe_handle wi_usb_ep[WI_USB_ENDPT_MAX];
! 148:
! 149: struct wi_usb_chain wi_usb_tx_chain[WI_USB_TX_LIST_CNT];
! 150: struct wi_usb_chain wi_usb_rx_chain[WI_USB_RX_LIST_CNT];
! 151:
! 152: int wi_usb_refcnt;
! 153: char wi_usb_dying;
! 154: char wi_usb_attached;
! 155: int wi_usb_intr_errs;
! 156: struct timeval wi_usb_rx_notice;
! 157:
! 158: int wi_usb_pollpending;
! 159:
! 160: wi_usb_usbin wi_usb_ibuf;
! 161: int wi_usb_tx_prod;
! 162: int wi_usb_tx_cons;
! 163: int wi_usb_tx_cnt;
! 164: int wi_usb_rx_prod;
! 165:
! 166: struct wi_ltv_gen *ridltv;
! 167: int ridresperr;
! 168:
! 169: int cmdresp;
! 170: int cmdresperr;
! 171: int txresp;
! 172: int txresperr;
! 173:
! 174: /* nummem (tx/mgmt) */
! 175: int wi_usb_nummem;
! 176: #define MAX_WI_NMEM 3
! 177: void *wi_usb_txmem[MAX_WI_NMEM];
! 178: int wi_usb_txmemsize[MAX_WI_NMEM];
! 179: void *wi_usb_rxmem;
! 180: int wi_usb_rxmemsize;
! 181:
! 182: void *wi_info;
! 183: void *wi_rxframe;
! 184:
! 185: /* prevent multiple outstanding USB requests */
! 186: int wi_lock;
! 187: int wi_lockwait;
! 188:
! 189: /* prevent multiple command requests */
! 190: int wi_ctllock;
! 191: int wi_ctllockwait;
! 192: struct proc *wi_curproc;
! 193:
! 194: /* kthread */
! 195: struct wi_usb_thread_info *wi_thread_info;
! 196: int wi_resetonce;
! 197: };
! 198:
! 199: struct wi_funcs wi_func_usb = {
! 200: wi_cmd_usb,
! 201: wi_read_record_usb,
! 202: wi_write_record_usb,
! 203: wi_alloc_nicmem_usb,
! 204: wi_read_data_usb,
! 205: wi_write_data_usb,
! 206: wi_get_fid_usb,
! 207: wi_init_usb,
! 208:
! 209: wi_start_usb,
! 210: wi_ioctl_usb,
! 211: wi_watchdog_usb,
! 212: wi_inquire_usb,
! 213: };
! 214:
! 215: /*
! 216: * Various supported device vendors/products.
! 217: */
! 218: const struct wi_usb_type {
! 219: struct usb_devno wi_usb_device;
! 220: u_int16_t wi_usb_flags;
! 221: /* XXX */
! 222: } wi_usb_devs[] = {
! 223: {{ USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_111 }, 0 },
! 224: {{ USB_VENDOR_ACERW, USB_PRODUCT_ACERW_WARPLINK }, 0 },
! 225: {{ USB_VENDOR_ACTIONTEC, USB_PRODUCT_ACTIONTEC_FREELAN }, 0 },
! 226: {{ USB_VENDOR_ACTIONTEC, USB_PRODUCT_ACTIONTEC_PRISM_25 }, 0 },
! 227: {{ USB_VENDOR_ACTIONTEC, USB_PRODUCT_ACTIONTEC_PRISM_25A }, 0 },
! 228: {{ USB_VENDOR_ADAPTEC, USB_PRODUCT_ADAPTEC_AWN8020 }, 0 },
! 229: {{ USB_VENDOR_AMBIT, USB_PRODUCT_AMBIT_WLAN }, 0 },
! 230: {{ USB_VENDOR_ASUSTEK, USB_PRODUCT_ASUSTEK_WL140 }, 0 },
! 231: {{ USB_VENDOR_AVERATEC, USB_PRODUCT_AVERATEC_USBWLAN }, 0 },
! 232: {{ USB_VENDOR_COMPAQ, USB_PRODUCT_COMPAQ_W100 }, 0 },
! 233: {{ USB_VENDOR_COMPAQ, USB_PRODUCT_COMPAQ_W200 }, 0 },
! 234: {{ USB_VENDOR_COREGA, USB_PRODUCT_COREGA_WLANUSB }, 0 },
! 235: {{ USB_VENDOR_COREGA, USB_PRODUCT_COREGA_WLUSB_11_KEY }, 0 },
! 236: {{ USB_VENDOR_DELL, USB_PRODUCT_DELL_TM1180 }, 0 },
! 237: {{ USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DWL120F }, 0 },
! 238: {{ USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DWL122 }, 0 },
! 239: {{ USB_VENDOR_INTEL, USB_PRODUCT_INTEL_I2011B }, 0 },
! 240: {{ USB_VENDOR_INTERSIL, USB_PRODUCT_INTERSIL_PRISM_2X }, 0 },
! 241: {{ USB_VENDOR_IODATA, USB_PRODUCT_IODATA_USBWNB11 }, 0 },
! 242: {{ USB_VENDOR_JVC, USB_PRODUCT_JVC_MP_XP7250_WL }, 0 },
! 243: {{ USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_WUSB11_25 }, 0 },
! 244: {{ USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_WUSB12_11 }, 0 },
! 245: {{ USB_VENDOR_LINKSYS3, USB_PRODUCT_LINKSYS3_WUSB11V30 }, 0 },
! 246: {{ USB_VENDOR_MELCO, USB_PRODUCT_MELCO_KB11 }, 0 },
! 247: {{ USB_VENDOR_MELCO, USB_PRODUCT_MELCO_KS11G }, 0 },
! 248: {{ USB_VENDOR_MELCO, USB_PRODUCT_MELCO_S11 }, 0 },
! 249: {{ USB_VENDOR_MICROSOFT, USB_PRODUCT_MICROSOFT_MN510 }, 0 },
! 250: {{ USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_MA111NA }, 0 },
! 251: {{ USB_VENDOR_PHEENET, USB_PRODUCT_PHEENET_WL503IA }, 0 },
! 252: {{ USB_VENDOR_PHEENET, USB_PRODUCT_PHEENET_WM168B }, 0 },
! 253: {{ USB_VENDOR_PLANEX, USB_PRODUCT_PLANEX_GW_US11H }, 0 },
! 254: {{ USB_VENDOR_SIEMENS, USB_PRODUCT_SIEMENS_SPEEDSTREAM22 }, 0 },
! 255: {{ USB_VENDOR_SITECOM2, USB_PRODUCT_SITECOM2_WL022 }, 0 },
! 256: {{ USB_VENDOR_TEKRAM, USB_PRODUCT_TEKRAM_0193 }, 0 },
! 257: {{ USB_VENDOR_TEKRAM, USB_PRODUCT_TEKRAM_ZYAIR_B200 }, 0 },
! 258: {{ USB_VENDOR_USR, USB_PRODUCT_USR_USR1120 }, 0 },
! 259: {{ USB_VENDOR_VIEWSONIC, USB_PRODUCT_VIEWSONIC_AIRSYNC }, 0 },
! 260: {{ USB_VENDOR_ZCOM, USB_PRODUCT_ZCOM_XI725 }, 0 },
! 261: {{ USB_VENDOR_ZCOM, USB_PRODUCT_ZCOM_XI735 }, 0 }
! 262: };
! 263: #define wi_usb_lookup(v, p) ((struct wi_usb_type *)usb_lookup(wi_usb_devs, v, p))
! 264:
! 265: int wi_usb_match(struct device *, void *, void *);
! 266: void wi_usb_attach(struct device *, struct device *, void *);
! 267: int wi_usb_detach(struct device *, int);
! 268: int wi_usb_activate(struct device *, enum devact);
! 269:
! 270: struct cfdriver wi_usb_cd = {
! 271: NULL, "wi_usb", DV_IFNET
! 272: };
! 273:
! 274: const struct cfattach wi_usb_ca = {
! 275: sizeof(struct wi_usb_softc),
! 276: wi_usb_match,
! 277: wi_usb_attach,
! 278: wi_usb_detach,
! 279: wi_usb_activate,
! 280: };
! 281:
! 282: int
! 283: wi_usb_match(struct device *parent, void *match, void *aux)
! 284: {
! 285: struct usb_attach_arg *uaa = aux;
! 286:
! 287: if (uaa->iface != NULL)
! 288: return (UMATCH_NONE);
! 289:
! 290: return (wi_usb_lookup(uaa->vendor, uaa->product) != NULL ?
! 291: UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
! 292: }
! 293:
! 294:
! 295: /*
! 296: * Attach the interface. Allocate softc structures, do ifmedia
! 297: * setup and ethernet/BPF attach.
! 298: */
! 299: void
! 300: wi_usb_attach(struct device *parent, struct device *self, void *aux)
! 301: {
! 302: struct wi_usb_softc *sc = (struct wi_usb_softc *)self;
! 303: struct usb_attach_arg *uaa = aux;
! 304: char *devinfop;
! 305: /* int s; */
! 306: usbd_device_handle dev = uaa->device;
! 307: usbd_interface_handle iface;
! 308: usbd_status err;
! 309: usb_interface_descriptor_t *id;
! 310: usb_endpoint_descriptor_t *ed;
! 311: int i;
! 312:
! 313: DPRINTFN(5,(" : wi_usb_attach: sc=%p", sc));
! 314:
! 315: err = usbd_set_config_no(dev, WI_USB_CONFIG_NO, 1);
! 316: if (err) {
! 317: printf("%s: setting config no failed\n",
! 318: sc->wi_usb_dev.dv_xname);
! 319: return;
! 320: }
! 321:
! 322: devinfop = usbd_devinfo_alloc(dev, 0);
! 323: printf("\n%s: %s\n", sc->wi_usb_dev.dv_xname, devinfop);
! 324: usbd_devinfo_free(devinfop);
! 325:
! 326: /* XXX - any tasks? */
! 327:
! 328: err = usbd_device2interface_handle(dev, WI_USB_IFACE_IDX, &iface);
! 329: if (err) {
! 330: printf("%s: getting interface handle failed\n",
! 331: sc->wi_usb_dev.dv_xname);
! 332: return;
! 333: }
! 334:
! 335: /* XXX - flags? */
! 336:
! 337: sc->wi_usb_udev = dev;
! 338: sc->wi_usb_iface = iface;
! 339: sc->wi_usb_product = uaa->product;
! 340: sc->wi_usb_vendor = uaa->vendor;
! 341:
! 342: sc->sc_wi.wi_usb_cdata = sc;
! 343: sc->sc_wi.wi_flags |= WI_FLAGS_BUS_USB;
! 344:
! 345: sc->wi_lock = 0;
! 346: sc->wi_lockwait = 0;
! 347: sc->wi_resetonce = 0;
! 348:
! 349: id = usbd_get_interface_descriptor(iface);
! 350:
! 351: /* Find endpoints. */
! 352: for (i = 0; i < id->bNumEndpoints; i++) {
! 353: ed = usbd_interface2endpoint_descriptor(iface, i);
! 354: if (ed == NULL) {
! 355: printf("%s: couldn't get endpoint descriptor %d\n",
! 356: sc->wi_usb_dev.dv_xname, i);
! 357: return;
! 358: }
! 359: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
! 360: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
! 361: sc->wi_usb_ed[WI_USB_ENDPT_RX] = ed->bEndpointAddress;
! 362: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
! 363: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
! 364: sc->wi_usb_ed[WI_USB_ENDPT_TX] = ed->bEndpointAddress;
! 365: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
! 366: UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
! 367: sc->wi_usb_ed[WI_USB_ENDPT_INTR] = ed->bEndpointAddress;
! 368: }
! 369: }
! 370:
! 371: sc->wi_usb_nummem = 0;
! 372:
! 373: /* attach wi device */
! 374:
! 375: if (wi_usb_rx_list_init(sc)) {
! 376: printf("%s: rx list init failed\n",
! 377: sc->wi_usb_dev.dv_xname);
! 378: return;
! 379: }
! 380: if (wi_usb_tx_list_init(sc)) {
! 381: printf("%s: tx list init failed\n",
! 382: sc->wi_usb_dev.dv_xname);
! 383: return;
! 384: }
! 385:
! 386: if (wi_usb_open_pipes(sc)){
! 387: printf("%s: open pipes failed\n",
! 388: sc->wi_usb_dev.dv_xname);
! 389: return;
! 390: }
! 391:
! 392: sc->wi_usb_attached = 1;
! 393:
! 394: kthread_create_deferred(wi_usb_start_thread, sc);
! 395:
! 396: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->wi_usb_udev,
! 397: &sc->wi_usb_dev);
! 398: }
! 399:
! 400: int
! 401: wi_usb_detach(struct device *self, int flags)
! 402: {
! 403: struct wi_usb_softc *sc = (struct wi_usb_softc *)self;
! 404: struct ifnet *ifp = WI_GET_IFP(sc);
! 405: struct wi_softc *wsc = &sc->sc_wi;
! 406: int s;
! 407: int err;
! 408:
! 409: sc->wi_usb_dying = 1;
! 410: if (sc->wi_thread_info != NULL) {
! 411: sc->wi_thread_info->dying = 1;
! 412:
! 413: sc->wi_thread_info->status |= WI_DYING;
! 414: if (sc->wi_thread_info->idle)
! 415: wakeup(sc->wi_thread_info);
! 416: }
! 417:
! 418: if (!sc->wi_usb_attached) {
! 419: /* Detached before attach finished, so just bail out. */
! 420: return (0);
! 421: }
! 422: /* tasks? */
! 423:
! 424: s = splusb();
! 425: /* detatch wi */
! 426:
! 427: if (!(wsc->wi_flags & WI_FLAGS_ATTACHED)) {
! 428: printf("%s: already detached\n", sc->wi_usb_dev.dv_xname);
! 429: splx(s);
! 430: return (0);
! 431: }
! 432:
! 433: wi_detach(&sc->sc_wi);
! 434:
! 435: wsc->wi_flags = 0;
! 436:
! 437: ether_ifdetach(ifp);
! 438: if_detach(ifp);
! 439:
! 440: sc->wi_usb_attached = 0;
! 441:
! 442: if (--sc->wi_usb_refcnt >= 0) {
! 443: /* Wait for processes to go away. */
! 444: usb_detach_wait(&sc->wi_usb_dev);
! 445: }
! 446:
! 447: while (sc->wi_usb_nummem) {
! 448: sc->wi_usb_nummem--;
! 449: if (sc->wi_usb_txmem[sc->wi_usb_nummem] != NULL)
! 450: free(sc->wi_usb_txmem[sc->wi_usb_nummem], M_DEVBUF);
! 451: sc->wi_usb_txmem[sc->wi_usb_nummem] = NULL;
! 452: }
! 453:
! 454: if (sc->wi_usb_ep[WI_USB_ENDPT_INTR] != NULL) {
! 455: err = usbd_abort_pipe(sc->wi_usb_ep[WI_USB_ENDPT_INTR]);
! 456: if (err) {
! 457: printf("%s: abort intr pipe failed: %s\n",
! 458: sc->wi_usb_dev.dv_xname, usbd_errstr(err));
! 459: }
! 460: err = usbd_close_pipe(sc->wi_usb_ep[WI_USB_ENDPT_INTR]);
! 461: if (err) {
! 462: printf("%s: close intr pipe failed: %s\n",
! 463: sc->wi_usb_dev.dv_xname, usbd_errstr(err));
! 464: }
! 465: sc->wi_usb_ep[WI_USB_ENDPT_INTR] = NULL;
! 466: }
! 467: if (sc->wi_usb_ep[WI_USB_ENDPT_TX] != NULL) {
! 468: usbd_abort_pipe(sc->wi_usb_ep[WI_USB_ENDPT_TX]);
! 469: if (err) {
! 470: printf("%s: abort tx pipe failed: %s\n",
! 471: sc->wi_usb_dev.dv_xname, usbd_errstr(err));
! 472: }
! 473: err = usbd_close_pipe(sc->wi_usb_ep[WI_USB_ENDPT_TX]);
! 474: if (err) {
! 475: printf("%s: close tx pipe failed: %s\n",
! 476: sc->wi_usb_dev.dv_xname, usbd_errstr(err));
! 477: }
! 478: sc->wi_usb_ep[WI_USB_ENDPT_TX] = NULL;
! 479: }
! 480: if (sc->wi_usb_ep[WI_USB_ENDPT_RX] != NULL) {
! 481: usbd_abort_pipe(sc->wi_usb_ep[WI_USB_ENDPT_RX]);
! 482: if (err) {
! 483: printf("%s: abort rx pipe failed: %s\n",
! 484: sc->wi_usb_dev.dv_xname, usbd_errstr(err));
! 485: }
! 486: err = usbd_close_pipe(sc->wi_usb_ep[WI_USB_ENDPT_RX]);
! 487: if (err) {
! 488: printf("%s: close rx pipe failed: %s\n",
! 489: sc->wi_usb_dev.dv_xname, usbd_errstr(err));
! 490: }
! 491: sc->wi_usb_ep[WI_USB_ENDPT_RX] = NULL;
! 492: }
! 493:
! 494: splx(s);
! 495:
! 496: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->wi_usb_udev,
! 497: &sc->wi_usb_dev);
! 498: return (0);
! 499: }
! 500:
! 501: int
! 502: wi_send_packet(struct wi_usb_softc *sc, int id)
! 503: {
! 504: struct wi_usb_chain *c;
! 505: struct wi_frame *wibuf;
! 506: int total_len, rnd_len;
! 507: int err;
! 508:
! 509: c = &sc->wi_usb_tx_chain[0];
! 510:
! 511: DPRINTFN(10,("%s: %s: id=%x\n",
! 512: sc->wi_usb_dev.dv_xname, __func__, id));
! 513:
! 514: /* assemble packet from write_data buffer */
! 515: if (id == 0 || id == 1) {
! 516: /* tx_lock acquired before wi_start() */
! 517: wibuf = sc->wi_usb_txmem[id];
! 518:
! 519: total_len = sizeof (struct wi_frame) +
! 520: letoh16(wibuf->wi_dat_len);
! 521: rnd_len = ROUNDUP64(total_len);
! 522: if ((total_len > sc->wi_usb_txmemsize[id]) ||
! 523: (rnd_len > WI_USB_BUFSZ )){
! 524: printf("invalid packet len: %x memsz %x max %x\n",
! 525: total_len, sc->wi_usb_txmemsize[id], WI_USB_BUFSZ);
! 526: total_len = sc->wi_usb_txmemsize[id];
! 527:
! 528: err = EIO;
! 529: goto err_ret;
! 530: }
! 531:
! 532: sc->txresp = WI_CMD_TX;
! 533: sc->txresperr = 0;
! 534:
! 535: bcopy(wibuf, c->wi_usb_buf, total_len);
! 536:
! 537: bzero(((char *)c->wi_usb_buf)+total_len,
! 538: rnd_len - total_len);
! 539:
! 540: /* zero old packet for next TX */
! 541: bzero(wibuf, total_len);
! 542:
! 543: total_len = rnd_len;
! 544:
! 545: DPRINTFN(5,("%s: %s: id=%x len=%x\n",
! 546: sc->wi_usb_dev.dv_xname, __func__, id, total_len));
! 547:
! 548: usbd_setup_xfer(c->wi_usb_xfer, sc->wi_usb_ep[WI_USB_ENDPT_TX],
! 549: c, c->wi_usb_buf, rnd_len,
! 550: USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
! 551: WI_USB_TX_TIMEOUT, wi_usb_txeof_frm);
! 552:
! 553: err = usbd_transfer(c->wi_usb_xfer);
! 554: if (err != USBD_IN_PROGRESS && err != USBD_NORMAL_COMPLETION) {
! 555: printf("%s: %s: error=%s\n",
! 556: sc->wi_usb_dev.dv_xname, __func__,
! 557: usbd_errstr(err));
! 558: /* Stop the interface from process context. */
! 559: wi_usb_stop(sc);
! 560: err = EIO;
! 561: } else {
! 562: err = 0;
! 563: }
! 564:
! 565: DPRINTFN(5,("%s: %s: exit err=%x\n",
! 566: sc->wi_usb_dev.dv_xname, __func__, err));
! 567: err_ret:
! 568: return err;
! 569: }
! 570: printf("%s:%s: invalid packet id sent %x\n",
! 571: sc->wi_usb_dev.dv_xname, __func__, id);
! 572: return 0;
! 573: }
! 574:
! 575: int
! 576: wi_cmd_usb(struct wi_softc *wsc, int cmd, int val0, int val1, int val2)
! 577: {
! 578: struct wi_usb_chain *c;
! 579: struct wi_usb_softc *sc = wsc->wi_usb_cdata;
! 580: struct wi_cmdreq *pcmd;
! 581: int total_len, rnd_len;
! 582: int err;
! 583:
! 584: DPRINTFN(5,("%s: %s: enter cmd=%x %x %x %x\n",
! 585: sc->wi_usb_dev.dv_xname, __func__, cmd, val0, val1, val2));
! 586:
! 587: if ((cmd & WI_CMD_CODE_MASK) == WI_CMD_TX) {
! 588: return wi_send_packet(sc, val0);
! 589: }
! 590:
! 591:
! 592: if ((cmd & WI_CMD_CODE_MASK) == WI_CMD_INI) {
! 593: /* free alloc_nicmem regions */
! 594: while (sc->wi_usb_nummem) {
! 595: sc->wi_usb_nummem--;
! 596: free(sc->wi_usb_txmem[sc->wi_usb_nummem], M_DEVBUF);
! 597: sc->wi_usb_txmem[sc->wi_usb_nummem] = NULL;
! 598: }
! 599:
! 600: #if 0
! 601: /* if this is the first time, init, otherwise do not?? */
! 602: if (sc->wi_resetonce) {
! 603: return 0;
! 604: } else
! 605: sc->wi_resetonce = 1;
! 606: #endif
! 607: }
! 608:
! 609: wi_usb_ctl_lock(sc);
! 610:
! 611: wi_usb_tx_lock(sc);
! 612:
! 613: c = &sc->wi_usb_tx_chain[0];
! 614: pcmd = c->wi_usb_buf;
! 615:
! 616:
! 617: total_len = sizeof (struct wi_cmdreq);
! 618: rnd_len = ROUNDUP64(total_len);
! 619: if (rnd_len > WI_USB_BUFSZ) {
! 620: printf("read_record buf size err %x %x\n",
! 621: rnd_len, WI_USB_BUFSZ);
! 622: err = EIO;
! 623: goto err_ret;
! 624: }
! 625:
! 626: sc->cmdresp = cmd;
! 627: sc->cmdresperr = 0;
! 628:
! 629: pcmd->type = htole16(WI_USB_CMDREQ);
! 630: pcmd->cmd = htole16(cmd);
! 631: pcmd->param0 = htole16(val0);
! 632: pcmd->param1 = htole16(val1);
! 633: pcmd->param2 = htole16(val2);
! 634:
! 635: bzero(((char*)pcmd)+total_len, rnd_len - total_len);
! 636:
! 637: total_len = rnd_len;
! 638:
! 639: usbd_setup_xfer(c->wi_usb_xfer, sc->wi_usb_ep[WI_USB_ENDPT_TX],
! 640: c, c->wi_usb_buf, rnd_len, USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
! 641: WI_USB_TX_TIMEOUT, wi_usb_txeof);
! 642:
! 643: err = wi_usb_do_transmit_sync(sc, c, &sc->cmdresperr);
! 644:
! 645: if (err == 0)
! 646: err = sc->cmdresperr;
! 647:
! 648: sc->cmdresperr = 0;
! 649:
! 650: err_ret:
! 651: wi_usb_tx_unlock(sc);
! 652:
! 653: wi_usb_ctl_unlock(sc);
! 654:
! 655: DPRINTFN(5,("%s: %s: exit err=%x\n",
! 656: sc->wi_usb_dev.dv_xname, __func__, err));
! 657: return err;
! 658: }
! 659:
! 660:
! 661: int
! 662: wi_read_record_usb(struct wi_softc *wsc, struct wi_ltv_gen *ltv)
! 663: {
! 664: struct wi_usb_chain *c;
! 665: struct wi_usb_softc *sc = wsc->wi_usb_cdata;
! 666: struct wi_rridreq *prid;
! 667: int total_len, rnd_len;
! 668: int err;
! 669: struct wi_ltv_gen *oltv, p2ltv;
! 670:
! 671: DPRINTFN(5,("%s: %s: enter rid=%x\n",
! 672: sc->wi_usb_dev.dv_xname, __func__, ltv->wi_type));
! 673:
! 674: /* Do we need to deal with these here, as in _io version?
! 675: * WI_RID_ENCRYPTION -> WI_RID_P2_ENCRYPTION
! 676: * WI_RID_TX_CRYPT_KEY -> WI_RID_P2_TX_CRYPT_KEY
! 677: */
! 678: if (wsc->sc_firmware_type != WI_LUCENT) {
! 679: oltv = ltv;
! 680: switch (ltv->wi_type) {
! 681: case WI_RID_ENCRYPTION:
! 682: p2ltv.wi_type = WI_RID_P2_ENCRYPTION;
! 683: p2ltv.wi_len = 2;
! 684: ltv = &p2ltv;
! 685: break;
! 686: case WI_RID_TX_CRYPT_KEY:
! 687: if (ltv->wi_val > WI_NLTV_KEYS)
! 688: return (EINVAL);
! 689: p2ltv.wi_type = WI_RID_P2_TX_CRYPT_KEY;
! 690: p2ltv.wi_len = 2;
! 691: ltv = &p2ltv;
! 692: break;
! 693: }
! 694: }
! 695:
! 696: wi_usb_tx_lock(sc);
! 697:
! 698: c = &sc->wi_usb_tx_chain[0];
! 699: prid = c->wi_usb_buf;
! 700:
! 701: total_len = sizeof(struct wi_rridreq);
! 702: rnd_len = ROUNDUP64(total_len);
! 703:
! 704: if (rnd_len > WI_USB_BUFSZ) {
! 705: printf("read_record buf size err %x %x\n",
! 706: rnd_len, WI_USB_BUFSZ);
! 707: wi_usb_tx_unlock(sc);
! 708: return EIO;
! 709: }
! 710:
! 711: sc->ridltv = ltv;
! 712: sc->ridresperr = 0;
! 713:
! 714: prid->type = htole16(WI_USB_RRIDREQ);
! 715: prid->frmlen = htole16(2); /* variable size? */
! 716: prid->rid = htole16(ltv->wi_type);
! 717:
! 718: bzero(((char*)prid)+total_len, rnd_len - total_len);
! 719:
! 720: usbd_setup_xfer(c->wi_usb_xfer, sc->wi_usb_ep[WI_USB_ENDPT_TX],
! 721: c, c->wi_usb_buf, rnd_len, USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
! 722: WI_USB_TX_TIMEOUT, wi_usb_txeof);
! 723:
! 724: DPRINTFN(10,("%s: %s: total_len=%x, wilen %d\n",
! 725: sc->wi_usb_dev.dv_xname, __func__, total_len, ltv->wi_len));
! 726:
! 727: err = wi_usb_do_transmit_sync(sc, c, &sc->ridresperr);
! 728:
! 729: /* Do we need to deal with these here, as in _io version?
! 730: *
! 731: * WI_RID_TX_RATE
! 732: * WI_RID_CUR_TX_RATE
! 733: * WI_RID_ENCRYPTION
! 734: * WI_RID_TX_CRYPT_KEY
! 735: * WI_RID_CNFAUTHMODE
! 736: */
! 737: if (ltv->wi_type == WI_RID_PORTTYPE && wsc->wi_ptype == WI_PORTTYPE_IBSS
! 738: && ltv->wi_val == wsc->wi_ibss_port) {
! 739: /*
! 740: * Convert vendor IBSS port type to WI_PORTTYPE_IBSS.
! 741: * Since Lucent uses port type 1 for BSS *and* IBSS we
! 742: * have to rely on wi_ptype to distinguish this for us.
! 743: */
! 744: ltv->wi_val = htole16(WI_PORTTYPE_IBSS);
! 745: } else if (wsc->sc_firmware_type != WI_LUCENT) {
! 746: int v;
! 747:
! 748: switch (oltv->wi_type) {
! 749: case WI_RID_TX_RATE:
! 750: case WI_RID_CUR_TX_RATE:
! 751: switch (letoh16(ltv->wi_val)) {
! 752: case 1: v = 1; break;
! 753: case 2: v = 2; break;
! 754: case 3: v = 6; break;
! 755: case 4: v = 5; break;
! 756: case 7: v = 7; break;
! 757: case 8: v = 11; break;
! 758: case 15: v = 3; break;
! 759: default: v = 0x100 + letoh16(ltv->wi_val); break;
! 760: }
! 761: oltv->wi_val = htole16(v);
! 762: break;
! 763: case WI_RID_ENCRYPTION:
! 764: oltv->wi_len = 2;
! 765: if (ltv->wi_val & htole16(0x01))
! 766: oltv->wi_val = htole16(1);
! 767: else
! 768: oltv->wi_val = htole16(0);
! 769: break;
! 770: case WI_RID_TX_CRYPT_KEY:
! 771: case WI_RID_CNFAUTHMODE:
! 772: oltv->wi_len = 2;
! 773: oltv->wi_val = ltv->wi_val;
! 774: break;
! 775: }
! 776: }
! 777:
! 778: if (err == 0)
! 779: err = sc->ridresperr;
! 780:
! 781: sc->ridresperr = 0;
! 782:
! 783: wi_usb_tx_unlock(sc);
! 784:
! 785: DPRINTFN(5,("%s: %s: exit err=%x\n",
! 786: sc->wi_usb_dev.dv_xname, __func__, err));
! 787: return err;
! 788: }
! 789:
! 790: int
! 791: wi_write_record_usb(struct wi_softc *wsc, struct wi_ltv_gen *ltv)
! 792: {
! 793: struct wi_usb_chain *c;
! 794: struct wi_usb_softc *sc = wsc->wi_usb_cdata;
! 795: struct wi_wridreq *prid;
! 796: int total_len, rnd_len;
! 797: int err;
! 798: struct wi_ltv_gen p2ltv;
! 799: u_int16_t val = 0;
! 800: int i;
! 801:
! 802: DPRINTFN(5,("%s: %s: enter rid=%x wi_len %d copying %x\n",
! 803: sc->wi_usb_dev.dv_xname, __func__, ltv->wi_type, ltv->wi_len,
! 804: (ltv->wi_len-1)*2 ));
! 805:
! 806: /* Do we need to deal with these here, as in _io version?
! 807: * WI_PORTTYPE_IBSS -> WI_RID_PORTTYPE
! 808: * RID_TX_RATE munging
! 809: * RID_ENCRYPTION
! 810: * WI_RID_TX_CRYPT_KEY
! 811: * WI_RID_DEFLT_CRYPT_KEYS
! 812: */
! 813: if (ltv->wi_type == WI_RID_PORTTYPE &&
! 814: letoh16(ltv->wi_val) == WI_PORTTYPE_IBSS) {
! 815: /* Convert WI_PORTTYPE_IBSS to vendor IBSS port type. */
! 816: p2ltv.wi_type = WI_RID_PORTTYPE;
! 817: p2ltv.wi_len = 2;
! 818: p2ltv.wi_val = wsc->wi_ibss_port;
! 819: ltv = &p2ltv;
! 820: } else if (wsc->sc_firmware_type != WI_LUCENT) {
! 821: int v;
! 822:
! 823: switch (ltv->wi_type) {
! 824: case WI_RID_TX_RATE:
! 825: p2ltv.wi_type = WI_RID_TX_RATE;
! 826: p2ltv.wi_len = 2;
! 827: switch (letoh16(ltv->wi_val)) {
! 828: case 1: v = 1; break;
! 829: case 2: v = 2; break;
! 830: case 3: v = 15; break;
! 831: case 5: v = 4; break;
! 832: case 6: v = 3; break;
! 833: case 7: v = 7; break;
! 834: case 11: v = 8; break;
! 835: default: return EINVAL;
! 836: }
! 837: p2ltv.wi_val = htole16(v);
! 838: ltv = &p2ltv;
! 839: break;
! 840: case WI_RID_ENCRYPTION:
! 841: p2ltv.wi_type = WI_RID_P2_ENCRYPTION;
! 842: p2ltv.wi_len = 2;
! 843: if (ltv->wi_val & htole16(0x01)) {
! 844: val = PRIVACY_INVOKED;
! 845: /*
! 846: * If using shared key WEP we must set the
! 847: * EXCLUDE_UNENCRYPTED bit. Symbol cards
! 848: * need this bit set even when not using
! 849: * shared key. We can't just test for
! 850: * IEEE80211_AUTH_SHARED since Symbol cards
! 851: * have 2 shared key modes.
! 852: */
! 853: if (wsc->wi_authtype != IEEE80211_AUTH_OPEN ||
! 854: wsc->sc_firmware_type == WI_SYMBOL)
! 855: val |= EXCLUDE_UNENCRYPTED;
! 856:
! 857: switch (wsc->wi_crypto_algorithm) {
! 858: case WI_CRYPTO_FIRMWARE_WEP:
! 859: /*
! 860: * TX encryption is broken in
! 861: * Host AP mode.
! 862: */
! 863: if (wsc->wi_ptype == WI_PORTTYPE_HOSTAP)
! 864: val |= HOST_ENCRYPT;
! 865: break;
! 866: case WI_CRYPTO_SOFTWARE_WEP:
! 867: val |= HOST_ENCRYPT|HOST_DECRYPT;
! 868: break;
! 869: }
! 870: p2ltv.wi_val = htole16(val);
! 871: } else
! 872: p2ltv.wi_val = htole16(HOST_ENCRYPT | HOST_DECRYPT);
! 873: ltv = &p2ltv;
! 874: break;
! 875: case WI_RID_TX_CRYPT_KEY:
! 876: if (ltv->wi_val > WI_NLTV_KEYS)
! 877: return (EINVAL);
! 878: p2ltv.wi_type = WI_RID_P2_TX_CRYPT_KEY;
! 879: p2ltv.wi_len = 2;
! 880: p2ltv.wi_val = ltv->wi_val;
! 881: ltv = &p2ltv;
! 882: break;
! 883: case WI_RID_DEFLT_CRYPT_KEYS: {
! 884: int error;
! 885: int keylen;
! 886: struct wi_ltv_str ws;
! 887: struct wi_ltv_keys *wk;
! 888:
! 889: wk = (struct wi_ltv_keys *)ltv;
! 890: keylen = wk->wi_keys[wsc->wi_tx_key].wi_keylen;
! 891: keylen = letoh16(keylen);
! 892:
! 893: for (i = 0; i < 4; i++) {
! 894: bzero(&ws, sizeof(ws));
! 895: ws.wi_len = (keylen > 5) ? 8 : 4;
! 896: ws.wi_type = WI_RID_P2_CRYPT_KEY0 + i;
! 897: bcopy(&wk->wi_keys[i].wi_keydat,
! 898: ws.wi_str, keylen);
! 899: error = wi_write_record_usb(wsc,
! 900: (struct wi_ltv_gen *)&ws);
! 901: if (error)
! 902: return (error);
! 903: }
! 904: }
! 905: return (0);
! 906: }
! 907: }
! 908:
! 909: wi_usb_tx_lock(sc);
! 910:
! 911: c = &sc->wi_usb_tx_chain[0];
! 912:
! 913: prid = c->wi_usb_buf;
! 914:
! 915: total_len = sizeof(prid->type) + sizeof(prid->frmlen) +
! 916: sizeof(prid->rid) + (ltv->wi_len-1)*2;
! 917: rnd_len = ROUNDUP64(total_len);
! 918: if (rnd_len > WI_USB_BUFSZ) {
! 919: printf("write_record buf size err %x %x\n",
! 920: rnd_len, WI_USB_BUFSZ);
! 921: wi_usb_tx_unlock(sc);
! 922: return EIO;
! 923: }
! 924:
! 925: prid->type = htole16(WI_USB_WRIDREQ);
! 926: prid->frmlen = htole16(ltv->wi_len);
! 927: prid->rid = htole16(ltv->wi_type);
! 928: if (ltv->wi_len > 1)
! 929: bcopy((u_int8_t *)<v->wi_val, (u_int8_t *)&prid->data[0],
! 930: (ltv->wi_len-1)*2);
! 931:
! 932: bzero(((char*)prid)+total_len, rnd_len - total_len);
! 933:
! 934: usbd_setup_xfer(c->wi_usb_xfer, sc->wi_usb_ep[WI_USB_ENDPT_TX],
! 935: c, c->wi_usb_buf, rnd_len, USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
! 936: WI_USB_TX_TIMEOUT, wi_usb_txeof);
! 937:
! 938: err = wi_usb_do_transmit_sync(sc, c, &sc->ridresperr);
! 939:
! 940: if (err == 0)
! 941: err = sc->ridresperr;
! 942:
! 943: sc->ridresperr = 0;
! 944:
! 945: wi_usb_tx_unlock(sc);
! 946:
! 947: DPRINTFN(5,("%s: %s: exit err=%x\n",
! 948: sc->wi_usb_dev.dv_xname, __func__, err));
! 949: return err;
! 950: }
! 951:
! 952: /*
! 953: * This is an ugly compat portion to emulate the I/O which writes
! 954: * a packet or management information
! 955: * The data is copied into local memory for the requested
! 956: * 'id' then on the wi_cmd WI_CMD_TX, the id argument
! 957: * will identify which buffer to use
! 958: */
! 959: int
! 960: wi_alloc_nicmem_usb(struct wi_softc *wsc, int len, int *id)
! 961: {
! 962: int nmem;
! 963: struct wi_usb_softc *sc = wsc->wi_usb_cdata;
! 964:
! 965: DPRINTFN(10,("%s: %s: enter len=%x\n",
! 966: sc->wi_usb_dev.dv_xname, __func__, len));
! 967:
! 968: /*
! 969: * NOTE THIS IS A USB DEVICE WHICH WILL LIKELY HAVE MANY
! 970: * CONNECTS/DISCONNECTS, FREE THIS MEMORY XXX XXX XXX !!! !!!
! 971: */
! 972: nmem = sc->wi_usb_nummem++;
! 973:
! 974: if (nmem >= MAX_WI_NMEM) {
! 975: sc->wi_usb_nummem--;
! 976: return ENOMEM;
! 977: }
! 978:
! 979: sc->wi_usb_txmem[nmem] = malloc(len, M_DEVBUF, M_WAITOK);
! 980: if (sc->wi_usb_txmem[nmem] == NULL) {
! 981: sc->wi_usb_nummem--;
! 982: return ENOMEM;
! 983: }
! 984: sc->wi_usb_txmemsize[nmem] = len;
! 985:
! 986: *id = nmem;
! 987: return 0;
! 988: }
! 989:
! 990: /*
! 991: * this is crazy, we skip the first 16 bits of the buf so that it
! 992: * can be used as the 'type' of the usb transfer.
! 993: */
! 994:
! 995:
! 996: int
! 997: wi_write_data_usb(struct wi_softc *wsc, int id, int off, caddr_t buf, int len)
! 998: {
! 999: u_int8_t *ptr;
! 1000: struct wi_usb_softc *sc = wsc->wi_usb_cdata;
! 1001:
! 1002: DPRINTFN(10,("%s: %s: id %x off %x len %d\n",
! 1003: sc->wi_usb_dev.dv_xname, __func__, id, off, len));
! 1004:
! 1005: if (id < 0 && id >= sc->wi_usb_nummem)
! 1006: return EIO;
! 1007:
! 1008: ptr = (u_int8_t *)(sc->wi_usb_txmem[id]) + off;
! 1009:
! 1010: if (len + off > sc->wi_usb_txmemsize[id])
! 1011: return EIO;
! 1012: DPRINTFN(10,("%s: %s: completed \n",
! 1013: sc->wi_usb_dev.dv_xname, __func__));
! 1014:
! 1015: bcopy(buf, ptr, len);
! 1016: return 0;
! 1017: }
! 1018:
! 1019: /*
! 1020: * On the prism I/O, this read_data points to the hardware buffer
! 1021: * which contains the
! 1022: */
! 1023: int
! 1024: wi_read_data_usb(struct wi_softc *wsc, int id, int off, caddr_t buf, int len)
! 1025: {
! 1026: u_int8_t *ptr;
! 1027: struct wi_usb_softc *sc = wsc->wi_usb_cdata;
! 1028:
! 1029: DPRINTFN(10,("%s: %s: id %x off %x len %d\n",
! 1030: sc->wi_usb_dev.dv_xname, __func__, id, off, len));
! 1031:
! 1032: if (id == 0x1001 && sc->wi_info != NULL)
! 1033: ptr = (u_int8_t *)sc->wi_info + off;
! 1034: else if (id == 0x1000 && sc->wi_rxframe != NULL)
! 1035: ptr = (u_int8_t *)sc->wi_rxframe + off;
! 1036: else if (id >= 0 && id < sc->wi_usb_nummem) {
! 1037:
! 1038: if (sc->wi_usb_txmem[id] == NULL)
! 1039: return EIO;
! 1040: if (len + off > sc->wi_usb_txmemsize[id])
! 1041: return EIO;
! 1042:
! 1043: ptr = (u_int8_t *)(sc->wi_usb_txmem[id]) + off;
! 1044: } else
! 1045: return EIO;
! 1046:
! 1047: if (id < sc->wi_usb_nummem) {
! 1048: ptr = (u_int8_t *)(sc->wi_usb_txmem[id]) + off;
! 1049:
! 1050: if (len + off > sc->wi_usb_txmemsize[id])
! 1051: return EIO;
! 1052: }
! 1053:
! 1054: bcopy(ptr, buf, len);
! 1055: return 0;
! 1056: }
! 1057:
! 1058: void
! 1059: wi_usb_stop(struct wi_usb_softc *sc)
! 1060: {
! 1061: DPRINTFN(1,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname,__func__));
! 1062: /* XXX */
! 1063:
! 1064: /* Stop transfers */
! 1065: }
! 1066:
! 1067: int
! 1068: wi_usb_do_transmit_sync(struct wi_usb_softc *sc, struct wi_usb_chain *c,
! 1069: void *ident)
! 1070: {
! 1071: usbd_status err;
! 1072:
! 1073: DPRINTFN(10,("%s: %s:\n",
! 1074: sc->wi_usb_dev.dv_xname, __func__));
! 1075:
! 1076: sc->wi_usb_refcnt++;
! 1077: err = usbd_transfer(c->wi_usb_xfer);
! 1078: if (err != USBD_IN_PROGRESS && err != USBD_NORMAL_COMPLETION) {
! 1079: printf("%s: %s error=%s\n",
! 1080: sc->wi_usb_dev.dv_xname, __func__,
! 1081: usbd_errstr(err));
! 1082: /* Stop the interface from process context. */
! 1083: wi_usb_stop(sc);
! 1084: err = EIO;
! 1085: goto done;
! 1086: }
! 1087: err = tsleep(ident, PRIBIO, "wiTXsync", hz*1);
! 1088: if (err) {
! 1089: DPRINTFN(1,("%s: %s: err %x\n",
! 1090: sc->wi_usb_dev.dv_xname, __func__, err));
! 1091: err = ETIMEDOUT;
! 1092: }
! 1093: done:
! 1094: if (--sc->wi_usb_refcnt < 0)
! 1095: usb_detach_wakeup(&sc->wi_usb_dev);
! 1096: return err;
! 1097: }
! 1098:
! 1099:
! 1100: /*
! 1101: * A command/rrid/wrid was sent to the chip. It's safe for us to clean up
! 1102: * the list buffers.
! 1103: */
! 1104:
! 1105: void
! 1106: wi_usb_txeof(usbd_xfer_handle xfer, usbd_private_handle priv,
! 1107: usbd_status status)
! 1108: {
! 1109: struct wi_usb_chain *c = priv;
! 1110: struct wi_usb_softc *sc = c->wi_usb_sc;
! 1111:
! 1112: int s;
! 1113:
! 1114: if (sc->wi_usb_dying)
! 1115: return;
! 1116:
! 1117: s = splnet();
! 1118:
! 1119: DPRINTFN(10,("%s: %s: enter status=%d\n", sc->wi_usb_dev.dv_xname,
! 1120: __func__, status));
! 1121:
! 1122: if (status != USBD_NORMAL_COMPLETION) {
! 1123: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
! 1124: splx(s);
! 1125: return;
! 1126: }
! 1127: printf("%s: usb error on tx: %s\n", sc->wi_usb_dev.dv_xname,
! 1128: usbd_errstr(status));
! 1129: if (status == USBD_STALLED) {
! 1130: sc->wi_usb_refcnt++;
! 1131: usbd_clear_endpoint_stall_async(
! 1132: sc->wi_usb_ep[WI_USB_ENDPT_TX]);
! 1133: if (--sc->wi_usb_refcnt < 0)
! 1134: usb_detach_wakeup(&sc->wi_usb_dev);
! 1135: }
! 1136: splx(s);
! 1137: return;
! 1138: }
! 1139:
! 1140: splx(s);
! 1141: }
! 1142:
! 1143: /*
! 1144: * A packet was sent to the chip. It's safe for us to clean up
! 1145: * the list buffers.
! 1146: */
! 1147:
! 1148: void
! 1149: wi_usb_txeof_frm(usbd_xfer_handle xfer, usbd_private_handle priv,
! 1150: usbd_status status)
! 1151: {
! 1152: struct wi_usb_chain *c = priv;
! 1153: struct wi_usb_softc *sc = c->wi_usb_sc;
! 1154: struct wi_softc *wsc = &sc->sc_wi;
! 1155: struct ifnet *ifp = &wsc->sc_ic.ic_if;
! 1156:
! 1157: int s;
! 1158: int err = 0;
! 1159:
! 1160: if (sc->wi_usb_dying)
! 1161: return;
! 1162:
! 1163: s = splnet();
! 1164:
! 1165: DPRINTFN(10,("%s: %s: enter status=%d\n", sc->wi_usb_dev.dv_xname,
! 1166: __func__, status));
! 1167:
! 1168: if (status != USBD_NORMAL_COMPLETION) {
! 1169: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
! 1170: splx(s);
! 1171: return;
! 1172: }
! 1173: printf("%s: usb error on tx: %s\n", sc->wi_usb_dev.dv_xname,
! 1174: usbd_errstr(status));
! 1175: if (status == USBD_STALLED) {
! 1176: sc->wi_usb_refcnt++;
! 1177: usbd_clear_endpoint_stall_async(
! 1178: sc->wi_usb_ep[WI_USB_ENDPT_TX]);
! 1179: if (--sc->wi_usb_refcnt < 0)
! 1180: usb_detach_wakeup(&sc->wi_usb_dev);
! 1181: }
! 1182: splx(s);
! 1183: return;
! 1184: }
! 1185:
! 1186: if (status)
! 1187: err = WI_EV_TX_EXC;
! 1188:
! 1189: wi_txeof(wsc, err);
! 1190:
! 1191: wi_usb_tx_unlock(sc);
! 1192:
! 1193: if (!IFQ_IS_EMPTY(&ifp->if_snd))
! 1194: wi_start_usb(ifp);
! 1195:
! 1196: splx(s);
! 1197: }
! 1198:
! 1199: int
! 1200: wi_usb_rx_list_init(struct wi_usb_softc *sc)
! 1201: {
! 1202: struct wi_usb_chain *c;
! 1203: int i;
! 1204:
! 1205: DPRINTFN(10,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname, __func__));
! 1206:
! 1207: for (i = 0; i < WI_USB_RX_LIST_CNT; i++) {
! 1208: c = &sc->wi_usb_rx_chain[i];
! 1209: c->wi_usb_sc = sc;
! 1210: c->wi_usb_idx = i;
! 1211: if (c->wi_usb_xfer != NULL) {
! 1212: printf("UGH RX\n");
! 1213: }
! 1214: if (c->wi_usb_xfer == NULL) {
! 1215: c->wi_usb_xfer = usbd_alloc_xfer(sc->wi_usb_udev);
! 1216: if (c->wi_usb_xfer == NULL)
! 1217: return (ENOBUFS);
! 1218: c->wi_usb_buf = usbd_alloc_buffer(c->wi_usb_xfer,
! 1219: WI_USB_BUFSZ);
! 1220: if (c->wi_usb_buf == NULL)
! 1221: return (ENOBUFS); /* XXX free xfer */
! 1222: }
! 1223: }
! 1224:
! 1225: return (0);
! 1226: }
! 1227:
! 1228: int
! 1229: wi_usb_tx_list_init(struct wi_usb_softc *sc)
! 1230: {
! 1231: struct wi_usb_chain *c;
! 1232: int i;
! 1233:
! 1234: DPRINTFN(10,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname, __func__));
! 1235:
! 1236: for (i = 0; i < WI_USB_TX_LIST_CNT; i++) {
! 1237: c = &sc->wi_usb_tx_chain[i];
! 1238: c->wi_usb_sc = sc;
! 1239: c->wi_usb_idx = i;
! 1240: c->wi_usb_mbuf = NULL;
! 1241: if (c->wi_usb_xfer != NULL) {
! 1242: printf("UGH TX\n");
! 1243: }
! 1244: if (c->wi_usb_xfer == NULL) {
! 1245: c->wi_usb_xfer = usbd_alloc_xfer(sc->wi_usb_udev);
! 1246: if (c->wi_usb_xfer == NULL)
! 1247: return (ENOBUFS);
! 1248: c->wi_usb_buf = usbd_alloc_buffer(c->wi_usb_xfer,
! 1249: WI_USB_BUFSZ);
! 1250: if (c->wi_usb_buf == NULL)
! 1251: return (ENOBUFS);
! 1252: }
! 1253: }
! 1254:
! 1255: return (0);
! 1256: }
! 1257:
! 1258: int
! 1259: wi_usb_open_pipes(struct wi_usb_softc *sc)
! 1260: {
! 1261: usbd_status err;
! 1262: int error = 0;
! 1263: struct wi_usb_chain *c;
! 1264: int i;
! 1265:
! 1266: DPRINTFN(10,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname,__func__));
! 1267:
! 1268: sc->wi_usb_refcnt++;
! 1269:
! 1270: /* Open RX and TX pipes. */
! 1271: err = usbd_open_pipe(sc->wi_usb_iface, sc->wi_usb_ed[WI_USB_ENDPT_RX],
! 1272: USBD_EXCLUSIVE_USE, &sc->wi_usb_ep[WI_USB_ENDPT_RX]);
! 1273: if (err) {
! 1274: printf("%s: open rx pipe failed: %s\n",
! 1275: sc->wi_usb_dev.dv_xname, usbd_errstr(err));
! 1276: error = EIO;
! 1277: goto done;
! 1278: }
! 1279:
! 1280: err = usbd_open_pipe(sc->wi_usb_iface, sc->wi_usb_ed[WI_USB_ENDPT_TX],
! 1281: USBD_EXCLUSIVE_USE, &sc->wi_usb_ep[WI_USB_ENDPT_TX]);
! 1282: if (err) {
! 1283: printf("%s: open tx pipe failed: %s\n",
! 1284: sc->wi_usb_dev.dv_xname, usbd_errstr(err));
! 1285: error = EIO;
! 1286: goto done;
! 1287: }
! 1288:
! 1289: /* is this used? */
! 1290: err = usbd_open_pipe_intr(sc->wi_usb_iface,
! 1291: sc->wi_usb_ed[WI_USB_ENDPT_INTR], USBD_EXCLUSIVE_USE,
! 1292: &sc->wi_usb_ep[WI_USB_ENDPT_INTR], sc, &sc->wi_usb_ibuf,
! 1293: WI_USB_INTR_PKTLEN, wi_usb_intr, WI_USB_INTR_INTERVAL);
! 1294: if (err) {
! 1295: printf("%s: open intr pipe failed: %s\n",
! 1296: sc->wi_usb_dev.dv_xname, usbd_errstr(err));
! 1297: error = EIO;
! 1298: goto done;
! 1299: }
! 1300:
! 1301: /* Start up the receive pipe. */
! 1302: for (i = 0; i < WI_USB_RX_LIST_CNT; i++) {
! 1303: c = &sc->wi_usb_rx_chain[i];
! 1304: usbd_setup_xfer(c->wi_usb_xfer, sc->wi_usb_ep[WI_USB_ENDPT_RX],
! 1305: c, c->wi_usb_buf, WI_USB_BUFSZ,
! 1306: USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,
! 1307: wi_usb_rxeof);
! 1308: DPRINTFN(10,("%s: %s: start read\n", sc->wi_usb_dev.dv_xname,
! 1309: __func__));
! 1310: usbd_transfer(c->wi_usb_xfer);
! 1311: }
! 1312:
! 1313: done:
! 1314: if (--sc->wi_usb_refcnt < 0)
! 1315: usb_detach_wakeup(&sc->wi_usb_dev);
! 1316:
! 1317: return (error);
! 1318: }
! 1319:
! 1320: /*
! 1321: * This is a bit of a kludge, however wi_rxeof and wi_update_stats
! 1322: * call wi_get_fid to determine where the data associated with
! 1323: * the transaction is located, the returned id is then used to
! 1324: * wi_read_data the information out.
! 1325: *
! 1326: * This code returns which 'fid' should be used. The results are only valid
! 1327: * during a wi_usb_rxeof because the data is received packet is 'held'
! 1328: * an a variable for reading by wi_read_data_usb for that period.
! 1329: *
! 1330: * for magic numbers this uses 0x1000, 0x1001 for rx/info
! 1331: */
! 1332:
! 1333: int
! 1334: wi_get_fid_usb(struct wi_softc *sc, int fid)
! 1335: {
! 1336: switch (fid) {
! 1337: case WI_RX_FID:
! 1338: return 0x1000;
! 1339: case WI_INFO_FID:
! 1340: return 0x1001;
! 1341: default:
! 1342: return 0x1111;
! 1343: }
! 1344:
! 1345: }
! 1346:
! 1347: int
! 1348: wi_usb_activate(struct device *self, enum devact act)
! 1349: {
! 1350: struct wi_usb_softc *sc = (struct wi_usb_softc *)self;
! 1351:
! 1352: DPRINTFN(10,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname, __func__));
! 1353:
! 1354: switch (act) {
! 1355: case DVACT_ACTIVATE:
! 1356: break;
! 1357:
! 1358: case DVACT_DEACTIVATE:
! 1359: sc->wi_usb_dying = 1;
! 1360: sc->wi_thread_info->dying = 1;
! 1361: break;
! 1362: }
! 1363: return (0);
! 1364: }
! 1365:
! 1366: #if 0
! 1367: void
! 1368: wi_dump_data(void *buffer, int len)
! 1369: {
! 1370: int i;
! 1371: for (i = 0; i < len; i++) {
! 1372: if (((i) % 16) == 0)
! 1373: printf("\n %02x:", i);
! 1374: printf(" %02x",
! 1375: ((uint8_t *)(buffer))[i]);
! 1376:
! 1377: }
! 1378: printf("\n");
! 1379:
! 1380: }
! 1381: #endif
! 1382:
! 1383: /*
! 1384: * A frame has been received.
! 1385: */
! 1386: void
! 1387: wi_usb_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
! 1388: {
! 1389: struct wi_usb_chain *c = priv;
! 1390: struct wi_usb_softc *sc = c->wi_usb_sc;
! 1391: wi_usb_usbin *uin;
! 1392: int total_len = 0;
! 1393: u_int16_t rtype;
! 1394:
! 1395: if (sc->wi_usb_dying)
! 1396: return;
! 1397:
! 1398: DPRINTFN(10,("%s: %s: enter status=%d\n", sc->wi_usb_dev.dv_xname,
! 1399: __func__, status));
! 1400:
! 1401:
! 1402: if (status != USBD_NORMAL_COMPLETION) {
! 1403: if (status == USBD_NOT_STARTED || status == USBD_IOERROR
! 1404: || status == USBD_CANCELLED) {
! 1405: printf("%s: %u usb errors on rx: %s\n",
! 1406: sc->wi_usb_dev.dv_xname, 1,
! 1407: /* sc->wi_usb_rx_errs, */
! 1408: usbd_errstr(status));
! 1409: return;
! 1410: }
! 1411: #if 0
! 1412: sc->wi_usb_rx_errs++;
! 1413: if (usbd_ratecheck(&sc->wi_usb_rx_notice)) {
! 1414: printf("%s: %u usb errors on rx: %s\n",
! 1415: sc->wi_usb_dev.dv_xname, sc->wi_usb_rx_errs,
! 1416: usbd_errstr(status));
! 1417: sc->wi_usb_rx_errs = 0;
! 1418: }
! 1419: #endif
! 1420: if (status == USBD_STALLED) {
! 1421: sc->wi_usb_refcnt++;
! 1422: usbd_clear_endpoint_stall_async(
! 1423: sc->wi_usb_ep[WI_USB_ENDPT_RX]);
! 1424: if (--sc->wi_usb_refcnt < 0)
! 1425: usb_detach_wakeup(&sc->wi_usb_dev);
! 1426: }
! 1427: goto done;
! 1428: }
! 1429:
! 1430: usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
! 1431:
! 1432: if (total_len < 6) /* short XXX */
! 1433: goto done;
! 1434:
! 1435: uin = (wi_usb_usbin *)(c->wi_usb_buf);
! 1436:
! 1437: rtype = letoh16(uin->type);
! 1438:
! 1439:
! 1440: #if 0
! 1441: wi_dump_data(c->wi_usb_buf, total_len);
! 1442: #endif
! 1443:
! 1444: if (WI_USB_ISRXFRM(rtype)) {
! 1445: wi_usb_rxfrm(sc, uin, total_len);
! 1446: goto done;
! 1447: }
! 1448: if (WI_USB_ISTXFRM(rtype)) {
! 1449: DPRINTFN(2,("%s: %s: txfrm type %x\n",
! 1450: sc->wi_usb_dev.dv_xname, __func__, rtype));
! 1451: wi_usb_txfrm(sc, uin, total_len);
! 1452: goto done;
! 1453: }
! 1454:
! 1455: switch (rtype) {
! 1456: case WI_USB_INFOFRM:
! 1457: /* info packet, INFO_FID hmm */
! 1458: DPRINTFN(10,("%s: %s: infofrm type %x\n",
! 1459: sc->wi_usb_dev.dv_xname, __func__, rtype));
! 1460: wi_usb_infofrm(c, total_len);
! 1461: break;
! 1462: case WI_USB_CMDRESP:
! 1463: wi_usb_cmdresp(c);
! 1464: break;
! 1465: case WI_USB_WRIDRESP:
! 1466: wi_usb_wridresp(c);
! 1467: break;
! 1468: case WI_USB_RRIDRESP:
! 1469: wi_usb_rridresp(c);
! 1470: break;
! 1471: case WI_USB_WMEMRESP:
! 1472: /* Not currently used */
! 1473: DPRINTFN(2,("%s: %s: wmemresp type %x\n",
! 1474: sc->wi_usb_dev.dv_xname, __func__, rtype));
! 1475: break;
! 1476: case WI_USB_RMEMRESP:
! 1477: /* Not currently used */
! 1478: DPRINTFN(2,("%s: %s: rmemresp type %x\n",
! 1479: sc->wi_usb_dev.dv_xname, __func__, rtype));
! 1480: break;
! 1481: case WI_USB_BUFAVAIL:
! 1482: printf("wi_usb: received USB_BUFAVAIL packet\n"); /* XXX */
! 1483: break;
! 1484: case WI_USB_ERROR:
! 1485: printf("wi_usb: received USB_ERROR packet\n"); /* XXX */
! 1486: break;
! 1487: #if 0
! 1488: default:
! 1489: printf("wi_usb: received Unknown packet 0x%x len %x\n",
! 1490: rtype, total_len);
! 1491: wi_dump_data(c->wi_usb_buf, total_len);
! 1492: #endif
! 1493: }
! 1494:
! 1495: done:
! 1496: /* Setup new transfer. */
! 1497: usbd_setup_xfer(c->wi_usb_xfer, sc->wi_usb_ep[WI_USB_ENDPT_RX],
! 1498: c, c->wi_usb_buf, WI_USB_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,
! 1499: USBD_NO_TIMEOUT, wi_usb_rxeof);
! 1500: sc->wi_usb_refcnt++;
! 1501: usbd_transfer(c->wi_usb_xfer);
! 1502: if (--sc->wi_usb_refcnt < 0)
! 1503: usb_detach_wakeup(&sc->wi_usb_dev);
! 1504:
! 1505: DPRINTFN(10,("%s: %s: start rx\n", sc->wi_usb_dev.dv_xname,
! 1506: __func__));
! 1507: }
! 1508:
! 1509: void
! 1510: wi_usb_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
! 1511: {
! 1512: struct wi_usb_softc *sc = priv;
! 1513:
! 1514: DPRINTFN(2,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname, __func__));
! 1515:
! 1516: if (sc->wi_usb_dying)
! 1517: return;
! 1518:
! 1519: if (status != USBD_NORMAL_COMPLETION) {
! 1520: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
! 1521: return;
! 1522:
! 1523: if (status == USBD_STALLED) {
! 1524: sc->wi_usb_refcnt++;
! 1525: usbd_clear_endpoint_stall_async(
! 1526: sc->wi_usb_ep[WI_USB_ENDPT_RX]);
! 1527: if (--sc->wi_usb_refcnt < 0)
! 1528: usb_detach_wakeup(&sc->wi_usb_dev);
! 1529: }
! 1530: return;
! 1531: }
! 1532: /* XXX oerrors or collisions? */
! 1533: }
! 1534: void
! 1535: wi_usb_cmdresp(struct wi_usb_chain *c)
! 1536: {
! 1537: struct wi_cmdresp *presp = (struct wi_cmdresp *)(c->wi_usb_buf);
! 1538: u_int16_t status = letoh16(presp->status);
! 1539: struct wi_usb_softc *sc = c->wi_usb_sc;
! 1540: uint16_t type;
! 1541: uint16_t cmdresperr;
! 1542:
! 1543: type = htole16(presp->type);
! 1544: cmdresperr = letoh16(presp->resp0);
! 1545: DPRINTFN(10,("%s: %s: enter type=%x, status=%x, cmdresp=%x, "
! 1546: "resp=%x,%x,%x\n",
! 1547: sc->wi_usb_dev.dv_xname, __func__, type, status, sc->cmdresp,
! 1548: cmdresperr, letoh16(presp->resp1),
! 1549: letoh16(presp->resp2)));
! 1550:
! 1551: /* XXX */
! 1552: if (sc->cmdresp != (status & WI_STAT_CMD_CODE)) {
! 1553: DPRINTFN(1,("%s: cmd ty %x st %x cmd %x failed %x\n",
! 1554: sc->wi_usb_dev.dv_xname,
! 1555: type, status, sc->cmdresp, cmdresperr));
! 1556: return;
! 1557: }
! 1558:
! 1559: sc->cmdresperr = (status & WI_STAT_CMD_RESULT) >> 8;
! 1560:
! 1561: sc->cmdresp = 0; /* good value for idle == INI ?? XXX */
! 1562:
! 1563: wakeup(&sc->cmdresperr);
! 1564: }
! 1565: void
! 1566: wi_usb_rridresp(struct wi_usb_chain *c)
! 1567: {
! 1568: struct wi_rridresp *presp = (struct wi_rridresp *)(c->wi_usb_buf);
! 1569: u_int16_t frmlen = letoh16(presp->frmlen);
! 1570: struct wi_usb_softc *sc = c->wi_usb_sc;
! 1571: struct wi_ltv_gen *ltv;
! 1572: uint16_t rid;
! 1573:
! 1574: rid = letoh16(presp->rid);
! 1575: ltv = sc->ridltv;
! 1576:
! 1577: if (ltv == 0) {
! 1578: DPRINTFN(5,("%s: %s: enter ltv = 0 rid=%x len %d\n",
! 1579: sc->wi_usb_dev.dv_xname, __func__, rid,
! 1580: frmlen));
! 1581: return;
! 1582: }
! 1583:
! 1584: DPRINTFN(5,("%s: %s: enter rid=%x expecting %x len %d exptlen %d\n",
! 1585: sc->wi_usb_dev.dv_xname, __func__, rid, ltv->wi_type,
! 1586: frmlen, ltv->wi_len));
! 1587:
! 1588: rid = letoh16(presp->rid);
! 1589:
! 1590: if (rid != ltv->wi_type) {
! 1591: sc->ridresperr = EIO;
! 1592: return;
! 1593: }
! 1594:
! 1595: if (frmlen > ltv->wi_len) {
! 1596: sc->ridresperr = ENOSPC;
! 1597: sc->ridltv = 0;
! 1598: wakeup(&sc->ridresperr);
! 1599: return;
! 1600: }
! 1601:
! 1602: ltv->wi_len = frmlen;
! 1603:
! 1604: DPRINTFN(10,("%s: %s: copying %d frmlen %d\n",
! 1605: sc->wi_usb_dev.dv_xname, __func__, (ltv->wi_len-1)*2,
! 1606: frmlen));
! 1607:
! 1608: if (ltv->wi_len > 1)
! 1609: bcopy(&presp->data[0], (u_int8_t *)<v->wi_val,
! 1610: (ltv->wi_len-1)*2);
! 1611:
! 1612: sc->ridresperr = 0;
! 1613: sc->ridltv = 0;
! 1614: wakeup(&sc->ridresperr);
! 1615:
! 1616: }
! 1617:
! 1618: void
! 1619: wi_usb_wridresp(struct wi_usb_chain *c)
! 1620: {
! 1621: struct wi_wridresp *presp = (struct wi_wridresp *)(c->wi_usb_buf);
! 1622: struct wi_usb_softc *sc = c->wi_usb_sc;
! 1623: uint16_t status;
! 1624:
! 1625: status = letoh16(presp->status);
! 1626:
! 1627: DPRINTFN(10,("%s: %s: enter status=%x\n",
! 1628: sc->wi_usb_dev.dv_xname, __func__, status));
! 1629:
! 1630: sc->ridresperr = (status & WI_STAT_CMD_RESULT) >> 8;
! 1631: sc->ridltv = 0;
! 1632: wakeup(&sc->ridresperr);
! 1633: }
! 1634:
! 1635: void
! 1636: wi_usb_infofrm(struct wi_usb_chain *c, int len)
! 1637: {
! 1638: struct wi_usb_softc *sc = c->wi_usb_sc;
! 1639:
! 1640: DPRINTFN(10,("%s: %s: enter\n",
! 1641: sc->wi_usb_dev.dv_xname, __func__));
! 1642:
! 1643: sc->wi_info = ((char *)c->wi_usb_buf) + 2;
! 1644: wi_update_stats(&sc->sc_wi);
! 1645: sc->wi_info = NULL;
! 1646: }
! 1647:
! 1648: void
! 1649: wi_usb_txfrm(struct wi_usb_softc *sc, wi_usb_usbin *uin, int total_len)
! 1650: {
! 1651: u_int16_t status;
! 1652: int s;
! 1653: struct wi_softc *wsc = &sc->sc_wi;
! 1654: struct ifnet *ifp = &wsc->sc_ic.ic_if;
! 1655:
! 1656: s = splnet();
! 1657: status = letoh16(uin->type); /* XXX -- type == status */
! 1658:
! 1659:
! 1660: DPRINTFN(2,("%s: %s: enter status=%d\n",
! 1661: sc->wi_usb_dev.dv_xname, __func__, status));
! 1662:
! 1663: if (sc->txresp == WI_CMD_TX) {
! 1664: sc->txresperr=status;
! 1665: sc->txresp = 0;
! 1666: wakeup(&sc->txresperr);
! 1667: } else {
! 1668: if (status != 0) /* XXX */
! 1669: wi_watchdog_usb(ifp);
! 1670: DPRINTFN(1,("%s: %s: txresp not expected status=%d \n",
! 1671: sc->wi_usb_dev.dv_xname, __func__, status));
! 1672: }
! 1673:
! 1674: splx(s);
! 1675: }
! 1676: void
! 1677: wi_usb_rxfrm(struct wi_usb_softc *sc, wi_usb_usbin *uin, int total_len)
! 1678: {
! 1679: int s;
! 1680:
! 1681: DPRINTFN(5,("%s: %s: enter len=%d\n",
! 1682: sc->wi_usb_dev.dv_xname, __func__, total_len));
! 1683:
! 1684: s = splnet();
! 1685:
! 1686: sc->wi_rxframe = (void *)uin;
! 1687:
! 1688: wi_rxeof(&sc->sc_wi);
! 1689:
! 1690: sc->wi_rxframe = NULL;
! 1691:
! 1692: splx(s);
! 1693:
! 1694: }
! 1695:
! 1696:
! 1697: void
! 1698: wi_usb_start_thread(void *arg)
! 1699: {
! 1700: struct wi_usb_softc *sc = arg;
! 1701: kthread_create (wi_usb_thread, arg, NULL, sc->wi_usb_dev.dv_xname);
! 1702: }
! 1703:
! 1704: void
! 1705: wi_start_usb(struct ifnet *ifp)
! 1706: {
! 1707: struct wi_softc *wsc;
! 1708: struct wi_usb_softc *sc;
! 1709: int s;
! 1710:
! 1711: wsc = ifp->if_softc;
! 1712: sc = wsc->wi_usb_cdata;
! 1713:
! 1714: s = splnet();
! 1715:
! 1716: DPRINTFN(5,("%s: %s:\n",
! 1717: sc->wi_usb_dev.dv_xname, __func__));
! 1718:
! 1719: if (wi_usb_tx_lock_try(sc)) {
! 1720: /* lock acquired do start now */
! 1721: wi_func_io.f_start(ifp);
! 1722: } else {
! 1723: sc->wi_thread_info->status |= WI_START;
! 1724: if (sc->wi_thread_info->idle)
! 1725: wakeup(sc->wi_thread_info);
! 1726: }
! 1727:
! 1728: splx(s);
! 1729: }
! 1730:
! 1731: /*
! 1732: * inquire is called from interrupt context (timeout)
! 1733: * It is not possible to sleep in interrupt context so it is necessary
! 1734: * to signal the kernel thread to perform the action.
! 1735: */
! 1736: void
! 1737: wi_init_usb(struct wi_softc *wsc)
! 1738: {
! 1739: DPRINTFN(5,("%s: %s:\n", WI_PRT_ARG(wsc), __func__));
! 1740:
! 1741: wi_usb_ctl_lock(wsc->wi_usb_cdata);
! 1742: wi_func_io.f_init(wsc);
! 1743: wi_usb_ctl_unlock(wsc->wi_usb_cdata);
! 1744: }
! 1745:
! 1746:
! 1747: /*
! 1748: * inquire is called from interrupt context (timeout)
! 1749: * It is not possible to sleep in interrupt context so it is necessary
! 1750: * to signal the kernel thread to perform the action.
! 1751: */
! 1752: void
! 1753: wi_inquire_usb(void *xsc)
! 1754: {
! 1755: struct wi_softc *wsc = xsc;
! 1756: struct wi_usb_softc *sc = wsc->wi_usb_cdata;
! 1757: int s;
! 1758:
! 1759:
! 1760: s = splnet();
! 1761:
! 1762: DPRINTFN(2,("%s: %s:\n",
! 1763: sc->wi_usb_dev.dv_xname, __func__));
! 1764:
! 1765: sc->wi_thread_info->status |= WI_INQUIRE;
! 1766:
! 1767: if (sc->wi_thread_info->idle)
! 1768: wakeup(sc->wi_thread_info);
! 1769: splx(s);
! 1770: }
! 1771:
! 1772: /*
! 1773: * Watchdog is normally called from interrupt context (timeout)
! 1774: * It is not possible to sleep in interrupt context so it is necessary
! 1775: * to signal the kernel thread to perform the action.
! 1776: */
! 1777: void
! 1778: wi_watchdog_usb(struct ifnet *ifp)
! 1779: {
! 1780: struct wi_softc *wsc;
! 1781: struct wi_usb_softc *sc;
! 1782: int s;
! 1783:
! 1784: wsc = ifp->if_softc;
! 1785: sc = wsc->wi_usb_cdata;
! 1786:
! 1787: s = splnet();
! 1788:
! 1789: DPRINTFN(5,("%s: %s: ifp %x\n",
! 1790: sc->wi_usb_dev.dv_xname, __func__, ifp));
! 1791:
! 1792: sc->wi_thread_info->status |= WI_WATCHDOG;
! 1793:
! 1794: if (sc->wi_thread_info->idle)
! 1795: wakeup(sc->wi_thread_info);
! 1796: splx(s);
! 1797: }
! 1798:
! 1799: /*
! 1800: * ioctl will always be called from a user context,
! 1801: * therefore it is possible to sleep in the calling context
! 1802: * acquire the lock and call the real ioctl fucntion directly
! 1803: */
! 1804: int
! 1805: wi_ioctl_usb(struct ifnet *ifp, u_long command, caddr_t data)
! 1806: {
! 1807: struct wi_softc *wsc;
! 1808: int err;
! 1809:
! 1810: wsc = ifp->if_softc;
! 1811:
! 1812: wi_usb_ctl_lock(wsc->wi_usb_cdata);
! 1813: err = wi_func_io.f_ioctl(ifp, command, data);
! 1814: wi_usb_ctl_unlock(wsc->wi_usb_cdata);
! 1815: return err;
! 1816: }
! 1817:
! 1818: void
! 1819: wi_usb_thread(void *arg)
! 1820: {
! 1821: struct wi_usb_softc *sc = arg;
! 1822: struct wi_usb_thread_info *wi_thread_info;
! 1823: int s;
! 1824:
! 1825: wi_thread_info = malloc(sizeof(*wi_thread_info), M_DEVBUF, M_WAITOK);
! 1826:
! 1827: /*
! 1828: * is there a remote possibility that the device could
! 1829: * be removed before the kernel thread starts up?
! 1830: */
! 1831:
! 1832: sc->wi_usb_refcnt++;
! 1833:
! 1834: sc->wi_thread_info = wi_thread_info;
! 1835: wi_thread_info->dying = 0;
! 1836: wi_thread_info->status = 0;
! 1837:
! 1838: wi_usb_ctl_lock(sc);
! 1839:
! 1840: wi_attach(&sc->sc_wi, &wi_func_usb);
! 1841:
! 1842: wi_usb_ctl_unlock(sc);
! 1843:
! 1844: for(;;) {
! 1845: if (wi_thread_info->dying) {
! 1846: if (--sc->wi_usb_refcnt < 0)
! 1847: usb_detach_wakeup(&sc->wi_usb_dev);
! 1848: kthread_exit(0);
! 1849: }
! 1850:
! 1851: DPRINTFN(5,("%s: %s: dying %x status %x\n",
! 1852: sc->wi_usb_dev.dv_xname, __func__,
! 1853: wi_thread_info->dying, wi_thread_info->status));
! 1854:
! 1855: wi_usb_ctl_lock(sc);
! 1856:
! 1857: DPRINTFN(5,("%s: %s: starting %x\n",
! 1858: sc->wi_usb_dev.dv_xname, __func__,
! 1859: wi_thread_info->status));
! 1860:
! 1861: s = splusb();
! 1862: if (wi_thread_info->status & WI_START) {
! 1863: wi_thread_info->status &= ~WI_START;
! 1864: wi_usb_tx_lock(sc);
! 1865: wi_func_io.f_start(&sc->sc_wi.sc_ic.ic_if);
! 1866: /*
! 1867: * tx_unlock is explicitly missing here
! 1868: * it is done in txeof_frm
! 1869: */
! 1870: } else if (wi_thread_info->status & WI_INQUIRE) {
! 1871: wi_thread_info->status &= ~WI_INQUIRE;
! 1872: wi_func_io.f_inquire(&sc->sc_wi);
! 1873: } else if (wi_thread_info->status & WI_WATCHDOG) {
! 1874: wi_thread_info->status &= ~WI_WATCHDOG;
! 1875: wi_func_io.f_watchdog( &sc->sc_wi.sc_ic.ic_if);
! 1876: }
! 1877: splx(s);
! 1878:
! 1879: DPRINTFN(5,("%s: %s: ending %x\n",
! 1880: sc->wi_usb_dev.dv_xname, __func__,
! 1881: wi_thread_info->status));
! 1882: wi_usb_ctl_unlock(sc);
! 1883:
! 1884: if (wi_thread_info->status == 0) {
! 1885: s = splnet();
! 1886: wi_thread_info->idle = 1;
! 1887: tsleep(wi_thread_info, PRIBIO, "wiIDL", 0);
! 1888: wi_thread_info->idle = 0;
! 1889: splx(s);
! 1890: }
! 1891: }
! 1892: }
! 1893:
! 1894: int
! 1895: wi_usb_tx_lock_try(struct wi_usb_softc *sc)
! 1896: {
! 1897: int s;
! 1898:
! 1899: s = splnet();
! 1900:
! 1901: DPRINTFN(10,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname, __func__));
! 1902:
! 1903: if (sc->wi_lock != 0) {
! 1904: return 0; /* failed to aquire lock */
! 1905: }
! 1906:
! 1907: sc->wi_lock = 1;
! 1908:
! 1909: splx(s);
! 1910:
! 1911: return 1;
! 1912: }
! 1913: void
! 1914: wi_usb_tx_lock(struct wi_usb_softc *sc)
! 1915: {
! 1916: int s;
! 1917:
! 1918: s = splnet();
! 1919:
! 1920: again:
! 1921: DPRINTFN(10,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname, __func__));
! 1922:
! 1923: if (sc->wi_lock != 0) {
! 1924: sc->wi_lockwait++;
! 1925: DPRINTFN(10,("%s: %s: busy %d\n", sc->wi_usb_dev.dv_xname,
! 1926: __func__, sc->wi_lockwait ));
! 1927: tsleep(&sc->wi_lock, PRIBIO, "witxl", 0);
! 1928: }
! 1929:
! 1930: if (sc->wi_lock != 0)
! 1931: goto again;
! 1932: sc->wi_lock = 1;
! 1933:
! 1934: splx(s);
! 1935:
! 1936: return;
! 1937:
! 1938: }
! 1939:
! 1940: void
! 1941: wi_usb_tx_unlock(struct wi_usb_softc *sc)
! 1942: {
! 1943: int s;
! 1944: s = splnet();
! 1945:
! 1946: sc->wi_lock = 0;
! 1947:
! 1948: DPRINTFN(10,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname, __func__));
! 1949:
! 1950: if (sc->wi_lockwait) {
! 1951: DPRINTFN(10,("%s: %s: waking\n",
! 1952: sc->wi_usb_dev.dv_xname, __func__));
! 1953: sc->wi_lockwait = 0;
! 1954: wakeup(&sc->wi_lock);
! 1955: }
! 1956:
! 1957: splx(s);
! 1958: }
! 1959:
! 1960: void
! 1961: wi_usb_ctl_lock(struct wi_usb_softc *sc)
! 1962: {
! 1963: int s;
! 1964:
! 1965: s = splnet();
! 1966:
! 1967: again:
! 1968: DPRINTFN(10,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname,
! 1969: __func__));
! 1970:
! 1971: if (sc->wi_ctllock != 0) {
! 1972: if (curproc == sc->wi_curproc) {
! 1973: /* allow recursion */
! 1974: sc->wi_ctllock++;
! 1975: splx(s);
! 1976: return;
! 1977: }
! 1978: sc->wi_ctllockwait++;
! 1979: DPRINTFN(10,("%s: %s: busy %d\n", sc->wi_usb_dev.dv_xname,
! 1980: __func__, sc->wi_ctllockwait ));
! 1981: tsleep(&sc->wi_ctllock, PRIBIO, "wiusbthr", 0);
! 1982: }
! 1983:
! 1984: if (sc->wi_ctllock != 0)
! 1985: goto again;
! 1986: sc->wi_ctllock++;
! 1987: sc->wi_curproc = curproc;
! 1988:
! 1989: splx(s);
! 1990:
! 1991: return;
! 1992:
! 1993: }
! 1994:
! 1995: void
! 1996: wi_usb_ctl_unlock(struct wi_usb_softc *sc)
! 1997: {
! 1998: int s;
! 1999:
! 2000: s = splnet();
! 2001:
! 2002: sc->wi_ctllock--;
! 2003:
! 2004: DPRINTFN(10,("%s: %s: enter\n", sc->wi_usb_dev.dv_xname, __func__));
! 2005:
! 2006: if (sc->wi_ctllock == 0 && sc->wi_ctllockwait) {
! 2007: DPRINTFN(10,("%s: %s: waking\n",
! 2008: sc->wi_usb_dev.dv_xname, __func__));
! 2009: sc->wi_ctllockwait = 0;
! 2010: sc->wi_curproc = 0;
! 2011: wakeup(&sc->wi_ctllock);
! 2012: }
! 2013:
! 2014: splx(s);
! 2015: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_wi_usb.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb