1 /* 2 * Copyright (c) 2010-2011 Atheros Communications Inc. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17 #include "htc.h" 18 19 /*************/ 20 /* Utilities */ 21 /*************/ 22 23 /* HACK Alert: Use 11NG for 2.4, use 11NA for 5 */ 24 static enum htc_phymode ath9k_htc_get_curmode(struct ath9k_htc_priv *priv, 25 struct ath9k_channel *ichan) 26 { 27 if (IS_CHAN_5GHZ(ichan)) 28 return HTC_MODE_11NA; 29 30 return HTC_MODE_11NG; 31 } 32 33 bool ath9k_htc_setpower(struct ath9k_htc_priv *priv, 34 enum ath9k_power_mode mode) 35 { 36 bool ret; 37 38 mutex_lock(&priv->htc_pm_lock); 39 ret = ath9k_hw_setpower(priv->ah, mode); 40 mutex_unlock(&priv->htc_pm_lock); 41 42 return ret; 43 } 44 45 void ath9k_htc_ps_wakeup(struct ath9k_htc_priv *priv) 46 { 47 mutex_lock(&priv->htc_pm_lock); 48 if (++priv->ps_usecount != 1) 49 goto unlock; 50 ath9k_hw_setpower(priv->ah, ATH9K_PM_AWAKE); 51 52 unlock: 53 mutex_unlock(&priv->htc_pm_lock); 54 } 55 56 void ath9k_htc_ps_restore(struct ath9k_htc_priv *priv) 57 { 58 bool reset; 59 60 mutex_lock(&priv->htc_pm_lock); 61 if (--priv->ps_usecount != 0) 62 goto unlock; 63 64 if (priv->ps_idle) { 65 ath9k_hw_setrxabort(priv->ah, true); 66 ath9k_hw_stopdmarecv(priv->ah, &reset); 67 ath9k_hw_setpower(priv->ah, ATH9K_PM_FULL_SLEEP); 68 } else if (priv->ps_enabled) { 69 ath9k_hw_setpower(priv->ah, ATH9K_PM_NETWORK_SLEEP); 70 } 71 72 unlock: 73 mutex_unlock(&priv->htc_pm_lock); 74 } 75 76 void ath9k_ps_work(struct work_struct *work) 77 { 78 struct ath9k_htc_priv *priv = 79 container_of(work, struct ath9k_htc_priv, 80 ps_work); 81 ath9k_htc_setpower(priv, ATH9K_PM_AWAKE); 82 83 /* The chip wakes up after receiving the first beacon 84 while network sleep is enabled. For the driver to 85 be in sync with the hw, set the chip to awake and 86 only then set it to sleep. 87 */ 88 ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP); 89 } 90 91 static void ath9k_htc_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif) 92 { 93 struct ath9k_htc_priv *priv = data; 94 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 95 96 if ((vif->type == NL80211_IFTYPE_AP || 97 vif->type == NL80211_IFTYPE_MESH_POINT) && 98 bss_conf->enable_beacon) { 99 priv->reconfig_beacon = true; 100 priv->rearm_ani = true; 101 } 102 103 if (bss_conf->assoc) { 104 priv->rearm_ani = true; 105 priv->reconfig_beacon = true; 106 } 107 } 108 109 static void ath9k_htc_vif_reconfig(struct ath9k_htc_priv *priv) 110 { 111 priv->rearm_ani = false; 112 priv->reconfig_beacon = false; 113 114 ieee80211_iterate_active_interfaces_atomic( 115 priv->hw, IEEE80211_IFACE_ITER_RESUME_ALL, 116 ath9k_htc_vif_iter, priv); 117 if (priv->rearm_ani) 118 ath9k_htc_start_ani(priv); 119 120 if (priv->reconfig_beacon) { 121 ath9k_htc_ps_wakeup(priv); 122 ath9k_htc_beacon_reconfig(priv); 123 ath9k_htc_ps_restore(priv); 124 } 125 } 126 127 static void ath9k_htc_bssid_iter(void *data, u8 *mac, struct ieee80211_vif *vif) 128 { 129 struct ath9k_vif_iter_data *iter_data = data; 130 int i; 131 132 if (iter_data->hw_macaddr != NULL) { 133 for (i = 0; i < ETH_ALEN; i++) 134 iter_data->mask[i] &= ~(iter_data->hw_macaddr[i] ^ mac[i]); 135 } else { 136 iter_data->hw_macaddr = mac; 137 } 138 } 139 140 static void ath9k_htc_set_mac_bssid_mask(struct ath9k_htc_priv *priv, 141 struct ieee80211_vif *vif) 142 { 143 struct ath_common *common = ath9k_hw_common(priv->ah); 144 struct ath9k_vif_iter_data iter_data; 145 146 /* 147 * Pick the MAC address of the first interface as the new hardware 148 * MAC address. The hardware will use it together with the BSSID mask 149 * when matching addresses. 150 */ 151 iter_data.hw_macaddr = NULL; 152 eth_broadcast_addr(iter_data.mask); 153 154 if (vif) 155 ath9k_htc_bssid_iter(&iter_data, vif->addr, vif); 156 157 /* Get list of all active MAC addresses */ 158 ieee80211_iterate_active_interfaces_atomic( 159 priv->hw, IEEE80211_IFACE_ITER_RESUME_ALL, 160 ath9k_htc_bssid_iter, &iter_data); 161 162 memcpy(common->bssidmask, iter_data.mask, ETH_ALEN); 163 164 if (iter_data.hw_macaddr) 165 memcpy(common->macaddr, iter_data.hw_macaddr, ETH_ALEN); 166 167 ath_hw_setbssidmask(common); 168 } 169 170 static void ath9k_htc_set_opmode(struct ath9k_htc_priv *priv) 171 { 172 if (priv->num_ibss_vif) 173 priv->ah->opmode = NL80211_IFTYPE_ADHOC; 174 else if (priv->num_ap_vif) 175 priv->ah->opmode = NL80211_IFTYPE_AP; 176 else if (priv->num_mbss_vif) 177 priv->ah->opmode = NL80211_IFTYPE_MESH_POINT; 178 else 179 priv->ah->opmode = NL80211_IFTYPE_STATION; 180 181 ath9k_hw_setopmode(priv->ah); 182 } 183 184 void ath9k_htc_reset(struct ath9k_htc_priv *priv) 185 { 186 struct ath_hw *ah = priv->ah; 187 struct ath_common *common = ath9k_hw_common(ah); 188 struct ieee80211_channel *channel = priv->hw->conf.chandef.chan; 189 struct ath9k_hw_cal_data *caldata = NULL; 190 enum htc_phymode mode; 191 __be16 htc_mode; 192 u8 cmd_rsp; 193 int ret; 194 195 mutex_lock(&priv->mutex); 196 ath9k_htc_ps_wakeup(priv); 197 198 ath9k_htc_stop_ani(priv); 199 ieee80211_stop_queues(priv->hw); 200 201 del_timer_sync(&priv->tx.cleanup_timer); 202 ath9k_htc_tx_drain(priv); 203 204 WMI_CMD(WMI_DISABLE_INTR_CMDID); 205 WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID); 206 WMI_CMD(WMI_STOP_RECV_CMDID); 207 208 ath9k_wmi_event_drain(priv); 209 210 caldata = &priv->caldata; 211 ret = ath9k_hw_reset(ah, ah->curchan, caldata, false); 212 if (ret) { 213 ath_err(common, 214 "Unable to reset device (%u Mhz) reset status %d\n", 215 channel->center_freq, ret); 216 } 217 218 ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit, 219 &priv->curtxpow); 220 221 WMI_CMD(WMI_START_RECV_CMDID); 222 ath9k_host_rx_init(priv); 223 224 mode = ath9k_htc_get_curmode(priv, ah->curchan); 225 htc_mode = cpu_to_be16(mode); 226 WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode); 227 228 WMI_CMD(WMI_ENABLE_INTR_CMDID); 229 htc_start(priv->htc); 230 ath9k_htc_vif_reconfig(priv); 231 ieee80211_wake_queues(priv->hw); 232 233 mod_timer(&priv->tx.cleanup_timer, 234 jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL)); 235 236 ath9k_htc_ps_restore(priv); 237 mutex_unlock(&priv->mutex); 238 } 239 240 static int ath9k_htc_set_channel(struct ath9k_htc_priv *priv, 241 struct ieee80211_hw *hw, 242 struct ath9k_channel *hchan) 243 { 244 struct ath_hw *ah = priv->ah; 245 struct ath_common *common = ath9k_hw_common(ah); 246 struct ieee80211_conf *conf = &common->hw->conf; 247 bool fastcc; 248 struct ieee80211_channel *channel = hw->conf.chandef.chan; 249 struct ath9k_hw_cal_data *caldata = NULL; 250 enum htc_phymode mode; 251 __be16 htc_mode; 252 u8 cmd_rsp; 253 int ret; 254 255 if (test_bit(ATH_OP_INVALID, &common->op_flags)) 256 return -EIO; 257 258 fastcc = !!(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL); 259 260 ath9k_htc_ps_wakeup(priv); 261 262 ath9k_htc_stop_ani(priv); 263 del_timer_sync(&priv->tx.cleanup_timer); 264 ath9k_htc_tx_drain(priv); 265 266 WMI_CMD(WMI_DISABLE_INTR_CMDID); 267 WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID); 268 WMI_CMD(WMI_STOP_RECV_CMDID); 269 270 ath9k_wmi_event_drain(priv); 271 272 ath_dbg(common, CONFIG, 273 "(%u MHz) -> (%u MHz), HT: %d, HT40: %d fastcc: %d\n", 274 priv->ah->curchan->channel, 275 channel->center_freq, conf_is_ht(conf), conf_is_ht40(conf), 276 fastcc); 277 278 if (!fastcc) 279 caldata = &priv->caldata; 280 281 ret = ath9k_hw_reset(ah, hchan, caldata, fastcc); 282 if (ret) { 283 ath_err(common, 284 "Unable to reset channel (%u Mhz) reset status %d\n", 285 channel->center_freq, ret); 286 goto err; 287 } 288 289 ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit, 290 &priv->curtxpow); 291 292 WMI_CMD(WMI_START_RECV_CMDID); 293 if (ret) 294 goto err; 295 296 ath9k_host_rx_init(priv); 297 298 mode = ath9k_htc_get_curmode(priv, hchan); 299 htc_mode = cpu_to_be16(mode); 300 WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode); 301 if (ret) 302 goto err; 303 304 WMI_CMD(WMI_ENABLE_INTR_CMDID); 305 if (ret) 306 goto err; 307 308 htc_start(priv->htc); 309 310 if (!test_bit(ATH_OP_SCANNING, &common->op_flags) && 311 !(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) 312 ath9k_htc_vif_reconfig(priv); 313 314 mod_timer(&priv->tx.cleanup_timer, 315 jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL)); 316 317 /* perform spectral scan if requested. */ 318 if (test_bit(ATH_OP_SCANNING, &common->op_flags) && 319 priv->spec_priv.spectral_mode == SPECTRAL_CHANSCAN) 320 ath9k_cmn_spectral_scan_trigger(common, &priv->spec_priv); 321 err: 322 ath9k_htc_ps_restore(priv); 323 return ret; 324 } 325 326 /* 327 * Monitor mode handling is a tad complicated because the firmware requires 328 * an interface to be created exclusively, while mac80211 doesn't associate 329 * an interface with the mode. 330 * 331 * So, for now, only one monitor interface can be configured. 332 */ 333 static void __ath9k_htc_remove_monitor_interface(struct ath9k_htc_priv *priv) 334 { 335 struct ath_common *common = ath9k_hw_common(priv->ah); 336 struct ath9k_htc_target_vif hvif; 337 int ret = 0; 338 u8 cmd_rsp; 339 340 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif)); 341 memcpy(&hvif.myaddr, common->macaddr, ETH_ALEN); 342 hvif.index = priv->mon_vif_idx; 343 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif); 344 if (ret) { 345 ath_err(common, "Unable to remove monitor interface at idx: %d\n", 346 priv->mon_vif_idx); 347 } 348 349 priv->nvifs--; 350 priv->vif_slot &= ~(1 << priv->mon_vif_idx); 351 } 352 353 static int ath9k_htc_add_monitor_interface(struct ath9k_htc_priv *priv) 354 { 355 struct ath_common *common = ath9k_hw_common(priv->ah); 356 struct ath9k_htc_target_vif hvif; 357 struct ath9k_htc_target_sta tsta; 358 int ret = 0, sta_idx; 359 u8 cmd_rsp; 360 361 if ((priv->nvifs >= ATH9K_HTC_MAX_VIF) || 362 (priv->nstations >= ATH9K_HTC_MAX_STA)) { 363 ret = -ENOBUFS; 364 goto err_vif; 365 } 366 367 sta_idx = ffz(priv->sta_slot); 368 if ((sta_idx < 0) || (sta_idx > ATH9K_HTC_MAX_STA)) { 369 ret = -ENOBUFS; 370 goto err_vif; 371 } 372 373 /* 374 * Add an interface. 375 */ 376 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif)); 377 memcpy(&hvif.myaddr, common->macaddr, ETH_ALEN); 378 379 hvif.opmode = HTC_M_MONITOR; 380 hvif.index = ffz(priv->vif_slot); 381 382 WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif); 383 if (ret) 384 goto err_vif; 385 386 /* 387 * Assign the monitor interface index as a special case here. 388 * This is needed when the interface is brought down. 389 */ 390 priv->mon_vif_idx = hvif.index; 391 priv->vif_slot |= (1 << hvif.index); 392 393 /* 394 * Set the hardware mode to monitor only if there are no 395 * other interfaces. 396 */ 397 if (!priv->nvifs) 398 priv->ah->opmode = NL80211_IFTYPE_MONITOR; 399 400 priv->nvifs++; 401 402 /* 403 * Associate a station with the interface for packet injection. 404 */ 405 memset(&tsta, 0, sizeof(struct ath9k_htc_target_sta)); 406 407 memcpy(&tsta.macaddr, common->macaddr, ETH_ALEN); 408 409 tsta.is_vif_sta = 1; 410 tsta.sta_index = sta_idx; 411 tsta.vif_index = hvif.index; 412 tsta.maxampdu = cpu_to_be16(0xffff); 413 414 WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta); 415 if (ret) { 416 ath_err(common, "Unable to add station entry for monitor mode\n"); 417 goto err_sta; 418 } 419 420 priv->sta_slot |= (1 << sta_idx); 421 priv->nstations++; 422 priv->vif_sta_pos[priv->mon_vif_idx] = sta_idx; 423 priv->ah->is_monitoring = true; 424 425 ath_dbg(common, CONFIG, 426 "Attached a monitor interface at idx: %d, sta idx: %d\n", 427 priv->mon_vif_idx, sta_idx); 428 429 return 0; 430 431 err_sta: 432 /* 433 * Remove the interface from the target. 434 */ 435 __ath9k_htc_remove_monitor_interface(priv); 436 err_vif: 437 ath_dbg(common, FATAL, "Unable to attach a monitor interface\n"); 438 439 return ret; 440 } 441 442 static int ath9k_htc_remove_monitor_interface(struct ath9k_htc_priv *priv) 443 { 444 struct ath_common *common = ath9k_hw_common(priv->ah); 445 int ret = 0; 446 u8 cmd_rsp, sta_idx; 447 448 __ath9k_htc_remove_monitor_interface(priv); 449 450 sta_idx = priv->vif_sta_pos[priv->mon_vif_idx]; 451 452 WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx); 453 if (ret) { 454 ath_err(common, "Unable to remove station entry for monitor mode\n"); 455 return ret; 456 } 457 458 priv->sta_slot &= ~(1 << sta_idx); 459 priv->nstations--; 460 priv->ah->is_monitoring = false; 461 462 ath_dbg(common, CONFIG, 463 "Removed a monitor interface at idx: %d, sta idx: %d\n", 464 priv->mon_vif_idx, sta_idx); 465 466 return 0; 467 } 468 469 static int ath9k_htc_add_station(struct ath9k_htc_priv *priv, 470 struct ieee80211_vif *vif, 471 struct ieee80211_sta *sta) 472 { 473 struct ath_common *common = ath9k_hw_common(priv->ah); 474 struct ath9k_htc_target_sta tsta; 475 struct ath9k_htc_vif *avp = (struct ath9k_htc_vif *) vif->drv_priv; 476 struct ath9k_htc_sta *ista; 477 int ret, sta_idx; 478 u8 cmd_rsp; 479 u16 maxampdu; 480 481 if (priv->nstations >= ATH9K_HTC_MAX_STA) 482 return -ENOBUFS; 483 484 sta_idx = ffz(priv->sta_slot); 485 if ((sta_idx < 0) || (sta_idx > ATH9K_HTC_MAX_STA)) 486 return -ENOBUFS; 487 488 memset(&tsta, 0, sizeof(struct ath9k_htc_target_sta)); 489 490 if (sta) { 491 ista = (struct ath9k_htc_sta *) sta->drv_priv; 492 memcpy(&tsta.macaddr, sta->addr, ETH_ALEN); 493 memcpy(&tsta.bssid, common->curbssid, ETH_ALEN); 494 ista->index = sta_idx; 495 tsta.is_vif_sta = 0; 496 maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR + 497 sta->ht_cap.ampdu_factor); 498 tsta.maxampdu = cpu_to_be16(maxampdu); 499 } else { 500 memcpy(&tsta.macaddr, vif->addr, ETH_ALEN); 501 tsta.is_vif_sta = 1; 502 tsta.maxampdu = cpu_to_be16(0xffff); 503 } 504 505 tsta.sta_index = sta_idx; 506 tsta.vif_index = avp->index; 507 508 WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta); 509 if (ret) { 510 if (sta) 511 ath_err(common, 512 "Unable to add station entry for: %pM\n", 513 sta->addr); 514 return ret; 515 } 516 517 if (sta) { 518 ath_dbg(common, CONFIG, 519 "Added a station entry for: %pM (idx: %d)\n", 520 sta->addr, tsta.sta_index); 521 } else { 522 ath_dbg(common, CONFIG, 523 "Added a station entry for VIF %d (idx: %d)\n", 524 avp->index, tsta.sta_index); 525 } 526 527 priv->sta_slot |= (1 << sta_idx); 528 priv->nstations++; 529 if (!sta) 530 priv->vif_sta_pos[avp->index] = sta_idx; 531 532 return 0; 533 } 534 535 static int ath9k_htc_remove_station(struct ath9k_htc_priv *priv, 536 struct ieee80211_vif *vif, 537 struct ieee80211_sta *sta) 538 { 539 struct ath_common *common = ath9k_hw_common(priv->ah); 540 struct ath9k_htc_vif *avp = (struct ath9k_htc_vif *) vif->drv_priv; 541 struct ath9k_htc_sta *ista; 542 int ret; 543 u8 cmd_rsp, sta_idx; 544 545 if (sta) { 546 ista = (struct ath9k_htc_sta *) sta->drv_priv; 547 sta_idx = ista->index; 548 } else { 549 sta_idx = priv->vif_sta_pos[avp->index]; 550 } 551 552 WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx); 553 if (ret) { 554 if (sta) 555 ath_err(common, 556 "Unable to remove station entry for: %pM\n", 557 sta->addr); 558 return ret; 559 } 560 561 if (sta) { 562 ath_dbg(common, CONFIG, 563 "Removed a station entry for: %pM (idx: %d)\n", 564 sta->addr, sta_idx); 565 } else { 566 ath_dbg(common, CONFIG, 567 "Removed a station entry for VIF %d (idx: %d)\n", 568 avp->index, sta_idx); 569 } 570 571 priv->sta_slot &= ~(1 << sta_idx); 572 priv->nstations--; 573 574 return 0; 575 } 576 577 int ath9k_htc_update_cap_target(struct ath9k_htc_priv *priv, 578 u8 enable_coex) 579 { 580 struct ath9k_htc_cap_target tcap; 581 int ret; 582 u8 cmd_rsp; 583 584 memset(&tcap, 0, sizeof(struct ath9k_htc_cap_target)); 585 586 tcap.ampdu_limit = cpu_to_be32(0xffff); 587 tcap.ampdu_subframes = 0xff; 588 tcap.enable_coex = enable_coex; 589 tcap.tx_chainmask = priv->ah->caps.tx_chainmask; 590 591 WMI_CMD_BUF(WMI_TARGET_IC_UPDATE_CMDID, &tcap); 592 593 return ret; 594 } 595 596 static void ath9k_htc_setup_rate(struct ath9k_htc_priv *priv, 597 struct ieee80211_sta *sta, 598 struct ath9k_htc_target_rate *trate) 599 { 600 struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv; 601 struct ieee80211_supported_band *sband; 602 u32 caps = 0; 603 int i, j; 604 605 sband = priv->hw->wiphy->bands[priv->hw->conf.chandef.chan->band]; 606 607 for (i = 0, j = 0; i < sband->n_bitrates; i++) { 608 if (sta->supp_rates[sband->band] & BIT(i)) { 609 trate->rates.legacy_rates.rs_rates[j] 610 = (sband->bitrates[i].bitrate * 2) / 10; 611 j++; 612 } 613 } 614 trate->rates.legacy_rates.rs_nrates = j; 615 616 if (sta->ht_cap.ht_supported) { 617 for (i = 0, j = 0; i < 77; i++) { 618 if (sta->ht_cap.mcs.rx_mask[i/8] & (1<<(i%8))) 619 trate->rates.ht_rates.rs_rates[j++] = i; 620 if (j == ATH_HTC_RATE_MAX) 621 break; 622 } 623 trate->rates.ht_rates.rs_nrates = j; 624 625 caps = WLAN_RC_HT_FLAG; 626 if (sta->ht_cap.cap & IEEE80211_HT_CAP_RX_STBC) 627 caps |= ATH_RC_TX_STBC_FLAG; 628 if (sta->ht_cap.mcs.rx_mask[1]) 629 caps |= WLAN_RC_DS_FLAG; 630 if ((sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) && 631 (conf_is_ht40(&priv->hw->conf))) 632 caps |= WLAN_RC_40_FLAG; 633 if (conf_is_ht40(&priv->hw->conf) && 634 (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40)) 635 caps |= WLAN_RC_SGI_FLAG; 636 else if (conf_is_ht20(&priv->hw->conf) && 637 (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20)) 638 caps |= WLAN_RC_SGI_FLAG; 639 } 640 641 trate->sta_index = ista->index; 642 trate->isnew = 1; 643 trate->capflags = cpu_to_be32(caps); 644 } 645 646 static int ath9k_htc_send_rate_cmd(struct ath9k_htc_priv *priv, 647 struct ath9k_htc_target_rate *trate) 648 { 649 struct ath_common *common = ath9k_hw_common(priv->ah); 650 int ret; 651 u8 cmd_rsp; 652 653 WMI_CMD_BUF(WMI_RC_RATE_UPDATE_CMDID, trate); 654 if (ret) { 655 ath_err(common, 656 "Unable to initialize Rate information on target\n"); 657 } 658 659 return ret; 660 } 661 662 static void ath9k_htc_init_rate(struct ath9k_htc_priv *priv, 663 struct ieee80211_sta *sta) 664 { 665 struct ath_common *common = ath9k_hw_common(priv->ah); 666 struct ath9k_htc_target_rate trate; 667 int ret; 668 669 memset(&trate, 0, sizeof(struct ath9k_htc_target_rate)); 670 ath9k_htc_setup_rate(priv, sta, &trate); 671 ret = ath9k_htc_send_rate_cmd(priv, &trate); 672 if (!ret) 673 ath_dbg(common, CONFIG, 674 "Updated target sta: %pM, rate caps: 0x%X\n", 675 sta->addr, be32_to_cpu(trate.capflags)); 676 } 677 678 static void ath9k_htc_update_rate(struct ath9k_htc_priv *priv, 679 struct ieee80211_vif *vif, 680 struct ieee80211_bss_conf *bss_conf) 681 { 682 struct ath_common *common = ath9k_hw_common(priv->ah); 683 struct ath9k_htc_target_rate trate; 684 struct ieee80211_sta *sta; 685 int ret; 686 687 memset(&trate, 0, sizeof(struct ath9k_htc_target_rate)); 688 689 rcu_read_lock(); 690 sta = ieee80211_find_sta(vif, bss_conf->bssid); 691 if (!sta) { 692 rcu_read_unlock(); 693 return; 694 } 695 ath9k_htc_setup_rate(priv, sta, &trate); 696 rcu_read_unlock(); 697 698 ret = ath9k_htc_send_rate_cmd(priv, &trate); 699 if (!ret) 700 ath_dbg(common, CONFIG, 701 "Updated target sta: %pM, rate caps: 0x%X\n", 702 bss_conf->bssid, be32_to_cpu(trate.capflags)); 703 } 704 705 static int ath9k_htc_tx_aggr_oper(struct ath9k_htc_priv *priv, 706 struct ieee80211_vif *vif, 707 struct ieee80211_sta *sta, 708 enum ieee80211_ampdu_mlme_action action, 709 u16 tid) 710 { 711 struct ath_common *common = ath9k_hw_common(priv->ah); 712 struct ath9k_htc_target_aggr aggr; 713 struct ath9k_htc_sta *ista; 714 int ret = 0; 715 u8 cmd_rsp; 716 717 if (tid >= ATH9K_HTC_MAX_TID) 718 return -EINVAL; 719 720 memset(&aggr, 0, sizeof(struct ath9k_htc_target_aggr)); 721 ista = (struct ath9k_htc_sta *) sta->drv_priv; 722 723 aggr.sta_index = ista->index; 724 aggr.tidno = tid & 0xf; 725 aggr.aggr_enable = (action == IEEE80211_AMPDU_TX_START) ? true : false; 726 727 WMI_CMD_BUF(WMI_TX_AGGR_ENABLE_CMDID, &aggr); 728 if (ret) 729 ath_dbg(common, CONFIG, 730 "Unable to %s TX aggregation for (%pM, %d)\n", 731 (aggr.aggr_enable) ? "start" : "stop", sta->addr, tid); 732 else 733 ath_dbg(common, CONFIG, 734 "%s TX aggregation for (%pM, %d)\n", 735 (aggr.aggr_enable) ? "Starting" : "Stopping", 736 sta->addr, tid); 737 738 spin_lock_bh(&priv->tx.tx_lock); 739 ista->tid_state[tid] = (aggr.aggr_enable && !ret) ? AGGR_START : AGGR_STOP; 740 spin_unlock_bh(&priv->tx.tx_lock); 741 742 return ret; 743 } 744 745 /*******/ 746 /* ANI */ 747 /*******/ 748 749 void ath9k_htc_start_ani(struct ath9k_htc_priv *priv) 750 { 751 struct ath_common *common = ath9k_hw_common(priv->ah); 752 unsigned long timestamp = jiffies_to_msecs(jiffies); 753 754 common->ani.longcal_timer = timestamp; 755 common->ani.shortcal_timer = timestamp; 756 common->ani.checkani_timer = timestamp; 757 758 set_bit(ATH_OP_ANI_RUN, &common->op_flags); 759 760 ieee80211_queue_delayed_work(common->hw, &priv->ani_work, 761 msecs_to_jiffies(ATH_ANI_POLLINTERVAL)); 762 } 763 764 void ath9k_htc_stop_ani(struct ath9k_htc_priv *priv) 765 { 766 struct ath_common *common = ath9k_hw_common(priv->ah); 767 cancel_delayed_work_sync(&priv->ani_work); 768 clear_bit(ATH_OP_ANI_RUN, &common->op_flags); 769 } 770 771 void ath9k_htc_ani_work(struct work_struct *work) 772 { 773 struct ath9k_htc_priv *priv = 774 container_of(work, struct ath9k_htc_priv, ani_work.work); 775 struct ath_hw *ah = priv->ah; 776 struct ath_common *common = ath9k_hw_common(ah); 777 bool longcal = false; 778 bool shortcal = false; 779 bool aniflag = false; 780 unsigned int timestamp = jiffies_to_msecs(jiffies); 781 u32 cal_interval, short_cal_interval; 782 783 short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ? 784 ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL; 785 786 /* Only calibrate if awake */ 787 if (ah->power_mode != ATH9K_PM_AWAKE) 788 goto set_timer; 789 790 /* Long calibration runs independently of short calibration. */ 791 if ((timestamp - common->ani.longcal_timer) >= ATH_LONG_CALINTERVAL) { 792 longcal = true; 793 ath_dbg(common, ANI, "longcal @%lu\n", jiffies); 794 common->ani.longcal_timer = timestamp; 795 } 796 797 /* 798 * Short calibration applies only while caldone 799 * is false or -ETIMEDOUT 800 */ 801 if (common->ani.caldone <= 0) { 802 if ((timestamp - common->ani.shortcal_timer) >= 803 short_cal_interval) { 804 shortcal = true; 805 ath_dbg(common, ANI, "shortcal @%lu\n", jiffies); 806 common->ani.shortcal_timer = timestamp; 807 common->ani.resetcal_timer = timestamp; 808 } 809 } else { 810 if ((timestamp - common->ani.resetcal_timer) >= 811 ATH_RESTART_CALINTERVAL) { 812 common->ani.caldone = ath9k_hw_reset_calvalid(ah); 813 if (common->ani.caldone) 814 common->ani.resetcal_timer = timestamp; 815 } 816 } 817 818 /* Verify whether we must check ANI */ 819 if ((timestamp - common->ani.checkani_timer) >= ATH_ANI_POLLINTERVAL) { 820 aniflag = true; 821 common->ani.checkani_timer = timestamp; 822 } 823 824 /* Skip all processing if there's nothing to do. */ 825 if (longcal || shortcal || aniflag) { 826 827 ath9k_htc_ps_wakeup(priv); 828 829 /* Call ANI routine if necessary */ 830 if (aniflag) 831 ath9k_hw_ani_monitor(ah, ah->curchan); 832 833 /* Perform calibration if necessary */ 834 if (longcal || shortcal) 835 common->ani.caldone = 836 ath9k_hw_calibrate(ah, ah->curchan, 837 ah->rxchainmask, longcal); 838 839 ath9k_htc_ps_restore(priv); 840 } 841 842 set_timer: 843 /* 844 * Set timer interval based on previous results. 845 * The interval must be the shortest necessary to satisfy ANI, 846 * short calibration and long calibration. 847 */ 848 cal_interval = ATH_LONG_CALINTERVAL; 849 cal_interval = min(cal_interval, (u32)ATH_ANI_POLLINTERVAL); 850 /* 851 * Short calibration applies only while caldone 852 * is false or -ETIMEDOUT 853 */ 854 if (common->ani.caldone <= 0) 855 cal_interval = min(cal_interval, (u32)short_cal_interval); 856 857 ieee80211_queue_delayed_work(common->hw, &priv->ani_work, 858 msecs_to_jiffies(cal_interval)); 859 } 860 861 /**********************/ 862 /* mac80211 Callbacks */ 863 /**********************/ 864 865 static void ath9k_htc_tx(struct ieee80211_hw *hw, 866 struct ieee80211_tx_control *control, 867 struct sk_buff *skb) 868 { 869 struct ieee80211_hdr *hdr; 870 struct ath9k_htc_priv *priv = hw->priv; 871 struct ath_common *common = ath9k_hw_common(priv->ah); 872 int padpos, padsize, ret, slot; 873 874 hdr = (struct ieee80211_hdr *) skb->data; 875 876 /* Add the padding after the header if this is not already done */ 877 padpos = ieee80211_hdrlen(hdr->frame_control); 878 padsize = padpos & 3; 879 if (padsize && skb->len > padpos) { 880 if (skb_headroom(skb) < padsize) { 881 ath_dbg(common, XMIT, "No room for padding\n"); 882 goto fail_tx; 883 } 884 skb_push(skb, padsize); 885 memmove(skb->data, skb->data + padsize, padpos); 886 } 887 888 slot = ath9k_htc_tx_get_slot(priv); 889 if (slot < 0) { 890 ath_dbg(common, XMIT, "No free TX slot\n"); 891 goto fail_tx; 892 } 893 894 ret = ath9k_htc_tx_start(priv, control->sta, skb, slot, false); 895 if (ret != 0) { 896 ath_dbg(common, XMIT, "Tx failed\n"); 897 goto clear_slot; 898 } 899 900 ath9k_htc_check_stop_queues(priv); 901 902 return; 903 904 clear_slot: 905 ath9k_htc_tx_clear_slot(priv, slot); 906 fail_tx: 907 dev_kfree_skb_any(skb); 908 } 909 910 static int ath9k_htc_start(struct ieee80211_hw *hw) 911 { 912 struct ath9k_htc_priv *priv = hw->priv; 913 struct ath_hw *ah = priv->ah; 914 struct ath_common *common = ath9k_hw_common(ah); 915 struct ieee80211_channel *curchan = hw->conf.chandef.chan; 916 struct ath9k_channel *init_channel; 917 int ret = 0; 918 enum htc_phymode mode; 919 __be16 htc_mode; 920 u8 cmd_rsp; 921 922 mutex_lock(&priv->mutex); 923 924 ath_dbg(common, CONFIG, 925 "Starting driver with initial channel: %d MHz\n", 926 curchan->center_freq); 927 928 /* Ensure that HW is awake before flushing RX */ 929 ath9k_htc_setpower(priv, ATH9K_PM_AWAKE); 930 WMI_CMD(WMI_FLUSH_RECV_CMDID); 931 932 /* setup initial channel */ 933 init_channel = ath9k_cmn_get_channel(hw, ah, &hw->conf.chandef); 934 935 ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false); 936 if (ret) { 937 ath_err(common, 938 "Unable to reset hardware; reset status %d (freq %u MHz)\n", 939 ret, curchan->center_freq); 940 mutex_unlock(&priv->mutex); 941 return ret; 942 } 943 944 ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit, 945 &priv->curtxpow); 946 947 mode = ath9k_htc_get_curmode(priv, init_channel); 948 htc_mode = cpu_to_be16(mode); 949 WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode); 950 WMI_CMD(WMI_ATH_INIT_CMDID); 951 WMI_CMD(WMI_START_RECV_CMDID); 952 953 ath9k_host_rx_init(priv); 954 955 ret = ath9k_htc_update_cap_target(priv, 0); 956 if (ret) 957 ath_dbg(common, CONFIG, 958 "Failed to update capability in target\n"); 959 960 clear_bit(ATH_OP_INVALID, &common->op_flags); 961 htc_start(priv->htc); 962 963 spin_lock_bh(&priv->tx.tx_lock); 964 priv->tx.flags &= ~ATH9K_HTC_OP_TX_QUEUES_STOP; 965 spin_unlock_bh(&priv->tx.tx_lock); 966 967 ieee80211_wake_queues(hw); 968 969 mod_timer(&priv->tx.cleanup_timer, 970 jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL)); 971 972 ath9k_htc_start_btcoex(priv); 973 974 mutex_unlock(&priv->mutex); 975 976 return ret; 977 } 978 979 static void ath9k_htc_stop(struct ieee80211_hw *hw) 980 { 981 struct ath9k_htc_priv *priv = hw->priv; 982 struct ath_hw *ah = priv->ah; 983 struct ath_common *common = ath9k_hw_common(ah); 984 int ret __attribute__ ((unused)); 985 u8 cmd_rsp; 986 987 mutex_lock(&priv->mutex); 988 989 if (test_bit(ATH_OP_INVALID, &common->op_flags)) { 990 ath_dbg(common, ANY, "Device not present\n"); 991 mutex_unlock(&priv->mutex); 992 return; 993 } 994 995 ath9k_htc_ps_wakeup(priv); 996 997 WMI_CMD(WMI_DISABLE_INTR_CMDID); 998 WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID); 999 WMI_CMD(WMI_STOP_RECV_CMDID); 1000 1001 tasklet_kill(&priv->rx_tasklet); 1002 1003 del_timer_sync(&priv->tx.cleanup_timer); 1004 ath9k_htc_tx_drain(priv); 1005 ath9k_wmi_event_drain(priv); 1006 1007 mutex_unlock(&priv->mutex); 1008 1009 /* Cancel all the running timers/work .. */ 1010 cancel_work_sync(&priv->fatal_work); 1011 cancel_work_sync(&priv->ps_work); 1012 1013 #ifdef CONFIG_MAC80211_LEDS 1014 cancel_work_sync(&priv->led_work); 1015 #endif 1016 ath9k_htc_stop_ani(priv); 1017 1018 mutex_lock(&priv->mutex); 1019 1020 ath9k_htc_stop_btcoex(priv); 1021 1022 /* Remove a monitor interface if it's present. */ 1023 if (priv->ah->is_monitoring) 1024 ath9k_htc_remove_monitor_interface(priv); 1025 1026 ath9k_hw_phy_disable(ah); 1027 ath9k_hw_disable(ah); 1028 ath9k_htc_ps_restore(priv); 1029 ath9k_htc_setpower(priv, ATH9K_PM_FULL_SLEEP); 1030 1031 set_bit(ATH_OP_INVALID, &common->op_flags); 1032 1033 ath_dbg(common, CONFIG, "Driver halt\n"); 1034 mutex_unlock(&priv->mutex); 1035 } 1036 1037 static int ath9k_htc_add_interface(struct ieee80211_hw *hw, 1038 struct ieee80211_vif *vif) 1039 { 1040 struct ath9k_htc_priv *priv = hw->priv; 1041 struct ath9k_htc_vif *avp = (void *)vif->drv_priv; 1042 struct ath_common *common = ath9k_hw_common(priv->ah); 1043 struct ath9k_htc_target_vif hvif; 1044 int ret = 0; 1045 u8 cmd_rsp; 1046 1047 mutex_lock(&priv->mutex); 1048 1049 ath9k_htc_ps_wakeup(priv); 1050 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif)); 1051 memcpy(&hvif.myaddr, vif->addr, ETH_ALEN); 1052 1053 switch (vif->type) { 1054 case NL80211_IFTYPE_STATION: 1055 hvif.opmode = HTC_M_STA; 1056 break; 1057 case NL80211_IFTYPE_ADHOC: 1058 hvif.opmode = HTC_M_IBSS; 1059 break; 1060 case NL80211_IFTYPE_AP: 1061 hvif.opmode = HTC_M_HOSTAP; 1062 break; 1063 case NL80211_IFTYPE_MESH_POINT: 1064 hvif.opmode = HTC_M_WDS; /* close enough */ 1065 break; 1066 default: 1067 ath_err(common, 1068 "Interface type %d not yet supported\n", vif->type); 1069 ret = -EOPNOTSUPP; 1070 goto out; 1071 } 1072 1073 /* Index starts from zero on the target */ 1074 avp->index = hvif.index = ffz(priv->vif_slot); 1075 hvif.rtsthreshold = cpu_to_be16(2304); 1076 WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif); 1077 if (ret) 1078 goto out; 1079 1080 /* 1081 * We need a node in target to tx mgmt frames 1082 * before association. 1083 */ 1084 ret = ath9k_htc_add_station(priv, vif, NULL); 1085 if (ret) { 1086 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif); 1087 goto out; 1088 } 1089 1090 ath9k_htc_set_mac_bssid_mask(priv, vif); 1091 1092 priv->vif_slot |= (1 << avp->index); 1093 priv->nvifs++; 1094 1095 INC_VIF(priv, vif->type); 1096 1097 if ((vif->type == NL80211_IFTYPE_AP) || 1098 (vif->type == NL80211_IFTYPE_MESH_POINT) || 1099 (vif->type == NL80211_IFTYPE_ADHOC)) 1100 ath9k_htc_assign_bslot(priv, vif); 1101 1102 ath9k_htc_set_opmode(priv); 1103 1104 if ((priv->ah->opmode == NL80211_IFTYPE_AP) && 1105 !test_bit(ATH_OP_ANI_RUN, &common->op_flags)) { 1106 ath9k_hw_set_tsfadjust(priv->ah, true); 1107 ath9k_htc_start_ani(priv); 1108 } 1109 1110 ath_dbg(common, CONFIG, "Attach a VIF of type: %d at idx: %d\n", 1111 vif->type, avp->index); 1112 1113 out: 1114 ath9k_htc_ps_restore(priv); 1115 mutex_unlock(&priv->mutex); 1116 1117 return ret; 1118 } 1119 1120 static void ath9k_htc_remove_interface(struct ieee80211_hw *hw, 1121 struct ieee80211_vif *vif) 1122 { 1123 struct ath9k_htc_priv *priv = hw->priv; 1124 struct ath_common *common = ath9k_hw_common(priv->ah); 1125 struct ath9k_htc_vif *avp = (void *)vif->drv_priv; 1126 struct ath9k_htc_target_vif hvif; 1127 int ret = 0; 1128 u8 cmd_rsp; 1129 1130 mutex_lock(&priv->mutex); 1131 ath9k_htc_ps_wakeup(priv); 1132 1133 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif)); 1134 memcpy(&hvif.myaddr, vif->addr, ETH_ALEN); 1135 hvif.index = avp->index; 1136 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif); 1137 if (ret) { 1138 ath_err(common, "Unable to remove interface at idx: %d\n", 1139 avp->index); 1140 } 1141 priv->nvifs--; 1142 priv->vif_slot &= ~(1 << avp->index); 1143 1144 if (priv->csa_vif == vif) 1145 priv->csa_vif = NULL; 1146 1147 ath9k_htc_remove_station(priv, vif, NULL); 1148 1149 DEC_VIF(priv, vif->type); 1150 1151 if ((vif->type == NL80211_IFTYPE_AP) || 1152 vif->type == NL80211_IFTYPE_MESH_POINT || 1153 (vif->type == NL80211_IFTYPE_ADHOC)) 1154 ath9k_htc_remove_bslot(priv, vif); 1155 1156 ath9k_htc_set_opmode(priv); 1157 1158 ath9k_htc_set_mac_bssid_mask(priv, vif); 1159 1160 /* 1161 * Stop ANI only if there are no associated station interfaces. 1162 */ 1163 if ((vif->type == NL80211_IFTYPE_AP) && (priv->num_ap_vif == 0)) { 1164 priv->rearm_ani = false; 1165 ieee80211_iterate_active_interfaces_atomic( 1166 priv->hw, IEEE80211_IFACE_ITER_RESUME_ALL, 1167 ath9k_htc_vif_iter, priv); 1168 if (!priv->rearm_ani) 1169 ath9k_htc_stop_ani(priv); 1170 } 1171 1172 ath_dbg(common, CONFIG, "Detach Interface at idx: %d\n", avp->index); 1173 1174 ath9k_htc_ps_restore(priv); 1175 mutex_unlock(&priv->mutex); 1176 } 1177 1178 static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed) 1179 { 1180 struct ath9k_htc_priv *priv = hw->priv; 1181 struct ath_common *common = ath9k_hw_common(priv->ah); 1182 struct ieee80211_conf *conf = &hw->conf; 1183 bool chip_reset = false; 1184 int ret = 0; 1185 1186 mutex_lock(&priv->mutex); 1187 ath9k_htc_ps_wakeup(priv); 1188 1189 if (changed & IEEE80211_CONF_CHANGE_IDLE) { 1190 mutex_lock(&priv->htc_pm_lock); 1191 1192 priv->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE); 1193 if (!priv->ps_idle) 1194 chip_reset = true; 1195 1196 mutex_unlock(&priv->htc_pm_lock); 1197 } 1198 1199 /* 1200 * Monitor interface should be added before 1201 * IEEE80211_CONF_CHANGE_CHANNEL is handled. 1202 */ 1203 if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 1204 if ((conf->flags & IEEE80211_CONF_MONITOR) && 1205 !priv->ah->is_monitoring) 1206 ath9k_htc_add_monitor_interface(priv); 1207 else if (priv->ah->is_monitoring) 1208 ath9k_htc_remove_monitor_interface(priv); 1209 } 1210 1211 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL) || chip_reset) { 1212 struct ieee80211_channel *curchan = hw->conf.chandef.chan; 1213 int pos = curchan->hw_value; 1214 1215 ath_dbg(common, CONFIG, "Set channel: %d MHz\n", 1216 curchan->center_freq); 1217 1218 ath9k_cmn_get_channel(hw, priv->ah, &hw->conf.chandef); 1219 if (ath9k_htc_set_channel(priv, hw, &priv->ah->channels[pos]) < 0) { 1220 ath_err(common, "Unable to set channel\n"); 1221 ret = -EINVAL; 1222 goto out; 1223 } 1224 1225 } 1226 1227 if (changed & IEEE80211_CONF_CHANGE_PS) { 1228 if (conf->flags & IEEE80211_CONF_PS) { 1229 ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP); 1230 priv->ps_enabled = true; 1231 } else { 1232 priv->ps_enabled = false; 1233 cancel_work_sync(&priv->ps_work); 1234 ath9k_htc_setpower(priv, ATH9K_PM_AWAKE); 1235 } 1236 } 1237 1238 if (changed & IEEE80211_CONF_CHANGE_POWER) { 1239 priv->txpowlimit = 2 * conf->power_level; 1240 ath9k_cmn_update_txpow(priv->ah, priv->curtxpow, 1241 priv->txpowlimit, &priv->curtxpow); 1242 } 1243 1244 out: 1245 ath9k_htc_ps_restore(priv); 1246 mutex_unlock(&priv->mutex); 1247 return ret; 1248 } 1249 1250 #define SUPPORTED_FILTERS \ 1251 (FIF_ALLMULTI | \ 1252 FIF_CONTROL | \ 1253 FIF_PSPOLL | \ 1254 FIF_OTHER_BSS | \ 1255 FIF_BCN_PRBRESP_PROMISC | \ 1256 FIF_PROBE_REQ | \ 1257 FIF_FCSFAIL) 1258 1259 static void ath9k_htc_configure_filter(struct ieee80211_hw *hw, 1260 unsigned int changed_flags, 1261 unsigned int *total_flags, 1262 u64 multicast) 1263 { 1264 struct ath9k_htc_priv *priv = hw->priv; 1265 struct ath_common *common = ath9k_hw_common(priv->ah); 1266 u32 rfilt; 1267 1268 mutex_lock(&priv->mutex); 1269 changed_flags &= SUPPORTED_FILTERS; 1270 *total_flags &= SUPPORTED_FILTERS; 1271 1272 if (test_bit(ATH_OP_INVALID, &common->op_flags)) { 1273 ath_dbg(ath9k_hw_common(priv->ah), ANY, 1274 "Unable to configure filter on invalid state\n"); 1275 mutex_unlock(&priv->mutex); 1276 return; 1277 } 1278 ath9k_htc_ps_wakeup(priv); 1279 1280 priv->rxfilter = *total_flags; 1281 rfilt = ath9k_htc_calcrxfilter(priv); 1282 ath9k_hw_setrxfilter(priv->ah, rfilt); 1283 1284 ath_dbg(ath9k_hw_common(priv->ah), CONFIG, "Set HW RX filter: 0x%x\n", 1285 rfilt); 1286 1287 ath9k_htc_ps_restore(priv); 1288 mutex_unlock(&priv->mutex); 1289 } 1290 1291 static void ath9k_htc_sta_rc_update_work(struct work_struct *work) 1292 { 1293 struct ath9k_htc_sta *ista = 1294 container_of(work, struct ath9k_htc_sta, rc_update_work); 1295 struct ieee80211_sta *sta = 1296 container_of((void *)ista, struct ieee80211_sta, drv_priv); 1297 struct ath9k_htc_priv *priv = ista->htc_priv; 1298 struct ath_common *common = ath9k_hw_common(priv->ah); 1299 struct ath9k_htc_target_rate trate; 1300 1301 mutex_lock(&priv->mutex); 1302 ath9k_htc_ps_wakeup(priv); 1303 1304 memset(&trate, 0, sizeof(struct ath9k_htc_target_rate)); 1305 ath9k_htc_setup_rate(priv, sta, &trate); 1306 if (!ath9k_htc_send_rate_cmd(priv, &trate)) 1307 ath_dbg(common, CONFIG, 1308 "Supported rates for sta: %pM updated, rate caps: 0x%X\n", 1309 sta->addr, be32_to_cpu(trate.capflags)); 1310 else 1311 ath_dbg(common, CONFIG, 1312 "Unable to update supported rates for sta: %pM\n", 1313 sta->addr); 1314 1315 ath9k_htc_ps_restore(priv); 1316 mutex_unlock(&priv->mutex); 1317 } 1318 1319 static int ath9k_htc_sta_add(struct ieee80211_hw *hw, 1320 struct ieee80211_vif *vif, 1321 struct ieee80211_sta *sta) 1322 { 1323 struct ath9k_htc_priv *priv = hw->priv; 1324 struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv; 1325 int ret; 1326 1327 mutex_lock(&priv->mutex); 1328 ath9k_htc_ps_wakeup(priv); 1329 ret = ath9k_htc_add_station(priv, vif, sta); 1330 if (!ret) { 1331 INIT_WORK(&ista->rc_update_work, ath9k_htc_sta_rc_update_work); 1332 ista->htc_priv = priv; 1333 ath9k_htc_init_rate(priv, sta); 1334 } 1335 ath9k_htc_ps_restore(priv); 1336 mutex_unlock(&priv->mutex); 1337 1338 return ret; 1339 } 1340 1341 static int ath9k_htc_sta_remove(struct ieee80211_hw *hw, 1342 struct ieee80211_vif *vif, 1343 struct ieee80211_sta *sta) 1344 { 1345 struct ath9k_htc_priv *priv = hw->priv; 1346 struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv; 1347 int ret; 1348 1349 cancel_work_sync(&ista->rc_update_work); 1350 1351 mutex_lock(&priv->mutex); 1352 ath9k_htc_ps_wakeup(priv); 1353 htc_sta_drain(priv->htc, ista->index); 1354 ret = ath9k_htc_remove_station(priv, vif, sta); 1355 ath9k_htc_ps_restore(priv); 1356 mutex_unlock(&priv->mutex); 1357 1358 return ret; 1359 } 1360 1361 static void ath9k_htc_sta_rc_update(struct ieee80211_hw *hw, 1362 struct ieee80211_vif *vif, 1363 struct ieee80211_sta *sta, u32 changed) 1364 { 1365 struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv; 1366 1367 if (!(changed & IEEE80211_RC_SUPP_RATES_CHANGED)) 1368 return; 1369 1370 schedule_work(&ista->rc_update_work); 1371 } 1372 1373 static int ath9k_htc_conf_tx(struct ieee80211_hw *hw, 1374 struct ieee80211_vif *vif, u16 queue, 1375 const struct ieee80211_tx_queue_params *params) 1376 { 1377 struct ath9k_htc_priv *priv = hw->priv; 1378 struct ath_common *common = ath9k_hw_common(priv->ah); 1379 struct ath9k_tx_queue_info qi; 1380 int ret = 0, qnum; 1381 1382 if (queue >= IEEE80211_NUM_ACS) 1383 return 0; 1384 1385 mutex_lock(&priv->mutex); 1386 ath9k_htc_ps_wakeup(priv); 1387 1388 memset(&qi, 0, sizeof(struct ath9k_tx_queue_info)); 1389 1390 qi.tqi_aifs = params->aifs; 1391 qi.tqi_cwmin = params->cw_min; 1392 qi.tqi_cwmax = params->cw_max; 1393 qi.tqi_burstTime = params->txop * 32; 1394 1395 qnum = get_hw_qnum(queue, priv->hwq_map); 1396 1397 ath_dbg(common, CONFIG, 1398 "Configure tx [queue/hwq] [%d/%d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n", 1399 queue, qnum, params->aifs, params->cw_min, 1400 params->cw_max, params->txop); 1401 1402 ret = ath_htc_txq_update(priv, qnum, &qi); 1403 if (ret) { 1404 ath_err(common, "TXQ Update failed\n"); 1405 goto out; 1406 } 1407 1408 if ((priv->ah->opmode == NL80211_IFTYPE_ADHOC) && 1409 (qnum == priv->hwq_map[IEEE80211_AC_BE])) 1410 ath9k_htc_beaconq_config(priv); 1411 out: 1412 ath9k_htc_ps_restore(priv); 1413 mutex_unlock(&priv->mutex); 1414 1415 return ret; 1416 } 1417 1418 static int ath9k_htc_set_key(struct ieee80211_hw *hw, 1419 enum set_key_cmd cmd, 1420 struct ieee80211_vif *vif, 1421 struct ieee80211_sta *sta, 1422 struct ieee80211_key_conf *key) 1423 { 1424 struct ath9k_htc_priv *priv = hw->priv; 1425 struct ath_common *common = ath9k_hw_common(priv->ah); 1426 int ret = 0; 1427 1428 if (htc_modparam_nohwcrypt) 1429 return -ENOSPC; 1430 1431 if ((vif->type == NL80211_IFTYPE_ADHOC || 1432 vif->type == NL80211_IFTYPE_MESH_POINT) && 1433 (key->cipher == WLAN_CIPHER_SUITE_TKIP || 1434 key->cipher == WLAN_CIPHER_SUITE_CCMP) && 1435 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) { 1436 /* 1437 * For now, disable hw crypto for the RSN IBSS group keys. This 1438 * could be optimized in the future to use a modified key cache 1439 * design to support per-STA RX GTK, but until that gets 1440 * implemented, use of software crypto for group addressed 1441 * frames is a acceptable to allow RSN IBSS to be used. 1442 */ 1443 return -EOPNOTSUPP; 1444 } 1445 1446 mutex_lock(&priv->mutex); 1447 ath_dbg(common, CONFIG, "Set HW Key\n"); 1448 ath9k_htc_ps_wakeup(priv); 1449 1450 switch (cmd) { 1451 case SET_KEY: 1452 ret = ath_key_config(common, vif, sta, key); 1453 if (ret >= 0) { 1454 key->hw_key_idx = ret; 1455 /* push IV and Michael MIC generation to stack */ 1456 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 1457 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) 1458 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC; 1459 if (priv->ah->sw_mgmt_crypto_tx && 1460 key->cipher == WLAN_CIPHER_SUITE_CCMP) 1461 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX; 1462 ret = 0; 1463 } 1464 break; 1465 case DISABLE_KEY: 1466 ath_key_delete(common, key); 1467 break; 1468 default: 1469 ret = -EINVAL; 1470 } 1471 1472 ath9k_htc_ps_restore(priv); 1473 mutex_unlock(&priv->mutex); 1474 1475 return ret; 1476 } 1477 1478 static void ath9k_htc_set_bssid(struct ath9k_htc_priv *priv) 1479 { 1480 struct ath_common *common = ath9k_hw_common(priv->ah); 1481 1482 ath9k_hw_write_associd(priv->ah); 1483 ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n", 1484 common->curbssid, common->curaid); 1485 } 1486 1487 static void ath9k_htc_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif) 1488 { 1489 struct ath9k_htc_priv *priv = (struct ath9k_htc_priv *)data; 1490 struct ath_common *common = ath9k_hw_common(priv->ah); 1491 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; 1492 1493 if ((vif->type == NL80211_IFTYPE_STATION) && bss_conf->assoc) { 1494 common->curaid = bss_conf->aid; 1495 common->last_rssi = ATH_RSSI_DUMMY_MARKER; 1496 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN); 1497 set_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags); 1498 } 1499 } 1500 1501 static void ath9k_htc_choose_set_bssid(struct ath9k_htc_priv *priv) 1502 { 1503 if (priv->num_sta_assoc_vif == 1) { 1504 ieee80211_iterate_active_interfaces_atomic( 1505 priv->hw, IEEE80211_IFACE_ITER_RESUME_ALL, 1506 ath9k_htc_bss_iter, priv); 1507 ath9k_htc_set_bssid(priv); 1508 } 1509 } 1510 1511 static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw, 1512 struct ieee80211_vif *vif, 1513 struct ieee80211_bss_conf *bss_conf, 1514 u32 changed) 1515 { 1516 struct ath9k_htc_priv *priv = hw->priv; 1517 struct ath_hw *ah = priv->ah; 1518 struct ath_common *common = ath9k_hw_common(ah); 1519 int slottime; 1520 1521 mutex_lock(&priv->mutex); 1522 ath9k_htc_ps_wakeup(priv); 1523 1524 if (changed & BSS_CHANGED_ASSOC) { 1525 ath_dbg(common, CONFIG, "BSS Changed ASSOC %d\n", 1526 bss_conf->assoc); 1527 1528 bss_conf->assoc ? 1529 priv->num_sta_assoc_vif++ : priv->num_sta_assoc_vif--; 1530 1531 if (!bss_conf->assoc) 1532 clear_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags); 1533 1534 if (priv->ah->opmode == NL80211_IFTYPE_STATION) { 1535 ath9k_htc_choose_set_bssid(priv); 1536 if (bss_conf->assoc && (priv->num_sta_assoc_vif == 1)) 1537 ath9k_htc_start_ani(priv); 1538 else if (priv->num_sta_assoc_vif == 0) 1539 ath9k_htc_stop_ani(priv); 1540 } 1541 } 1542 1543 if (changed & BSS_CHANGED_IBSS) { 1544 if (priv->ah->opmode == NL80211_IFTYPE_ADHOC) { 1545 common->curaid = bss_conf->aid; 1546 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN); 1547 ath9k_htc_set_bssid(priv); 1548 } 1549 } 1550 1551 if ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon) { 1552 ath_dbg(common, CONFIG, "Beacon enabled for BSS: %pM\n", 1553 bss_conf->bssid); 1554 ath9k_htc_set_tsfadjust(priv, vif); 1555 priv->cur_beacon_conf.enable_beacon = 1; 1556 ath9k_htc_beacon_config(priv, vif); 1557 } 1558 1559 if ((changed & BSS_CHANGED_BEACON_ENABLED) && !bss_conf->enable_beacon) { 1560 /* 1561 * Disable SWBA interrupt only if there are no 1562 * concurrent AP/mesh or IBSS interfaces. 1563 */ 1564 if ((priv->num_ap_vif + priv->num_mbss_vif <= 1) || 1565 priv->num_ibss_vif) { 1566 ath_dbg(common, CONFIG, 1567 "Beacon disabled for BSS: %pM\n", 1568 bss_conf->bssid); 1569 priv->cur_beacon_conf.enable_beacon = 0; 1570 ath9k_htc_beacon_config(priv, vif); 1571 } 1572 } 1573 1574 if (changed & BSS_CHANGED_BEACON_INT) { 1575 /* 1576 * Reset the HW TSF for the first AP or mesh interface. 1577 */ 1578 if (priv->nvifs == 1 && 1579 ((priv->ah->opmode == NL80211_IFTYPE_AP && 1580 vif->type == NL80211_IFTYPE_AP && 1581 priv->num_ap_vif == 1) || 1582 (priv->ah->opmode == NL80211_IFTYPE_MESH_POINT && 1583 vif->type == NL80211_IFTYPE_MESH_POINT && 1584 priv->num_mbss_vif == 1))) { 1585 set_bit(OP_TSF_RESET, &priv->op_flags); 1586 } 1587 ath_dbg(common, CONFIG, 1588 "Beacon interval changed for BSS: %pM\n", 1589 bss_conf->bssid); 1590 ath9k_htc_beacon_config(priv, vif); 1591 } 1592 1593 if (changed & BSS_CHANGED_ERP_SLOT) { 1594 if (bss_conf->use_short_slot) 1595 slottime = 9; 1596 else 1597 slottime = 20; 1598 if (vif->type == NL80211_IFTYPE_AP) { 1599 /* 1600 * Defer update, so that connected stations can adjust 1601 * their settings at the same time. 1602 * See beacon.c for more details 1603 */ 1604 priv->beacon.slottime = slottime; 1605 priv->beacon.updateslot = UPDATE; 1606 } else { 1607 ah->slottime = slottime; 1608 ath9k_hw_init_global_settings(ah); 1609 } 1610 } 1611 1612 if (changed & BSS_CHANGED_HT) 1613 ath9k_htc_update_rate(priv, vif, bss_conf); 1614 1615 ath9k_htc_ps_restore(priv); 1616 mutex_unlock(&priv->mutex); 1617 } 1618 1619 static u64 ath9k_htc_get_tsf(struct ieee80211_hw *hw, 1620 struct ieee80211_vif *vif) 1621 { 1622 struct ath9k_htc_priv *priv = hw->priv; 1623 u64 tsf; 1624 1625 mutex_lock(&priv->mutex); 1626 ath9k_htc_ps_wakeup(priv); 1627 tsf = ath9k_hw_gettsf64(priv->ah); 1628 ath9k_htc_ps_restore(priv); 1629 mutex_unlock(&priv->mutex); 1630 1631 return tsf; 1632 } 1633 1634 static void ath9k_htc_set_tsf(struct ieee80211_hw *hw, 1635 struct ieee80211_vif *vif, u64 tsf) 1636 { 1637 struct ath9k_htc_priv *priv = hw->priv; 1638 1639 mutex_lock(&priv->mutex); 1640 ath9k_htc_ps_wakeup(priv); 1641 ath9k_hw_settsf64(priv->ah, tsf); 1642 ath9k_htc_ps_restore(priv); 1643 mutex_unlock(&priv->mutex); 1644 } 1645 1646 static void ath9k_htc_reset_tsf(struct ieee80211_hw *hw, 1647 struct ieee80211_vif *vif) 1648 { 1649 struct ath9k_htc_priv *priv = hw->priv; 1650 1651 mutex_lock(&priv->mutex); 1652 ath9k_htc_ps_wakeup(priv); 1653 ath9k_hw_reset_tsf(priv->ah); 1654 ath9k_htc_ps_restore(priv); 1655 mutex_unlock(&priv->mutex); 1656 } 1657 1658 static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw, 1659 struct ieee80211_vif *vif, 1660 enum ieee80211_ampdu_mlme_action action, 1661 struct ieee80211_sta *sta, 1662 u16 tid, u16 *ssn, u8 buf_size) 1663 { 1664 struct ath9k_htc_priv *priv = hw->priv; 1665 struct ath9k_htc_sta *ista; 1666 int ret = 0; 1667 1668 mutex_lock(&priv->mutex); 1669 ath9k_htc_ps_wakeup(priv); 1670 1671 switch (action) { 1672 case IEEE80211_AMPDU_RX_START: 1673 break; 1674 case IEEE80211_AMPDU_RX_STOP: 1675 break; 1676 case IEEE80211_AMPDU_TX_START: 1677 ret = ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid); 1678 if (!ret) 1679 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1680 break; 1681 case IEEE80211_AMPDU_TX_STOP_CONT: 1682 case IEEE80211_AMPDU_TX_STOP_FLUSH: 1683 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 1684 ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid); 1685 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1686 break; 1687 case IEEE80211_AMPDU_TX_OPERATIONAL: 1688 ista = (struct ath9k_htc_sta *) sta->drv_priv; 1689 spin_lock_bh(&priv->tx.tx_lock); 1690 ista->tid_state[tid] = AGGR_OPERATIONAL; 1691 spin_unlock_bh(&priv->tx.tx_lock); 1692 break; 1693 default: 1694 ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n"); 1695 } 1696 1697 ath9k_htc_ps_restore(priv); 1698 mutex_unlock(&priv->mutex); 1699 1700 return ret; 1701 } 1702 1703 static void ath9k_htc_sw_scan_start(struct ieee80211_hw *hw, 1704 struct ieee80211_vif *vif, 1705 const u8 *mac_addr) 1706 { 1707 struct ath9k_htc_priv *priv = hw->priv; 1708 struct ath_common *common = ath9k_hw_common(priv->ah); 1709 1710 mutex_lock(&priv->mutex); 1711 spin_lock_bh(&priv->beacon_lock); 1712 set_bit(ATH_OP_SCANNING, &common->op_flags); 1713 spin_unlock_bh(&priv->beacon_lock); 1714 cancel_work_sync(&priv->ps_work); 1715 ath9k_htc_stop_ani(priv); 1716 mutex_unlock(&priv->mutex); 1717 } 1718 1719 static void ath9k_htc_sw_scan_complete(struct ieee80211_hw *hw, 1720 struct ieee80211_vif *vif) 1721 { 1722 struct ath9k_htc_priv *priv = hw->priv; 1723 struct ath_common *common = ath9k_hw_common(priv->ah); 1724 1725 mutex_lock(&priv->mutex); 1726 spin_lock_bh(&priv->beacon_lock); 1727 clear_bit(ATH_OP_SCANNING, &common->op_flags); 1728 spin_unlock_bh(&priv->beacon_lock); 1729 ath9k_htc_ps_wakeup(priv); 1730 ath9k_htc_vif_reconfig(priv); 1731 ath9k_htc_ps_restore(priv); 1732 mutex_unlock(&priv->mutex); 1733 } 1734 1735 static int ath9k_htc_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 1736 { 1737 return 0; 1738 } 1739 1740 static void ath9k_htc_set_coverage_class(struct ieee80211_hw *hw, 1741 s16 coverage_class) 1742 { 1743 struct ath9k_htc_priv *priv = hw->priv; 1744 1745 mutex_lock(&priv->mutex); 1746 ath9k_htc_ps_wakeup(priv); 1747 priv->ah->coverage_class = coverage_class; 1748 ath9k_hw_init_global_settings(priv->ah); 1749 ath9k_htc_ps_restore(priv); 1750 mutex_unlock(&priv->mutex); 1751 } 1752 1753 /* 1754 * Currently, this is used only for selecting the minimum rate 1755 * for management frames, rate selection for data frames remain 1756 * unaffected. 1757 */ 1758 static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw, 1759 struct ieee80211_vif *vif, 1760 const struct cfg80211_bitrate_mask *mask) 1761 { 1762 struct ath9k_htc_priv *priv = hw->priv; 1763 struct ath_common *common = ath9k_hw_common(priv->ah); 1764 struct ath9k_htc_target_rate_mask tmask; 1765 struct ath9k_htc_vif *avp = (void *)vif->drv_priv; 1766 int ret = 0; 1767 u8 cmd_rsp; 1768 1769 memset(&tmask, 0, sizeof(struct ath9k_htc_target_rate_mask)); 1770 1771 tmask.vif_index = avp->index; 1772 tmask.band = IEEE80211_BAND_2GHZ; 1773 tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_2GHZ].legacy); 1774 1775 WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask); 1776 if (ret) { 1777 ath_err(common, 1778 "Unable to set 2G rate mask for " 1779 "interface at idx: %d\n", avp->index); 1780 goto out; 1781 } 1782 1783 tmask.band = IEEE80211_BAND_5GHZ; 1784 tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_5GHZ].legacy); 1785 1786 WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask); 1787 if (ret) { 1788 ath_err(common, 1789 "Unable to set 5G rate mask for " 1790 "interface at idx: %d\n", avp->index); 1791 goto out; 1792 } 1793 1794 ath_dbg(common, CONFIG, "Set bitrate masks: 0x%x, 0x%x\n", 1795 mask->control[IEEE80211_BAND_2GHZ].legacy, 1796 mask->control[IEEE80211_BAND_5GHZ].legacy); 1797 out: 1798 return ret; 1799 } 1800 1801 1802 static int ath9k_htc_get_stats(struct ieee80211_hw *hw, 1803 struct ieee80211_low_level_stats *stats) 1804 { 1805 struct ath9k_htc_priv *priv = hw->priv; 1806 struct ath_hw *ah = priv->ah; 1807 struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats; 1808 1809 stats->dot11ACKFailureCount = mib_stats->ackrcv_bad; 1810 stats->dot11RTSFailureCount = mib_stats->rts_bad; 1811 stats->dot11FCSErrorCount = mib_stats->fcs_bad; 1812 stats->dot11RTSSuccessCount = mib_stats->rts_good; 1813 1814 return 0; 1815 } 1816 1817 struct base_eep_header *ath9k_htc_get_eeprom_base(struct ath9k_htc_priv *priv) 1818 { 1819 struct base_eep_header *pBase = NULL; 1820 /* 1821 * This can be done since all the 3 EEPROM families have the 1822 * same base header upto a certain point, and we are interested in 1823 * the data only upto that point. 1824 */ 1825 1826 if (AR_SREV_9271(priv->ah)) 1827 pBase = (struct base_eep_header *) 1828 &priv->ah->eeprom.map4k.baseEepHeader; 1829 else if (priv->ah->hw_version.usbdev == AR9280_USB) 1830 pBase = (struct base_eep_header *) 1831 &priv->ah->eeprom.def.baseEepHeader; 1832 else if (priv->ah->hw_version.usbdev == AR9287_USB) 1833 pBase = (struct base_eep_header *) 1834 &priv->ah->eeprom.map9287.baseEepHeader; 1835 return pBase; 1836 } 1837 1838 1839 static int ath9k_htc_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, 1840 u32 *rx_ant) 1841 { 1842 struct ath9k_htc_priv *priv = hw->priv; 1843 struct base_eep_header *pBase = ath9k_htc_get_eeprom_base(priv); 1844 if (pBase) { 1845 *tx_ant = pBase->txMask; 1846 *rx_ant = pBase->rxMask; 1847 } else { 1848 *tx_ant = 0; 1849 *rx_ant = 0; 1850 } 1851 return 0; 1852 } 1853 1854 static void ath9k_htc_channel_switch_beacon(struct ieee80211_hw *hw, 1855 struct ieee80211_vif *vif, 1856 struct cfg80211_chan_def *chandef) 1857 { 1858 struct ath9k_htc_priv *priv = hw->priv; 1859 1860 /* mac80211 does not support CSA in multi-if cases (yet) */ 1861 if (WARN_ON(priv->csa_vif)) 1862 return; 1863 1864 priv->csa_vif = vif; 1865 } 1866 1867 struct ieee80211_ops ath9k_htc_ops = { 1868 .tx = ath9k_htc_tx, 1869 .start = ath9k_htc_start, 1870 .stop = ath9k_htc_stop, 1871 .add_interface = ath9k_htc_add_interface, 1872 .remove_interface = ath9k_htc_remove_interface, 1873 .config = ath9k_htc_config, 1874 .configure_filter = ath9k_htc_configure_filter, 1875 .sta_add = ath9k_htc_sta_add, 1876 .sta_remove = ath9k_htc_sta_remove, 1877 .conf_tx = ath9k_htc_conf_tx, 1878 .sta_rc_update = ath9k_htc_sta_rc_update, 1879 .bss_info_changed = ath9k_htc_bss_info_changed, 1880 .set_key = ath9k_htc_set_key, 1881 .get_tsf = ath9k_htc_get_tsf, 1882 .set_tsf = ath9k_htc_set_tsf, 1883 .reset_tsf = ath9k_htc_reset_tsf, 1884 .ampdu_action = ath9k_htc_ampdu_action, 1885 .sw_scan_start = ath9k_htc_sw_scan_start, 1886 .sw_scan_complete = ath9k_htc_sw_scan_complete, 1887 .set_rts_threshold = ath9k_htc_set_rts_threshold, 1888 .rfkill_poll = ath9k_htc_rfkill_poll_state, 1889 .set_coverage_class = ath9k_htc_set_coverage_class, 1890 .set_bitrate_mask = ath9k_htc_set_bitrate_mask, 1891 .get_stats = ath9k_htc_get_stats, 1892 .get_antenna = ath9k_htc_get_antenna, 1893 .channel_switch_beacon = ath9k_htc_channel_switch_beacon, 1894 1895 #ifdef CONFIG_ATH9K_HTC_DEBUGFS 1896 .get_et_sset_count = ath9k_htc_get_et_sset_count, 1897 .get_et_stats = ath9k_htc_get_et_stats, 1898 .get_et_strings = ath9k_htc_get_et_strings, 1899 #endif 1900 }; 1901