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