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