1 2/*- 3 * Copyright (c) 2009-2010 Alexander Egorenkov <egorenar@gmail.com> 4 * Copyright (c) 2009 Damien Bergamini <damien.bergamini@free.fr> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19#include <dev/rt2860/rt2860_softc.h> 20#include <dev/rt2860/rt2860_reg.h> 21#include <dev/rt2860/rt2860_eeprom.h> 22#include <dev/rt2860/rt2860_ucode.h> 23#include <dev/rt2860/rt2860_txwi.h> 24#include <dev/rt2860/rt2860_rxwi.h> 25#include <dev/rt2860/rt2860_io.h> 26#include <dev/rt2860/rt2860_read_eeprom.h> 27#include <dev/rt2860/rt2860_led.h> 28#include <dev/rt2860/rt2860_rf.h> 29#include <dev/rt2860/rt2860_debug.h> 30 31/* 32 * Defines and macros 33 */ 34 35#define RT2860_MAX_AGG_SIZE 3840 36 37#define RT2860_TX_DATA_SEG0_SIZE \ 38 (sizeof(struct rt2860_txwi) + sizeof(struct ieee80211_qosframe_addr4)) 39 40#define RT2860_NOISE_FLOOR -95 41 42#define IEEE80211_HAS_ADDR4(wh) \ 43 (((wh)->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS) 44 45#define RT2860_MS(_v, _f) (((_v) & _f) >> _f##_S) 46#define RT2860_SM(_v, _f) (((_v) << _f##_S) & _f) 47 48#define RT2860_TX_WATCHDOG_TIMEOUT 5 49 50#define RT2860_WCID_RESERVED 0xff 51#define RT2860_WCID_MCAST 0xf7 52 53/* 54 * Global function prototypes, used in bus depended interfaces 55 */ 56 57int rt2860_attach(device_t dev); 58 59int rt2860_detach(device_t dev); 60 61int rt2860_shutdown(device_t dev); 62 63int rt2860_suspend(device_t dev); 64 65int rt2860_resume(device_t dev); 66 67/* 68 * Static function prototypes 69 */ 70 71static void rt2860_init_channels(struct rt2860_softc *sc); 72 73static void rt2860_init_channels_ht40(struct rt2860_softc *sc); 74 75static void rt2860_init_locked(void *priv); 76 77static void rt2860_init(void *priv); 78 79static int rt2860_init_bbp(struct rt2860_softc *sc); 80 81static void rt2860_stop_locked(void *priv); 82 83static void rt2860_stop(void *priv); 84 85static void rt2860_start(struct ifnet *ifp); 86 87static int rt2860_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data); 88 89static struct ieee80211vap *rt2860_vap_create(struct ieee80211com *ic, 90 const char name[IFNAMSIZ], int unit, int opmode, int flags, 91 const uint8_t bssid[IEEE80211_ADDR_LEN], 92 const uint8_t mac[IEEE80211_ADDR_LEN]); 93 94static void rt2860_vap_delete(struct ieee80211vap *vap); 95 96static int rt2860_vap_reset(struct ieee80211vap *vap, u_long cmd); 97 98static int rt2860_vap_newstate(struct ieee80211vap *vap, 99 enum ieee80211_state nstate, int arg); 100 101static void rt2860_vap_key_update_begin(struct ieee80211vap *vap); 102 103static void rt2860_vap_key_update_end(struct ieee80211vap *vap); 104 105static int rt2860_vap_key_set(struct ieee80211vap *vap, 106 const struct ieee80211_key *k, const uint8_t mac[IEEE80211_ADDR_LEN]); 107 108static int rt2860_vap_key_delete(struct ieee80211vap *vap, 109 const struct ieee80211_key *k); 110 111static void rt2860_vap_update_beacon(struct ieee80211vap *vap, int what); 112 113static int rt2860_media_change(struct ifnet *ifp); 114 115static struct ieee80211_node *rt2860_node_alloc(struct ieee80211vap *vap, 116 const uint8_t mac[IEEE80211_ADDR_LEN]); 117 118static void rt2860_node_cleanup(struct ieee80211_node *ni); 119 120static void rt2860_node_getmimoinfo(const struct ieee80211_node *ni, 121 struct ieee80211_mimo_info *mi); 122 123static int rt2860_setregdomain(struct ieee80211com *ic, 124 struct ieee80211_regdomain *reg, 125 int nchans, struct ieee80211_channel chans[]); 126 127static void rt2860_getradiocaps(struct ieee80211com *ic, 128 int maxchans, int *nchans, struct ieee80211_channel chans[]); 129 130static void rt2860_scan_start(struct ieee80211com *ic); 131 132static void rt2860_scan_end(struct ieee80211com *ic); 133 134static void rt2860_set_channel(struct ieee80211com *ic); 135 136static void rt2860_newassoc(struct ieee80211_node *ni, int isnew); 137 138static void rt2860_updateslot(struct ifnet *ifp); 139 140static void rt2860_update_promisc(struct ifnet *ifp); 141 142static void rt2860_update_mcast(struct ifnet *ifp); 143 144static int rt2860_wme_update(struct ieee80211com *ic); 145 146static int rt2860_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 147 const struct ieee80211_bpf_params *params); 148 149static int rt2860_recv_action(struct ieee80211_node *ni, 150 const struct ieee80211_frame *wh, 151 const uint8_t *frm, const uint8_t *efrm); 152 153static int rt2860_send_action(struct ieee80211_node *ni, 154 int cat, int act, void *sa); 155 156static int rt2860_addba_response(struct ieee80211_node *ni, 157 struct ieee80211_tx_ampdu *tap, 158 int status, int baparamset, int batimeout); 159 160static void rt2860_addba_stop(struct ieee80211_node *ni, 161 struct ieee80211_tx_ampdu *tap); 162 163static int rt2860_ampdu_rx_start(struct ieee80211_node *ni, 164 struct ieee80211_rx_ampdu *rap, 165 int baparamset, int batimeout, int baseqctl); 166 167static void rt2860_ampdu_rx_stop(struct ieee80211_node *ni, 168 struct ieee80211_rx_ampdu *rap); 169 170static int rt2860_send_bar(struct ieee80211_node *ni, 171 struct ieee80211_tx_ampdu *tap, ieee80211_seq seqno); 172 173static void rt2860_amrr_update_iter_func(void *arg, struct ieee80211_node *ni); 174 175static void rt2860_periodic(void *arg); 176 177static void rt2860_tx_watchdog(void *arg); 178 179static int rt2860_staid_alloc(struct rt2860_softc *sc, int aid); 180 181static void rt2860_staid_delete(struct rt2860_softc *sc, int staid); 182 183static void rt2860_asic_set_bssid(struct rt2860_softc *sc, 184 const uint8_t *bssid); 185 186static void rt2860_asic_set_macaddr(struct rt2860_softc *sc, 187 const uint8_t *addr); 188 189static void rt2860_asic_enable_tsf_sync(struct rt2860_softc *sc); 190 191static void rt2860_asic_disable_tsf_sync(struct rt2860_softc *sc); 192 193static void rt2860_asic_enable_mrr(struct rt2860_softc *sc); 194 195static void rt2860_asic_set_txpreamble(struct rt2860_softc *sc); 196 197static void rt2860_asic_set_basicrates(struct rt2860_softc *sc); 198 199static void rt2860_asic_update_rtsthreshold(struct rt2860_softc *sc); 200 201static void rt2860_asic_update_txpower(struct rt2860_softc *sc); 202 203static void rt2860_asic_update_promisc(struct rt2860_softc *sc); 204 205static void rt2860_asic_updateprot(struct rt2860_softc *sc); 206 207static void rt2860_asic_updateslot(struct rt2860_softc *sc); 208 209static void rt2860_asic_wme_update(struct rt2860_softc *sc); 210 211static void rt2860_asic_update_beacon(struct rt2860_softc *sc, 212 struct ieee80211vap *vap); 213 214static void rt2860_asic_clear_keytables(struct rt2860_softc *sc); 215 216static void rt2860_asic_add_ba_session(struct rt2860_softc *sc, 217 uint8_t wcid, int tid); 218 219static void rt2860_asic_del_ba_session(struct rt2860_softc *sc, 220 uint8_t wcid, int tid); 221 222static int rt2860_beacon_alloc(struct rt2860_softc *sc, 223 struct ieee80211vap *vap); 224 225static uint8_t rt2860_rxrate(struct rt2860_rxwi *rxwi); 226 227static uint8_t rt2860_maxrssi_rxpath(struct rt2860_softc *sc, 228 const struct rt2860_rxwi *rxwi); 229 230static int8_t rt2860_rssi2dbm(struct rt2860_softc *sc, 231 uint8_t rssi, uint8_t rxpath); 232 233static uint8_t rt2860_rate2mcs(uint8_t rate); 234 235static int rt2860_tx_mgmt(struct rt2860_softc *sc, 236 struct mbuf *m, struct ieee80211_node *ni, int qid); 237 238static int rt2860_tx_data(struct rt2860_softc *sc, 239 struct mbuf *m, struct ieee80211_node *ni, int qid); 240 241/* 242static int rt2860_tx_raw(struct rt2860_softc *sc, 243 struct mbuf *m, struct ieee80211_node *ni, 244 const struct ieee80211_bpf_params *params); 245*/ 246 247static void rt2860_intr(void *arg); 248 249static void rt2860_tx_coherent_intr(struct rt2860_softc *sc); 250 251static void rt2860_rx_coherent_intr(struct rt2860_softc *sc); 252 253static void rt2860_txrx_coherent_intr(struct rt2860_softc *sc); 254 255static void rt2860_fifo_sta_full_intr(struct rt2860_softc *sc); 256 257static void rt2860_rx_intr(struct rt2860_softc *sc); 258 259static void rt2860_rx_delay_intr(struct rt2860_softc *sc); 260 261static void rt2860_tx_intr(struct rt2860_softc *sc, int qid); 262 263static void rt2860_tx_delay_intr(struct rt2860_softc *sc); 264 265static void rt2860_pre_tbtt_intr(struct rt2860_softc *sc); 266 267static void rt2860_tbtt_intr(struct rt2860_softc *sc); 268 269static void rt2860_mcu_cmd_intr(struct rt2860_softc *sc); 270 271static void rt2860_auto_wakeup_intr(struct rt2860_softc *sc); 272 273static void rt2860_gp_timer_intr(struct rt2860_softc *sc); 274 275static void rt2860_rx_done_task(void *context, int pending); 276 277static void rt2860_tx_done_task(void *context, int pending); 278 279static void rt2860_fifo_sta_full_task(void *context, int pending); 280 281static void rt2860_periodic_task(void *context, int pending); 282 283static int rt2860_rx_eof(struct rt2860_softc *sc, int limit); 284 285static void rt2860_tx_eof(struct rt2860_softc *sc, 286 struct rt2860_softc_tx_ring *ring); 287 288static void rt2860_update_stats(struct rt2860_softc *sc); 289 290static void rt2860_bbp_tuning(struct rt2860_softc *sc); 291 292static void rt2860_watchdog(struct rt2860_softc *sc); 293 294static void rt2860_drain_fifo_stats(struct rt2860_softc *sc); 295 296static void rt2860_update_raw_counters(struct rt2860_softc *sc); 297 298static void rt2860_intr_enable(struct rt2860_softc *sc, uint32_t intr_mask); 299 300static void rt2860_intr_disable(struct rt2860_softc *sc, uint32_t intr_mask); 301 302static int rt2860_txrx_enable(struct rt2860_softc *sc); 303 304static int rt2860_alloc_rx_ring(struct rt2860_softc *sc, 305 struct rt2860_softc_rx_ring *ring); 306 307static void rt2860_reset_rx_ring(struct rt2860_softc *sc, 308 struct rt2860_softc_rx_ring *ring); 309 310static void rt2860_free_rx_ring(struct rt2860_softc *sc, 311 struct rt2860_softc_rx_ring *ring); 312 313static int rt2860_alloc_tx_ring(struct rt2860_softc *sc, 314 struct rt2860_softc_tx_ring *ring, int qid); 315 316static void rt2860_reset_tx_ring(struct rt2860_softc *sc, 317 struct rt2860_softc_tx_ring *ring); 318 319static void rt2860_free_tx_ring(struct rt2860_softc *sc, 320 struct rt2860_softc_tx_ring *ring); 321 322static void rt2860_dma_map_addr(void *arg, bus_dma_segment_t *segs, 323 int nseg, int error); 324 325static void rt2860_sysctl_attach(struct rt2860_softc *sc); 326 327/* 328 * Static variables 329 */ 330 331static const struct 332{ 333 uint32_t reg; 334 uint32_t val; 335} rt2860_def_mac[] = 336{ 337 { RT2860_REG_PBF_BCN_OFFSET0, 0xf8f0e8e0 }, 338 { RT2860_REG_PBF_BCN_OFFSET1, 0x6f77d0c8 }, 339 { RT2860_REG_LEGACY_BASIC_RATE, 0x0000013f }, 340 { RT2860_REG_HT_BASIC_RATE, 0x00008003 }, 341 { RT2860_REG_SYS_CTRL, 0x00000000 }, 342 { RT2860_REG_RX_FILTER_CFG, 0x00017f97 }, 343 { RT2860_REG_BKOFF_SLOT_CFG, 0x00000209 }, 344 { RT2860_REG_TX_SW_CFG0, 0x00000000 }, 345 { RT2860_REG_TX_SW_CFG1, 0x00080606 }, 346 { RT2860_REG_TX_LINK_CFG, 0x00001020 }, 347 { RT2860_REG_TX_TIMEOUT_CFG, 0x000a2090 }, 348 { RT2860_REG_MAX_LEN_CFG, (1 << 12) | RT2860_MAX_AGG_SIZE }, 349 { RT2860_REG_LED_CFG, 0x7f031e46 }, 350 { RT2860_REG_PBF_MAX_PCNT, 0x1f3fbf9f }, 351 { RT2860_REG_TX_RTY_CFG, 0x47d01f0f }, 352 { RT2860_REG_AUTO_RSP_CFG, 0x00000013 }, 353 { RT2860_REG_TX_CCK_PROT_CFG, 0x05740003 }, 354 { RT2860_REG_TX_OFDM_PROT_CFG, 0x05740003 }, 355 { RT2860_REG_TX_GF20_PROT_CFG, 0x01744004 }, 356 { RT2860_REG_TX_GF40_PROT_CFG, 0x03f44084 }, 357 { RT2860_REG_TX_MM20_PROT_CFG, 0x01744004 }, 358 { RT2860_REG_TX_MM40_PROT_CFG, 0x03f54084 }, 359 { RT2860_REG_TX_TXOP_CTRL_CFG, 0x0000583f }, 360 { RT2860_REG_TX_RTS_CFG, 0x00092b20 }, 361 { RT2860_REG_TX_EXP_ACK_TIME, 0x002400ca }, 362 { RT2860_REG_HCCAPSMP_TXOP_HLDR_ET, 0x00000002 }, 363 { RT2860_REG_XIFS_TIME_CFG, 0x33a41010 }, 364 { RT2860_REG_PWR_PIN_CFG, 0x00000003 }, 365 { RT2860_REG_SCHDMA_WMM_AIFSN_CFG, 0x00002273 }, 366 { RT2860_REG_SCHDMA_WMM_CWMIN_CFG, 0x00002344 }, 367 { RT2860_REG_SCHDMA_WMM_CWMAX_CFG, 0x000034aa }, 368}; 369 370#define RT2860_DEF_MAC_SIZE (sizeof(rt2860_def_mac) / sizeof(rt2860_def_mac[0])) 371 372static const struct 373{ 374 uint8_t reg; 375 uint8_t val; 376} rt2860_def_bbp[] = 377{ 378 { 65, 0x2c }, 379 { 66, 0x38 }, 380 { 69, 0x12 }, 381 { 70, 0x0a }, 382 { 73, 0x10 }, 383 { 81, 0x37 }, 384 { 82, 0x62 }, 385 { 83, 0x6a }, 386 { 84, 0x99 }, 387 { 86, 0x00 }, 388 { 91, 0x04 }, 389 { 92, 0x00 }, 390 { 103, 0x00 }, 391 { 105, 0x05 }, 392 { 106, 0x35 }, 393}; 394 395#define RT2860_DEF_BBP_SIZE (sizeof(rt2860_def_bbp) / sizeof(rt2860_def_bbp[0])) 396 397SYSCTL_NODE(_hw, OID_AUTO, rt2860, CTLFLAG_RD, 0, "RT2860 driver parameters"); 398 399static int rt2860_tx_stbc = 1; 400SYSCTL_INT(_hw_rt2860, OID_AUTO, tx_stbc, CTLFLAG_RW, &rt2860_tx_stbc, 0, "RT2860 Tx STBC"); 401TUNABLE_INT("hw.rt2860.tx_stbc", &rt2860_tx_stbc); 402 403#ifdef RT2860_DEBUG 404//static int rt2860_debug = 0xffffffff; 405static int rt2860_debug = 0; 406SYSCTL_INT(_hw_rt2860, OID_AUTO, debug, CTLFLAG_RW, &rt2860_debug, 0, "RT2860 debug level"); 407TUNABLE_INT("hw.rt2860.debug", &rt2860_debug); 408#endif 409 410/* 411 * rt2860_attach 412 */ 413int rt2860_attach(device_t dev) 414{ 415 struct rt2860_softc *sc; 416 struct ifnet *ifp; 417 struct ieee80211com *ic; 418 int error, ntries, i; 419 420 sc = device_get_softc(dev); 421 422 sc->dev = dev; 423 424 mtx_init(&sc->lock, device_get_nameunit(dev), 425 MTX_NETWORK_LOCK, MTX_DEF | MTX_RECURSE); 426 427 sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 428 &sc->mem_rid, RF_ACTIVE); 429 if (sc->mem == NULL) 430 { 431 printf("%s: could not allocate memory resource\n", 432 device_get_nameunit(dev)); 433 error = ENXIO; 434 goto fail; 435 } 436 437 438 sc->bst = rman_get_bustag(sc->mem); 439 sc->bsh = rman_get_bushandle(sc->mem); 440 441 sc->irq_rid = 0; 442 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, 443 &sc->irq_rid, RF_ACTIVE | RF_SHAREABLE); 444 if (sc->irq == NULL) 445 { 446 printf("%s: could not allocate interrupt resource\n", 447 device_get_nameunit(dev)); 448 error = ENXIO; 449 goto fail; 450 } 451 452 sc->tx_stbc = rt2860_tx_stbc; 453 454#ifdef RT2860_DEBUG 455 sc->debug = rt2860_debug; 456 457 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), 458 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, 459 "debug", CTLFLAG_RW, &sc->debug, 0, "rt2860 debug level"); 460#endif 461 462 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY, 463 "%s: attaching\n", 464 device_get_nameunit(sc->dev)); 465 466 /* wait for NIC to initialize */ 467 468 for (ntries = 0; ntries < 100; ntries++) 469 { 470 sc->mac_rev = rt2860_io_mac_read(sc, RT2860_REG_MAC_CSR0); 471 if (sc->mac_rev != 0x00000000 && sc->mac_rev != 0xffffffff) 472 break; 473 474 DELAY(10); 475 } 476 477 if (ntries == 100) 478 { 479 printf("%s: timeout waiting for NIC to initialize\n", 480 device_get_nameunit(dev)); 481 error = EIO; 482 goto fail; 483 } 484 485 rt2860_read_eeprom(sc); 486 487 printf("%s: MAC/BBP RT2860 (rev 0x%08x), RF %s\n", 488 device_get_nameunit(sc->dev), sc->mac_rev, 489 rt2860_rf_name(sc->rf_rev)); 490 491 /* clear key tables */ 492 493 rt2860_asic_clear_keytables(sc); 494 495 /* allocate Tx and Rx rings */ 496 497 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++) 498 { 499 error = rt2860_alloc_tx_ring(sc, &sc->tx_ring[i], i); 500 if (error != 0) 501 { 502 printf("%s: could not allocate Tx ring #%d\n", 503 device_get_nameunit(sc->dev), i); 504 goto fail; 505 } 506 } 507 508 sc->tx_ring_mgtqid = 5; 509 510 error = rt2860_alloc_rx_ring(sc, &sc->rx_ring); 511 if (error != 0) 512 { 513 printf("%s: could not allocate Rx ring\n", 514 device_get_nameunit(sc->dev)); 515 goto fail; 516 } 517 518 callout_init(&sc->periodic_ch, 0); 519 callout_init_mtx(&sc->tx_watchdog_ch, &sc->lock, 0); 520 521 ifp = sc->ifp = if_alloc(IFT_IEEE80211); 522 if (ifp == NULL) 523 { 524 printf("%s: could not if_alloc()\n", 525 device_get_nameunit(sc->dev)); 526 error = ENOMEM; 527 goto fail; 528 } 529 530 ifp->if_softc = sc; 531 532 if_initname(ifp, "rt2860", device_get_unit(sc->dev)); 533 534 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 535 536 ifp->if_init = rt2860_init; 537 ifp->if_ioctl = rt2860_ioctl; 538 ifp->if_start = rt2860_start; 539 540 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN); 541 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN; 542 IFQ_SET_READY(&ifp->if_snd); 543 544 ic = ifp->if_l2com; 545 546 ic->ic_ifp = ifp; 547 548 ic->ic_phytype = IEEE80211_T_HT; 549 ic->ic_opmode = IEEE80211_M_STA; 550 551 ic->ic_caps = IEEE80211_C_MONITOR | 552 IEEE80211_C_IBSS | 553 IEEE80211_C_STA | 554 IEEE80211_C_AHDEMO | 555 IEEE80211_C_HOSTAP | 556 IEEE80211_C_WDS | 557 IEEE80211_C_MBSS | 558 IEEE80211_C_BGSCAN | 559 IEEE80211_C_TXPMGT | 560 IEEE80211_C_SHPREAMBLE | 561 IEEE80211_C_SHSLOT | 562 IEEE80211_C_TXFRAG | 563 IEEE80211_C_BURST | 564 IEEE80211_C_WME | 565 IEEE80211_C_WPA; 566 567 ic->ic_cryptocaps |= IEEE80211_CRYPTO_WEP | 568 IEEE80211_CRYPTO_TKIP | 569 IEEE80211_CRYPTO_TKIPMIC | 570 IEEE80211_CRYPTO_AES_CCM; 571 572 ic->ic_htcaps = IEEE80211_HTC_HT | 573 IEEE80211_HTC_AMSDU | /* A-MSDU Tx */ 574 IEEE80211_HTC_AMPDU | /* A-MPDU Tx */ 575 IEEE80211_HTC_SMPS | /* MIMO power save */ 576 IEEE80211_HTCAP_MAXAMSDU_3839 | /* max. A-MSDU Rx length */ 577 IEEE80211_HTCAP_CHWIDTH40 | /* HT 40MHz channel width */ 578 IEEE80211_HTCAP_GREENFIELD | /* HT greenfield */ 579 IEEE80211_HTCAP_SHORTGI20 | /* HT 20MHz short GI */ 580 IEEE80211_HTCAP_SHORTGI40 | /* HT 40MHz short GI */ 581 IEEE80211_HTCAP_SMPS_OFF; /* MIMO power save disabled */ 582 583 /* spatial streams */ 584 585 if (sc->nrxpath == 2) 586 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_2STREAM; 587 else if (sc->nrxpath == 3) 588 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_3STREAM; 589 else 590 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_1STREAM; 591 592 if (sc->ntxpath > 1) 593 ic->ic_htcaps |= IEEE80211_HTCAP_TXSTBC; 594 595 /* delayed BA */ 596 597 if (sc->mac_rev != 0x28600100) 598 ic->ic_htcaps |= IEEE80211_HTCAP_DELBA; 599 600 /* init channels */ 601 602 ic->ic_nchans = 0; 603 604 rt2860_init_channels(sc); 605 606 rt2860_init_channels_ht40(sc); 607 608 ieee80211_ifattach(ic, sc->mac_addr); 609 610 ic->ic_vap_create = rt2860_vap_create; 611 ic->ic_vap_delete = rt2860_vap_delete; 612 613 ic->ic_node_alloc = rt2860_node_alloc; 614 615 sc->node_cleanup = ic->ic_node_cleanup; 616 ic->ic_node_cleanup = rt2860_node_cleanup; 617 618 ic->ic_node_getmimoinfo = rt2860_node_getmimoinfo; 619 ic->ic_setregdomain = rt2860_setregdomain; 620 ic->ic_getradiocaps = rt2860_getradiocaps; 621 ic->ic_scan_start = rt2860_scan_start; 622 ic->ic_scan_end = rt2860_scan_end; 623 ic->ic_set_channel = rt2860_set_channel; 624 ic->ic_newassoc = rt2860_newassoc; 625 ic->ic_updateslot = rt2860_updateslot; 626 ic->ic_update_promisc = rt2860_update_promisc; 627 ic->ic_update_mcast = rt2860_update_mcast; 628 ic->ic_wme.wme_update = rt2860_wme_update; 629 ic->ic_raw_xmit = rt2860_raw_xmit; 630 631 sc->recv_action = ic->ic_recv_action; 632 ic->ic_recv_action = rt2860_recv_action; 633 634 sc->send_action = ic->ic_send_action; 635 ic->ic_send_action = rt2860_send_action; 636 637 sc->addba_response = ic->ic_addba_response; 638 ic->ic_addba_response = rt2860_addba_response; 639 640 sc->addba_stop = ic->ic_addba_stop; 641 ic->ic_addba_stop = rt2860_addba_stop; 642 643 sc->ampdu_rx_start = ic->ic_ampdu_rx_start; 644 ic->ic_ampdu_rx_start = rt2860_ampdu_rx_start; 645 646 sc->ampdu_rx_stop = ic->ic_ampdu_rx_stop; 647 ic->ic_ampdu_rx_stop = rt2860_ampdu_rx_stop; 648 649 /* hardware requires padding between 802.11 frame header and body */ 650 651 ic->ic_flags |= IEEE80211_F_DATAPAD | IEEE80211_F_DOTH; 652 653 ic->ic_flags_ext |= IEEE80211_FEXT_SWBMISS; 654 655 ieee80211_radiotap_attach(ic, 656 &sc->txtap.ihdr, sizeof(sc->txtap), 657 RT2860_SOFTC_TX_RADIOTAP_PRESENT, 658 &sc->rxtap.ihdr, sizeof(sc->rxtap), 659 RT2860_SOFTC_RX_RADIOTAP_PRESENT); 660 661 /* init task queue */ 662 663 TASK_INIT(&sc->rx_done_task, 0, rt2860_rx_done_task, sc); 664 TASK_INIT(&sc->tx_done_task, 0, rt2860_tx_done_task, sc); 665 TASK_INIT(&sc->fifo_sta_full_task, 0, rt2860_fifo_sta_full_task, sc); 666 TASK_INIT(&sc->periodic_task, 0, rt2860_periodic_task, sc); 667 668 sc->rx_process_limit = 100; 669 670 sc->taskqueue = taskqueue_create("rt2860_taskq", M_NOWAIT, 671 taskqueue_thread_enqueue, &sc->taskqueue); 672 673 taskqueue_start_threads(&sc->taskqueue, 1, PI_NET, "%s taskq", 674 device_get_nameunit(sc->dev)); 675 676 rt2860_sysctl_attach(sc); 677 678 if (bootverbose) 679 ieee80211_announce(ic); 680 681 /* set up interrupt */ 682 683 error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE, 684 NULL, rt2860_intr, sc, &sc->irqh); 685 if (error != 0) 686 { 687 printf("%s: could not set up interrupt\n", 688 device_get_nameunit(dev)); 689 goto fail; 690 } 691 692 return 0; 693 694fail: 695 696 /* free Tx and Rx rings */ 697 698 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++) 699 rt2860_free_tx_ring(sc, &sc->tx_ring[i]); 700 701 rt2860_free_rx_ring(sc, &sc->rx_ring); 702 703 mtx_destroy(&sc->lock); 704 705 if (sc->mem != NULL) 706 bus_release_resource(dev, SYS_RES_MEMORY, sc->mem_rid, sc->mem); 707 708 if (sc->irq != NULL) 709 bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, sc->irq); 710 711 return error; 712} 713 714/* 715 * rt2860_detach 716 */ 717int rt2860_detach(device_t dev) 718{ 719 struct rt2860_softc *sc; 720 struct ifnet *ifp; 721 struct ieee80211com *ic; 722 int i; 723 724 sc = device_get_softc(dev); 725 ifp = sc->ifp; 726 ic = ifp->if_l2com; 727 728 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY, 729 "%s: detaching\n", 730 device_get_nameunit(sc->dev)); 731 732 RT2860_SOFTC_LOCK(sc); 733 734 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 735 736 callout_stop(&sc->periodic_ch); 737 callout_stop(&sc->tx_watchdog_ch); 738 739 taskqueue_drain(sc->taskqueue, &sc->rx_done_task); 740 taskqueue_drain(sc->taskqueue, &sc->tx_done_task); 741 taskqueue_drain(sc->taskqueue, &sc->fifo_sta_full_task); 742 taskqueue_drain(sc->taskqueue, &sc->periodic_task); 743 744 /* free Tx and Rx rings */ 745 746 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++) 747 rt2860_free_tx_ring(sc, &sc->tx_ring[i]); 748 749 rt2860_free_rx_ring(sc, &sc->rx_ring); 750 751 RT2860_SOFTC_UNLOCK(sc); 752 753 ieee80211_ifdetach(ic); 754 755 if_free(ifp); 756 757 taskqueue_free(sc->taskqueue); 758 759 mtx_destroy(&sc->lock); 760 761 bus_generic_detach(dev); 762 763 bus_teardown_intr(dev, sc->irq, sc->irqh); 764 765 bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, sc->irq); 766 767 bus_release_resource(dev, SYS_RES_MEMORY, sc->mem_rid, sc->mem); 768 769 return 0; 770} 771 772/* 773 * rt2860_shutdown 774 */ 775int rt2860_shutdown(device_t dev) 776{ 777 struct rt2860_softc *sc; 778 779 sc = device_get_softc(dev); 780 781 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY, 782 "%s: shutting down\n", 783 device_get_nameunit(sc->dev)); 784 785 rt2860_stop(sc); 786 787 sc->flags &= ~RT2860_SOFTC_FLAGS_UCODE_LOADED; 788 789 return 0; 790} 791 792/* 793 * rt2860_suspend 794 */ 795int rt2860_suspend(device_t dev) 796{ 797 struct rt2860_softc *sc; 798 799 sc = device_get_softc(dev); 800 801 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY, 802 "%s: suspending\n", 803 device_get_nameunit(sc->dev)); 804 805 rt2860_stop(sc); 806 807 sc->flags &= ~RT2860_SOFTC_FLAGS_UCODE_LOADED; 808 809 return 0; 810} 811 812/* 813 * rt2860_resume 814 */ 815int rt2860_resume(device_t dev) 816{ 817 struct rt2860_softc *sc; 818 struct ifnet *ifp; 819 820 sc = device_get_softc(dev); 821 ifp = sc->ifp; 822 823 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY, 824 "%s: resuming\n", 825 device_get_nameunit(sc->dev)); 826 827 if (ifp->if_flags & IFF_UP) 828 rt2860_init(sc); 829 830 return 0; 831} 832 833/* 834 * rt2860_init_channels 835 */ 836static void rt2860_init_channels(struct rt2860_softc *sc) 837{ 838 struct ifnet *ifp; 839 struct ieee80211com *ic; 840 struct ieee80211_channel *c; 841 int i, flags; 842 843 ifp = sc->ifp; 844 ic = ifp->if_l2com; 845 846 /* set supported channels for 2GHz band */ 847 848 for (i = 1; i <= 14; i++) 849 { 850 c = &ic->ic_channels[ic->ic_nchans++]; 851 flags = IEEE80211_CHAN_B; 852 853 c->ic_freq = ieee80211_ieee2mhz(i, flags); 854 c->ic_ieee = i; 855 c->ic_flags = flags; 856 857 c = &ic->ic_channels[ic->ic_nchans++]; 858 flags = IEEE80211_CHAN_B | IEEE80211_CHAN_HT20; 859 860 c->ic_freq = ieee80211_ieee2mhz(i, flags); 861 c->ic_ieee = i; 862 c->ic_flags = flags; 863 864 c = &ic->ic_channels[ic->ic_nchans++]; 865 flags = IEEE80211_CHAN_G; 866 867 c->ic_freq = ieee80211_ieee2mhz(i, flags); 868 c->ic_ieee = i; 869 c->ic_flags = flags; 870 871 c = &ic->ic_channels[ic->ic_nchans++]; 872 flags = IEEE80211_CHAN_G | IEEE80211_CHAN_HT20; 873 874 c->ic_freq = ieee80211_ieee2mhz(i, flags); 875 c->ic_ieee = i; 876 c->ic_flags = flags; 877 } 878 879 /* set supported channels for 5GHz band */ 880 881 if (sc->rf_rev == RT2860_EEPROM_RF_2850 || 882 sc->rf_rev == RT2860_EEPROM_RF_2750 || 883 sc->rf_rev == RT2860_EEPROM_RF_3052) 884 { 885 for (i = 36; i <= 64; i += 4) 886 { 887 c = &ic->ic_channels[ic->ic_nchans++]; 888 flags = IEEE80211_CHAN_A; 889 890 c->ic_freq = ieee80211_ieee2mhz(i, flags); 891 c->ic_ieee = i; 892 c->ic_flags = flags; 893 894 c = &ic->ic_channels[ic->ic_nchans++]; 895 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20; 896 897 c->ic_freq = ieee80211_ieee2mhz(i, flags); 898 c->ic_ieee = i; 899 c->ic_flags = flags; 900 } 901 902 for (i = 100; i <= 140; i += 4) 903 { 904 c = &ic->ic_channels[ic->ic_nchans++]; 905 flags = IEEE80211_CHAN_A; 906 907 c->ic_freq = ieee80211_ieee2mhz(i, flags); 908 c->ic_ieee = i; 909 c->ic_flags = flags; 910 911 c = &ic->ic_channels[ic->ic_nchans++]; 912 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20; 913 914 c->ic_freq = ieee80211_ieee2mhz(i, flags); 915 c->ic_ieee = i; 916 c->ic_flags = flags; 917 } 918 919 for (i = 149; i <= 165; i += 4) 920 { 921 c = &ic->ic_channels[ic->ic_nchans++]; 922 flags = IEEE80211_CHAN_A; 923 924 c->ic_freq = ieee80211_ieee2mhz(i, flags); 925 c->ic_ieee = i; 926 c->ic_flags = flags; 927 928 c = &ic->ic_channels[ic->ic_nchans++]; 929 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20; 930 931 c->ic_freq = ieee80211_ieee2mhz(i, flags); 932 c->ic_ieee = i; 933 c->ic_flags = flags; 934 } 935 } 936} 937 938/* 939 * rt2860_init_channels_ht40 940 */ 941static void rt2860_init_channels_ht40(struct rt2860_softc *sc) 942{ 943 struct ifnet *ifp; 944 struct ieee80211com *ic; 945 struct ieee80211_channel *c, *cent, *ext; 946 int i, flags; 947 948 ifp = sc->ifp; 949 ic = ifp->if_l2com; 950 951 /* set supported channels for 2GHz band */ 952 953 for (i = 1; i <= 14; i++) 954 { 955 flags = IEEE80211_CHAN_G | IEEE80211_CHAN_HT40; 956 957 /* find the center channel */ 958 959 cent = ieee80211_find_channel_byieee(ic, i, 960 flags & ~IEEE80211_CHAN_HT); 961 if (cent == NULL) 962 { 963 printf("%s: skip channel %d, could not find center channel\n", 964 device_get_nameunit(sc->dev), i); 965 continue; 966 } 967 968 /* find the extension channel */ 969 970 ext = ieee80211_find_channel(ic, cent->ic_freq + 20, 971 flags & ~IEEE80211_CHAN_HT); 972 if (ext == NULL) 973 { 974 printf("%s: skip channel %d, could not find extension channel\n", 975 device_get_nameunit(sc->dev), i); 976 continue; 977 } 978 979 c = &ic->ic_channels[ic->ic_nchans++]; 980 981 *c = *cent; 982 c->ic_extieee = ext->ic_ieee; 983 c->ic_flags &= ~IEEE80211_CHAN_HT; 984 c->ic_flags |= IEEE80211_CHAN_HT40U; 985 986 c = &ic->ic_channels[ic->ic_nchans++]; 987 988 *c = *ext; 989 c->ic_extieee = cent->ic_ieee; 990 c->ic_flags &= ~IEEE80211_CHAN_HT; 991 c->ic_flags |= IEEE80211_CHAN_HT40D; 992 } 993 994 /* set supported channels for 5GHz band */ 995 996 if (sc->rf_rev == RT2860_EEPROM_RF_2850 || 997 sc->rf_rev == RT2860_EEPROM_RF_2750 || 998 sc->rf_rev == RT2860_EEPROM_RF_3052) 999 { 1000 for (i = 36; i <= 64; i += 4) 1001 { 1002 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40; 1003 1004 /* find the center channel */ 1005 1006 cent = ieee80211_find_channel_byieee(ic, i, 1007 flags & ~IEEE80211_CHAN_HT); 1008 if (cent == NULL) 1009 { 1010 printf("%s: skip channel %d, could not find center channel\n", 1011 device_get_nameunit(sc->dev), i); 1012 continue; 1013 } 1014 1015 /* find the extension channel */ 1016 1017 ext = ieee80211_find_channel(ic, cent->ic_freq + 20, 1018 flags & ~IEEE80211_CHAN_HT); 1019 if (ext == NULL) 1020 { 1021 printf("%s: skip channel %d, could not find extension channel\n", 1022 device_get_nameunit(sc->dev), i); 1023 continue; 1024 } 1025 1026 c = &ic->ic_channels[ic->ic_nchans++]; 1027 1028 *c = *cent; 1029 c->ic_extieee = ext->ic_ieee; 1030 c->ic_flags &= ~IEEE80211_CHAN_HT; 1031 c->ic_flags |= IEEE80211_CHAN_HT40U; 1032 1033 c = &ic->ic_channels[ic->ic_nchans++]; 1034 1035 *c = *ext; 1036 c->ic_extieee = cent->ic_ieee; 1037 c->ic_flags &= ~IEEE80211_CHAN_HT; 1038 c->ic_flags |= IEEE80211_CHAN_HT40D; 1039 } 1040 1041 for (i = 100; i <= 140; i += 4) 1042 { 1043 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40; 1044 1045 /* find the center channel */ 1046 1047 cent = ieee80211_find_channel_byieee(ic, i, 1048 flags & ~IEEE80211_CHAN_HT); 1049 if (cent == NULL) 1050 { 1051 printf("%s: skip channel %d, could not find center channel\n", 1052 device_get_nameunit(sc->dev), i); 1053 continue; 1054 } 1055 1056 /* find the extension channel */ 1057 1058 ext = ieee80211_find_channel(ic, cent->ic_freq + 20, 1059 flags & ~IEEE80211_CHAN_HT); 1060 if (ext == NULL) 1061 { 1062 printf("%s: skip channel %d, could not find extension channel\n", 1063 device_get_nameunit(sc->dev), i); 1064 continue; 1065 } 1066 1067 c = &ic->ic_channels[ic->ic_nchans++]; 1068 1069 *c = *cent; 1070 c->ic_extieee = ext->ic_ieee; 1071 c->ic_flags &= ~IEEE80211_CHAN_HT; 1072 c->ic_flags |= IEEE80211_CHAN_HT40U; 1073 1074 c = &ic->ic_channels[ic->ic_nchans++]; 1075 1076 *c = *ext; 1077 c->ic_extieee = cent->ic_ieee; 1078 c->ic_flags &= ~IEEE80211_CHAN_HT; 1079 c->ic_flags |= IEEE80211_CHAN_HT40D; 1080 } 1081 1082 for (i = 149; i <= 165; i += 4) 1083 { 1084 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40; 1085 1086 /* find the center channel */ 1087 1088 cent = ieee80211_find_channel_byieee(ic, i, 1089 flags & ~IEEE80211_CHAN_HT); 1090 if (cent == NULL) 1091 { 1092 printf("%s: skip channel %d, could not find center channel\n", 1093 device_get_nameunit(sc->dev), i); 1094 continue; 1095 } 1096 1097 /* find the extension channel */ 1098 1099 ext = ieee80211_find_channel(ic, cent->ic_freq + 20, 1100 flags & ~IEEE80211_CHAN_HT); 1101 if (ext == NULL) 1102 { 1103 printf("%s: skip channel %d, could not find extension channel\n", 1104 device_get_nameunit(sc->dev), i); 1105 continue; 1106 } 1107 1108 c = &ic->ic_channels[ic->ic_nchans++]; 1109 1110 *c = *cent; 1111 c->ic_extieee = ext->ic_ieee; 1112 c->ic_flags &= ~IEEE80211_CHAN_HT; 1113 c->ic_flags |= IEEE80211_CHAN_HT40U; 1114 1115 c = &ic->ic_channels[ic->ic_nchans++]; 1116 1117 *c = *ext; 1118 c->ic_extieee = cent->ic_ieee; 1119 c->ic_flags &= ~IEEE80211_CHAN_HT; 1120 c->ic_flags |= IEEE80211_CHAN_HT40D; 1121 } 1122 } 1123} 1124 1125/* 1126 * rt2860_init_locked 1127 */ 1128static void rt2860_init_locked(void *priv) 1129{ 1130 struct rt2860_softc *sc; 1131 struct ifnet *ifp; 1132 struct ieee80211com *ic; 1133 int error, i, ntries; 1134 uint32_t tmp, stacnt[6]; 1135 1136 sc = priv; 1137 ifp = sc->ifp; 1138 ic = ifp->if_l2com; 1139 1140 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY, 1141 "%s: initializing\n", 1142 device_get_nameunit(sc->dev)); 1143 1144 RT2860_SOFTC_ASSERT_LOCKED(sc); 1145 1146 if (sc->mac_rev != 0x28720200) 1147 { 1148 if (!(sc->flags & RT2860_SOFTC_FLAGS_UCODE_LOADED)) 1149 { 1150 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY, 1151 "%s: loading 8051 microcode\n", 1152 device_get_nameunit(sc->dev)); 1153 1154 error = rt2860_io_mcu_load_ucode(sc, rt2860_ucode, sizeof(rt2860_ucode)); 1155 if (error != 0) 1156 { 1157 printf("%s: could not load 8051 microcode\n", 1158 device_get_nameunit(sc->dev)); 1159 goto fail; 1160 } 1161 1162 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY, 1163 "%s: 8051 microcode was successfully loaded\n", 1164 device_get_nameunit(sc->dev)); 1165 1166 sc->flags |= RT2860_SOFTC_FLAGS_UCODE_LOADED; 1167 } 1168 } 1169 else 1170 { 1171 sc->flags |= RT2860_SOFTC_FLAGS_UCODE_LOADED; 1172 1173 /* Blink every TX */ 1174#define LED_CFG_LED_POLARITY (1<<30) 1175#define LED_CFG_Y_LED_MODE_ONTX (1<<28) 1176#define LED_CFG_G_LED_MODE_ONTX (1<<26) 1177#define LED_CFG_R_LED_MODE_ONTX (1<<24) 1178#define LED_CFG_SLOW_BLK_TIME (0x03<<16) /* sec */ 1179#define LED_CFG_LED_OFF_TIME (0x1e<<8) /* msec */ 1180#define LED_CFG_LED_ON_TIME (0x46) /* msec */ 1181 rt2860_io_mac_write(sc, RT2860_REG_LED_CFG, 1182 LED_CFG_LED_POLARITY | 1183 LED_CFG_Y_LED_MODE_ONTX | 1184 LED_CFG_G_LED_MODE_ONTX | 1185 LED_CFG_R_LED_MODE_ONTX | 1186 LED_CFG_SLOW_BLK_TIME | 1187 LED_CFG_LED_OFF_TIME | 1188 LED_CFG_LED_ON_TIME); 1189 } 1190 1191 rt2860_io_mac_write(sc, RT2860_REG_PWR_PIN_CFG, 0x2); 1192 1193 /* disable DMA engine */ 1194 1195 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG); 1196 1197 tmp &= 0xff0; 1198 tmp |= RT2860_REG_TX_WB_DDONE; 1199 1200 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp); 1201 1202 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_RST_IDX, 0xffffffff); 1203 1204 /* PBF hardware reset */ 1205 1206 rt2860_io_mac_write(sc, RT2860_REG_PBF_SYS_CTRL, 0xe1f); 1207 rt2860_io_mac_write(sc, RT2860_REG_PBF_SYS_CTRL, 0xe00); 1208 1209 /* wait while DMA engine is busy */ 1210 1211 for (ntries = 0; ntries < 100; ntries++) 1212 { 1213 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG); 1214 if (!(tmp & (RT2860_REG_TX_DMA_BUSY | RT2860_REG_RX_DMA_BUSY))) 1215 break; 1216 1217 DELAY(1000); 1218 } 1219 1220 if (ntries == 100) 1221 { 1222 printf("%s: timeout waiting for DMA engine\n", 1223 device_get_nameunit(sc->dev)); 1224 goto fail; 1225 } 1226 1227 tmp &= 0xff0; 1228 tmp |= RT2860_REG_TX_WB_DDONE; 1229 1230 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp); 1231 1232 /* reset Rx and Tx rings */ 1233 1234 tmp = RT2860_REG_RST_IDX_RX | 1235 RT2860_REG_RST_IDX_TX_MGMT | 1236 RT2860_REG_RST_IDX_TX_HCCA | 1237 RT2860_REG_RST_IDX_TX_AC3 | 1238 RT2860_REG_RST_IDX_TX_AC2 | 1239 RT2860_REG_RST_IDX_TX_AC1 | 1240 RT2860_REG_RST_IDX_TX_AC0; 1241 1242 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_RST_IDX, tmp); 1243 1244 /* PBF hardware reset */ 1245 1246 rt2860_io_mac_write(sc, RT2860_REG_PBF_SYS_CTRL, 0xe1f); 1247 rt2860_io_mac_write(sc, RT2860_REG_PBF_SYS_CTRL, 0xe00); 1248 1249 rt2860_io_mac_write(sc, RT2860_REG_PWR_PIN_CFG, 0x3); 1250 1251 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL, 1252 RT2860_REG_MAC_SRST | RT2860_REG_BBP_HRST); 1253 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL, 0); 1254 1255 /* init Tx power per rate */ 1256 1257 for (i = 0; i < RT2860_SOFTC_TXPOW_RATE_COUNT; i++) 1258 { 1259 if (sc->txpow_rate_20mhz[i] == 0xffffffff) 1260 continue; 1261 1262 rt2860_io_mac_write(sc, RT2860_REG_TX_PWR_CFG(i), 1263 sc->txpow_rate_20mhz[i]); 1264 } 1265 1266 for (i = 0; i < RT2860_DEF_MAC_SIZE; i++) 1267 rt2860_io_mac_write(sc, rt2860_def_mac[i].reg, 1268 rt2860_def_mac[i].val); 1269 1270 /* wait while MAC is busy */ 1271 1272 for (ntries = 0; ntries < 100; ntries++) 1273 { 1274 if (!(rt2860_io_mac_read(sc, RT2860_REG_STATUS_CFG) & 1275 (RT2860_REG_STATUS_TX_BUSY | RT2860_REG_STATUS_RX_BUSY))) 1276 break; 1277 1278 DELAY(1000); 1279 } 1280 1281 if (ntries == 100) 1282 { 1283 printf("%s: timeout waiting for MAC\n", 1284 device_get_nameunit(sc->dev)); 1285 goto fail; 1286 } 1287 1288 /* clear Host to MCU mailbox */ 1289 1290 rt2860_io_mac_write(sc, RT2860_REG_H2M_MAILBOX_BBP_AGENT, 0); 1291 rt2860_io_mac_write(sc, RT2860_REG_H2M_MAILBOX, 0); 1292 1293 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_BOOT, 1294 RT2860_REG_H2M_TOKEN_NO_INTR, 0); 1295 1296 DELAY(1000); 1297 1298 error = rt2860_init_bbp(sc); 1299 if (error != 0) 1300 goto fail; 1301 1302 /* set up maximum buffer sizes */ 1303 1304 tmp = (1 << 12) | RT2860_MAX_AGG_SIZE; 1305 1306 rt2860_io_mac_write(sc, RT2860_REG_MAX_LEN_CFG, tmp); 1307 1308 if (sc->mac_rev == 0x28720200) 1309 { 1310 /* set max. PSDU length from 16K to 32K bytes */ 1311 1312 tmp = rt2860_io_mac_read(sc, RT2860_REG_MAX_LEN_CFG); 1313 1314 tmp &= ~(3 << 12); 1315 tmp |= (2 << 12); 1316 1317 rt2860_io_mac_write(sc, RT2860_REG_MAX_LEN_CFG, tmp); 1318 } 1319 1320 if (sc->mac_rev >= 0x28720200 && sc->mac_rev < 0x30700200) 1321 { 1322 tmp = rt2860_io_mac_read(sc, RT2860_REG_MAX_LEN_CFG); 1323 1324 tmp &= 0xfff; 1325 tmp |= 0x2000; 1326 1327 rt2860_io_mac_write(sc, RT2860_REG_MAX_LEN_CFG, tmp); 1328 } 1329 1330 /* set mac address */ 1331 1332 rt2860_asic_set_macaddr(sc, IF_LLADDR(ifp)); 1333 1334 /* clear statistic registers */ 1335 1336 rt2860_io_mac_read_multi(sc, RT2860_REG_RX_STA_CNT0, 1337 stacnt, sizeof(stacnt)); 1338 1339 /* set RTS threshold */ 1340 1341 rt2860_asic_update_rtsthreshold(sc); 1342 1343 /* set Tx power */ 1344 1345 rt2860_asic_update_txpower(sc); 1346 1347 /* set up protection mode */ 1348 1349 sc->tx_ampdu_sessions = 0; 1350 1351 rt2860_asic_updateprot(sc); 1352 1353 /* clear beacon frame space (entries = 8, entry size = 512) */ 1354 1355 rt2860_io_mac_set_region_4(sc, RT2860_REG_BEACON_BASE(0), 0, 1024); 1356 1357 taskqueue_unblock(sc->taskqueue); 1358 1359 /* init Tx rings (4 EDCAs + HCCA + MGMT) */ 1360 1361 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++) 1362 rt2860_reset_tx_ring(sc, &sc->tx_ring[i]); 1363 1364 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++) 1365 { 1366 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_BASE_PTR(i), 1367 sc->tx_ring[i].desc_phys_addr); 1368 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_MAX_CNT(i), 1369 RT2860_SOFTC_TX_RING_DESC_COUNT); 1370 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_CTX_IDX(i), 0); 1371 } 1372 1373 /* init Rx ring */ 1374 1375 rt2860_reset_rx_ring(sc, &sc->rx_ring); 1376 1377 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_BASE_PTR, 1378 sc->rx_ring.desc_phys_addr); 1379 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_MAX_CNT, 1380 RT2860_SOFTC_RX_RING_DATA_COUNT); 1381 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX, 1382 RT2860_SOFTC_RX_RING_DATA_COUNT - 1); 1383 1384 /* wait while DMA engine is busy */ 1385 1386 for (ntries = 0; ntries < 100; ntries++) 1387 { 1388 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG); 1389 if (!(tmp & (RT2860_REG_TX_DMA_BUSY | RT2860_REG_RX_DMA_BUSY))) 1390 break; 1391 1392 DELAY(1000); 1393 } 1394 1395 if (ntries == 100) 1396 { 1397 printf("%s: timeout waiting for DMA engine\n", 1398 device_get_nameunit(sc->dev)); 1399 goto fail; 1400 } 1401 1402 tmp &= 0xff0; 1403 tmp |= RT2860_REG_TX_WB_DDONE; 1404 1405 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp); 1406 1407 /* disable interrupts mitigation */ 1408 1409 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_DELAY_INT_CFG, 0); 1410 1411 /* select Main antenna for 1T1R devices */ 1412 if (sc->rf_rev == RT2860_EEPROM_RF_2020 || 1413 sc->rf_rev == RT2860_EEPROM_RF_3020 || 1414 sc->rf_rev == RT2860_EEPROM_RF_3320) 1415 rt3090_set_rx_antenna(sc, 0); 1416 1417 /* send LEDs operating mode to microcontroller */ 1418 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_LED1, 1419 RT2860_REG_H2M_TOKEN_NO_INTR, sc->led_off[0]); 1420 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_LED2, 1421 RT2860_REG_H2M_TOKEN_NO_INTR, sc->led_off[1]); 1422 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_LED3, 1423 RT2860_REG_H2M_TOKEN_NO_INTR, sc->led_off[2]); 1424 1425 /* turn radio LED on */ 1426 1427 rt2860_led_cmd(sc, RT2860_LED_CMD_RADIO_ON); 1428 1429 /* write vendor-specific BBP values (from EEPROM) */ 1430 1431 for (i = 0; i < RT2860_SOFTC_BBP_EEPROM_COUNT; i++) 1432 { 1433 if (sc->bbp_eeprom[i].reg == 0x00 || 1434 sc->bbp_eeprom[i].reg == 0xff) 1435 continue; 1436 1437 rt2860_io_bbp_write(sc, sc->bbp_eeprom[i].reg, 1438 sc->bbp_eeprom[i].val); 1439 } 1440 1441 if ((sc->mac_rev & 0xffff0000) >= 0x30710000) 1442 rt3090_rf_init(sc); 1443 1444 if (sc->mac_rev != 0x28720200) { 1445 /* 0x28720200 don`t have RT2860_REG_SCHDMA_GPIO_CTRL_CFG */ 1446 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_GPIO_CTRL_CFG); 1447 if (tmp & (1 << 2)) { 1448 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_SLEEP, 1449 RT2860_REG_H2M_TOKEN_RADIOOFF, 0x02ff); 1450 rt2860_io_mcu_cmd_check(sc, RT2860_REG_H2M_TOKEN_RADIOOFF); 1451 1452 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_WAKEUP, 1453 RT2860_REG_H2M_TOKEN_WAKEUP, 0); 1454 rt2860_io_mcu_cmd_check(sc, RT2860_REG_H2M_TOKEN_WAKEUP); 1455 } 1456 } 1457 1458 if ((sc->mac_rev & 0xffff0000) >= 0x30710000) 1459 rt3090_rf_wakeup(sc); 1460 1461 /* disable non-existing Rx chains */ 1462 1463 tmp = rt2860_io_bbp_read(sc, 3); 1464 1465 tmp &= ~((1 << 4) | (1 << 3)); 1466 1467 if (sc->nrxpath == 3) 1468 tmp |= (1 << 4); 1469 else if (sc->nrxpath == 2) 1470 tmp |= (1 << 3); 1471 1472 rt2860_io_bbp_write(sc, 3, tmp); 1473 1474 /* disable non-existing Tx chains */ 1475 1476 tmp = rt2860_io_bbp_read(sc, 1); 1477 1478 tmp &= ~((1 << 4) | (1 << 3)); 1479 1480 if (sc->ntxpath == 2) 1481 tmp |= (1 << 4); 1482 1483 rt2860_io_bbp_write(sc, 1, tmp); 1484 1485 if ((sc->mac_rev & 0xffff0000) >= 0x30710000) 1486 rt3090_rf_setup(sc); 1487 1488 if (sc->rf_rev == RT2860_EEPROM_RF_3022) 1489 { 1490 /* calibrate RF */ 1491 tmp = rt2860_io_rf_read(sc, 30); 1492 tmp |= 0x80; 1493 rt2860_io_rf_write(sc, 30, tmp); 1494 DELAY(1000); 1495 tmp &= 0x7F; 1496 rt2860_io_rf_write(sc, 30, tmp); 1497 1498 /* Initialize RF register to default value */ 1499 rt2860_io_rf_load_defaults(sc); 1500 } 1501 1502 /* set current channel */ 1503 rt2860_rf_set_chan(sc, ic->ic_curchan); 1504 1505 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_TXOP0_CFG, 0); 1506 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_TXOP1_CFG, 1507 (48 << 16) | 96); 1508 1509 if ((sc->mac_rev & 0xffff) != 0x0101) 1510 rt2860_io_mac_write(sc, RT2860_REG_TX_TXOP_CTRL_CFG, 0x583f); 1511 1512 /* clear pending interrupts */ 1513 1514 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_STATUS, 0xffffffff); 1515 1516 /* enable interrupts */ 1517 1518 tmp = RT2860_REG_INT_TX_COHERENT | 1519 RT2860_REG_INT_RX_COHERENT | 1520 RT2860_REG_INT_GP_TIMER | 1521 RT2860_REG_INT_AUTO_WAKEUP | 1522 RT2860_REG_INT_FIFO_STA_FULL | 1523 RT2860_REG_INT_PRE_TBTT | 1524 RT2860_REG_INT_TBTT | 1525 RT2860_REG_INT_TXRX_COHERENT | 1526 RT2860_REG_INT_MCU_CMD | 1527 RT2860_REG_INT_TX_MGMT_DONE | 1528 RT2860_REG_INT_TX_HCCA_DONE | 1529 RT2860_REG_INT_TX_AC3_DONE | 1530 RT2860_REG_INT_TX_AC2_DONE | 1531 RT2860_REG_INT_TX_AC1_DONE | 1532 RT2860_REG_INT_TX_AC0_DONE | 1533 RT2860_REG_INT_RX_DONE; 1534 1535 sc->intr_enable_mask = tmp; 1536 1537 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_MASK, tmp); 1538 1539 if (rt2860_txrx_enable(sc) != 0) 1540 goto fail; 1541 1542 /* clear garbage interrupts */ 1543 1544 tmp = rt2860_io_mac_read(sc, 0x1300); 1545 1546 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 1547 ifp->if_drv_flags |= IFF_DRV_RUNNING; 1548 1549 sc->periodic_round = 0; 1550 1551 callout_reset(&sc->periodic_ch, hz / 10, rt2860_periodic, sc); 1552 1553 return; 1554 1555fail: 1556 1557 rt2860_stop_locked(sc); 1558} 1559 1560/* 1561 * rt2860_init 1562 */ 1563static void rt2860_init(void *priv) 1564{ 1565 struct rt2860_softc *sc; 1566 1567 sc = priv; 1568 1569 RT2860_SOFTC_LOCK(sc); 1570 1571 rt2860_init_locked(sc); 1572 1573 RT2860_SOFTC_UNLOCK(sc); 1574} 1575 1576/* 1577 * rt2860_init_bbp 1578 */ 1579static int rt2860_init_bbp(struct rt2860_softc *sc) 1580{ 1581 int ntries, i; 1582 uint8_t tmp; 1583 1584 for (ntries = 0; ntries < 20; ntries++) 1585 { 1586 tmp = rt2860_io_bbp_read(sc, 0); 1587 if (tmp != 0x00 && tmp != 0xff) 1588 break; 1589 } 1590 1591 if (tmp == 0x00 || tmp == 0xff) 1592 { 1593 printf("%s: timeout waiting for BBP to wakeup\n", 1594 device_get_nameunit(sc->dev)); 1595 return ETIMEDOUT; 1596 } 1597 1598 for (i = 0; i < RT2860_DEF_BBP_SIZE; i++) 1599 rt2860_io_bbp_write(sc, rt2860_def_bbp[i].reg, 1600 rt2860_def_bbp[i].val); 1601 1602 if ((sc->mac_rev & 0xffff) != 0x0101) 1603 rt2860_io_bbp_write(sc, 84, 0x19); 1604 1605 if (sc->mac_rev == 0x28600100) 1606 { 1607 rt2860_io_bbp_write(sc, 69, 0x16); 1608 rt2860_io_bbp_write(sc, 73, 0x12); 1609 } 1610 1611 return 0; 1612} 1613 1614/* 1615 * rt2860_stop_locked 1616 */ 1617static void rt2860_stop_locked(void *priv) 1618{ 1619 struct rt2860_softc *sc; 1620 struct ifnet *ifp; 1621 struct ieee80211com *ic; 1622 uint32_t tmp; 1623 1624 sc = priv; 1625 ifp = sc->ifp; 1626 ic = ifp->if_l2com; 1627 1628 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY, 1629 "%s: stopping\n", 1630 device_get_nameunit(sc->dev)); 1631 1632 RT2860_SOFTC_ASSERT_LOCKED(sc); 1633 1634 sc->tx_timer = 0; 1635 1636 if (ifp->if_drv_flags & IFF_DRV_RUNNING) 1637 rt2860_led_cmd(sc, RT2860_LED_CMD_RADIO_OFF); 1638 1639 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 1640 1641 callout_stop(&sc->periodic_ch); 1642 callout_stop(&sc->tx_watchdog_ch); 1643 1644 RT2860_SOFTC_UNLOCK(sc); 1645 1646 taskqueue_block(sc->taskqueue); 1647 1648 taskqueue_drain(sc->taskqueue, &sc->rx_done_task); 1649 taskqueue_drain(sc->taskqueue, &sc->tx_done_task); 1650 taskqueue_drain(sc->taskqueue, &sc->fifo_sta_full_task); 1651 taskqueue_drain(sc->taskqueue, &sc->periodic_task); 1652 1653 RT2860_SOFTC_LOCK(sc); 1654 1655 /* clear key tables */ 1656 1657 rt2860_asic_clear_keytables(sc); 1658 1659 /* disable interrupts */ 1660 1661 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_MASK, 0); 1662 1663 /* disable Tx/Rx */ 1664 1665 tmp = rt2860_io_mac_read(sc, RT2860_REG_SYS_CTRL); 1666 1667 tmp &= ~(RT2860_REG_RX_ENABLE | RT2860_REG_TX_ENABLE); 1668 1669 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL, tmp); 1670 1671 /* reset adapter */ 1672 1673 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL, 1674 RT2860_REG_MAC_SRST | RT2860_REG_BBP_HRST); 1675 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL, 0); 1676} 1677 1678/* 1679 * rt2860_stop 1680 */ 1681static void rt2860_stop(void *priv) 1682{ 1683 struct rt2860_softc *sc; 1684 1685 sc = priv; 1686 1687 RT2860_SOFTC_LOCK(sc); 1688 1689 rt2860_stop_locked(sc); 1690 1691 RT2860_SOFTC_UNLOCK(sc); 1692} 1693 1694/* 1695 * rt2860_start 1696 */ 1697static void rt2860_start(struct ifnet *ifp) 1698{ 1699 struct rt2860_softc *sc; 1700 struct ieee80211_node *ni; 1701 struct mbuf *m; 1702 int qid; 1703 1704 sc = ifp->if_softc; 1705 1706 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) 1707 return; 1708 1709 for (;;) 1710 { 1711 IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 1712 if (m == NULL) 1713 break; 1714 1715 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif; 1716 1717 m->m_pkthdr.rcvif = NULL; 1718 1719 qid = M_WME_GETAC(m); 1720 1721 RT2860_SOFTC_TX_RING_LOCK(&sc->tx_ring[qid]); 1722 1723 if (sc->tx_ring[qid].data_queued >= RT2860_SOFTC_TX_RING_DATA_COUNT) 1724 { 1725 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]); 1726 1727 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 1728 "%s: if_start: Tx ring with qid=%d is full\n", 1729 device_get_nameunit(sc->dev), qid); 1730 1731 m_freem(m); 1732 ieee80211_free_node(ni); 1733 1734 ifp->if_drv_flags |= IFF_DRV_OACTIVE; 1735 ifp->if_oerrors++; 1736 1737 sc->tx_data_queue_full[qid]++; 1738 1739 break; 1740 } 1741 1742 if (rt2860_tx_data(sc, m, ni, qid) != 0) 1743 { 1744 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]); 1745 1746 ieee80211_free_node(ni); 1747 1748 ifp->if_oerrors++; 1749 1750 break; 1751 } 1752 1753 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]); 1754 1755 rt2860_drain_fifo_stats(sc); 1756 1757 sc->tx_timer = RT2860_TX_WATCHDOG_TIMEOUT; 1758 1759 callout_reset(&sc->tx_watchdog_ch, hz, rt2860_tx_watchdog, sc); 1760 } 1761} 1762 1763/* 1764 * rt2860_ioctl 1765 */ 1766static int rt2860_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 1767{ 1768 struct rt2860_softc *sc; 1769 struct ieee80211com *ic; 1770 struct ifreq *ifr; 1771 int error, startall; 1772 1773 sc = ifp->if_softc; 1774 ic = ifp->if_l2com; 1775 ifr = (struct ifreq *) data; 1776 1777 error = 0; 1778 1779 switch (cmd) 1780 { 1781 case SIOCSIFFLAGS: 1782 startall = 0; 1783 1784 RT2860_SOFTC_LOCK(sc); 1785 1786 if (ifp->if_flags & IFF_UP) 1787 { 1788 if (ifp->if_drv_flags & IFF_DRV_RUNNING) 1789 { 1790 if ((ifp->if_flags ^ sc->if_flags) & IFF_PROMISC) 1791 rt2860_asic_update_promisc(sc); 1792 } 1793 else 1794 { 1795 rt2860_init_locked(sc); 1796 startall = 1; 1797 } 1798 } 1799 else 1800 { 1801 if (ifp->if_drv_flags & IFF_DRV_RUNNING) 1802 rt2860_stop_locked(sc); 1803 } 1804 1805 sc->if_flags = ifp->if_flags; 1806 1807 RT2860_SOFTC_UNLOCK(sc); 1808 1809 if (startall) 1810 ieee80211_start_all(ic); 1811 break; 1812 1813 case SIOCGIFMEDIA: 1814 case SIOCSIFMEDIA: 1815 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd); 1816 break; 1817 1818 case SIOCGIFADDR: 1819 error = ether_ioctl(ifp, cmd, data); 1820 break; 1821 1822 default: 1823 error = EINVAL; 1824 break; 1825 } 1826 1827 return error; 1828} 1829 1830/* 1831 * rt2860_vap_create 1832 */ 1833static struct ieee80211vap *rt2860_vap_create(struct ieee80211com *ic, 1834 const char name[IFNAMSIZ], int unit, int opmode, int flags, 1835 const uint8_t bssid[IEEE80211_ADDR_LEN], 1836 const uint8_t mac[IEEE80211_ADDR_LEN]) 1837{ 1838 struct rt2860_softc *sc; 1839 struct ifnet *ifp; 1840 struct rt2860_softc_vap *rvap; 1841 struct ieee80211vap *vap; 1842 1843 ifp = ic->ic_ifp; 1844 sc = ifp->if_softc; 1845 1846 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE, 1847 "%s: VAP create: opmode=%s\n", 1848 device_get_nameunit(sc->dev), 1849 ieee80211_opmode_name[opmode]); 1850 1851 switch (opmode) 1852 { 1853 case IEEE80211_M_IBSS: 1854 case IEEE80211_M_STA: 1855 case IEEE80211_M_AHDEMO: 1856 case IEEE80211_M_HOSTAP: 1857 case IEEE80211_M_MBSS: 1858 if ((sc->napvaps + sc->nadhocvaps + sc->nstavaps) != 0) 1859 { 1860 if_printf(ifp, "only 1 VAP supported\n"); 1861 return NULL; 1862 } 1863 1864 if (opmode == IEEE80211_M_STA) 1865 flags |= IEEE80211_CLONE_NOBEACONS; 1866 break; 1867 1868 case IEEE80211_M_WDS: 1869 if (sc->napvaps == 0) 1870 { 1871 if_printf(ifp, "WDS only supported in AP mode\n"); 1872 return NULL; 1873 } 1874 break; 1875 1876 case IEEE80211_M_MONITOR: 1877 break; 1878 1879 default: 1880 if_printf(ifp, "unknown opmode %d\n", opmode); 1881 return NULL; 1882 } 1883 1884 rvap = (struct rt2860_softc_vap *) malloc(sizeof(struct rt2860_softc_vap), 1885 M_80211_VAP, M_NOWAIT | M_ZERO); 1886 if (rvap == NULL) 1887 return NULL; 1888 1889 vap = &rvap->vap; 1890 1891 ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid, mac); 1892 1893 rvap->newstate = vap->iv_newstate; 1894 vap->iv_newstate = rt2860_vap_newstate; 1895 1896 vap->iv_reset = rt2860_vap_reset; 1897 vap->iv_key_update_begin = rt2860_vap_key_update_begin; 1898 vap->iv_key_update_end = rt2860_vap_key_update_end; 1899 vap->iv_key_set = rt2860_vap_key_set; 1900 vap->iv_key_delete = rt2860_vap_key_delete; 1901 vap->iv_update_beacon = rt2860_vap_update_beacon; 1902 1903 rt2860_amrr_init(&rvap->amrr, vap, 1904 sc->ntxpath, 1905 RT2860_AMRR_MIN_SUCCESS_THRESHOLD, 1906 RT2860_AMRR_MAX_SUCCESS_THRESHOLD, 1907 500); 1908 1909 vap->iv_max_aid = RT2860_SOFTC_STAID_COUNT; 1910 1911 /* overwrite default Rx A-MPDU factor */ 1912 1913 vap->iv_ampdu_rxmax = IEEE80211_HTCAP_MAXRXAMPDU_32K; 1914 vap->iv_ampdu_density = IEEE80211_HTCAP_MPDUDENSITY_NA; 1915 vap->iv_ampdu_limit = vap->iv_ampdu_rxmax; 1916 1917 ieee80211_vap_attach(vap, rt2860_media_change, ieee80211_media_status); 1918 1919 switch (vap->iv_opmode) 1920 { 1921 case IEEE80211_M_HOSTAP: 1922 case IEEE80211_M_MBSS: 1923 case IEEE80211_M_AHDEMO: 1924 sc->napvaps++; 1925 break; 1926 1927 case IEEE80211_M_IBSS: 1928 sc->nadhocvaps++; 1929 break; 1930 1931 case IEEE80211_M_STA: 1932 sc->nstavaps++; 1933 break; 1934 1935 case IEEE80211_M_WDS: 1936 sc->nwdsvaps++; 1937 break; 1938 1939 default: 1940 break; 1941 } 1942 1943 sc->nvaps++; 1944 1945 if (sc->napvaps > 0) 1946 ic->ic_opmode = IEEE80211_M_HOSTAP; 1947 else if (sc->nadhocvaps > 0) 1948 ic->ic_opmode = IEEE80211_M_IBSS; 1949 else if (sc->nstavaps > 0) 1950 ic->ic_opmode = IEEE80211_M_STA; 1951 else 1952 ic->ic_opmode = opmode; 1953 1954 return vap; 1955} 1956 1957/* 1958 * rt2860_vap_delete 1959 */ 1960static void rt2860_vap_delete(struct ieee80211vap *vap) 1961{ 1962 struct rt2860_softc *sc; 1963 struct ieee80211com *ic; 1964 struct ifnet *ifp; 1965 struct rt2860_softc_vap *rvap; 1966 enum ieee80211_opmode opmode; 1967 1968 ic = vap->iv_ic; 1969 ifp = ic->ic_ifp; 1970 sc = ifp->if_softc; 1971 rvap = (struct rt2860_softc_vap *) vap; 1972 opmode = vap->iv_opmode; 1973 1974 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE, 1975 "%s: VAP delete: opmode=%s\n", 1976 device_get_nameunit(sc->dev), ieee80211_opmode_name[opmode]); 1977 1978 rt2860_amrr_cleanup(&rvap->amrr); 1979 1980 ieee80211_vap_detach(vap); 1981 1982 if (rvap->beacon_mbuf != NULL) 1983 { 1984 m_free(rvap->beacon_mbuf); 1985 rvap->beacon_mbuf = NULL; 1986 } 1987 1988 switch (opmode) 1989 { 1990 case IEEE80211_M_HOSTAP: 1991 case IEEE80211_M_MBSS: 1992 case IEEE80211_M_AHDEMO: 1993 sc->napvaps--; 1994 break; 1995 1996 case IEEE80211_M_IBSS: 1997 sc->nadhocvaps--; 1998 break; 1999 2000 case IEEE80211_M_STA: 2001 sc->nstavaps--; 2002 break; 2003 2004 case IEEE80211_M_WDS: 2005 sc->nwdsvaps--; 2006 break; 2007 2008 default: 2009 break; 2010 } 2011 2012 sc->nvaps--; 2013 2014 if (sc->napvaps > 0) 2015 ic->ic_opmode = IEEE80211_M_HOSTAP; 2016 else if (sc->nadhocvaps > 0) 2017 ic->ic_opmode = IEEE80211_M_IBSS; 2018 else if (sc->nstavaps > 0) 2019 ic->ic_opmode = IEEE80211_M_STA; 2020 2021 free(rvap, M_80211_VAP); 2022} 2023 2024/* 2025 * rt2860_reset_vap 2026 */ 2027static int rt2860_vap_reset(struct ieee80211vap *vap, u_long cmd) 2028{ 2029 struct rt2860_softc *sc; 2030 struct ieee80211com *ic; 2031 struct ifnet *ifp; 2032 struct rt2860_softc_vap *rvap; 2033 int error; 2034 2035 ic = vap->iv_ic; 2036 ifp = ic->ic_ifp; 2037 sc = ifp->if_softc; 2038 rvap = (struct rt2860_softc_vap *) vap; 2039 2040 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE, 2041 "%s: VAP reset: cmd=%lu\n", 2042 device_get_nameunit(sc->dev), cmd); 2043 2044 error = 0; 2045 2046 switch (cmd) 2047 { 2048 case IEEE80211_IOC_RTSTHRESHOLD: 2049 case IEEE80211_IOC_AMSDU: 2050 rt2860_asic_update_rtsthreshold(sc); 2051 break; 2052 2053 case IEEE80211_IOC_PROTMODE: 2054 case IEEE80211_IOC_HTPROTMODE: 2055 rt2860_asic_updateprot(sc); 2056 break; 2057 2058 case IEEE80211_IOC_TXPOWER: 2059 rt2860_asic_update_txpower(sc); 2060 break; 2061 2062 case IEEE80211_IOC_BURST: 2063 rt2860_asic_updateslot(sc); 2064 break; 2065 2066 case IEEE80211_IOC_SHORTGI: 2067 case IEEE80211_IOC_AMPDU_DENSITY: 2068 case IEEE80211_IOC_SMPS: 2069 break; 2070 2071 default: 2072 error = ENETRESET; 2073 break; 2074 } 2075 2076 return error; 2077} 2078 2079/* 2080 * rt2860_vap_newstate 2081 */ 2082static int rt2860_vap_newstate(struct ieee80211vap *vap, 2083 enum ieee80211_state nstate, int arg) 2084{ 2085 struct rt2860_softc *sc; 2086 struct ieee80211com *ic; 2087 struct ifnet *ifp; 2088 struct rt2860_softc_vap *rvap; 2089 struct ieee80211_node *ni; 2090 enum ieee80211_state ostate; 2091 int error; 2092 2093 ic = vap->iv_ic; 2094 ifp = ic->ic_ifp; 2095 sc = ifp->if_softc; 2096 rvap = (struct rt2860_softc_vap *) vap; 2097 2098 ostate = vap->iv_state; 2099 2100 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE, 2101 "%s: VAP newstate: %s -> %s\n", 2102 device_get_nameunit(sc->dev), 2103 ieee80211_state_name[ostate], ieee80211_state_name[nstate]); 2104 2105 error = rvap->newstate(vap, nstate, arg); 2106 if (error != 0) 2107 return error; 2108 2109 IEEE80211_UNLOCK(ic); 2110 2111 RT2860_SOFTC_LOCK(sc); 2112 2113 /* turn link LED off */ 2114 2115 if (nstate != IEEE80211_S_RUN) 2116 rt2860_led_cmd(sc, RT2860_LED_CMD_RADIO_OFF); 2117 2118 switch (nstate) 2119 { 2120 case IEEE80211_S_INIT: 2121 rt2860_asic_disable_tsf_sync(sc); 2122 break; 2123 2124 case IEEE80211_S_RUN: 2125 ni = vap->iv_bss; 2126 2127 rt2860_rf_set_chan(sc, ni->ni_chan); 2128 2129 if (vap->iv_opmode != IEEE80211_M_MONITOR) 2130 { 2131 rt2860_asic_enable_mrr(sc); 2132 rt2860_asic_set_txpreamble(sc); 2133 rt2860_asic_set_basicrates(sc); 2134 rt2860_asic_update_txpower(sc); 2135 rt2860_asic_set_bssid(sc, ni->ni_bssid); 2136 } 2137 2138 if (vap->iv_opmode == IEEE80211_M_HOSTAP || 2139 vap->iv_opmode == IEEE80211_M_IBSS || 2140 vap->iv_opmode == IEEE80211_M_MBSS) 2141 { 2142 error = rt2860_beacon_alloc(sc, vap); 2143 if (error != 0) 2144 break; 2145 2146 rt2860_asic_update_beacon(sc, vap); 2147 } 2148 2149 if (vap->iv_opmode != IEEE80211_M_MONITOR) 2150 rt2860_asic_enable_tsf_sync(sc); 2151 2152 /* turn link LED on */ 2153 2154 if (vap->iv_opmode != IEEE80211_M_MONITOR) 2155 { 2156 rt2860_led_cmd(sc, RT2860_LED_CMD_RADIO_ON | 2157 (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan) ? 2158 RT2860_LED_CMD_LINK_2GHZ : RT2860_LED_CMD_LINK_5GHZ)); 2159 } 2160 break; 2161 2162 case IEEE80211_S_SLEEP: 2163 break; 2164 2165 default: 2166 break; 2167 } 2168 2169 RT2860_SOFTC_UNLOCK(sc); 2170 2171 IEEE80211_LOCK(ic); 2172 2173 return error; 2174} 2175 2176/* 2177 * rt2860_vap_key_update_begin 2178 */ 2179static void rt2860_vap_key_update_begin(struct ieee80211vap *vap) 2180{ 2181 struct rt2860_softc *sc; 2182 struct ieee80211com *ic; 2183 struct ifnet *ifp; 2184 2185 ic = vap->iv_ic; 2186 ifp = ic->ic_ifp; 2187 sc = ifp->if_softc; 2188 2189 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY, 2190 "%s: VAP key update begin\n", 2191 device_get_nameunit(sc->dev)); 2192 2193 taskqueue_block(sc->taskqueue); 2194 2195 IF_LOCK(&ifp->if_snd); 2196} 2197 2198/* 2199 * rt2860_vap_key_update_end 2200 */ 2201static void rt2860_vap_key_update_end(struct ieee80211vap *vap) 2202{ 2203 struct rt2860_softc *sc; 2204 struct ieee80211com *ic; 2205 struct ifnet *ifp; 2206 2207 ic = vap->iv_ic; 2208 ifp = ic->ic_ifp; 2209 sc = ifp->if_softc; 2210 2211 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY, 2212 "%s: VAP key update end\n", 2213 device_get_nameunit(sc->dev)); 2214 2215 IF_UNLOCK(&ifp->if_snd); 2216 2217 taskqueue_unblock(sc->taskqueue); 2218} 2219 2220/* 2221 * rt2860_vap_key_set 2222 */ 2223static int rt2860_vap_key_set(struct ieee80211vap *vap, 2224 const struct ieee80211_key *k, const uint8_t mac[IEEE80211_ADDR_LEN]) 2225{ 2226 struct rt2860_softc *sc; 2227 struct ieee80211com *ic; 2228 struct ifnet *ifp; 2229 struct ieee80211_node *ni; 2230 struct rt2860_softc_node *rni; 2231 uint16_t key_base, keymode_base; 2232 uint8_t mode, vapid, wcid, iv[8]; 2233 uint32_t tmp; 2234 2235 if (k->wk_cipher->ic_cipher != IEEE80211_CIPHER_WEP && 2236 k->wk_cipher->ic_cipher != IEEE80211_CIPHER_TKIP && 2237 k->wk_cipher->ic_cipher != IEEE80211_CIPHER_AES_CCM) 2238 return 0; 2239 2240 ic = vap->iv_ic; 2241 ifp = ic->ic_ifp; 2242 sc = ifp->if_softc; 2243 2244 switch (k->wk_cipher->ic_cipher) 2245 { 2246 case IEEE80211_CIPHER_WEP: 2247 if(k->wk_keylen < 8) 2248 mode = RT2860_REG_CIPHER_MODE_WEP40; 2249 else 2250 mode = RT2860_REG_CIPHER_MODE_WEP104; 2251 break; 2252 2253 case IEEE80211_CIPHER_TKIP: 2254 mode = RT2860_REG_CIPHER_MODE_TKIP; 2255 break; 2256 2257 case IEEE80211_CIPHER_AES_CCM: 2258 mode = RT2860_REG_CIPHER_MODE_AES_CCMP; 2259 break; 2260 2261 default: 2262 return 0; 2263 } 2264 2265 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY, 2266 "%s: VAP key set: keyix=%d, keylen=%d, macaddr=%s, mode=%d, group=%d\n", 2267 device_get_nameunit(sc->dev), k->wk_keyix, k->wk_keylen, ether_sprintf(k->wk_macaddr), 2268 mode, (k->wk_flags & IEEE80211_KEY_GROUP) ? 1 : 0); 2269 2270 if (!(k->wk_flags & IEEE80211_KEY_GROUP)) 2271 { 2272 /* install pairwise key */ 2273 2274 ni = ieee80211_find_vap_node(&ic->ic_sta, vap, mac); 2275 if (!ni) { 2276 printf("ieee80211_find_vap_node return 0\n"); 2277 return 0; 2278 } 2279 rni = (struct rt2860_softc_node *) ni; 2280 2281 vapid = 0; 2282 wcid = rni->staid; 2283 key_base = RT2860_REG_PKEY(wcid); 2284 2285 ieee80211_free_node(ni); 2286 2287 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP) 2288 { 2289 memset(iv, 0, 8); 2290 2291 iv[3] = (k->wk_keyix << 6); 2292 } 2293 else 2294 { 2295 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP) 2296 { 2297 iv[0] = (k->wk_keytsc >> 8); 2298 iv[1] = ((iv[0] | 0x20) & 0x7f); 2299 iv[2] = k->wk_keytsc; 2300 } 2301 else 2302 { 2303 /* AES CCMP */ 2304 2305 iv[0] = k->wk_keytsc; 2306 iv[1] = k->wk_keytsc >> 8; 2307 iv[2] = 0; 2308 } 2309 2310 iv[3] = ((k->wk_keyix << 6) | IEEE80211_WEP_EXTIV); 2311 iv[4] = (k->wk_keytsc >> 16); 2312 iv[5] = (k->wk_keytsc >> 24); 2313 iv[6] = (k->wk_keytsc >> 32); 2314 iv[7] = (k->wk_keytsc >> 40); 2315 2316 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY, 2317 "%s: VAP key set: iv=%02x %02x %02x %02x %02x %02x %02x %02x\n", 2318 device_get_nameunit(sc->dev), 2319 iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]); 2320 } 2321 2322 rt2860_io_mac_write_multi(sc, RT2860_REG_IVEIV(wcid), iv, 8); 2323 2324 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP) 2325 { 2326 rt2860_io_mac_write_multi(sc, key_base, k->wk_key, 16); 2327 2328 if (vap->iv_opmode != IEEE80211_M_HOSTAP) 2329 { 2330 rt2860_io_mac_write_multi(sc, key_base + 16, &k->wk_key[16], 8); 2331 rt2860_io_mac_write_multi(sc, key_base + 24, &k->wk_key[24], 8); 2332 } 2333 else 2334 { 2335 rt2860_io_mac_write_multi(sc, key_base + 16, &k->wk_key[24], 8); 2336 rt2860_io_mac_write_multi(sc, key_base + 24, &k->wk_key[16], 8); 2337 } 2338 } 2339 else 2340 { 2341 rt2860_io_mac_write_multi(sc, key_base, k->wk_key, k->wk_keylen); 2342 } 2343 2344 tmp = ((vapid & RT2860_REG_VAP_MASK) << RT2860_REG_VAP_SHIFT) | 2345 (mode << RT2860_REG_CIPHER_MODE_SHIFT) | RT2860_REG_PKEY_ENABLE; 2346 2347 rt2860_io_mac_write(sc, RT2860_REG_WCID_ATTR(wcid), tmp); 2348 } 2349 2350 if ((k->wk_flags & IEEE80211_KEY_GROUP) || 2351 (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP)) 2352 { 2353 /* install group key */ 2354 2355 vapid = 0; 2356 wcid = RT2860_WCID_MCAST; 2357 key_base = RT2860_REG_SKEY(vapid, k->wk_keyix); 2358 keymode_base = RT2860_REG_SKEY_MODE(vapid); 2359 2360 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP) 2361 { 2362 rt2860_io_mac_write_multi(sc, key_base, k->wk_key, 16); 2363 2364 if (vap->iv_opmode != IEEE80211_M_HOSTAP) 2365 { 2366 rt2860_io_mac_write_multi(sc, key_base + 16, &k->wk_key[16], 8); 2367 rt2860_io_mac_write_multi(sc, key_base + 24, &k->wk_key[24], 8); 2368 } 2369 else 2370 { 2371 rt2860_io_mac_write_multi(sc, key_base + 16, &k->wk_key[24], 8); 2372 rt2860_io_mac_write_multi(sc, key_base + 24, &k->wk_key[16], 8); 2373 } 2374 } 2375 else 2376 { 2377 rt2860_io_mac_write_multi(sc, key_base, k->wk_key, k->wk_keylen); 2378 } 2379 2380 tmp = rt2860_io_mac_read(sc, keymode_base); 2381 2382 tmp &= ~(0xf << (k->wk_keyix * 4 + 16 * (vapid % 2))); 2383 tmp |= (mode << (k->wk_keyix * 4 + 16 * (vapid % 2))); 2384 2385 rt2860_io_mac_write(sc, keymode_base, tmp); 2386 2387 if (vap->iv_opmode == IEEE80211_M_HOSTAP) 2388 { 2389 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP) 2390 { 2391 memset(iv, 0, 8); 2392 2393 iv[3] = (k->wk_keyix << 6); 2394 } 2395 else 2396 { 2397 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP) 2398 { 2399 iv[0] = (k->wk_keytsc >> 8); 2400 iv[1] = ((iv[0] | 0x20) & 0x7f); 2401 iv[2] = k->wk_keytsc; 2402 } 2403 else 2404 { 2405 /* AES CCMP */ 2406 2407 iv[0] = k->wk_keytsc; 2408 iv[1] = k->wk_keytsc >> 8; 2409 iv[2] = 0; 2410 } 2411 2412 iv[3] = ((k->wk_keyix << 6) | IEEE80211_WEP_EXTIV); 2413 iv[4] = (k->wk_keytsc >> 16); 2414 iv[5] = (k->wk_keytsc >> 24); 2415 iv[6] = (k->wk_keytsc >> 32); 2416 iv[7] = (k->wk_keytsc >> 40); 2417 2418 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY, 2419 "%s: VAP key set: iv=%02x %02x %02x %02x %02x %02x %02x %02x\n", 2420 device_get_nameunit(sc->dev), 2421 iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]); 2422 } 2423 2424 rt2860_io_mac_write_multi(sc, RT2860_REG_IVEIV(wcid), iv, 8); 2425 2426 tmp = ((vapid & RT2860_REG_VAP_MASK) << RT2860_REG_VAP_SHIFT) | 2427 (mode << RT2860_REG_CIPHER_MODE_SHIFT); 2428 2429 rt2860_io_mac_write(sc, RT2860_REG_WCID_ATTR(wcid), tmp); 2430 } 2431 } 2432 2433 return 1; 2434} 2435 2436/* 2437 * rt2860_vap_key_delete 2438 */ 2439static int rt2860_vap_key_delete(struct ieee80211vap *vap, 2440 const struct ieee80211_key *k) 2441{ 2442 struct rt2860_softc *sc; 2443 struct ieee80211com *ic; 2444 struct ifnet *ifp; 2445 uint8_t vapid, wcid; 2446 uint32_t tmp; 2447 2448 ic = vap->iv_ic; 2449 ifp = ic->ic_ifp; 2450 sc = ifp->if_softc; 2451 2452 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY, 2453 "%s: VAP key delete: keyix=%d, keylen=%d, macaddr=%s, group=%d\n", 2454 device_get_nameunit(sc->dev), k->wk_keyix, k->wk_keylen, ether_sprintf(k->wk_macaddr), 2455 (k->wk_flags & IEEE80211_KEY_GROUP) ? 1 : 0); 2456 2457 if (k->wk_flags & IEEE80211_KEY_GROUP) 2458 { 2459 /* remove group key */ 2460 2461 vapid = 0; 2462 wcid = RT2860_WCID_MCAST; 2463 2464 tmp = rt2860_io_mac_read(sc, RT2860_REG_SKEY_MODE(vapid)); 2465 2466 tmp &= ~(0xf << (k->wk_keyix * 4 + 16 * (vapid % 2))); 2467 tmp |= (RT2860_REG_CIPHER_MODE_NONE << (k->wk_keyix * 4 + 16 * (vapid % 2))); 2468 2469 rt2860_io_mac_write(sc, RT2860_REG_SKEY_MODE(vapid), tmp); 2470 2471 if (vap->iv_opmode == IEEE80211_M_HOSTAP) 2472 { 2473 tmp = ((vapid & RT2860_REG_VAP_MASK) << RT2860_REG_VAP_SHIFT) | 2474 (RT2860_REG_CIPHER_MODE_NONE << RT2860_REG_CIPHER_MODE_SHIFT) | RT2860_REG_PKEY_ENABLE; 2475 2476 rt2860_io_mac_write(sc, RT2860_REG_WCID_ATTR(wcid), tmp); 2477 } 2478 } 2479 2480 return 1; 2481} 2482 2483/* 2484 * rt2860_vap_update_beacon 2485 */ 2486static void rt2860_vap_update_beacon(struct ieee80211vap *vap, int what) 2487{ 2488 struct rt2860_softc *sc; 2489 struct ieee80211com *ic; 2490 struct ifnet *ifp; 2491 struct rt2860_softc_vap *rvap; 2492 struct mbuf *m; 2493 struct ieee80211_beacon_offsets *bo; 2494 int error; 2495 2496 ic = vap->iv_ic; 2497 ifp = ic->ic_ifp; 2498 sc = ifp->if_softc; 2499 rvap = (struct rt2860_softc_vap *) vap; 2500 m = rvap->beacon_mbuf; 2501 bo = &rvap->beacon_offsets; 2502 2503 RT2860_DPRINTF(sc, RT2860_DEBUG_BEACON, 2504 "%s: VAP update beacon: what=%d\n", 2505 device_get_nameunit(sc->dev), what); 2506 2507 setbit(bo->bo_flags, what); 2508 2509 if (m == NULL) 2510 { 2511 error = rt2860_beacon_alloc(sc, vap); 2512 if (error != 0) 2513 return; 2514 2515 m = rvap->beacon_mbuf; 2516 } 2517 2518 ieee80211_beacon_update(vap->iv_bss, bo, m, 0); 2519 2520 rt2860_asic_update_beacon(sc, vap); 2521} 2522 2523/* 2524 * rt2860_media_change 2525 */ 2526static int rt2860_media_change(struct ifnet *ifp) 2527{ 2528 int error; 2529 2530 error = ieee80211_media_change(ifp); 2531 2532 return (error == ENETRESET ? 0 : error); 2533} 2534 2535/* 2536 * rt2860_node_alloc 2537 */ 2538static struct ieee80211_node *rt2860_node_alloc(struct ieee80211vap *vap, 2539 const uint8_t mac[IEEE80211_ADDR_LEN]) 2540{ 2541 return malloc(sizeof(struct rt2860_softc_node), 2542 M_80211_NODE, M_NOWAIT | M_ZERO); 2543} 2544 2545/* 2546 * rt2860_node_cleanup 2547 */ 2548static void rt2860_node_cleanup(struct ieee80211_node *ni) 2549{ 2550 struct rt2860_softc *sc; 2551 struct ieee80211com *ic; 2552 struct ifnet *ifp; 2553 struct rt2860_softc_node *rni; 2554 uint8_t vapid, wcid; 2555 uint32_t tmp; 2556 2557 ic = ni->ni_ic; 2558 ifp = ic->ic_ifp; 2559 sc = ifp->if_softc; 2560 rni = (struct rt2860_softc_node *) ni; 2561 2562 RT2860_DPRINTF(sc, RT2860_DEBUG_NODE, 2563 "%s: node cleanup: macaddr=%s, associd=0x%04x, staid=0x%02x\n", 2564 device_get_nameunit(sc->dev), ether_sprintf(ni->ni_macaddr), 2565 ni->ni_associd, rni->staid); 2566 2567 if (rni->staid != 0) 2568 { 2569 vapid = 0; 2570 wcid = rni->staid; 2571 2572 tmp = ((vapid & RT2860_REG_VAP_MASK) << RT2860_REG_VAP_SHIFT) | 2573 (RT2860_REG_CIPHER_MODE_NONE << RT2860_REG_CIPHER_MODE_SHIFT) | RT2860_REG_PKEY_ENABLE; 2574 2575 rt2860_io_mac_write(sc, RT2860_REG_WCID_ATTR(wcid), tmp); 2576 2577 rt2860_io_mac_write(sc, RT2860_REG_WCID(wcid), 0x00000000); 2578 rt2860_io_mac_write(sc, RT2860_REG_WCID(wcid) + 4, 0x00000000); 2579 2580 rt2860_staid_delete(sc, rni->staid); 2581 2582 rni->staid = 0; 2583 } 2584 2585 sc->node_cleanup(ni); 2586} 2587 2588/* 2589 * rt2860_node_getmimoinfo 2590 */ 2591static void rt2860_node_getmimoinfo(const struct ieee80211_node *ni, 2592 struct ieee80211_mimo_info *mi) 2593{ 2594 const struct rt2860_softc_node *rni; 2595 int i; 2596 2597 rni = (const struct rt2860_softc_node *) ni; 2598 2599 for (i = 0; i < RT2860_SOFTC_RSSI_COUNT; i++) 2600 { 2601 mi->rssi[i] = rni->last_rssi_dbm[i]; 2602 mi->noise[i] = RT2860_NOISE_FLOOR; 2603 } 2604} 2605 2606/* 2607 * rt2860_setregdomain 2608 */ 2609static int rt2860_setregdomain(struct ieee80211com *ic, 2610 struct ieee80211_regdomain *reg, 2611 int nchans, struct ieee80211_channel chans[]) 2612{ 2613 struct rt2860_softc *sc; 2614 struct ifnet *ifp; 2615 2616 ifp = ic->ic_ifp; 2617 sc = ifp->if_softc; 2618 2619 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE, 2620 "%s: set regulatory domain: country=%d, country code string=%c%c, location=%c\n", 2621 device_get_nameunit(sc->dev), 2622 reg->country, reg->isocc[0], reg->isocc[1], reg->location); 2623 2624 return 0; 2625} 2626 2627/* 2628 * rt2860_getradiocaps 2629 */ 2630static void rt2860_getradiocaps(struct ieee80211com *ic, 2631 int maxchans, int *nchans, struct ieee80211_channel chans[]) 2632{ 2633 *nchans = (ic->ic_nchans >= maxchans) ? maxchans : ic->ic_nchans; 2634 2635 memcpy(chans, ic->ic_channels, (*nchans) * sizeof(struct ieee80211_channel)); 2636} 2637 2638/* 2639 * rt2860_scan_start 2640 */ 2641static void rt2860_scan_start(struct ieee80211com *ic) 2642{ 2643 struct rt2860_softc *sc; 2644 struct ifnet *ifp; 2645 2646 ifp = ic->ic_ifp; 2647 sc = ifp->if_softc; 2648 2649 rt2860_asic_disable_tsf_sync(sc); 2650} 2651 2652/* 2653 * rt2860_scan_end 2654 */ 2655static void rt2860_scan_end(struct ieee80211com *ic) 2656{ 2657 struct rt2860_softc *sc; 2658 struct ifnet *ifp; 2659 2660 ifp = ic->ic_ifp; 2661 sc = ifp->if_softc; 2662 2663 rt2860_asic_enable_tsf_sync(sc); 2664} 2665 2666/* 2667 * rt2860_set_channel 2668 */ 2669static void rt2860_set_channel(struct ieee80211com *ic) 2670{ 2671 struct rt2860_softc *sc; 2672 struct ifnet *ifp; 2673 2674 ifp = ic->ic_ifp; 2675 sc = ifp->if_softc; 2676 2677 RT2860_DPRINTF(sc, RT2860_DEBUG_CHAN, 2678 "%s: set channel: channel=%u, HT%s%s\n", 2679 device_get_nameunit(sc->dev), 2680 ieee80211_chan2ieee(ic, ic->ic_curchan), 2681 !IEEE80211_IS_CHAN_HT(ic->ic_curchan) ? " disabled" : 2682 IEEE80211_IS_CHAN_HT20(ic->ic_curchan) ? "20": 2683 IEEE80211_IS_CHAN_HT40U(ic->ic_curchan) ? "40U" : "40D", 2684 (ic->ic_flags & IEEE80211_F_SCAN) ? ", scanning" : ""); 2685 2686 RT2860_SOFTC_LOCK(sc); 2687 2688 rt2860_rf_set_chan(sc, ic->ic_curchan); 2689 2690 RT2860_SOFTC_UNLOCK(sc); 2691} 2692 2693/* 2694 * rt2860_newassoc 2695 */ 2696static void rt2860_newassoc(struct ieee80211_node *ni, int isnew) 2697{ 2698 struct rt2860_softc *sc; 2699 struct ieee80211com *ic; 2700 struct ifnet *ifp; 2701 struct ieee80211vap *vap; 2702 struct rt2860_softc_vap *rvap; 2703 struct rt2860_softc_node *rni; 2704 uint16_t aid; 2705 uint8_t wcid; 2706 uint32_t tmp; 2707 2708 vap = ni->ni_vap; 2709 ic = vap->iv_ic; 2710 ifp = ic->ic_ifp; 2711 sc = ifp->if_softc; 2712 rvap = (struct rt2860_softc_vap *) vap; 2713 rni = (struct rt2860_softc_node *) ni; 2714 2715 if (isnew) 2716 { 2717 aid = IEEE80211_AID(ni->ni_associd); 2718 rni->staid = rt2860_staid_alloc(sc, aid); 2719 wcid = rni->staid; 2720 2721 tmp = (ni->ni_macaddr[3] << 24) | 2722 (ni->ni_macaddr[2] << 16) | 2723 (ni->ni_macaddr[1] << 8) | 2724 ni->ni_macaddr[0]; 2725 2726 rt2860_io_mac_write(sc, RT2860_REG_WCID(wcid), tmp); 2727 2728 tmp = (ni->ni_macaddr[5] << 8) | 2729 ni->ni_macaddr[4]; 2730 2731 rt2860_io_mac_write(sc, RT2860_REG_WCID(wcid) + 4, tmp); 2732 2733 rt2860_amrr_node_init(&rvap->amrr, &sc->amrr_node[wcid], ni); 2734 2735 RT2860_DPRINTF(sc, RT2860_DEBUG_RATE, 2736 "%s: initial%s node Tx rate: associd=0x%04x, rate=0x%02x, max rate=0x%02x\n", 2737 device_get_nameunit(sc->dev), 2738 (ni->ni_flags & IEEE80211_NODE_HT) ? " HT" : "", 2739 ni->ni_associd, ni->ni_txrate, 2740 (ni->ni_flags & IEEE80211_NODE_HT) ? 2741 (ni->ni_htrates.rs_rates[ni->ni_htrates.rs_nrates - 1] | IEEE80211_RATE_MCS) : 2742 (ni->ni_rates.rs_rates[ni->ni_rates.rs_nrates - 1] & IEEE80211_RATE_VAL)); 2743 2744 rt2860_asic_updateprot(sc); 2745 rt2860_asic_updateslot(sc); 2746 rt2860_asic_set_txpreamble(sc); 2747 } 2748 2749 RT2860_DPRINTF(sc, RT2860_DEBUG_NODE, 2750 "%s: new association: isnew=%d, macaddr=%s, associd=0x%04x, staid=0x%02x, QoS %s, ERP %s, HT %s\n", 2751 device_get_nameunit(sc->dev), isnew, ether_sprintf(ni->ni_macaddr), 2752 ni->ni_associd, rni->staid, 2753 (ni->ni_flags & IEEE80211_NODE_QOS) ? "enabled" : "disabled", 2754 (ni->ni_flags & IEEE80211_NODE_ERP) ? "enabled" : "disabled", 2755 (ni->ni_flags & IEEE80211_NODE_HT) ? "enabled" : "disabled"); 2756} 2757 2758/* 2759 * rt2860_updateslot 2760 */ 2761static void rt2860_updateslot(struct ifnet *ifp) 2762{ 2763 struct rt2860_softc *sc; 2764 2765 sc = ifp->if_softc; 2766 2767 rt2860_asic_updateslot(sc); 2768} 2769 2770/* 2771 * rt2860_update_promisc 2772 */ 2773static void rt2860_update_promisc(struct ifnet *ifp) 2774{ 2775 struct rt2860_softc *sc; 2776 2777 sc = ifp->if_softc; 2778 2779 rt2860_asic_update_promisc(sc); 2780} 2781 2782/* 2783 * rt2860_update_mcast 2784 */ 2785static void rt2860_update_mcast(struct ifnet *ifp) 2786{ 2787 struct rt2860_softc *sc; 2788 2789 sc = ifp->if_softc; 2790} 2791 2792/* 2793 * rt2860_wme_update 2794 */ 2795static int rt2860_wme_update(struct ieee80211com *ic) 2796{ 2797 struct rt2860_softc *sc; 2798 struct ifnet *ifp; 2799 2800 ifp = ic->ic_ifp; 2801 sc = ifp->if_softc; 2802 2803 rt2860_asic_wme_update(sc); 2804 2805 return 0; 2806} 2807 2808/* 2809 * rt2860_raw_xmit 2810 */ 2811static int rt2860_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 2812 const struct ieee80211_bpf_params *params) 2813{ 2814 struct rt2860_softc *sc; 2815 struct ieee80211com *ic; 2816 struct ifnet *ifp; 2817 2818 ic = ni->ni_ic; 2819 ifp = ic->ic_ifp; 2820 sc = ifp->if_softc; 2821 2822 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) 2823 { 2824 m_freem(m); 2825 ieee80211_free_node(ni); 2826 2827 return ENETDOWN; 2828 } 2829 2830 RT2860_SOFTC_TX_RING_LOCK(&sc->tx_ring[sc->tx_ring_mgtqid]); 2831 2832 if (sc->tx_ring[sc->tx_ring_mgtqid].data_queued >= RT2860_SOFTC_TX_RING_DATA_COUNT) 2833 { 2834 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[sc->tx_ring_mgtqid]); 2835 2836 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 2837 "%s: raw xmit: Tx ring with qid=%d is full\n", 2838 device_get_nameunit(sc->dev), sc->tx_ring_mgtqid); 2839 2840 ifp->if_drv_flags |= IFF_DRV_OACTIVE; 2841 2842 m_freem(m); 2843 ieee80211_free_node(ni); 2844 2845 sc->tx_data_queue_full[sc->tx_ring_mgtqid]++; 2846 2847 return ENOBUFS; 2848 } 2849 2850 if (rt2860_tx_mgmt(sc, m, ni, sc->tx_ring_mgtqid) != 0) 2851 { 2852 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[sc->tx_ring_mgtqid]); 2853 2854 ifp->if_oerrors++; 2855 2856 ieee80211_free_node(ni); 2857 2858 return EIO; 2859 } 2860 2861 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[sc->tx_ring_mgtqid]); 2862 2863 sc->tx_timer = RT2860_TX_WATCHDOG_TIMEOUT; 2864 2865 return 0; 2866} 2867 2868/* 2869 * rt2860_recv_action 2870 */ 2871static int rt2860_recv_action(struct ieee80211_node *ni, 2872 const struct ieee80211_frame *wh, 2873 const uint8_t *frm, const uint8_t *efrm) 2874{ 2875 struct rt2860_softc *sc; 2876 struct ieee80211com *ic; 2877 struct ifnet *ifp; 2878 struct rt2860_softc_node *rni; 2879 const struct ieee80211_action *ia; 2880 uint16_t baparamset; 2881 uint8_t wcid; 2882 int tid; 2883 2884 ic = ni->ni_ic; 2885 ifp = ic->ic_ifp; 2886 sc = ifp->if_softc; 2887 rni = (struct rt2860_softc_node *) ni; 2888 2889 ia = (const struct ieee80211_action *) frm; 2890 2891 if (ia->ia_category == IEEE80211_ACTION_CAT_BA) 2892 { 2893 switch (ia->ia_action) 2894 { 2895 /* IEEE80211_ACTION_BA_DELBA */ 2896 case IEEE80211_ACTION_BA_DELBA: 2897 baparamset = LE_READ_2(frm + 2); 2898 tid = RT2860_MS(baparamset, IEEE80211_BAPS_TID); 2899 wcid = rni->staid; 2900 2901 RT2860_DPRINTF(sc, RT2860_DEBUG_BA, 2902 "%s: received DELBA request: associd=0x%04x, staid=0x%02x, tid=%d\n", 2903 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, tid); 2904 2905 if (rni->staid != 0) 2906 rt2860_asic_del_ba_session(sc, wcid, tid); 2907 break; 2908 } 2909 } 2910 2911 return sc->recv_action(ni, wh, frm, efrm); 2912} 2913 2914/* 2915 * rt2860_send_action 2916 */ 2917static int rt2860_send_action(struct ieee80211_node *ni, 2918 int cat, int act, void *sa) 2919{ 2920 struct rt2860_softc *sc; 2921 struct ieee80211com *ic; 2922 struct ifnet *ifp; 2923 struct rt2860_softc_node *rni; 2924 uint16_t *args, status, baparamset; 2925 uint8_t wcid; 2926 int tid, bufsize; 2927 2928 ic = ni->ni_ic; 2929 ifp = ic->ic_ifp; 2930 sc = ifp->if_softc; 2931 rni = (struct rt2860_softc_node *) ni; 2932 2933 wcid = rni->staid; 2934 args = sa; 2935 2936 if (cat == IEEE80211_ACTION_CAT_BA) 2937 { 2938 switch (act) 2939 { 2940 /* IEEE80211_ACTION_BA_ADDBA_RESPONSE */ 2941 case IEEE80211_ACTION_BA_ADDBA_RESPONSE: 2942 status = args[1]; 2943 baparamset = args[2]; 2944 tid = RT2860_MS(baparamset, IEEE80211_BAPS_TID); 2945 bufsize = RT2860_MS(baparamset, IEEE80211_BAPS_BUFSIZ); 2946 2947 RT2860_DPRINTF(sc, RT2860_DEBUG_BA, 2948 "%s: sending ADDBA response: associd=0x%04x, staid=0x%02x, status=%d, tid=%d, bufsize=%d\n", 2949 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, status, tid, bufsize); 2950 2951 if (status == IEEE80211_STATUS_SUCCESS) 2952 rt2860_asic_add_ba_session(sc, wcid, tid); 2953 break; 2954 2955 /* IEEE80211_ACTION_BA_DELBA */ 2956 case IEEE80211_ACTION_BA_DELBA: 2957 baparamset = RT2860_SM(args[0], IEEE80211_DELBAPS_TID) | args[1]; 2958 tid = RT2860_MS(baparamset, IEEE80211_DELBAPS_TID); 2959 2960 RT2860_DPRINTF(sc, RT2860_DEBUG_BA, 2961 "%s: sending DELBA request: associd=0x%04x, staid=0x%02x, tid=%d\n", 2962 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, tid); 2963 2964 if (RT2860_MS(baparamset, IEEE80211_DELBAPS_INIT) != IEEE80211_DELBAPS_INIT) 2965 rt2860_asic_del_ba_session(sc, wcid, tid); 2966 break; 2967 } 2968 } 2969 2970 return sc->send_action(ni, cat, act, sa); 2971} 2972 2973/* 2974 * rt2860_addba_response 2975 */ 2976static int rt2860_addba_response(struct ieee80211_node *ni, 2977 struct ieee80211_tx_ampdu *tap, 2978 int status, int baparamset, int batimeout) 2979{ 2980 struct rt2860_softc *sc; 2981 struct ieee80211com *ic; 2982 struct ifnet *ifp; 2983 struct rt2860_softc_node *rni; 2984 ieee80211_seq seqno; 2985 int ret, tid, old_bufsize, new_bufsize; 2986 2987 ic = ni->ni_ic; 2988 ifp = ic->ic_ifp; 2989 sc = ifp->if_softc; 2990 rni = (struct rt2860_softc_node *) ni; 2991 2992 tid = RT2860_MS(baparamset, IEEE80211_BAPS_TID); 2993 old_bufsize = RT2860_MS(baparamset, IEEE80211_BAPS_BUFSIZ); 2994 new_bufsize = old_bufsize; 2995 2996 if (status == IEEE80211_STATUS_SUCCESS) 2997 { 2998 if (sc->mac_rev >= 0x28830300) 2999 { 3000 if (sc->mac_rev >= 0x30700200) 3001 new_bufsize = 13; 3002 else 3003 new_bufsize = 31; 3004 } 3005 else if (sc->mac_rev >= 0x28720200) 3006 { 3007 new_bufsize = 13; 3008 } 3009 else 3010 { 3011 new_bufsize = 7; 3012 } 3013 3014 if (old_bufsize > new_bufsize) 3015 { 3016 baparamset &= ~IEEE80211_BAPS_BUFSIZ; 3017 baparamset = RT2860_SM(new_bufsize, IEEE80211_BAPS_BUFSIZ); 3018 } 3019 3020 if (!(tap->txa_flags & IEEE80211_AGGR_RUNNING)) 3021 { 3022 sc->tx_ampdu_sessions++; 3023 3024 if (sc->tx_ampdu_sessions == 1) 3025 rt2860_asic_updateprot(sc); 3026 } 3027 } 3028 3029 RT2860_DPRINTF(sc, RT2860_DEBUG_BA, 3030 "%s: received ADDBA response: associd=0x%04x, staid=0x%02x, status=%d, tid=%d, " 3031 "old bufsize=%d, new bufsize=%d\n", 3032 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, status, tid, 3033 old_bufsize, new_bufsize); 3034 3035 ret = sc->addba_response(ni, tap, status, baparamset, batimeout); 3036 3037 if (status == IEEE80211_STATUS_SUCCESS) 3038 { 3039 seqno = ni->ni_txseqs[tid]; 3040 3041 rt2860_send_bar(ni, tap, seqno); 3042 } 3043 3044 return ret; 3045} 3046 3047/* 3048 * rt2860_addba_stop 3049 */ 3050static void rt2860_addba_stop(struct ieee80211_node *ni, 3051 struct ieee80211_tx_ampdu *tap) 3052{ 3053 struct rt2860_softc *sc; 3054 struct ieee80211com *ic; 3055 struct ifnet *ifp; 3056 struct rt2860_softc_node *rni; 3057 int tid; 3058 3059 ic = ni->ni_ic; 3060 ifp = ic->ic_ifp; 3061 sc = ifp->if_softc; 3062 rni = (struct rt2860_softc_node *) ni; 3063 3064 tid = WME_AC_TO_TID(tap->txa_ac); 3065 3066 RT2860_DPRINTF(sc, RT2860_DEBUG_BA, 3067 "%s: stopping A-MPDU Tx: associd=0x%04x, staid=0x%02x, tid=%d\n", 3068 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, tid); 3069 3070 if (tap->txa_flags & IEEE80211_AGGR_RUNNING) 3071 { 3072 if (sc->tx_ampdu_sessions > 0) 3073 { 3074 sc->tx_ampdu_sessions--; 3075 3076 if (sc->tx_ampdu_sessions == 0) 3077 rt2860_asic_updateprot(sc); 3078 } 3079 else 3080 { 3081 printf("%s: number of A-MPDU Tx sessions cannot be negative\n", 3082 device_get_nameunit(sc->dev)); 3083 } 3084 } 3085 3086 sc->addba_stop(ni, tap); 3087} 3088 3089/* 3090 * rt2860_ampdu_rx_start 3091 */ 3092static int rt2860_ampdu_rx_start(struct ieee80211_node *ni, 3093 struct ieee80211_rx_ampdu *rap, 3094 int baparamset, int batimeout, int baseqctl) 3095{ 3096 struct rt2860_softc *sc; 3097 struct ieee80211com *ic; 3098 struct ifnet *ifp; 3099 struct rt2860_softc_node *rni; 3100 int tid; 3101 3102 ic = ni->ni_ic; 3103 ifp = ic->ic_ifp; 3104 sc = ifp->if_softc; 3105 rni = (struct rt2860_softc_node *) ni; 3106 3107 tid = RT2860_MS(baparamset, IEEE80211_BAPS_TID); 3108 3109 RT2860_DPRINTF(sc, RT2860_DEBUG_BA, 3110 "%s: starting A-MPDU Rx: associd=0x%04x, staid=0x%02x, tid=%d\n", 3111 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, tid); 3112 3113 if (!(rap->rxa_flags & IEEE80211_AGGR_RUNNING)) 3114 sc->rx_ampdu_sessions++; 3115 3116 return sc->ampdu_rx_start(ni, rap, baparamset, batimeout, baseqctl); 3117} 3118 3119/* 3120 * rt2860_ampdu_rx_stop 3121 */ 3122static void rt2860_ampdu_rx_stop(struct ieee80211_node *ni, 3123 struct ieee80211_rx_ampdu *rap) 3124{ 3125 struct rt2860_softc *sc; 3126 struct ieee80211com *ic; 3127 struct ifnet *ifp; 3128 struct rt2860_softc_node *rni; 3129 3130 ic = ni->ni_ic; 3131 ifp = ic->ic_ifp; 3132 sc = ifp->if_softc; 3133 rni = (struct rt2860_softc_node *) ni; 3134 3135 RT2860_DPRINTF(sc, RT2860_DEBUG_BA, 3136 "%s: stopping A-MPDU Rx: associd=0x%04x, staid=0x%02x\n", 3137 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid); 3138 3139 if (rap->rxa_flags & IEEE80211_AGGR_RUNNING) 3140 { 3141 if (sc->rx_ampdu_sessions > 0) 3142 sc->rx_ampdu_sessions--; 3143 else 3144 printf("%s: number of A-MPDU Rx sessions cannot be negative\n", 3145 device_get_nameunit(sc->dev)); 3146 } 3147 3148 sc->ampdu_rx_stop(ni, rap); 3149} 3150 3151/* 3152 * rt2860_send_bar 3153 */ 3154static int rt2860_send_bar(struct ieee80211_node *ni, 3155 struct ieee80211_tx_ampdu *tap, ieee80211_seq seqno) 3156{ 3157 struct rt2860_softc *sc; 3158 struct ieee80211com *ic; 3159 struct ifnet *ifp; 3160 struct ieee80211vap *vap; 3161 struct ieee80211_frame_bar *bar; 3162 struct rt2860_softc_node *rni; 3163 struct mbuf *m; 3164 uint16_t barctl, barseqctl; 3165 uint8_t *frm; 3166 int ret, tid; 3167 3168 ic = ni->ni_ic; 3169 ifp = ic->ic_ifp; 3170 sc = ifp->if_softc; 3171 vap = ni->ni_vap; 3172 rni = (struct rt2860_softc_node *) ni; 3173 3174 if (!(tap->txa_flags & IEEE80211_AGGR_RUNNING)) 3175 return EINVAL; 3176 3177 m = ieee80211_getmgtframe(&frm, ic->ic_headroom, sizeof(struct ieee80211_frame_bar)); 3178 if (m == NULL) 3179 return ENOMEM; 3180 3181 bar = mtod(m, struct ieee80211_frame_bar *); 3182 3183 bar->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_CTL | IEEE80211_FC0_SUBTYPE_BAR; 3184 bar->i_fc[1] = 0; 3185 3186 IEEE80211_ADDR_COPY(bar->i_ra, ni->ni_macaddr); 3187 IEEE80211_ADDR_COPY(bar->i_ta, vap->iv_myaddr); 3188 3189 tid = WME_AC_TO_TID(tap->txa_ac); 3190 3191 barctl = (tap->txa_flags & IEEE80211_AGGR_IMMEDIATE ? 0 : IEEE80211_BAR_NOACK) | 3192 IEEE80211_BAR_COMP | 3193 RT2860_SM(tid, IEEE80211_BAR_TID); 3194 barseqctl = RT2860_SM(seqno, IEEE80211_BAR_SEQ_START); 3195 3196 bar->i_ctl = htole16(barctl); 3197 bar->i_seq = htole16(barseqctl); 3198 3199 m->m_pkthdr.len = m->m_len = sizeof(struct ieee80211_frame_bar); 3200 3201 tap->txa_start = seqno; 3202 3203 ieee80211_ref_node(ni); 3204 3205 RT2860_DPRINTF(sc, RT2860_DEBUG_BA, 3206 "%s: sending BAR: associd=0x%04x, staid=0x%02x, tid=%d, seqno=%d\n", 3207 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, tid, seqno); 3208 3209 ret = ic->ic_raw_xmit(ni, m, NULL); 3210 if (ret != 0) 3211 ieee80211_free_node(ni); 3212 3213 return ret; 3214} 3215 3216/* 3217 * rt2860_amrr_update_iter_func 3218 */ 3219static void rt2860_amrr_update_iter_func(void *arg, struct ieee80211_node *ni) 3220{ 3221 struct rt2860_softc *sc; 3222 struct ieee80211com *ic; 3223 struct ifnet *ifp; 3224 struct ieee80211vap *vap; 3225 struct rt2860_softc_vap *rvap; 3226 struct rt2860_softc_node *rni; 3227 uint8_t wcid; 3228 3229 vap = arg; 3230 ic = vap->iv_ic; 3231 ifp = ic->ic_ifp; 3232 sc = ifp->if_softc; 3233 rvap = (struct rt2860_softc_vap *) vap; 3234 rni = (struct rt2860_softc_node *) ni; 3235 3236 /* only associated stations */ 3237 3238 if ((ni->ni_vap == vap) && (rni->staid != 0)) 3239 { 3240 wcid = rni->staid; 3241 3242 RT2860_DPRINTF(sc, RT2860_DEBUG_RATE, 3243 "%s: AMRR node: staid=0x%02x, txcnt=%d, success=%d, retrycnt=%d\n", 3244 device_get_nameunit(sc->dev), 3245 rni->staid, sc->amrr_node[wcid].txcnt, sc->amrr_node[wcid].success, sc->amrr_node[wcid].retrycnt); 3246 3247 rt2860_amrr_choose(ni, &sc->amrr_node[wcid]); 3248 3249 RT2860_DPRINTF(sc, RT2860_DEBUG_RATE, 3250 "%s:%s node Tx rate: associd=0x%04x, staid=0x%02x, rate=0x%02x, max rate=0x%02x\n", 3251 device_get_nameunit(sc->dev), 3252 (ni->ni_flags & IEEE80211_NODE_HT) ? " HT" : "", 3253 ni->ni_associd, rni->staid, ni->ni_txrate, 3254 (ni->ni_flags & IEEE80211_NODE_HT) ? 3255 (ni->ni_htrates.rs_rates[ni->ni_htrates.rs_nrates - 1] | IEEE80211_RATE_MCS) : 3256 (ni->ni_rates.rs_rates[ni->ni_rates.rs_nrates - 1] & IEEE80211_RATE_VAL)); 3257 } 3258} 3259 3260/* 3261 * rt2860_periodic 3262 */ 3263static void rt2860_periodic(void *arg) 3264{ 3265 struct rt2860_softc *sc; 3266 3267 sc = arg; 3268 3269 RT2860_DPRINTF(sc, RT2860_DEBUG_PERIODIC, 3270 "%s: periodic\n", 3271 device_get_nameunit(sc->dev)); 3272 3273 taskqueue_enqueue(sc->taskqueue, &sc->periodic_task); 3274} 3275 3276/* 3277 * rt2860_tx_watchdog 3278 */ 3279static void rt2860_tx_watchdog(void *arg) 3280{ 3281 struct rt2860_softc *sc; 3282 struct ifnet *ifp; 3283 3284 sc = arg; 3285 ifp = sc->ifp; 3286 3287 if (sc->tx_timer == 0) 3288 return; 3289 3290 if (--sc->tx_timer == 0) 3291 { 3292 printf("%s: Tx watchdog timeout: resetting\n", 3293 device_get_nameunit(sc->dev)); 3294 3295 rt2860_stop_locked(sc); 3296 rt2860_init_locked(sc); 3297 3298 ifp->if_oerrors++; 3299 3300 sc->tx_watchdog_timeouts++; 3301 } 3302 3303 callout_reset(&sc->tx_watchdog_ch, hz, rt2860_tx_watchdog, sc); 3304} 3305 3306/* 3307 * rt2860_staid_alloc 3308 */ 3309static int rt2860_staid_alloc(struct rt2860_softc *sc, int aid) 3310{ 3311 int staid; 3312 3313 if ((aid > 0 && aid < RT2860_SOFTC_STAID_COUNT) && isclr(sc->staid_mask, aid)) 3314 { 3315 staid = aid; 3316 } 3317 else 3318 { 3319 for (staid = 1; staid < RT2860_SOFTC_STAID_COUNT; staid++) 3320 { 3321 if (isclr(sc->staid_mask, staid)) 3322 break; 3323 } 3324 } 3325 3326 setbit(sc->staid_mask, staid); 3327 3328 return staid; 3329} 3330 3331/* 3332 * rt2860_staid_delete 3333 */ 3334static void rt2860_staid_delete(struct rt2860_softc *sc, int staid) 3335{ 3336 clrbit(sc->staid_mask, staid); 3337} 3338 3339/* 3340 * rt2860_asic_set_bssid 3341 */ 3342static void rt2860_asic_set_bssid(struct rt2860_softc *sc, 3343 const uint8_t *bssid) 3344{ 3345 uint32_t tmp; 3346 3347 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE, 3348 "%s: set bssid: bssid=%s\n", 3349 device_get_nameunit(sc->dev), 3350 ether_sprintf(bssid)); 3351 3352 tmp = bssid[0] | (bssid[1]) << 8 | (bssid[2] << 16) | (bssid[3] << 24); 3353 3354 rt2860_io_mac_write(sc, RT2860_REG_BSSID_DW0, tmp); 3355 3356 tmp = bssid[4] | (bssid[5] << 8); 3357 3358 rt2860_io_mac_write(sc, RT2860_REG_BSSID_DW1, tmp); 3359} 3360 3361/* 3362 * rt2860_asic_set_macaddr 3363 */ 3364static void rt2860_asic_set_macaddr(struct rt2860_softc *sc, 3365 const uint8_t *addr) 3366{ 3367 uint32_t tmp; 3368 3369 tmp = addr[0] | (addr[1] << 8) | (addr[2] << 16) | (addr[3] << 24); 3370 3371 rt2860_io_mac_write(sc, RT2860_REG_ADDR_DW0, tmp); 3372 3373 tmp = addr[4] | (addr[5] << 8) | (0xff << 16); 3374 3375 rt2860_io_mac_write(sc, RT2860_REG_ADDR_DW1, tmp); 3376} 3377 3378/* 3379 * rt2860_asic_enable_tsf_sync 3380 */ 3381static void rt2860_asic_enable_tsf_sync(struct rt2860_softc *sc) 3382{ 3383 struct ifnet *ifp; 3384 struct ieee80211com *ic; 3385 struct ieee80211vap *vap; 3386 uint32_t tmp; 3387 3388 ifp = sc->ifp; 3389 ic = ifp->if_l2com; 3390 vap = TAILQ_FIRST(&ic->ic_vaps); 3391 3392 RT2860_DPRINTF(sc, RT2860_DEBUG_BEACON, 3393 "%s: enabling TSF\n", 3394 device_get_nameunit(sc->dev)); 3395 3396 tmp = rt2860_io_mac_read(sc, RT2860_REG_BCN_TIME_CFG); 3397 3398 tmp &= ~0x1fffff; 3399 tmp |= vap->iv_bss->ni_intval * 16; 3400 tmp |= (RT2860_REG_TSF_TIMER_ENABLE | RT2860_REG_TBTT_TIMER_ENABLE); 3401 3402 if (vap->iv_opmode == IEEE80211_M_STA) 3403 { 3404 tmp |= (RT2860_REG_TSF_SYNC_MODE_STA << RT2860_REG_TSF_SYNC_MODE_SHIFT); 3405 } 3406 else if (vap->iv_opmode == IEEE80211_M_IBSS) 3407 { 3408 tmp |= RT2860_REG_BCN_TX_ENABLE; 3409 tmp |= (RT2860_REG_TSF_SYNC_MODE_IBSS << RT2860_REG_TSF_SYNC_MODE_SHIFT); 3410 } 3411 else if (vap->iv_opmode == IEEE80211_M_HOSTAP) 3412 { 3413 tmp |= RT2860_REG_BCN_TX_ENABLE; 3414 tmp |= (RT2860_REG_TSF_SYNC_MODE_HOSTAP << RT2860_REG_TSF_SYNC_MODE_SHIFT); 3415 } 3416 3417 rt2860_io_mac_write(sc, RT2860_REG_BCN_TIME_CFG, tmp); 3418} 3419 3420/* 3421 * rt2860_asic_disable_tsf_sync 3422 */ 3423static void rt2860_asic_disable_tsf_sync(struct rt2860_softc *sc) 3424{ 3425 uint32_t tmp; 3426 3427 RT2860_DPRINTF(sc, RT2860_DEBUG_BEACON, 3428 "%s: disabling TSF\n", 3429 device_get_nameunit(sc->dev)); 3430 3431 tmp = rt2860_io_mac_read(sc, RT2860_REG_BCN_TIME_CFG); 3432 3433 tmp &= ~(RT2860_REG_BCN_TX_ENABLE | 3434 RT2860_REG_TSF_TIMER_ENABLE | 3435 RT2860_REG_TBTT_TIMER_ENABLE); 3436 3437 tmp &= ~(RT2860_REG_TSF_SYNC_MODE_MASK << RT2860_REG_TSF_SYNC_MODE_SHIFT); 3438 tmp |= (RT2860_REG_TSF_SYNC_MODE_DISABLE << RT2860_REG_TSF_SYNC_MODE_SHIFT); 3439 3440 rt2860_io_mac_write(sc, RT2860_REG_BCN_TIME_CFG, tmp); 3441} 3442 3443/* 3444 * rt2860_asic_enable_mrr 3445 */ 3446static void rt2860_asic_enable_mrr(struct rt2860_softc *sc) 3447{ 3448#define CCK(mcs) (mcs) 3449#define OFDM(mcs) ((1 << 3) | (mcs)) 3450#define HT(mcs) (mcs) 3451 3452 rt2860_io_mac_write(sc, RT2860_REG_TX_LG_FBK_CFG0, 3453 (OFDM(6) << 28) | /* 54 -> 48 */ 3454 (OFDM(5) << 24) | /* 48 -> 36 */ 3455 (OFDM(4) << 20) | /* 36 -> 24 */ 3456 (OFDM(3) << 16) | /* 24 -> 18 */ 3457 (OFDM(2) << 12) | /* 18 -> 12 */ 3458 (OFDM(1) << 8) | /* 12 -> 9 */ 3459 (OFDM(0) << 4) | /* 9 -> 6 */ 3460 OFDM(0)); /* 6 -> 6 */ 3461 3462 rt2860_io_mac_write(sc, RT2860_REG_TX_LG_FBK_CFG1, 3463 (CCK(2) << 12) | /* 11 -> 5.5 */ 3464 (CCK(1) << 8) | /* 5.5 -> 2 */ 3465 (CCK(0) << 4) | /* 2 -> 1 */ 3466 CCK(0)); /* 1 -> 1 */ 3467 3468 rt2860_io_mac_write(sc, RT2860_REG_TX_HT_FBK_CFG0, 3469 (HT(6) << 28) | 3470 (HT(5) << 24) | 3471 (HT(4) << 20) | 3472 (HT(3) << 16) | 3473 (HT(2) << 12) | 3474 (HT(1) << 8) | 3475 (HT(0) << 4) | 3476 HT(0)); 3477 3478 rt2860_io_mac_write(sc, RT2860_REG_TX_HT_FBK_CFG1, 3479 (HT(14) << 28) | 3480 (HT(13) << 24) | 3481 (HT(12) << 20) | 3482 (HT(11) << 16) | 3483 (HT(10) << 12) | 3484 (HT(9) << 8) | 3485 (HT(8) << 4) | 3486 HT(7)); 3487 3488#undef HT 3489#undef OFDM 3490#undef CCK 3491} 3492 3493/* 3494 * rt2860_asic_set_txpreamble 3495 */ 3496static void rt2860_asic_set_txpreamble(struct rt2860_softc *sc) 3497{ 3498 struct ifnet *ifp; 3499 struct ieee80211com *ic; 3500 uint32_t tmp; 3501 3502 ifp = sc->ifp; 3503 ic = ifp->if_l2com; 3504 3505 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE, 3506 "%s: %s short Tx preamble\n", 3507 device_get_nameunit(sc->dev), 3508 (ic->ic_flags & IEEE80211_F_SHPREAMBLE) ? "enabling" : "disabling"); 3509 3510 tmp = rt2860_io_mac_read(sc, RT2860_REG_AUTO_RSP_CFG); 3511 3512 tmp &= ~RT2860_REG_CCK_SHORT_ENABLE; 3513 3514 if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) 3515 tmp |= RT2860_REG_CCK_SHORT_ENABLE; 3516 3517 rt2860_io_mac_write(sc, RT2860_REG_AUTO_RSP_CFG, tmp); 3518} 3519 3520/* 3521 * rt2860_asic_set_basicrates 3522 */ 3523static void rt2860_asic_set_basicrates(struct rt2860_softc *sc) 3524{ 3525 struct ifnet *ifp; 3526 struct ieee80211com *ic; 3527 3528 ifp = sc->ifp; 3529 ic = ifp->if_l2com; 3530 3531 if (ic->ic_curmode == IEEE80211_MODE_11B) 3532 rt2860_io_mac_write(sc, RT2860_REG_LEGACY_BASIC_RATE, 0xf); 3533 else if (ic->ic_curmode == IEEE80211_MODE_11A) 3534 rt2860_io_mac_write(sc, RT2860_REG_LEGACY_BASIC_RATE, 0x150); 3535 else 3536 rt2860_io_mac_write(sc, RT2860_REG_LEGACY_BASIC_RATE, 0x15f); 3537} 3538 3539/* 3540 * rt2860_asic_update_rtsthreshold 3541 */ 3542static void rt2860_asic_update_rtsthreshold(struct rt2860_softc *sc) 3543{ 3544 struct ifnet *ifp; 3545 struct ieee80211com *ic; 3546 struct ieee80211vap *vap; 3547 uint32_t tmp; 3548 uint16_t threshold; 3549 3550 ifp = sc->ifp; 3551 ic = ifp->if_l2com; 3552 vap = TAILQ_FIRST(&ic->ic_vaps); 3553 3554 if (vap == NULL) 3555 threshold = IEEE80211_RTS_MAX; 3556 else if (vap->iv_flags_ht & IEEE80211_FHT_AMSDU_TX) 3557 threshold = 0x1000; 3558 else 3559 threshold = vap->iv_rtsthreshold; 3560 3561 RT2860_DPRINTF(sc, RT2860_DEBUG_PROT, 3562 "%s: updating RTS threshold: %d\n", 3563 device_get_nameunit(sc->dev), threshold); 3564 3565 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_RTS_CFG); 3566 3567 tmp &= ~(RT2860_REG_TX_RTS_THRESHOLD_MASK << RT2860_REG_TX_RTS_THRESHOLD_SHIFT); 3568 3569 tmp |= ((threshold & RT2860_REG_TX_RTS_THRESHOLD_MASK) << 3570 RT2860_REG_TX_RTS_THRESHOLD_SHIFT); 3571 3572 rt2860_io_mac_write(sc, RT2860_REG_TX_RTS_CFG, tmp); 3573} 3574 3575/* 3576 * rt2860_asic_update_txpower 3577 */ 3578static void rt2860_asic_update_txpower(struct rt2860_softc *sc) 3579{ 3580 struct ifnet *ifp; 3581 struct ieee80211com *ic; 3582 uint32_t *txpow_rate; 3583 int8_t delta; 3584 uint8_t val; 3585 uint32_t tmp; 3586 int i; 3587 3588 ifp = sc->ifp; 3589 ic = ifp->if_l2com; 3590 3591 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE, 3592 "%s: updating Tx power: %d\n", 3593 device_get_nameunit(sc->dev), ic->ic_txpowlimit); 3594 3595 if (!IEEE80211_IS_CHAN_HT40(ic->ic_curchan)) 3596 { 3597 txpow_rate = sc->txpow_rate_20mhz; 3598 } 3599 else 3600 { 3601 if (IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan)) 3602 txpow_rate = sc->txpow_rate_40mhz_2ghz; 3603 else 3604 txpow_rate = sc->txpow_rate_40mhz_5ghz; 3605 } 3606 3607 delta = 0; 3608 3609 val = rt2860_io_bbp_read(sc, 1); 3610 val &= 0xfc; 3611 3612 if (ic->ic_txpowlimit > 90) 3613 { 3614 /* do nothing */ 3615 } 3616 else if (ic->ic_txpowlimit > 60) 3617 { 3618 delta -= 1; 3619 } 3620 else if (ic->ic_txpowlimit > 30) 3621 { 3622 delta -= 3; 3623 } 3624 else if (ic->ic_txpowlimit > 15) 3625 { 3626 val |= 0x1; 3627 } 3628 else if (ic->ic_txpowlimit > 9) 3629 { 3630 val |= 0x1; 3631 delta -= 3; 3632 } 3633 else 3634 { 3635 val |= 0x2; 3636 } 3637 3638 rt2860_io_bbp_write(sc, 1, val); 3639 3640 for (i = 0; i < RT2860_SOFTC_TXPOW_RATE_COUNT; i++) 3641 { 3642 if (txpow_rate[i] == 0xffffffff) 3643 continue; 3644 3645 tmp = rt2860_read_eeprom_txpow_rate_add_delta(txpow_rate[i], delta); 3646 3647 rt2860_io_mac_write(sc, RT2860_REG_TX_PWR_CFG(i), tmp); 3648 } 3649} 3650 3651/* 3652 * rt2860_asic_update_promisc 3653 */ 3654static void rt2860_asic_update_promisc(struct rt2860_softc *sc) 3655{ 3656 struct ifnet *ifp; 3657 uint32_t tmp; 3658 3659 ifp = sc->ifp; 3660 3661 printf("%s: %s promiscuous mode\n", 3662 device_get_nameunit(sc->dev), 3663 (ifp->if_flags & IFF_PROMISC) ? "entering" : "leaving"); 3664 3665 tmp = rt2860_io_mac_read(sc, RT2860_REG_RX_FILTER_CFG); 3666 3667 tmp &= ~RT2860_REG_RX_FILTER_DROP_UC_NOME; 3668 3669 if (!(ifp->if_flags & IFF_PROMISC)) 3670 tmp |= RT2860_REG_RX_FILTER_DROP_UC_NOME; 3671 3672 rt2860_io_mac_write(sc, RT2860_REG_RX_FILTER_CFG, tmp); 3673} 3674 3675/* 3676 * rt2860_asic_updateprot 3677 */ 3678static void rt2860_asic_updateprot(struct rt2860_softc *sc) 3679{ 3680 struct ifnet *ifp; 3681 struct ieee80211com *ic; 3682 struct ieee80211vap *vap; 3683 uint32_t cck_prot, ofdm_prot, mm20_prot, mm40_prot, gf20_prot, gf40_prot; 3684 uint8_t htopmode; 3685 enum ieee80211_protmode htprotmode; 3686 3687 ifp = sc->ifp; 3688 ic = ifp->if_l2com; 3689 vap = TAILQ_FIRST(&ic->ic_vaps); 3690 3691 /* CCK frame protection */ 3692 3693 cck_prot = RT2860_REG_RTSTH_ENABLE | RT2860_REG_PROT_NAV_SHORT | 3694 RT2860_REG_TXOP_ALLOW_ALL | RT2860_REG_PROT_CTRL_NONE; 3695 3696 /* set up protection frame phy mode and rate (MCS code) */ 3697 3698 if (ic->ic_curmode == IEEE80211_MODE_11A) 3699 cck_prot |= (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) | 3700 (0 << RT2860_REG_PROT_MCS_SHIFT); 3701 else 3702 cck_prot |= ((RT2860_REG_PROT_PHYMODE_CCK << RT2860_REG_PROT_PHYMODE_SHIFT) | 3703 (3 << RT2860_REG_PROT_MCS_SHIFT)); 3704 3705 rt2860_io_mac_write(sc, RT2860_REG_TX_CCK_PROT_CFG, cck_prot); 3706 3707 /* OFDM frame protection */ 3708 3709 ofdm_prot = RT2860_REG_RTSTH_ENABLE | RT2860_REG_PROT_NAV_SHORT | 3710 RT2860_REG_TXOP_ALLOW_ALL; 3711 3712 if (ic->ic_flags & IEEE80211_F_USEPROT) 3713 { 3714 RT2860_DPRINTF(sc, RT2860_DEBUG_PROT, 3715 "%s: updating protection mode: b/g protection mode=%s\n", 3716 device_get_nameunit(sc->dev), 3717 (ic->ic_protmode == IEEE80211_PROT_RTSCTS) ? "RTS/CTS" : 3718 ((ic->ic_protmode == IEEE80211_PROT_CTSONLY) ? "CTS-to-self" : "none")); 3719 3720 if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) 3721 ofdm_prot |= RT2860_REG_PROT_CTRL_RTS_CTS; 3722 else if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) 3723 ofdm_prot |= RT2860_REG_PROT_CTRL_CTS; 3724 else 3725 ofdm_prot |= RT2860_REG_PROT_CTRL_NONE; 3726 } 3727 else 3728 { 3729 RT2860_DPRINTF(sc, RT2860_DEBUG_PROT, 3730 "%s: updating protection mode: b/g protection mode=%s\n", 3731 device_get_nameunit(sc->dev), "none"); 3732 3733 ofdm_prot |= RT2860_REG_PROT_CTRL_NONE; 3734 } 3735 3736 rt2860_io_mac_write(sc, RT2860_REG_TX_OFDM_PROT_CFG, ofdm_prot); 3737 3738 /* HT frame protection */ 3739 3740 if ((vap != NULL) && (vap->iv_opmode == IEEE80211_M_STA) && (vap->iv_state == IEEE80211_S_RUN)) 3741 htopmode = vap->iv_bss->ni_htopmode; 3742 else 3743 htopmode = ic->ic_curhtprotmode; 3744 3745 htprotmode = ic->ic_htprotmode; 3746 3747 /* force HT mixed mode and RTS/CTS protection if A-MPDU Tx aggregation is enabled */ 3748 3749 if (sc->tx_ampdu_sessions > 0) 3750 { 3751 RT2860_DPRINTF(sc, RT2860_DEBUG_PROT, 3752 "%s: updating protection mode: forcing HT mixed mode and RTS/CTS protection\n", 3753 device_get_nameunit(sc->dev)); 3754 3755 htopmode = IEEE80211_HTINFO_OPMODE_MIXED; 3756 htprotmode = IEEE80211_PROT_RTSCTS; 3757 } 3758 3759 RT2860_DPRINTF(sc, RT2860_DEBUG_PROT, 3760 "%s: updating protection mode: HT operation mode=0x%02x, protection mode=%s\n", 3761 device_get_nameunit(sc->dev), 3762 htopmode & IEEE80211_HTINFO_OPMODE, 3763 (htprotmode == IEEE80211_PROT_RTSCTS) ? "RTS/CTS" : 3764 ((htprotmode == IEEE80211_PROT_CTSONLY) ? "CTS-to-self" : "none")); 3765 3766 switch (htopmode & IEEE80211_HTINFO_OPMODE) 3767 { 3768 /* IEEE80211_HTINFO_OPMODE_HT20PR */ 3769 case IEEE80211_HTINFO_OPMODE_HT20PR: 3770 mm20_prot = RT2860_REG_PROT_NAV_SHORT | RT2860_REG_PROT_CTRL_NONE | 3771 RT2860_REG_TXOP_ALLOW_CCK | RT2860_REG_TXOP_ALLOW_OFDM | 3772 RT2860_REG_TXOP_ALLOW_MM20 | RT2860_REG_TXOP_ALLOW_GF20 | 3773 (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) | 3774 (4 << RT2860_REG_PROT_MCS_SHIFT); 3775 3776 gf20_prot = mm20_prot; 3777 3778 mm40_prot = RT2860_REG_PROT_NAV_SHORT | RT2860_REG_TXOP_ALLOW_ALL | 3779 (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) | 3780 (0x84 << RT2860_REG_PROT_MCS_SHIFT); 3781 3782 if (htprotmode == IEEE80211_PROT_RTSCTS) 3783 mm40_prot |= RT2860_REG_PROT_CTRL_RTS_CTS; 3784 else if (htprotmode == IEEE80211_PROT_CTSONLY) 3785 mm40_prot |= RT2860_REG_PROT_CTRL_CTS; 3786 else 3787 mm40_prot |= RT2860_REG_PROT_CTRL_NONE; 3788 3789 gf40_prot = mm40_prot; 3790 break; 3791 3792 /* IEEE80211_HTINFO_OPMODE_MIXED */ 3793 case IEEE80211_HTINFO_OPMODE_MIXED: 3794 mm20_prot = RT2860_REG_PROT_NAV_SHORT | 3795 RT2860_REG_TXOP_ALLOW_CCK | RT2860_REG_TXOP_ALLOW_OFDM | 3796 RT2860_REG_TXOP_ALLOW_MM20 | RT2860_REG_TXOP_ALLOW_GF20; 3797 3798 if (ic->ic_flags & IEEE80211_F_USEPROT) 3799 mm20_prot |= (RT2860_REG_PROT_PHYMODE_CCK << RT2860_REG_PROT_PHYMODE_SHIFT) | 3800 (3 << RT2860_REG_PROT_MCS_SHIFT); 3801 else 3802 mm20_prot |= (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) | 3803 (4 << RT2860_REG_PROT_MCS_SHIFT); 3804 3805 if (htprotmode == IEEE80211_PROT_RTSCTS) 3806 mm20_prot |= RT2860_REG_PROT_CTRL_RTS_CTS; 3807 else if (htprotmode == IEEE80211_PROT_CTSONLY) 3808 mm20_prot |= RT2860_REG_PROT_CTRL_CTS; 3809 else 3810 mm20_prot |= RT2860_REG_PROT_CTRL_NONE; 3811 3812 gf20_prot = mm20_prot; 3813 3814 mm40_prot = RT2860_REG_PROT_NAV_SHORT | RT2860_REG_TXOP_ALLOW_ALL; 3815 3816 if (ic->ic_flags & IEEE80211_F_USEPROT) 3817 mm40_prot |= (RT2860_REG_PROT_PHYMODE_CCK << RT2860_REG_PROT_PHYMODE_SHIFT) | 3818 (3 << RT2860_REG_PROT_MCS_SHIFT); 3819 else 3820 mm40_prot |= (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) | 3821 (0x84 << RT2860_REG_PROT_MCS_SHIFT); 3822 3823 if (htprotmode == IEEE80211_PROT_RTSCTS) 3824 mm40_prot |= RT2860_REG_PROT_CTRL_RTS_CTS; 3825 else if (htprotmode == IEEE80211_PROT_CTSONLY) 3826 mm40_prot |= RT2860_REG_PROT_CTRL_CTS; 3827 else 3828 mm40_prot |= RT2860_REG_PROT_CTRL_NONE; 3829 3830 gf40_prot = mm40_prot; 3831 break; 3832 3833 /* 3834 * IEEE80211_HTINFO_OPMODE_PURE 3835 * IEEE80211_HTINFO_OPMODE_PROTOPT 3836 */ 3837 case IEEE80211_HTINFO_OPMODE_PURE: 3838 case IEEE80211_HTINFO_OPMODE_PROTOPT: 3839 default: 3840 mm20_prot = RT2860_REG_PROT_NAV_SHORT | RT2860_REG_PROT_CTRL_NONE | 3841 RT2860_REG_TXOP_ALLOW_CCK | RT2860_REG_TXOP_ALLOW_OFDM | 3842 RT2860_REG_TXOP_ALLOW_MM20 | RT2860_REG_TXOP_ALLOW_GF20 | 3843 (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) | 3844 (4 << RT2860_REG_PROT_MCS_SHIFT); 3845 3846 gf20_prot = mm20_prot; 3847 3848 mm40_prot = RT2860_REG_PROT_NAV_SHORT | RT2860_REG_PROT_CTRL_NONE | 3849 RT2860_REG_TXOP_ALLOW_ALL | 3850 (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) | 3851 (0x84 << RT2860_REG_PROT_MCS_SHIFT); 3852 3853 gf40_prot = mm40_prot; 3854 break; 3855 } 3856 3857 rt2860_io_mac_write(sc, RT2860_REG_TX_MM20_PROT_CFG, mm20_prot); 3858 rt2860_io_mac_write(sc, RT2860_REG_TX_MM40_PROT_CFG, mm40_prot); 3859 rt2860_io_mac_write(sc, RT2860_REG_TX_GF20_PROT_CFG, gf20_prot); 3860 rt2860_io_mac_write(sc, RT2860_REG_TX_GF40_PROT_CFG, gf40_prot); 3861} 3862 3863/* 3864 * rt2860_asic_updateslot 3865 */ 3866static void rt2860_asic_updateslot(struct rt2860_softc *sc) 3867{ 3868 struct ifnet *ifp; 3869 struct ieee80211com *ic; 3870 struct ieee80211vap *vap; 3871 uint32_t tmp; 3872 3873 ifp = sc->ifp; 3874 ic = ifp->if_l2com; 3875 vap = TAILQ_FIRST(&ic->ic_vaps); 3876 3877 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE, 3878 "%s: %s short slot time\n", 3879 device_get_nameunit(sc->dev), 3880 ((ic->ic_flags & IEEE80211_F_SHSLOT) || 3881 ((vap != NULL) && (vap->iv_flags & IEEE80211_F_BURST))) ? "enabling" : "disabling"); 3882 3883 tmp = rt2860_io_mac_read(sc, RT2860_REG_BKOFF_SLOT_CFG); 3884 3885 tmp &= ~0xff; 3886 3887 if ((ic->ic_flags & IEEE80211_F_SHSLOT) || 3888 ((vap != NULL) && (vap->iv_flags & IEEE80211_F_BURST))) 3889 tmp |= IEEE80211_DUR_SHSLOT; 3890 else 3891 tmp |= IEEE80211_DUR_SLOT; 3892 3893 rt2860_io_mac_write(sc, RT2860_REG_BKOFF_SLOT_CFG, tmp); 3894} 3895 3896/* 3897 * rt2860_asic_wme_update 3898 */ 3899static void rt2860_asic_wme_update(struct rt2860_softc *sc) 3900{ 3901 struct ifnet *ifp; 3902 struct ieee80211com *ic; 3903 struct ieee80211_wme_state *wme; 3904 const struct wmeParams *wmep; 3905 int i; 3906 3907 ifp = sc->ifp; 3908 ic = ifp->if_l2com; 3909 wme = &ic->ic_wme; 3910 wmep = wme->wme_chanParams.cap_wmeParams; 3911 3912 RT2860_DPRINTF(sc, RT2860_DEBUG_WME, 3913 "%s: wme update: WME_AC_VO=%d/%d/%d/%d, WME_AC_VI=%d/%d/%d/%d, " 3914 "WME_AC_BK=%d/%d/%d/%d, WME_AC_BE=%d/%d/%d/%d\n", 3915 device_get_nameunit(sc->dev), 3916 wmep[WME_AC_VO].wmep_aifsn, 3917 wmep[WME_AC_VO].wmep_logcwmin, wmep[WME_AC_VO].wmep_logcwmax, 3918 wmep[WME_AC_VO].wmep_txopLimit, 3919 wmep[WME_AC_VI].wmep_aifsn, 3920 wmep[WME_AC_VI].wmep_logcwmin, wmep[WME_AC_VI].wmep_logcwmax, 3921 wmep[WME_AC_VI].wmep_txopLimit, 3922 wmep[WME_AC_BK].wmep_aifsn, 3923 wmep[WME_AC_BK].wmep_logcwmin, wmep[WME_AC_BK].wmep_logcwmax, 3924 wmep[WME_AC_BK].wmep_txopLimit, 3925 wmep[WME_AC_BE].wmep_aifsn, 3926 wmep[WME_AC_BE].wmep_logcwmin, wmep[WME_AC_BE].wmep_logcwmax, 3927 wmep[WME_AC_BE].wmep_txopLimit); 3928 3929 for (i = 0; i < WME_NUM_AC; i++) 3930 rt2860_io_mac_write(sc, RT2860_REG_TX_EDCA_AC_CFG(i), 3931 (wmep[i].wmep_logcwmax << 16) | (wmep[i].wmep_logcwmin << 12) | 3932 (wmep[i].wmep_aifsn << 8) | wmep[i].wmep_txopLimit); 3933 3934 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_AIFSN_CFG, 3935 (wmep[WME_AC_VO].wmep_aifsn << 12) | (wmep[WME_AC_VI].wmep_aifsn << 8) | 3936 (wmep[WME_AC_BK].wmep_aifsn << 4) | wmep[WME_AC_BE].wmep_aifsn); 3937 3938 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_CWMIN_CFG, 3939 (wmep[WME_AC_VO].wmep_logcwmin << 12) | (wmep[WME_AC_VI].wmep_logcwmin << 8) | 3940 (wmep[WME_AC_BK].wmep_logcwmin << 4) | wmep[WME_AC_BE].wmep_logcwmin); 3941 3942 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_CWMAX_CFG, 3943 (wmep[WME_AC_VO].wmep_logcwmax << 12) | (wmep[WME_AC_VI].wmep_logcwmax << 8) | 3944 (wmep[WME_AC_BK].wmep_logcwmax << 4) | wmep[WME_AC_BE].wmep_logcwmax); 3945 3946 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_TXOP0_CFG, 3947 (wmep[WME_AC_BK].wmep_txopLimit << 16) | wmep[WME_AC_BE].wmep_txopLimit); 3948 3949 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_TXOP1_CFG, 3950 (wmep[WME_AC_VO].wmep_txopLimit << 16) | wmep[WME_AC_VI].wmep_txopLimit); 3951} 3952 3953/* 3954 * rt2860_asic_update_beacon 3955 */ 3956static void rt2860_asic_update_beacon(struct rt2860_softc *sc, 3957 struct ieee80211vap *vap) 3958{ 3959 struct rt2860_softc_vap *rvap; 3960 struct mbuf *m; 3961 struct rt2860_txwi *txwi; 3962 uint32_t tmp; 3963 3964 rvap = (struct rt2860_softc_vap *) vap; 3965 3966 m = rvap->beacon_mbuf; 3967 txwi = &rvap->beacon_txwi; 3968 3969 /* disable temporarily TSF sync */ 3970 3971 tmp = rt2860_io_mac_read(sc, RT2860_REG_BCN_TIME_CFG); 3972 3973 tmp &= ~(RT2860_REG_BCN_TX_ENABLE | 3974 RT2860_REG_TSF_TIMER_ENABLE | 3975 RT2860_REG_TBTT_TIMER_ENABLE); 3976 3977 rt2860_io_mac_write(sc, RT2860_REG_BCN_TIME_CFG, tmp); 3978 3979 /* write Tx wireless info and beacon frame to on-chip memory */ 3980 3981 rt2860_io_mac_write_multi(sc, RT2860_REG_BEACON_BASE(0), 3982 txwi, sizeof(struct rt2860_txwi)); 3983 3984 rt2860_io_mac_write_multi(sc, RT2860_REG_BEACON_BASE(0) + sizeof(struct rt2860_txwi), 3985 mtod(m, uint8_t *), m->m_pkthdr.len); 3986 3987 /* enable again TSF sync */ 3988 3989 tmp = rt2860_io_mac_read(sc, RT2860_REG_BCN_TIME_CFG); 3990 3991 tmp |= (RT2860_REG_BCN_TX_ENABLE | 3992 RT2860_REG_TSF_TIMER_ENABLE | 3993 RT2860_REG_TBTT_TIMER_ENABLE); 3994 3995 rt2860_io_mac_write(sc, RT2860_REG_BCN_TIME_CFG, tmp); 3996} 3997 3998/* 3999 * rt2860_asic_clear_keytables 4000 */ 4001static void rt2860_asic_clear_keytables(struct rt2860_softc *sc) 4002{ 4003 int i; 4004 4005 /* clear Rx WCID search table (entries = 256, entry size = 8) */ 4006 4007 for (i = 0; i < 256; i++) 4008 { 4009 rt2860_io_mac_write(sc, RT2860_REG_WCID(i), 0xffffffff); 4010 rt2860_io_mac_write(sc, RT2860_REG_WCID(i) + 4, 0x0000ffff); 4011 } 4012 4013 /* clear WCID attribute table (entries = 256, entry size = 4) */ 4014 4015 rt2860_io_mac_set_region_4(sc, RT2860_REG_WCID_ATTR(0), 0, 256); 4016 4017 /* clear IV/EIV table (entries = 256, entry size = 8) */ 4018 4019 rt2860_io_mac_set_region_4(sc, RT2860_REG_IVEIV(0), 0, 2 * 256); 4020 4021 /* clear pairwise key table (entries = 64, entry size = 32) */ 4022 4023 rt2860_io_mac_set_region_4(sc, RT2860_REG_PKEY(0), 0, 8 * 64); 4024 4025 /* clear shared key table (entries = 32, entry size = 32) */ 4026 4027 rt2860_io_mac_set_region_4(sc, RT2860_REG_SKEY(0, 0), 0, 8 * 32); 4028 4029 /* clear shared key mode (entries = 32, entry size = 2) */ 4030 4031 rt2860_io_mac_set_region_4(sc, RT2860_REG_SKEY_MODE(0), 0, 16); 4032} 4033 4034/* 4035 * rt2860_asic_add_ba_session 4036 */ 4037static void rt2860_asic_add_ba_session(struct rt2860_softc *sc, 4038 uint8_t wcid, int tid) 4039{ 4040 uint32_t tmp; 4041 4042 RT2860_DPRINTF(sc, RT2860_DEBUG_BA, 4043 "%s: adding BA session: wcid=0x%02x, tid=%d\n", 4044 device_get_nameunit(sc->dev), wcid, tid); 4045 4046 tmp = rt2860_io_mac_read(sc, RT2860_REG_WCID(wcid) + 4); 4047 4048 tmp |= (0x10000 << tid); 4049 4050 rt2860_io_mac_write(sc, RT2860_REG_WCID(wcid) + 4, tmp); 4051} 4052 4053/* 4054 * rt2860_asic_del_ba_session 4055 */ 4056static void rt2860_asic_del_ba_session(struct rt2860_softc *sc, 4057 uint8_t wcid, int tid) 4058{ 4059 uint32_t tmp; 4060 4061 RT2860_DPRINTF(sc, RT2860_DEBUG_BA, 4062 "%s: deleting BA session: wcid=0x%02x, tid=%d\n", 4063 device_get_nameunit(sc->dev), wcid, tid); 4064 4065 tmp = rt2860_io_mac_read(sc, RT2860_REG_WCID(wcid) + 4); 4066 4067 tmp &= ~(0x10000 << tid); 4068 4069 rt2860_io_mac_write(sc, RT2860_REG_WCID(wcid) + 4, tmp); 4070} 4071 4072/* 4073 * rt2860_beacon_alloc 4074 */ 4075static int rt2860_beacon_alloc(struct rt2860_softc *sc, 4076 struct ieee80211vap *vap) 4077{ 4078 struct ieee80211com *ic; 4079 struct rt2860_softc_vap *rvap; 4080 struct mbuf *m; 4081 struct rt2860_txwi txwi; 4082 uint8_t rate, mcs; 4083 4084 ic = vap->iv_ic; 4085 rvap = (struct rt2860_softc_vap *) vap; 4086 4087 m = ieee80211_beacon_alloc(vap->iv_bss, &rvap->beacon_offsets); 4088 if (m == NULL) 4089 return ENOMEM; 4090 4091 rate = IEEE80211_IS_CHAN_5GHZ(vap->iv_bss->ni_chan) ? 12 : 2; 4092 mcs = rt2860_rate2mcs(rate); 4093 4094 RT2860_DPRINTF(sc, RT2860_DEBUG_BEACON, 4095 "%s: beacon allocate: mcs=0x%02x\n", 4096 device_get_nameunit(sc->dev), mcs); 4097 4098 memset(&txwi, 0, sizeof(struct rt2860_txwi)); 4099 4100 txwi.wcid = RT2860_WCID_RESERVED; 4101 txwi.pid_mpdu_len = ((htole16(m->m_pkthdr.len) & RT2860_TXWI_MPDU_LEN_MASK) << 4102 RT2860_TXWI_MPDU_LEN_SHIFT); 4103 txwi.txop = (RT2860_TXWI_TXOP_HT << RT2860_TXWI_TXOP_SHIFT); 4104 txwi.mpdu_density_flags |= 4105 (RT2860_TXWI_FLAGS_TS << RT2860_TXWI_FLAGS_SHIFT); 4106 txwi.bawin_size_xflags |= 4107 (RT2860_TXWI_XFLAGS_NSEQ << RT2860_TXWI_XFLAGS_SHIFT); 4108 4109 if (rate == 2) 4110 { 4111 txwi.phymode_ifs_stbc_shortgi = 4112 (RT2860_TXWI_PHYMODE_CCK << RT2860_TXWI_PHYMODE_SHIFT); 4113 4114 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE)) 4115 mcs |= RT2860_TXWI_MCS_SHOTPRE; 4116 } 4117 else 4118 { 4119 txwi.phymode_ifs_stbc_shortgi = 4120 (RT2860_TXWI_PHYMODE_OFDM << RT2860_TXWI_PHYMODE_SHIFT); 4121 } 4122 4123 txwi.bw_mcs = (RT2860_TXWI_BW_20 << RT2860_TXWI_BW_SHIFT) | 4124 ((mcs & RT2860_TXWI_MCS_MASK) << RT2860_TXWI_MCS_SHIFT); 4125 4126 if (rvap->beacon_mbuf != NULL) 4127 { 4128 m_free(rvap->beacon_mbuf); 4129 rvap->beacon_mbuf = NULL; 4130 } 4131 4132 rvap->beacon_mbuf = m; 4133 rvap->beacon_txwi = txwi; 4134 4135 return 0; 4136} 4137 4138/* 4139 * rt2860_rxrate 4140 */ 4141static uint8_t rt2860_rxrate(struct rt2860_rxwi *rxwi) 4142{ 4143 uint8_t mcs, phymode; 4144 uint8_t rate; 4145 4146 mcs = (rxwi->bw_mcs >> RT2860_RXWI_MCS_SHIFT) & RT2860_RXWI_MCS_MASK; 4147 phymode = (rxwi->phymode_stbc_shortgi >> RT2860_RXWI_PHYMODE_SHIFT) & 4148 RT2860_RXWI_PHYMODE_MASK; 4149 4150 rate = 2; 4151 4152 switch (phymode) 4153 { 4154 case RT2860_RXWI_PHYMODE_CCK: 4155 switch (mcs & ~RT2860_RXWI_MCS_SHOTPRE) 4156 { 4157 case 0: rate = 2; break; /* 1 Mbps */ 4158 case 1: rate = 4; break; /* 2 MBps */ 4159 case 2: rate = 11; break; /* 5.5 Mbps */ 4160 case 3: rate = 22; break; /* 11 Mbps */ 4161 } 4162 break; 4163 4164 case RT2860_RXWI_PHYMODE_OFDM: 4165 switch (mcs) 4166 { 4167 case 0: rate = 12; break; /* 6 Mbps */ 4168 case 1: rate = 18; break; /* 9 Mbps */ 4169 case 2: rate = 24; break; /* 12 Mbps */ 4170 case 3: rate = 36; break; /* 18 Mbps */ 4171 case 4: rate = 48; break; /* 24 Mbps */ 4172 case 5: rate = 72; break; /* 36 Mbps */ 4173 case 6: rate = 96; break; /* 48 Mbps */ 4174 case 7: rate = 108; break; /* 54 Mbps */ 4175 } 4176 break; 4177 4178 case RT2860_RXWI_PHYMODE_HT_MIXED: 4179 case RT2860_RXWI_PHYMODE_HT_GF: 4180 break; 4181 } 4182 4183 return rate; 4184} 4185 4186/* 4187 * rt2860_maxrssi_rxpath 4188 */ 4189static uint8_t rt2860_maxrssi_rxpath(struct rt2860_softc *sc, 4190 const struct rt2860_rxwi *rxwi) 4191{ 4192 uint8_t rxpath; 4193 4194 rxpath = 0; 4195 4196 if (sc->nrxpath > 1) 4197 if (rxwi->rssi[1] > rxwi->rssi[rxpath]) 4198 rxpath = 1; 4199 4200 if (sc->nrxpath > 2) 4201 if (rxwi->rssi[2] > rxwi->rssi[rxpath]) 4202 rxpath = 2; 4203 4204 return rxpath; 4205} 4206 4207/* 4208 * rt2860_rssi2dbm 4209 */ 4210static int8_t rt2860_rssi2dbm(struct rt2860_softc *sc, 4211 uint8_t rssi, uint8_t rxpath) 4212{ 4213 struct ifnet *ifp; 4214 struct ieee80211com *ic; 4215 struct ieee80211_channel *c; 4216 int chan; 4217 int8_t rssi_off, lna_gain; 4218 4219 if (rssi == 0) 4220 return -99; 4221 4222 ifp = sc->ifp; 4223 ic = ifp->if_l2com; 4224 c = ic->ic_curchan; 4225 chan = ieee80211_chan2ieee(ic, c); 4226 4227 if (IEEE80211_IS_CHAN_5GHZ(c)) 4228 { 4229 rssi_off = sc->rssi_off_5ghz[rxpath]; 4230 4231 if (chan <= 64) 4232 lna_gain = sc->lna_gain[1]; 4233 else if (chan <= 128) 4234 lna_gain = sc->lna_gain[2]; 4235 else 4236 lna_gain = sc->lna_gain[3]; 4237 } 4238 else 4239 { 4240 rssi_off = sc->rssi_off_2ghz[rxpath] - sc->lna_gain[0]; 4241 lna_gain = sc->lna_gain[0]; 4242 } 4243 4244 return (-12 - rssi_off - lna_gain - rssi); 4245} 4246 4247/* 4248 * rt2860_rate2mcs 4249 */ 4250static uint8_t rt2860_rate2mcs(uint8_t rate) 4251{ 4252 switch (rate) 4253 { 4254 /* CCK rates */ 4255 case 2: return 0; 4256 case 4: return 1; 4257 case 11: return 2; 4258 case 22: return 3; 4259 4260 /* OFDM rates */ 4261 case 12: return 0; 4262 case 18: return 1; 4263 case 24: return 2; 4264 case 36: return 3; 4265 case 48: return 4; 4266 case 72: return 5; 4267 case 96: return 6; 4268 case 108: return 7; 4269 } 4270 4271 return 0; 4272} 4273 4274/* 4275 * rt2860_tx_mgmt 4276 */ 4277static int rt2860_tx_mgmt(struct rt2860_softc *sc, 4278 struct mbuf *m, struct ieee80211_node *ni, int qid) 4279{ 4280 struct ifnet *ifp; 4281 struct ieee80211com *ic; 4282 struct ieee80211vap *vap; 4283 const struct ieee80211_txparam *tp; 4284 struct rt2860_softc_node *rni; 4285 struct rt2860_softc_tx_ring *ring; 4286 struct rt2860_softc_tx_data *data; 4287 struct rt2860_txdesc *desc; 4288 struct rt2860_txwi *txwi; 4289 struct ieee80211_frame *wh; 4290 struct rt2860_softc_tx_radiotap_header *tap; 4291 bus_dma_segment_t dma_seg[RT2860_SOFTC_MAX_SCATTER]; 4292 u_int hdrsize, hdrspace; 4293 uint8_t rate, mcs, pid, qsel; 4294 uint16_t len, dmalen, mpdu_len, dur; 4295 int error, mimops, ndmasegs, ndescs, i, j; 4296 4297 KASSERT(qid >= 0 && qid < RT2860_SOFTC_TX_RING_COUNT, 4298 ("%s: Tx MGMT: invalid qid=%d\n", 4299 device_get_nameunit(sc->dev), qid)); 4300 4301 RT2860_SOFTC_TX_RING_ASSERT_LOCKED(&sc->tx_ring[qid]); 4302 4303 ifp = sc->ifp; 4304 ic = ifp->if_l2com; 4305 vap = ni->ni_vap; 4306 rni = (struct rt2860_softc_node *) ni; 4307 tp = ni->ni_txparms; 4308 4309 ring = &sc->tx_ring[qid]; 4310 desc = &ring->desc[ring->desc_cur]; 4311 data = &ring->data[ring->data_cur]; 4312 txwi = (struct rt2860_txwi *) (ring->seg0 + ring->data_cur * RT2860_TX_DATA_SEG0_SIZE); 4313 4314 wh = mtod(m, struct ieee80211_frame *); 4315 4316 rate = tp->mgmtrate & IEEE80211_RATE_VAL; 4317/* XXX */ 4318 if (!rate) 4319 return EFBIG; 4320 4321 /* fill Tx wireless info */ 4322 4323 if (ni->ni_flags & IEEE80211_NODE_HT) 4324 mcs = rate; 4325 else 4326 mcs = rt2860_rate2mcs(rate); 4327 4328 /* calculate MPDU length without padding */ 4329 4330 hdrsize = ieee80211_anyhdrsize(wh); 4331 hdrspace = ieee80211_anyhdrspace(ic, wh); 4332 mpdu_len = m->m_pkthdr.len - hdrspace + hdrsize; 4333 4334 memset(txwi, 0, sizeof(struct rt2860_txwi)); 4335 4336 /* management frames do not need encryption */ 4337 4338 txwi->wcid = RT2860_WCID_RESERVED; 4339 4340 /* MIMO power save */ 4341 4342 if ((ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_flags & IEEE80211_NODE_MIMO_PS)) 4343 { 4344 if (mcs > 7) 4345 { 4346 if (ni->ni_flags & IEEE80211_NODE_MIMO_RTS) 4347 { 4348 /* dynamic MIMO power save */ 4349 4350 txwi->mpdu_density_flags |= 4351 (RT2860_TXWI_FLAGS_MIMOPS << RT2860_TXWI_FLAGS_SHIFT); 4352 } 4353 else 4354 { 4355 /* static MIMO power save */ 4356 4357 mcs = 7; 4358 } 4359 } 4360 4361 mimops = 1; 4362 } 4363 else 4364 { 4365 mimops = 0; 4366 } 4367 4368 pid = (mcs < 0xf) ? (mcs + 1) : mcs; 4369 4370 txwi->pid_mpdu_len = ((htole16(pid) & RT2860_TXWI_PID_MASK) << 4371 RT2860_TXWI_PID_SHIFT) | ((htole16(mpdu_len) & RT2860_TXWI_MPDU_LEN_MASK) << 4372 RT2860_TXWI_MPDU_LEN_SHIFT); 4373 4374 if (ni->ni_flags & IEEE80211_NODE_HT) 4375 { 4376 txwi->phymode_ifs_stbc_shortgi |= 4377 (RT2860_TXWI_PHYMODE_HT_MIXED << RT2860_TXWI_PHYMODE_SHIFT); 4378 } 4379 else 4380 { 4381 if (ieee80211_rate2phytype(ic->ic_rt, rate) != IEEE80211_T_OFDM) 4382 { 4383 txwi->phymode_ifs_stbc_shortgi |= 4384 (RT2860_TXWI_PHYMODE_CCK << RT2860_TXWI_PHYMODE_SHIFT); 4385 4386 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE)) 4387 mcs |= RT2860_TXWI_MCS_SHOTPRE; 4388 } 4389 else 4390 { 4391 txwi->phymode_ifs_stbc_shortgi |= 4392 (RT2860_TXWI_PHYMODE_OFDM << RT2860_TXWI_PHYMODE_SHIFT); 4393 } 4394 } 4395 4396 txwi->bw_mcs = (RT2860_TXWI_BW_20 << RT2860_TXWI_BW_SHIFT) | 4397 ((mcs & RT2860_TXWI_MCS_MASK) << RT2860_TXWI_MCS_SHIFT); 4398 4399 txwi->txop = (RT2860_TXWI_TXOP_BACKOFF << RT2860_TXWI_TXOP_SHIFT); 4400 4401 /* skip ACKs for multicast frames */ 4402 4403 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) 4404 { 4405 txwi->bawin_size_xflags |= 4406 (RT2860_TXWI_XFLAGS_ACK << RT2860_TXWI_XFLAGS_SHIFT); 4407 4408 if (ni->ni_flags & IEEE80211_NODE_HT) 4409 { 4410 /* preamble + plcp + signal extension + SIFS */ 4411 4412 dur = 16 + 4 + 6 + 10; 4413 } 4414 else 4415 { 4416 dur = ieee80211_ack_duration(ic->ic_rt, rate, 4417 ic->ic_flags & IEEE80211_F_SHPREAMBLE); 4418 } 4419 4420 *(uint16_t *) wh->i_dur = htole16(dur); 4421 } 4422 4423 /* ask MAC to insert timestamp into probe responses */ 4424 4425 if ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) == 4426 (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP)) 4427 txwi->mpdu_density_flags |= 4428 (RT2860_TXWI_FLAGS_TS << RT2860_TXWI_FLAGS_SHIFT); 4429 4430 if (ieee80211_radiotap_active_vap(vap)) 4431 { 4432 tap = &sc->txtap; 4433 4434 tap->flags = IEEE80211_RADIOTAP_F_DATAPAD; 4435 tap->chan_flags = htole32(ic->ic_curchan->ic_flags); 4436 tap->chan_freq = htole16(ic->ic_curchan->ic_freq); 4437 tap->chan_ieee = ic->ic_curchan->ic_ieee; 4438 tap->chan_maxpow = 0; 4439 4440 if (ni->ni_flags & IEEE80211_NODE_HT) 4441 tap->rate = mcs | IEEE80211_RATE_MCS; 4442 else 4443 tap->rate = rate; 4444 4445 if (mcs & RT2860_TXWI_MCS_SHOTPRE) 4446 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE; 4447 4448 if (wh->i_fc[1] & IEEE80211_FC1_WEP) 4449 tap->flags |= IEEE80211_RADIOTAP_F_WEP; 4450 4451 if (wh->i_fc[1] & IEEE80211_FC1_WEP) 4452 { 4453 wh->i_fc[1] &= ~IEEE80211_FC1_WEP; 4454 4455 ieee80211_radiotap_tx(vap, m); 4456 4457 wh->i_fc[1] |= IEEE80211_FC1_WEP; 4458 } 4459 else 4460 { 4461 ieee80211_radiotap_tx(vap, m); 4462 } 4463 } 4464 4465 /* copy and trim 802.11 header */ 4466 4467 m_copydata(m, 0, hdrsize, (caddr_t) (txwi + 1)); 4468 m_adj(m, hdrspace); 4469 4470 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag, data->dma_map, m, 4471 dma_seg, &ndmasegs, BUS_DMA_NOWAIT); 4472 if (error != 0) 4473 { 4474 /* too many fragments, linearize */ 4475 4476 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 4477 "%s: could not load mbuf DMA map, trying to linearize mbuf: ndmasegs=%d, len=%d, error=%d\n", 4478 device_get_nameunit(sc->dev), ndmasegs, m->m_pkthdr.len, error); 4479 4480 m = m_defrag(m, M_DONTWAIT); 4481 if (m == NULL) 4482 return ENOMEM; 4483 4484 sc->tx_defrag_packets++; 4485 4486 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag, data->dma_map, m, 4487 dma_seg, &ndmasegs, BUS_DMA_NOWAIT); 4488 if (error != 0) 4489 { 4490 printf("%s: could not load mbuf DMA map: ndmasegs=%d, len=%d, error=%d\n", 4491 device_get_nameunit(sc->dev), ndmasegs, m->m_pkthdr.len, error); 4492 m_freem(m); 4493 return error; 4494 } 4495 } 4496 4497 if (m->m_pkthdr.len == 0) 4498 ndmasegs = 0; 4499 4500 /* determine how many Tx descs are required */ 4501 4502 ndescs = 1 + ndmasegs / 2; 4503 if ((ring->desc_queued + ndescs) > (RT2860_SOFTC_TX_RING_DESC_COUNT - 2)) 4504 { 4505 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 4506 "%s: there are not enough Tx descs\n", 4507 device_get_nameunit(sc->dev)); 4508 4509 sc->no_tx_desc_avail++; 4510 4511 bus_dmamap_unload(ring->data_dma_tag, data->dma_map); 4512 m_freem(m); 4513 return EFBIG; 4514 } 4515 4516 data->m = m; 4517 data->ni = ni; 4518 4519 /* set up Tx descs */ 4520 4521 /* first segment is Tx wireless info and 802.11 header */ 4522 4523 len = sizeof(struct rt2860_txwi) + hdrsize; 4524 4525 /* align end on a 4-bytes boundary */ 4526 4527 dmalen = (len + 3) & ~ 3; 4528 4529 memset((caddr_t) txwi + len, 0, dmalen - len); 4530 4531 qsel = RT2860_TXDESC_QSEL_EDCA; 4532 4533 desc->sdp0 = htole32(ring->seg0_phys_addr + ring->data_cur * RT2860_TX_DATA_SEG0_SIZE); 4534 desc->sdl0 = htole16(dmalen); 4535 desc->qsel_flags = (qsel << RT2860_TXDESC_QSEL_SHIFT); 4536 4537 /* set up payload segments */ 4538 4539 for (i = ndmasegs, j = 0; i >= 2; i -= 2) 4540 { 4541 desc->sdp1 = htole32(dma_seg[j].ds_addr); 4542 desc->sdl1 = htole16(dma_seg[j].ds_len); 4543 4544 ring->desc_queued++; 4545 ring->desc_cur = (ring->desc_cur + 1) % RT2860_SOFTC_TX_RING_DESC_COUNT; 4546 4547 j++; 4548 4549 desc = &ring->desc[ring->desc_cur]; 4550 4551 desc->sdp0 = htole32(dma_seg[j].ds_addr); 4552 desc->sdl0 = htole16(dma_seg[j].ds_len); 4553 desc->qsel_flags = (qsel << RT2860_TXDESC_QSEL_SHIFT); 4554 4555 j++; 4556 } 4557 4558 /* finalize last payload segment */ 4559 4560 if (i > 0) 4561 { 4562 desc->sdp1 = htole32(dma_seg[j].ds_addr); 4563 desc->sdl1 = htole16(dma_seg[j].ds_len | RT2860_TXDESC_SDL1_LASTSEG); 4564 } 4565 else 4566 { 4567 desc->sdl0 |= htole16(RT2860_TXDESC_SDL0_LASTSEG); 4568 desc->sdl1 = 0; 4569 } 4570 4571 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 4572 "%s: sending MGMT frame: qid=%d, hdrsize=%d, hdrspace=%d, len=%d, " 4573 "mcs=%d, mimops=%d, DMA len=%d, ndmasegs=%d, DMA ds_len=%d/%d/%d/%d/%d\n", 4574 device_get_nameunit(sc->dev), 4575 qid, hdrsize, hdrspace, m->m_pkthdr.len + hdrsize, 4576 mcs, mimops, dmalen, ndmasegs, 4577 (int) dma_seg[0].ds_len, (int) dma_seg[1].ds_len, (int) dma_seg[2].ds_len, (int) dma_seg[3].ds_len, (int) dma_seg[4].ds_len); 4578 4579 bus_dmamap_sync(ring->seg0_dma_tag, ring->seg0_dma_map, 4580 BUS_DMASYNC_PREWRITE); 4581 bus_dmamap_sync(ring->data_dma_tag, data->dma_map, 4582 BUS_DMASYNC_PREWRITE); 4583 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map, 4584 BUS_DMASYNC_PREWRITE); 4585 4586 ring->desc_queued++; 4587 ring->desc_cur = (ring->desc_cur + 1) % RT2860_SOFTC_TX_RING_DESC_COUNT; 4588 4589 ring->data_queued++; 4590 ring->data_cur = (ring->data_cur + 1) % RT2860_SOFTC_TX_RING_DATA_COUNT; 4591 4592 /* kick Tx */ 4593 4594 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_CTX_IDX(qid), ring->desc_cur); 4595 4596 return 0; 4597} 4598 4599/* 4600 * rt2860_tx_data 4601 */ 4602static int rt2860_tx_data(struct rt2860_softc *sc, 4603 struct mbuf *m, struct ieee80211_node *ni, int qid) 4604{ 4605 struct ifnet *ifp; 4606 struct ieee80211com *ic; 4607 struct ieee80211vap *vap; 4608 const struct ieee80211_txparam *tp; 4609 struct rt2860_softc_node *rni; 4610 struct rt2860_softc_tx_ring *ring; 4611 struct rt2860_softc_tx_data *data; 4612 struct rt2860_txdesc *desc; 4613 struct rt2860_txwi *txwi; 4614 struct ieee80211_frame *wh; 4615 struct ieee80211_tx_ampdu *tx_ampdu; 4616 ieee80211_seq seqno; 4617 struct rt2860_softc_tx_radiotap_header *tap; 4618 bus_dma_segment_t dma_seg[RT2860_SOFTC_MAX_SCATTER]; 4619 u_int hdrsize, hdrspace; 4620 uint8_t type, rate, bw, stbc, shortgi, mcs, pid, wcid, mpdu_density, bawin_size, qsel; 4621 uint16_t qos, len, dmalen, mpdu_len, dur; 4622 int error, hasqos, ac, tid, ampdu, mimops, ndmasegs, ndescs, i, j; 4623 4624 KASSERT(qid >= 0 && qid < RT2860_SOFTC_TX_RING_COUNT, 4625 ("%s: Tx data: invalid qid=%d\n", 4626 device_get_nameunit(sc->dev), qid)); 4627 4628 RT2860_SOFTC_TX_RING_ASSERT_LOCKED(&sc->tx_ring[qid]); 4629 4630 ifp = sc->ifp; 4631 ic = ifp->if_l2com; 4632 vap = ni->ni_vap; 4633 rni = (struct rt2860_softc_node *) ni; 4634 tp = ni->ni_txparms; 4635 4636 ring = &sc->tx_ring[qid]; 4637 desc = &ring->desc[ring->desc_cur]; 4638 data = &ring->data[ring->data_cur]; 4639 txwi = (struct rt2860_txwi *) (ring->seg0 + ring->data_cur * RT2860_TX_DATA_SEG0_SIZE); 4640 4641 wh = mtod(m, struct ieee80211_frame *); 4642 4643 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; 4644 4645 hasqos = IEEE80211_QOS_HAS_SEQ(wh); 4646 if (hasqos) 4647 { 4648 if (IEEE80211_HAS_ADDR4(wh)) 4649 qos = le16toh(*(const uint16_t *) 4650 (((struct ieee80211_qosframe_addr4 *) wh)->i_qos)); 4651 else 4652 qos = le16toh(*(const uint16_t *) 4653 (((struct ieee80211_qosframe *) wh)->i_qos)); 4654 } 4655 else 4656 { 4657 qos = 0; 4658 } 4659 4660 if (IEEE80211_IS_MULTICAST(wh->i_addr1)) 4661 rate = tp->mcastrate; 4662 else if (m->m_flags & M_EAPOL) 4663 rate = tp->mgmtrate; 4664 else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) 4665 rate = tp->ucastrate; 4666 else 4667 rate = ni->ni_txrate; 4668 4669 rate &= IEEE80211_RATE_VAL; 4670/* XXX */ 4671 if (!rate) 4672 return EFBIG; 4673 4674 /* fill Tx wireless info */ 4675 4676 if (ni->ni_flags & IEEE80211_NODE_HT) 4677 mcs = rate; 4678 else 4679 mcs = rt2860_rate2mcs(rate); 4680 4681 if (type == IEEE80211_FC0_TYPE_DATA) 4682 wcid = !IEEE80211_IS_MULTICAST(wh->i_addr1) ? rni->staid : RT2860_WCID_MCAST; 4683 else 4684 wcid = RT2860_WCID_RESERVED; 4685 4686 /* calculate MPDU length without padding */ 4687 4688 hdrsize = ieee80211_anyhdrsize(wh); 4689 hdrspace = ieee80211_anyhdrspace(ic, wh); 4690 mpdu_len = m->m_pkthdr.len - hdrspace + hdrsize; 4691 4692 memset(txwi, 0, sizeof(struct rt2860_txwi)); 4693 4694 txwi->wcid = wcid; 4695 4696 /* MIMO power save */ 4697 4698 if ((ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_flags & IEEE80211_NODE_MIMO_PS)) 4699 { 4700 if (mcs > 7) 4701 { 4702 if (ni->ni_flags & IEEE80211_NODE_MIMO_RTS) 4703 { 4704 /* dynamic MIMO power save */ 4705 4706 txwi->mpdu_density_flags |= 4707 (RT2860_TXWI_FLAGS_MIMOPS << RT2860_TXWI_FLAGS_SHIFT); 4708 } 4709 else 4710 { 4711 /* static MIMO power save */ 4712 4713 mcs = 7; 4714 } 4715 } 4716 4717 mimops = 1; 4718 } 4719 else 4720 { 4721 mimops = 0; 4722 } 4723 4724 pid = (mcs < 0xf) ? (mcs + 1) : mcs; 4725 4726 txwi->pid_mpdu_len = ((htole16(pid) & RT2860_TXWI_PID_MASK) << 4727 RT2860_TXWI_PID_SHIFT) | ((htole16(mpdu_len) & RT2860_TXWI_MPDU_LEN_MASK) << 4728 RT2860_TXWI_MPDU_LEN_SHIFT); 4729 4730 stbc = sc->tx_stbc && (mcs <= 7) && (vap->iv_htcaps & IEEE80211_HTCAP_TXSTBC) && 4731 (ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_htcap & IEEE80211_HTCAP_RXSTBC); 4732 4733 shortgi = ((vap->iv_flags_ht & IEEE80211_FHT_SHORTGI20) && (ni->ni_flags & IEEE80211_NODE_SGI20) && (ni->ni_chw == 20)) || 4734 ((vap->iv_flags_ht & IEEE80211_FHT_SHORTGI40) && (ni->ni_flags & IEEE80211_NODE_SGI40) && (ni->ni_chw == 40)); 4735 4736 txwi->phymode_ifs_stbc_shortgi |= 4737 ((stbc & RT2860_TXWI_STBC_MASK) << RT2860_TXWI_STBC_SHIFT) | 4738 ((shortgi & RT2860_TXWI_SHORTGI_MASK) << RT2860_TXWI_SHORTGI_SHIFT); 4739 4740 if (ni->ni_flags & IEEE80211_NODE_HT) 4741 { 4742 txwi->phymode_ifs_stbc_shortgi |= 4743 (RT2860_TXWI_PHYMODE_HT_MIXED << RT2860_TXWI_PHYMODE_SHIFT); 4744 } 4745 else 4746 { 4747 if (ieee80211_rate2phytype(ic->ic_rt, rate) != IEEE80211_T_OFDM) 4748 { 4749 txwi->phymode_ifs_stbc_shortgi |= 4750 (RT2860_TXWI_PHYMODE_CCK << RT2860_TXWI_PHYMODE_SHIFT); 4751 4752 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE)) 4753 mcs |= RT2860_TXWI_MCS_SHOTPRE; 4754 } 4755 else 4756 { 4757 txwi->phymode_ifs_stbc_shortgi |= 4758 (RT2860_TXWI_PHYMODE_OFDM << RT2860_TXWI_PHYMODE_SHIFT); 4759 } 4760 } 4761 4762 if ((ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_chw == 40)) 4763 bw = RT2860_TXWI_BW_40; 4764 else 4765 bw = RT2860_TXWI_BW_20; 4766 4767 txwi->bw_mcs = ((bw & RT2860_TXWI_BW_MASK) << RT2860_TXWI_BW_SHIFT) | 4768 ((mcs & RT2860_TXWI_MCS_MASK) << RT2860_TXWI_MCS_SHIFT); 4769 4770 txwi->txop = (RT2860_TXWI_TXOP_HT << RT2860_TXWI_TXOP_SHIFT); 4771 4772 if (!IEEE80211_IS_MULTICAST(wh->i_addr1) && 4773 (!hasqos || (qos & IEEE80211_QOS_ACKPOLICY) != IEEE80211_QOS_ACKPOLICY_NOACK)) 4774 { 4775 txwi->bawin_size_xflags |= 4776 (RT2860_TXWI_XFLAGS_ACK << RT2860_TXWI_XFLAGS_SHIFT); 4777 4778 if (ni->ni_flags & IEEE80211_NODE_HT) 4779 { 4780 /* preamble + plcp + signal extension + SIFS */ 4781 4782 dur = 16 + 4 + 6 + 10; 4783 } 4784 else 4785 { 4786 dur = ieee80211_ack_duration(ic->ic_rt, rate, 4787 ic->ic_flags & IEEE80211_F_SHPREAMBLE); 4788 } 4789 4790 *(uint16_t *) wh->i_dur = htole16(dur); 4791 } 4792 4793 /* check for A-MPDU */ 4794 4795 if (m->m_flags & M_AMPDU_MPDU) 4796 { 4797 ac = M_WME_GETAC(m); 4798 tid = WME_AC_TO_TID(ac); 4799 tx_ampdu = &ni->ni_tx_ampdu[ac]; 4800 4801 mpdu_density = RT2860_MS(ni->ni_htparam, IEEE80211_HTCAP_MPDUDENSITY); 4802 bawin_size = tx_ampdu->txa_wnd; 4803 4804 txwi->mpdu_density_flags |= 4805 ((mpdu_density & RT2860_TXWI_MPDU_DENSITY_MASK) << RT2860_TXWI_MPDU_DENSITY_SHIFT) | 4806 (RT2860_TXWI_FLAGS_AMPDU << RT2860_TXWI_FLAGS_SHIFT); 4807 4808 txwi->bawin_size_xflags |= 4809 ((bawin_size & RT2860_TXWI_BAWIN_SIZE_MASK) << RT2860_TXWI_BAWIN_SIZE_SHIFT); 4810 4811 seqno = ni->ni_txseqs[tid]++; 4812 4813 *(uint16_t *) &wh->i_seq[0] = htole16(seqno << IEEE80211_SEQ_SEQ_SHIFT); 4814 4815 ampdu = 1; 4816 } 4817 else 4818 { 4819 mpdu_density = 0; 4820 bawin_size = 0; 4821 ampdu = 0; 4822 } 4823 4824 /* ask MAC to insert timestamp into probe responses */ 4825 4826 if ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) == 4827 (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP)) 4828 txwi->mpdu_density_flags |= 4829 (RT2860_TXWI_FLAGS_TS << RT2860_TXWI_FLAGS_SHIFT); 4830 4831 if (ieee80211_radiotap_active_vap(vap)) 4832 { 4833 tap = &sc->txtap; 4834 4835 tap->flags = IEEE80211_RADIOTAP_F_DATAPAD; 4836 tap->chan_flags = htole32(ic->ic_curchan->ic_flags); 4837 tap->chan_freq = htole16(ic->ic_curchan->ic_freq); 4838 tap->chan_ieee = ic->ic_curchan->ic_ieee; 4839 tap->chan_maxpow = 0; 4840 4841 if (ni->ni_flags & IEEE80211_NODE_HT) 4842 tap->rate = mcs | IEEE80211_RATE_MCS; 4843 else 4844 tap->rate = rate; 4845 4846 if (mcs & RT2860_TXWI_MCS_SHOTPRE) 4847 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE; 4848 4849 if (shortgi) 4850 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI; 4851 4852 if (wh->i_fc[1] & IEEE80211_FC1_WEP) 4853 tap->flags |= IEEE80211_RADIOTAP_F_WEP; 4854 4855 /* XXX use temporarily radiotap CFP flag as A-MPDU flag */ 4856 4857 if (ampdu) 4858 tap->flags |= IEEE80211_RADIOTAP_F_CFP; 4859 4860 if (wh->i_fc[1] & IEEE80211_FC1_WEP) 4861 { 4862 wh->i_fc[1] &= ~IEEE80211_FC1_WEP; 4863 4864 ieee80211_radiotap_tx(vap, m); 4865 4866 wh->i_fc[1] |= IEEE80211_FC1_WEP; 4867 } 4868 else 4869 { 4870 ieee80211_radiotap_tx(vap, m); 4871 } 4872 } 4873 4874 /* copy and trim 802.11 header */ 4875 4876 m_copydata(m, 0, hdrsize, (caddr_t) (txwi + 1)); 4877 m_adj(m, hdrspace); 4878 4879 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag, data->dma_map, m, 4880 dma_seg, &ndmasegs, BUS_DMA_NOWAIT); 4881 if (error != 0) 4882 { 4883 /* too many fragments, linearize */ 4884 4885 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 4886 "%s: could not load mbuf DMA map, trying to linearize mbuf: ndmasegs=%d, len=%d, error=%d\n", 4887 device_get_nameunit(sc->dev), ndmasegs, m->m_pkthdr.len, error); 4888 4889 m = m_defrag(m, M_DONTWAIT); 4890 if (m == NULL) 4891 return ENOMEM; 4892 4893 sc->tx_defrag_packets++; 4894 4895 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag, data->dma_map, m, 4896 dma_seg, &ndmasegs, BUS_DMA_NOWAIT); 4897 if (error != 0) 4898 { 4899 printf("%s: could not load mbuf DMA map: ndmasegs=%d, len=%d, error=%d\n", 4900 device_get_nameunit(sc->dev), ndmasegs, m->m_pkthdr.len, error); 4901 m_freem(m); 4902 return error; 4903 } 4904 } 4905 4906 if (m->m_pkthdr.len == 0) 4907 ndmasegs = 0; 4908 4909 /* determine how many Tx descs are required */ 4910 4911 ndescs = 1 + ndmasegs / 2; 4912 if ((ring->desc_queued + ndescs) > (RT2860_SOFTC_TX_RING_DESC_COUNT - 2)) 4913 { 4914 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 4915 "%s: there are not enough Tx descs\n", 4916 device_get_nameunit(sc->dev)); 4917 4918 sc->no_tx_desc_avail++; 4919 4920 bus_dmamap_unload(ring->data_dma_tag, data->dma_map); 4921 m_freem(m); 4922 return EFBIG; 4923 } 4924 4925 data->m = m; 4926 data->ni = ni; 4927 4928 /* set up Tx descs */ 4929 4930 /* first segment is Tx wireless info and 802.11 header */ 4931 4932 len = sizeof(struct rt2860_txwi) + hdrsize; 4933 4934 /* align end on a 4-bytes boundary */ 4935 4936 dmalen = (len + 3) & ~ 3; 4937 4938 memset((caddr_t) txwi + len, 0, dmalen - len); 4939 4940 qsel = RT2860_TXDESC_QSEL_EDCA; 4941 4942 desc->sdp0 = htole32(ring->seg0_phys_addr + ring->data_cur * RT2860_TX_DATA_SEG0_SIZE); 4943 desc->sdl0 = htole16(dmalen); 4944 desc->qsel_flags = (qsel << RT2860_TXDESC_QSEL_SHIFT); 4945 4946 /* set up payload segments */ 4947 4948 for (i = ndmasegs, j = 0; i >= 2; i -= 2) 4949 { 4950 desc->sdp1 = htole32(dma_seg[j].ds_addr); 4951 desc->sdl1 = htole16(dma_seg[j].ds_len); 4952 4953 ring->desc_queued++; 4954 ring->desc_cur = (ring->desc_cur + 1) % RT2860_SOFTC_TX_RING_DESC_COUNT; 4955 4956 j++; 4957 4958 desc = &ring->desc[ring->desc_cur]; 4959 4960 desc->sdp0 = htole32(dma_seg[j].ds_addr); 4961 desc->sdl0 = htole16(dma_seg[j].ds_len); 4962 desc->qsel_flags = (qsel << RT2860_TXDESC_QSEL_SHIFT); 4963 4964 j++; 4965 } 4966 4967 /* finalize last payload segment */ 4968 4969 if (i > 0) 4970 { 4971 desc->sdp1 = htole32(dma_seg[j].ds_addr); 4972 desc->sdl1 = htole16(dma_seg[j].ds_len | RT2860_TXDESC_SDL1_LASTSEG); 4973 } 4974 else 4975 { 4976 desc->sdl0 |= htole16(RT2860_TXDESC_SDL0_LASTSEG); 4977 desc->sdl1 = 0; 4978 } 4979 4980 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 4981 "%s: sending data: qid=%d, hdrsize=%d, hdrspace=%d, len=%d, " 4982 "bw=%d, stbc=%d, shortgi=%d, mcs=%d, wcid=0x%02x, " 4983 "ampdu=%d (density=%d, winsize=%d), mimops=%d, DMA len=%d, ndmasegs=%d, DMA ds_len=%d/%d/%d/%d/%d\n", 4984 device_get_nameunit(sc->dev), 4985 qid, hdrsize, hdrspace, m->m_pkthdr.len + hdrsize, 4986 bw, stbc, shortgi, mcs, wcid, ampdu, mpdu_density, bawin_size, mimops, dmalen, ndmasegs, 4987 (int) dma_seg[0].ds_len, (int) dma_seg[1].ds_len, (int) dma_seg[2].ds_len, (int) dma_seg[3].ds_len, (int) dma_seg[4].ds_len); 4988 4989 bus_dmamap_sync(ring->seg0_dma_tag, ring->seg0_dma_map, 4990 BUS_DMASYNC_PREWRITE); 4991 bus_dmamap_sync(ring->data_dma_tag, data->dma_map, 4992 BUS_DMASYNC_PREWRITE); 4993 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map, 4994 BUS_DMASYNC_PREWRITE); 4995 4996 ring->desc_queued++; 4997 ring->desc_cur = (ring->desc_cur + 1) % RT2860_SOFTC_TX_RING_DESC_COUNT; 4998 4999 ring->data_queued++; 5000 ring->data_cur = (ring->data_cur + 1) % RT2860_SOFTC_TX_RING_DATA_COUNT; 5001 5002 /* kick Tx */ 5003 5004 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_CTX_IDX(qid), ring->desc_cur); 5005 5006 return 0; 5007} 5008 5009/* 5010 * rt2860_tx_raw 5011static int rt2860_tx_raw(struct rt2860_softc *sc, 5012 struct mbuf *m, struct ieee80211_node *ni, 5013 const struct ieee80211_bpf_params *params) 5014{ 5015 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 5016 "%s: Tx raw\n", 5017 device_get_nameunit(sc->dev)); 5018 5019 return 0; 5020} 5021 */ 5022 5023/* 5024 * rt2860_intr 5025 */ 5026static void rt2860_intr(void *arg) 5027{ 5028 struct rt2860_softc *sc; 5029 struct ifnet *ifp; 5030 uint32_t status; 5031 5032 sc = arg; 5033#if !defined(__HAIKU__) 5034 ifp = sc->ifp; 5035 5036 /* acknowledge interrupts */ 5037 5038 status = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_INT_STATUS); 5039 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_STATUS, status); 5040 5041 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5042 "%s: interrupt: status = 0x%08x\n", 5043 device_get_nameunit(sc->dev), status); 5044 5045 if (status == 0xffffffff || /* device likely went away */ 5046 status == 0) /* not for us */ 5047 return; 5048 5049 sc->interrupts++; 5050 5051 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) 5052 return; 5053 5054#else 5055 status = sc->interrupt_status; 5056#endif 5057 5058 if (status & RT2860_REG_INT_TX_COHERENT) 5059 rt2860_tx_coherent_intr(sc); 5060 5061 if (status & RT2860_REG_INT_RX_COHERENT) 5062 rt2860_rx_coherent_intr(sc); 5063 5064 if (status & RT2860_REG_INT_TXRX_COHERENT) 5065 rt2860_txrx_coherent_intr(sc); 5066 5067 if (status & RT2860_REG_INT_FIFO_STA_FULL) 5068 rt2860_fifo_sta_full_intr(sc); 5069 5070 if (status & RT2860_REG_INT_TX_MGMT_DONE) 5071 rt2860_tx_intr(sc, 5); 5072 5073 if (status & RT2860_REG_INT_RX_DONE) 5074 rt2860_rx_intr(sc); 5075 5076 if (status & RT2860_REG_INT_RX_DELAY_DONE) 5077 rt2860_rx_delay_intr(sc); 5078 5079 if (status & RT2860_REG_INT_TX_HCCA_DONE) 5080 rt2860_tx_intr(sc, 4); 5081 5082 if (status & RT2860_REG_INT_TX_AC3_DONE) 5083 rt2860_tx_intr(sc, 3); 5084 5085 if (status & RT2860_REG_INT_TX_AC2_DONE) 5086 rt2860_tx_intr(sc, 2); 5087 5088 if (status & RT2860_REG_INT_TX_AC1_DONE) 5089 rt2860_tx_intr(sc, 1); 5090 5091 if (status & RT2860_REG_INT_TX_AC0_DONE) 5092 rt2860_tx_intr(sc, 0); 5093 5094 if (status & RT2860_REG_INT_TX_DELAY_DONE) 5095 rt2860_tx_delay_intr(sc); 5096 5097 if (status & RT2860_REG_INT_PRE_TBTT) 5098 rt2860_pre_tbtt_intr(sc); 5099 5100 if (status & RT2860_REG_INT_TBTT) 5101 rt2860_tbtt_intr(sc); 5102 5103 if (status & RT2860_REG_INT_MCU_CMD) 5104 rt2860_mcu_cmd_intr(sc); 5105 5106 if (status & RT2860_REG_INT_AUTO_WAKEUP) 5107 rt2860_auto_wakeup_intr(sc); 5108 5109 if (status & RT2860_REG_INT_GP_TIMER) 5110 rt2860_gp_timer_intr(sc); 5111} 5112 5113/* 5114 * rt2860_tx_coherent_intr 5115 */ 5116static void rt2860_tx_coherent_intr(struct rt2860_softc *sc) 5117{ 5118 uint32_t tmp; 5119 int i; 5120 5121 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5122 "%s: Tx coherent interrupt\n", 5123 device_get_nameunit(sc->dev)); 5124 5125 sc->tx_coherent_interrupts++; 5126 5127 /* restart DMA engine */ 5128 5129 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG); 5130 5131 tmp &= ~(RT2860_REG_TX_WB_DDONE | 5132 RT2860_REG_RX_DMA_ENABLE | 5133 RT2860_REG_TX_DMA_ENABLE); 5134 5135 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp); 5136 5137 /* init Tx rings (4 EDCAs + HCCA + MGMT) */ 5138 5139 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++) 5140 rt2860_reset_tx_ring(sc, &sc->tx_ring[i]); 5141 5142 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++) 5143 { 5144 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_BASE_PTR(i), 5145 sc->tx_ring[i].desc_phys_addr); 5146 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_MAX_CNT(i), 5147 RT2860_SOFTC_TX_RING_DESC_COUNT); 5148 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_CTX_IDX(i), 0); 5149 } 5150 5151 /* init Rx ring */ 5152 5153 rt2860_reset_rx_ring(sc, &sc->rx_ring); 5154 5155 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_BASE_PTR, 5156 sc->rx_ring.desc_phys_addr); 5157 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_MAX_CNT, 5158 RT2860_SOFTC_RX_RING_DATA_COUNT); 5159 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX, 5160 RT2860_SOFTC_RX_RING_DATA_COUNT - 1); 5161 5162 rt2860_txrx_enable(sc); 5163} 5164 5165/* 5166 * rt2860_rx_coherent_intr 5167 */ 5168static void rt2860_rx_coherent_intr(struct rt2860_softc *sc) 5169{ 5170 uint32_t tmp; 5171 int i; 5172 5173 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5174 "%s: Rx coherent interrupt\n", 5175 device_get_nameunit(sc->dev)); 5176 5177 sc->rx_coherent_interrupts++; 5178 5179 /* restart DMA engine */ 5180 5181 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG); 5182 5183 tmp &= ~(RT2860_REG_TX_WB_DDONE | 5184 RT2860_REG_RX_DMA_ENABLE | 5185 RT2860_REG_TX_DMA_ENABLE); 5186 5187 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp); 5188 5189 /* init Tx rings (4 EDCAs + HCCA + MGMT) */ 5190 5191 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++) 5192 rt2860_reset_tx_ring(sc, &sc->tx_ring[i]); 5193 5194 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++) 5195 { 5196 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_BASE_PTR(i), 5197 sc->tx_ring[i].desc_phys_addr); 5198 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_MAX_CNT(i), 5199 RT2860_SOFTC_TX_RING_DESC_COUNT); 5200 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_CTX_IDX(i), 0); 5201 } 5202 5203 /* init Rx ring */ 5204 5205 rt2860_reset_rx_ring(sc, &sc->rx_ring); 5206 5207 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_BASE_PTR, 5208 sc->rx_ring.desc_phys_addr); 5209 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_MAX_CNT, 5210 RT2860_SOFTC_RX_RING_DATA_COUNT); 5211 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX, 5212 RT2860_SOFTC_RX_RING_DATA_COUNT - 1); 5213 5214 rt2860_txrx_enable(sc); 5215} 5216 5217/* 5218 * rt2860_txrx_coherent_intr 5219 */ 5220static void rt2860_txrx_coherent_intr(struct rt2860_softc *sc) 5221{ 5222 uint32_t tmp; 5223 int i; 5224 5225 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5226 "%s: Tx/Rx coherent interrupt\n", 5227 device_get_nameunit(sc->dev)); 5228 5229 sc->txrx_coherent_interrupts++; 5230 5231 /* restart DMA engine */ 5232 5233 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG); 5234 5235 tmp &= ~(RT2860_REG_TX_WB_DDONE | 5236 RT2860_REG_RX_DMA_ENABLE | 5237 RT2860_REG_TX_DMA_ENABLE); 5238 5239 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp); 5240 5241 /* init Tx rings (4 EDCAs + HCCA + MGMT) */ 5242 5243 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++) 5244 rt2860_reset_tx_ring(sc, &sc->tx_ring[i]); 5245 5246 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++) 5247 { 5248 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_BASE_PTR(i), 5249 sc->tx_ring[i].desc_phys_addr); 5250 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_MAX_CNT(i), 5251 RT2860_SOFTC_TX_RING_DESC_COUNT); 5252 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_CTX_IDX(i), 0); 5253 } 5254 5255 /* init Rx ring */ 5256 5257 rt2860_reset_rx_ring(sc, &sc->rx_ring); 5258 5259 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_BASE_PTR, 5260 sc->rx_ring.desc_phys_addr); 5261 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_MAX_CNT, 5262 RT2860_SOFTC_RX_RING_DATA_COUNT); 5263 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX, 5264 RT2860_SOFTC_RX_RING_DATA_COUNT - 1); 5265 5266 rt2860_txrx_enable(sc); 5267} 5268 5269/* 5270 * rt2860_fifo_sta_full_intr 5271 */ 5272static void rt2860_fifo_sta_full_intr(struct rt2860_softc *sc) 5273{ 5274 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5275 "%s: FIFO statistic full interrupt\n", 5276 device_get_nameunit(sc->dev)); 5277 5278 sc->fifo_sta_full_interrupts++; 5279 5280 RT2860_SOFTC_LOCK(sc); 5281 5282 if (!(sc->intr_disable_mask & RT2860_REG_INT_FIFO_STA_FULL)) 5283 { 5284 rt2860_intr_disable(sc, RT2860_REG_INT_FIFO_STA_FULL); 5285 5286 taskqueue_enqueue(sc->taskqueue, &sc->fifo_sta_full_task); 5287 } 5288 5289 sc->intr_pending_mask |= RT2860_REG_INT_FIFO_STA_FULL; 5290 5291 RT2860_SOFTC_UNLOCK(sc); 5292} 5293 5294/* 5295 * rt2860_rx_intr 5296 */ 5297static void rt2860_rx_intr(struct rt2860_softc *sc) 5298{ 5299 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5300 "%s: Rx interrupt\n", 5301 device_get_nameunit(sc->dev)); 5302 5303 sc->rx_interrupts++; 5304 5305 RT2860_SOFTC_LOCK(sc); 5306 5307 if (!(sc->intr_disable_mask & RT2860_REG_INT_RX_DONE)) 5308 { 5309 rt2860_intr_disable(sc, RT2860_REG_INT_RX_DONE); 5310 5311 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task); 5312 } 5313 5314 sc->intr_pending_mask |= RT2860_REG_INT_RX_DONE; 5315 5316 RT2860_SOFTC_UNLOCK(sc); 5317} 5318 5319/* 5320 * rt2860_rx_delay_intr 5321 */ 5322static void rt2860_rx_delay_intr(struct rt2860_softc *sc) 5323{ 5324 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5325 "%s: Rx delay interrupt\n", 5326 device_get_nameunit(sc->dev)); 5327 5328 sc->rx_delay_interrupts++; 5329} 5330 5331/* 5332 * rt2860_tx_intr 5333 */ 5334static void rt2860_tx_intr(struct rt2860_softc *sc, int qid) 5335{ 5336 KASSERT(qid >= 0 && qid < RT2860_SOFTC_TX_RING_COUNT, 5337 ("%s: Tx interrupt: invalid qid=%d\n", 5338 device_get_nameunit(sc->dev), qid)); 5339 5340 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5341 "%s: Tx interrupt: qid=%d\n", 5342 device_get_nameunit(sc->dev), qid); 5343 5344 sc->tx_interrupts[qid]++; 5345 5346 RT2860_SOFTC_LOCK(sc); 5347 5348 if (!(sc->intr_disable_mask & (RT2860_REG_INT_TX_AC0_DONE << qid))) 5349 { 5350 rt2860_intr_disable(sc, (RT2860_REG_INT_TX_AC0_DONE << qid)); 5351 5352 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task); 5353 } 5354 5355 sc->intr_pending_mask |= (RT2860_REG_INT_TX_AC0_DONE << qid); 5356 5357 RT2860_SOFTC_UNLOCK(sc); 5358} 5359 5360/* 5361 * rt2860_tx_delay_intr 5362 */ 5363static void rt2860_tx_delay_intr(struct rt2860_softc *sc) 5364{ 5365 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5366 "%s: Tx delay interrupt\n", 5367 device_get_nameunit(sc->dev)); 5368 5369 sc->tx_delay_interrupts++; 5370} 5371 5372/* 5373 * rt2860_pre_tbtt_intr 5374 */ 5375static void rt2860_pre_tbtt_intr(struct rt2860_softc *sc) 5376{ 5377 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5378 "%s: Pre-TBTT interrupt\n", 5379 device_get_nameunit(sc->dev)); 5380 5381 sc->pre_tbtt_interrupts++; 5382} 5383 5384/* 5385 * rt2860_tbtt_intr 5386 */ 5387static void rt2860_tbtt_intr(struct rt2860_softc *sc) 5388{ 5389 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5390 "%s: TBTT interrupt\n", 5391 device_get_nameunit(sc->dev)); 5392 5393 sc->tbtt_interrupts++; 5394} 5395 5396/* 5397 * rt2860_mcu_cmd_intr 5398 */ 5399static void rt2860_mcu_cmd_intr(struct rt2860_softc *sc) 5400{ 5401 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5402 "%s: MCU command interrupt\n", 5403 device_get_nameunit(sc->dev)); 5404 5405 sc->mcu_cmd_interrupts++; 5406} 5407 5408/* 5409 * rt2860_auto_wakeup_intr 5410 */ 5411static void rt2860_auto_wakeup_intr(struct rt2860_softc *sc) 5412{ 5413 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5414 "%s: auto wakeup interrupt\n", 5415 device_get_nameunit(sc->dev)); 5416 5417 sc->auto_wakeup_interrupts++; 5418} 5419 5420/* 5421 * rt2860_gp_timer_intr 5422 */ 5423static void rt2860_gp_timer_intr(struct rt2860_softc *sc) 5424{ 5425 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR, 5426 "%s: GP timer interrupt\n", 5427 device_get_nameunit(sc->dev)); 5428 5429 sc->gp_timer_interrupts++; 5430} 5431 5432/* 5433 * rt2860_rx_done_task 5434 */ 5435static void rt2860_rx_done_task(void *context, int pending) 5436{ 5437 struct rt2860_softc *sc; 5438 struct ifnet *ifp; 5439 int again; 5440 5441 sc = context; 5442 ifp = sc->ifp; 5443 5444 RT2860_DPRINTF(sc, RT2860_DEBUG_RX, 5445 "%s: Rx done task\n", 5446 device_get_nameunit(sc->dev)); 5447 5448 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) 5449 return; 5450 5451 sc->intr_pending_mask &= ~RT2860_REG_INT_RX_DONE; 5452 5453 again = rt2860_rx_eof(sc, sc->rx_process_limit); 5454 5455 RT2860_SOFTC_LOCK(sc); 5456 5457 if ((sc->intr_pending_mask & RT2860_REG_INT_RX_DONE) || again) 5458 { 5459 RT2860_DPRINTF(sc, RT2860_DEBUG_RX, 5460 "%s: Rx done task: scheduling again\n", 5461 device_get_nameunit(sc->dev)); 5462 5463 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task); 5464 } 5465 else 5466 { 5467 rt2860_intr_enable(sc, RT2860_REG_INT_RX_DONE); 5468 } 5469 5470 RT2860_SOFTC_UNLOCK(sc); 5471} 5472 5473/* 5474 * rt2860_tx_done_task 5475 */ 5476static void rt2860_tx_done_task(void *context, int pending) 5477{ 5478 struct rt2860_softc *sc; 5479 struct ifnet *ifp; 5480 uint32_t intr_mask; 5481 int i; 5482 5483 sc = context; 5484 ifp = sc->ifp; 5485 5486 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 5487 "%s: Tx done task\n", 5488 device_get_nameunit(sc->dev)); 5489 5490 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) 5491 return; 5492 5493 for (i = RT2860_SOFTC_TX_RING_COUNT - 1; i >= 0; i--) 5494 { 5495 if (sc->intr_pending_mask & (RT2860_REG_INT_TX_AC0_DONE << i)) 5496 { 5497 sc->intr_pending_mask &= ~(RT2860_REG_INT_TX_AC0_DONE << i); 5498 5499 rt2860_tx_eof(sc, &sc->tx_ring[i]); 5500 } 5501 } 5502 5503 sc->tx_timer = 0; 5504 5505 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 5506 5507 intr_mask = (RT2860_REG_INT_TX_MGMT_DONE | 5508 RT2860_REG_INT_TX_HCCA_DONE | 5509 RT2860_REG_INT_TX_AC3_DONE | 5510 RT2860_REG_INT_TX_AC2_DONE | 5511 RT2860_REG_INT_TX_AC1_DONE | 5512 RT2860_REG_INT_TX_AC0_DONE); 5513 5514 RT2860_SOFTC_LOCK(sc); 5515 5516 rt2860_intr_enable(sc, ~sc->intr_pending_mask & 5517 (sc->intr_disable_mask & intr_mask)); 5518 5519 if (sc->intr_pending_mask & intr_mask) 5520 { 5521 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 5522 "%s: Tx done task: scheduling again\n", 5523 device_get_nameunit(sc->dev)); 5524 5525 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task); 5526 } 5527 5528 RT2860_SOFTC_UNLOCK(sc); 5529 5530 if (!IFQ_IS_EMPTY(&ifp->if_snd)) 5531 rt2860_start(ifp); 5532} 5533 5534/* 5535 * rt2860_fifo_sta_full_task 5536 */ 5537static void rt2860_fifo_sta_full_task(void *context, int pending) 5538{ 5539 struct rt2860_softc *sc; 5540 struct ifnet *ifp; 5541 5542 sc = context; 5543 ifp = sc->ifp; 5544 5545 RT2860_DPRINTF(sc, RT2860_DEBUG_STATS, 5546 "%s: FIFO statistic full task\n", 5547 device_get_nameunit(sc->dev)); 5548 5549 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) 5550 return; 5551 5552 sc->intr_pending_mask &= ~RT2860_REG_INT_FIFO_STA_FULL; 5553 5554 rt2860_drain_fifo_stats(sc); 5555 5556 RT2860_SOFTC_LOCK(sc); 5557 5558 if (sc->intr_pending_mask & RT2860_REG_INT_FIFO_STA_FULL) 5559 { 5560 RT2860_DPRINTF(sc, RT2860_DEBUG_STATS, 5561 "%s: FIFO statistic full task: scheduling again\n", 5562 device_get_nameunit(sc->dev)); 5563 5564 taskqueue_enqueue(sc->taskqueue, &sc->fifo_sta_full_task); 5565 } 5566 else 5567 { 5568 rt2860_intr_enable(sc, RT2860_REG_INT_FIFO_STA_FULL); 5569 } 5570 5571 RT2860_SOFTC_UNLOCK(sc); 5572 5573 if (!IFQ_IS_EMPTY(&ifp->if_snd)) 5574 rt2860_start(ifp); 5575} 5576 5577/* 5578 * rt2860_periodic_task 5579 */ 5580static void rt2860_periodic_task(void *context, int pending) 5581{ 5582 struct rt2860_softc *sc; 5583 struct ifnet *ifp; 5584 struct ieee80211com *ic; 5585 struct ieee80211vap *vap; 5586 5587 sc = context; 5588 ifp = sc->ifp; 5589 ic = ifp->if_l2com; 5590 vap = TAILQ_FIRST(&ic->ic_vaps); 5591 5592 RT2860_DPRINTF(sc, RT2860_DEBUG_PERIODIC, 5593 "%s: periodic task: round=%lu\n", 5594 device_get_nameunit(sc->dev), sc->periodic_round); 5595 5596 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) 5597 return; 5598 5599 RT2860_SOFTC_LOCK(sc); 5600 5601 sc->periodic_round++; 5602 5603 rt2860_update_stats(sc); 5604 5605 if ((sc->periodic_round % 10) == 0) 5606 { 5607 rt2860_bbp_tuning(sc); 5608 5609 rt2860_update_raw_counters(sc); 5610 5611 rt2860_watchdog(sc); 5612 5613 if (vap != NULL && vap->iv_opmode != IEEE80211_M_MONITOR && vap->iv_state == IEEE80211_S_RUN) 5614 { 5615 if (vap->iv_opmode == IEEE80211_M_STA) 5616 rt2860_amrr_update_iter_func(vap, vap->iv_bss); 5617 else 5618 ieee80211_iterate_nodes(&ic->ic_sta, rt2860_amrr_update_iter_func, vap); 5619 } 5620 } 5621 5622 RT2860_SOFTC_UNLOCK(sc); 5623 5624 callout_reset(&sc->periodic_ch, hz / 10, rt2860_periodic, sc); 5625} 5626 5627/* 5628 * rt2860_rx_eof 5629 */ 5630static int rt2860_rx_eof(struct rt2860_softc *sc, int limit) 5631{ 5632 struct ifnet *ifp; 5633 struct ieee80211com *ic; 5634 struct ieee80211_frame *wh; 5635 struct ieee80211_node *ni; 5636 struct rt2860_softc_node *rni; 5637 struct rt2860_softc_rx_radiotap_header *tap; 5638 struct rt2860_softc_rx_ring *ring; 5639 struct rt2860_rxdesc *desc; 5640 struct rt2860_softc_rx_data *data; 5641 struct rt2860_rxwi *rxwi; 5642 struct mbuf *m, *mnew; 5643 bus_dma_segment_t segs[1]; 5644 bus_dmamap_t dma_map; 5645 uint32_t index, desc_flags; 5646 uint8_t cipher_err, rssi, ant, phymode, bw, shortgi, stbc, mcs, keyidx, tid, frag; 5647 uint16_t seq; 5648 int8_t rssi_dbm; 5649 int error, nsegs, len, ampdu, amsdu, rssi_dbm_rel, nframes, i; 5650 5651 ifp = sc->ifp; 5652 ic = ifp->if_l2com; 5653 ring = &sc->rx_ring; 5654 5655 nframes = 0; 5656 5657 while (limit != 0) 5658 { 5659 index = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_RX_DRX_IDX); 5660 if (ring->cur == index) 5661 break; 5662 5663 desc = &ring->desc[ring->cur]; 5664 data = &ring->data[ring->cur]; 5665 5666 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map, 5667 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 5668#ifdef XXX_TESTED_AND_WORKED 5669 if (!(desc->sdl0 & htole16(RT2860_RXDESC_SDL0_DDONE))) 5670 break; 5671#endif 5672 5673 nframes++; 5674 5675 mnew = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); 5676 if (mnew == NULL) 5677 { 5678 sc->rx_mbuf_alloc_errors++; 5679 ifp->if_ierrors++; 5680 goto skip; 5681 } 5682 5683 mnew->m_len = mnew->m_pkthdr.len = MJUMPAGESIZE; 5684 5685 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag, ring->spare_dma_map, 5686 mnew, segs, &nsegs, BUS_DMA_NOWAIT); 5687 if (error != 0) 5688 { 5689 RT2860_DPRINTF(sc, RT2860_DEBUG_RX, 5690 "%s: could not load Rx mbuf DMA map: error=%d, nsegs=%d\n", 5691 device_get_nameunit(sc->dev), error, nsegs); 5692 5693 m_freem(mnew); 5694 5695 sc->rx_mbuf_dmamap_errors++; 5696 ifp->if_ierrors++; 5697 5698 goto skip; 5699 } 5700 5701 KASSERT(nsegs == 1, ("%s: too many DMA segments", 5702 device_get_nameunit(sc->dev))); 5703 5704 bus_dmamap_sync(ring->data_dma_tag, data->dma_map, 5705 BUS_DMASYNC_POSTREAD); 5706 bus_dmamap_unload(ring->data_dma_tag, data->dma_map); 5707 5708 dma_map = data->dma_map; 5709 data->dma_map = ring->spare_dma_map; 5710 ring->spare_dma_map = dma_map; 5711 5712 bus_dmamap_sync(ring->data_dma_tag, data->dma_map, 5713 BUS_DMASYNC_PREREAD); 5714 5715 m = data->m; 5716 5717 data->m = mnew; 5718 desc->sdp0 = htole32(segs[0].ds_addr); 5719 5720 desc_flags = le32toh(desc->flags); 5721 5722 RT2860_DPRINTF(sc, RT2860_DEBUG_RX, 5723 "%s: Rx frame: rxdesc flags=0x%08x\n", 5724 device_get_nameunit(sc->dev), desc_flags); 5725 5726 /* get Rx wireless info */ 5727 5728 rxwi = mtod(m, struct rt2860_rxwi *); 5729 len = (le16toh(rxwi->tid_size) >> RT2860_RXWI_SIZE_SHIFT) & 5730 RT2860_RXWI_SIZE_MASK; 5731 5732 /* check for L2 padding between IEEE 802.11 frame header and body */ 5733 5734 if (desc_flags & RT2860_RXDESC_FLAGS_L2PAD) 5735 { 5736 RT2860_DPRINTF(sc, RT2860_DEBUG_RX, 5737 "%s: L2 padding: len=%d\n", 5738 device_get_nameunit(sc->dev), len); 5739 5740 len += 2; 5741 } 5742 5743 m->m_pkthdr.rcvif = ifp; 5744 m->m_data = (caddr_t) (rxwi + 1); 5745 m->m_pkthdr.len = m->m_len = len; 5746 5747 /* check for crc errors */ 5748 5749 if (desc_flags & RT2860_RXDESC_FLAGS_CRC_ERR) 5750 { 5751 RT2860_DPRINTF(sc, RT2860_DEBUG_RX, 5752 "%s: rxdesc: crc error\n", 5753 device_get_nameunit(sc->dev)); 5754 5755 ifp->if_ierrors++; 5756 5757 if (!(ifp->if_flags & IFF_PROMISC)) 5758 { 5759 m_freem(m); 5760 goto skip; 5761 } 5762 } 5763 5764 wh = (struct ieee80211_frame *) (rxwi + 1); 5765 5766 /* check for cipher errors */ 5767 5768 if (desc_flags & RT2860_RXDESC_FLAGS_DECRYPTED) 5769 { 5770 cipher_err = ((desc_flags >> RT2860_RXDESC_FLAGS_CIPHER_ERR_SHIFT) & 5771 RT2860_RXDESC_FLAGS_CIPHER_ERR_MASK); 5772 if (cipher_err == RT2860_RXDESC_FLAGS_CIPHER_ERR_NONE) 5773 { 5774 if (wh->i_fc[1] & IEEE80211_FC1_WEP) 5775 wh->i_fc[1] &= ~IEEE80211_FC1_WEP; 5776 5777 m->m_flags |= M_WEP; 5778 5779 sc->rx_cipher_no_errors++; 5780 } 5781 else 5782 { 5783 RT2860_DPRINTF(sc, RT2860_DEBUG_RX, 5784 "%s: rxdesc: cipher error=0x%02x\n", 5785 device_get_nameunit(sc->dev), cipher_err); 5786 5787 if (cipher_err == RT2860_RXDESC_FLAGS_CIPHER_ERR_ICV) 5788 sc->rx_cipher_icv_errors++; 5789 else if (cipher_err == RT2860_RXDESC_FLAGS_CIPHER_ERR_MIC) 5790 sc->rx_cipher_mic_errors++; 5791 else if (cipher_err == RT2860_RXDESC_FLAGS_CIPHER_ERR_INVALID_KEY) 5792 sc->rx_cipher_invalid_key_errors++; 5793 5794 if ((cipher_err == RT2860_RXDESC_FLAGS_CIPHER_ERR_MIC) && 5795 (desc_flags & RT2860_RXDESC_FLAGS_MYBSS)) 5796 { 5797 ni = ieee80211_find_rxnode(ic, (const struct ieee80211_frame_min *) wh); 5798 if (ni != NULL) 5799 { 5800 keyidx = (rxwi->udf_bssidx_keyidx >> RT2860_RXWI_KEYIDX_SHIFT) & 5801 RT2860_RXWI_KEYIDX_MASK; 5802 5803 ieee80211_notify_michael_failure(ni->ni_vap, wh, keyidx); 5804 5805 ieee80211_free_node(ni); 5806 } 5807 } 5808 5809 ifp->if_ierrors++; 5810 5811 if (!(ifp->if_flags & IFF_PROMISC)) 5812 { 5813 m_free(m); 5814 goto skip; 5815 } 5816 } 5817 } 5818 else 5819 { 5820 if (wh->i_fc[1] & IEEE80211_FC1_WEP) 5821 { 5822 RT2860_DPRINTF(sc, RT2860_DEBUG_RX, 5823 "%s: rxdesc: not decrypted but protected flag set\n", 5824 device_get_nameunit(sc->dev)); 5825 5826 ifp->if_ierrors++; 5827 5828 if (!(ifp->if_flags & IFF_PROMISC)) 5829 { 5830 m_free(m); 5831 goto skip; 5832 } 5833 } 5834 } 5835 5836 /* check for A-MPDU */ 5837 5838 if (desc_flags & RT2860_RXDESC_FLAGS_BA) 5839 { 5840 m->m_flags |= M_AMPDU; 5841 5842 sc->rx_ampdu++; 5843 5844 if (wh->i_fc[1] & IEEE80211_FC1_RETRY) 5845 sc->rx_ampdu_retries++; 5846 5847 ampdu = 1; 5848 } 5849 else 5850 { 5851 ampdu = 0; 5852 } 5853 5854 /* check for A-MSDU */ 5855 5856 if (desc_flags & RT2860_RXDESC_FLAGS_AMSDU) 5857 { 5858 sc->rx_amsdu++; 5859 5860 amsdu = 1; 5861 } 5862 else 5863 { 5864 amsdu = 0; 5865 } 5866 5867 ant = rt2860_maxrssi_rxpath(sc, rxwi); 5868 rssi = rxwi->rssi[ant]; 5869 rssi_dbm = rt2860_rssi2dbm(sc, rssi, ant); 5870 phymode = ((rxwi->phymode_stbc_shortgi >> RT2860_RXWI_PHYMODE_SHIFT) & 5871 RT2860_RXWI_PHYMODE_MASK); 5872 bw = ((rxwi->bw_mcs >> RT2860_RXWI_BW_SHIFT) & RT2860_RXWI_BW_MASK); 5873 shortgi = ((rxwi->phymode_stbc_shortgi >> RT2860_RXWI_SHORTGI_SHIFT) & 5874 RT2860_RXWI_SHORTGI_MASK); 5875 stbc = ((rxwi->phymode_stbc_shortgi >> RT2860_RXWI_STBC_SHIFT) & 5876 RT2860_RXWI_STBC_MASK); 5877 mcs = ((rxwi->bw_mcs >> RT2860_RXWI_MCS_SHIFT) & RT2860_RXWI_MCS_MASK); 5878 tid = ((rxwi->tid_size >> RT2860_RXWI_TID_SHIFT) & RT2860_RXWI_TID_MASK); 5879 seq = ((rxwi->seq_frag >> RT2860_RXWI_SEQ_SHIFT) & RT2860_RXWI_SEQ_MASK); 5880 frag = ((rxwi->seq_frag >> RT2860_RXWI_FRAG_SHIFT) & RT2860_RXWI_FRAG_MASK); 5881 5882 if (ieee80211_radiotap_active(ic)) 5883 { 5884 tap = &sc->rxtap; 5885 5886 tap->flags = (desc_flags & RT2860_RXDESC_FLAGS_L2PAD) ? IEEE80211_RADIOTAP_F_DATAPAD : 0; 5887 tap->dbm_antsignal = rssi_dbm; 5888 tap->dbm_antnoise = RT2860_NOISE_FLOOR; 5889 tap->antenna = ant; 5890 tap->antsignal = rssi; 5891 tap->chan_flags = htole32(ic->ic_curchan->ic_flags); 5892 tap->chan_freq = htole16(ic->ic_curchan->ic_freq); 5893 tap->chan_ieee = ic->ic_curchan->ic_ieee; 5894 tap->chan_maxpow = 0; 5895 5896 if (phymode == RT2860_TXWI_PHYMODE_HT_MIXED || phymode == RT2860_TXWI_PHYMODE_HT_GF) 5897 tap->rate = mcs | IEEE80211_RATE_MCS; 5898 else 5899 tap->rate = rt2860_rxrate(rxwi); 5900 5901 if (desc_flags & RT2860_RXDESC_FLAGS_CRC_ERR) 5902 tap->flags |= IEEE80211_RADIOTAP_F_BADFCS; 5903 5904 if (desc_flags & RT2860_RXDESC_FLAGS_FRAG) 5905 tap->flags |= IEEE80211_RADIOTAP_F_FRAG; 5906 5907 if (rxwi->bw_mcs & RT2860_RXWI_MCS_SHOTPRE) 5908 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE; 5909 5910 if ((desc_flags & RT2860_RXDESC_FLAGS_DECRYPTED) || 5911 (wh->i_fc[1] & IEEE80211_FC1_WEP)) 5912 tap->flags |= IEEE80211_RADIOTAP_F_WEP; 5913 5914 if (shortgi) 5915 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI; 5916 5917 /* XXX use temporarily radiotap CFP flag as A-MPDU flag */ 5918 5919 if (ampdu) 5920 tap->flags |= IEEE80211_RADIOTAP_F_CFP; 5921 } 5922 5923 /* 5924 * net80211 assumes that RSSI data are in the range [-127..127] and 5925 * in .5 dBm units relative to the current noise floor 5926 */ 5927 5928 rssi_dbm_rel = (rssi_dbm - RT2860_NOISE_FLOOR) * 2; 5929 if (rssi_dbm_rel > 127) 5930 rssi_dbm_rel = 127; 5931 5932 RT2860_DPRINTF(sc, RT2860_DEBUG_RX, 5933 "%s: received frame: len=%d, phymode=%d, bw=%d, shortgi=%d, stbc=0x%02x, mcs=%d, " 5934 "ant=%d, rssi=%d/%d/%d, snr=%d/%d, wcid=0x%02x, ampdu=%d, amsdu=%d, tid=%d, seq=%d, frag=%d, " 5935 "retry=%d, rssi_dbm=%d, rssi_dbm_rel=%d\n", 5936 device_get_nameunit(sc->dev), 5937 len, phymode, bw, shortgi, stbc, mcs, 5938 ant, rxwi->rssi[0], rxwi->rssi[1], rxwi->rssi[2], 5939 rxwi->snr[0], rxwi->snr[1], 5940 rxwi->wcid, ampdu, amsdu, tid, seq, frag, (wh->i_fc[1] & IEEE80211_FC1_RETRY) ? 1 : 0, 5941 rssi_dbm, rssi_dbm_rel); 5942 5943 ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *) wh); 5944 if (ni != NULL) 5945 { 5946 rni = (struct rt2860_softc_node *) ni; 5947 5948 for (i = 0; i < RT2860_SOFTC_RSSI_COUNT; i++) 5949 { 5950 rni->last_rssi[i] = rxwi->rssi[i]; 5951 rni->last_rssi_dbm[i] = rt2860_rssi2dbm(sc, rxwi->rssi[i], i); 5952 } 5953 5954 ieee80211_input(ni, m, rssi_dbm_rel, RT2860_NOISE_FLOOR); 5955 ieee80211_free_node(ni); 5956 } 5957 else 5958 { 5959 ieee80211_input_all(ic, m, rssi_dbm_rel, RT2860_NOISE_FLOOR); 5960 } 5961 5962skip: 5963 5964 desc->sdl0 &= ~htole16(RT2860_RXDESC_SDL0_DDONE); 5965 5966 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map, 5967 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 5968 5969 ring->cur = (ring->cur + 1) % RT2860_SOFTC_RX_RING_DATA_COUNT; 5970 5971 limit--; 5972 } 5973 5974 if (ring->cur == 0) 5975 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX, 5976 RT2860_SOFTC_RX_RING_DATA_COUNT - 1); 5977 else 5978 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX, 5979 ring->cur - 1); 5980 5981 RT2860_DPRINTF(sc, RT2860_DEBUG_RX, 5982 "%s: Rx eof: nframes=%d\n", 5983 device_get_nameunit(sc->dev), nframes); 5984 5985 sc->rx_packets += nframes; 5986 5987 return (limit == 0); 5988} 5989 5990/* 5991 * rt2860_tx_eof 5992 */ 5993static void rt2860_tx_eof(struct rt2860_softc *sc, 5994 struct rt2860_softc_tx_ring *ring) 5995{ 5996 struct ifnet *ifp; 5997 struct rt2860_txdesc *desc; 5998 struct rt2860_softc_tx_data *data; 5999 uint32_t index; 6000 int ndescs, nframes; 6001 6002 ifp = sc->ifp; 6003 6004 ndescs = 0; 6005 nframes = 0; 6006 6007 for (;;) 6008 { 6009 index = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_TX_DTX_IDX(ring->qid)); 6010 if (ring->desc_next == index) 6011 break; 6012 6013 ndescs++; 6014 6015 rt2860_drain_fifo_stats(sc); 6016 6017 desc = &ring->desc[ring->desc_next]; 6018 6019 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map, 6020 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 6021 6022 if (desc->sdl0 & htole16(RT2860_TXDESC_SDL0_LASTSEG) || 6023 desc->sdl1 & htole16(RT2860_TXDESC_SDL1_LASTSEG)) 6024 { 6025 nframes++; 6026 6027 data = &ring->data[ring->data_next]; 6028 6029 if (data->m->m_flags & M_TXCB) 6030 ieee80211_process_callback(data->ni, data->m, 0); 6031 6032 bus_dmamap_sync(ring->data_dma_tag, data->dma_map, 6033 BUS_DMASYNC_POSTWRITE); 6034 bus_dmamap_unload(ring->data_dma_tag, data->dma_map); 6035 6036 m_freem(data->m); 6037 6038 ieee80211_free_node(data->ni); 6039 6040 data->m = NULL; 6041 data->ni = NULL; 6042 6043 ifp->if_opackets++; 6044 6045 RT2860_SOFTC_TX_RING_LOCK(ring); 6046 6047 ring->data_queued--; 6048 ring->data_next = (ring->data_next + 1) % RT2860_SOFTC_TX_RING_DATA_COUNT; 6049 6050 RT2860_SOFTC_TX_RING_UNLOCK(ring); 6051 } 6052 6053 desc->sdl0 &= ~htole16(RT2860_TXDESC_SDL0_DDONE); 6054 6055 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map, 6056 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 6057 6058 RT2860_SOFTC_TX_RING_LOCK(ring); 6059 6060 ring->desc_queued--; 6061 ring->desc_next = (ring->desc_next + 1) % RT2860_SOFTC_TX_RING_DESC_COUNT; 6062 6063 RT2860_SOFTC_TX_RING_UNLOCK(ring); 6064 } 6065 6066 RT2860_DPRINTF(sc, RT2860_DEBUG_TX, 6067 "%s: Tx eof: qid=%d, ndescs=%d, nframes=%d\n", 6068 device_get_nameunit(sc->dev), ring->qid, ndescs, nframes); 6069} 6070 6071/* 6072 * rt2860_update_stats 6073 */ 6074static void rt2860_update_stats(struct rt2860_softc *sc) 6075{ 6076 struct ifnet *ifp; 6077 struct ieee80211com *ic; 6078 uint32_t stacnt[3]; 6079 int beacons, noretryok, retryok, failed, underflows, zerolen; 6080 6081 ifp = sc->ifp; 6082 ic = ifp->if_l2com; 6083 6084 RT2860_DPRINTF(sc, RT2860_DEBUG_STATS, 6085 "%s: update statistic\n", 6086 device_get_nameunit(sc->dev)); 6087 6088 rt2860_drain_fifo_stats(sc); 6089 6090 /* read and clear Tx statistic registers */ 6091 6092 rt2860_io_mac_read_multi(sc, RT2860_REG_TX_STA_CNT0, 6093 stacnt, sizeof(stacnt)); 6094 6095 stacnt[0] = le32toh(stacnt[0]); 6096 stacnt[1] = le32toh(stacnt[1]); 6097 stacnt[2] = le32toh(stacnt[2]); 6098 6099 beacons = stacnt[0] >> 16; 6100 noretryok = stacnt[1] & 0xffff; 6101 retryok = stacnt[1] >> 16; 6102 failed = stacnt[0] & 0xffff; 6103 underflows = stacnt[2] >> 16; 6104 zerolen = stacnt[2] & 0xffff; 6105 6106 RT2860_DPRINTF(sc, RT2860_DEBUG_STATS, 6107 "%s: update statistic: beacons=%d, noretryok=%d, retryok=%d, failed=%d, underflows=%d, zerolen=%d\n", 6108 device_get_nameunit(sc->dev), 6109 beacons, noretryok, retryok, failed, underflows, zerolen); 6110 6111 ifp->if_oerrors += failed; 6112 6113 sc->tx_beacons += beacons; 6114 sc->tx_noretryok += noretryok; 6115 sc->tx_retryok += retryok; 6116 sc->tx_failed += failed; 6117 sc->tx_underflows += underflows; 6118 sc->tx_zerolen += zerolen; 6119} 6120 6121/* 6122 * rt2860_bbp_tuning 6123 */ 6124static void rt2860_bbp_tuning(struct rt2860_softc *sc) 6125{ 6126 struct ifnet *ifp; 6127 struct ieee80211com *ic; 6128 struct ieee80211vap *vap; 6129 struct ieee80211_node *ni; 6130 int chan, group; 6131 int8_t rssi, old, new; 6132 6133 /* RT2860C does not support BBP tuning */ 6134 6135 if (sc->mac_rev == 0x28600100) 6136 return; 6137 6138 ifp = sc->ifp; 6139 ic = ifp->if_l2com; 6140 vap = TAILQ_FIRST(&ic->ic_vaps); 6141 6142 if ((ic->ic_flags & IEEE80211_F_SCAN) || vap == NULL || 6143 vap->iv_opmode != IEEE80211_M_STA || vap->iv_state != IEEE80211_S_RUN) 6144 return; 6145 6146 ni = vap->iv_bss; 6147 6148 chan = ieee80211_chan2ieee(ic, ni->ni_chan); 6149 6150 if (chan <= 14) 6151 group = 0; 6152 else if (chan <= 64) 6153 group = 1; 6154 else if (chan <= 128) 6155 group = 2; 6156 else 6157 group = 3; 6158 6159 rssi = ieee80211_getrssi(vap); 6160 6161 if (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) 6162 { 6163 new = 0x2e + sc->lna_gain[group]; 6164 } 6165 else 6166 { 6167 if (!IEEE80211_IS_CHAN_HT40(ni->ni_chan)) 6168 new = 0x32 + sc->lna_gain[group] * 5 / 3; 6169 else 6170 new = 0x3a + sc->lna_gain[group] * 5 / 3; 6171 } 6172 6173 /* Tune if absolute average RSSI is greater than -80 */ 6174 6175 if (rssi > 30) 6176 new += 0x10; 6177 6178 old = rt2860_io_bbp_read(sc, 66); 6179 6180 if (old != new) 6181 rt2860_io_bbp_write(sc, 66, new); 6182} 6183 6184/* 6185 * rt2860_watchdog 6186 */ 6187static void rt2860_watchdog(struct rt2860_softc *sc) 6188{ 6189 uint32_t tmp; 6190 int ntries; 6191 6192 tmp = rt2860_io_mac_read(sc, RT2860_REG_PBF_TXRXQ_PCNT); 6193 6194 RT2860_DPRINTF(sc, RT2860_DEBUG_WATCHDOG, 6195 "%s: watchdog: TXRXQ_PCNT=0x%08x\n", 6196 device_get_nameunit(sc->dev), tmp); 6197 6198 if (((tmp >> RT2860_REG_TX0Q_PCNT_SHIFT) & RT2860_REG_TX0Q_PCNT_MASK) != 0) 6199 { 6200 sc->tx_queue_not_empty[0]++; 6201 6202 rt2860_io_mac_write(sc, RT2860_REG_PBF_CFG, 0xf40012); 6203 6204 for (ntries = 0; ntries < 10; ntries++) 6205 { 6206 tmp = rt2860_io_mac_read(sc, RT2860_REG_PBF_TXRXQ_PCNT); 6207 if (((tmp >> RT2860_REG_TX0Q_PCNT_SHIFT) & RT2860_REG_TX0Q_PCNT_MASK) == 0) 6208 break; 6209 6210 DELAY(1); 6211 } 6212 6213 rt2860_io_mac_write(sc, RT2860_REG_PBF_CFG, 0xf40006); 6214 } 6215 6216 if (((tmp >> RT2860_REG_TX1Q_PCNT_SHIFT) & RT2860_REG_TX1Q_PCNT_MASK) != 0) 6217 { 6218 sc->tx_queue_not_empty[1]++; 6219 6220 rt2860_io_mac_write(sc, RT2860_REG_PBF_CFG, 0xf4000a); 6221 6222 for (ntries = 0; ntries < 10; ntries++) 6223 { 6224 tmp = rt2860_io_mac_read(sc, RT2860_REG_PBF_TXRXQ_PCNT); 6225 if (((tmp >> RT2860_REG_TX1Q_PCNT_SHIFT) & RT2860_REG_TX1Q_PCNT_MASK) == 0) 6226 break; 6227 6228 DELAY(1); 6229 } 6230 6231 rt2860_io_mac_write(sc, RT2860_REG_PBF_CFG, 0xf40006); 6232 } 6233} 6234 6235/* 6236 * rt2860_drain_fifo_stats 6237 */ 6238static void rt2860_drain_fifo_stats(struct rt2860_softc *sc) 6239{ 6240 struct ifnet *ifp; 6241 uint32_t stats; 6242 uint8_t wcid, mcs, pid; 6243 int ok, agg, retrycnt; 6244 6245 ifp = sc->ifp; 6246 6247 /* drain Tx status FIFO (maxsize = 16) */ 6248 6249 while ((stats = rt2860_io_mac_read(sc, RT2860_REG_TX_STA_FIFO)) & 6250 RT2860_REG_TX_STA_FIFO_VALID) 6251 { 6252 wcid = (stats >> RT2860_REG_TX_STA_FIFO_WCID_SHIFT) & 6253 RT2860_REG_TX_STA_FIFO_WCID_MASK; 6254 6255 /* if no ACK was requested, no feedback is available */ 6256 6257 if (!(stats & RT2860_REG_TX_STA_FIFO_ACK_REQ) || wcid == RT2860_WCID_RESERVED) 6258 continue; 6259 6260 /* update AMRR statistic */ 6261 6262 ok = (stats & RT2860_REG_TX_STA_FIFO_TX_OK) ? 1 : 0; 6263 agg = (stats & RT2860_REG_TX_STA_FIFO_AGG) ? 1 : 0; 6264 mcs = (stats >> RT2860_REG_TX_STA_FIFO_MCS_SHIFT) & 6265 RT2860_REG_TX_STA_FIFO_MCS_MASK; 6266 pid = (stats >> RT2860_REG_TX_STA_FIFO_PID_SHIFT) & 6267 RT2860_REG_TX_STA_FIFO_PID_MASK; 6268 retrycnt = (mcs < 0xf) ? (pid - mcs - 1) : 0; 6269 6270 RT2860_DPRINTF(sc, RT2860_DEBUG_STATS, 6271 "%s: FIFO statistic: wcid=0x%02x, ok=%d, agg=%d, mcs=0x%02x, pid=0x%02x, retrycnt=%d\n", 6272 device_get_nameunit(sc->dev), 6273 wcid, ok, agg, mcs, pid, retrycnt); 6274 6275 rt2860_amrr_tx_complete(&sc->amrr_node[wcid], ok, retrycnt); 6276 6277 if (!ok) 6278 ifp->if_oerrors++; 6279 } 6280} 6281 6282/* 6283 * rt2860_update_raw_counters 6284 */ 6285static void rt2860_update_raw_counters(struct rt2860_softc *sc) 6286{ 6287 uint32_t tmp; 6288 6289 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT); 6290 6291 sc->tx_nonagg += tmp & 0xffff; 6292 sc->tx_agg += tmp >> 16; 6293 6294 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT0); 6295 6296 sc->tx_ampdu += (tmp & 0xffff) / 1 + (tmp >> 16) / 2; 6297 6298 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT1); 6299 6300 sc->tx_ampdu += (tmp & 0xffff) / 3 + (tmp >> 16) / 4; 6301 6302 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT2); 6303 6304 sc->tx_ampdu += (tmp & 0xffff) / 5 + (tmp >> 16) / 6; 6305 6306 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT3); 6307 6308 sc->tx_ampdu += (tmp & 0xffff) / 7 + (tmp >> 16) / 8; 6309 6310 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT4); 6311 6312 sc->tx_ampdu += (tmp & 0xffff) / 9 + (tmp >> 16) / 10; 6313 6314 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT5); 6315 6316 sc->tx_ampdu += (tmp & 0xffff) / 11 + (tmp >> 16) / 12; 6317 6318 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT6); 6319 6320 sc->tx_ampdu += (tmp & 0xffff) / 13 + (tmp >> 16) / 14; 6321 6322 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT7); 6323 6324 sc->tx_ampdu += (tmp & 0xffff) / 15 + (tmp >> 16) / 16; 6325 6326 tmp = rt2860_io_mac_read(sc, RT2860_REG_RX_STA_CNT0); 6327 6328 sc->rx_crc_errors += tmp & 0xffff; 6329 sc->rx_phy_errors += tmp >> 16; 6330 6331 tmp = rt2860_io_mac_read(sc, RT2860_REG_RX_STA_CNT1); 6332 6333 sc->rx_false_ccas += tmp & 0xffff; 6334 sc->rx_plcp_errors += tmp >> 16; 6335 6336 tmp = rt2860_io_mac_read(sc, RT2860_REG_RX_STA_CNT2); 6337 6338 sc->rx_dup_packets += tmp & 0xffff; 6339 sc->rx_fifo_overflows += tmp >> 16; 6340 6341 tmp = rt2860_io_mac_read(sc, RT2860_REG_TXRX_MPDU_DEN_CNT); 6342 6343 sc->tx_mpdu_zero_density += tmp & 0xffff; 6344 sc->rx_mpdu_zero_density += tmp >> 16; 6345} 6346 6347/* 6348 * rt2860_intr_enable 6349 */ 6350static void rt2860_intr_enable(struct rt2860_softc *sc, uint32_t intr_mask) 6351{ 6352 uint32_t tmp; 6353 6354 sc->intr_disable_mask &= ~intr_mask; 6355 6356 tmp = sc->intr_enable_mask & ~sc->intr_disable_mask; 6357 6358 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_MASK, tmp); 6359} 6360 6361/* 6362 * rt2860_intr_disable 6363 */ 6364static void rt2860_intr_disable(struct rt2860_softc *sc, uint32_t intr_mask) 6365{ 6366 uint32_t tmp; 6367 6368 sc->intr_disable_mask |= intr_mask; 6369 6370 tmp = sc->intr_enable_mask & ~sc->intr_disable_mask; 6371 6372 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_MASK, tmp); 6373} 6374 6375/* 6376 * rt2860_txrx_enable 6377 */ 6378static int rt2860_txrx_enable(struct rt2860_softc *sc) 6379{ 6380 struct ieee80211com *ic; 6381 struct ifnet *ifp; 6382 uint32_t tmp; 6383 int ntries; 6384 6385 ifp = sc->ifp; 6386 ic = ifp->if_l2com; 6387 6388 /* enable Tx/Rx DMA engine */ 6389 6390 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL, RT2860_REG_TX_ENABLE); 6391 6392 for (ntries = 0; ntries < 200; ntries++) 6393 { 6394 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG); 6395 if (!(tmp & (RT2860_REG_TX_DMA_BUSY | RT2860_REG_RX_DMA_BUSY))) 6396 break; 6397 6398 DELAY(1000); 6399 } 6400 6401 if (ntries == 200) 6402 { 6403 printf("%s: timeout waiting for DMA engine\n", 6404 device_get_nameunit(sc->dev)); 6405 return -1; 6406 } 6407 6408 DELAY(50); 6409 6410 tmp |= RT2860_REG_TX_WB_DDONE | 6411 RT2860_REG_RX_DMA_ENABLE | 6412 RT2860_REG_TX_DMA_ENABLE | 6413 (RT2860_REG_WPDMA_BT_SIZE64 << RT2860_REG_WPDMA_BT_SIZE_SHIFT); 6414 6415 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp); 6416 6417 /* set Rx filter */ 6418 6419 tmp = RT2860_REG_RX_FILTER_DROP_CRC_ERR | 6420 RT2860_REG_RX_FILTER_DROP_PHY_ERR; 6421 6422 if (ic->ic_opmode != IEEE80211_M_MONITOR) 6423 { 6424 tmp |= RT2860_REG_RX_FILTER_DROP_DUPL | 6425 RT2860_REG_RX_FILTER_DROP_CTS | 6426 RT2860_REG_RX_FILTER_DROP_BA | 6427 RT2860_REG_RX_FILTER_DROP_ACK | 6428 RT2860_REG_RX_FILTER_DROP_VER_ERR | 6429 RT2860_REG_RX_FILTER_DROP_CTRL_RSV | 6430 RT2860_REG_RX_FILTER_DROP_CFACK | 6431 RT2860_REG_RX_FILTER_DROP_CFEND; 6432 6433 if (ic->ic_opmode == IEEE80211_M_STA) 6434 tmp |= RT2860_REG_RX_FILTER_DROP_RTS | 6435 RT2860_REG_RX_FILTER_DROP_PSPOLL; 6436 6437 if (!(ifp->if_flags & IFF_PROMISC)) 6438 tmp |= RT2860_REG_RX_FILTER_DROP_UC_NOME; 6439 } 6440 6441 rt2860_io_mac_write(sc, RT2860_REG_RX_FILTER_CFG, tmp); 6442 6443 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL, 6444 RT2860_REG_RX_ENABLE | RT2860_REG_TX_ENABLE); 6445 6446 return 0; 6447} 6448 6449/* 6450 * rt2860_alloc_rx_ring 6451 */ 6452static int rt2860_alloc_rx_ring(struct rt2860_softc *sc, 6453 struct rt2860_softc_rx_ring *ring) 6454{ 6455 struct rt2860_rxdesc *desc; 6456 struct rt2860_softc_rx_data *data; 6457 bus_dma_segment_t segs[1]; 6458 int i, nsegs, error; 6459 6460 error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0, 6461 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 6462 RT2860_SOFTC_RX_RING_DATA_COUNT * sizeof(struct rt2860_rxdesc), 1, 6463 RT2860_SOFTC_RX_RING_DATA_COUNT * sizeof(struct rt2860_rxdesc), 6464 0, NULL, NULL, &ring->desc_dma_tag); 6465 if (error != 0) 6466 { 6467 printf("%s: could not create Rx desc DMA tag\n", 6468 device_get_nameunit(sc->dev)); 6469 goto fail; 6470 } 6471 6472 error = bus_dmamem_alloc(ring->desc_dma_tag, (void **) &ring->desc, 6473 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->desc_dma_map); 6474 if (error != 0) 6475 { 6476 printf("%s: could not allocate Rx desc DMA memory\n", 6477 device_get_nameunit(sc->dev)); 6478 goto fail; 6479 } 6480 6481 error = bus_dmamap_load(ring->desc_dma_tag, ring->desc_dma_map, 6482 ring->desc, 6483 RT2860_SOFTC_RX_RING_DATA_COUNT * sizeof(struct rt2860_rxdesc), 6484 rt2860_dma_map_addr, &ring->desc_phys_addr, 0); 6485 if (error != 0) 6486 { 6487 printf("%s: could not load Rx desc DMA map\n", 6488 device_get_nameunit(sc->dev)); 6489 goto fail; 6490 } 6491 6492 error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0, 6493 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 6494 MJUMPAGESIZE, 1, MJUMPAGESIZE, 0, NULL, NULL, 6495 &ring->data_dma_tag); 6496 if (error != 0) 6497 { 6498 printf("%s: could not create Rx data DMA tag\n", 6499 device_get_nameunit(sc->dev)); 6500 goto fail; 6501 } 6502 6503 for (i = 0; i < RT2860_SOFTC_RX_RING_DATA_COUNT; i++) 6504 { 6505 desc = &ring->desc[i]; 6506 data = &ring->data[i]; 6507 6508 error = bus_dmamap_create(ring->data_dma_tag, 0, &data->dma_map); 6509 if (error != 0) 6510 { 6511 printf("%s: could not create Rx data DMA map\n", 6512 device_get_nameunit(sc->dev)); 6513 goto fail; 6514 } 6515 6516 data->m = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); 6517 if (data->m == NULL) 6518 { 6519 printf("%s: could not allocate Rx mbuf\n", 6520 device_get_nameunit(sc->dev)); 6521 error = ENOMEM; 6522 goto fail; 6523 } 6524 6525 data->m->m_len = data->m->m_pkthdr.len = MJUMPAGESIZE; 6526 6527 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag, data->dma_map, 6528 data->m, segs, &nsegs, BUS_DMA_NOWAIT); 6529 if (error != 0) 6530 { 6531 printf("%s: could not load Rx mbuf DMA map\n", 6532 device_get_nameunit(sc->dev)); 6533 goto fail; 6534 } 6535 6536 KASSERT(nsegs == 1, ("%s: too many DMA segments", 6537 device_get_nameunit(sc->dev))); 6538 6539 desc->sdp0 = htole32(segs[0].ds_addr); 6540 desc->sdl0 = htole16(MJUMPAGESIZE); 6541 } 6542 6543 error = bus_dmamap_create(ring->data_dma_tag, 0, &ring->spare_dma_map); 6544 if (error != 0) 6545 { 6546 printf("%s: could not create Rx spare DMA map\n", 6547 device_get_nameunit(sc->dev)); 6548 goto fail; 6549 } 6550 6551 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map, 6552 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 6553 6554 return 0; 6555 6556fail: 6557 6558 rt2860_free_rx_ring(sc, ring); 6559 6560 return error; 6561} 6562 6563/* 6564 * rt2860_reset_rx_ring 6565 */ 6566static void rt2860_reset_rx_ring(struct rt2860_softc *sc, 6567 struct rt2860_softc_rx_ring *ring) 6568{ 6569 struct rt2860_rxdesc *desc; 6570 int i; 6571 6572 for (i = 0; i < RT2860_SOFTC_RX_RING_DATA_COUNT; i++) 6573 { 6574 desc = &ring->desc[i]; 6575 6576 desc->sdl0 &= ~htole16(RT2860_RXDESC_SDL0_DDONE); 6577 } 6578 6579 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map, 6580 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 6581 6582 ring->cur = 0; 6583} 6584 6585/* 6586 * rt2860_free_rx_ring 6587 */ 6588static void rt2860_free_rx_ring(struct rt2860_softc *sc, 6589 struct rt2860_softc_rx_ring *ring) 6590{ 6591 struct rt2860_softc_rx_data *data; 6592 int i; 6593 6594 if (ring->desc != NULL) 6595 { 6596 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map, 6597 BUS_DMASYNC_POSTWRITE); 6598 bus_dmamap_unload(ring->desc_dma_tag, ring->desc_dma_map); 6599 bus_dmamem_free(ring->desc_dma_tag, ring->desc, 6600 ring->desc_dma_map); 6601 } 6602 6603 if (ring->desc_dma_tag != NULL) 6604 bus_dma_tag_destroy(ring->desc_dma_tag); 6605 6606 for (i = 0; i < RT2860_SOFTC_RX_RING_DATA_COUNT; i++) 6607 { 6608 data = &ring->data[i]; 6609 6610 if (data->m != NULL) 6611 { 6612 bus_dmamap_sync(ring->data_dma_tag, data->dma_map, 6613 BUS_DMASYNC_POSTREAD); 6614 bus_dmamap_unload(ring->data_dma_tag, data->dma_map); 6615 m_freem(data->m); 6616 } 6617 6618 if (data->dma_map != NULL) 6619 bus_dmamap_destroy(ring->data_dma_tag, data->dma_map); 6620 } 6621 6622 if (ring->spare_dma_map != NULL) 6623 bus_dmamap_destroy(ring->data_dma_tag, ring->spare_dma_map); 6624 6625 if (ring->data_dma_tag != NULL) 6626 bus_dma_tag_destroy(ring->data_dma_tag); 6627} 6628 6629/* 6630 * rt2860_alloc_tx_ring 6631 */ 6632static int rt2860_alloc_tx_ring(struct rt2860_softc *sc, 6633 struct rt2860_softc_tx_ring *ring, int qid) 6634{ 6635 struct rt2860_softc_tx_data *data; 6636 int error, i; 6637 6638 mtx_init(&ring->lock, device_get_nameunit(sc->dev), NULL, MTX_DEF); 6639 6640 error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0, 6641 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 6642 RT2860_SOFTC_TX_RING_DESC_COUNT * sizeof(struct rt2860_txdesc), 1, 6643 RT2860_SOFTC_TX_RING_DESC_COUNT * sizeof(struct rt2860_txdesc), 6644 0, NULL, NULL, &ring->desc_dma_tag); 6645 if (error != 0) 6646 { 6647 printf("%s: could not create Tx desc DMA tag\n", 6648 device_get_nameunit(sc->dev)); 6649 goto fail; 6650 } 6651 6652 error = bus_dmamem_alloc(ring->desc_dma_tag, (void **) &ring->desc, 6653 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->desc_dma_map); 6654 if (error != 0) 6655 { 6656 printf("%s: could not allocate Tx desc DMA memory\n", 6657 device_get_nameunit(sc->dev)); 6658 goto fail; 6659 } 6660 6661 error = bus_dmamap_load(ring->desc_dma_tag, ring->desc_dma_map, 6662 ring->desc, 6663 RT2860_SOFTC_TX_RING_DESC_COUNT * sizeof(struct rt2860_txdesc), 6664 rt2860_dma_map_addr, &ring->desc_phys_addr, 0); 6665 if (error != 0) 6666 { 6667 printf("%s: could not load Tx desc DMA map\n", 6668 device_get_nameunit(sc->dev)); 6669 goto fail; 6670 } 6671 6672 ring->desc_queued = 0; 6673 ring->desc_cur = 0; 6674 ring->desc_next = 0; 6675 6676 error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0, 6677 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 6678 RT2860_SOFTC_TX_RING_DATA_COUNT * RT2860_TX_DATA_SEG0_SIZE, 1, 6679 RT2860_SOFTC_TX_RING_DATA_COUNT * RT2860_TX_DATA_SEG0_SIZE, 6680 0, NULL, NULL, &ring->seg0_dma_tag); 6681 if (error != 0) 6682 { 6683 printf("%s: could not create Tx seg0 DMA tag\n", 6684 device_get_nameunit(sc->dev)); 6685 goto fail; 6686 } 6687 6688 error = bus_dmamem_alloc(ring->seg0_dma_tag, (void **) &ring->seg0, 6689 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->seg0_dma_map); 6690 if (error != 0) 6691 { 6692 printf("%s: could not allocate Tx seg0 DMA memory\n", 6693 device_get_nameunit(sc->dev)); 6694 goto fail; 6695 } 6696 6697 error = bus_dmamap_load(ring->seg0_dma_tag, ring->seg0_dma_map, 6698 ring->seg0, 6699 RT2860_SOFTC_TX_RING_DATA_COUNT * RT2860_TX_DATA_SEG0_SIZE, 6700 rt2860_dma_map_addr, &ring->seg0_phys_addr, 0); 6701 if (error != 0) 6702 { 6703 printf("%s: could not load Tx seg0 DMA map\n", 6704 device_get_nameunit(sc->dev)); 6705 goto fail; 6706 } 6707 6708 error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0, 6709 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 6710 MJUMPAGESIZE, RT2860_SOFTC_MAX_SCATTER, MJUMPAGESIZE, 0, NULL, NULL, 6711 &ring->data_dma_tag); 6712 if (error != 0) 6713 { 6714 printf("%s: could not create Tx data DMA tag\n", 6715 device_get_nameunit(sc->dev)); 6716 goto fail; 6717 } 6718 6719 for (i = 0; i < RT2860_SOFTC_TX_RING_DATA_COUNT; i++) 6720 { 6721 data = &ring->data[i]; 6722 6723 error = bus_dmamap_create(ring->data_dma_tag, 0, &data->dma_map); 6724 if (error != 0) 6725 { 6726 printf("%s: could not create Tx data DMA map\n", 6727 device_get_nameunit(sc->dev)); 6728 goto fail; 6729 } 6730 } 6731 6732 ring->data_queued = 0; 6733 ring->data_cur = 0; 6734 ring->data_next = 0; 6735 6736 ring->qid = qid; 6737 6738 return 0; 6739 6740fail: 6741 6742 rt2860_free_tx_ring(sc, ring); 6743 6744 return error; 6745} 6746 6747/* 6748 * rt2860_reset_tx_ring 6749 */ 6750static void rt2860_reset_tx_ring(struct rt2860_softc *sc, 6751 struct rt2860_softc_tx_ring *ring) 6752{ 6753 struct rt2860_softc_tx_data *data; 6754 struct rt2860_txdesc *desc; 6755 int i; 6756 6757 for (i = 0; i < RT2860_SOFTC_TX_RING_DESC_COUNT; i++) 6758 { 6759 desc = &ring->desc[i]; 6760 6761 desc->sdl0 = 0; 6762 desc->sdl1 = 0; 6763 } 6764 6765 ring->desc_queued = 0; 6766 ring->desc_cur = 0; 6767 ring->desc_next = 0; 6768 6769 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map, 6770 BUS_DMASYNC_PREWRITE); 6771 6772 bus_dmamap_sync(ring->seg0_dma_tag, ring->seg0_dma_map, 6773 BUS_DMASYNC_PREWRITE); 6774 6775 for (i = 0; i < RT2860_SOFTC_TX_RING_DATA_COUNT; i++) 6776 { 6777 data = &ring->data[i]; 6778 6779 if (data->m != NULL) 6780 { 6781 bus_dmamap_sync(ring->data_dma_tag, data->dma_map, 6782 BUS_DMASYNC_POSTWRITE); 6783 bus_dmamap_unload(ring->data_dma_tag, data->dma_map); 6784 m_freem(data->m); 6785 data->m = NULL; 6786 } 6787 6788 if (data->ni != NULL) 6789 { 6790 ieee80211_free_node(data->ni); 6791 data->ni = NULL; 6792 } 6793 } 6794 6795 ring->data_queued = 0; 6796 ring->data_cur = 0; 6797 ring->data_next = 0; 6798} 6799 6800/* 6801 * rt2860_free_tx_ring 6802 */ 6803static void rt2860_free_tx_ring(struct rt2860_softc *sc, 6804 struct rt2860_softc_tx_ring *ring) 6805{ 6806 struct rt2860_softc_tx_data *data; 6807 int i; 6808 6809 if (ring->desc != NULL) 6810 { 6811 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map, 6812 BUS_DMASYNC_POSTWRITE); 6813 bus_dmamap_unload(ring->desc_dma_tag, ring->desc_dma_map); 6814 bus_dmamem_free(ring->desc_dma_tag, ring->desc, 6815 ring->desc_dma_map); 6816 } 6817 6818 if (ring->desc_dma_tag != NULL) 6819 bus_dma_tag_destroy(ring->desc_dma_tag); 6820 6821 if (ring->seg0 != NULL) 6822 { 6823 bus_dmamap_sync(ring->seg0_dma_tag, ring->seg0_dma_map, 6824 BUS_DMASYNC_POSTWRITE); 6825 bus_dmamap_unload(ring->seg0_dma_tag, ring->seg0_dma_map); 6826 bus_dmamem_free(ring->seg0_dma_tag, ring->seg0, 6827 ring->seg0_dma_map); 6828 } 6829 6830 if (ring->seg0_dma_tag != NULL) 6831 bus_dma_tag_destroy(ring->seg0_dma_tag); 6832 6833 for (i = 0; i < RT2860_SOFTC_TX_RING_DATA_COUNT; i++) 6834 { 6835 data = &ring->data[i]; 6836 6837 if (data->m != NULL) 6838 { 6839 bus_dmamap_sync(ring->data_dma_tag, data->dma_map, 6840 BUS_DMASYNC_POSTWRITE); 6841 bus_dmamap_unload(ring->data_dma_tag, data->dma_map); 6842 m_freem(data->m); 6843 } 6844 6845 if (data->ni != NULL) 6846 ieee80211_free_node(data->ni); 6847 6848 if (data->dma_map != NULL) 6849 bus_dmamap_destroy(ring->data_dma_tag, data->dma_map); 6850 } 6851 6852 if (ring->data_dma_tag != NULL) 6853 bus_dma_tag_destroy(ring->data_dma_tag); 6854 6855 mtx_destroy(&ring->lock); 6856} 6857 6858/* 6859 * rt2860_dma_map_addr 6860 */ 6861static void rt2860_dma_map_addr(void *arg, bus_dma_segment_t *segs, 6862 int nseg, int error) 6863{ 6864 if (error != 0) 6865 return; 6866 6867 KASSERT(nseg == 1, ("too many DMA segments, %d should be 1", nseg)); 6868 6869 *(bus_addr_t *) arg = segs[0].ds_addr; 6870} 6871 6872/* 6873 * rt2860_sysctl_attach 6874 */ 6875static void rt2860_sysctl_attach(struct rt2860_softc *sc) 6876{ 6877 struct sysctl_ctx_list *ctx; 6878 struct sysctl_oid *tree; 6879 struct sysctl_oid *stats; 6880 6881 ctx = device_get_sysctl_ctx(sc->dev); 6882 tree = device_get_sysctl_tree(sc->dev); 6883 6884 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 6885 "tx_stbc", CTLFLAG_RW, &sc->tx_stbc, 0, 6886 "Tx STBC"); 6887 6888 /* statistic counters */ 6889 6890 stats = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 6891 "stats", CTLFLAG_RD, 0, "statistic"); 6892 6893 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6894 "interrupts", CTLFLAG_RD, &sc->interrupts, 0, 6895 "all interrupts"); 6896 6897 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6898 "tx_coherent_interrupts", CTLFLAG_RD, &sc->tx_coherent_interrupts, 0, 6899 "Tx coherent interrupts"); 6900 6901 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6902 "rx_coherent_interrupts", CTLFLAG_RD, &sc->rx_coherent_interrupts, 0, 6903 "Rx coherent interrupts"); 6904 6905 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6906 "txrx_coherent_interrupts", CTLFLAG_RD, &sc->txrx_coherent_interrupts, 0, 6907 "Tx/Rx coherent interrupts"); 6908 6909 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6910 "fifo_sta_full_interrupts", CTLFLAG_RD, &sc->fifo_sta_full_interrupts, 0, 6911 "FIFO statistic full interrupts"); 6912 6913 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6914 "rx_interrupts", CTLFLAG_RD, &sc->rx_interrupts, 0, 6915 "Rx interrupts"); 6916 6917 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6918 "rx_delay_interrupts", CTLFLAG_RD, &sc->rx_delay_interrupts, 0, 6919 "Rx delay interrupts"); 6920 6921 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6922 "tx_mgmt_interrupts", CTLFLAG_RD, &sc->tx_interrupts[5], 0, 6923 "Tx MGMT interrupts"); 6924 6925 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6926 "tx_hcca_interrupts", CTLFLAG_RD, &sc->tx_interrupts[4], 0, 6927 "Tx HCCA interrupts"); 6928 6929 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6930 "tx_ac3_interrupts", CTLFLAG_RD, &sc->tx_interrupts[3], 0, 6931 "Tx AC3 interrupts"); 6932 6933 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6934 "tx_ac2_interrupts", CTLFLAG_RD, &sc->tx_interrupts[2], 0, 6935 "Tx AC2 interrupts"); 6936 6937 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6938 "tx_ac1_interrupts", CTLFLAG_RD, &sc->tx_interrupts[1], 0, 6939 "Tx AC1 interrupts"); 6940 6941 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6942 "tx_ac0_interrupts", CTLFLAG_RD, &sc->tx_interrupts[0], 0, 6943 "Tx AC0 interrupts"); 6944 6945 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6946 "tx_delay_interrupts", CTLFLAG_RD, &sc->tx_delay_interrupts, 0, 6947 "Tx delay interrupts"); 6948 6949 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6950 "pre_tbtt_interrupts", CTLFLAG_RD, &sc->pre_tbtt_interrupts, 0, 6951 "Pre-TBTT interrupts"); 6952 6953 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6954 "tbtt_interrupts", CTLFLAG_RD, &sc->tbtt_interrupts, 0, 6955 "TBTT interrupts"); 6956 6957 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6958 "mcu_cmd_interrupts", CTLFLAG_RD, &sc->mcu_cmd_interrupts, 0, 6959 "MCU command interrupts"); 6960 6961 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6962 "auto_wakeup_interrupts", CTLFLAG_RD, &sc->auto_wakeup_interrupts, 0, 6963 "auto wakeup interrupts"); 6964 6965 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6966 "gp_timer_interrupts", CTLFLAG_RD, &sc->gp_timer_interrupts, 0, 6967 "GP timer interrupts"); 6968 6969 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6970 "tx_mgmt_desc_queued", CTLFLAG_RD, &sc->tx_ring[5].desc_queued, 0, 6971 "Tx MGMT descriptors queued"); 6972 6973 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6974 "tx_mgmt_data_queued", CTLFLAG_RD, &sc->tx_ring[5].data_queued, 0, 6975 "Tx MGMT data queued"); 6976 6977 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6978 "tx_hcca_desc_queued", CTLFLAG_RD, &sc->tx_ring[4].desc_queued, 0, 6979 "Tx HCCA descriptors queued"); 6980 6981 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6982 "tx_hcca_data_queued", CTLFLAG_RD, &sc->tx_ring[4].data_queued, 0, 6983 "Tx HCCA data queued"); 6984 6985 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6986 "tx_ac3_desc_queued", CTLFLAG_RD, &sc->tx_ring[3].desc_queued, 0, 6987 "Tx AC3 descriptors queued"); 6988 6989 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6990 "tx_ac3_data_queued", CTLFLAG_RD, &sc->tx_ring[3].data_queued, 0, 6991 "Tx AC3 data queued"); 6992 6993 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6994 "tx_ac2_desc_queued", CTLFLAG_RD, &sc->tx_ring[2].desc_queued, 0, 6995 "Tx AC2 descriptors queued"); 6996 6997 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 6998 "tx_ac2_data_queued", CTLFLAG_RD, &sc->tx_ring[2].data_queued, 0, 6999 "Tx AC2 data queued"); 7000 7001 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7002 "tx_ac1_desc_queued", CTLFLAG_RD, &sc->tx_ring[1].desc_queued, 0, 7003 "Tx AC1 descriptors queued"); 7004 7005 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7006 "tx_ac1_data_queued", CTLFLAG_RD, &sc->tx_ring[1].data_queued, 0, 7007 "Tx AC1 data queued"); 7008 7009 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7010 "tx_ac0_desc_queued", CTLFLAG_RD, &sc->tx_ring[0].desc_queued, 0, 7011 "Tx AC0 descriptors queued"); 7012 7013 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7014 "tx_ac0_data_queued", CTLFLAG_RD, &sc->tx_ring[0].data_queued, 0, 7015 "Tx AC0 data queued"); 7016 7017 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7018 "tx_mgmt_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[5], 0, 7019 "Tx MGMT data queue full"); 7020 7021 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7022 "tx_hcca_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[4], 0, 7023 "Tx HCCA data queue full"); 7024 7025 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7026 "tx_ac3_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[3], 0, 7027 "Tx AC3 data queue full"); 7028 7029 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7030 "tx_ac2_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[2], 0, 7031 "Tx AC2 data queue full"); 7032 7033 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7034 "tx_ac1_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[1], 0, 7035 "Tx AC1 data queue full"); 7036 7037 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7038 "tx_ac0_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[0], 0, 7039 "Tx AC0 data queue full"); 7040 7041 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7042 "tx_watchdog_timeouts", CTLFLAG_RD, &sc->tx_watchdog_timeouts, 0, 7043 "Tx watchdog timeouts"); 7044 7045 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7046 "tx_defrag_packets", CTLFLAG_RD, &sc->tx_defrag_packets, 0, 7047 "Tx defragmented packets"); 7048 7049 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7050 "no_tx_desc_avail", CTLFLAG_RD, &sc->no_tx_desc_avail, 0, 7051 "no Tx descriptors available"); 7052 7053 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7054 "rx_mbuf_alloc_errors", CTLFLAG_RD, &sc->rx_mbuf_alloc_errors, 0, 7055 "Rx mbuf allocation errors"); 7056 7057 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7058 "rx_mbuf_dmamap_errors", CTLFLAG_RD, &sc->rx_mbuf_dmamap_errors, 0, 7059 "Rx mbuf DMA mapping errors"); 7060 7061 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7062 "tx_queue_0_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[0], 0, 7063 "Tx queue 0 not empty"); 7064 7065 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7066 "tx_queue_1_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[1], 0, 7067 "Tx queue 1 not empty"); 7068 7069 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7070 "tx_beacons", CTLFLAG_RD, &sc->tx_beacons, 0, 7071 "Tx beacons"); 7072 7073 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7074 "tx_noretryok", CTLFLAG_RD, &sc->tx_noretryok, 0, 7075 "Tx successfull without retries"); 7076 7077 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7078 "tx_retryok", CTLFLAG_RD, &sc->tx_retryok, 0, 7079 "Tx successfull with retries"); 7080 7081 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7082 "tx_failed", CTLFLAG_RD, &sc->tx_failed, 0, 7083 "Tx failed"); 7084 7085 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7086 "tx_underflows", CTLFLAG_RD, &sc->tx_underflows, 0, 7087 "Tx underflows"); 7088 7089 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7090 "tx_zerolen", CTLFLAG_RD, &sc->tx_zerolen, 0, 7091 "Tx zero length"); 7092 7093 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7094 "tx_nonagg", CTLFLAG_RD, &sc->tx_nonagg, 0, 7095 "Tx non-aggregated"); 7096 7097 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7098 "tx_agg", CTLFLAG_RD, &sc->tx_agg, 0, 7099 "Tx aggregated"); 7100 7101 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7102 "tx_ampdu", CTLFLAG_RD, &sc->tx_ampdu, 0, 7103 "Tx A-MPDU"); 7104 7105 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7106 "tx_mpdu_zero_density", CTLFLAG_RD, &sc->tx_mpdu_zero_density, 0, 7107 "Tx MPDU with zero density"); 7108 7109 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7110 "tx_ampdu_sessions", CTLFLAG_RD, &sc->tx_ampdu_sessions, 0, 7111 "Tx A-MPDU sessions"); 7112 7113 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7114 "rx_packets", CTLFLAG_RD, &sc->rx_packets, 0, 7115 "Rx packets"); 7116 7117 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7118 "rx_ampdu", CTLFLAG_RD, &sc->rx_ampdu, 0, 7119 "Rx A-MPDU"); 7120 7121 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7122 "rx_ampdu_retries", CTLFLAG_RD, &sc->rx_ampdu_retries, 0, 7123 "Rx A-MPDU retries"); 7124 7125 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7126 "rx_mpdu_zero_density", CTLFLAG_RD, &sc->rx_mpdu_zero_density, 0, 7127 "Rx MPDU with zero density"); 7128 7129 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7130 "rx_ampdu_sessions", CTLFLAG_RD, &sc->rx_ampdu_sessions, 0, 7131 "Rx A-MPDU sessions"); 7132 7133 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7134 "rx_amsdu", CTLFLAG_RD, &sc->rx_amsdu, 0, 7135 "Rx A-MSDU"); 7136 7137 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7138 "rx_crc_errors", CTLFLAG_RD, &sc->rx_crc_errors, 0, 7139 "Rx CRC errors"); 7140 7141 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7142 "rx_phy_errors", CTLFLAG_RD, &sc->rx_phy_errors, 0, 7143 "Rx PHY errors"); 7144 7145 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7146 "rx_false_ccas", CTLFLAG_RD, &sc->rx_false_ccas, 0, 7147 "Rx false CCAs"); 7148 7149 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7150 "rx_plcp_errors", CTLFLAG_RD, &sc->rx_plcp_errors, 0, 7151 "Rx PLCP errors"); 7152 7153 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7154 "rx_dup_packets", CTLFLAG_RD, &sc->rx_dup_packets, 0, 7155 "Rx duplicate packets"); 7156 7157 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7158 "rx_fifo_overflows", CTLFLAG_RD, &sc->rx_fifo_overflows, 0, 7159 "Rx FIFO overflows"); 7160 7161 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7162 "rx_cipher_no_errors", CTLFLAG_RD, &sc->rx_cipher_no_errors, 0, 7163 "Rx cipher no errors"); 7164 7165 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7166 "rx_cipher_icv_errors", CTLFLAG_RD, &sc->rx_cipher_icv_errors, 0, 7167 "Rx cipher ICV errors"); 7168 7169 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7170 "rx_cipher_mic_errors", CTLFLAG_RD, &sc->rx_cipher_mic_errors, 0, 7171 "Rx cipher MIC errors"); 7172 7173 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO, 7174 "rx_cipher_invalid_key_errors", CTLFLAG_RD, &sc->rx_cipher_invalid_key_errors, 0, 7175 "Rx cipher invalid key errors"); 7176} 7177 7178 7179