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