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