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