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