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