Annotation of sys/dev/usb/if_uath.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_uath.c,v 1.27 2007/07/18 18:10:31 damien Exp $ */
! 2:
! 3: /*-
! 4: * Copyright (c) 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 Atheros AR5005UG/AR5005UX chipsets.
! 22: * http://www.atheros.com/pt/bulletins/AR5005UGBulletin.pdf
! 23: * http://www.atheros.com/pt/bulletins/AR5005UXBulletin.pdf
! 24: *
! 25: * IMPORTANT NOTICE:
! 26: * This driver was written without any documentation or support from Atheros
! 27: * Communications. It is based on a black-box analysis of the Windows binary
! 28: * driver. It handles both pre and post-firmware devices.
! 29: */
! 30:
! 31: #include "bpfilter.h"
! 32:
! 33: #include <sys/param.h>
! 34: #include <sys/sockio.h>
! 35: #include <sys/sysctl.h>
! 36: #include <sys/mbuf.h>
! 37: #include <sys/kernel.h>
! 38: #include <sys/socket.h>
! 39: #include <sys/systm.h>
! 40: #include <sys/malloc.h>
! 41: #include <sys/timeout.h>
! 42: #include <sys/conf.h>
! 43: #include <sys/device.h>
! 44:
! 45: #include <machine/bus.h>
! 46: #include <machine/endian.h>
! 47: #include <machine/intr.h>
! 48:
! 49: #if NBPFILTER > 0
! 50: #include <net/bpf.h>
! 51: #endif
! 52: #include <net/if.h>
! 53: #include <net/if_arp.h>
! 54: #include <net/if_dl.h>
! 55: #include <net/if_media.h>
! 56: #include <net/if_types.h>
! 57:
! 58: #include <netinet/in.h>
! 59: #include <netinet/in_systm.h>
! 60: #include <netinet/in_var.h>
! 61: #include <netinet/if_ether.h>
! 62: #include <netinet/ip.h>
! 63:
! 64: #include <net80211/ieee80211_var.h>
! 65: #include <net80211/ieee80211_radiotap.h>
! 66:
! 67: #include <dev/rndvar.h>
! 68: #include <crypto/arc4.h>
! 69:
! 70: #include <dev/usb/usb.h>
! 71: #include <dev/usb/usbdi.h>
! 72: #include <dev/usb/usbdivar.h> /* needs_reattach() */
! 73: #include <dev/usb/usbdi_util.h>
! 74: #include <dev/usb/usbdevs.h>
! 75:
! 76: #include <dev/usb/if_uathreg.h>
! 77: #include <dev/usb/if_uathvar.h>
! 78:
! 79: #ifdef USB_DEBUG
! 80: #define UATH_DEBUG
! 81: #endif
! 82:
! 83: #ifdef UATH_DEBUG
! 84: #define DPRINTF(x) do { if (uath_debug) printf x; } while (0)
! 85: #define DPRINTFN(n, x) do { if (uath_debug >= (n)) printf x; } while (0)
! 86: int uath_debug = 1;
! 87: #else
! 88: #define DPRINTF(x)
! 89: #define DPRINTFN(n, x)
! 90: #endif
! 91:
! 92: /*-
! 93: * Various supported device vendors/products.
! 94: * UB51: AR5005UG 802.11b/g, UB52: AR5005UX 802.11a/b/g
! 95: */
! 96: #define UATH_DEV(v, p, f) \
! 97: { { USB_VENDOR_##v, USB_PRODUCT_##v##_##p }, (f) }, \
! 98: { { USB_VENDOR_##v, USB_PRODUCT_##v##_##p##_NF }, \
! 99: (f) | UATH_FLAG_PRE_FIRMWARE }
! 100: #define UATH_DEV_UG(v, p) UATH_DEV(v, p, 0)
! 101: #define UATH_DEV_UX(v, p) UATH_DEV(v, p, UATH_FLAG_ABG)
! 102: static const struct uath_type {
! 103: struct usb_devno dev;
! 104: unsigned int flags;
! 105: #define UATH_FLAG_PRE_FIRMWARE (1 << 0)
! 106: #define UATH_FLAG_ABG (1 << 1)
! 107: } uath_devs[] = {
! 108: UATH_DEV_UG(ATHEROS, AR5523),
! 109: UATH_DEV_UG(ATHEROS2, AR5523_1),
! 110: UATH_DEV_UG(ATHEROS2, AR5523_2),
! 111: UATH_DEV_UX(ATHEROS2, AR5523_3),
! 112: UATH_DEV_UG(CONCEPTRONIC, AR5523_1),
! 113: UATH_DEV_UX(CONCEPTRONIC, AR5523_2),
! 114: UATH_DEV_UX(DLINK, DWLAG122),
! 115: UATH_DEV_UX(DLINK, DWLAG132),
! 116: UATH_DEV_UG(DLINK, DWLG132),
! 117: UATH_DEV_UG(GIGASET, AR5523),
! 118: UATH_DEV_UG(GIGASET, SMCWUSBTG),
! 119: UATH_DEV_UG(GLOBALSUN, AR5523_1),
! 120: UATH_DEV_UX(GLOBALSUN, AR5523_2),
! 121: UATH_DEV_UX(NETGEAR, WG111U),
! 122: UATH_DEV_UG(NETGEAR3, WG111T),
! 123: UATH_DEV_UG(NETGEAR3, WPN111),
! 124: UATH_DEV_UG(UMEDIA, AR5523_1),
! 125: UATH_DEV_UX(UMEDIA, AR5523_2),
! 126: UATH_DEV_UG(UMEDIA, TEW444UBEU),
! 127: UATH_DEV_UG(WISTRONNEWEB, AR5523_1),
! 128: UATH_DEV_UX(WISTRONNEWEB, AR5523_2),
! 129: UATH_DEV_UG(ZCOM, AR5523)
! 130: };
! 131: #define uath_lookup(v, p) \
! 132: ((const struct uath_type *)usb_lookup(uath_devs, v, p))
! 133:
! 134: void uath_attachhook(void *);
! 135: int uath_open_pipes(struct uath_softc *);
! 136: void uath_close_pipes(struct uath_softc *);
! 137: int uath_alloc_tx_data_list(struct uath_softc *);
! 138: void uath_free_tx_data_list(struct uath_softc *);
! 139: int uath_alloc_rx_data_list(struct uath_softc *);
! 140: void uath_free_rx_data_list(struct uath_softc *);
! 141: void uath_free_rx_data(caddr_t, u_int, void *);
! 142: int uath_alloc_tx_cmd_list(struct uath_softc *);
! 143: void uath_free_tx_cmd_list(struct uath_softc *);
! 144: int uath_alloc_rx_cmd_list(struct uath_softc *);
! 145: void uath_free_rx_cmd_list(struct uath_softc *);
! 146: int uath_media_change(struct ifnet *);
! 147: void uath_stat(void *);
! 148: void uath_next_scan(void *);
! 149: void uath_task(void *);
! 150: int uath_newstate(struct ieee80211com *, enum ieee80211_state, int);
! 151: #ifdef UATH_DEBUG
! 152: void uath_dump_cmd(const uint8_t *, int, char);
! 153: #endif
! 154: int uath_cmd(struct uath_softc *, uint32_t, const void *, int, void *,
! 155: int);
! 156: int uath_cmd_write(struct uath_softc *, uint32_t, const void *, int, int);
! 157: int uath_cmd_read(struct uath_softc *, uint32_t, const void *, int, void *,
! 158: int);
! 159: int uath_write_reg(struct uath_softc *, uint32_t, uint32_t);
! 160: int uath_write_multi(struct uath_softc *, uint32_t, const void *, int);
! 161: int uath_read_reg(struct uath_softc *, uint32_t, uint32_t *);
! 162: int uath_read_eeprom(struct uath_softc *, uint32_t, void *);
! 163: void uath_cmd_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
! 164: void uath_data_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
! 165: void uath_data_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
! 166: int uath_tx_null(struct uath_softc *);
! 167: int uath_tx_data(struct uath_softc *, struct mbuf *,
! 168: struct ieee80211_node *);
! 169: void uath_start(struct ifnet *);
! 170: void uath_watchdog(struct ifnet *);
! 171: int uath_ioctl(struct ifnet *, u_long, caddr_t);
! 172: int uath_query_eeprom(struct uath_softc *);
! 173: int uath_reset(struct uath_softc *);
! 174: int uath_reset_tx_queues(struct uath_softc *);
! 175: int uath_wme_init(struct uath_softc *);
! 176: int uath_set_chan(struct uath_softc *, struct ieee80211_channel *);
! 177: int uath_set_key(struct uath_softc *, const struct ieee80211_key *, int);
! 178: int uath_set_keys(struct uath_softc *);
! 179: int uath_set_rates(struct uath_softc *, const struct ieee80211_rateset *);
! 180: int uath_set_rxfilter(struct uath_softc *, uint32_t, uint32_t);
! 181: int uath_set_led(struct uath_softc *, int, int);
! 182: int uath_switch_channel(struct uath_softc *, struct ieee80211_channel *);
! 183: int uath_init(struct ifnet *);
! 184: void uath_stop(struct ifnet *, int);
! 185: int uath_loadfirmware(struct uath_softc *, const u_char *, int);
! 186: int uath_activate(struct device *, enum devact);
! 187:
! 188: int uath_match(struct device *, void *, void *);
! 189: void uath_attach(struct device *, struct device *, void *);
! 190: int uath_detach(struct device *, int);
! 191: int uath_activate(struct device *, enum devact);
! 192:
! 193: struct cfdriver uath_cd = {
! 194: NULL, "uath", DV_DULL
! 195: };
! 196:
! 197: const struct cfattach uath_ca = {
! 198: sizeof(struct uath_softc),
! 199: uath_match,
! 200: uath_attach,
! 201: uath_detach,
! 202: uath_activate,
! 203: };
! 204:
! 205: int
! 206: uath_match(struct device *parent, void *match, void *aux)
! 207: {
! 208: struct usb_attach_arg *uaa = aux;
! 209:
! 210: if (uaa->iface != NULL)
! 211: return UMATCH_NONE;
! 212:
! 213: return (uath_lookup(uaa->vendor, uaa->product) != NULL) ?
! 214: UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
! 215: }
! 216:
! 217: void
! 218: uath_attachhook(void *xsc)
! 219: {
! 220: struct uath_softc *sc = xsc;
! 221: u_char *fw;
! 222: size_t size;
! 223: int error;
! 224:
! 225: if ((error = loadfirmware("uath-ar5523", &fw, &size)) != 0) {
! 226: printf("%s: could not read firmware (error=%d)\n",
! 227: sc->sc_dev.dv_xname, error);
! 228: return;
! 229: }
! 230:
! 231: error = uath_loadfirmware(sc, fw, size);
! 232: free(fw, M_DEVBUF);
! 233:
! 234: if (error == 0) {
! 235: usb_port_status_t status;
! 236:
! 237: /*
! 238: * Hack alert: the device doesn't always gracefully detach
! 239: * from the bus after a firmware upload. We need to force
! 240: * a port reset and a re-exploration on the parent hub.
! 241: */
! 242: usbd_reset_port(sc->sc_uhub, sc->sc_port, &status);
! 243: usb_needs_reattach(sc->sc_udev);
! 244: } else {
! 245: printf("%s: could not load firmware (error=%s)\n",
! 246: sc->sc_dev.dv_xname, usbd_errstr(error));
! 247: }
! 248: }
! 249:
! 250: void
! 251: uath_attach(struct device *parent, struct device *self, void *aux)
! 252: {
! 253: struct uath_softc *sc = (struct uath_softc *)self;
! 254: struct usb_attach_arg *uaa = aux;
! 255: struct ieee80211com *ic = &sc->sc_ic;
! 256: struct ifnet *ifp = &ic->ic_if;
! 257: usbd_status error;
! 258: char *devinfop;
! 259: int i;
! 260:
! 261: sc->sc_udev = uaa->device;
! 262: sc->sc_uhub = uaa->device->myhub;
! 263: sc->sc_port = uaa->port;
! 264:
! 265: devinfop = usbd_devinfo_alloc(uaa->device, 0);
! 266: printf("\n%s: %s\n", sc->sc_dev.dv_xname, devinfop);
! 267: usbd_devinfo_free(devinfop);
! 268:
! 269: sc->sc_flags = uath_lookup(uaa->vendor, uaa->product)->flags;
! 270:
! 271: if (usbd_set_config_no(sc->sc_udev, UATH_CONFIG_NO, 0) != 0) {
! 272: printf("%s: could not set configuration no\n",
! 273: sc->sc_dev.dv_xname);
! 274: return;
! 275: }
! 276:
! 277: /* get the first interface handle */
! 278: error = usbd_device2interface_handle(sc->sc_udev, UATH_IFACE_INDEX,
! 279: &sc->sc_iface);
! 280: if (error != 0) {
! 281: printf("%s: could not get interface handle\n",
! 282: sc->sc_dev.dv_xname);
! 283: return;
! 284: }
! 285:
! 286: /*
! 287: * We must open the pipes early because they're used to upload the
! 288: * firmware (pre-firmware devices) or to send firmware commands.
! 289: */
! 290: if (uath_open_pipes(sc) != 0) {
! 291: printf("%s: could not open pipes\n", sc->sc_dev.dv_xname);
! 292: return;
! 293: }
! 294:
! 295: if (sc->sc_flags & UATH_FLAG_PRE_FIRMWARE) {
! 296: if (rootvp == NULL)
! 297: mountroothook_establish(uath_attachhook, sc);
! 298: else
! 299: uath_attachhook(sc);
! 300: return;
! 301: }
! 302:
! 303: /*
! 304: * Only post-firmware devices here.
! 305: */
! 306: usb_init_task(&sc->sc_task, uath_task, sc);
! 307: timeout_set(&sc->scan_to, uath_next_scan, sc);
! 308: timeout_set(&sc->stat_to, uath_stat, sc);
! 309:
! 310: /*
! 311: * Allocate xfers for firmware commands.
! 312: */
! 313: if (uath_alloc_tx_cmd_list(sc) != 0) {
! 314: printf("%s: could not allocate Tx command list\n",
! 315: sc->sc_dev.dv_xname);
! 316: goto fail1;
! 317: }
! 318: if (uath_alloc_rx_cmd_list(sc) != 0) {
! 319: printf("%s: could not allocate Rx command list\n",
! 320: sc->sc_dev.dv_xname);
! 321: goto fail2;
! 322: }
! 323:
! 324: /*
! 325: * Queue Rx command xfers.
! 326: */
! 327: for (i = 0; i < UATH_RX_CMD_LIST_COUNT; i++) {
! 328: struct uath_rx_cmd *cmd = &sc->rx_cmd[i];
! 329:
! 330: usbd_setup_xfer(cmd->xfer, sc->cmd_rx_pipe, cmd, cmd->buf,
! 331: UATH_MAX_RXCMDSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,
! 332: USBD_NO_TIMEOUT, uath_cmd_rxeof);
! 333: error = usbd_transfer(cmd->xfer);
! 334: if (error != USBD_IN_PROGRESS && error != 0) {
! 335: printf("%s: could not queue Rx command xfer\n",
! 336: sc->sc_dev.dv_xname);
! 337: goto fail3;
! 338: }
! 339: }
! 340:
! 341: /*
! 342: * We're now ready to send/receive firmware commands.
! 343: */
! 344: if (uath_reset(sc) != 0) {
! 345: printf("%s: could not initialize adapter\n",
! 346: sc->sc_dev.dv_xname);
! 347: goto fail3;
! 348: }
! 349: if (uath_query_eeprom(sc) != 0) {
! 350: printf("%s: could not read EEPROM\n", sc->sc_dev.dv_xname);
! 351: goto fail3;
! 352: }
! 353:
! 354: printf("%s: MAC/BBP AR5523, RF AR%c112, address %s\n",
! 355: sc->sc_dev.dv_xname, (sc->sc_flags & UATH_FLAG_ABG) ? '5': '2',
! 356: ether_sprintf(ic->ic_myaddr));
! 357:
! 358: /*
! 359: * Allocate xfers for Tx/Rx data pipes.
! 360: */
! 361: if (uath_alloc_tx_data_list(sc) != 0) {
! 362: printf("%s: could not allocate Tx data list\n",
! 363: sc->sc_dev.dv_xname);
! 364: goto fail3;
! 365: }
! 366: if (uath_alloc_rx_data_list(sc) != 0) {
! 367: printf("%s: could not allocate Rx data list\n",
! 368: sc->sc_dev.dv_xname);
! 369: goto fail4;
! 370: }
! 371:
! 372: ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
! 373: ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */
! 374: ic->ic_state = IEEE80211_S_INIT;
! 375:
! 376: /* set device capabilities */
! 377: ic->ic_caps =
! 378: IEEE80211_C_TXPMGT | /* tx power management */
! 379: IEEE80211_C_SHPREAMBLE | /* short preamble supported */
! 380: IEEE80211_C_SHSLOT | /* short slot time supported */
! 381: IEEE80211_C_WEP; /* h/w WEP */
! 382:
! 383: /* set supported .11b and .11g rates */
! 384: ic->ic_sup_rates[IEEE80211_MODE_11B] = ieee80211_std_rateset_11b;
! 385: ic->ic_sup_rates[IEEE80211_MODE_11G] = ieee80211_std_rateset_11g;
! 386:
! 387: /* set supported .11b and .11g channels (1 through 14) */
! 388: for (i = 1; i <= 14; i++) {
! 389: ic->ic_channels[i].ic_freq =
! 390: ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ);
! 391: ic->ic_channels[i].ic_flags =
! 392: IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM |
! 393: IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ;
! 394: }
! 395:
! 396: ifp->if_softc = sc;
! 397: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
! 398: ifp->if_init = uath_init;
! 399: ifp->if_ioctl = uath_ioctl;
! 400: ifp->if_start = uath_start;
! 401: ifp->if_watchdog = uath_watchdog;
! 402: IFQ_SET_READY(&ifp->if_snd);
! 403: memcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);
! 404:
! 405: if_attach(ifp);
! 406: ieee80211_ifattach(ifp);
! 407:
! 408: /* override state transition machine */
! 409: sc->sc_newstate = ic->ic_newstate;
! 410: ic->ic_newstate = uath_newstate;
! 411: ieee80211_media_init(ifp, uath_media_change, ieee80211_media_status);
! 412:
! 413: #if NBPFILTER > 0
! 414: bpfattach(&sc->sc_drvbpf, ifp, DLT_IEEE802_11_RADIO,
! 415: sizeof (struct ieee80211_frame) + IEEE80211_RADIOTAP_HDRLEN);
! 416:
! 417: sc->sc_rxtap_len = sizeof sc->sc_rxtapu;
! 418: sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len);
! 419: sc->sc_rxtap.wr_ihdr.it_present = htole32(UATH_RX_RADIOTAP_PRESENT);
! 420:
! 421: sc->sc_txtap_len = sizeof sc->sc_txtapu;
! 422: sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
! 423: sc->sc_txtap.wt_ihdr.it_present = htole32(UATH_TX_RADIOTAP_PRESENT);
! 424: #endif
! 425:
! 426: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
! 427: &sc->sc_dev);
! 428:
! 429: return;
! 430:
! 431: fail4: uath_free_tx_data_list(sc);
! 432: fail3: uath_free_rx_cmd_list(sc);
! 433: fail2: uath_free_tx_cmd_list(sc);
! 434: fail1: uath_close_pipes(sc);
! 435: }
! 436:
! 437: int
! 438: uath_detach(struct device *self, int flags)
! 439: {
! 440: struct uath_softc *sc = (struct uath_softc *)self;
! 441: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 442: int s;
! 443:
! 444: s = splnet();
! 445:
! 446: if (sc->sc_flags & UATH_FLAG_PRE_FIRMWARE) {
! 447: uath_close_pipes(sc);
! 448: splx(s);
! 449: return 0;
! 450: }
! 451:
! 452: /* post-firmware device */
! 453:
! 454: usb_rem_task(sc->sc_udev, &sc->sc_task);
! 455: timeout_del(&sc->scan_to);
! 456: timeout_del(&sc->stat_to);
! 457:
! 458: ieee80211_ifdetach(ifp); /* free all nodes */
! 459: if_detach(ifp);
! 460:
! 461: sc->sc_dying = 1;
! 462: DPRINTF(("reclaiming %d references\n", sc->sc_refcnt));
! 463: while (sc->sc_refcnt > 0)
! 464: (void)tsleep(UATH_COND_NOREF(sc), 0, "uathdet", 0);
! 465: DPRINTF(("all references reclaimed\n"));
! 466:
! 467: /* abort and free xfers */
! 468: uath_free_tx_data_list(sc);
! 469: uath_free_rx_data_list(sc);
! 470: uath_free_tx_cmd_list(sc);
! 471: uath_free_rx_cmd_list(sc);
! 472:
! 473: /* close Tx/Rx pipes */
! 474: uath_close_pipes(sc);
! 475:
! 476: splx(s);
! 477:
! 478: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
! 479: &sc->sc_dev);
! 480:
! 481: return 0;
! 482: }
! 483:
! 484: int
! 485: uath_open_pipes(struct uath_softc *sc)
! 486: {
! 487: int error;
! 488:
! 489: /*
! 490: * XXX pipes numbers are hardcoded because we don't have any way
! 491: * to distinguish the data pipes from the firmware command pipes
! 492: * (both are bulk pipes) using the endpoints descriptors.
! 493: */
! 494: error = usbd_open_pipe(sc->sc_iface, 0x01, USBD_EXCLUSIVE_USE,
! 495: &sc->cmd_tx_pipe);
! 496: if (error != 0) {
! 497: printf("%s: could not open Tx command pipe: %s\n",
! 498: sc->sc_dev.dv_xname, usbd_errstr(error));
! 499: goto fail;
! 500: }
! 501:
! 502: error = usbd_open_pipe(sc->sc_iface, 0x02, USBD_EXCLUSIVE_USE,
! 503: &sc->data_tx_pipe);
! 504: if (error != 0) {
! 505: printf("%s: could not open Tx data pipe: %s\n",
! 506: sc->sc_dev.dv_xname, usbd_errstr(error));
! 507: goto fail;
! 508: }
! 509:
! 510: error = usbd_open_pipe(sc->sc_iface, 0x81, USBD_EXCLUSIVE_USE,
! 511: &sc->cmd_rx_pipe);
! 512: if (error != 0) {
! 513: printf("%s: could not open Rx command pipe: %s\n",
! 514: sc->sc_dev.dv_xname, usbd_errstr(error));
! 515: goto fail;
! 516: }
! 517:
! 518: error = usbd_open_pipe(sc->sc_iface, 0x82, USBD_EXCLUSIVE_USE,
! 519: &sc->data_rx_pipe);
! 520: if (error != 0) {
! 521: printf("%s: could not open Rx data pipe: %s\n",
! 522: sc->sc_dev.dv_xname, usbd_errstr(error));
! 523: goto fail;
! 524: }
! 525:
! 526: return 0;
! 527:
! 528: fail: uath_close_pipes(sc);
! 529: return error;
! 530: }
! 531:
! 532: void
! 533: uath_close_pipes(struct uath_softc *sc)
! 534: {
! 535: /* assumes no transfers are pending on the pipes */
! 536:
! 537: if (sc->data_tx_pipe != NULL)
! 538: usbd_close_pipe(sc->data_tx_pipe);
! 539:
! 540: if (sc->data_rx_pipe != NULL)
! 541: usbd_close_pipe(sc->data_rx_pipe);
! 542:
! 543: if (sc->cmd_tx_pipe != NULL)
! 544: usbd_close_pipe(sc->cmd_tx_pipe);
! 545:
! 546: if (sc->cmd_rx_pipe != NULL)
! 547: usbd_close_pipe(sc->cmd_rx_pipe);
! 548: }
! 549:
! 550: int
! 551: uath_alloc_tx_data_list(struct uath_softc *sc)
! 552: {
! 553: int i, error;
! 554:
! 555: for (i = 0; i < UATH_TX_DATA_LIST_COUNT; i++) {
! 556: struct uath_tx_data *data = &sc->tx_data[i];
! 557:
! 558: data->sc = sc; /* backpointer for callbacks */
! 559:
! 560: data->xfer = usbd_alloc_xfer(sc->sc_udev);
! 561: if (data->xfer == NULL) {
! 562: printf("%s: could not allocate xfer\n",
! 563: sc->sc_dev.dv_xname);
! 564: error = ENOMEM;
! 565: goto fail;
! 566: }
! 567: data->buf = usbd_alloc_buffer(data->xfer, UATH_MAX_TXBUFSZ);
! 568: if (data->buf == NULL) {
! 569: printf("%s: could not allocate xfer buffer\n",
! 570: sc->sc_dev.dv_xname);
! 571: error = ENOMEM;
! 572: goto fail;
! 573: }
! 574: }
! 575: return 0;
! 576:
! 577: fail: uath_free_tx_data_list(sc);
! 578: return error;
! 579: }
! 580:
! 581: void
! 582: uath_free_tx_data_list(struct uath_softc *sc)
! 583: {
! 584: int i;
! 585:
! 586: /* make sure no transfers are pending */
! 587: usbd_abort_pipe(sc->data_tx_pipe);
! 588:
! 589: for (i = 0; i < UATH_TX_DATA_LIST_COUNT; i++)
! 590: if (sc->tx_data[i].xfer != NULL)
! 591: usbd_free_xfer(sc->tx_data[i].xfer);
! 592: }
! 593:
! 594: int
! 595: uath_alloc_rx_data_list(struct uath_softc *sc)
! 596: {
! 597: int i, error;
! 598:
! 599: SLIST_INIT(&sc->rx_freelist);
! 600: for (i = 0; i < UATH_RX_DATA_POOL_COUNT; i++) {
! 601: struct uath_rx_data *data = &sc->rx_data[i];
! 602:
! 603: data->sc = sc; /* backpointer for callbacks */
! 604:
! 605: data->xfer = usbd_alloc_xfer(sc->sc_udev);
! 606: if (data->xfer == NULL) {
! 607: printf("%s: could not allocate xfer\n",
! 608: sc->sc_dev.dv_xname);
! 609: error = ENOMEM;
! 610: goto fail;
! 611: }
! 612: data->buf = usbd_alloc_buffer(data->xfer, sc->rxbufsz);
! 613: if (data->buf == NULL) {
! 614: printf("%s: could not allocate xfer buffer\n",
! 615: sc->sc_dev.dv_xname);
! 616: error = ENOMEM;
! 617: goto fail;
! 618: }
! 619: SLIST_INSERT_HEAD(&sc->rx_freelist, data, next);
! 620: }
! 621: return 0;
! 622:
! 623: fail: uath_free_rx_data_list(sc);
! 624: return error;
! 625: }
! 626:
! 627: void
! 628: uath_free_rx_data_list(struct uath_softc *sc)
! 629: {
! 630: int i;
! 631:
! 632: /* make sure no transfers are pending */
! 633: usbd_abort_pipe(sc->data_rx_pipe);
! 634:
! 635: for (i = 0; i < UATH_RX_DATA_POOL_COUNT; i++)
! 636: if (sc->rx_data[i].xfer != NULL)
! 637: usbd_free_xfer(sc->rx_data[i].xfer);
! 638: }
! 639:
! 640: void
! 641: uath_free_rx_data(caddr_t buf, u_int size, void *arg)
! 642: {
! 643: struct uath_rx_data *data = arg;
! 644: struct uath_softc *sc = data->sc;
! 645:
! 646: /* put the buffer back in the free list */
! 647: SLIST_INSERT_HEAD(&sc->rx_freelist, data, next);
! 648:
! 649: /* release reference to softc */
! 650: if (--sc->sc_refcnt == 0 && sc->sc_dying)
! 651: wakeup(UATH_COND_NOREF(sc));
! 652: }
! 653:
! 654: int
! 655: uath_alloc_tx_cmd_list(struct uath_softc *sc)
! 656: {
! 657: int i, error;
! 658:
! 659: for (i = 0; i < UATH_TX_CMD_LIST_COUNT; i++) {
! 660: struct uath_tx_cmd *cmd = &sc->tx_cmd[i];
! 661:
! 662: cmd->sc = sc; /* backpointer for callbacks */
! 663:
! 664: cmd->xfer = usbd_alloc_xfer(sc->sc_udev);
! 665: if (cmd->xfer == NULL) {
! 666: printf("%s: could not allocate xfer\n",
! 667: sc->sc_dev.dv_xname);
! 668: error = ENOMEM;
! 669: goto fail;
! 670: }
! 671: cmd->buf = usbd_alloc_buffer(cmd->xfer, UATH_MAX_TXCMDSZ);
! 672: if (cmd->buf == NULL) {
! 673: printf("%s: could not allocate xfer buffer\n",
! 674: sc->sc_dev.dv_xname);
! 675: error = ENOMEM;
! 676: goto fail;
! 677: }
! 678: }
! 679: return 0;
! 680:
! 681: fail: uath_free_tx_cmd_list(sc);
! 682: return error;
! 683: }
! 684:
! 685: void
! 686: uath_free_tx_cmd_list(struct uath_softc *sc)
! 687: {
! 688: int i;
! 689:
! 690: /* make sure no transfers are pending */
! 691: usbd_abort_pipe(sc->cmd_tx_pipe);
! 692:
! 693: for (i = 0; i < UATH_TX_CMD_LIST_COUNT; i++)
! 694: if (sc->tx_cmd[i].xfer != NULL)
! 695: usbd_free_xfer(sc->tx_cmd[i].xfer);
! 696: }
! 697:
! 698: int
! 699: uath_alloc_rx_cmd_list(struct uath_softc *sc)
! 700: {
! 701: int i, error;
! 702:
! 703: for (i = 0; i < UATH_RX_CMD_LIST_COUNT; i++) {
! 704: struct uath_rx_cmd *cmd = &sc->rx_cmd[i];
! 705:
! 706: cmd->sc = sc; /* backpointer for callbacks */
! 707:
! 708: cmd->xfer = usbd_alloc_xfer(sc->sc_udev);
! 709: if (cmd->xfer == NULL) {
! 710: printf("%s: could not allocate xfer\n",
! 711: sc->sc_dev.dv_xname);
! 712: error = ENOMEM;
! 713: goto fail;
! 714: }
! 715: cmd->buf = usbd_alloc_buffer(cmd->xfer, UATH_MAX_RXCMDSZ);
! 716: if (cmd->buf == NULL) {
! 717: printf("%s: could not allocate xfer buffer\n",
! 718: sc->sc_dev.dv_xname);
! 719: error = ENOMEM;
! 720: goto fail;
! 721: }
! 722: }
! 723: return 0;
! 724:
! 725: fail: uath_free_rx_cmd_list(sc);
! 726: return error;
! 727: }
! 728:
! 729: void
! 730: uath_free_rx_cmd_list(struct uath_softc *sc)
! 731: {
! 732: int i;
! 733:
! 734: /* make sure no transfers are pending */
! 735: usbd_abort_pipe(sc->cmd_rx_pipe);
! 736:
! 737: for (i = 0; i < UATH_RX_CMD_LIST_COUNT; i++)
! 738: if (sc->rx_cmd[i].xfer != NULL)
! 739: usbd_free_xfer(sc->rx_cmd[i].xfer);
! 740: }
! 741:
! 742: int
! 743: uath_media_change(struct ifnet *ifp)
! 744: {
! 745: int error;
! 746:
! 747: error = ieee80211_media_change(ifp);
! 748: if (error != ENETRESET)
! 749: return error;
! 750:
! 751: if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING))
! 752: uath_init(ifp);
! 753:
! 754: return 0;
! 755: }
! 756:
! 757: /*
! 758: * This function is called periodically (every second) when associated to
! 759: * query device statistics.
! 760: */
! 761: void
! 762: uath_stat(void *arg)
! 763: {
! 764: struct uath_softc *sc = arg;
! 765: int error;
! 766:
! 767: /*
! 768: * Send request for statistics asynchronously. The timer will be
! 769: * restarted when we'll get the stats notification.
! 770: */
! 771: error = uath_cmd_write(sc, UATH_CMD_STATS, NULL, 0,
! 772: UATH_CMD_FLAG_ASYNC);
! 773: if (error != 0) {
! 774: printf("%s: could not query statistics (error=%d)\n",
! 775: sc->sc_dev.dv_xname, error);
! 776: }
! 777: }
! 778:
! 779: /*
! 780: * This function is called periodically (every 250ms) during scanning to
! 781: * switch from one channel to another.
! 782: */
! 783: void
! 784: uath_next_scan(void *arg)
! 785: {
! 786: struct uath_softc *sc = arg;
! 787: struct ieee80211com *ic = &sc->sc_ic;
! 788: struct ifnet *ifp = &ic->ic_if;
! 789:
! 790: if (ic->ic_state == IEEE80211_S_SCAN)
! 791: ieee80211_next_scan(ifp);
! 792: }
! 793:
! 794: void
! 795: uath_task(void *arg)
! 796: {
! 797: struct uath_softc *sc = arg;
! 798: struct ieee80211com *ic = &sc->sc_ic;
! 799: enum ieee80211_state ostate;
! 800:
! 801: ostate = ic->ic_state;
! 802:
! 803: switch (sc->sc_state) {
! 804: case IEEE80211_S_INIT:
! 805: if (ostate == IEEE80211_S_RUN) {
! 806: /* turn link and activity LEDs off */
! 807: (void)uath_set_led(sc, UATH_LED_LINK, 0);
! 808: (void)uath_set_led(sc, UATH_LED_ACTIVITY, 0);
! 809: }
! 810: break;
! 811:
! 812: case IEEE80211_S_SCAN:
! 813: if (uath_switch_channel(sc, ic->ic_bss->ni_chan) != 0) {
! 814: printf("%s: could not switch channel\n",
! 815: sc->sc_dev.dv_xname);
! 816: break;
! 817: }
! 818: timeout_add(&sc->scan_to, hz / 4);
! 819: break;
! 820:
! 821: case IEEE80211_S_AUTH:
! 822: {
! 823: struct ieee80211_node *ni = ic->ic_bss;
! 824: struct uath_cmd_bssid bssid;
! 825: struct uath_cmd_0b cmd0b;
! 826: struct uath_cmd_0c cmd0c;
! 827:
! 828: if (uath_switch_channel(sc, ni->ni_chan) != 0) {
! 829: printf("%s: could not switch channel\n",
! 830: sc->sc_dev.dv_xname);
! 831: break;
! 832: }
! 833:
! 834: (void)uath_cmd_write(sc, UATH_CMD_24, NULL, 0, 0);
! 835:
! 836: bzero(&bssid, sizeof bssid);
! 837: bssid.len = htobe32(IEEE80211_ADDR_LEN);
! 838: IEEE80211_ADDR_COPY(bssid.bssid, ni->ni_bssid);
! 839: (void)uath_cmd_write(sc, UATH_CMD_SET_BSSID, &bssid,
! 840: sizeof bssid, 0);
! 841:
! 842: bzero(&cmd0b, sizeof cmd0b);
! 843: cmd0b.code = htobe32(2);
! 844: cmd0b.size = htobe32(sizeof (cmd0b.data));
! 845: (void)uath_cmd_write(sc, UATH_CMD_0B, &cmd0b, sizeof cmd0b, 0);
! 846:
! 847: bzero(&cmd0c, sizeof cmd0c);
! 848: cmd0c.magic1 = htobe32(2);
! 849: cmd0c.magic2 = htobe32(7);
! 850: cmd0c.magic3 = htobe32(1);
! 851: (void)uath_cmd_write(sc, UATH_CMD_0C, &cmd0c, sizeof cmd0c, 0);
! 852:
! 853: if (uath_set_rates(sc, &ni->ni_rates) != 0) {
! 854: printf("%s: could not set negotiated rate set\n",
! 855: sc->sc_dev.dv_xname);
! 856: break;
! 857: }
! 858: break;
! 859: }
! 860:
! 861: case IEEE80211_S_ASSOC:
! 862: break;
! 863:
! 864: case IEEE80211_S_RUN:
! 865: {
! 866: struct ieee80211_node *ni = ic->ic_bss;
! 867: struct uath_cmd_bssid bssid;
! 868: struct uath_cmd_xled xled;
! 869: uint32_t val;
! 870:
! 871: if (ic->ic_opmode == IEEE80211_M_MONITOR) {
! 872: /* make both LEDs blink while monitoring */
! 873: bzero(&xled, sizeof xled);
! 874: xled.which = htobe32(0);
! 875: xled.rate = htobe32(1);
! 876: xled.mode = htobe32(2);
! 877: (void)uath_cmd_write(sc, UATH_CMD_SET_XLED, &xled,
! 878: sizeof xled, 0);
! 879: break;
! 880: }
! 881:
! 882: /*
! 883: * Tx rate is controlled by firmware, report the maximum
! 884: * negotiated rate in ifconfig output.
! 885: */
! 886: ni->ni_txrate = ni->ni_rates.rs_nrates - 1;
! 887:
! 888: val = htobe32(1);
! 889: (void)uath_cmd_write(sc, UATH_CMD_2E, &val, sizeof val, 0);
! 890:
! 891: bzero(&bssid, sizeof bssid);
! 892: bssid.flags1 = htobe32(0xc004);
! 893: bssid.flags2 = htobe32(0x003b);
! 894: bssid.len = htobe32(IEEE80211_ADDR_LEN);
! 895: IEEE80211_ADDR_COPY(bssid.bssid, ni->ni_bssid);
! 896: (void)uath_cmd_write(sc, UATH_CMD_SET_BSSID, &bssid,
! 897: sizeof bssid, 0);
! 898:
! 899: /* turn link LED on */
! 900: (void)uath_set_led(sc, UATH_LED_LINK, 1);
! 901:
! 902: /* make activity LED blink */
! 903: bzero(&xled, sizeof xled);
! 904: xled.which = htobe32(1);
! 905: xled.rate = htobe32(1);
! 906: xled.mode = htobe32(2);
! 907: (void)uath_cmd_write(sc, UATH_CMD_SET_XLED, &xled, sizeof xled,
! 908: 0);
! 909:
! 910: /* set state to associated */
! 911: val = htobe32(1);
! 912: (void)uath_cmd_write(sc, UATH_CMD_SET_STATE, &val, sizeof val,
! 913: 0);
! 914:
! 915: /* start statistics timer */
! 916: timeout_add(&sc->stat_to, hz);
! 917: break;
! 918: }
! 919: }
! 920: sc->sc_newstate(ic, sc->sc_state, sc->sc_arg);
! 921: }
! 922:
! 923: int
! 924: uath_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
! 925: {
! 926: struct uath_softc *sc = ic->ic_softc;
! 927:
! 928: usb_rem_task(sc->sc_udev, &sc->sc_task);
! 929: timeout_del(&sc->scan_to);
! 930: timeout_del(&sc->stat_to);
! 931:
! 932: /* do it in a process context */
! 933: sc->sc_state = nstate;
! 934: sc->sc_arg = arg;
! 935: usb_add_task(sc->sc_udev, &sc->sc_task);
! 936: return 0;
! 937: }
! 938:
! 939: #ifdef UATH_DEBUG
! 940: void
! 941: uath_dump_cmd(const uint8_t *buf, int len, char prefix)
! 942: {
! 943: int i;
! 944:
! 945: for (i = 0; i < len; i++) {
! 946: if ((i % 16) == 0)
! 947: printf("\n%c ", prefix);
! 948: else if ((i % 4) == 0)
! 949: printf(" ");
! 950: printf("%02x", buf[i]);
! 951: }
! 952: printf("\n");
! 953: }
! 954: #endif
! 955:
! 956: /*
! 957: * Low-level function to send read or write commands to the firmware.
! 958: */
! 959: int
! 960: uath_cmd(struct uath_softc *sc, uint32_t code, const void *idata, int ilen,
! 961: void *odata, int flags)
! 962: {
! 963: struct uath_cmd_hdr *hdr;
! 964: struct uath_tx_cmd *cmd;
! 965: uint16_t xferflags;
! 966: int s, xferlen, error;
! 967:
! 968: /* grab a xfer */
! 969: cmd = &sc->tx_cmd[sc->cmd_idx];
! 970:
! 971: /* always bulk-out a multiple of 4 bytes */
! 972: xferlen = (sizeof (struct uath_cmd_hdr) + ilen + 3) & ~3;
! 973:
! 974: hdr = (struct uath_cmd_hdr *)cmd->buf;
! 975: bzero(hdr, sizeof (struct uath_cmd_hdr));
! 976: hdr->len = htobe32(xferlen);
! 977: hdr->code = htobe32(code);
! 978: hdr->priv = sc->cmd_idx; /* don't care about endianness */
! 979: hdr->magic = htobe32((flags & UATH_CMD_FLAG_MAGIC) ? 1 << 24 : 0);
! 980: bcopy(idata, (uint8_t *)(hdr + 1), ilen);
! 981:
! 982: #ifdef UATH_DEBUG
! 983: if (uath_debug >= 5) {
! 984: printf("sending command code=0x%02x flags=0x%x index=%u",
! 985: code, flags, sc->cmd_idx);
! 986: uath_dump_cmd(cmd->buf, xferlen, '+');
! 987: }
! 988: #endif
! 989: xferflags = USBD_FORCE_SHORT_XFER | USBD_NO_COPY;
! 990: if (!(flags & UATH_CMD_FLAG_READ)) {
! 991: if (!(flags & UATH_CMD_FLAG_ASYNC))
! 992: xferflags |= USBD_SYNCHRONOUS;
! 993: } else
! 994: s = splusb();
! 995:
! 996: cmd->odata = odata;
! 997:
! 998: usbd_setup_xfer(cmd->xfer, sc->cmd_tx_pipe, cmd, cmd->buf, xferlen,
! 999: xferflags, UATH_CMD_TIMEOUT, NULL);
! 1000: error = usbd_transfer(cmd->xfer);
! 1001: if (error != USBD_IN_PROGRESS && error != 0) {
! 1002: if (flags & UATH_CMD_FLAG_READ)
! 1003: splx(s);
! 1004: printf("%s: could not send command 0x%x (error=%s)\n",
! 1005: sc->sc_dev.dv_xname, code, usbd_errstr(error));
! 1006: return error;
! 1007: }
! 1008: sc->cmd_idx = (sc->cmd_idx + 1) % UATH_TX_CMD_LIST_COUNT;
! 1009:
! 1010: if (!(flags & UATH_CMD_FLAG_READ))
! 1011: return 0; /* write: don't wait for reply */
! 1012:
! 1013: /* wait at most two seconds for command reply */
! 1014: error = tsleep(cmd, PCATCH, "uathcmd", 2 * hz);
! 1015: cmd->odata = NULL; /* in case answer is received too late */
! 1016: splx(s);
! 1017: if (error != 0) {
! 1018: printf("%s: timeout waiting for command reply\n",
! 1019: sc->sc_dev.dv_xname);
! 1020: }
! 1021: return error;
! 1022: }
! 1023:
! 1024: int
! 1025: uath_cmd_write(struct uath_softc *sc, uint32_t code, const void *data, int len,
! 1026: int flags)
! 1027: {
! 1028: flags &= ~UATH_CMD_FLAG_READ;
! 1029: return uath_cmd(sc, code, data, len, NULL, flags);
! 1030: }
! 1031:
! 1032: int
! 1033: uath_cmd_read(struct uath_softc *sc, uint32_t code, const void *idata,
! 1034: int ilen, void *odata, int flags)
! 1035: {
! 1036: flags |= UATH_CMD_FLAG_READ;
! 1037: return uath_cmd(sc, code, idata, ilen, odata, flags);
! 1038: }
! 1039:
! 1040: int
! 1041: uath_write_reg(struct uath_softc *sc, uint32_t reg, uint32_t val)
! 1042: {
! 1043: struct uath_write_mac write;
! 1044: int error;
! 1045:
! 1046: write.reg = htobe32(reg);
! 1047: write.len = htobe32(0); /* 0 = single write */
! 1048: *(uint32_t *)write.data = htobe32(val);
! 1049:
! 1050: error = uath_cmd_write(sc, UATH_CMD_WRITE_MAC, &write,
! 1051: 3 * sizeof (uint32_t), 0);
! 1052: if (error != 0) {
! 1053: printf("%s: could not write register 0x%02x\n",
! 1054: sc->sc_dev.dv_xname, reg);
! 1055: }
! 1056: return error;
! 1057: }
! 1058:
! 1059: int
! 1060: uath_write_multi(struct uath_softc *sc, uint32_t reg, const void *data,
! 1061: int len)
! 1062: {
! 1063: struct uath_write_mac write;
! 1064: int error;
! 1065:
! 1066: write.reg = htobe32(reg);
! 1067: write.len = htobe32(len);
! 1068: bcopy(data, write.data, len);
! 1069:
! 1070: /* properly handle the case where len is zero (reset) */
! 1071: error = uath_cmd_write(sc, UATH_CMD_WRITE_MAC, &write,
! 1072: (len == 0) ? sizeof (uint32_t) : 2 * sizeof (uint32_t) + len, 0);
! 1073: if (error != 0) {
! 1074: printf("%s: could not write %d bytes to register 0x%02x\n",
! 1075: sc->sc_dev.dv_xname, len, reg);
! 1076: }
! 1077: return error;
! 1078: }
! 1079:
! 1080: int
! 1081: uath_read_reg(struct uath_softc *sc, uint32_t reg, uint32_t *val)
! 1082: {
! 1083: struct uath_read_mac read;
! 1084: int error;
! 1085:
! 1086: reg = htobe32(reg);
! 1087: error = uath_cmd_read(sc, UATH_CMD_READ_MAC, ®, sizeof reg, &read,
! 1088: 0);
! 1089: if (error != 0) {
! 1090: printf("%s: could not read register 0x%02x\n",
! 1091: sc->sc_dev.dv_xname, betoh32(reg));
! 1092: return error;
! 1093: }
! 1094: *val = betoh32(*(uint32_t *)read.data);
! 1095: return error;
! 1096: }
! 1097:
! 1098: int
! 1099: uath_read_eeprom(struct uath_softc *sc, uint32_t reg, void *odata)
! 1100: {
! 1101: struct uath_read_mac read;
! 1102: int len, error;
! 1103:
! 1104: reg = htobe32(reg);
! 1105: error = uath_cmd_read(sc, UATH_CMD_READ_EEPROM, ®, sizeof reg,
! 1106: &read, 0);
! 1107: if (error != 0) {
! 1108: printf("%s: could not read EEPROM offset 0x%02x\n",
! 1109: sc->sc_dev.dv_xname, betoh32(reg));
! 1110: return error;
! 1111: }
! 1112: len = betoh32(read.len);
! 1113: bcopy(read.data, odata, (len == 0) ? sizeof (uint32_t) : len);
! 1114: return error;
! 1115: }
! 1116:
! 1117: void
! 1118: uath_cmd_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv,
! 1119: usbd_status status)
! 1120: {
! 1121: struct uath_rx_cmd *cmd = priv;
! 1122: struct uath_softc *sc = cmd->sc;
! 1123: struct uath_cmd_hdr *hdr;
! 1124:
! 1125: if (status != USBD_NORMAL_COMPLETION) {
! 1126: if (status == USBD_STALLED)
! 1127: usbd_clear_endpoint_stall_async(sc->cmd_rx_pipe);
! 1128: return;
! 1129: }
! 1130:
! 1131: hdr = (struct uath_cmd_hdr *)cmd->buf;
! 1132:
! 1133: #ifdef UATH_DEBUG
! 1134: if (uath_debug >= 5) {
! 1135: printf("received command code=0x%x index=%u len=%u",
! 1136: betoh32(hdr->code), hdr->priv, betoh32(hdr->len));
! 1137: uath_dump_cmd(cmd->buf, betoh32(hdr->len), '-');
! 1138: }
! 1139: #endif
! 1140:
! 1141: switch (betoh32(hdr->code) & 0xff) {
! 1142: /* reply to a read command */
! 1143: default:
! 1144: {
! 1145: struct uath_tx_cmd *txcmd = &sc->tx_cmd[hdr->priv];
! 1146:
! 1147: if (txcmd->odata != NULL) {
! 1148: /* copy answer into caller's supplied buffer */
! 1149: bcopy((uint8_t *)(hdr + 1), txcmd->odata,
! 1150: betoh32(hdr->len) - sizeof (struct uath_cmd_hdr));
! 1151: }
! 1152: wakeup(txcmd); /* wake up caller */
! 1153: break;
! 1154: }
! 1155: /* spontaneous firmware notifications */
! 1156: case UATH_NOTIF_READY:
! 1157: DPRINTF(("received device ready notification\n"));
! 1158: wakeup(UATH_COND_INIT(sc));
! 1159: break;
! 1160:
! 1161: case UATH_NOTIF_TX:
! 1162: /* this notification is sent when UATH_TX_NOTIFY is set */
! 1163: DPRINTF(("received Tx notification\n"));
! 1164: break;
! 1165:
! 1166: case UATH_NOTIF_STATS:
! 1167: DPRINTFN(2, ("received device statistics\n"));
! 1168: timeout_add(&sc->stat_to, hz);
! 1169: break;
! 1170: }
! 1171:
! 1172: /* setup a new transfer */
! 1173: usbd_setup_xfer(xfer, sc->cmd_rx_pipe, cmd, cmd->buf, UATH_MAX_RXCMDSZ,
! 1174: USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,
! 1175: uath_cmd_rxeof);
! 1176: (void)usbd_transfer(xfer);
! 1177: }
! 1178:
! 1179: void
! 1180: uath_data_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv,
! 1181: usbd_status status)
! 1182: {
! 1183: struct uath_rx_data *data = priv;
! 1184: struct uath_softc *sc = data->sc;
! 1185: struct ieee80211com *ic = &sc->sc_ic;
! 1186: struct ifnet *ifp = &ic->ic_if;
! 1187: struct ieee80211_frame *wh;
! 1188: struct ieee80211_node *ni;
! 1189: struct uath_rx_data *ndata;
! 1190: struct uath_rx_desc *desc;
! 1191: struct mbuf *m;
! 1192: uint32_t hdr;
! 1193: int s, len;
! 1194:
! 1195: if (status != USBD_NORMAL_COMPLETION) {
! 1196: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
! 1197: return;
! 1198:
! 1199: if (status == USBD_STALLED)
! 1200: usbd_clear_endpoint_stall_async(sc->data_rx_pipe);
! 1201:
! 1202: ifp->if_ierrors++;
! 1203: return;
! 1204: }
! 1205: usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);
! 1206:
! 1207: if (len < UATH_MIN_RXBUFSZ) {
! 1208: DPRINTF(("wrong xfer size (len=%d)\n", len));
! 1209: ifp->if_ierrors++;
! 1210: goto skip;
! 1211: }
! 1212:
! 1213: hdr = betoh32(*(uint32_t *)data->buf);
! 1214:
! 1215: /* Rx descriptor is located at the end, 32-bit aligned */
! 1216: desc = (struct uath_rx_desc *)
! 1217: (data->buf + len - sizeof (struct uath_rx_desc));
! 1218:
! 1219: if (betoh32(desc->len) > sc->rxbufsz) {
! 1220: DPRINTF(("bad descriptor (len=%d)\n", betoh32(desc->len)));
! 1221: ifp->if_ierrors++;
! 1222: goto skip;
! 1223: }
! 1224:
! 1225: /* there's probably a "bad CRC" flag somewhere in the descriptor.. */
! 1226:
! 1227: MGETHDR(m, M_DONTWAIT, MT_DATA);
! 1228: if (m == NULL) {
! 1229: ifp->if_ierrors++;
! 1230: goto skip;
! 1231: }
! 1232:
! 1233: /* grab a new Rx buffer */
! 1234: ndata = SLIST_FIRST(&sc->rx_freelist);
! 1235: if (ndata == NULL) {
! 1236: printf("%s: could not allocate Rx buffer\n",
! 1237: sc->sc_dev.dv_xname);
! 1238: m_freem(m);
! 1239: ifp->if_ierrors++;
! 1240: goto skip;
! 1241: }
! 1242: SLIST_REMOVE_HEAD(&sc->rx_freelist, next);
! 1243:
! 1244: MEXTADD(m, data->buf, sc->rxbufsz, 0, uath_free_rx_data, data);
! 1245:
! 1246: /* finalize mbuf */
! 1247: m->m_pkthdr.rcvif = ifp;
! 1248: m->m_data = data->buf + sizeof (uint32_t);
! 1249: m->m_pkthdr.len = m->m_len = betoh32(desc->len) -
! 1250: sizeof (struct uath_rx_desc) - IEEE80211_CRC_LEN;
! 1251:
! 1252: data = ndata;
! 1253:
! 1254: wh = mtod(m, struct ieee80211_frame *);
! 1255: if ((wh->i_fc[1] & IEEE80211_FC1_WEP) &&
! 1256: ic->ic_opmode != IEEE80211_M_MONITOR) {
! 1257: /*
! 1258: * Hardware decrypts the frame itself but leaves the WEP bit
! 1259: * set in the 802.11 header and doesn't remove the IV and CRC
! 1260: * fields.
! 1261: */
! 1262: wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
! 1263: ovbcopy(wh, (caddr_t)wh + IEEE80211_WEP_IVLEN +
! 1264: IEEE80211_WEP_KIDLEN, sizeof (struct ieee80211_frame));
! 1265: m_adj(m, IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN);
! 1266: m_adj(m, -IEEE80211_WEP_CRCLEN);
! 1267: wh = mtod(m, struct ieee80211_frame *);
! 1268: }
! 1269:
! 1270: #if NBPFILTER > 0
! 1271: /* there are a lot more fields in the Rx descriptor */
! 1272: if (sc->sc_drvbpf != NULL) {
! 1273: struct mbuf mb;
! 1274: struct uath_rx_radiotap_header *tap = &sc->sc_rxtap;
! 1275:
! 1276: tap->wr_flags = 0;
! 1277: tap->wr_chan_freq = htole16(betoh32(desc->freq));
! 1278: tap->wr_chan_flags = htole16(ic->ic_bss->ni_chan->ic_flags);
! 1279: tap->wr_dbm_antsignal = (int8_t)betoh32(desc->rssi);
! 1280:
! 1281: mb.m_data = (caddr_t)tap;
! 1282: mb.m_len = sc->sc_rxtap_len;
! 1283: mb.m_next = m;
! 1284: mb.m_nextpkt = NULL;
! 1285: mb.m_type = 0;
! 1286: mb.m_flags = 0;
! 1287: bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_IN);
! 1288: }
! 1289: #endif
! 1290:
! 1291: s = splnet();
! 1292: sc->sc_refcnt++;
! 1293: ni = ieee80211_find_rxnode(ic, wh);
! 1294: ieee80211_input(ifp, m, ni, (int)betoh32(desc->rssi), 0);
! 1295:
! 1296: /* node is no longer needed */
! 1297: ieee80211_release_node(ic, ni);
! 1298: splx(s);
! 1299:
! 1300: skip: /* setup a new transfer */
! 1301: usbd_setup_xfer(data->xfer, sc->data_rx_pipe, data, data->buf,
! 1302: sc->rxbufsz, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,
! 1303: uath_data_rxeof);
! 1304: (void)usbd_transfer(data->xfer);
! 1305: }
! 1306:
! 1307: int
! 1308: uath_tx_null(struct uath_softc *sc)
! 1309: {
! 1310: struct uath_tx_data *data;
! 1311: struct uath_tx_desc *desc;
! 1312:
! 1313: data = &sc->tx_data[sc->data_idx];
! 1314:
! 1315: data->ni = NULL;
! 1316:
! 1317: *(uint32_t *)data->buf = UATH_MAKECTL(1, sizeof (struct uath_tx_desc));
! 1318: desc = (struct uath_tx_desc *)(data->buf + sizeof (uint32_t));
! 1319:
! 1320: bzero(desc, sizeof (struct uath_tx_desc));
! 1321: desc->len = htobe32(sizeof (struct uath_tx_desc));
! 1322: desc->type = htobe32(UATH_TX_NULL);
! 1323:
! 1324: usbd_setup_xfer(data->xfer, sc->data_tx_pipe, data, data->buf,
! 1325: sizeof (uint32_t) + sizeof (struct uath_tx_desc), USBD_NO_COPY |
! 1326: USBD_FORCE_SHORT_XFER, UATH_DATA_TIMEOUT, NULL);
! 1327: if (usbd_sync_transfer(data->xfer) != 0)
! 1328: return EIO;
! 1329:
! 1330: sc->data_idx = (sc->data_idx + 1) % UATH_TX_DATA_LIST_COUNT;
! 1331:
! 1332: return uath_cmd_write(sc, UATH_CMD_0F, NULL, 0, UATH_CMD_FLAG_ASYNC);
! 1333: }
! 1334:
! 1335: void
! 1336: uath_data_txeof(usbd_xfer_handle xfer, usbd_private_handle priv,
! 1337: usbd_status status)
! 1338: {
! 1339: struct uath_tx_data *data = priv;
! 1340: struct uath_softc *sc = data->sc;
! 1341: struct ieee80211com *ic = &sc->sc_ic;
! 1342: struct ifnet *ifp = &ic->ic_if;
! 1343: int s;
! 1344:
! 1345: if (status != USBD_NORMAL_COMPLETION) {
! 1346: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
! 1347: return;
! 1348:
! 1349: printf("%s: could not transmit buffer: %s\n",
! 1350: sc->sc_dev.dv_xname, usbd_errstr(status));
! 1351:
! 1352: if (status == USBD_STALLED)
! 1353: usbd_clear_endpoint_stall_async(sc->data_tx_pipe);
! 1354:
! 1355: ifp->if_oerrors++;
! 1356: return;
! 1357: }
! 1358:
! 1359: s = splnet();
! 1360:
! 1361: ieee80211_release_node(ic, data->ni);
! 1362: data->ni = NULL;
! 1363:
! 1364: sc->tx_queued--;
! 1365: ifp->if_opackets++;
! 1366:
! 1367: sc->sc_tx_timer = 0;
! 1368: ifp->if_flags &= ~IFF_OACTIVE;
! 1369: uath_start(ifp);
! 1370:
! 1371: splx(s);
! 1372: }
! 1373:
! 1374: int
! 1375: uath_tx_data(struct uath_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
! 1376: {
! 1377: struct ieee80211com *ic = &sc->sc_ic;
! 1378: struct uath_tx_data *data;
! 1379: struct uath_tx_desc *desc;
! 1380: const struct ieee80211_frame *wh;
! 1381: int paylen, totlen, xferlen, error;
! 1382:
! 1383: data = &sc->tx_data[sc->data_idx];
! 1384: desc = (struct uath_tx_desc *)(data->buf + sizeof (uint32_t));
! 1385:
! 1386: data->ni = ni;
! 1387:
! 1388: #if NBPFILTER > 0
! 1389: if (sc->sc_drvbpf != NULL) {
! 1390: struct mbuf mb;
! 1391: struct uath_tx_radiotap_header *tap = &sc->sc_txtap;
! 1392:
! 1393: tap->wt_flags = 0;
! 1394: tap->wt_chan_freq = htole16(ic->ic_bss->ni_chan->ic_freq);
! 1395: tap->wt_chan_flags = htole16(ic->ic_bss->ni_chan->ic_flags);
! 1396:
! 1397: mb.m_data = (caddr_t)tap;
! 1398: mb.m_len = sc->sc_txtap_len;
! 1399: mb.m_next = m0;
! 1400: mb.m_nextpkt = NULL;
! 1401: mb.m_type = 0;
! 1402: mb.m_flags = 0;
! 1403: bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_OUT);
! 1404: }
! 1405: #endif
! 1406:
! 1407: paylen = m0->m_pkthdr.len;
! 1408: xferlen = sizeof (uint32_t) + sizeof (struct uath_tx_desc) + paylen;
! 1409:
! 1410: wh = mtod(m0, struct ieee80211_frame *);
! 1411: if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
! 1412: uint8_t *frm = (uint8_t *)(desc + 1);
! 1413: uint32_t iv;
! 1414:
! 1415: /* h/w WEP: it's up to the host to fill the IV field */
! 1416: bcopy(wh, frm, sizeof (struct ieee80211_frame));
! 1417: frm += sizeof (struct ieee80211_frame);
! 1418:
! 1419: /* insert IV: code copied from net80211 */
! 1420: iv = (ic->ic_iv != 0) ? ic->ic_iv : arc4random();
! 1421: if (iv >= 0x03ff00 && (iv & 0xf8ff00) == 0x00ff00)
! 1422: iv += 0x000100;
! 1423: ic->ic_iv = iv + 1;
! 1424:
! 1425: *frm++ = iv & 0xff;
! 1426: *frm++ = (iv >> 8) & 0xff;
! 1427: *frm++ = (iv >> 16) & 0xff;
! 1428: *frm++ = ic->ic_wep_txkey << 6;
! 1429:
! 1430: m_copydata(m0, sizeof (struct ieee80211_frame),
! 1431: m0->m_pkthdr.len - sizeof (struct ieee80211_frame), frm);
! 1432:
! 1433: paylen += IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN;
! 1434: xferlen += IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN;
! 1435: totlen = xferlen + IEEE80211_WEP_CRCLEN;
! 1436: } else {
! 1437: m_copydata(m0, 0, m0->m_pkthdr.len, (uint8_t *)(desc + 1));
! 1438: totlen = xferlen;
! 1439: }
! 1440:
! 1441: /* fill Tx descriptor */
! 1442: *(uint32_t *)data->buf = UATH_MAKECTL(1, xferlen - sizeof (uint32_t));
! 1443:
! 1444: desc->len = htobe32(totlen);
! 1445: desc->priv = sc->data_idx; /* don't care about endianness */
! 1446: desc->paylen = htobe32(paylen);
! 1447: desc->type = htobe32(UATH_TX_DATA);
! 1448: desc->flags = htobe32(0);
! 1449: if (IEEE80211_IS_MULTICAST(wh->i_addr1)) {
! 1450: desc->dest = htobe32(UATH_ID_BROADCAST);
! 1451: desc->magic = htobe32(3);
! 1452: } else {
! 1453: desc->dest = htobe32(UATH_ID_BSS);
! 1454: desc->magic = htobe32(1);
! 1455: }
! 1456:
! 1457: m_freem(m0); /* mbuf is no longer needed */
! 1458:
! 1459: #ifdef UATH_DEBUG
! 1460: if (uath_debug >= 6) {
! 1461: printf("sending frame index=%u len=%d xferlen=%d",
! 1462: sc->data_idx, paylen, xferlen);
! 1463: uath_dump_cmd(data->buf, xferlen, '+');
! 1464: }
! 1465: #endif
! 1466: usbd_setup_xfer(data->xfer, sc->data_tx_pipe, data, data->buf, xferlen,
! 1467: USBD_FORCE_SHORT_XFER | USBD_NO_COPY, UATH_DATA_TIMEOUT,
! 1468: uath_data_txeof);
! 1469: error = usbd_transfer(data->xfer);
! 1470: if (error != USBD_IN_PROGRESS && error != 0) {
! 1471: ic->ic_if.if_oerrors++;
! 1472: return error;
! 1473: }
! 1474: sc->data_idx = (sc->data_idx + 1) % UATH_TX_DATA_LIST_COUNT;
! 1475: sc->tx_queued++;
! 1476:
! 1477: return 0;
! 1478: }
! 1479:
! 1480: void
! 1481: uath_start(struct ifnet *ifp)
! 1482: {
! 1483: struct uath_softc *sc = ifp->if_softc;
! 1484: struct ieee80211com *ic = &sc->sc_ic;
! 1485: struct ieee80211_node *ni;
! 1486: struct mbuf *m0;
! 1487:
! 1488: /*
! 1489: * net80211 may still try to send management frames even if the
! 1490: * IFF_RUNNING flag is not set...
! 1491: */
! 1492: if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
! 1493: return;
! 1494:
! 1495: for (;;) {
! 1496: IF_POLL(&ic->ic_mgtq, m0);
! 1497: if (m0 != NULL) {
! 1498: if (sc->tx_queued >= UATH_TX_DATA_LIST_COUNT) {
! 1499: ifp->if_flags |= IFF_OACTIVE;
! 1500: break;
! 1501: }
! 1502: IF_DEQUEUE(&ic->ic_mgtq, m0);
! 1503:
! 1504: ni = (struct ieee80211_node *)m0->m_pkthdr.rcvif;
! 1505: m0->m_pkthdr.rcvif = NULL;
! 1506: #if NBPFILTER > 0
! 1507: if (ic->ic_rawbpf != NULL)
! 1508: bpf_mtap(ic->ic_rawbpf, m0, BPF_DIRECTION_OUT);
! 1509: #endif
! 1510: if (uath_tx_data(sc, m0, ni) != 0)
! 1511: break;
! 1512: } else {
! 1513: if (ic->ic_state != IEEE80211_S_RUN)
! 1514: break;
! 1515: IFQ_POLL(&ifp->if_snd, m0);
! 1516: if (m0 == NULL)
! 1517: break;
! 1518: if (sc->tx_queued >= UATH_TX_DATA_LIST_COUNT) {
! 1519: ifp->if_flags |= IFF_OACTIVE;
! 1520: break;
! 1521: }
! 1522: IFQ_DEQUEUE(&ifp->if_snd, m0);
! 1523: #if NBPFILTER > 0
! 1524: if (ifp->if_bpf != NULL)
! 1525: bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
! 1526: #endif
! 1527: m0 = ieee80211_encap(ifp, m0, &ni);
! 1528: if (m0 == NULL)
! 1529: continue;
! 1530: #if NBPFILTER > 0
! 1531: if (ic->ic_rawbpf != NULL)
! 1532: bpf_mtap(ic->ic_rawbpf, m0, BPF_DIRECTION_OUT);
! 1533: #endif
! 1534: if (uath_tx_data(sc, m0, ni) != 0) {
! 1535: if (ni != NULL)
! 1536: ieee80211_release_node(ic, ni);
! 1537: ifp->if_oerrors++;
! 1538: break;
! 1539: }
! 1540: }
! 1541:
! 1542: sc->sc_tx_timer = 5;
! 1543: ifp->if_timer = 1;
! 1544: }
! 1545: }
! 1546:
! 1547: void
! 1548: uath_watchdog(struct ifnet *ifp)
! 1549: {
! 1550: struct uath_softc *sc = ifp->if_softc;
! 1551:
! 1552: ifp->if_timer = 0;
! 1553:
! 1554: if (sc->sc_tx_timer > 0) {
! 1555: if (--sc->sc_tx_timer == 0) {
! 1556: printf("%s: device timeout\n", sc->sc_dev.dv_xname);
! 1557: /*uath_init(ifp); XXX needs a process context! */
! 1558: ifp->if_oerrors++;
! 1559: return;
! 1560: }
! 1561: ifp->if_timer = 1;
! 1562: }
! 1563:
! 1564: ieee80211_watchdog(ifp);
! 1565: }
! 1566:
! 1567: int
! 1568: uath_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
! 1569: {
! 1570: struct uath_softc *sc = ifp->if_softc;
! 1571: struct ieee80211com *ic = &sc->sc_ic;
! 1572: struct ifaddr *ifa;
! 1573: struct ifreq *ifr;
! 1574: int s, error = 0;
! 1575:
! 1576: s = splnet();
! 1577:
! 1578: switch (cmd) {
! 1579: case SIOCSIFADDR:
! 1580: ifa = (struct ifaddr *)data;
! 1581: ifp->if_flags |= IFF_UP;
! 1582: #ifdef INET
! 1583: if (ifa->ifa_addr->sa_family == AF_INET)
! 1584: arp_ifinit(&ic->ic_ac, ifa);
! 1585: #endif
! 1586: /* FALLTHROUGH */
! 1587: case SIOCSIFFLAGS:
! 1588: if (ifp->if_flags & IFF_UP) {
! 1589: if (!(ifp->if_flags & IFF_RUNNING))
! 1590: uath_init(ifp);
! 1591: } else {
! 1592: if (ifp->if_flags & IFF_RUNNING)
! 1593: uath_stop(ifp, 1);
! 1594: }
! 1595: break;
! 1596:
! 1597: case SIOCADDMULTI:
! 1598: case SIOCDELMULTI:
! 1599: ifr = (struct ifreq *)data;
! 1600: error = (cmd == SIOCADDMULTI) ?
! 1601: ether_addmulti(ifr, &ic->ic_ac) :
! 1602: ether_delmulti(ifr, &ic->ic_ac);
! 1603: if (error == ENETRESET)
! 1604: error = 0;
! 1605: break;
! 1606:
! 1607: default:
! 1608: error = ieee80211_ioctl(ifp, cmd, data);
! 1609: }
! 1610:
! 1611: if (error == ENETRESET) {
! 1612: if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
! 1613: (IFF_UP | IFF_RUNNING))
! 1614: uath_init(ifp);
! 1615: error = 0;
! 1616: }
! 1617:
! 1618: splx(s);
! 1619:
! 1620: return error;
! 1621: }
! 1622:
! 1623: int
! 1624: uath_query_eeprom(struct uath_softc *sc)
! 1625: {
! 1626: uint32_t tmp;
! 1627: int error;
! 1628:
! 1629: /* retrieve MAC address */
! 1630: error = uath_read_eeprom(sc, UATH_EEPROM_MACADDR, sc->sc_ic.ic_myaddr);
! 1631: if (error != 0) {
! 1632: printf("%s: could not read MAC address\n",
! 1633: sc->sc_dev.dv_xname);
! 1634: return error;
! 1635: }
! 1636:
! 1637: /* retrieve the maximum frame size that the hardware can receive */
! 1638: error = uath_read_eeprom(sc, UATH_EEPROM_RXBUFSZ, &tmp);
! 1639: if (error != 0) {
! 1640: printf("%s: could not read maximum Rx buffer size\n",
! 1641: sc->sc_dev.dv_xname);
! 1642: return error;
! 1643: }
! 1644: sc->rxbufsz = betoh32(tmp) & 0xfff;
! 1645: DPRINTF(("maximum Rx buffer size %d\n", sc->rxbufsz));
! 1646: return 0;
! 1647: }
! 1648:
! 1649: int
! 1650: uath_reset(struct uath_softc *sc)
! 1651: {
! 1652: struct uath_cmd_setup setup;
! 1653: uint32_t reg, val;
! 1654: int s, error;
! 1655:
! 1656: /* init device with some voodoo incantations.. */
! 1657: setup.magic1 = htobe32(1);
! 1658: setup.magic2 = htobe32(5);
! 1659: setup.magic3 = htobe32(200);
! 1660: setup.magic4 = htobe32(27);
! 1661: s = splusb();
! 1662: error = uath_cmd_write(sc, UATH_CMD_SETUP, &setup, sizeof setup,
! 1663: UATH_CMD_FLAG_ASYNC);
! 1664: /* ..and wait until firmware notifies us that it is ready */
! 1665: if (error == 0)
! 1666: error = tsleep(UATH_COND_INIT(sc), PCATCH, "uathinit", 5 * hz);
! 1667: splx(s);
! 1668: if (error != 0)
! 1669: return error;
! 1670:
! 1671: /* read PHY registers */
! 1672: for (reg = 0x09; reg <= 0x24; reg++) {
! 1673: if (reg == 0x0b || reg == 0x0c)
! 1674: continue;
! 1675: DELAY(100);
! 1676: if ((error = uath_read_reg(sc, reg, &val)) != 0)
! 1677: return error;
! 1678: DPRINTFN(2, ("reg 0x%02x=0x%08x\n", reg, val));
! 1679: }
! 1680: return error;
! 1681: }
! 1682:
! 1683: int
! 1684: uath_reset_tx_queues(struct uath_softc *sc)
! 1685: {
! 1686: int ac, error;
! 1687:
! 1688: for (ac = 0; ac < 4; ac++) {
! 1689: const uint32_t qid = htobe32(UATH_AC_TO_QID(ac));
! 1690:
! 1691: DPRINTF(("resetting Tx queue %d\n", UATH_AC_TO_QID(ac)));
! 1692: error = uath_cmd_write(sc, UATH_CMD_RESET_QUEUE, &qid,
! 1693: sizeof qid, 0);
! 1694: if (error != 0)
! 1695: break;
! 1696: }
! 1697: return error;
! 1698: }
! 1699:
! 1700: int
! 1701: uath_wme_init(struct uath_softc *sc)
! 1702: {
! 1703: struct uath_qinfo qinfo;
! 1704: int ac, error;
! 1705: static const struct uath_wme_settings uath_wme_11g[4] = {
! 1706: { 7, 4, 10, 0, 0 }, /* Background */
! 1707: { 3, 4, 10, 0, 0 }, /* Best-Effort */
! 1708: { 3, 3, 4, 26, 0 }, /* Video */
! 1709: { 2, 2, 3, 47, 0 } /* Voice */
! 1710: };
! 1711:
! 1712: bzero(&qinfo, sizeof qinfo);
! 1713: qinfo.size = htobe32(32);
! 1714: qinfo.magic1 = htobe32(1); /* XXX ack policy? */
! 1715: qinfo.magic2 = htobe32(1);
! 1716: for (ac = 0; ac < 4; ac++) {
! 1717: qinfo.qid = htobe32(UATH_AC_TO_QID(ac));
! 1718: qinfo.ac = htobe32(ac);
! 1719: qinfo.aifsn = htobe32(uath_wme_11g[ac].aifsn);
! 1720: qinfo.logcwmin = htobe32(uath_wme_11g[ac].logcwmin);
! 1721: qinfo.logcwmax = htobe32(uath_wme_11g[ac].logcwmax);
! 1722: qinfo.txop = htobe32(UATH_TXOP_TO_US(
! 1723: uath_wme_11g[ac].txop));
! 1724: qinfo.acm = htobe32(uath_wme_11g[ac].acm);
! 1725:
! 1726: DPRINTF(("setting up Tx queue %d\n", UATH_AC_TO_QID(ac)));
! 1727: error = uath_cmd_write(sc, UATH_CMD_SET_QUEUE, &qinfo,
! 1728: sizeof qinfo, 0);
! 1729: if (error != 0)
! 1730: break;
! 1731: }
! 1732: return error;
! 1733: }
! 1734:
! 1735: int
! 1736: uath_set_chan(struct uath_softc *sc, struct ieee80211_channel *c)
! 1737: {
! 1738: struct uath_set_chan chan;
! 1739:
! 1740: bzero(&chan, sizeof chan);
! 1741: chan.flags = htobe32(0x1400);
! 1742: chan.freq = htobe32(c->ic_freq);
! 1743: chan.magic1 = htobe32(20);
! 1744: chan.magic2 = htobe32(50);
! 1745: chan.magic3 = htobe32(1);
! 1746:
! 1747: DPRINTF(("switching to channel %d\n",
! 1748: ieee80211_chan2ieee(&sc->sc_ic, c)));
! 1749: return uath_cmd_write(sc, UATH_CMD_SET_CHAN, &chan, sizeof chan, 0);
! 1750: }
! 1751:
! 1752: int
! 1753: uath_set_key(struct uath_softc *sc, const struct ieee80211_key *k, int index)
! 1754: {
! 1755: struct uath_cmd_crypto crypto;
! 1756: int i;
! 1757:
! 1758: bzero(&crypto, sizeof crypto);
! 1759: crypto.keyidx = htobe32(index);
! 1760: crypto.magic1 = htobe32(1);
! 1761: crypto.size = htobe32(368);
! 1762: crypto.mask = htobe32(0xffff);
! 1763: crypto.flags = htobe32(0x80000068);
! 1764: if (index != UATH_DEFAULT_KEY)
! 1765: crypto.flags |= htobe32(index << 16);
! 1766: memset(crypto.magic2, 0xff, sizeof crypto.magic2);
! 1767:
! 1768: /*
! 1769: * Each byte of the key must be XOR'ed with 10101010 before being
! 1770: * transmitted to the firmware.
! 1771: */
! 1772: for (i = 0; i < k->k_len; i++)
! 1773: crypto.key[i] = k->k_key[i] ^ 0xaa;
! 1774:
! 1775: DPRINTF(("setting crypto key index=%d len=%d\n", index, k->k_len));
! 1776: return uath_cmd_write(sc, UATH_CMD_CRYPTO, &crypto, sizeof crypto, 0);
! 1777: }
! 1778:
! 1779: int
! 1780: uath_set_keys(struct uath_softc *sc)
! 1781: {
! 1782: const struct ieee80211com *ic = &sc->sc_ic;
! 1783: int i, error;
! 1784:
! 1785: for (i = 0; i < IEEE80211_WEP_NKID; i++) {
! 1786: const struct ieee80211_key *k = &ic->ic_nw_keys[i];
! 1787:
! 1788: if (k->k_len > 0 && (error = uath_set_key(sc, k, i)) != 0)
! 1789: return error;
! 1790: }
! 1791: return uath_set_key(sc, &ic->ic_nw_keys[ic->ic_wep_txkey],
! 1792: UATH_DEFAULT_KEY);
! 1793: }
! 1794:
! 1795: int
! 1796: uath_set_rates(struct uath_softc *sc, const struct ieee80211_rateset *rs)
! 1797: {
! 1798: struct uath_cmd_rates rates;
! 1799:
! 1800: bzero(&rates, sizeof rates);
! 1801: rates.magic1 = htobe32(0x02);
! 1802: rates.size = htobe32(1 + sizeof rates.rates);
! 1803: rates.nrates = rs->rs_nrates;
! 1804: bcopy(rs->rs_rates, rates.rates, rs->rs_nrates);
! 1805:
! 1806: DPRINTF(("setting supported rates nrates=%d\n", rs->rs_nrates));
! 1807: return uath_cmd_write(sc, UATH_CMD_SET_RATES, &rates, sizeof rates, 0);
! 1808: }
! 1809:
! 1810: int
! 1811: uath_set_rxfilter(struct uath_softc *sc, uint32_t filter, uint32_t flags)
! 1812: {
! 1813: struct uath_cmd_filter rxfilter;
! 1814:
! 1815: rxfilter.filter = htobe32(filter);
! 1816: rxfilter.flags = htobe32(flags);
! 1817:
! 1818: DPRINTF(("setting Rx filter=0x%x flags=0x%x\n", filter, flags));
! 1819: return uath_cmd_write(sc, UATH_CMD_SET_FILTER, &rxfilter,
! 1820: sizeof rxfilter, 0);
! 1821: }
! 1822:
! 1823: int
! 1824: uath_set_led(struct uath_softc *sc, int which, int on)
! 1825: {
! 1826: struct uath_cmd_led led;
! 1827:
! 1828: led.which = htobe32(which);
! 1829: led.state = htobe32(on ? UATH_LED_ON : UATH_LED_OFF);
! 1830:
! 1831: DPRINTFN(2, ("switching %s led %s\n",
! 1832: (which == UATH_LED_LINK) ? "link" : "activity",
! 1833: on ? "on" : "off"));
! 1834: return uath_cmd_write(sc, UATH_CMD_SET_LED, &led, sizeof led, 0);
! 1835: }
! 1836:
! 1837: int
! 1838: uath_switch_channel(struct uath_softc *sc, struct ieee80211_channel *c)
! 1839: {
! 1840: uint32_t val;
! 1841: int error;
! 1842:
! 1843: /* set radio frequency */
! 1844: if ((error = uath_set_chan(sc, c)) != 0) {
! 1845: printf("%s: could not set channel\n", sc->sc_dev.dv_xname);
! 1846: return error;
! 1847: }
! 1848:
! 1849: /* reset Tx rings */
! 1850: if ((error = uath_reset_tx_queues(sc)) != 0) {
! 1851: printf("%s: could not reset Tx queues\n",
! 1852: sc->sc_dev.dv_xname);
! 1853: return error;
! 1854: }
! 1855:
! 1856: /* set Tx rings WME properties */
! 1857: if ((error = uath_wme_init(sc)) != 0) {
! 1858: printf("%s: could not init Tx queues\n",
! 1859: sc->sc_dev.dv_xname);
! 1860: return error;
! 1861: }
! 1862:
! 1863: val = htobe32(0);
! 1864: error = uath_cmd_write(sc, UATH_CMD_SET_STATE, &val, sizeof val, 0);
! 1865: if (error != 0) {
! 1866: printf("%s: could not set state\n", sc->sc_dev.dv_xname);
! 1867: return error;
! 1868: }
! 1869:
! 1870: return uath_tx_null(sc);
! 1871: }
! 1872:
! 1873: int
! 1874: uath_init(struct ifnet *ifp)
! 1875: {
! 1876: struct uath_softc *sc = ifp->if_softc;
! 1877: struct ieee80211com *ic = &sc->sc_ic;
! 1878: struct uath_cmd_31 cmd31;
! 1879: uint32_t val;
! 1880: int i, error;
! 1881:
! 1882: /* reset data and command rings */
! 1883: sc->tx_queued = sc->data_idx = sc->cmd_idx = 0;
! 1884:
! 1885: val = htobe32(0);
! 1886: (void)uath_cmd_write(sc, UATH_CMD_02, &val, sizeof val, 0);
! 1887:
! 1888: /* set MAC address */
! 1889: IEEE80211_ADDR_COPY(ic->ic_myaddr, LLADDR(ifp->if_sadl));
! 1890: (void)uath_write_multi(sc, 0x13, ic->ic_myaddr, IEEE80211_ADDR_LEN);
! 1891:
! 1892: (void)uath_write_reg(sc, 0x02, 0x00000001);
! 1893: (void)uath_write_reg(sc, 0x0e, 0x0000003f);
! 1894: (void)uath_write_reg(sc, 0x10, 0x00000001);
! 1895: (void)uath_write_reg(sc, 0x06, 0x0000001e);
! 1896:
! 1897: /*
! 1898: * Queue Rx data xfers.
! 1899: */
! 1900: for (i = 0; i < UATH_RX_DATA_LIST_COUNT; i++) {
! 1901: struct uath_rx_data *data = SLIST_FIRST(&sc->rx_freelist);
! 1902:
! 1903: usbd_setup_xfer(data->xfer, sc->data_rx_pipe, data, data->buf,
! 1904: sc->rxbufsz, USBD_SHORT_XFER_OK | USBD_NO_COPY,
! 1905: USBD_NO_TIMEOUT, uath_data_rxeof);
! 1906: error = usbd_transfer(data->xfer);
! 1907: if (error != USBD_IN_PROGRESS && error != 0) {
! 1908: printf("%s: could not queue Rx transfer\n",
! 1909: sc->sc_dev.dv_xname);
! 1910: goto fail;
! 1911: }
! 1912: SLIST_REMOVE_HEAD(&sc->rx_freelist, next);
! 1913: }
! 1914:
! 1915: error = uath_cmd_read(sc, UATH_CMD_07, 0, NULL, &val,
! 1916: UATH_CMD_FLAG_MAGIC);
! 1917: if (error != 0) {
! 1918: printf("%s: could not send read command 07h\n",
! 1919: sc->sc_dev.dv_xname);
! 1920: goto fail;
! 1921: }
! 1922: DPRINTF(("command 07h return code: %x\n", betoh32(val)));
! 1923:
! 1924: /* set default channel */
! 1925: ic->ic_bss->ni_chan = ic->ic_ibss_chan;
! 1926: if ((error = uath_set_chan(sc, ic->ic_bss->ni_chan)) != 0) {
! 1927: printf("%s: could not set channel\n", sc->sc_dev.dv_xname);
! 1928: goto fail;
! 1929: }
! 1930:
! 1931: if ((error = uath_wme_init(sc)) != 0) {
! 1932: printf("%s: could not setup WME parameters\n",
! 1933: sc->sc_dev.dv_xname);
! 1934: goto fail;
! 1935: }
! 1936:
! 1937: /* init MAC registers */
! 1938: (void)uath_write_reg(sc, 0x19, 0x00000000);
! 1939: (void)uath_write_reg(sc, 0x1a, 0x0000003c);
! 1940: (void)uath_write_reg(sc, 0x1b, 0x0000003c);
! 1941: (void)uath_write_reg(sc, 0x1c, 0x00000000);
! 1942: (void)uath_write_reg(sc, 0x1e, 0x00000000);
! 1943: (void)uath_write_reg(sc, 0x1f, 0x00000003);
! 1944: (void)uath_write_reg(sc, 0x0c, 0x00000000);
! 1945: (void)uath_write_reg(sc, 0x0f, 0x00000002);
! 1946: (void)uath_write_reg(sc, 0x0a, 0x00000007); /* XXX retry? */
! 1947: (void)uath_write_reg(sc, 0x09, ic->ic_rtsthreshold);
! 1948:
! 1949: val = htobe32(4);
! 1950: (void)uath_cmd_write(sc, UATH_CMD_27, &val, sizeof val, 0);
! 1951: (void)uath_cmd_write(sc, UATH_CMD_27, &val, sizeof val, 0);
! 1952: (void)uath_cmd_write(sc, UATH_CMD_1B, NULL, 0, 0);
! 1953:
! 1954: if ((error = uath_set_keys(sc)) != 0) {
! 1955: printf("%s: could not set crypto keys\n",
! 1956: sc->sc_dev.dv_xname);
! 1957: goto fail;
! 1958: }
! 1959:
! 1960: /* enable Rx */
! 1961: (void)uath_set_rxfilter(sc, 0x0000, 4);
! 1962: (void)uath_set_rxfilter(sc, 0x0817, 1);
! 1963:
! 1964: cmd31.magic1 = htobe32(0xffffffff);
! 1965: cmd31.magic2 = htobe32(0xffffffff);
! 1966: (void)uath_cmd_write(sc, UATH_CMD_31, &cmd31, sizeof cmd31, 0);
! 1967:
! 1968: ifp->if_flags &= ~IFF_OACTIVE;
! 1969: ifp->if_flags |= IFF_RUNNING;
! 1970:
! 1971: if (ic->ic_opmode == IEEE80211_M_MONITOR)
! 1972: ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
! 1973: else
! 1974: ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
! 1975:
! 1976: return 0;
! 1977:
! 1978: fail: uath_stop(ifp, 1);
! 1979: return error;
! 1980: }
! 1981:
! 1982: void
! 1983: uath_stop(struct ifnet *ifp, int disable)
! 1984: {
! 1985: struct uath_softc *sc = ifp->if_softc;
! 1986: struct ieee80211com *ic = &sc->sc_ic;
! 1987: uint32_t val;
! 1988: int s;
! 1989:
! 1990: s = splusb();
! 1991:
! 1992: sc->sc_tx_timer = 0;
! 1993: ifp->if_timer = 0;
! 1994: ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
! 1995:
! 1996: ieee80211_new_state(ic, IEEE80211_S_INIT, -1); /* free all nodes */
! 1997:
! 1998: val = htobe32(0);
! 1999: (void)uath_cmd_write(sc, UATH_CMD_SET_STATE, &val, sizeof val, 0);
! 2000: (void)uath_cmd_write(sc, UATH_CMD_RESET, NULL, 0, 0);
! 2001:
! 2002: val = htobe32(0);
! 2003: (void)uath_cmd_write(sc, UATH_CMD_15, &val, sizeof val, 0);
! 2004:
! 2005: #if 0
! 2006: (void)uath_cmd_read(sc, UATH_CMD_SHUTDOWN, NULL, 0, NULL,
! 2007: UATH_CMD_FLAG_MAGIC);
! 2008: #endif
! 2009:
! 2010: /* abort any pending transfers */
! 2011: usbd_abort_pipe(sc->data_tx_pipe);
! 2012: usbd_abort_pipe(sc->data_rx_pipe);
! 2013: usbd_abort_pipe(sc->cmd_tx_pipe);
! 2014:
! 2015: splx(s);
! 2016: }
! 2017:
! 2018: /*
! 2019: * Load the MIPS R4000 microcode into the device. Once the image is loaded,
! 2020: * the device will detach itself from the bus and reattach later with a new
! 2021: * product Id (a la ezusb). XXX this could also be implemented in userland
! 2022: * through /dev/ugen.
! 2023: */
! 2024: int
! 2025: uath_loadfirmware(struct uath_softc *sc, const u_char *fw, int len)
! 2026: {
! 2027: usbd_xfer_handle ctlxfer, txxfer, rxxfer;
! 2028: struct uath_fwblock *txblock, *rxblock;
! 2029: uint8_t *txdata;
! 2030: int error = 0;
! 2031:
! 2032: if ((ctlxfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) {
! 2033: printf("%s: could not allocate Tx control xfer\n",
! 2034: sc->sc_dev.dv_xname);
! 2035: error = USBD_NOMEM;
! 2036: goto fail1;
! 2037: }
! 2038: txblock = usbd_alloc_buffer(ctlxfer, sizeof (struct uath_fwblock));
! 2039: if (txblock == NULL) {
! 2040: printf("%s: could not allocate Tx control block\n",
! 2041: sc->sc_dev.dv_xname);
! 2042: error = USBD_NOMEM;
! 2043: goto fail2;
! 2044: }
! 2045:
! 2046: if ((txxfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) {
! 2047: printf("%s: could not allocate Tx xfer\n",
! 2048: sc->sc_dev.dv_xname);
! 2049: error = USBD_NOMEM;
! 2050: goto fail2;
! 2051: }
! 2052: txdata = usbd_alloc_buffer(txxfer, UATH_MAX_FWBLOCK_SIZE);
! 2053: if (txdata == NULL) {
! 2054: printf("%s: could not allocate Tx buffer\n",
! 2055: sc->sc_dev.dv_xname);
! 2056: error = USBD_NOMEM;
! 2057: goto fail3;
! 2058: }
! 2059:
! 2060: if ((rxxfer = usbd_alloc_xfer(sc->sc_udev)) == NULL) {
! 2061: printf("%s: could not allocate Rx control xfer\n",
! 2062: sc->sc_dev.dv_xname);
! 2063: error = USBD_NOMEM;
! 2064: goto fail3;
! 2065: }
! 2066: rxblock = usbd_alloc_buffer(rxxfer, sizeof (struct uath_fwblock));
! 2067: if (rxblock == NULL) {
! 2068: printf("%s: could not allocate Rx control block\n",
! 2069: sc->sc_dev.dv_xname);
! 2070: error = USBD_NOMEM;
! 2071: goto fail4;
! 2072: }
! 2073:
! 2074: bzero(txblock, sizeof (struct uath_fwblock));
! 2075: txblock->flags = htobe32(UATH_WRITE_BLOCK);
! 2076: txblock->total = htobe32(len);
! 2077:
! 2078: while (len > 0) {
! 2079: int mlen = min(len, UATH_MAX_FWBLOCK_SIZE);
! 2080:
! 2081: txblock->remain = htobe32(len - mlen);
! 2082: txblock->len = htobe32(mlen);
! 2083:
! 2084: DPRINTF(("sending firmware block: %d bytes remaining\n",
! 2085: len - mlen));
! 2086:
! 2087: /* send firmware block meta-data */
! 2088: usbd_setup_xfer(ctlxfer, sc->cmd_tx_pipe, sc, txblock,
! 2089: sizeof (struct uath_fwblock), USBD_NO_COPY,
! 2090: UATH_CMD_TIMEOUT, NULL);
! 2091: if ((error = usbd_sync_transfer(ctlxfer)) != 0) {
! 2092: printf("%s: could not send firmware block info\n",
! 2093: sc->sc_dev.dv_xname);
! 2094: break;
! 2095: }
! 2096:
! 2097: /* send firmware block data */
! 2098: bcopy(fw, txdata, mlen);
! 2099: usbd_setup_xfer(txxfer, sc->data_tx_pipe, sc, txdata, mlen,
! 2100: USBD_NO_COPY, UATH_DATA_TIMEOUT, NULL);
! 2101: if ((error = usbd_sync_transfer(txxfer)) != 0) {
! 2102: printf("%s: could not send firmware block data\n",
! 2103: sc->sc_dev.dv_xname);
! 2104: break;
! 2105: }
! 2106:
! 2107: /* wait for ack from firmware */
! 2108: usbd_setup_xfer(rxxfer, sc->cmd_rx_pipe, sc, rxblock,
! 2109: sizeof (struct uath_fwblock), USBD_SHORT_XFER_OK |
! 2110: USBD_NO_COPY, UATH_CMD_TIMEOUT, NULL);
! 2111: if ((error = usbd_sync_transfer(rxxfer)) != 0) {
! 2112: printf("%s: could not read firmware answer\n",
! 2113: sc->sc_dev.dv_xname);
! 2114: break;
! 2115: }
! 2116:
! 2117: DPRINTFN(2, ("rxblock flags=0x%x total=%d\n",
! 2118: betoh32(rxblock->flags), betoh32(rxblock->rxtotal)));
! 2119: fw += mlen;
! 2120: len -= mlen;
! 2121: }
! 2122:
! 2123: fail4: usbd_free_xfer(rxxfer);
! 2124: fail3: usbd_free_xfer(txxfer);
! 2125: fail2: usbd_free_xfer(ctlxfer);
! 2126: fail1: return error;
! 2127: }
! 2128:
! 2129: int
! 2130: uath_activate(struct device *self, enum devact act)
! 2131: {
! 2132: switch (act) {
! 2133: case DVACT_ACTIVATE:
! 2134: break;
! 2135:
! 2136: case DVACT_DEACTIVATE:
! 2137: break;
! 2138: }
! 2139: return 0;
! 2140: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_uath.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb