1 /* $OpenBSD: if_otus.c,v 1.46 2015/03/14 03:38:49 jsg Exp $ */ 2 3 /*- 4 * Copyright (c) 2009 Damien Bergamini <damien.bergamini@free.fr> 5 * Copyright (c) 2015 Adrian Chadd <adrian@FreeBSD.org> 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 AR9001U chipset. 22 */ 23 24 #include <sys/cdefs.h> 25 __FBSDID("$FreeBSD$"); 26 27 #include "opt_wlan.h" 28 29 #include <sys/param.h> 30 #include <sys/endian.h> 31 #include <sys/sockio.h> 32 #include <sys/mbuf.h> 33 #include <sys/kernel.h> 34 #include <sys/malloc.h> 35 #include <sys/socket.h> 36 #include <sys/systm.h> 37 #include <sys/conf.h> 38 #include <sys/bus.h> 39 #include <sys/rman.h> 40 #include <sys/firmware.h> 41 #include <sys/module.h> 42 #include <sys/taskqueue.h> 43 44 #include <machine/bus.h> 45 #include <machine/resource.h> 46 47 #include <net/bpf.h> 48 #include <net/if.h> 49 #include <net/if_var.h> 50 #include <net/if_arp.h> 51 #include <net/if_dl.h> 52 #include <net/if_media.h> 53 #include <net/if_types.h> 54 55 #include <netinet/in.h> 56 #include <netinet/in_systm.h> 57 #include <netinet/in_var.h> 58 #include <netinet/if_ether.h> 59 #include <netinet/ip.h> 60 61 #include <net80211/ieee80211_var.h> 62 #include <net80211/ieee80211_regdomain.h> 63 #include <net80211/ieee80211_radiotap.h> 64 #include <net80211/ieee80211_ratectl.h> 65 #ifdef IEEE80211_SUPPORT_SUPERG 66 #include <net80211/ieee80211_superg.h> 67 #endif 68 69 #include <dev/usb/usb.h> 70 #include <dev/usb/usbdi.h> 71 #include "usbdevs.h" 72 73 #define USB_DEBUG_VAR otus_debug 74 #include <dev/usb/usb_debug.h> 75 76 #include "if_otusreg.h" 77 78 static int otus_debug = 0; 79 static SYSCTL_NODE(_hw_usb, OID_AUTO, otus, CTLFLAG_RW, 0, "USB otus"); 80 SYSCTL_INT(_hw_usb_otus, OID_AUTO, debug, CTLFLAG_RWTUN, &otus_debug, 0, 81 "Debug level"); 82 #define OTUS_DEBUG_XMIT 0x00000001 83 #define OTUS_DEBUG_RECV 0x00000002 84 #define OTUS_DEBUG_TXDONE 0x00000004 85 #define OTUS_DEBUG_RXDONE 0x00000008 86 #define OTUS_DEBUG_CMD 0x00000010 87 #define OTUS_DEBUG_CMDDONE 0x00000020 88 #define OTUS_DEBUG_RESET 0x00000040 89 #define OTUS_DEBUG_STATE 0x00000080 90 #define OTUS_DEBUG_CMDNOTIFY 0x00000100 91 #define OTUS_DEBUG_REGIO 0x00000200 92 #define OTUS_DEBUG_IRQ 0x00000400 93 #define OTUS_DEBUG_TXCOMP 0x00000800 94 #define OTUS_DEBUG_ANY 0xffffffff 95 96 #define OTUS_DPRINTF(sc, dm, ...) \ 97 do { \ 98 if ((dm == OTUS_DEBUG_ANY) || (dm & otus_debug)) \ 99 device_printf(sc->sc_dev, __VA_ARGS__); \ 100 } while (0) 101 102 #define OTUS_DEV(v, p) { USB_VPI(v, p, 0) } 103 static const STRUCT_USB_HOST_ID otus_devs[] = { 104 OTUS_DEV(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_WN7512), 105 OTUS_DEV(USB_VENDOR_ATHEROS2, USB_PRODUCT_ATHEROS2_3CRUSBN275), 106 OTUS_DEV(USB_VENDOR_ATHEROS2, USB_PRODUCT_ATHEROS2_TG121N), 107 OTUS_DEV(USB_VENDOR_ATHEROS2, USB_PRODUCT_ATHEROS2_AR9170), 108 OTUS_DEV(USB_VENDOR_ATHEROS2, USB_PRODUCT_ATHEROS2_WN612), 109 OTUS_DEV(USB_VENDOR_ATHEROS2, USB_PRODUCT_ATHEROS2_WN821NV2), 110 OTUS_DEV(USB_VENDOR_AVM, USB_PRODUCT_AVM_FRITZWLAN), 111 OTUS_DEV(USB_VENDOR_CACE, USB_PRODUCT_CACE_AIRPCAPNX), 112 OTUS_DEV(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA130D1), 113 OTUS_DEV(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA160A1), 114 OTUS_DEV(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA160A2), 115 OTUS_DEV(USB_VENDOR_IODATA, USB_PRODUCT_IODATA_WNGDNUS2), 116 OTUS_DEV(USB_VENDOR_NEC, USB_PRODUCT_NEC_WL300NUG), 117 OTUS_DEV(USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_WN111V2), 118 OTUS_DEV(USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_WNA1000), 119 OTUS_DEV(USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_WNDA3100), 120 OTUS_DEV(USB_VENDOR_PLANEX2, USB_PRODUCT_PLANEX2_GW_US300), 121 OTUS_DEV(USB_VENDOR_WISTRONNEWEB, USB_PRODUCT_WISTRONNEWEB_O8494), 122 OTUS_DEV(USB_VENDOR_WISTRONNEWEB, USB_PRODUCT_WISTRONNEWEB_WNC0600), 123 OTUS_DEV(USB_VENDOR_ZCOM, USB_PRODUCT_ZCOM_UB81), 124 OTUS_DEV(USB_VENDOR_ZCOM, USB_PRODUCT_ZCOM_UB82), 125 OTUS_DEV(USB_VENDOR_ZYDAS, USB_PRODUCT_ZYDAS_ZD1221), 126 OTUS_DEV(USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_NWD271N), 127 }; 128 129 static device_probe_t otus_match; 130 static device_attach_t otus_attach; 131 static device_detach_t otus_detach; 132 133 static int otus_attachhook(struct otus_softc *); 134 void otus_get_chanlist(struct otus_softc *); 135 static void otus_getradiocaps(struct ieee80211com *, int, int *, 136 struct ieee80211_channel[]); 137 int otus_load_firmware(struct otus_softc *, const char *, 138 uint32_t); 139 int otus_open_pipes(struct otus_softc *); 140 void otus_close_pipes(struct otus_softc *); 141 142 static int otus_alloc_tx_cmd_list(struct otus_softc *); 143 static void otus_free_tx_cmd_list(struct otus_softc *); 144 145 static int otus_alloc_rx_list(struct otus_softc *); 146 static void otus_free_rx_list(struct otus_softc *); 147 static int otus_alloc_tx_list(struct otus_softc *); 148 static void otus_free_tx_list(struct otus_softc *); 149 static void otus_free_list(struct otus_softc *, struct otus_data [], int); 150 static struct otus_data *_otus_getbuf(struct otus_softc *); 151 static struct otus_data *otus_getbuf(struct otus_softc *); 152 static void otus_freebuf(struct otus_softc *, struct otus_data *); 153 154 static struct otus_tx_cmd *_otus_get_txcmd(struct otus_softc *); 155 static struct otus_tx_cmd *otus_get_txcmd(struct otus_softc *); 156 static void otus_free_txcmd(struct otus_softc *, struct otus_tx_cmd *); 157 158 void otus_next_scan(void *, int); 159 static void otus_tx_task(void *, int pending); 160 void otus_do_async(struct otus_softc *, 161 void (*)(struct otus_softc *, void *), void *, int); 162 int otus_newstate(struct ieee80211vap *, enum ieee80211_state, 163 int); 164 int otus_cmd(struct otus_softc *, uint8_t, const void *, int, 165 void *, int); 166 void otus_write(struct otus_softc *, uint32_t, uint32_t); 167 int otus_write_barrier(struct otus_softc *); 168 static struct ieee80211_node *otus_node_alloc(struct ieee80211vap *vap, 169 const uint8_t mac[IEEE80211_ADDR_LEN]); 170 int otus_media_change(struct ifnet *); 171 int otus_read_eeprom(struct otus_softc *); 172 void otus_newassoc(struct ieee80211_node *, int); 173 void otus_cmd_rxeof(struct otus_softc *, uint8_t *, int); 174 void otus_sub_rxeof(struct otus_softc *, uint8_t *, int, 175 struct mbufq *); 176 static int otus_tx(struct otus_softc *, struct ieee80211_node *, 177 struct mbuf *, struct otus_data *, 178 const struct ieee80211_bpf_params *); 179 int otus_ioctl(struct ifnet *, u_long, caddr_t); 180 int otus_set_multi(struct otus_softc *); 181 static int otus_updateedca(struct ieee80211com *); 182 static void otus_updateedca_locked(struct otus_softc *); 183 static void otus_updateslot(struct otus_softc *); 184 static void otus_set_operating_mode(struct otus_softc *sc); 185 static void otus_set_rx_filter(struct otus_softc *sc); 186 int otus_init_mac(struct otus_softc *); 187 uint32_t otus_phy_get_def(struct otus_softc *, uint32_t); 188 int otus_set_board_values(struct otus_softc *, 189 struct ieee80211_channel *); 190 int otus_program_phy(struct otus_softc *, 191 struct ieee80211_channel *); 192 int otus_set_rf_bank4(struct otus_softc *, 193 struct ieee80211_channel *); 194 void otus_get_delta_slope(uint32_t, uint32_t *, uint32_t *); 195 static int otus_set_chan(struct otus_softc *, struct ieee80211_channel *, 196 int); 197 int otus_set_key(struct ieee80211com *, struct ieee80211_node *, 198 struct ieee80211_key *); 199 void otus_set_key_cb(struct otus_softc *, void *); 200 void otus_delete_key(struct ieee80211com *, struct ieee80211_node *, 201 struct ieee80211_key *); 202 void otus_delete_key_cb(struct otus_softc *, void *); 203 void otus_calibrate_to(void *, int); 204 int otus_set_bssid(struct otus_softc *, const uint8_t *); 205 int otus_set_macaddr(struct otus_softc *, const uint8_t *); 206 void otus_led_newstate_type1(struct otus_softc *); 207 void otus_led_newstate_type2(struct otus_softc *); 208 void otus_led_newstate_type3(struct otus_softc *); 209 int otus_init(struct otus_softc *sc); 210 void otus_stop(struct otus_softc *sc); 211 212 static device_method_t otus_methods[] = { 213 DEVMETHOD(device_probe, otus_match), 214 DEVMETHOD(device_attach, otus_attach), 215 DEVMETHOD(device_detach, otus_detach), 216 217 DEVMETHOD_END 218 }; 219 220 static driver_t otus_driver = { 221 .name = "otus", 222 .methods = otus_methods, 223 .size = sizeof(struct otus_softc) 224 }; 225 226 static devclass_t otus_devclass; 227 228 DRIVER_MODULE(otus, uhub, otus_driver, otus_devclass, NULL, 0); 229 MODULE_DEPEND(otus, wlan, 1, 1, 1); 230 MODULE_DEPEND(otus, usb, 1, 1, 1); 231 MODULE_DEPEND(otus, firmware, 1, 1, 1); 232 MODULE_VERSION(otus, 1); 233 234 static usb_callback_t otus_bulk_tx_callback; 235 static usb_callback_t otus_bulk_rx_callback; 236 static usb_callback_t otus_bulk_irq_callback; 237 static usb_callback_t otus_bulk_cmd_callback; 238 239 static const struct usb_config otus_config[OTUS_N_XFER] = { 240 [OTUS_BULK_TX] = { 241 .type = UE_BULK, 242 .endpoint = UE_ADDR_ANY, 243 .direction = UE_DIR_OUT, 244 .bufsize = 0x200, 245 .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 246 .callback = otus_bulk_tx_callback, 247 .timeout = 5000, /* ms */ 248 }, 249 [OTUS_BULK_RX] = { 250 .type = UE_BULK, 251 .endpoint = UE_ADDR_ANY, 252 .direction = UE_DIR_IN, 253 .bufsize = OTUS_RXBUFSZ, 254 .flags = { .ext_buffer = 1, .pipe_bof = 1,.short_xfer_ok = 1,}, 255 .callback = otus_bulk_rx_callback, 256 }, 257 [OTUS_BULK_IRQ] = { 258 .type = UE_INTERRUPT, 259 .endpoint = UE_ADDR_ANY, 260 .direction = UE_DIR_IN, 261 .bufsize = OTUS_MAX_CTRLSZ, 262 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 263 .callback = otus_bulk_irq_callback, 264 }, 265 [OTUS_BULK_CMD] = { 266 .type = UE_INTERRUPT, 267 .endpoint = UE_ADDR_ANY, 268 .direction = UE_DIR_OUT, 269 .bufsize = OTUS_MAX_CTRLSZ, 270 .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 271 .callback = otus_bulk_cmd_callback, 272 .timeout = 5000, /* ms */ 273 }, 274 }; 275 276 static int 277 otus_match(device_t self) 278 { 279 struct usb_attach_arg *uaa = device_get_ivars(self); 280 281 if (uaa->usb_mode != USB_MODE_HOST || 282 uaa->info.bIfaceIndex != 0 || 283 uaa->info.bConfigIndex != 0) 284 return (ENXIO); 285 286 return (usbd_lookup_id_by_uaa(otus_devs, sizeof(otus_devs), uaa)); 287 } 288 289 static int 290 otus_attach(device_t self) 291 { 292 struct usb_attach_arg *uaa = device_get_ivars(self); 293 struct otus_softc *sc = device_get_softc(self); 294 int error; 295 uint8_t iface_index; 296 297 device_set_usb_desc(self); 298 sc->sc_udev = uaa->device; 299 sc->sc_dev = self; 300 301 mtx_init(&sc->sc_mtx, device_get_nameunit(self), MTX_NETWORK_LOCK, 302 MTX_DEF); 303 304 TIMEOUT_TASK_INIT(taskqueue_thread, &sc->scan_to, 0, otus_next_scan, sc); 305 TIMEOUT_TASK_INIT(taskqueue_thread, &sc->calib_to, 0, otus_calibrate_to, sc); 306 TASK_INIT(&sc->tx_task, 0, otus_tx_task, sc); 307 mbufq_init(&sc->sc_snd, ifqmaxlen); 308 309 iface_index = 0; 310 error = usbd_transfer_setup(uaa->device, &iface_index, sc->sc_xfer, 311 otus_config, OTUS_N_XFER, sc, &sc->sc_mtx); 312 if (error) { 313 device_printf(sc->sc_dev, 314 "could not allocate USB transfers, err=%s\n", 315 usbd_errstr(error)); 316 goto fail_usb; 317 } 318 319 if ((error = otus_open_pipes(sc)) != 0) { 320 device_printf(sc->sc_dev, "%s: could not open pipes\n", 321 __func__); 322 goto fail; 323 } 324 325 /* XXX check return status; fail out if appropriate */ 326 if (otus_attachhook(sc) != 0) 327 goto fail; 328 329 return (0); 330 331 fail: 332 otus_close_pipes(sc); 333 fail_usb: 334 mtx_destroy(&sc->sc_mtx); 335 return (ENXIO); 336 } 337 338 static int 339 otus_detach(device_t self) 340 { 341 struct otus_softc *sc = device_get_softc(self); 342 struct ieee80211com *ic = &sc->sc_ic; 343 344 otus_stop(sc); 345 346 usbd_transfer_unsetup(sc->sc_xfer, OTUS_N_XFER); 347 348 taskqueue_drain_timeout(taskqueue_thread, &sc->scan_to); 349 taskqueue_drain_timeout(taskqueue_thread, &sc->calib_to); 350 taskqueue_drain(taskqueue_thread, &sc->tx_task); 351 352 otus_close_pipes(sc); 353 #if 0 354 /* Wait for all queued asynchronous commands to complete. */ 355 usb_rem_wait_task(sc->sc_udev, &sc->sc_task); 356 357 usbd_ref_wait(sc->sc_udev); 358 #endif 359 360 ieee80211_ifdetach(ic); 361 mtx_destroy(&sc->sc_mtx); 362 return 0; 363 } 364 365 static void 366 otus_delay_ms(struct otus_softc *sc, int ms) 367 { 368 369 DELAY(1000 * ms); 370 } 371 372 static struct ieee80211vap * 373 otus_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit, 374 enum ieee80211_opmode opmode, int flags, 375 const uint8_t bssid[IEEE80211_ADDR_LEN], 376 const uint8_t mac[IEEE80211_ADDR_LEN]) 377 { 378 struct otus_vap *uvp; 379 struct ieee80211vap *vap; 380 381 if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */ 382 return (NULL); 383 384 uvp = malloc(sizeof(struct otus_vap), M_80211_VAP, M_WAITOK | M_ZERO); 385 vap = &uvp->vap; 386 387 if (ieee80211_vap_setup(ic, vap, name, unit, opmode, 388 flags, bssid) != 0) { 389 /* out of memory */ 390 free(uvp, M_80211_VAP); 391 return (NULL); 392 } 393 394 /* override state transition machine */ 395 uvp->newstate = vap->iv_newstate; 396 vap->iv_newstate = otus_newstate; 397 398 /* XXX TODO: double-check */ 399 vap->iv_ampdu_density = IEEE80211_HTCAP_MPDUDENSITY_16; 400 vap->iv_ampdu_rxmax = IEEE80211_HTCAP_MAXRXAMPDU_32K; 401 402 ieee80211_ratectl_init(vap); 403 404 /* complete setup */ 405 ieee80211_vap_attach(vap, ieee80211_media_change, 406 ieee80211_media_status, mac); 407 ic->ic_opmode = opmode; 408 409 return (vap); 410 } 411 412 static void 413 otus_vap_delete(struct ieee80211vap *vap) 414 { 415 struct otus_vap *uvp = OTUS_VAP(vap); 416 417 ieee80211_ratectl_deinit(vap); 418 ieee80211_vap_detach(vap); 419 free(uvp, M_80211_VAP); 420 } 421 422 static void 423 otus_parent(struct ieee80211com *ic) 424 { 425 struct otus_softc *sc = ic->ic_softc; 426 int startall = 0; 427 428 if (ic->ic_nrunning > 0) { 429 if (!sc->sc_running) { 430 otus_init(sc); 431 startall = 1; 432 } else { 433 (void) otus_set_multi(sc); 434 } 435 } else if (sc->sc_running) 436 otus_stop(sc); 437 438 if (startall) 439 ieee80211_start_all(ic); 440 } 441 442 static void 443 otus_drain_mbufq(struct otus_softc *sc) 444 { 445 struct mbuf *m; 446 struct ieee80211_node *ni; 447 448 OTUS_LOCK_ASSERT(sc); 449 while ((m = mbufq_dequeue(&sc->sc_snd)) != NULL) { 450 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif; 451 m->m_pkthdr.rcvif = NULL; 452 ieee80211_free_node(ni); 453 m_freem(m); 454 } 455 } 456 457 static void 458 otus_tx_start(struct otus_softc *sc) 459 { 460 461 taskqueue_enqueue(taskqueue_thread, &sc->tx_task); 462 } 463 464 static int 465 otus_transmit(struct ieee80211com *ic, struct mbuf *m) 466 { 467 struct otus_softc *sc = ic->ic_softc; 468 int error; 469 470 OTUS_LOCK(sc); 471 if (! sc->sc_running) { 472 OTUS_UNLOCK(sc); 473 return (ENXIO); 474 } 475 476 /* XXX TODO: handle fragments */ 477 error = mbufq_enqueue(&sc->sc_snd, m); 478 if (error) { 479 OTUS_DPRINTF(sc, OTUS_DEBUG_XMIT, 480 "%s: mbufq_enqueue failed: %d\n", 481 __func__, 482 error); 483 OTUS_UNLOCK(sc); 484 return (error); 485 } 486 OTUS_UNLOCK(sc); 487 488 /* Kick TX */ 489 otus_tx_start(sc); 490 491 return (0); 492 } 493 494 static void 495 _otus_start(struct otus_softc *sc) 496 { 497 struct ieee80211_node *ni; 498 struct otus_data *bf; 499 struct mbuf *m; 500 501 OTUS_LOCK_ASSERT(sc); 502 503 while ((m = mbufq_dequeue(&sc->sc_snd)) != NULL) { 504 bf = otus_getbuf(sc); 505 if (bf == NULL) { 506 OTUS_DPRINTF(sc, OTUS_DEBUG_XMIT, 507 "%s: failed to get buffer\n", __func__); 508 mbufq_prepend(&sc->sc_snd, m); 509 break; 510 } 511 512 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; 513 m->m_pkthdr.rcvif = NULL; 514 515 if (otus_tx(sc, ni, m, bf, NULL) != 0) { 516 OTUS_DPRINTF(sc, OTUS_DEBUG_XMIT, 517 "%s: failed to transmit\n", __func__); 518 if_inc_counter(ni->ni_vap->iv_ifp, 519 IFCOUNTER_OERRORS, 1); 520 otus_freebuf(sc, bf); 521 ieee80211_free_node(ni); 522 m_freem(m); 523 break; 524 } 525 } 526 } 527 528 static void 529 otus_tx_task(void *arg, int pending) 530 { 531 struct otus_softc *sc = arg; 532 533 OTUS_LOCK(sc); 534 _otus_start(sc); 535 OTUS_UNLOCK(sc); 536 } 537 538 static int 539 otus_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 540 const struct ieee80211_bpf_params *params) 541 { 542 struct ieee80211com *ic= ni->ni_ic; 543 struct otus_softc *sc = ic->ic_softc; 544 struct otus_data *bf = NULL; 545 int error = 0; 546 547 /* Don't transmit if we're not running */ 548 OTUS_LOCK(sc); 549 if (! sc->sc_running) { 550 error = ENETDOWN; 551 goto error; 552 } 553 554 bf = otus_getbuf(sc); 555 if (bf == NULL) { 556 error = ENOBUFS; 557 goto error; 558 } 559 560 if (otus_tx(sc, ni, m, bf, params) != 0) { 561 error = EIO; 562 goto error; 563 } 564 565 OTUS_UNLOCK(sc); 566 return (0); 567 error: 568 if (bf) 569 otus_freebuf(sc, bf); 570 OTUS_UNLOCK(sc); 571 m_freem(m); 572 return (ENXIO); 573 } 574 575 static void 576 otus_update_chw(struct ieee80211com *ic) 577 { 578 579 printf("%s: TODO\n", __func__); 580 } 581 582 static void 583 otus_set_channel(struct ieee80211com *ic) 584 { 585 struct otus_softc *sc = ic->ic_softc; 586 OTUS_DPRINTF(sc, OTUS_DEBUG_RESET, "%s: set channel: %d\n", 587 __func__, 588 ic->ic_curchan->ic_freq); 589 590 OTUS_LOCK(sc); 591 (void) otus_set_chan(sc, ic->ic_curchan, 0); 592 OTUS_UNLOCK(sc); 593 } 594 595 static int 596 otus_ampdu_enable(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap) 597 { 598 599 /* For now, no A-MPDU TX support in the driver */ 600 return (0); 601 } 602 603 static void 604 otus_scan_start(struct ieee80211com *ic) 605 { 606 607 // printf("%s: TODO\n", __func__); 608 } 609 610 static void 611 otus_scan_end(struct ieee80211com *ic) 612 { 613 614 // printf("%s: TODO\n", __func__); 615 } 616 617 static void 618 otus_update_mcast(struct ieee80211com *ic) 619 { 620 struct otus_softc *sc = ic->ic_softc; 621 622 (void) otus_set_multi(sc); 623 } 624 625 static int 626 otus_attachhook(struct otus_softc *sc) 627 { 628 struct ieee80211com *ic = &sc->sc_ic; 629 usb_device_request_t req; 630 uint32_t in, out; 631 int error; 632 633 /* Not locked */ 634 error = otus_load_firmware(sc, "otusfw_init", AR_FW_INIT_ADDR); 635 if (error != 0) { 636 device_printf(sc->sc_dev, "%s: could not load %s firmware\n", 637 __func__, "init"); 638 return (ENXIO); 639 } 640 641 /* XXX not locked? */ 642 otus_delay_ms(sc, 1000); 643 644 /* Not locked */ 645 error = otus_load_firmware(sc, "otusfw_main", AR_FW_MAIN_ADDR); 646 if (error != 0) { 647 device_printf(sc->sc_dev, "%s: could not load %s firmware\n", 648 __func__, "main"); 649 return (ENXIO); 650 } 651 652 OTUS_LOCK(sc); 653 654 /* Tell device that firmware transfer is complete. */ 655 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 656 req.bRequest = AR_FW_DOWNLOAD_COMPLETE; 657 USETW(req.wValue, 0); 658 USETW(req.wIndex, 0); 659 USETW(req.wLength, 0); 660 if (usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx, &req, NULL, 661 0, NULL, 250) != 0) { 662 OTUS_UNLOCK(sc); 663 device_printf(sc->sc_dev, 664 "%s: firmware initialization failed\n", 665 __func__); 666 return (ENXIO); 667 } 668 669 /* Send an ECHO command to check that everything is settled. */ 670 in = 0xbadc0ffe; 671 if (otus_cmd(sc, AR_CMD_ECHO, &in, sizeof in, &out, sizeof(out)) != 0) { 672 OTUS_UNLOCK(sc); 673 device_printf(sc->sc_dev, 674 "%s: echo command failed\n", __func__); 675 return (ENXIO); 676 } 677 if (in != out) { 678 OTUS_UNLOCK(sc); 679 device_printf(sc->sc_dev, 680 "%s: echo reply mismatch: 0x%08x!=0x%08x\n", 681 __func__, in, out); 682 return (ENXIO); 683 } 684 685 /* Read entire EEPROM. */ 686 if (otus_read_eeprom(sc) != 0) { 687 OTUS_UNLOCK(sc); 688 device_printf(sc->sc_dev, 689 "%s: could not read EEPROM\n", 690 __func__); 691 return (ENXIO); 692 } 693 694 OTUS_UNLOCK(sc); 695 696 sc->txmask = sc->eeprom.baseEepHeader.txMask; 697 sc->rxmask = sc->eeprom.baseEepHeader.rxMask; 698 sc->capflags = sc->eeprom.baseEepHeader.opCapFlags; 699 IEEE80211_ADDR_COPY(ic->ic_macaddr, sc->eeprom.baseEepHeader.macAddr); 700 sc->sc_led_newstate = otus_led_newstate_type3; /* XXX */ 701 702 device_printf(sc->sc_dev, 703 "MAC/BBP AR9170, RF AR%X, MIMO %dT%dR, address %s\n", 704 (sc->capflags & AR5416_OPFLAGS_11A) ? 705 0x9104 : ((sc->txmask == 0x5) ? 0x9102 : 0x9101), 706 (sc->txmask == 0x5) ? 2 : 1, (sc->rxmask == 0x5) ? 2 : 1, 707 ether_sprintf(ic->ic_macaddr)); 708 709 ic->ic_softc = sc; 710 ic->ic_name = device_get_nameunit(sc->sc_dev); 711 ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */ 712 ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */ 713 714 /* Set device capabilities. */ 715 ic->ic_caps = 716 IEEE80211_C_STA | /* station mode */ 717 #if 0 718 IEEE80211_C_BGSCAN | /* Background scan. */ 719 #endif 720 IEEE80211_C_SHPREAMBLE | /* Short preamble supported. */ 721 IEEE80211_C_WME | /* WME/QoS */ 722 IEEE80211_C_SHSLOT | /* Short slot time supported. */ 723 IEEE80211_C_FF | /* Atheros fast-frames supported. */ 724 IEEE80211_C_MONITOR | 725 IEEE80211_C_WPA; /* WPA/RSN. */ 726 727 /* XXX TODO: 11n */ 728 729 #if 0 730 if (sc->eeprom.baseEepHeader.opCapFlags & AR5416_OPFLAGS_11G) { 731 /* Set supported .11b and .11g rates. */ 732 ic->ic_sup_rates[IEEE80211_MODE_11B] = 733 ieee80211_std_rateset_11b; 734 ic->ic_sup_rates[IEEE80211_MODE_11G] = 735 ieee80211_std_rateset_11g; 736 } 737 if (sc->eeprom.baseEepHeader.opCapFlags & AR5416_OPFLAGS_11A) { 738 /* Set supported .11a rates. */ 739 ic->ic_sup_rates[IEEE80211_MODE_11A] = 740 ieee80211_std_rateset_11a; 741 } 742 #endif 743 744 #if 0 745 /* Build the list of supported channels. */ 746 otus_get_chanlist(sc); 747 #else 748 otus_getradiocaps(ic, IEEE80211_CHAN_MAX, &ic->ic_nchans, 749 ic->ic_channels); 750 #endif 751 752 ieee80211_ifattach(ic); 753 ic->ic_raw_xmit = otus_raw_xmit; 754 ic->ic_scan_start = otus_scan_start; 755 ic->ic_scan_end = otus_scan_end; 756 ic->ic_set_channel = otus_set_channel; 757 ic->ic_getradiocaps = otus_getradiocaps; 758 ic->ic_vap_create = otus_vap_create; 759 ic->ic_vap_delete = otus_vap_delete; 760 ic->ic_update_mcast = otus_update_mcast; 761 ic->ic_update_promisc = otus_update_mcast; 762 ic->ic_parent = otus_parent; 763 ic->ic_transmit = otus_transmit; 764 ic->ic_update_chw = otus_update_chw; 765 ic->ic_ampdu_enable = otus_ampdu_enable; 766 ic->ic_wme.wme_update = otus_updateedca; 767 ic->ic_newassoc = otus_newassoc; 768 ic->ic_node_alloc = otus_node_alloc; 769 770 #ifdef notyet 771 ic->ic_set_key = otus_set_key; 772 ic->ic_delete_key = otus_delete_key; 773 #endif 774 775 ieee80211_radiotap_attach(ic, &sc->sc_txtap.wt_ihdr, 776 sizeof(sc->sc_txtap), OTUS_TX_RADIOTAP_PRESENT, 777 &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap), 778 OTUS_RX_RADIOTAP_PRESENT); 779 780 return (0); 781 } 782 783 void 784 otus_get_chanlist(struct otus_softc *sc) 785 { 786 struct ieee80211com *ic = &sc->sc_ic; 787 uint16_t domain; 788 uint8_t chan; 789 int i; 790 791 /* XXX regulatory domain. */ 792 domain = le16toh(sc->eeprom.baseEepHeader.regDmn[0]); 793 OTUS_DPRINTF(sc, OTUS_DEBUG_RESET, "regdomain=0x%04x\n", domain); 794 795 if (sc->eeprom.baseEepHeader.opCapFlags & AR5416_OPFLAGS_11G) { 796 for (i = 0; i < 14; i++) { 797 chan = ar_chans[i]; 798 ic->ic_channels[chan].ic_freq = 799 ieee80211_ieee2mhz(chan, IEEE80211_CHAN_2GHZ); 800 ic->ic_channels[chan].ic_flags = 801 IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM | 802 IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ; 803 } 804 } 805 if (sc->eeprom.baseEepHeader.opCapFlags & AR5416_OPFLAGS_11A) { 806 for (i = 14; i < nitems(ar_chans); i++) { 807 chan = ar_chans[i]; 808 ic->ic_channels[chan].ic_freq = 809 ieee80211_ieee2mhz(chan, IEEE80211_CHAN_5GHZ); 810 ic->ic_channels[chan].ic_flags = IEEE80211_CHAN_A; 811 } 812 } 813 } 814 815 static void 816 otus_getradiocaps(struct ieee80211com *ic, 817 int maxchans, int *nchans, struct ieee80211_channel chans[]) 818 { 819 struct otus_softc *sc = ic->ic_softc; 820 uint8_t bands[IEEE80211_MODE_BYTES]; 821 822 /* Set supported .11b and .11g rates. */ 823 memset(bands, 0, sizeof(bands)); 824 if (sc->eeprom.baseEepHeader.opCapFlags & AR5416_OPFLAGS_11G) { 825 setbit(bands, IEEE80211_MODE_11B); 826 setbit(bands, IEEE80211_MODE_11G); 827 #if 0 828 if (sc->sc_ht) 829 setbit(bands, IEEE80211_MODE_11NG); 830 #endif 831 ieee80211_add_channel_list_2ghz(chans, maxchans, nchans, 832 ar_chans, 14, bands, 0); 833 } 834 if (sc->eeprom.baseEepHeader.opCapFlags & AR5416_OPFLAGS_11A) { 835 setbit(bands, IEEE80211_MODE_11A); 836 ieee80211_add_channel_list_5ghz(chans, maxchans, nchans, 837 &ar_chans[14], nitems(ar_chans) - 14, bands, 0); 838 } 839 } 840 841 int 842 otus_load_firmware(struct otus_softc *sc, const char *name, uint32_t addr) 843 { 844 usb_device_request_t req; 845 char *ptr; 846 const struct firmware *fw; 847 int mlen, error, size; 848 849 error = 0; 850 851 /* Read firmware image from the filesystem. */ 852 if ((fw = firmware_get(name)) == NULL) { 853 device_printf(sc->sc_dev, 854 "%s: failed loadfirmware of file %s\n", __func__, name); 855 return (ENXIO); 856 } 857 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 858 req.bRequest = AR_FW_DOWNLOAD; 859 USETW(req.wIndex, 0); 860 861 OTUS_LOCK(sc); 862 863 /* XXX const */ 864 ptr = __DECONST(char *, fw->data); 865 size = fw->datasize; 866 addr >>= 8; 867 while (size > 0) { 868 mlen = MIN(size, 4096); 869 870 USETW(req.wValue, addr); 871 USETW(req.wLength, mlen); 872 if (usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx, 873 &req, ptr, 0, NULL, 250) != 0) { 874 error = EIO; 875 break; 876 } 877 addr += mlen >> 8; 878 ptr += mlen; 879 size -= mlen; 880 } 881 882 OTUS_UNLOCK(sc); 883 884 firmware_put(fw, FIRMWARE_UNLOAD); 885 if (error != 0) 886 device_printf(sc->sc_dev, 887 "%s: %s: error=%d\n", __func__, name, error); 888 return error; 889 } 890 891 int 892 otus_open_pipes(struct otus_softc *sc) 893 { 894 #if 0 895 int isize, error; 896 int i; 897 #endif 898 int error; 899 900 OTUS_UNLOCK_ASSERT(sc); 901 902 if ((error = otus_alloc_tx_cmd_list(sc)) != 0) { 903 device_printf(sc->sc_dev, 904 "%s: could not allocate command xfer\n", 905 __func__); 906 goto fail; 907 } 908 909 if ((error = otus_alloc_tx_list(sc)) != 0) { 910 device_printf(sc->sc_dev, "%s: could not allocate Tx xfers\n", 911 __func__); 912 goto fail; 913 } 914 915 if ((error = otus_alloc_rx_list(sc)) != 0) { 916 device_printf(sc->sc_dev, "%s: could not allocate Rx xfers\n", 917 __func__); 918 goto fail; 919 } 920 921 /* Enable RX transfers; needed for initial firmware messages */ 922 OTUS_LOCK(sc); 923 usbd_transfer_start(sc->sc_xfer[OTUS_BULK_RX]); 924 usbd_transfer_start(sc->sc_xfer[OTUS_BULK_IRQ]); 925 OTUS_UNLOCK(sc); 926 return 0; 927 928 fail: otus_close_pipes(sc); 929 return error; 930 } 931 932 void 933 otus_close_pipes(struct otus_softc *sc) 934 { 935 936 OTUS_LOCK(sc); 937 otus_free_tx_cmd_list(sc); 938 otus_free_tx_list(sc); 939 otus_free_rx_list(sc); 940 OTUS_UNLOCK(sc); 941 942 usbd_transfer_unsetup(sc->sc_xfer, OTUS_N_XFER); 943 } 944 945 static void 946 otus_free_cmd_list(struct otus_softc *sc, struct otus_tx_cmd cmd[], int ndata) 947 { 948 int i; 949 950 /* XXX TODO: someone has to have waken up waiters! */ 951 for (i = 0; i < ndata; i++) { 952 struct otus_tx_cmd *dp = &cmd[i]; 953 954 if (dp->buf != NULL) { 955 free(dp->buf, M_USBDEV); 956 dp->buf = NULL; 957 } 958 } 959 } 960 961 static int 962 otus_alloc_cmd_list(struct otus_softc *sc, struct otus_tx_cmd cmd[], 963 int ndata, int maxsz) 964 { 965 int i, error; 966 967 for (i = 0; i < ndata; i++) { 968 struct otus_tx_cmd *dp = &cmd[i]; 969 dp->buf = malloc(maxsz, M_USBDEV, M_NOWAIT | M_ZERO); 970 dp->odata = NULL; 971 if (dp->buf == NULL) { 972 device_printf(sc->sc_dev, 973 "could not allocate buffer\n"); 974 error = ENOMEM; 975 goto fail; 976 } 977 } 978 979 return (0); 980 fail: 981 otus_free_cmd_list(sc, cmd, ndata); 982 return (error); 983 } 984 985 static int 986 otus_alloc_tx_cmd_list(struct otus_softc *sc) 987 { 988 int error, i; 989 990 error = otus_alloc_cmd_list(sc, sc->sc_cmd, OTUS_CMD_LIST_COUNT, 991 OTUS_MAX_TXCMDSZ); 992 if (error != 0) 993 return (error); 994 995 STAILQ_INIT(&sc->sc_cmd_active); 996 STAILQ_INIT(&sc->sc_cmd_inactive); 997 STAILQ_INIT(&sc->sc_cmd_pending); 998 STAILQ_INIT(&sc->sc_cmd_waiting); 999 1000 for (i = 0; i < OTUS_CMD_LIST_COUNT; i++) 1001 STAILQ_INSERT_HEAD(&sc->sc_cmd_inactive, &sc->sc_cmd[i], 1002 next_cmd); 1003 1004 return (0); 1005 } 1006 1007 static void 1008 otus_free_tx_cmd_list(struct otus_softc *sc) 1009 { 1010 1011 /* 1012 * XXX TODO: something needs to wake up any pending/sleeping 1013 * waiters! 1014 */ 1015 STAILQ_INIT(&sc->sc_cmd_active); 1016 STAILQ_INIT(&sc->sc_cmd_inactive); 1017 STAILQ_INIT(&sc->sc_cmd_pending); 1018 STAILQ_INIT(&sc->sc_cmd_waiting); 1019 1020 otus_free_cmd_list(sc, sc->sc_cmd, OTUS_CMD_LIST_COUNT); 1021 } 1022 1023 static int 1024 otus_alloc_list(struct otus_softc *sc, struct otus_data data[], 1025 int ndata, int maxsz) 1026 { 1027 int i, error; 1028 1029 for (i = 0; i < ndata; i++) { 1030 struct otus_data *dp = &data[i]; 1031 dp->sc = sc; 1032 dp->m = NULL; 1033 dp->buf = malloc(maxsz, M_USBDEV, M_NOWAIT | M_ZERO); 1034 if (dp->buf == NULL) { 1035 device_printf(sc->sc_dev, 1036 "could not allocate buffer\n"); 1037 error = ENOMEM; 1038 goto fail; 1039 } 1040 dp->ni = NULL; 1041 } 1042 1043 return (0); 1044 fail: 1045 otus_free_list(sc, data, ndata); 1046 return (error); 1047 } 1048 1049 static int 1050 otus_alloc_rx_list(struct otus_softc *sc) 1051 { 1052 int error, i; 1053 1054 error = otus_alloc_list(sc, sc->sc_rx, OTUS_RX_LIST_COUNT, 1055 OTUS_RXBUFSZ); 1056 if (error != 0) 1057 return (error); 1058 1059 STAILQ_INIT(&sc->sc_rx_active); 1060 STAILQ_INIT(&sc->sc_rx_inactive); 1061 1062 for (i = 0; i < OTUS_RX_LIST_COUNT; i++) 1063 STAILQ_INSERT_HEAD(&sc->sc_rx_inactive, &sc->sc_rx[i], next); 1064 1065 return (0); 1066 } 1067 1068 static int 1069 otus_alloc_tx_list(struct otus_softc *sc) 1070 { 1071 int error, i; 1072 1073 error = otus_alloc_list(sc, sc->sc_tx, OTUS_TX_LIST_COUNT, 1074 OTUS_TXBUFSZ); 1075 if (error != 0) 1076 return (error); 1077 1078 STAILQ_INIT(&sc->sc_tx_inactive); 1079 1080 for (i = 0; i != OTUS_N_XFER; i++) { 1081 STAILQ_INIT(&sc->sc_tx_active[i]); 1082 STAILQ_INIT(&sc->sc_tx_pending[i]); 1083 } 1084 1085 for (i = 0; i < OTUS_TX_LIST_COUNT; i++) { 1086 STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, &sc->sc_tx[i], next); 1087 } 1088 1089 return (0); 1090 } 1091 1092 static void 1093 otus_free_tx_list(struct otus_softc *sc) 1094 { 1095 int i; 1096 1097 /* prevent further allocations from TX list(s) */ 1098 STAILQ_INIT(&sc->sc_tx_inactive); 1099 1100 for (i = 0; i != OTUS_N_XFER; i++) { 1101 STAILQ_INIT(&sc->sc_tx_active[i]); 1102 STAILQ_INIT(&sc->sc_tx_pending[i]); 1103 } 1104 1105 otus_free_list(sc, sc->sc_tx, OTUS_TX_LIST_COUNT); 1106 } 1107 1108 static void 1109 otus_free_rx_list(struct otus_softc *sc) 1110 { 1111 /* prevent further allocations from RX list(s) */ 1112 STAILQ_INIT(&sc->sc_rx_inactive); 1113 STAILQ_INIT(&sc->sc_rx_active); 1114 1115 otus_free_list(sc, sc->sc_rx, OTUS_RX_LIST_COUNT); 1116 } 1117 1118 static void 1119 otus_free_list(struct otus_softc *sc, struct otus_data data[], int ndata) 1120 { 1121 int i; 1122 1123 for (i = 0; i < ndata; i++) { 1124 struct otus_data *dp = &data[i]; 1125 1126 if (dp->buf != NULL) { 1127 free(dp->buf, M_USBDEV); 1128 dp->buf = NULL; 1129 } 1130 if (dp->ni != NULL) { 1131 ieee80211_free_node(dp->ni); 1132 dp->ni = NULL; 1133 } 1134 } 1135 } 1136 1137 static struct otus_data * 1138 _otus_getbuf(struct otus_softc *sc) 1139 { 1140 struct otus_data *bf; 1141 1142 bf = STAILQ_FIRST(&sc->sc_tx_inactive); 1143 if (bf != NULL) 1144 STAILQ_REMOVE_HEAD(&sc->sc_tx_inactive, next); 1145 else 1146 bf = NULL; 1147 /* XXX bzero? */ 1148 return (bf); 1149 } 1150 1151 static struct otus_data * 1152 otus_getbuf(struct otus_softc *sc) 1153 { 1154 struct otus_data *bf; 1155 1156 OTUS_LOCK_ASSERT(sc); 1157 1158 bf = _otus_getbuf(sc); 1159 return (bf); 1160 } 1161 1162 static void 1163 otus_freebuf(struct otus_softc *sc, struct otus_data *bf) 1164 { 1165 1166 OTUS_LOCK_ASSERT(sc); 1167 STAILQ_INSERT_TAIL(&sc->sc_tx_inactive, bf, next); 1168 } 1169 1170 static struct otus_tx_cmd * 1171 _otus_get_txcmd(struct otus_softc *sc) 1172 { 1173 struct otus_tx_cmd *bf; 1174 1175 bf = STAILQ_FIRST(&sc->sc_cmd_inactive); 1176 if (bf != NULL) 1177 STAILQ_REMOVE_HEAD(&sc->sc_cmd_inactive, next_cmd); 1178 else 1179 bf = NULL; 1180 return (bf); 1181 } 1182 1183 static struct otus_tx_cmd * 1184 otus_get_txcmd(struct otus_softc *sc) 1185 { 1186 struct otus_tx_cmd *bf; 1187 1188 OTUS_LOCK_ASSERT(sc); 1189 1190 bf = _otus_get_txcmd(sc); 1191 if (bf == NULL) { 1192 device_printf(sc->sc_dev, "%s: no tx cmd buffers\n", 1193 __func__); 1194 } 1195 return (bf); 1196 } 1197 1198 static void 1199 otus_free_txcmd(struct otus_softc *sc, struct otus_tx_cmd *bf) 1200 { 1201 1202 OTUS_LOCK_ASSERT(sc); 1203 STAILQ_INSERT_TAIL(&sc->sc_cmd_inactive, bf, next_cmd); 1204 } 1205 1206 void 1207 otus_next_scan(void *arg, int pending) 1208 { 1209 #if 0 1210 struct otus_softc *sc = arg; 1211 1212 if (usbd_is_dying(sc->sc_udev)) 1213 return; 1214 1215 usbd_ref_incr(sc->sc_udev); 1216 1217 if (sc->sc_ic.ic_state == IEEE80211_S_SCAN) 1218 ieee80211_next_scan(&sc->sc_ic.ic_if); 1219 1220 usbd_ref_decr(sc->sc_udev); 1221 #endif 1222 } 1223 1224 int 1225 otus_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 1226 { 1227 struct otus_vap *uvp = OTUS_VAP(vap); 1228 struct ieee80211com *ic = vap->iv_ic; 1229 struct otus_softc *sc = ic->ic_softc; 1230 enum ieee80211_state ostate; 1231 1232 ostate = vap->iv_state; 1233 OTUS_DPRINTF(sc, OTUS_DEBUG_STATE, "%s: %s -> %s\n", __func__, 1234 ieee80211_state_name[ostate], 1235 ieee80211_state_name[nstate]); 1236 1237 IEEE80211_UNLOCK(ic); 1238 1239 OTUS_LOCK(sc); 1240 1241 /* XXX TODO: more fleshing out! */ 1242 1243 switch (nstate) { 1244 case IEEE80211_S_INIT: 1245 otus_set_operating_mode(sc); 1246 otus_set_rx_filter(sc); 1247 break; 1248 case IEEE80211_S_RUN: 1249 if (ic->ic_opmode == IEEE80211_M_STA) { 1250 otus_updateslot(sc); 1251 otus_set_operating_mode(sc); 1252 otus_set_rx_filter(sc); 1253 1254 /* Start calibration timer. */ 1255 taskqueue_enqueue_timeout(taskqueue_thread, 1256 &sc->calib_to, hz); 1257 } 1258 break; 1259 default: 1260 break; 1261 } 1262 1263 /* XXX TODO: calibration? */ 1264 1265 sc->sc_led_newstate(sc); 1266 1267 OTUS_UNLOCK(sc); 1268 IEEE80211_LOCK(ic); 1269 return (uvp->newstate(vap, nstate, arg)); 1270 } 1271 1272 int 1273 otus_cmd(struct otus_softc *sc, uint8_t code, const void *idata, int ilen, 1274 void *odata, int odatalen) 1275 { 1276 struct otus_tx_cmd *cmd; 1277 struct ar_cmd_hdr *hdr; 1278 int xferlen, error; 1279 1280 OTUS_LOCK_ASSERT(sc); 1281 1282 /* Always bulk-out a multiple of 4 bytes. */ 1283 xferlen = (sizeof (*hdr) + ilen + 3) & ~3; 1284 if (xferlen > OTUS_MAX_TXCMDSZ) { 1285 device_printf(sc->sc_dev, "%s: command (0x%02x) size (%d) > %d\n", 1286 __func__, 1287 code, 1288 xferlen, 1289 OTUS_MAX_TXCMDSZ); 1290 return (EIO); 1291 } 1292 1293 cmd = otus_get_txcmd(sc); 1294 if (cmd == NULL) { 1295 device_printf(sc->sc_dev, "%s: failed to get buf\n", 1296 __func__); 1297 return (EIO); 1298 } 1299 1300 hdr = (struct ar_cmd_hdr *)cmd->buf; 1301 hdr->code = code; 1302 hdr->len = ilen; 1303 hdr->token = ++sc->token; /* Don't care about endianness. */ 1304 cmd->token = hdr->token; 1305 /* XXX TODO: check max cmd length? */ 1306 memcpy((uint8_t *)&hdr[1], idata, ilen); 1307 1308 OTUS_DPRINTF(sc, OTUS_DEBUG_CMD, 1309 "%s: sending command code=0x%02x len=%d token=%d\n", 1310 __func__, code, ilen, hdr->token); 1311 1312 cmd->odata = odata; 1313 cmd->odatalen = odatalen; 1314 cmd->buflen = xferlen; 1315 1316 /* Queue the command to the endpoint */ 1317 STAILQ_INSERT_TAIL(&sc->sc_cmd_pending, cmd, next_cmd); 1318 usbd_transfer_start(sc->sc_xfer[OTUS_BULK_CMD]); 1319 1320 /* Sleep on the command; wait for it to complete */ 1321 error = msleep(cmd, &sc->sc_mtx, PCATCH, "otuscmd", hz); 1322 1323 /* 1324 * At this point we don't own cmd any longer; it'll be 1325 * freed by the cmd bulk path or the RX notification 1326 * path. If the data is made available then it'll be copied 1327 * to the caller. All that is left to do is communicate 1328 * status back to the caller. 1329 */ 1330 if (error != 0) { 1331 device_printf(sc->sc_dev, 1332 "%s: timeout waiting for command 0x%02x reply\n", 1333 __func__, code); 1334 } 1335 return error; 1336 } 1337 1338 void 1339 otus_write(struct otus_softc *sc, uint32_t reg, uint32_t val) 1340 { 1341 1342 OTUS_LOCK_ASSERT(sc); 1343 1344 sc->write_buf[sc->write_idx].reg = htole32(reg); 1345 sc->write_buf[sc->write_idx].val = htole32(val); 1346 1347 if (++sc->write_idx > (AR_MAX_WRITE_IDX-1)) 1348 (void)otus_write_barrier(sc); 1349 } 1350 1351 int 1352 otus_write_barrier(struct otus_softc *sc) 1353 { 1354 int error; 1355 1356 OTUS_LOCK_ASSERT(sc); 1357 1358 if (sc->write_idx == 0) 1359 return 0; /* Nothing to flush. */ 1360 1361 OTUS_DPRINTF(sc, OTUS_DEBUG_REGIO, "%s: called; %d updates\n", 1362 __func__, 1363 sc->write_idx); 1364 1365 error = otus_cmd(sc, AR_CMD_WREG, sc->write_buf, 1366 sizeof (sc->write_buf[0]) * sc->write_idx, NULL, 0); 1367 sc->write_idx = 0; 1368 return error; 1369 } 1370 1371 static struct ieee80211_node * 1372 otus_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN]) 1373 { 1374 1375 return malloc(sizeof (struct otus_node), M_80211_NODE, 1376 M_NOWAIT | M_ZERO); 1377 } 1378 1379 #if 0 1380 int 1381 otus_media_change(struct ifnet *ifp) 1382 { 1383 struct otus_softc *sc = ifp->if_softc; 1384 struct ieee80211com *ic = &sc->sc_ic; 1385 uint8_t rate, ridx; 1386 int error; 1387 1388 error = ieee80211_media_change(ifp); 1389 if (error != ENETRESET) 1390 return error; 1391 1392 if (ic->ic_fixed_rate != -1) { 1393 rate = ic->ic_sup_rates[ic->ic_curmode]. 1394 rs_rates[ic->ic_fixed_rate] & IEEE80211_RATE_VAL; 1395 for (ridx = 0; ridx <= OTUS_RIDX_MAX; ridx++) 1396 if (otus_rates[ridx].rate == rate) 1397 break; 1398 sc->fixed_ridx = ridx; 1399 } 1400 1401 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING)) 1402 error = otus_init(sc); 1403 1404 return error; 1405 } 1406 #endif 1407 1408 int 1409 otus_read_eeprom(struct otus_softc *sc) 1410 { 1411 uint32_t regs[8], reg; 1412 uint8_t *eep; 1413 int i, j, error; 1414 1415 OTUS_LOCK_ASSERT(sc); 1416 1417 /* Read EEPROM by blocks of 32 bytes. */ 1418 eep = (uint8_t *)&sc->eeprom; 1419 reg = AR_EEPROM_OFFSET; 1420 for (i = 0; i < sizeof (sc->eeprom) / 32; i++) { 1421 for (j = 0; j < 8; j++, reg += 4) 1422 regs[j] = htole32(reg); 1423 error = otus_cmd(sc, AR_CMD_RREG, regs, sizeof regs, eep, 32); 1424 if (error != 0) 1425 break; 1426 eep += 32; 1427 } 1428 return error; 1429 } 1430 1431 void 1432 otus_newassoc(struct ieee80211_node *ni, int isnew) 1433 { 1434 struct ieee80211com *ic = ni->ni_ic; 1435 struct otus_softc *sc = ic->ic_softc; 1436 struct otus_node *on = OTUS_NODE(ni); 1437 1438 OTUS_DPRINTF(sc, OTUS_DEBUG_STATE, "new assoc isnew=%d addr=%s\n", 1439 isnew, ether_sprintf(ni->ni_macaddr)); 1440 1441 on->tx_done = 0; 1442 on->tx_err = 0; 1443 on->tx_retries = 0; 1444 } 1445 1446 static void 1447 otus_cmd_handle_response(struct otus_softc *sc, struct ar_cmd_hdr *hdr) 1448 { 1449 struct otus_tx_cmd *cmd; 1450 1451 OTUS_LOCK_ASSERT(sc); 1452 1453 OTUS_DPRINTF(sc, OTUS_DEBUG_CMDDONE, 1454 "%s: received reply code=0x%02x len=%d token=%d\n", 1455 __func__, 1456 hdr->code, hdr->len, hdr->token); 1457 1458 /* 1459 * Walk the list, freeing items that aren't ours, 1460 * stopping when we hit our token. 1461 */ 1462 while ((cmd = STAILQ_FIRST(&sc->sc_cmd_waiting)) != NULL) { 1463 STAILQ_REMOVE_HEAD(&sc->sc_cmd_waiting, next_cmd); 1464 OTUS_DPRINTF(sc, OTUS_DEBUG_CMDDONE, 1465 "%s: cmd=%p; hdr.token=%d, cmd.token=%d\n", 1466 __func__, 1467 cmd, 1468 (int) hdr->token, 1469 (int) cmd->token); 1470 if (hdr->token == cmd->token) { 1471 /* Copy answer into caller's supplied buffer. */ 1472 if (cmd->odata != NULL) { 1473 if (hdr->len != cmd->odatalen) { 1474 device_printf(sc->sc_dev, 1475 "%s: code 0x%02x, len=%d, olen=%d\n", 1476 __func__, 1477 (int) hdr->code, 1478 (int) hdr->len, 1479 (int) cmd->odatalen); 1480 } 1481 memcpy(cmd->odata, &hdr[1], 1482 MIN(cmd->odatalen, hdr->len)); 1483 } 1484 wakeup(cmd); 1485 } 1486 1487 STAILQ_INSERT_TAIL(&sc->sc_cmd_inactive, cmd, next_cmd); 1488 } 1489 } 1490 1491 void 1492 otus_cmd_rxeof(struct otus_softc *sc, uint8_t *buf, int len) 1493 { 1494 struct ieee80211com *ic = &sc->sc_ic; 1495 struct ar_cmd_hdr *hdr; 1496 1497 OTUS_LOCK_ASSERT(sc); 1498 1499 if (__predict_false(len < sizeof (*hdr))) { 1500 OTUS_DPRINTF(sc, OTUS_DEBUG_CMDDONE, 1501 "cmd too small %d\n", len); 1502 return; 1503 } 1504 hdr = (struct ar_cmd_hdr *)buf; 1505 if (__predict_false(sizeof (*hdr) + hdr->len > len || 1506 sizeof (*hdr) + hdr->len > 64)) { 1507 OTUS_DPRINTF(sc, OTUS_DEBUG_CMDDONE, 1508 "cmd too large %d\n", hdr->len); 1509 return; 1510 } 1511 1512 OTUS_DPRINTF(sc, OTUS_DEBUG_RXDONE, 1513 "%s: code=%.02x\n", 1514 __func__, 1515 hdr->code); 1516 1517 /* 1518 * This has to reach into the cmd queue "waiting for 1519 * an RX response" list, grab the head entry and check 1520 * if we need to wake anyone up. 1521 */ 1522 if ((hdr->code & 0xc0) != 0xc0) { 1523 otus_cmd_handle_response(sc, hdr); 1524 return; 1525 } 1526 1527 /* Received unsolicited notification. */ 1528 switch (hdr->code & 0x3f) { 1529 case AR_EVT_BEACON: 1530 break; 1531 case AR_EVT_TX_COMP: 1532 { 1533 struct ar_evt_tx_comp *tx = (struct ar_evt_tx_comp *)&hdr[1]; 1534 struct ieee80211_node *ni; 1535 1536 ni = ieee80211_find_node(&ic->ic_sta, tx->macaddr); 1537 if (ni == NULL) { 1538 device_printf(sc->sc_dev, 1539 "%s: txcomp on unknown node (%s)\n", 1540 __func__, 1541 ether_sprintf(tx->macaddr)); 1542 break; 1543 } 1544 1545 OTUS_DPRINTF(sc, OTUS_DEBUG_TXCOMP, 1546 "tx completed %s status=%d phy=0x%x\n", 1547 ether_sprintf(tx->macaddr), le16toh(tx->status), 1548 le32toh(tx->phy)); 1549 1550 switch (le16toh(tx->status)) { 1551 case AR_TX_STATUS_COMP: 1552 #if 0 1553 ackfailcnt = 0; 1554 ieee80211_ratectl_tx_complete(ni->ni_vap, ni, 1555 IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL); 1556 #endif 1557 /* 1558 * We don't get the above; only error notifications. 1559 * Sigh. So, don't worry about this. 1560 */ 1561 break; 1562 case AR_TX_STATUS_RETRY_COMP: 1563 OTUS_NODE(ni)->tx_retries++; 1564 break; 1565 case AR_TX_STATUS_FAILED: 1566 OTUS_NODE(ni)->tx_err++; 1567 break; 1568 } 1569 ieee80211_free_node(ni); 1570 break; 1571 } 1572 case AR_EVT_TBTT: 1573 break; 1574 case AR_EVT_DO_BB_RESET: 1575 /* 1576 * This is "tell driver to reset baseband" from ar9170-fw. 1577 * 1578 * I'm not sure what we should do here, so I'm going to 1579 * fall through; it gets generated when RTSRetryCnt internally 1580 * reaches '5' - I guess the firmware authors thought that 1581 * meant that the BB may have gone deaf or something. 1582 */ 1583 default: 1584 device_printf(sc->sc_dev, 1585 "%s: received notification code=0x%02x len=%d\n", 1586 __func__, 1587 hdr->code, hdr->len); 1588 } 1589 } 1590 1591 void 1592 otus_sub_rxeof(struct otus_softc *sc, uint8_t *buf, int len, struct mbufq *rxq) 1593 { 1594 struct ieee80211com *ic = &sc->sc_ic; 1595 struct ieee80211_rx_stats rxs; 1596 #if 0 1597 struct ieee80211_node *ni; 1598 #endif 1599 struct ar_rx_tail *tail; 1600 struct ieee80211_frame *wh; 1601 struct mbuf *m; 1602 uint8_t *plcp; 1603 // int s; 1604 int mlen; 1605 1606 if (__predict_false(len < AR_PLCP_HDR_LEN)) { 1607 OTUS_DPRINTF(sc, OTUS_DEBUG_RXDONE, 1608 "sub-xfer too short %d\n", len); 1609 return; 1610 } 1611 plcp = buf; 1612 1613 /* All bits in the PLCP header are set to 1 for non-MPDU. */ 1614 if (memcmp(plcp, AR_PLCP_HDR_INTR, AR_PLCP_HDR_LEN) == 0) { 1615 otus_cmd_rxeof(sc, plcp + AR_PLCP_HDR_LEN, 1616 len - AR_PLCP_HDR_LEN); 1617 return; 1618 } 1619 1620 /* Received MPDU. */ 1621 if (__predict_false(len < AR_PLCP_HDR_LEN + sizeof (*tail))) { 1622 OTUS_DPRINTF(sc, OTUS_DEBUG_RXDONE, "MPDU too short %d\n", len); 1623 counter_u64_add(ic->ic_ierrors, 1); 1624 return; 1625 } 1626 tail = (struct ar_rx_tail *)(plcp + len - sizeof (*tail)); 1627 1628 /* Discard error frames; don't discard BAD_RA (eg monitor mode); let net80211 do that */ 1629 if (__predict_false((tail->error & ~AR_RX_ERROR_BAD_RA) != 0)) { 1630 OTUS_DPRINTF(sc, OTUS_DEBUG_RXDONE, "error frame 0x%02x\n", tail->error); 1631 if (tail->error & AR_RX_ERROR_FCS) { 1632 OTUS_DPRINTF(sc, OTUS_DEBUG_RXDONE, "bad FCS\n"); 1633 } else if (tail->error & AR_RX_ERROR_MMIC) { 1634 /* Report Michael MIC failures to net80211. */ 1635 #if 0 1636 ieee80211_notify_michael_failure(ni->ni_vap, wh, keyidx); 1637 #endif 1638 device_printf(sc->sc_dev, "%s: MIC failure\n", __func__); 1639 } 1640 counter_u64_add(ic->ic_ierrors, 1); 1641 return; 1642 } 1643 /* Compute MPDU's length. */ 1644 mlen = len - AR_PLCP_HDR_LEN - sizeof (*tail); 1645 /* Make sure there's room for an 802.11 header + FCS. */ 1646 if (__predict_false(mlen < IEEE80211_MIN_LEN)) { 1647 counter_u64_add(ic->ic_ierrors, 1); 1648 return; 1649 } 1650 mlen -= IEEE80211_CRC_LEN; /* strip 802.11 FCS */ 1651 1652 wh = (struct ieee80211_frame *)(plcp + AR_PLCP_HDR_LEN); 1653 1654 /* 1655 * TODO: I see > 2KiB buffers in this path; is it A-MSDU or something? 1656 */ 1657 m = m_get2(mlen, M_NOWAIT, MT_DATA, M_PKTHDR); 1658 if (m == NULL) { 1659 device_printf(sc->sc_dev, "%s: failed m_get2() (mlen=%d)\n", __func__, mlen); 1660 counter_u64_add(ic->ic_ierrors, 1); 1661 return; 1662 } 1663 1664 /* Finalize mbuf. */ 1665 memcpy(mtod(m, uint8_t *), wh, mlen); 1666 m->m_pkthdr.len = m->m_len = mlen; 1667 1668 #if 0 1669 if (__predict_false(sc->sc_drvbpf != NULL)) { 1670 struct otus_rx_radiotap_header *tap = &sc->sc_rxtap; 1671 struct mbuf mb; 1672 1673 tap->wr_flags = 0; 1674 tap->wr_chan_freq = htole16(ic->ic_ibss_chan->ic_freq); 1675 tap->wr_chan_flags = htole16(ic->ic_ibss_chan->ic_flags); 1676 tap->wr_antsignal = tail->rssi; 1677 tap->wr_rate = 2; /* In case it can't be found below. */ 1678 switch (tail->status & AR_RX_STATUS_MT_MASK) { 1679 case AR_RX_STATUS_MT_CCK: 1680 switch (plcp[0]) { 1681 case 10: tap->wr_rate = 2; break; 1682 case 20: tap->wr_rate = 4; break; 1683 case 55: tap->wr_rate = 11; break; 1684 case 110: tap->wr_rate = 22; break; 1685 } 1686 if (tail->status & AR_RX_STATUS_SHPREAMBLE) 1687 tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE; 1688 break; 1689 case AR_RX_STATUS_MT_OFDM: 1690 switch (plcp[0] & 0xf) { 1691 case 0xb: tap->wr_rate = 12; break; 1692 case 0xf: tap->wr_rate = 18; break; 1693 case 0xa: tap->wr_rate = 24; break; 1694 case 0xe: tap->wr_rate = 36; break; 1695 case 0x9: tap->wr_rate = 48; break; 1696 case 0xd: tap->wr_rate = 72; break; 1697 case 0x8: tap->wr_rate = 96; break; 1698 case 0xc: tap->wr_rate = 108; break; 1699 } 1700 break; 1701 } 1702 mb.m_data = (caddr_t)tap; 1703 mb.m_next = m; 1704 mb.m_nextpkt = NULL; 1705 mb.m_type = 0; 1706 mb.m_flags = 0; 1707 bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_IN); 1708 } 1709 #endif 1710 1711 /* Add RSSI/NF to this mbuf */ 1712 bzero(&rxs, sizeof(rxs)); 1713 rxs.r_flags = IEEE80211_R_NF | IEEE80211_R_RSSI; 1714 rxs.nf = sc->sc_nf[0]; /* XXX chain 0 != combined rssi/nf */ 1715 rxs.rssi = tail->rssi; 1716 /* XXX TODO: add MIMO RSSI/NF as well */ 1717 ieee80211_add_rx_params(m, &rxs); 1718 1719 /* XXX make a method */ 1720 STAILQ_INSERT_TAIL(&rxq->mq_head, m, m_stailqpkt); 1721 1722 #if 0 1723 OTUS_UNLOCK(sc); 1724 ni = ieee80211_find_rxnode(ic, wh); 1725 rxi.rxi_flags = 0; 1726 rxi.rxi_rssi = tail->rssi; 1727 rxi.rxi_tstamp = 0; /* unused */ 1728 ieee80211_input(ifp, m, ni, &rxi); 1729 1730 /* Node is no longer needed. */ 1731 ieee80211_release_node(ic, ni); 1732 OTUS_LOCK(sc); 1733 #endif 1734 } 1735 1736 static void 1737 otus_rxeof(struct usb_xfer *xfer, struct otus_data *data, struct mbufq *rxq) 1738 { 1739 struct otus_softc *sc = usbd_xfer_softc(xfer); 1740 caddr_t buf = data->buf; 1741 struct ar_rx_head *head; 1742 uint16_t hlen; 1743 int len; 1744 1745 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 1746 1747 while (len >= sizeof (*head)) { 1748 head = (struct ar_rx_head *)buf; 1749 if (__predict_false(head->tag != htole16(AR_RX_HEAD_TAG))) { 1750 OTUS_DPRINTF(sc, OTUS_DEBUG_RXDONE, 1751 "tag not valid 0x%x\n", le16toh(head->tag)); 1752 break; 1753 } 1754 hlen = le16toh(head->len); 1755 if (__predict_false(sizeof (*head) + hlen > len)) { 1756 OTUS_DPRINTF(sc, OTUS_DEBUG_RXDONE, 1757 "xfer too short %d/%d\n", len, hlen); 1758 break; 1759 } 1760 /* Process sub-xfer. */ 1761 otus_sub_rxeof(sc, (uint8_t *)&head[1], hlen, rxq); 1762 1763 /* Next sub-xfer is aligned on a 32-bit boundary. */ 1764 hlen = (sizeof (*head) + hlen + 3) & ~3; 1765 buf += hlen; 1766 len -= hlen; 1767 } 1768 } 1769 1770 static void 1771 otus_bulk_rx_callback(struct usb_xfer *xfer, usb_error_t error) 1772 { 1773 struct otus_softc *sc = usbd_xfer_softc(xfer); 1774 struct ieee80211com *ic = &sc->sc_ic; 1775 struct ieee80211_frame *wh; 1776 struct ieee80211_node *ni; 1777 struct mbuf *m; 1778 struct mbufq scrx; 1779 struct otus_data *data; 1780 1781 OTUS_LOCK_ASSERT(sc); 1782 1783 mbufq_init(&scrx, 1024); 1784 1785 #if 0 1786 device_printf(sc->sc_dev, "%s: called; state=%d; error=%d\n", 1787 __func__, 1788 USB_GET_STATE(xfer), 1789 error); 1790 #endif 1791 1792 switch (USB_GET_STATE(xfer)) { 1793 case USB_ST_TRANSFERRED: 1794 data = STAILQ_FIRST(&sc->sc_rx_active); 1795 if (data == NULL) 1796 goto tr_setup; 1797 STAILQ_REMOVE_HEAD(&sc->sc_rx_active, next); 1798 otus_rxeof(xfer, data, &scrx); 1799 STAILQ_INSERT_TAIL(&sc->sc_rx_inactive, data, next); 1800 /* FALLTHROUGH */ 1801 case USB_ST_SETUP: 1802 tr_setup: 1803 /* 1804 * XXX TODO: what if sc_rx isn't empty, but data 1805 * is empty? Then we leak mbufs. 1806 */ 1807 data = STAILQ_FIRST(&sc->sc_rx_inactive); 1808 if (data == NULL) { 1809 //KASSERT(m == NULL, ("mbuf isn't NULL")); 1810 return; 1811 } 1812 STAILQ_REMOVE_HEAD(&sc->sc_rx_inactive, next); 1813 STAILQ_INSERT_TAIL(&sc->sc_rx_active, data, next); 1814 usbd_xfer_set_frame_data(xfer, 0, data->buf, 1815 usbd_xfer_max_len(xfer)); 1816 usbd_transfer_submit(xfer); 1817 /* 1818 * To avoid LOR we should unlock our private mutex here to call 1819 * ieee80211_input() because here is at the end of a USB 1820 * callback and safe to unlock. 1821 */ 1822 OTUS_UNLOCK(sc); 1823 while ((m = mbufq_dequeue(&scrx)) != NULL) { 1824 wh = mtod(m, struct ieee80211_frame *); 1825 ni = ieee80211_find_rxnode(ic, 1826 (struct ieee80211_frame_min *)wh); 1827 if (ni != NULL) { 1828 if (ni->ni_flags & IEEE80211_NODE_HT) 1829 m->m_flags |= M_AMPDU; 1830 (void)ieee80211_input_mimo(ni, m, NULL); 1831 ieee80211_free_node(ni); 1832 } else 1833 (void)ieee80211_input_mimo_all(ic, m, NULL); 1834 } 1835 #ifdef IEEE80211_SUPPORT_SUPERG 1836 ieee80211_ff_age_all(ic, 100); 1837 #endif 1838 OTUS_LOCK(sc); 1839 break; 1840 default: 1841 /* needs it to the inactive queue due to a error. */ 1842 data = STAILQ_FIRST(&sc->sc_rx_active); 1843 if (data != NULL) { 1844 STAILQ_REMOVE_HEAD(&sc->sc_rx_active, next); 1845 STAILQ_INSERT_TAIL(&sc->sc_rx_inactive, data, next); 1846 } 1847 if (error != USB_ERR_CANCELLED) { 1848 usbd_xfer_set_stall(xfer); 1849 counter_u64_add(ic->ic_ierrors, 1); 1850 goto tr_setup; 1851 } 1852 break; 1853 } 1854 } 1855 1856 static void 1857 otus_txeof(struct usb_xfer *xfer, struct otus_data *data) 1858 { 1859 struct otus_softc *sc = usbd_xfer_softc(xfer); 1860 1861 OTUS_DPRINTF(sc, OTUS_DEBUG_TXDONE, 1862 "%s: called; data=%p\n", __func__, data); 1863 1864 OTUS_LOCK_ASSERT(sc); 1865 1866 if (sc->sc_tx_n_active == 0) { 1867 device_printf(sc->sc_dev, 1868 "%s: completed but tx_active=0\n", 1869 __func__); 1870 } else { 1871 sc->sc_tx_n_active--; 1872 } 1873 1874 if (data->m) { 1875 /* XXX status? */ 1876 /* XXX we get TX status via the RX path.. */ 1877 ieee80211_tx_complete(data->ni, data->m, 0); 1878 data->m = NULL; 1879 data->ni = NULL; 1880 } 1881 } 1882 1883 static void 1884 otus_txcmdeof(struct usb_xfer *xfer, struct otus_tx_cmd *cmd) 1885 { 1886 struct otus_softc *sc = usbd_xfer_softc(xfer); 1887 1888 OTUS_LOCK_ASSERT(sc); 1889 1890 OTUS_DPRINTF(sc, OTUS_DEBUG_CMDDONE, 1891 "%s: called; data=%p; odata=%p\n", 1892 __func__, cmd, cmd->odata); 1893 1894 /* 1895 * Non-response commands still need wakeup so the caller 1896 * knows it was submitted and completed OK; response commands should 1897 * wait until they're ACKed by the firmware with a response. 1898 */ 1899 if (cmd->odata) { 1900 STAILQ_INSERT_TAIL(&sc->sc_cmd_waiting, cmd, next_cmd); 1901 } else { 1902 wakeup(cmd); 1903 otus_free_txcmd(sc, cmd); 1904 } 1905 } 1906 1907 static void 1908 otus_bulk_tx_callback(struct usb_xfer *xfer, usb_error_t error) 1909 { 1910 uint8_t which = OTUS_BULK_TX; 1911 struct otus_softc *sc = usbd_xfer_softc(xfer); 1912 struct ieee80211com *ic = &sc->sc_ic; 1913 struct otus_data *data; 1914 1915 OTUS_LOCK_ASSERT(sc); 1916 1917 switch (USB_GET_STATE(xfer)) { 1918 case USB_ST_TRANSFERRED: 1919 data = STAILQ_FIRST(&sc->sc_tx_active[which]); 1920 if (data == NULL) 1921 goto tr_setup; 1922 OTUS_DPRINTF(sc, OTUS_DEBUG_TXDONE, 1923 "%s: transfer done %p\n", __func__, data); 1924 STAILQ_REMOVE_HEAD(&sc->sc_tx_active[which], next); 1925 otus_txeof(xfer, data); 1926 otus_freebuf(sc, data); 1927 /* FALLTHROUGH */ 1928 case USB_ST_SETUP: 1929 tr_setup: 1930 data = STAILQ_FIRST(&sc->sc_tx_pending[which]); 1931 if (data == NULL) { 1932 OTUS_DPRINTF(sc, OTUS_DEBUG_XMIT, 1933 "%s: empty pending queue sc %p\n", __func__, sc); 1934 sc->sc_tx_n_active = 0; 1935 goto finish; 1936 } 1937 STAILQ_REMOVE_HEAD(&sc->sc_tx_pending[which], next); 1938 STAILQ_INSERT_TAIL(&sc->sc_tx_active[which], data, next); 1939 usbd_xfer_set_frame_data(xfer, 0, data->buf, data->buflen); 1940 OTUS_DPRINTF(sc, OTUS_DEBUG_XMIT, 1941 "%s: submitting transfer %p\n", __func__, data); 1942 usbd_transfer_submit(xfer); 1943 sc->sc_tx_n_active++; 1944 break; 1945 default: 1946 data = STAILQ_FIRST(&sc->sc_tx_active[which]); 1947 if (data != NULL) { 1948 STAILQ_REMOVE_HEAD(&sc->sc_tx_active[which], next); 1949 otus_txeof(xfer, data); 1950 otus_freebuf(sc, data); 1951 } 1952 counter_u64_add(ic->ic_oerrors, 1); 1953 1954 if (error != USB_ERR_CANCELLED) { 1955 usbd_xfer_set_stall(xfer); 1956 goto tr_setup; 1957 } 1958 break; 1959 } 1960 1961 finish: 1962 #ifdef IEEE80211_SUPPORT_SUPERG 1963 /* 1964 * If the TX active queue drops below a certain 1965 * threshold, ensure we age fast-frames out so they're 1966 * transmitted. 1967 */ 1968 if (sc->sc_tx_n_active < 2) { 1969 /* XXX ew - net80211 should defer this for us! */ 1970 OTUS_UNLOCK(sc); 1971 ieee80211_ff_flush(ic, WME_AC_VO); 1972 ieee80211_ff_flush(ic, WME_AC_VI); 1973 ieee80211_ff_flush(ic, WME_AC_BE); 1974 ieee80211_ff_flush(ic, WME_AC_BK); 1975 OTUS_LOCK(sc); 1976 } 1977 #endif 1978 /* Kick TX */ 1979 otus_tx_start(sc); 1980 } 1981 1982 static void 1983 otus_bulk_cmd_callback(struct usb_xfer *xfer, usb_error_t error) 1984 { 1985 struct otus_softc *sc = usbd_xfer_softc(xfer); 1986 #if 0 1987 struct ieee80211com *ic = &sc->sc_ic; 1988 #endif 1989 struct otus_tx_cmd *cmd; 1990 1991 OTUS_LOCK_ASSERT(sc); 1992 1993 switch (USB_GET_STATE(xfer)) { 1994 case USB_ST_TRANSFERRED: 1995 cmd = STAILQ_FIRST(&sc->sc_cmd_active); 1996 if (cmd == NULL) 1997 goto tr_setup; 1998 OTUS_DPRINTF(sc, OTUS_DEBUG_CMDDONE, 1999 "%s: transfer done %p\n", __func__, cmd); 2000 STAILQ_REMOVE_HEAD(&sc->sc_cmd_active, next_cmd); 2001 otus_txcmdeof(xfer, cmd); 2002 /* FALLTHROUGH */ 2003 case USB_ST_SETUP: 2004 tr_setup: 2005 cmd = STAILQ_FIRST(&sc->sc_cmd_pending); 2006 if (cmd == NULL) { 2007 OTUS_DPRINTF(sc, OTUS_DEBUG_CMD, 2008 "%s: empty pending queue sc %p\n", __func__, sc); 2009 return; 2010 } 2011 STAILQ_REMOVE_HEAD(&sc->sc_cmd_pending, next_cmd); 2012 STAILQ_INSERT_TAIL(&sc->sc_cmd_active, cmd, next_cmd); 2013 usbd_xfer_set_frame_data(xfer, 0, cmd->buf, cmd->buflen); 2014 OTUS_DPRINTF(sc, OTUS_DEBUG_CMD, 2015 "%s: submitting transfer %p; buf=%p, buflen=%d\n", __func__, cmd, cmd->buf, cmd->buflen); 2016 usbd_transfer_submit(xfer); 2017 break; 2018 default: 2019 cmd = STAILQ_FIRST(&sc->sc_cmd_active); 2020 if (cmd != NULL) { 2021 STAILQ_REMOVE_HEAD(&sc->sc_cmd_active, next_cmd); 2022 otus_txcmdeof(xfer, cmd); 2023 } 2024 2025 if (error != USB_ERR_CANCELLED) { 2026 usbd_xfer_set_stall(xfer); 2027 goto tr_setup; 2028 } 2029 break; 2030 } 2031 } 2032 2033 /* 2034 * This isn't used by carl9170; it however may be used by the 2035 * initial bootloader. 2036 */ 2037 static void 2038 otus_bulk_irq_callback(struct usb_xfer *xfer, usb_error_t error) 2039 { 2040 struct otus_softc *sc = usbd_xfer_softc(xfer); 2041 int actlen; 2042 int sumlen; 2043 2044 usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL); 2045 OTUS_DPRINTF(sc, OTUS_DEBUG_IRQ, 2046 "%s: called; state=%d\n", __func__, USB_GET_STATE(xfer)); 2047 2048 switch (USB_GET_STATE(xfer)) { 2049 case USB_ST_TRANSFERRED: 2050 /* 2051 * Read usb frame data, if any. 2052 * "actlen" has the total length for all frames 2053 * transferred. 2054 */ 2055 OTUS_DPRINTF(sc, OTUS_DEBUG_IRQ, 2056 "%s: comp; %d bytes\n", 2057 __func__, 2058 actlen); 2059 #if 0 2060 pc = usbd_xfer_get_frame(xfer, 0); 2061 otus_dump_usb_rx_page(sc, pc, actlen); 2062 #endif 2063 /* XXX fallthrough */ 2064 case USB_ST_SETUP: 2065 /* 2066 * Setup xfer frame lengths/count and data 2067 */ 2068 OTUS_DPRINTF(sc, OTUS_DEBUG_IRQ, "%s: setup\n", __func__); 2069 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 2070 usbd_transfer_submit(xfer); 2071 break; 2072 2073 default: /* Error */ 2074 /* 2075 * Print error message and clear stall 2076 * for example. 2077 */ 2078 OTUS_DPRINTF(sc, OTUS_DEBUG_IRQ, "%s: ERROR?\n", __func__); 2079 break; 2080 } 2081 } 2082 2083 /* 2084 * Map net80211 rate to hw rate for otus MAC/PHY. 2085 */ 2086 static uint8_t 2087 otus_rate_to_hw_rate(struct otus_softc *sc, uint8_t rate) 2088 { 2089 int is_2ghz; 2090 2091 is_2ghz = !! (IEEE80211_IS_CHAN_2GHZ(sc->sc_ic.ic_curchan)); 2092 2093 switch (rate) { 2094 /* CCK */ 2095 case 2: 2096 return (0x0); 2097 case 4: 2098 return (0x1); 2099 case 11: 2100 return (0x2); 2101 case 22: 2102 return (0x3); 2103 /* OFDM */ 2104 case 12: 2105 return (0xb); 2106 case 18: 2107 return (0xf); 2108 case 24: 2109 return (0xa); 2110 case 36: 2111 return (0xe); 2112 case 48: 2113 return (0x9); 2114 case 72: 2115 return (0xd); 2116 case 96: 2117 return (0x8); 2118 case 108: 2119 return (0xc); 2120 default: 2121 device_printf(sc->sc_dev, "%s: unknown rate '%d'\n", 2122 __func__, (int) rate); 2123 case 0: 2124 if (is_2ghz) 2125 return (0x0); /* 1MB CCK */ 2126 else 2127 return (0xb); /* 6MB OFDM */ 2128 2129 /* XXX TODO: HT */ 2130 } 2131 } 2132 2133 static int 2134 otus_hw_rate_is_ofdm(struct otus_softc *sc, uint8_t hw_rate) 2135 { 2136 2137 switch (hw_rate) { 2138 case 0x0: 2139 case 0x1: 2140 case 0x2: 2141 case 0x3: 2142 return (0); 2143 default: 2144 return (1); 2145 } 2146 } 2147 2148 2149 static void 2150 otus_tx_update_ratectl(struct otus_softc *sc, struct ieee80211_node *ni) 2151 { 2152 int tx, tx_success, tx_retry; 2153 2154 tx = OTUS_NODE(ni)->tx_done; 2155 tx_success = OTUS_NODE(ni)->tx_done - OTUS_NODE(ni)->tx_err; 2156 tx_retry = OTUS_NODE(ni)->tx_retries; 2157 2158 ieee80211_ratectl_tx_update(ni->ni_vap, ni, &tx, &tx_success, 2159 &tx_retry); 2160 } 2161 2162 /* 2163 * XXX TODO: support tx bpf parameters for configuration! 2164 * 2165 * Relevant pieces: 2166 * 2167 * ac = params->ibp_pri & 3; 2168 * rate = params->ibp_rate0; 2169 * params->ibp_flags & IEEE80211_BPF_NOACK 2170 * params->ibp_flags & IEEE80211_BPF_RTS 2171 * params->ibp_flags & IEEE80211_BPF_CTS 2172 * tx->rts_ntries = params->ibp_try1; 2173 * tx->data_ntries = params->ibp_try0; 2174 */ 2175 static int 2176 otus_tx(struct otus_softc *sc, struct ieee80211_node *ni, struct mbuf *m, 2177 struct otus_data *data, const struct ieee80211_bpf_params *params) 2178 { 2179 struct ieee80211com *ic = &sc->sc_ic; 2180 struct ieee80211vap *vap = ni->ni_vap; 2181 struct ieee80211_frame *wh; 2182 struct ieee80211_key *k; 2183 struct ar_tx_head *head; 2184 uint32_t phyctl; 2185 uint16_t macctl, qos; 2186 uint8_t qid, rate; 2187 int hasqos, xferlen; 2188 2189 wh = mtod(m, struct ieee80211_frame *); 2190 if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) { 2191 k = ieee80211_crypto_encap(ni, m); 2192 if (k == NULL) { 2193 device_printf(sc->sc_dev, 2194 "%s: m=%p: ieee80211_crypto_encap returns NULL\n", 2195 __func__, 2196 m); 2197 return (ENOBUFS); 2198 } 2199 wh = mtod(m, struct ieee80211_frame *); 2200 } 2201 2202 /* Calculate transfer length; ensure data buffer is large enough */ 2203 xferlen = sizeof (*head) + m->m_pkthdr.len; 2204 if (xferlen > OTUS_TXBUFSZ) { 2205 device_printf(sc->sc_dev, 2206 "%s: 802.11 TX frame is %d bytes, max %d bytes\n", 2207 __func__, 2208 xferlen, 2209 OTUS_TXBUFSZ); 2210 return (ENOBUFS); 2211 } 2212 2213 hasqos = !! IEEE80211_QOS_HAS_SEQ(wh); 2214 2215 if (hasqos) { 2216 uint8_t tid; 2217 qos = ((const struct ieee80211_qosframe *)wh)->i_qos[0]; 2218 tid = qos & IEEE80211_QOS_TID; 2219 qid = TID_TO_WME_AC(tid); 2220 } else { 2221 qos = 0; 2222 qid = WME_AC_BE; 2223 } 2224 2225 /* Pickup a rate index. */ 2226 if (params != NULL) { 2227 rate = otus_rate_to_hw_rate(sc, params->ibp_rate0); 2228 } else if (IEEE80211_IS_MULTICAST(wh->i_addr1) || 2229 (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_DATA) { 2230 /* Get lowest rate */ 2231 rate = otus_rate_to_hw_rate(sc, 0); 2232 } else if (m->m_flags & M_EAPOL) { 2233 /* Get lowest rate */ 2234 rate = otus_rate_to_hw_rate(sc, 0); 2235 } else { 2236 (void) ieee80211_ratectl_rate(ni, NULL, 0); 2237 rate = otus_rate_to_hw_rate(sc, ni->ni_txrate); 2238 } 2239 2240 phyctl = 0; 2241 macctl = AR_TX_MAC_BACKOFF | AR_TX_MAC_HW_DUR | AR_TX_MAC_QID(qid); 2242 2243 /* 2244 * XXX TODO: params for NOACK, ACK, RTS, CTS, etc 2245 */ 2246 if (IEEE80211_IS_MULTICAST(wh->i_addr1) || 2247 (hasqos && ((qos & IEEE80211_QOS_ACKPOLICY) == 2248 IEEE80211_QOS_ACKPOLICY_NOACK))) 2249 macctl |= AR_TX_MAC_NOACK; 2250 2251 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) { 2252 if (m->m_pkthdr.len + IEEE80211_CRC_LEN >= vap->iv_rtsthreshold) 2253 macctl |= AR_TX_MAC_RTS; 2254 else if (ic->ic_flags & IEEE80211_F_USEPROT) { 2255 if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) 2256 macctl |= AR_TX_MAC_CTS; 2257 else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) 2258 macctl |= AR_TX_MAC_RTS; 2259 } 2260 } 2261 2262 phyctl |= AR_TX_PHY_MCS(rate); 2263 if (otus_hw_rate_is_ofdm(sc, rate)) { 2264 phyctl |= AR_TX_PHY_MT_OFDM; 2265 /* Always use all tx antennas for now, just to be safe */ 2266 phyctl |= AR_TX_PHY_ANTMSK(sc->txmask); 2267 } else { /* CCK */ 2268 phyctl |= AR_TX_PHY_MT_CCK; 2269 phyctl |= AR_TX_PHY_ANTMSK(sc->txmask); 2270 } 2271 2272 /* Update net80211 with the current counters */ 2273 otus_tx_update_ratectl(sc, ni); 2274 2275 /* Update rate control stats for frames that are ACK'ed. */ 2276 if (!(macctl & AR_TX_MAC_NOACK)) 2277 OTUS_NODE(ni)->tx_done++; 2278 2279 2280 /* Fill Tx descriptor. */ 2281 head = (struct ar_tx_head *)data->buf; 2282 head->len = htole16(m->m_pkthdr.len + IEEE80211_CRC_LEN); 2283 head->macctl = htole16(macctl); 2284 head->phyctl = htole32(phyctl); 2285 2286 m_copydata(m, 0, m->m_pkthdr.len, (caddr_t)&head[1]); 2287 2288 data->buflen = xferlen; 2289 data->ni = ni; 2290 data->m = m; 2291 2292 OTUS_DPRINTF(sc, OTUS_DEBUG_XMIT, 2293 "%s: tx: m=%p; data=%p; len=%d mac=0x%04x phy=0x%08x rate=0x%02x, ni_txrate=%d\n", 2294 __func__, m, data, le16toh(head->len), macctl, phyctl, 2295 (int) rate, (int) ni->ni_txrate); 2296 2297 /* Submit transfer */ 2298 STAILQ_INSERT_TAIL(&sc->sc_tx_pending[OTUS_BULK_TX], data, next); 2299 usbd_transfer_start(sc->sc_xfer[OTUS_BULK_TX]); 2300 2301 return 0; 2302 } 2303 2304 int 2305 otus_set_multi(struct otus_softc *sc) 2306 { 2307 uint32_t lo, hi; 2308 struct ieee80211com *ic = &sc->sc_ic; 2309 int r; 2310 2311 if (ic->ic_allmulti > 0 || ic->ic_promisc > 0 || 2312 ic->ic_opmode == IEEE80211_M_MONITOR) { 2313 lo = 0xffffffff; 2314 hi = 0xffffffff; 2315 } else { 2316 struct ieee80211vap *vap; 2317 struct ifnet *ifp; 2318 struct ifmultiaddr *ifma; 2319 2320 lo = hi = 0; 2321 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) { 2322 ifp = vap->iv_ifp; 2323 if_maddr_rlock(ifp); 2324 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 2325 caddr_t dl; 2326 uint32_t val; 2327 2328 dl = LLADDR((struct sockaddr_dl *) ifma->ifma_addr); 2329 val = le32dec(dl + 4); 2330 /* Get address byte 5 */ 2331 val = val & 0x0000ff00; 2332 val = val >> 8; 2333 2334 /* As per below, shift it >> 2 to get only 6 bits */ 2335 val = val >> 2; 2336 if (val < 32) 2337 lo |= 1 << val; 2338 else 2339 hi |= 1 << (val - 32); 2340 } 2341 if_maddr_runlock(ifp); 2342 } 2343 } 2344 #if 0 2345 /* XXX openbsd code */ 2346 while (enm != NULL) { 2347 bit = enm->enm_addrlo[5] >> 2; 2348 if (bit < 32) 2349 lo |= 1 << bit; 2350 else 2351 hi |= 1 << (bit - 32); 2352 ETHER_NEXT_MULTI(step, enm); 2353 } 2354 #endif 2355 2356 hi |= 1U << 31; /* Make sure the broadcast bit is set. */ 2357 2358 OTUS_LOCK(sc); 2359 otus_write(sc, AR_MAC_REG_GROUP_HASH_TBL_L, lo); 2360 otus_write(sc, AR_MAC_REG_GROUP_HASH_TBL_H, hi); 2361 r = otus_write_barrier(sc); 2362 /* XXX operating mode? filter? */ 2363 OTUS_UNLOCK(sc); 2364 return (r); 2365 } 2366 2367 static int 2368 otus_updateedca(struct ieee80211com *ic) 2369 { 2370 struct otus_softc *sc = ic->ic_softc; 2371 2372 OTUS_LOCK(sc); 2373 /* 2374 * XXX TODO: take temporary copy of EDCA information 2375 * when scheduling this so we have a more time-correct view 2376 * of things. 2377 * XXX TODO: this can be done on the net80211 level 2378 */ 2379 otus_updateedca_locked(sc); 2380 OTUS_UNLOCK(sc); 2381 return (0); 2382 } 2383 2384 static void 2385 otus_updateedca_locked(struct otus_softc *sc) 2386 { 2387 #define EXP2(val) ((1 << (val)) - 1) 2388 #define AIFS(val) ((val) * 9 + 10) 2389 struct ieee80211com *ic = &sc->sc_ic; 2390 const struct wmeParams *edca; 2391 2392 OTUS_LOCK_ASSERT(sc); 2393 2394 edca = ic->ic_wme.wme_chanParams.cap_wmeParams; 2395 2396 /* Set CWmin/CWmax values. */ 2397 otus_write(sc, AR_MAC_REG_AC0_CW, 2398 EXP2(edca[WME_AC_BE].wmep_logcwmax) << 16 | 2399 EXP2(edca[WME_AC_BE].wmep_logcwmin)); 2400 otus_write(sc, AR_MAC_REG_AC1_CW, 2401 EXP2(edca[WME_AC_BK].wmep_logcwmax) << 16 | 2402 EXP2(edca[WME_AC_BK].wmep_logcwmin)); 2403 otus_write(sc, AR_MAC_REG_AC2_CW, 2404 EXP2(edca[WME_AC_VI].wmep_logcwmax) << 16 | 2405 EXP2(edca[WME_AC_VI].wmep_logcwmin)); 2406 otus_write(sc, AR_MAC_REG_AC3_CW, 2407 EXP2(edca[WME_AC_VO].wmep_logcwmax) << 16 | 2408 EXP2(edca[WME_AC_VO].wmep_logcwmin)); 2409 otus_write(sc, AR_MAC_REG_AC4_CW, /* Special TXQ. */ 2410 EXP2(edca[WME_AC_VO].wmep_logcwmax) << 16 | 2411 EXP2(edca[WME_AC_VO].wmep_logcwmin)); 2412 2413 /* Set AIFSN values. */ 2414 otus_write(sc, AR_MAC_REG_AC1_AC0_AIFS, 2415 AIFS(edca[WME_AC_VI].wmep_aifsn) << 24 | 2416 AIFS(edca[WME_AC_BK].wmep_aifsn) << 12 | 2417 AIFS(edca[WME_AC_BE].wmep_aifsn)); 2418 otus_write(sc, AR_MAC_REG_AC3_AC2_AIFS, 2419 AIFS(edca[WME_AC_VO].wmep_aifsn) << 16 | /* Special TXQ. */ 2420 AIFS(edca[WME_AC_VO].wmep_aifsn) << 4 | 2421 AIFS(edca[WME_AC_VI].wmep_aifsn) >> 8); 2422 2423 /* Set TXOP limit. */ 2424 otus_write(sc, AR_MAC_REG_AC1_AC0_TXOP, 2425 edca[WME_AC_BK].wmep_txopLimit << 16 | 2426 edca[WME_AC_BE].wmep_txopLimit); 2427 otus_write(sc, AR_MAC_REG_AC3_AC2_TXOP, 2428 edca[WME_AC_VO].wmep_txopLimit << 16 | 2429 edca[WME_AC_VI].wmep_txopLimit); 2430 2431 /* XXX ACK policy? */ 2432 2433 (void)otus_write_barrier(sc); 2434 2435 #undef AIFS 2436 #undef EXP2 2437 } 2438 2439 static void 2440 otus_updateslot(struct otus_softc *sc) 2441 { 2442 struct ieee80211com *ic = &sc->sc_ic; 2443 uint32_t slottime; 2444 2445 OTUS_LOCK_ASSERT(sc); 2446 2447 slottime = IEEE80211_GET_SLOTTIME(ic); 2448 otus_write(sc, AR_MAC_REG_SLOT_TIME, slottime << 10); 2449 (void)otus_write_barrier(sc); 2450 } 2451 2452 int 2453 otus_init_mac(struct otus_softc *sc) 2454 { 2455 int error; 2456 2457 OTUS_LOCK_ASSERT(sc); 2458 2459 otus_write(sc, AR_MAC_REG_ACK_EXTENSION, 0x40); 2460 otus_write(sc, AR_MAC_REG_RETRY_MAX, 0); 2461 otus_write(sc, AR_MAC_REG_RX_THRESHOLD, 0xc1f80); 2462 otus_write(sc, AR_MAC_REG_RX_PE_DELAY, 0x70); 2463 otus_write(sc, AR_MAC_REG_EIFS_AND_SIFS, 0xa144000); 2464 otus_write(sc, AR_MAC_REG_SLOT_TIME, 9 << 10); 2465 otus_write(sc, AR_MAC_REG_TID_CFACK_CFEND_RATE, 0x19000000); 2466 /* NAV protects ACK only (in TXOP). */ 2467 otus_write(sc, AR_MAC_REG_TXOP_DURATION, 0x201); 2468 /* Set beacon Tx power to 0x7. */ 2469 otus_write(sc, AR_MAC_REG_BCN_HT1, 0x8000170); 2470 otus_write(sc, AR_MAC_REG_BACKOFF_PROTECT, 0x105); 2471 otus_write(sc, AR_MAC_REG_AMPDU_FACTOR, 0x10000a); 2472 2473 otus_set_rx_filter(sc); 2474 2475 otus_write(sc, AR_MAC_REG_BASIC_RATE, 0x150f); 2476 otus_write(sc, AR_MAC_REG_MANDATORY_RATE, 0x150f); 2477 otus_write(sc, AR_MAC_REG_RTS_CTS_RATE, 0x10b01bb); 2478 otus_write(sc, AR_MAC_REG_ACK_TPC, 0x4003c1e); 2479 2480 /* Enable LED0 and LED1. */ 2481 otus_write(sc, AR_GPIO_REG_PORT_TYPE, 0x3); 2482 otus_write(sc, AR_GPIO_REG_PORT_DATA, 0x3); 2483 /* Switch MAC to OTUS interface. */ 2484 otus_write(sc, 0x1c3600, 0x3); 2485 otus_write(sc, AR_MAC_REG_AMPDU_RX_THRESH, 0xffff); 2486 otus_write(sc, AR_MAC_REG_MISC_680, 0xf00008); 2487 /* Disable Rx timeout (workaround). */ 2488 otus_write(sc, AR_MAC_REG_RX_TIMEOUT, 0); 2489 2490 /* Set USB Rx stream mode maximum frame number to 2. */ 2491 otus_write(sc, 0x1e1110, 0x4); 2492 /* Set USB Rx stream mode timeout to 10us. */ 2493 otus_write(sc, 0x1e1114, 0x80); 2494 2495 /* Set clock frequency to 88/80MHz. */ 2496 otus_write(sc, AR_PWR_REG_CLOCK_SEL, 0x73); 2497 /* Set WLAN DMA interrupt mode: generate intr per packet. */ 2498 otus_write(sc, AR_MAC_REG_TXRX_MPI, 0x110011); 2499 otus_write(sc, AR_MAC_REG_FCS_SELECT, 0x4); 2500 otus_write(sc, AR_MAC_REG_TXOP_NOT_ENOUGH_INDICATION, 0x141e0f48); 2501 2502 /* Disable HW decryption for now. */ 2503 otus_write(sc, AR_MAC_REG_ENCRYPTION, 0x78); 2504 2505 if ((error = otus_write_barrier(sc)) != 0) 2506 return error; 2507 2508 /* Set default EDCA parameters. */ 2509 otus_updateedca_locked(sc); 2510 2511 return 0; 2512 } 2513 2514 /* 2515 * Return default value for PHY register based on current operating mode. 2516 */ 2517 uint32_t 2518 otus_phy_get_def(struct otus_softc *sc, uint32_t reg) 2519 { 2520 int i; 2521 2522 for (i = 0; i < nitems(ar5416_phy_regs); i++) 2523 if (AR_PHY(ar5416_phy_regs[i]) == reg) 2524 return sc->phy_vals[i]; 2525 return 0; /* Register not found. */ 2526 } 2527 2528 /* 2529 * Update PHY's programming based on vendor-specific data stored in EEPROM. 2530 * This is for FEM-type devices only. 2531 */ 2532 int 2533 otus_set_board_values(struct otus_softc *sc, struct ieee80211_channel *c) 2534 { 2535 const struct ModalEepHeader *eep; 2536 uint32_t tmp, offset; 2537 2538 if (IEEE80211_IS_CHAN_5GHZ(c)) 2539 eep = &sc->eeprom.modalHeader[0]; 2540 else 2541 eep = &sc->eeprom.modalHeader[1]; 2542 2543 /* Offset of chain 2. */ 2544 offset = 2 * 0x1000; 2545 2546 tmp = le32toh(eep->antCtrlCommon); 2547 otus_write(sc, AR_PHY_SWITCH_COM, tmp); 2548 2549 tmp = le32toh(eep->antCtrlChain[0]); 2550 otus_write(sc, AR_PHY_SWITCH_CHAIN_0, tmp); 2551 2552 tmp = le32toh(eep->antCtrlChain[1]); 2553 otus_write(sc, AR_PHY_SWITCH_CHAIN_0 + offset, tmp); 2554 2555 if (1 /* sc->sc_sco == AR_SCO_SCN */) { 2556 tmp = otus_phy_get_def(sc, AR_PHY_SETTLING); 2557 tmp &= ~(0x7f << 7); 2558 tmp |= (eep->switchSettling & 0x7f) << 7; 2559 otus_write(sc, AR_PHY_SETTLING, tmp); 2560 } 2561 2562 tmp = otus_phy_get_def(sc, AR_PHY_DESIRED_SZ); 2563 tmp &= ~0xffff; 2564 tmp |= eep->pgaDesiredSize << 8 | eep->adcDesiredSize; 2565 otus_write(sc, AR_PHY_DESIRED_SZ, tmp); 2566 2567 tmp = eep->txEndToXpaOff << 24 | eep->txEndToXpaOff << 16 | 2568 eep->txFrameToXpaOn << 8 | eep->txFrameToXpaOn; 2569 otus_write(sc, AR_PHY_RF_CTL4, tmp); 2570 2571 tmp = otus_phy_get_def(sc, AR_PHY_RF_CTL3); 2572 tmp &= ~(0xff << 16); 2573 tmp |= eep->txEndToRxOn << 16; 2574 otus_write(sc, AR_PHY_RF_CTL3, tmp); 2575 2576 tmp = otus_phy_get_def(sc, AR_PHY_CCA); 2577 tmp &= ~(0x7f << 12); 2578 tmp |= (eep->thresh62 & 0x7f) << 12; 2579 otus_write(sc, AR_PHY_CCA, tmp); 2580 2581 tmp = otus_phy_get_def(sc, AR_PHY_RXGAIN); 2582 tmp &= ~(0x3f << 12); 2583 tmp |= (eep->txRxAttenCh[0] & 0x3f) << 12; 2584 otus_write(sc, AR_PHY_RXGAIN, tmp); 2585 2586 tmp = otus_phy_get_def(sc, AR_PHY_RXGAIN + offset); 2587 tmp &= ~(0x3f << 12); 2588 tmp |= (eep->txRxAttenCh[1] & 0x3f) << 12; 2589 otus_write(sc, AR_PHY_RXGAIN + offset, tmp); 2590 2591 tmp = otus_phy_get_def(sc, AR_PHY_GAIN_2GHZ); 2592 tmp &= ~(0x3f << 18); 2593 tmp |= (eep->rxTxMarginCh[0] & 0x3f) << 18; 2594 if (IEEE80211_IS_CHAN_5GHZ(c)) { 2595 tmp &= ~(0xf << 10); 2596 tmp |= (eep->bswMargin[0] & 0xf) << 10; 2597 } 2598 otus_write(sc, AR_PHY_GAIN_2GHZ, tmp); 2599 2600 tmp = otus_phy_get_def(sc, AR_PHY_GAIN_2GHZ + offset); 2601 tmp &= ~(0x3f << 18); 2602 tmp |= (eep->rxTxMarginCh[1] & 0x3f) << 18; 2603 otus_write(sc, AR_PHY_GAIN_2GHZ + offset, tmp); 2604 2605 tmp = otus_phy_get_def(sc, AR_PHY_TIMING_CTRL4); 2606 tmp &= ~(0x3f << 5 | 0x1f); 2607 tmp |= (eep->iqCalICh[0] & 0x3f) << 5 | (eep->iqCalQCh[0] & 0x1f); 2608 otus_write(sc, AR_PHY_TIMING_CTRL4, tmp); 2609 2610 tmp = otus_phy_get_def(sc, AR_PHY_TIMING_CTRL4 + offset); 2611 tmp &= ~(0x3f << 5 | 0x1f); 2612 tmp |= (eep->iqCalICh[1] & 0x3f) << 5 | (eep->iqCalQCh[1] & 0x1f); 2613 otus_write(sc, AR_PHY_TIMING_CTRL4 + offset, tmp); 2614 2615 tmp = otus_phy_get_def(sc, AR_PHY_TPCRG1); 2616 tmp &= ~(0xf << 16); 2617 tmp |= (eep->xpd & 0xf) << 16; 2618 otus_write(sc, AR_PHY_TPCRG1, tmp); 2619 2620 return otus_write_barrier(sc); 2621 } 2622 2623 int 2624 otus_program_phy(struct otus_softc *sc, struct ieee80211_channel *c) 2625 { 2626 const uint32_t *vals; 2627 int error, i; 2628 2629 /* Select PHY programming based on band and bandwidth. */ 2630 if (IEEE80211_IS_CHAN_2GHZ(c)) 2631 vals = ar5416_phy_vals_2ghz_20mhz; 2632 else 2633 vals = ar5416_phy_vals_5ghz_20mhz; 2634 for (i = 0; i < nitems(ar5416_phy_regs); i++) 2635 otus_write(sc, AR_PHY(ar5416_phy_regs[i]), vals[i]); 2636 sc->phy_vals = vals; 2637 2638 if (sc->eeprom.baseEepHeader.deviceType == 0x80) /* FEM */ 2639 if ((error = otus_set_board_values(sc, c)) != 0) 2640 return error; 2641 2642 /* Initial Tx power settings. */ 2643 otus_write(sc, AR_PHY_POWER_TX_RATE_MAX, 0x7f); 2644 otus_write(sc, AR_PHY_POWER_TX_RATE1, 0x3f3f3f3f); 2645 otus_write(sc, AR_PHY_POWER_TX_RATE2, 0x3f3f3f3f); 2646 otus_write(sc, AR_PHY_POWER_TX_RATE3, 0x3f3f3f3f); 2647 otus_write(sc, AR_PHY_POWER_TX_RATE4, 0x3f3f3f3f); 2648 otus_write(sc, AR_PHY_POWER_TX_RATE5, 0x3f3f3f3f); 2649 otus_write(sc, AR_PHY_POWER_TX_RATE6, 0x3f3f3f3f); 2650 otus_write(sc, AR_PHY_POWER_TX_RATE7, 0x3f3f3f3f); 2651 otus_write(sc, AR_PHY_POWER_TX_RATE8, 0x3f3f3f3f); 2652 otus_write(sc, AR_PHY_POWER_TX_RATE9, 0x3f3f3f3f); 2653 2654 if (IEEE80211_IS_CHAN_2GHZ(c)) 2655 otus_write(sc, AR_PWR_REG_PLL_ADDAC, 0x5163); 2656 else 2657 otus_write(sc, AR_PWR_REG_PLL_ADDAC, 0x5143); 2658 2659 return otus_write_barrier(sc); 2660 } 2661 2662 static __inline uint8_t 2663 otus_reverse_bits(uint8_t v) 2664 { 2665 v = ((v >> 1) & 0x55) | ((v & 0x55) << 1); 2666 v = ((v >> 2) & 0x33) | ((v & 0x33) << 2); 2667 v = ((v >> 4) & 0x0f) | ((v & 0x0f) << 4); 2668 return v; 2669 } 2670 2671 int 2672 otus_set_rf_bank4(struct otus_softc *sc, struct ieee80211_channel *c) 2673 { 2674 uint8_t chansel, d0, d1; 2675 uint16_t data; 2676 int error; 2677 2678 OTUS_LOCK_ASSERT(sc); 2679 2680 d0 = 0; 2681 if (IEEE80211_IS_CHAN_5GHZ(c)) { 2682 chansel = (c->ic_freq - 4800) / 5; 2683 if (chansel & 1) 2684 d0 |= AR_BANK4_AMODE_REFSEL(2); 2685 else 2686 d0 |= AR_BANK4_AMODE_REFSEL(1); 2687 } else { 2688 d0 |= AR_BANK4_AMODE_REFSEL(2); 2689 if (c->ic_freq == 2484) { /* CH 14 */ 2690 d0 |= AR_BANK4_BMODE_LF_SYNTH_FREQ; 2691 chansel = 10 + (c->ic_freq - 2274) / 5; 2692 } else 2693 chansel = 16 + (c->ic_freq - 2272) / 5; 2694 chansel <<= 2; 2695 } 2696 d0 |= AR_BANK4_ADDR(1) | AR_BANK4_CHUP; 2697 d1 = otus_reverse_bits(chansel); 2698 2699 /* Write bits 0-4 of d0 and d1. */ 2700 data = (d1 & 0x1f) << 5 | (d0 & 0x1f); 2701 otus_write(sc, AR_PHY(44), data); 2702 /* Write bits 5-7 of d0 and d1. */ 2703 data = (d1 >> 5) << 5 | (d0 >> 5); 2704 otus_write(sc, AR_PHY(58), data); 2705 2706 if ((error = otus_write_barrier(sc)) == 0) 2707 otus_delay_ms(sc, 10); 2708 return error; 2709 } 2710 2711 void 2712 otus_get_delta_slope(uint32_t coeff, uint32_t *exponent, uint32_t *mantissa) 2713 { 2714 #define COEFF_SCALE_SHIFT 24 2715 uint32_t exp, man; 2716 2717 /* exponent = 14 - floor(log2(coeff)) */ 2718 for (exp = 31; exp > 0; exp--) 2719 if (coeff & (1 << exp)) 2720 break; 2721 KASSERT(exp != 0, ("exp")); 2722 exp = 14 - (exp - COEFF_SCALE_SHIFT); 2723 2724 /* mantissa = floor(coeff * 2^exponent + 0.5) */ 2725 man = coeff + (1 << (COEFF_SCALE_SHIFT - exp - 1)); 2726 2727 *mantissa = man >> (COEFF_SCALE_SHIFT - exp); 2728 *exponent = exp - 16; 2729 #undef COEFF_SCALE_SHIFT 2730 } 2731 2732 static int 2733 otus_set_chan(struct otus_softc *sc, struct ieee80211_channel *c, int assoc) 2734 { 2735 struct ieee80211com *ic = &sc->sc_ic; 2736 struct ar_cmd_frequency cmd; 2737 struct ar_rsp_frequency rsp; 2738 const uint32_t *vals; 2739 uint32_t coeff, exp, man, tmp; 2740 uint8_t code; 2741 int error, chan, i; 2742 2743 error = 0; 2744 chan = ieee80211_chan2ieee(ic, c); 2745 2746 OTUS_DPRINTF(sc, OTUS_DEBUG_RESET, 2747 "setting channel %d (%dMHz)\n", chan, c->ic_freq); 2748 2749 tmp = IEEE80211_IS_CHAN_2GHZ(c) ? 0x105 : 0x104; 2750 otus_write(sc, AR_MAC_REG_DYNAMIC_SIFS_ACK, tmp); 2751 if ((error = otus_write_barrier(sc)) != 0) 2752 goto finish; 2753 2754 /* Disable BB Heavy Clip. */ 2755 otus_write(sc, AR_PHY_HEAVY_CLIP_ENABLE, 0x200); 2756 if ((error = otus_write_barrier(sc)) != 0) 2757 goto finish; 2758 2759 /* XXX Is that FREQ_START ? */ 2760 error = otus_cmd(sc, AR_CMD_FREQ_STRAT, NULL, 0, NULL, 0); 2761 if (error != 0) 2762 goto finish; 2763 2764 /* Reprogram PHY and RF on channel band or bandwidth changes. */ 2765 if (sc->bb_reset || c->ic_flags != sc->sc_curchan->ic_flags) { 2766 OTUS_DPRINTF(sc, OTUS_DEBUG_RESET, "band switch\n"); 2767 2768 /* Cold/Warm reset BB/ADDA. */ 2769 otus_write(sc, AR_PWR_REG_RESET, sc->bb_reset ? 0x800 : 0x400); 2770 if ((error = otus_write_barrier(sc)) != 0) 2771 goto finish; 2772 otus_write(sc, AR_PWR_REG_RESET, 0); 2773 if ((error = otus_write_barrier(sc)) != 0) 2774 goto finish; 2775 sc->bb_reset = 0; 2776 2777 if ((error = otus_program_phy(sc, c)) != 0) { 2778 device_printf(sc->sc_dev, 2779 "%s: could not program PHY\n", 2780 __func__); 2781 goto finish; 2782 } 2783 2784 /* Select RF programming based on band. */ 2785 if (IEEE80211_IS_CHAN_5GHZ(c)) 2786 vals = ar5416_banks_vals_5ghz; 2787 else 2788 vals = ar5416_banks_vals_2ghz; 2789 for (i = 0; i < nitems(ar5416_banks_regs); i++) 2790 otus_write(sc, AR_PHY(ar5416_banks_regs[i]), vals[i]); 2791 if ((error = otus_write_barrier(sc)) != 0) { 2792 device_printf(sc->sc_dev, 2793 "%s: could not program RF\n", 2794 __func__); 2795 goto finish; 2796 } 2797 code = AR_CMD_RF_INIT; 2798 } else { 2799 code = AR_CMD_FREQUENCY; 2800 } 2801 2802 if ((error = otus_set_rf_bank4(sc, c)) != 0) 2803 goto finish; 2804 2805 tmp = (sc->txmask == 0x5) ? 0x340 : 0x240; 2806 otus_write(sc, AR_PHY_TURBO, tmp); 2807 if ((error = otus_write_barrier(sc)) != 0) 2808 goto finish; 2809 2810 /* Send firmware command to set channel. */ 2811 cmd.freq = htole32((uint32_t)c->ic_freq * 1000); 2812 cmd.dynht2040 = htole32(0); 2813 cmd.htena = htole32(1); 2814 /* Set Delta Slope (exponent and mantissa). */ 2815 coeff = (100 << 24) / c->ic_freq; 2816 otus_get_delta_slope(coeff, &exp, &man); 2817 cmd.dsc_exp = htole32(exp); 2818 cmd.dsc_man = htole32(man); 2819 OTUS_DPRINTF(sc, OTUS_DEBUG_RESET, 2820 "ds coeff=%u exp=%u man=%u\n", coeff, exp, man); 2821 /* For Short GI, coeff is 9/10 that of normal coeff. */ 2822 coeff = (9 * coeff) / 10; 2823 otus_get_delta_slope(coeff, &exp, &man); 2824 cmd.dsc_shgi_exp = htole32(exp); 2825 cmd.dsc_shgi_man = htole32(man); 2826 OTUS_DPRINTF(sc, OTUS_DEBUG_RESET, 2827 "ds shgi coeff=%u exp=%u man=%u\n", coeff, exp, man); 2828 /* Set wait time for AGC and noise calibration (100 or 200ms). */ 2829 cmd.check_loop_count = assoc ? htole32(2000) : htole32(1000); 2830 OTUS_DPRINTF(sc, OTUS_DEBUG_RESET, 2831 "%s\n", (code == AR_CMD_RF_INIT) ? "RF_INIT" : "FREQUENCY"); 2832 error = otus_cmd(sc, code, &cmd, sizeof cmd, &rsp, sizeof(rsp)); 2833 if (error != 0) 2834 goto finish; 2835 if ((rsp.status & htole32(AR_CAL_ERR_AGC | AR_CAL_ERR_NF_VAL)) != 0) { 2836 OTUS_DPRINTF(sc, OTUS_DEBUG_RESET, 2837 "status=0x%x\n", le32toh(rsp.status)); 2838 /* Force cold reset on next channel. */ 2839 sc->bb_reset = 1; 2840 } 2841 #ifdef USB_DEBUG 2842 if (otus_debug & OTUS_DEBUG_RESET) { 2843 device_printf(sc->sc_dev, "calibration status=0x%x\n", 2844 le32toh(rsp.status)); 2845 for (i = 0; i < 2; i++) { /* 2 Rx chains */ 2846 /* Sign-extend 9-bit NF values. */ 2847 device_printf(sc->sc_dev, 2848 "noisefloor chain %d=%d\n", i, 2849 (((int32_t)le32toh(rsp.nf[i])) << 4) >> 23); 2850 device_printf(sc->sc_dev, 2851 "noisefloor ext chain %d=%d\n", i, 2852 ((int32_t)le32toh(rsp.nf_ext[i])) >> 23); 2853 } 2854 } 2855 #endif 2856 for (i = 0; i < OTUS_NUM_CHAINS; i++) { 2857 sc->sc_nf[i] = ((((int32_t)le32toh(rsp.nf[i])) << 4) >> 23); 2858 } 2859 sc->sc_curchan = c; 2860 finish: 2861 return (error); 2862 } 2863 2864 #ifdef notyet 2865 int 2866 otus_set_key(struct ieee80211com *ic, struct ieee80211_node *ni, 2867 struct ieee80211_key *k) 2868 { 2869 struct otus_softc *sc = ic->ic_softc; 2870 struct otus_cmd_key cmd; 2871 2872 /* Defer setting of WEP keys until interface is brought up. */ 2873 if ((ic->ic_if.if_flags & (IFF_UP | IFF_RUNNING)) != 2874 (IFF_UP | IFF_RUNNING)) 2875 return 0; 2876 2877 /* Do it in a process context. */ 2878 cmd.key = *k; 2879 cmd.associd = (ni != NULL) ? ni->ni_associd : 0; 2880 otus_do_async(sc, otus_set_key_cb, &cmd, sizeof cmd); 2881 return 0; 2882 } 2883 2884 void 2885 otus_set_key_cb(struct otus_softc *sc, void *arg) 2886 { 2887 struct otus_cmd_key *cmd = arg; 2888 struct ieee80211_key *k = &cmd->key; 2889 struct ar_cmd_ekey key; 2890 uint16_t cipher; 2891 int error; 2892 2893 memset(&key, 0, sizeof key); 2894 if (k->k_flags & IEEE80211_KEY_GROUP) { 2895 key.uid = htole16(k->k_id); 2896 IEEE80211_ADDR_COPY(key.macaddr, sc->sc_ic.ic_myaddr); 2897 key.macaddr[0] |= 0x80; 2898 } else { 2899 key.uid = htole16(OTUS_UID(cmd->associd)); 2900 IEEE80211_ADDR_COPY(key.macaddr, ni->ni_macaddr); 2901 } 2902 key.kix = htole16(0); 2903 /* Map net80211 cipher to hardware. */ 2904 switch (k->k_cipher) { 2905 case IEEE80211_CIPHER_WEP40: 2906 cipher = AR_CIPHER_WEP64; 2907 break; 2908 case IEEE80211_CIPHER_WEP104: 2909 cipher = AR_CIPHER_WEP128; 2910 break; 2911 case IEEE80211_CIPHER_TKIP: 2912 cipher = AR_CIPHER_TKIP; 2913 break; 2914 case IEEE80211_CIPHER_CCMP: 2915 cipher = AR_CIPHER_AES; 2916 break; 2917 default: 2918 return; 2919 } 2920 key.cipher = htole16(cipher); 2921 memcpy(key.key, k->k_key, MIN(k->k_len, 16)); 2922 error = otus_cmd(sc, AR_CMD_EKEY, &key, sizeof key, NULL, 0); 2923 if (error != 0 || k->k_cipher != IEEE80211_CIPHER_TKIP) 2924 return; 2925 2926 /* TKIP: set Tx/Rx MIC Key. */ 2927 key.kix = htole16(1); 2928 memcpy(key.key, k->k_key + 16, 16); 2929 (void)otus_cmd(sc, AR_CMD_EKEY, &key, sizeof key, NULL, 0); 2930 } 2931 2932 void 2933 otus_delete_key(struct ieee80211com *ic, struct ieee80211_node *ni, 2934 struct ieee80211_key *k) 2935 { 2936 struct otus_softc *sc = ic->ic_softc; 2937 struct otus_cmd_key cmd; 2938 2939 if (!(ic->ic_if.if_flags & IFF_RUNNING) || 2940 ic->ic_state != IEEE80211_S_RUN) 2941 return; /* Nothing to do. */ 2942 2943 /* Do it in a process context. */ 2944 cmd.key = *k; 2945 cmd.associd = (ni != NULL) ? ni->ni_associd : 0; 2946 otus_do_async(sc, otus_delete_key_cb, &cmd, sizeof cmd); 2947 } 2948 2949 void 2950 otus_delete_key_cb(struct otus_softc *sc, void *arg) 2951 { 2952 struct otus_cmd_key *cmd = arg; 2953 struct ieee80211_key *k = &cmd->key; 2954 uint32_t uid; 2955 2956 if (k->k_flags & IEEE80211_KEY_GROUP) 2957 uid = htole32(k->k_id); 2958 else 2959 uid = htole32(OTUS_UID(cmd->associd)); 2960 (void)otus_cmd(sc, AR_CMD_DKEY, &uid, sizeof uid, NULL, 0); 2961 } 2962 #endif 2963 2964 /* 2965 * XXX TODO: check if we have to be doing any calibration in the host 2966 * or whether it's purely a firmware thing. 2967 */ 2968 void 2969 otus_calibrate_to(void *arg, int pending) 2970 { 2971 #if 0 2972 struct otus_softc *sc = arg; 2973 2974 device_printf(sc->sc_dev, "%s: called\n", __func__); 2975 struct ieee80211com *ic = &sc->sc_ic; 2976 struct ieee80211_node *ni; 2977 int s; 2978 2979 if (usbd_is_dying(sc->sc_udev)) 2980 return; 2981 2982 usbd_ref_incr(sc->sc_udev); 2983 2984 s = splnet(); 2985 ni = ic->ic_bss; 2986 ieee80211_amrr_choose(&sc->amrr, ni, &((struct otus_node *)ni)->amn); 2987 splx(s); 2988 2989 if (!usbd_is_dying(sc->sc_udev)) 2990 timeout_add_sec(&sc->calib_to, 1); 2991 2992 usbd_ref_decr(sc->sc_udev); 2993 #endif 2994 } 2995 2996 int 2997 otus_set_bssid(struct otus_softc *sc, const uint8_t *bssid) 2998 { 2999 3000 OTUS_LOCK_ASSERT(sc); 3001 3002 otus_write(sc, AR_MAC_REG_BSSID_L, 3003 bssid[0] | bssid[1] << 8 | bssid[2] << 16 | bssid[3] << 24); 3004 otus_write(sc, AR_MAC_REG_BSSID_H, 3005 bssid[4] | bssid[5] << 8); 3006 return otus_write_barrier(sc); 3007 } 3008 3009 int 3010 otus_set_macaddr(struct otus_softc *sc, const uint8_t *addr) 3011 { 3012 OTUS_LOCK_ASSERT(sc); 3013 3014 otus_write(sc, AR_MAC_REG_MAC_ADDR_L, 3015 addr[0] | addr[1] << 8 | addr[2] << 16 | addr[3] << 24); 3016 otus_write(sc, AR_MAC_REG_MAC_ADDR_H, 3017 addr[4] | addr[5] << 8); 3018 return otus_write_barrier(sc); 3019 } 3020 3021 /* Default single-LED. */ 3022 void 3023 otus_led_newstate_type1(struct otus_softc *sc) 3024 { 3025 /* TBD */ 3026 device_printf(sc->sc_dev, "%s: TODO\n", __func__); 3027 } 3028 3029 /* NETGEAR, dual-LED. */ 3030 void 3031 otus_led_newstate_type2(struct otus_softc *sc) 3032 { 3033 /* TBD */ 3034 device_printf(sc->sc_dev, "%s: TODO\n", __func__); 3035 } 3036 3037 /* NETGEAR, single-LED/3 colors (blue, red, purple.) */ 3038 void 3039 otus_led_newstate_type3(struct otus_softc *sc) 3040 { 3041 #if 0 3042 struct ieee80211com *ic = &sc->sc_ic; 3043 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 3044 3045 uint32_t state = sc->led_state; 3046 3047 OTUS_LOCK_ASSERT(sc); 3048 3049 if (!vap) { 3050 state = 0; /* led off */ 3051 } else if (vap->iv_state == IEEE80211_S_INIT) { 3052 state = 0; /* LED off. */ 3053 } else if (vap->iv_state == IEEE80211_S_RUN) { 3054 /* Associated, LED always on. */ 3055 if (IEEE80211_IS_CHAN_2GHZ(sc->sc_curchan)) 3056 state = AR_LED0_ON; /* 2GHz=>Red. */ 3057 else 3058 state = AR_LED1_ON; /* 5GHz=>Blue. */ 3059 } else { 3060 /* Scanning, blink LED. */ 3061 state ^= AR_LED0_ON | AR_LED1_ON; 3062 if (IEEE80211_IS_CHAN_2GHZ(sc->sc_curchan)) 3063 state &= ~AR_LED1_ON; 3064 else 3065 state &= ~AR_LED0_ON; 3066 } 3067 if (state != sc->led_state) { 3068 otus_write(sc, AR_GPIO_REG_PORT_DATA, state); 3069 if (otus_write_barrier(sc) == 0) 3070 sc->led_state = state; 3071 } 3072 #endif 3073 } 3074 3075 static uint8_t zero_macaddr[IEEE80211_ADDR_LEN] = { 0,0,0,0,0,0 }; 3076 3077 /* 3078 * Set up operating mode, MAC/BSS address and RX filter. 3079 */ 3080 static void 3081 otus_set_operating_mode(struct otus_softc *sc) 3082 { 3083 struct ieee80211com *ic = &sc->sc_ic; 3084 struct ieee80211vap *vap; 3085 uint32_t cam_mode = AR_MAC_CAM_DEFAULTS; 3086 uint32_t rx_ctrl = AR_MAC_RX_CTRL_DEAGG | AR_MAC_RX_CTRL_SHORT_FILTER; 3087 uint32_t sniffer = AR_MAC_SNIFFER_DEFAULTS; 3088 uint32_t enc_mode = 0x78; /* XXX */ 3089 const uint8_t *macaddr; 3090 uint8_t bssid[IEEE80211_ADDR_LEN]; 3091 struct ieee80211_node *ni; 3092 3093 OTUS_LOCK_ASSERT(sc); 3094 3095 /* 3096 * If we're in sniffer mode or we don't have a MAC 3097 * address assigned, ensure it gets reset to all-zero. 3098 */ 3099 IEEE80211_ADDR_COPY(bssid, zero_macaddr); 3100 vap = TAILQ_FIRST(&ic->ic_vaps); 3101 macaddr = ic->ic_macaddr; 3102 3103 switch (ic->ic_opmode) { 3104 case IEEE80211_M_STA: 3105 if (vap) { 3106 ni = ieee80211_ref_node(vap->iv_bss); 3107 IEEE80211_ADDR_COPY(bssid, ni->ni_bssid); 3108 ieee80211_free_node(ni); 3109 } 3110 cam_mode |= AR_MAC_CAM_STA; 3111 rx_ctrl |= AR_MAC_RX_CTRL_PASS_TO_HOST; 3112 break; 3113 case IEEE80211_M_MONITOR: 3114 /* 3115 * Note: monitor mode ends up causing the MAC to 3116 * generate ACK frames for everything it sees. 3117 * So don't do that; instead just put it in STA mode 3118 * and disable RX filters. 3119 */ 3120 default: 3121 cam_mode |= AR_MAC_CAM_STA; 3122 rx_ctrl |= AR_MAC_RX_CTRL_PASS_TO_HOST; 3123 break; 3124 } 3125 3126 /* 3127 * TODO: if/when we do hardware encryption, ensure it's 3128 * disabled if the NIC is in monitor mode. 3129 */ 3130 otus_write(sc, AR_MAC_REG_SNIFFER, sniffer); 3131 otus_write(sc, AR_MAC_REG_CAM_MODE, cam_mode); 3132 otus_write(sc, AR_MAC_REG_ENCRYPTION, enc_mode); 3133 otus_write(sc, AR_MAC_REG_RX_CONTROL, rx_ctrl); 3134 otus_set_macaddr(sc, macaddr); 3135 otus_set_bssid(sc, bssid); 3136 /* XXX barrier? */ 3137 } 3138 3139 static void 3140 otus_set_rx_filter(struct otus_softc *sc) 3141 { 3142 // struct ieee80211com *ic = &sc->sc_ic; 3143 3144 OTUS_LOCK_ASSERT(sc); 3145 3146 #if 0 3147 if (ic->ic_allmulti > 0 || ic->ic_promisc > 0 || 3148 ic->ic_opmode == IEEE80211_M_MONITOR) { 3149 otus_write(sc, AR_MAC_REG_FRAMETYPE_FILTER, 0xff00ffff); 3150 } else { 3151 #endif 3152 /* Filter any control frames, BAR is bit 24. */ 3153 otus_write(sc, AR_MAC_REG_FRAMETYPE_FILTER, 0x0500ffff); 3154 #if 0 3155 } 3156 #endif 3157 } 3158 3159 int 3160 otus_init(struct otus_softc *sc) 3161 { 3162 struct ieee80211com *ic = &sc->sc_ic; 3163 int error; 3164 3165 OTUS_UNLOCK_ASSERT(sc); 3166 3167 OTUS_LOCK(sc); 3168 3169 /* Drain any pending TX frames */ 3170 otus_drain_mbufq(sc); 3171 3172 /* Init MAC */ 3173 if ((error = otus_init_mac(sc)) != 0) { 3174 OTUS_UNLOCK(sc); 3175 device_printf(sc->sc_dev, 3176 "%s: could not initialize MAC\n", __func__); 3177 return error; 3178 } 3179 3180 otus_set_operating_mode(sc); 3181 otus_set_rx_filter(sc); 3182 (void) otus_set_operating_mode(sc); 3183 3184 sc->bb_reset = 1; /* Force cold reset. */ 3185 3186 if ((error = otus_set_chan(sc, ic->ic_curchan, 0)) != 0) { 3187 OTUS_UNLOCK(sc); 3188 device_printf(sc->sc_dev, 3189 "%s: could not set channel\n", __func__); 3190 return error; 3191 } 3192 3193 /* Start Rx. */ 3194 otus_write(sc, AR_MAC_REG_DMA_TRIGGER, 0x100); 3195 (void)otus_write_barrier(sc); 3196 3197 sc->sc_running = 1; 3198 3199 OTUS_UNLOCK(sc); 3200 return 0; 3201 } 3202 3203 void 3204 otus_stop(struct otus_softc *sc) 3205 { 3206 #if 0 3207 int s; 3208 #endif 3209 3210 OTUS_UNLOCK_ASSERT(sc); 3211 3212 OTUS_LOCK(sc); 3213 sc->sc_running = 0; 3214 sc->sc_tx_timer = 0; 3215 OTUS_UNLOCK(sc); 3216 3217 taskqueue_drain_timeout(taskqueue_thread, &sc->scan_to); 3218 taskqueue_drain_timeout(taskqueue_thread, &sc->calib_to); 3219 taskqueue_drain(taskqueue_thread, &sc->tx_task); 3220 3221 OTUS_LOCK(sc); 3222 sc->sc_running = 0; 3223 /* Stop Rx. */ 3224 otus_write(sc, AR_MAC_REG_DMA_TRIGGER, 0); 3225 (void)otus_write_barrier(sc); 3226 3227 /* Drain any pending TX frames */ 3228 otus_drain_mbufq(sc); 3229 3230 OTUS_UNLOCK(sc); 3231 } 3232