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