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