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