]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/net/wireless/ath/ath9k/htc_drv_main.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-2638/i2c/omap' into for-linus/i2c-2638
[mirror_ubuntu-artful-kernel.git] / drivers / net / wireless / ath / ath9k / htc_drv_main.c
1 /*
2 * Copyright (c) 2010 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 #ifdef CONFIG_ATH9K_HTC_DEBUGFS
20 static struct dentry *ath9k_debugfs_root;
21 #endif
22
23 /*************/
24 /* Utilities */
25 /*************/
26
27 void ath_update_txpow(struct ath9k_htc_priv *priv)
28 {
29 struct ath_hw *ah = priv->ah;
30
31 if (priv->curtxpow != priv->txpowlimit) {
32 ath9k_hw_set_txpowerlimit(ah, priv->txpowlimit, false);
33 /* read back in case value is clamped */
34 priv->curtxpow = ath9k_hw_regulatory(ah)->power_limit;
35 }
36 }
37
38 /* HACK Alert: Use 11NG for 2.4, use 11NA for 5 */
39 static enum htc_phymode ath9k_htc_get_curmode(struct ath9k_htc_priv *priv,
40 struct ath9k_channel *ichan)
41 {
42 enum htc_phymode mode;
43
44 mode = HTC_MODE_AUTO;
45
46 switch (ichan->chanmode) {
47 case CHANNEL_G:
48 case CHANNEL_G_HT20:
49 case CHANNEL_G_HT40PLUS:
50 case CHANNEL_G_HT40MINUS:
51 mode = HTC_MODE_11NG;
52 break;
53 case CHANNEL_A:
54 case CHANNEL_A_HT20:
55 case CHANNEL_A_HT40PLUS:
56 case CHANNEL_A_HT40MINUS:
57 mode = HTC_MODE_11NA;
58 break;
59 default:
60 break;
61 }
62
63 return mode;
64 }
65
66 bool ath9k_htc_setpower(struct ath9k_htc_priv *priv,
67 enum ath9k_power_mode mode)
68 {
69 bool ret;
70
71 mutex_lock(&priv->htc_pm_lock);
72 ret = ath9k_hw_setpower(priv->ah, mode);
73 mutex_unlock(&priv->htc_pm_lock);
74
75 return ret;
76 }
77
78 void ath9k_htc_ps_wakeup(struct ath9k_htc_priv *priv)
79 {
80 mutex_lock(&priv->htc_pm_lock);
81 if (++priv->ps_usecount != 1)
82 goto unlock;
83 ath9k_hw_setpower(priv->ah, ATH9K_PM_AWAKE);
84
85 unlock:
86 mutex_unlock(&priv->htc_pm_lock);
87 }
88
89 void ath9k_htc_ps_restore(struct ath9k_htc_priv *priv)
90 {
91 mutex_lock(&priv->htc_pm_lock);
92 if (--priv->ps_usecount != 0)
93 goto unlock;
94
95 if (priv->ps_idle)
96 ath9k_hw_setpower(priv->ah, ATH9K_PM_FULL_SLEEP);
97 else if (priv->ps_enabled)
98 ath9k_hw_setpower(priv->ah, ATH9K_PM_NETWORK_SLEEP);
99
100 unlock:
101 mutex_unlock(&priv->htc_pm_lock);
102 }
103
104 void ath9k_ps_work(struct work_struct *work)
105 {
106 struct ath9k_htc_priv *priv =
107 container_of(work, struct ath9k_htc_priv,
108 ps_work);
109 ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
110
111 /* The chip wakes up after receiving the first beacon
112 while network sleep is enabled. For the driver to
113 be in sync with the hw, set the chip to awake and
114 only then set it to sleep.
115 */
116 ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
117 }
118
119 void ath9k_htc_reset(struct ath9k_htc_priv *priv)
120 {
121 struct ath_hw *ah = priv->ah;
122 struct ath_common *common = ath9k_hw_common(ah);
123 struct ieee80211_channel *channel = priv->hw->conf.channel;
124 struct ath9k_hw_cal_data *caldata;
125 enum htc_phymode mode;
126 __be16 htc_mode;
127 u8 cmd_rsp;
128 int ret;
129
130 mutex_lock(&priv->mutex);
131 ath9k_htc_ps_wakeup(priv);
132
133 if (priv->op_flags & OP_ASSOCIATED)
134 cancel_delayed_work_sync(&priv->ath9k_ani_work);
135
136 ieee80211_stop_queues(priv->hw);
137 htc_stop(priv->htc);
138 WMI_CMD(WMI_DISABLE_INTR_CMDID);
139 WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
140 WMI_CMD(WMI_STOP_RECV_CMDID);
141
142 caldata = &priv->caldata[channel->hw_value];
143 ret = ath9k_hw_reset(ah, ah->curchan, caldata, false);
144 if (ret) {
145 ath_err(common,
146 "Unable to reset device (%u Mhz) reset status %d\n",
147 channel->center_freq, ret);
148 }
149
150 ath_update_txpow(priv);
151
152 WMI_CMD(WMI_START_RECV_CMDID);
153 ath9k_host_rx_init(priv);
154
155 mode = ath9k_htc_get_curmode(priv, ah->curchan);
156 htc_mode = cpu_to_be16(mode);
157 WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
158
159 WMI_CMD(WMI_ENABLE_INTR_CMDID);
160 htc_start(priv->htc);
161
162 if (priv->op_flags & OP_ASSOCIATED) {
163 ath9k_htc_beacon_config(priv, priv->vif);
164 ath_start_ani(priv);
165 }
166
167 ieee80211_wake_queues(priv->hw);
168
169 ath9k_htc_ps_restore(priv);
170 mutex_unlock(&priv->mutex);
171 }
172
173 static int ath9k_htc_set_channel(struct ath9k_htc_priv *priv,
174 struct ieee80211_hw *hw,
175 struct ath9k_channel *hchan)
176 {
177 struct ath_hw *ah = priv->ah;
178 struct ath_common *common = ath9k_hw_common(ah);
179 struct ieee80211_conf *conf = &common->hw->conf;
180 bool fastcc;
181 struct ieee80211_channel *channel = hw->conf.channel;
182 struct ath9k_hw_cal_data *caldata;
183 enum htc_phymode mode;
184 __be16 htc_mode;
185 u8 cmd_rsp;
186 int ret;
187
188 if (priv->op_flags & OP_INVALID)
189 return -EIO;
190
191 fastcc = !!(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL);
192
193 ath9k_htc_ps_wakeup(priv);
194 htc_stop(priv->htc);
195 WMI_CMD(WMI_DISABLE_INTR_CMDID);
196 WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
197 WMI_CMD(WMI_STOP_RECV_CMDID);
198
199 ath_dbg(common, ATH_DBG_CONFIG,
200 "(%u MHz) -> (%u MHz), HT: %d, HT40: %d fastcc: %d\n",
201 priv->ah->curchan->channel,
202 channel->center_freq, conf_is_ht(conf), conf_is_ht40(conf),
203 fastcc);
204
205 caldata = &priv->caldata[channel->hw_value];
206 ret = ath9k_hw_reset(ah, hchan, caldata, fastcc);
207 if (ret) {
208 ath_err(common,
209 "Unable to reset channel (%u Mhz) reset status %d\n",
210 channel->center_freq, ret);
211 goto err;
212 }
213
214 ath_update_txpow(priv);
215
216 WMI_CMD(WMI_START_RECV_CMDID);
217 if (ret)
218 goto err;
219
220 ath9k_host_rx_init(priv);
221
222 mode = ath9k_htc_get_curmode(priv, hchan);
223 htc_mode = cpu_to_be16(mode);
224 WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
225 if (ret)
226 goto err;
227
228 WMI_CMD(WMI_ENABLE_INTR_CMDID);
229 if (ret)
230 goto err;
231
232 htc_start(priv->htc);
233 err:
234 ath9k_htc_ps_restore(priv);
235 return ret;
236 }
237
238 static void __ath9k_htc_remove_monitor_interface(struct ath9k_htc_priv *priv)
239 {
240 struct ath_common *common = ath9k_hw_common(priv->ah);
241 struct ath9k_htc_target_vif hvif;
242 int ret = 0;
243 u8 cmd_rsp;
244
245 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
246 memcpy(&hvif.myaddr, common->macaddr, ETH_ALEN);
247 hvif.index = 0; /* Should do for now */
248 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
249 priv->nvifs--;
250 }
251
252 static int ath9k_htc_add_monitor_interface(struct ath9k_htc_priv *priv)
253 {
254 struct ath_common *common = ath9k_hw_common(priv->ah);
255 struct ath9k_htc_target_vif hvif;
256 struct ath9k_htc_target_sta tsta;
257 int ret = 0;
258 u8 cmd_rsp;
259
260 if (priv->nvifs > 0)
261 return -ENOBUFS;
262
263 if (priv->nstations >= ATH9K_HTC_MAX_STA)
264 return -ENOBUFS;
265
266 /*
267 * Add an interface.
268 */
269
270 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
271 memcpy(&hvif.myaddr, common->macaddr, ETH_ALEN);
272
273 hvif.opmode = cpu_to_be32(HTC_M_MONITOR);
274 priv->ah->opmode = NL80211_IFTYPE_MONITOR;
275 hvif.index = priv->nvifs;
276
277 WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif);
278 if (ret)
279 return ret;
280
281 priv->nvifs++;
282
283 /*
284 * Associate a station with the interface for packet injection.
285 */
286
287 memset(&tsta, 0, sizeof(struct ath9k_htc_target_sta));
288
289 memcpy(&tsta.macaddr, common->macaddr, ETH_ALEN);
290
291 tsta.is_vif_sta = 1;
292 tsta.sta_index = priv->nstations;
293 tsta.vif_index = hvif.index;
294 tsta.maxampdu = 0xffff;
295
296 WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta);
297 if (ret) {
298 ath_err(common, "Unable to add station entry for monitor mode\n");
299 goto err_vif;
300 }
301
302 priv->nstations++;
303
304 return 0;
305
306 err_vif:
307 /*
308 * Remove the interface from the target.
309 */
310 __ath9k_htc_remove_monitor_interface(priv);
311 return ret;
312 }
313
314 static int ath9k_htc_remove_monitor_interface(struct ath9k_htc_priv *priv)
315 {
316 struct ath_common *common = ath9k_hw_common(priv->ah);
317 int ret = 0;
318 u8 cmd_rsp, sta_idx;
319
320 __ath9k_htc_remove_monitor_interface(priv);
321
322 sta_idx = 0; /* Only single interface, for now */
323
324 WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx);
325 if (ret) {
326 ath_err(common, "Unable to remove station entry for monitor mode\n");
327 return ret;
328 }
329
330 priv->nstations--;
331
332 return 0;
333 }
334
335 static int ath9k_htc_add_station(struct ath9k_htc_priv *priv,
336 struct ieee80211_vif *vif,
337 struct ieee80211_sta *sta)
338 {
339 struct ath_common *common = ath9k_hw_common(priv->ah);
340 struct ath9k_htc_target_sta tsta;
341 struct ath9k_htc_vif *avp = (struct ath9k_htc_vif *) vif->drv_priv;
342 struct ath9k_htc_sta *ista;
343 int ret;
344 u8 cmd_rsp;
345
346 if (priv->nstations >= ATH9K_HTC_MAX_STA)
347 return -ENOBUFS;
348
349 memset(&tsta, 0, sizeof(struct ath9k_htc_target_sta));
350
351 if (sta) {
352 ista = (struct ath9k_htc_sta *) sta->drv_priv;
353 memcpy(&tsta.macaddr, sta->addr, ETH_ALEN);
354 memcpy(&tsta.bssid, common->curbssid, ETH_ALEN);
355 tsta.associd = common->curaid;
356 tsta.is_vif_sta = 0;
357 tsta.valid = true;
358 ista->index = priv->nstations;
359 } else {
360 memcpy(&tsta.macaddr, vif->addr, ETH_ALEN);
361 tsta.is_vif_sta = 1;
362 }
363
364 tsta.sta_index = priv->nstations;
365 tsta.vif_index = avp->index;
366 tsta.maxampdu = 0xffff;
367 if (sta && sta->ht_cap.ht_supported)
368 tsta.flags = cpu_to_be16(ATH_HTC_STA_HT);
369
370 WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta);
371 if (ret) {
372 if (sta)
373 ath_err(common,
374 "Unable to add station entry for: %pM\n",
375 sta->addr);
376 return ret;
377 }
378
379 if (sta)
380 ath_dbg(common, ATH_DBG_CONFIG,
381 "Added a station entry for: %pM (idx: %d)\n",
382 sta->addr, tsta.sta_index);
383
384 priv->nstations++;
385 return 0;
386 }
387
388 static int ath9k_htc_remove_station(struct ath9k_htc_priv *priv,
389 struct ieee80211_vif *vif,
390 struct ieee80211_sta *sta)
391 {
392 struct ath_common *common = ath9k_hw_common(priv->ah);
393 struct ath9k_htc_sta *ista;
394 int ret;
395 u8 cmd_rsp, sta_idx;
396
397 if (sta) {
398 ista = (struct ath9k_htc_sta *) sta->drv_priv;
399 sta_idx = ista->index;
400 } else {
401 sta_idx = 0;
402 }
403
404 WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx);
405 if (ret) {
406 if (sta)
407 ath_err(common,
408 "Unable to remove station entry for: %pM\n",
409 sta->addr);
410 return ret;
411 }
412
413 if (sta)
414 ath_dbg(common, ATH_DBG_CONFIG,
415 "Removed a station entry for: %pM (idx: %d)\n",
416 sta->addr, sta_idx);
417
418 priv->nstations--;
419 return 0;
420 }
421
422 static int ath9k_htc_update_cap_target(struct ath9k_htc_priv *priv)
423 {
424 struct ath9k_htc_cap_target tcap;
425 int ret;
426 u8 cmd_rsp;
427
428 memset(&tcap, 0, sizeof(struct ath9k_htc_cap_target));
429
430 /* FIXME: Values are hardcoded */
431 tcap.flags = 0x240c40;
432 tcap.flags_ext = 0x80601000;
433 tcap.ampdu_limit = 0xffff0000;
434 tcap.ampdu_subframes = 20;
435 tcap.tx_chainmask_legacy = priv->ah->caps.tx_chainmask;
436 tcap.protmode = 1;
437 tcap.tx_chainmask = priv->ah->caps.tx_chainmask;
438
439 WMI_CMD_BUF(WMI_TARGET_IC_UPDATE_CMDID, &tcap);
440
441 return ret;
442 }
443
444 static void ath9k_htc_setup_rate(struct ath9k_htc_priv *priv,
445 struct ieee80211_sta *sta,
446 struct ath9k_htc_target_rate *trate)
447 {
448 struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
449 struct ieee80211_supported_band *sband;
450 u32 caps = 0;
451 int i, j;
452
453 sband = priv->hw->wiphy->bands[priv->hw->conf.channel->band];
454
455 for (i = 0, j = 0; i < sband->n_bitrates; i++) {
456 if (sta->supp_rates[sband->band] & BIT(i)) {
457 trate->rates.legacy_rates.rs_rates[j]
458 = (sband->bitrates[i].bitrate * 2) / 10;
459 j++;
460 }
461 }
462 trate->rates.legacy_rates.rs_nrates = j;
463
464 if (sta->ht_cap.ht_supported) {
465 for (i = 0, j = 0; i < 77; i++) {
466 if (sta->ht_cap.mcs.rx_mask[i/8] & (1<<(i%8)))
467 trate->rates.ht_rates.rs_rates[j++] = i;
468 if (j == ATH_HTC_RATE_MAX)
469 break;
470 }
471 trate->rates.ht_rates.rs_nrates = j;
472
473 caps = WLAN_RC_HT_FLAG;
474 if (sta->ht_cap.mcs.rx_mask[1])
475 caps |= WLAN_RC_DS_FLAG;
476 if ((sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
477 (conf_is_ht40(&priv->hw->conf)))
478 caps |= WLAN_RC_40_FLAG;
479 if (conf_is_ht40(&priv->hw->conf) &&
480 (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40))
481 caps |= WLAN_RC_SGI_FLAG;
482 else if (conf_is_ht20(&priv->hw->conf) &&
483 (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20))
484 caps |= WLAN_RC_SGI_FLAG;
485 }
486
487 trate->sta_index = ista->index;
488 trate->isnew = 1;
489 trate->capflags = cpu_to_be32(caps);
490 }
491
492 static int ath9k_htc_send_rate_cmd(struct ath9k_htc_priv *priv,
493 struct ath9k_htc_target_rate *trate)
494 {
495 struct ath_common *common = ath9k_hw_common(priv->ah);
496 int ret;
497 u8 cmd_rsp;
498
499 WMI_CMD_BUF(WMI_RC_RATE_UPDATE_CMDID, trate);
500 if (ret) {
501 ath_err(common,
502 "Unable to initialize Rate information on target\n");
503 }
504
505 return ret;
506 }
507
508 static void ath9k_htc_init_rate(struct ath9k_htc_priv *priv,
509 struct ieee80211_sta *sta)
510 {
511 struct ath_common *common = ath9k_hw_common(priv->ah);
512 struct ath9k_htc_target_rate trate;
513 int ret;
514
515 memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
516 ath9k_htc_setup_rate(priv, sta, &trate);
517 ret = ath9k_htc_send_rate_cmd(priv, &trate);
518 if (!ret)
519 ath_dbg(common, ATH_DBG_CONFIG,
520 "Updated target sta: %pM, rate caps: 0x%X\n",
521 sta->addr, be32_to_cpu(trate.capflags));
522 }
523
524 static void ath9k_htc_update_rate(struct ath9k_htc_priv *priv,
525 struct ieee80211_vif *vif,
526 struct ieee80211_bss_conf *bss_conf)
527 {
528 struct ath_common *common = ath9k_hw_common(priv->ah);
529 struct ath9k_htc_target_rate trate;
530 struct ieee80211_sta *sta;
531 int ret;
532
533 memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
534
535 rcu_read_lock();
536 sta = ieee80211_find_sta(vif, bss_conf->bssid);
537 if (!sta) {
538 rcu_read_unlock();
539 return;
540 }
541 ath9k_htc_setup_rate(priv, sta, &trate);
542 rcu_read_unlock();
543
544 ret = ath9k_htc_send_rate_cmd(priv, &trate);
545 if (!ret)
546 ath_dbg(common, ATH_DBG_CONFIG,
547 "Updated target sta: %pM, rate caps: 0x%X\n",
548 bss_conf->bssid, be32_to_cpu(trate.capflags));
549 }
550
551 static int ath9k_htc_tx_aggr_oper(struct ath9k_htc_priv *priv,
552 struct ieee80211_vif *vif,
553 struct ieee80211_sta *sta,
554 enum ieee80211_ampdu_mlme_action action,
555 u16 tid)
556 {
557 struct ath_common *common = ath9k_hw_common(priv->ah);
558 struct ath9k_htc_target_aggr aggr;
559 struct ath9k_htc_sta *ista;
560 int ret = 0;
561 u8 cmd_rsp;
562
563 if (tid >= ATH9K_HTC_MAX_TID)
564 return -EINVAL;
565
566 memset(&aggr, 0, sizeof(struct ath9k_htc_target_aggr));
567 ista = (struct ath9k_htc_sta *) sta->drv_priv;
568
569 aggr.sta_index = ista->index;
570 aggr.tidno = tid & 0xf;
571 aggr.aggr_enable = (action == IEEE80211_AMPDU_TX_START) ? true : false;
572
573 WMI_CMD_BUF(WMI_TX_AGGR_ENABLE_CMDID, &aggr);
574 if (ret)
575 ath_dbg(common, ATH_DBG_CONFIG,
576 "Unable to %s TX aggregation for (%pM, %d)\n",
577 (aggr.aggr_enable) ? "start" : "stop", sta->addr, tid);
578 else
579 ath_dbg(common, ATH_DBG_CONFIG,
580 "%s TX aggregation for (%pM, %d)\n",
581 (aggr.aggr_enable) ? "Starting" : "Stopping",
582 sta->addr, tid);
583
584 spin_lock_bh(&priv->tx_lock);
585 ista->tid_state[tid] = (aggr.aggr_enable && !ret) ? AGGR_START : AGGR_STOP;
586 spin_unlock_bh(&priv->tx_lock);
587
588 return ret;
589 }
590
591 /*********/
592 /* DEBUG */
593 /*********/
594
595 #ifdef CONFIG_ATH9K_HTC_DEBUGFS
596
597 static int ath9k_debugfs_open(struct inode *inode, struct file *file)
598 {
599 file->private_data = inode->i_private;
600 return 0;
601 }
602
603 static ssize_t read_file_tgt_stats(struct file *file, char __user *user_buf,
604 size_t count, loff_t *ppos)
605 {
606 struct ath9k_htc_priv *priv = file->private_data;
607 struct ath9k_htc_target_stats cmd_rsp;
608 char buf[512];
609 unsigned int len = 0;
610 int ret = 0;
611
612 memset(&cmd_rsp, 0, sizeof(cmd_rsp));
613
614 WMI_CMD(WMI_TGT_STATS_CMDID);
615 if (ret)
616 return -EINVAL;
617
618
619 len += snprintf(buf + len, sizeof(buf) - len,
620 "%19s : %10u\n", "TX Short Retries",
621 be32_to_cpu(cmd_rsp.tx_shortretry));
622 len += snprintf(buf + len, sizeof(buf) - len,
623 "%19s : %10u\n", "TX Long Retries",
624 be32_to_cpu(cmd_rsp.tx_longretry));
625 len += snprintf(buf + len, sizeof(buf) - len,
626 "%19s : %10u\n", "TX Xretries",
627 be32_to_cpu(cmd_rsp.tx_xretries));
628 len += snprintf(buf + len, sizeof(buf) - len,
629 "%19s : %10u\n", "TX Unaggr. Xretries",
630 be32_to_cpu(cmd_rsp.ht_txunaggr_xretry));
631 len += snprintf(buf + len, sizeof(buf) - len,
632 "%19s : %10u\n", "TX Xretries (HT)",
633 be32_to_cpu(cmd_rsp.ht_tx_xretries));
634 len += snprintf(buf + len, sizeof(buf) - len,
635 "%19s : %10u\n", "TX Rate", priv->debug.txrate);
636
637 if (len > sizeof(buf))
638 len = sizeof(buf);
639
640 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
641 }
642
643 static const struct file_operations fops_tgt_stats = {
644 .read = read_file_tgt_stats,
645 .open = ath9k_debugfs_open,
646 .owner = THIS_MODULE,
647 .llseek = default_llseek,
648 };
649
650 static ssize_t read_file_xmit(struct file *file, char __user *user_buf,
651 size_t count, loff_t *ppos)
652 {
653 struct ath9k_htc_priv *priv = file->private_data;
654 char buf[512];
655 unsigned int len = 0;
656
657 len += snprintf(buf + len, sizeof(buf) - len,
658 "%20s : %10u\n", "Buffers queued",
659 priv->debug.tx_stats.buf_queued);
660 len += snprintf(buf + len, sizeof(buf) - len,
661 "%20s : %10u\n", "Buffers completed",
662 priv->debug.tx_stats.buf_completed);
663 len += snprintf(buf + len, sizeof(buf) - len,
664 "%20s : %10u\n", "SKBs queued",
665 priv->debug.tx_stats.skb_queued);
666 len += snprintf(buf + len, sizeof(buf) - len,
667 "%20s : %10u\n", "SKBs completed",
668 priv->debug.tx_stats.skb_completed);
669 len += snprintf(buf + len, sizeof(buf) - len,
670 "%20s : %10u\n", "SKBs dropped",
671 priv->debug.tx_stats.skb_dropped);
672
673 len += snprintf(buf + len, sizeof(buf) - len,
674 "%20s : %10u\n", "BE queued",
675 priv->debug.tx_stats.queue_stats[WME_AC_BE]);
676 len += snprintf(buf + len, sizeof(buf) - len,
677 "%20s : %10u\n", "BK queued",
678 priv->debug.tx_stats.queue_stats[WME_AC_BK]);
679 len += snprintf(buf + len, sizeof(buf) - len,
680 "%20s : %10u\n", "VI queued",
681 priv->debug.tx_stats.queue_stats[WME_AC_VI]);
682 len += snprintf(buf + len, sizeof(buf) - len,
683 "%20s : %10u\n", "VO queued",
684 priv->debug.tx_stats.queue_stats[WME_AC_VO]);
685
686 if (len > sizeof(buf))
687 len = sizeof(buf);
688
689 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
690 }
691
692 static const struct file_operations fops_xmit = {
693 .read = read_file_xmit,
694 .open = ath9k_debugfs_open,
695 .owner = THIS_MODULE,
696 .llseek = default_llseek,
697 };
698
699 static ssize_t read_file_recv(struct file *file, char __user *user_buf,
700 size_t count, loff_t *ppos)
701 {
702 struct ath9k_htc_priv *priv = file->private_data;
703 char buf[512];
704 unsigned int len = 0;
705
706 len += snprintf(buf + len, sizeof(buf) - len,
707 "%20s : %10u\n", "SKBs allocated",
708 priv->debug.rx_stats.skb_allocated);
709 len += snprintf(buf + len, sizeof(buf) - len,
710 "%20s : %10u\n", "SKBs completed",
711 priv->debug.rx_stats.skb_completed);
712 len += snprintf(buf + len, sizeof(buf) - len,
713 "%20s : %10u\n", "SKBs Dropped",
714 priv->debug.rx_stats.skb_dropped);
715
716 if (len > sizeof(buf))
717 len = sizeof(buf);
718
719 return simple_read_from_buffer(user_buf, count, ppos, buf, len);
720 }
721
722 static const struct file_operations fops_recv = {
723 .read = read_file_recv,
724 .open = ath9k_debugfs_open,
725 .owner = THIS_MODULE,
726 .llseek = default_llseek,
727 };
728
729 int ath9k_htc_init_debug(struct ath_hw *ah)
730 {
731 struct ath_common *common = ath9k_hw_common(ah);
732 struct ath9k_htc_priv *priv = (struct ath9k_htc_priv *) common->priv;
733
734 if (!ath9k_debugfs_root)
735 return -ENOENT;
736
737 priv->debug.debugfs_phy = debugfs_create_dir(wiphy_name(priv->hw->wiphy),
738 ath9k_debugfs_root);
739 if (!priv->debug.debugfs_phy)
740 goto err;
741
742 priv->debug.debugfs_tgt_stats = debugfs_create_file("tgt_stats", S_IRUSR,
743 priv->debug.debugfs_phy,
744 priv, &fops_tgt_stats);
745 if (!priv->debug.debugfs_tgt_stats)
746 goto err;
747
748
749 priv->debug.debugfs_xmit = debugfs_create_file("xmit", S_IRUSR,
750 priv->debug.debugfs_phy,
751 priv, &fops_xmit);
752 if (!priv->debug.debugfs_xmit)
753 goto err;
754
755 priv->debug.debugfs_recv = debugfs_create_file("recv", S_IRUSR,
756 priv->debug.debugfs_phy,
757 priv, &fops_recv);
758 if (!priv->debug.debugfs_recv)
759 goto err;
760
761 return 0;
762
763 err:
764 ath9k_htc_exit_debug(ah);
765 return -ENOMEM;
766 }
767
768 void ath9k_htc_exit_debug(struct ath_hw *ah)
769 {
770 struct ath_common *common = ath9k_hw_common(ah);
771 struct ath9k_htc_priv *priv = (struct ath9k_htc_priv *) common->priv;
772
773 debugfs_remove(priv->debug.debugfs_recv);
774 debugfs_remove(priv->debug.debugfs_xmit);
775 debugfs_remove(priv->debug.debugfs_tgt_stats);
776 debugfs_remove(priv->debug.debugfs_phy);
777 }
778
779 int ath9k_htc_debug_create_root(void)
780 {
781 ath9k_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
782 if (!ath9k_debugfs_root)
783 return -ENOENT;
784
785 return 0;
786 }
787
788 void ath9k_htc_debug_remove_root(void)
789 {
790 debugfs_remove(ath9k_debugfs_root);
791 ath9k_debugfs_root = NULL;
792 }
793
794 #endif /* CONFIG_ATH9K_HTC_DEBUGFS */
795
796 /*******/
797 /* ANI */
798 /*******/
799
800 void ath_start_ani(struct ath9k_htc_priv *priv)
801 {
802 struct ath_common *common = ath9k_hw_common(priv->ah);
803 unsigned long timestamp = jiffies_to_msecs(jiffies);
804
805 common->ani.longcal_timer = timestamp;
806 common->ani.shortcal_timer = timestamp;
807 common->ani.checkani_timer = timestamp;
808
809 ieee80211_queue_delayed_work(common->hw, &priv->ath9k_ani_work,
810 msecs_to_jiffies(ATH_ANI_POLLINTERVAL));
811 }
812
813 void ath9k_ani_work(struct work_struct *work)
814 {
815 struct ath9k_htc_priv *priv =
816 container_of(work, struct ath9k_htc_priv,
817 ath9k_ani_work.work);
818 struct ath_hw *ah = priv->ah;
819 struct ath_common *common = ath9k_hw_common(ah);
820 bool longcal = false;
821 bool shortcal = false;
822 bool aniflag = false;
823 unsigned int timestamp = jiffies_to_msecs(jiffies);
824 u32 cal_interval, short_cal_interval;
825
826 short_cal_interval = ATH_STA_SHORT_CALINTERVAL;
827
828 /* Only calibrate if awake */
829 if (ah->power_mode != ATH9K_PM_AWAKE)
830 goto set_timer;
831
832 /* Long calibration runs independently of short calibration. */
833 if ((timestamp - common->ani.longcal_timer) >= ATH_LONG_CALINTERVAL) {
834 longcal = true;
835 ath_dbg(common, ATH_DBG_ANI, "longcal @%lu\n", jiffies);
836 common->ani.longcal_timer = timestamp;
837 }
838
839 /* Short calibration applies only while caldone is false */
840 if (!common->ani.caldone) {
841 if ((timestamp - common->ani.shortcal_timer) >=
842 short_cal_interval) {
843 shortcal = true;
844 ath_dbg(common, ATH_DBG_ANI,
845 "shortcal @%lu\n", jiffies);
846 common->ani.shortcal_timer = timestamp;
847 common->ani.resetcal_timer = timestamp;
848 }
849 } else {
850 if ((timestamp - common->ani.resetcal_timer) >=
851 ATH_RESTART_CALINTERVAL) {
852 common->ani.caldone = ath9k_hw_reset_calvalid(ah);
853 if (common->ani.caldone)
854 common->ani.resetcal_timer = timestamp;
855 }
856 }
857
858 /* Verify whether we must check ANI */
859 if ((timestamp - common->ani.checkani_timer) >= ATH_ANI_POLLINTERVAL) {
860 aniflag = true;
861 common->ani.checkani_timer = timestamp;
862 }
863
864 /* Skip all processing if there's nothing to do. */
865 if (longcal || shortcal || aniflag) {
866
867 ath9k_htc_ps_wakeup(priv);
868
869 /* Call ANI routine if necessary */
870 if (aniflag)
871 ath9k_hw_ani_monitor(ah, ah->curchan);
872
873 /* Perform calibration if necessary */
874 if (longcal || shortcal)
875 common->ani.caldone =
876 ath9k_hw_calibrate(ah, ah->curchan,
877 common->rx_chainmask,
878 longcal);
879
880 ath9k_htc_ps_restore(priv);
881 }
882
883 set_timer:
884 /*
885 * Set timer interval based on previous results.
886 * The interval must be the shortest necessary to satisfy ANI,
887 * short calibration and long calibration.
888 */
889 cal_interval = ATH_LONG_CALINTERVAL;
890 if (priv->ah->config.enable_ani)
891 cal_interval = min(cal_interval, (u32)ATH_ANI_POLLINTERVAL);
892 if (!common->ani.caldone)
893 cal_interval = min(cal_interval, (u32)short_cal_interval);
894
895 ieee80211_queue_delayed_work(common->hw, &priv->ath9k_ani_work,
896 msecs_to_jiffies(cal_interval));
897 }
898
899 /**********************/
900 /* mac80211 Callbacks */
901 /**********************/
902
903 static int ath9k_htc_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
904 {
905 struct ieee80211_hdr *hdr;
906 struct ath9k_htc_priv *priv = hw->priv;
907 int padpos, padsize, ret;
908
909 hdr = (struct ieee80211_hdr *) skb->data;
910
911 /* Add the padding after the header if this is not already done */
912 padpos = ath9k_cmn_padpos(hdr->frame_control);
913 padsize = padpos & 3;
914 if (padsize && skb->len > padpos) {
915 if (skb_headroom(skb) < padsize)
916 return -1;
917 skb_push(skb, padsize);
918 memmove(skb->data, skb->data + padsize, padpos);
919 }
920
921 ret = ath9k_htc_tx_start(priv, skb);
922 if (ret != 0) {
923 if (ret == -ENOMEM) {
924 ath_dbg(ath9k_hw_common(priv->ah), ATH_DBG_XMIT,
925 "Stopping TX queues\n");
926 ieee80211_stop_queues(hw);
927 spin_lock_bh(&priv->tx_lock);
928 priv->tx_queues_stop = true;
929 spin_unlock_bh(&priv->tx_lock);
930 } else {
931 ath_dbg(ath9k_hw_common(priv->ah), ATH_DBG_XMIT,
932 "Tx failed\n");
933 }
934 goto fail_tx;
935 }
936
937 return 0;
938
939 fail_tx:
940 dev_kfree_skb_any(skb);
941 return 0;
942 }
943
944 static int ath9k_htc_start(struct ieee80211_hw *hw)
945 {
946 struct ath9k_htc_priv *priv = hw->priv;
947 struct ath_hw *ah = priv->ah;
948 struct ath_common *common = ath9k_hw_common(ah);
949 struct ieee80211_channel *curchan = hw->conf.channel;
950 struct ath9k_channel *init_channel;
951 int ret = 0;
952 enum htc_phymode mode;
953 __be16 htc_mode;
954 u8 cmd_rsp;
955
956 mutex_lock(&priv->mutex);
957
958 ath_dbg(common, ATH_DBG_CONFIG,
959 "Starting driver with initial channel: %d MHz\n",
960 curchan->center_freq);
961
962 /* Ensure that HW is awake before flushing RX */
963 ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
964 WMI_CMD(WMI_FLUSH_RECV_CMDID);
965
966 /* setup initial channel */
967 init_channel = ath9k_cmn_get_curchannel(hw, ah);
968
969 ath9k_hw_htc_resetinit(ah);
970 ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
971 if (ret) {
972 ath_err(common,
973 "Unable to reset hardware; reset status %d (freq %u MHz)\n",
974 ret, curchan->center_freq);
975 mutex_unlock(&priv->mutex);
976 return ret;
977 }
978
979 ath_update_txpow(priv);
980
981 mode = ath9k_htc_get_curmode(priv, init_channel);
982 htc_mode = cpu_to_be16(mode);
983 WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
984 WMI_CMD(WMI_ATH_INIT_CMDID);
985 WMI_CMD(WMI_START_RECV_CMDID);
986
987 ath9k_host_rx_init(priv);
988
989 priv->op_flags &= ~OP_INVALID;
990 htc_start(priv->htc);
991
992 spin_lock_bh(&priv->tx_lock);
993 priv->tx_queues_stop = false;
994 spin_unlock_bh(&priv->tx_lock);
995
996 ieee80211_wake_queues(hw);
997
998 if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE) {
999 ath9k_hw_btcoex_set_weight(ah, AR_BT_COEX_WGHT,
1000 AR_STOMP_LOW_WLAN_WGHT);
1001 ath9k_hw_btcoex_enable(ah);
1002 ath_htc_resume_btcoex_work(priv);
1003 }
1004 mutex_unlock(&priv->mutex);
1005
1006 return ret;
1007 }
1008
1009 static void ath9k_htc_stop(struct ieee80211_hw *hw)
1010 {
1011 struct ath9k_htc_priv *priv = hw->priv;
1012 struct ath_hw *ah = priv->ah;
1013 struct ath_common *common = ath9k_hw_common(ah);
1014 int ret = 0;
1015 u8 cmd_rsp;
1016
1017 /* Cancel all the running timers/work .. */
1018 cancel_work_sync(&priv->fatal_work);
1019 cancel_work_sync(&priv->ps_work);
1020 cancel_delayed_work_sync(&priv->ath9k_led_blink_work);
1021 ath9k_led_stop_brightness(priv);
1022
1023 mutex_lock(&priv->mutex);
1024
1025 if (priv->op_flags & OP_INVALID) {
1026 ath_dbg(common, ATH_DBG_ANY, "Device not present\n");
1027 mutex_unlock(&priv->mutex);
1028 return;
1029 }
1030
1031 ath9k_htc_ps_wakeup(priv);
1032 htc_stop(priv->htc);
1033 WMI_CMD(WMI_DISABLE_INTR_CMDID);
1034 WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
1035 WMI_CMD(WMI_STOP_RECV_CMDID);
1036 skb_queue_purge(&priv->tx_queue);
1037
1038 /* Remove monitor interface here */
1039 if (ah->opmode == NL80211_IFTYPE_MONITOR) {
1040 if (ath9k_htc_remove_monitor_interface(priv))
1041 ath_err(common, "Unable to remove monitor interface\n");
1042 else
1043 ath_dbg(common, ATH_DBG_CONFIG,
1044 "Monitor interface removed\n");
1045 }
1046
1047 if (ah->btcoex_hw.enabled) {
1048 ath9k_hw_btcoex_disable(ah);
1049 if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
1050 ath_htc_cancel_btcoex_work(priv);
1051 }
1052
1053 ath9k_hw_phy_disable(ah);
1054 ath9k_hw_disable(ah);
1055 ath9k_htc_ps_restore(priv);
1056 ath9k_htc_setpower(priv, ATH9K_PM_FULL_SLEEP);
1057
1058 priv->op_flags |= OP_INVALID;
1059
1060 ath_dbg(common, ATH_DBG_CONFIG, "Driver halt\n");
1061 mutex_unlock(&priv->mutex);
1062 }
1063
1064 static int ath9k_htc_add_interface(struct ieee80211_hw *hw,
1065 struct ieee80211_vif *vif)
1066 {
1067 struct ath9k_htc_priv *priv = hw->priv;
1068 struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1069 struct ath_common *common = ath9k_hw_common(priv->ah);
1070 struct ath9k_htc_target_vif hvif;
1071 int ret = 0;
1072 u8 cmd_rsp;
1073
1074 mutex_lock(&priv->mutex);
1075
1076 /* Only one interface for now */
1077 if (priv->nvifs > 0) {
1078 ret = -ENOBUFS;
1079 goto out;
1080 }
1081
1082 ath9k_htc_ps_wakeup(priv);
1083 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1084 memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1085
1086 switch (vif->type) {
1087 case NL80211_IFTYPE_STATION:
1088 hvif.opmode = cpu_to_be32(HTC_M_STA);
1089 break;
1090 case NL80211_IFTYPE_ADHOC:
1091 hvif.opmode = cpu_to_be32(HTC_M_IBSS);
1092 break;
1093 default:
1094 ath_err(common,
1095 "Interface type %d not yet supported\n", vif->type);
1096 ret = -EOPNOTSUPP;
1097 goto out;
1098 }
1099
1100 ath_dbg(common, ATH_DBG_CONFIG,
1101 "Attach a VIF of type: %d\n", vif->type);
1102
1103 priv->ah->opmode = vif->type;
1104
1105 /* Index starts from zero on the target */
1106 avp->index = hvif.index = priv->nvifs;
1107 hvif.rtsthreshold = cpu_to_be16(2304);
1108 WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif);
1109 if (ret)
1110 goto out;
1111
1112 priv->nvifs++;
1113
1114 /*
1115 * We need a node in target to tx mgmt frames
1116 * before association.
1117 */
1118 ret = ath9k_htc_add_station(priv, vif, NULL);
1119 if (ret)
1120 goto out;
1121
1122 ret = ath9k_htc_update_cap_target(priv);
1123 if (ret)
1124 ath_dbg(common, ATH_DBG_CONFIG,
1125 "Failed to update capability in target\n");
1126
1127 priv->vif = vif;
1128 out:
1129 ath9k_htc_ps_restore(priv);
1130 mutex_unlock(&priv->mutex);
1131
1132 return ret;
1133 }
1134
1135 static void ath9k_htc_remove_interface(struct ieee80211_hw *hw,
1136 struct ieee80211_vif *vif)
1137 {
1138 struct ath9k_htc_priv *priv = hw->priv;
1139 struct ath_common *common = ath9k_hw_common(priv->ah);
1140 struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1141 struct ath9k_htc_target_vif hvif;
1142 int ret = 0;
1143 u8 cmd_rsp;
1144
1145 ath_dbg(common, ATH_DBG_CONFIG, "Detach Interface\n");
1146
1147 mutex_lock(&priv->mutex);
1148 ath9k_htc_ps_wakeup(priv);
1149
1150 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1151 memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1152 hvif.index = avp->index;
1153 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1154 priv->nvifs--;
1155
1156 ath9k_htc_remove_station(priv, vif, NULL);
1157 priv->vif = NULL;
1158
1159 ath9k_htc_ps_restore(priv);
1160 mutex_unlock(&priv->mutex);
1161 }
1162
1163 static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
1164 {
1165 struct ath9k_htc_priv *priv = hw->priv;
1166 struct ath_common *common = ath9k_hw_common(priv->ah);
1167 struct ieee80211_conf *conf = &hw->conf;
1168
1169 mutex_lock(&priv->mutex);
1170
1171 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1172 bool enable_radio = false;
1173 bool idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1174
1175 mutex_lock(&priv->htc_pm_lock);
1176 if (!idle && priv->ps_idle)
1177 enable_radio = true;
1178 priv->ps_idle = idle;
1179 mutex_unlock(&priv->htc_pm_lock);
1180
1181 if (enable_radio) {
1182 ath_dbg(common, ATH_DBG_CONFIG,
1183 "not-idle: enabling radio\n");
1184 ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1185 ath9k_htc_radio_enable(hw);
1186 }
1187 }
1188
1189 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1190 struct ieee80211_channel *curchan = hw->conf.channel;
1191 int pos = curchan->hw_value;
1192
1193 ath_dbg(common, ATH_DBG_CONFIG, "Set channel: %d MHz\n",
1194 curchan->center_freq);
1195
1196 ath9k_cmn_update_ichannel(&priv->ah->channels[pos],
1197 hw->conf.channel,
1198 hw->conf.channel_type);
1199
1200 if (ath9k_htc_set_channel(priv, hw, &priv->ah->channels[pos]) < 0) {
1201 ath_err(common, "Unable to set channel\n");
1202 mutex_unlock(&priv->mutex);
1203 return -EINVAL;
1204 }
1205
1206 }
1207
1208 if (changed & IEEE80211_CONF_CHANGE_PS) {
1209 if (conf->flags & IEEE80211_CONF_PS) {
1210 ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
1211 priv->ps_enabled = true;
1212 } else {
1213 priv->ps_enabled = false;
1214 cancel_work_sync(&priv->ps_work);
1215 ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1216 }
1217 }
1218
1219 if (changed & IEEE80211_CONF_CHANGE_POWER) {
1220 priv->txpowlimit = 2 * conf->power_level;
1221 ath_update_txpow(priv);
1222 }
1223
1224 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1225 if (conf->flags & IEEE80211_CONF_MONITOR) {
1226 if (ath9k_htc_add_monitor_interface(priv))
1227 ath_err(common, "Failed to set monitor mode\n");
1228 else
1229 ath_dbg(common, ATH_DBG_CONFIG,
1230 "HW opmode set to Monitor mode\n");
1231 }
1232 }
1233
1234 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1235 mutex_lock(&priv->htc_pm_lock);
1236 if (!priv->ps_idle) {
1237 mutex_unlock(&priv->htc_pm_lock);
1238 goto out;
1239 }
1240 mutex_unlock(&priv->htc_pm_lock);
1241
1242 ath_dbg(common, ATH_DBG_CONFIG,
1243 "idle: disabling radio\n");
1244 ath9k_htc_radio_disable(hw);
1245 }
1246
1247 out:
1248 mutex_unlock(&priv->mutex);
1249 return 0;
1250 }
1251
1252 #define SUPPORTED_FILTERS \
1253 (FIF_PROMISC_IN_BSS | \
1254 FIF_ALLMULTI | \
1255 FIF_CONTROL | \
1256 FIF_PSPOLL | \
1257 FIF_OTHER_BSS | \
1258 FIF_BCN_PRBRESP_PROMISC | \
1259 FIF_PROBE_REQ | \
1260 FIF_FCSFAIL)
1261
1262 static void ath9k_htc_configure_filter(struct ieee80211_hw *hw,
1263 unsigned int changed_flags,
1264 unsigned int *total_flags,
1265 u64 multicast)
1266 {
1267 struct ath9k_htc_priv *priv = hw->priv;
1268 u32 rfilt;
1269
1270 mutex_lock(&priv->mutex);
1271 ath9k_htc_ps_wakeup(priv);
1272
1273 changed_flags &= SUPPORTED_FILTERS;
1274 *total_flags &= SUPPORTED_FILTERS;
1275
1276 priv->rxfilter = *total_flags;
1277 rfilt = ath9k_htc_calcrxfilter(priv);
1278 ath9k_hw_setrxfilter(priv->ah, rfilt);
1279
1280 ath_dbg(ath9k_hw_common(priv->ah), ATH_DBG_CONFIG,
1281 "Set HW RX filter: 0x%x\n", rfilt);
1282
1283 ath9k_htc_ps_restore(priv);
1284 mutex_unlock(&priv->mutex);
1285 }
1286
1287 static int ath9k_htc_sta_add(struct ieee80211_hw *hw,
1288 struct ieee80211_vif *vif,
1289 struct ieee80211_sta *sta)
1290 {
1291 struct ath9k_htc_priv *priv = hw->priv;
1292 int ret;
1293
1294 mutex_lock(&priv->mutex);
1295 ath9k_htc_ps_wakeup(priv);
1296 ret = ath9k_htc_add_station(priv, vif, sta);
1297 if (!ret)
1298 ath9k_htc_init_rate(priv, sta);
1299 ath9k_htc_ps_restore(priv);
1300 mutex_unlock(&priv->mutex);
1301
1302 return ret;
1303 }
1304
1305 static int ath9k_htc_sta_remove(struct ieee80211_hw *hw,
1306 struct ieee80211_vif *vif,
1307 struct ieee80211_sta *sta)
1308 {
1309 struct ath9k_htc_priv *priv = hw->priv;
1310 int ret;
1311
1312 mutex_lock(&priv->mutex);
1313 ath9k_htc_ps_wakeup(priv);
1314 ret = ath9k_htc_remove_station(priv, vif, sta);
1315 ath9k_htc_ps_restore(priv);
1316 mutex_unlock(&priv->mutex);
1317
1318 return ret;
1319 }
1320
1321 static int ath9k_htc_conf_tx(struct ieee80211_hw *hw, u16 queue,
1322 const struct ieee80211_tx_queue_params *params)
1323 {
1324 struct ath9k_htc_priv *priv = hw->priv;
1325 struct ath_common *common = ath9k_hw_common(priv->ah);
1326 struct ath9k_tx_queue_info qi;
1327 int ret = 0, qnum;
1328
1329 if (queue >= WME_NUM_AC)
1330 return 0;
1331
1332 mutex_lock(&priv->mutex);
1333 ath9k_htc_ps_wakeup(priv);
1334
1335 memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1336
1337 qi.tqi_aifs = params->aifs;
1338 qi.tqi_cwmin = params->cw_min;
1339 qi.tqi_cwmax = params->cw_max;
1340 qi.tqi_burstTime = params->txop;
1341
1342 qnum = get_hw_qnum(queue, priv->hwq_map);
1343
1344 ath_dbg(common, ATH_DBG_CONFIG,
1345 "Configure tx [queue/hwq] [%d/%d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1346 queue, qnum, params->aifs, params->cw_min,
1347 params->cw_max, params->txop);
1348
1349 ret = ath_htc_txq_update(priv, qnum, &qi);
1350 if (ret) {
1351 ath_err(common, "TXQ Update failed\n");
1352 goto out;
1353 }
1354
1355 if ((priv->ah->opmode == NL80211_IFTYPE_ADHOC) &&
1356 (qnum == priv->hwq_map[WME_AC_BE]))
1357 ath9k_htc_beaconq_config(priv);
1358 out:
1359 ath9k_htc_ps_restore(priv);
1360 mutex_unlock(&priv->mutex);
1361
1362 return ret;
1363 }
1364
1365 static int ath9k_htc_set_key(struct ieee80211_hw *hw,
1366 enum set_key_cmd cmd,
1367 struct ieee80211_vif *vif,
1368 struct ieee80211_sta *sta,
1369 struct ieee80211_key_conf *key)
1370 {
1371 struct ath9k_htc_priv *priv = hw->priv;
1372 struct ath_common *common = ath9k_hw_common(priv->ah);
1373 int ret = 0;
1374
1375 if (htc_modparam_nohwcrypt)
1376 return -ENOSPC;
1377
1378 mutex_lock(&priv->mutex);
1379 ath_dbg(common, ATH_DBG_CONFIG, "Set HW Key\n");
1380 ath9k_htc_ps_wakeup(priv);
1381
1382 switch (cmd) {
1383 case SET_KEY:
1384 ret = ath_key_config(common, vif, sta, key);
1385 if (ret >= 0) {
1386 key->hw_key_idx = ret;
1387 /* push IV and Michael MIC generation to stack */
1388 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1389 if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
1390 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1391 if (priv->ah->sw_mgmt_crypto &&
1392 key->cipher == WLAN_CIPHER_SUITE_CCMP)
1393 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT;
1394 ret = 0;
1395 }
1396 break;
1397 case DISABLE_KEY:
1398 ath_key_delete(common, key);
1399 break;
1400 default:
1401 ret = -EINVAL;
1402 }
1403
1404 ath9k_htc_ps_restore(priv);
1405 mutex_unlock(&priv->mutex);
1406
1407 return ret;
1408 }
1409
1410 static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
1411 struct ieee80211_vif *vif,
1412 struct ieee80211_bss_conf *bss_conf,
1413 u32 changed)
1414 {
1415 struct ath9k_htc_priv *priv = hw->priv;
1416 struct ath_hw *ah = priv->ah;
1417 struct ath_common *common = ath9k_hw_common(ah);
1418
1419 mutex_lock(&priv->mutex);
1420 ath9k_htc_ps_wakeup(priv);
1421
1422 if (changed & BSS_CHANGED_ASSOC) {
1423 common->curaid = bss_conf->assoc ?
1424 bss_conf->aid : 0;
1425 ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed ASSOC %d\n",
1426 bss_conf->assoc);
1427
1428 if (bss_conf->assoc) {
1429 priv->op_flags |= OP_ASSOCIATED;
1430 ath_start_ani(priv);
1431 } else {
1432 priv->op_flags &= ~OP_ASSOCIATED;
1433 cancel_delayed_work_sync(&priv->ath9k_ani_work);
1434 }
1435 }
1436
1437 if (changed & BSS_CHANGED_BSSID) {
1438 /* Set BSSID */
1439 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1440 ath9k_hw_write_associd(ah);
1441
1442 ath_dbg(common, ATH_DBG_CONFIG,
1443 "BSSID: %pM aid: 0x%x\n",
1444 common->curbssid, common->curaid);
1445 }
1446
1447 if ((changed & BSS_CHANGED_BEACON_INT) ||
1448 (changed & BSS_CHANGED_BEACON) ||
1449 ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1450 bss_conf->enable_beacon)) {
1451 priv->op_flags |= OP_ENABLE_BEACON;
1452 ath9k_htc_beacon_config(priv, vif);
1453 }
1454
1455 if ((changed & BSS_CHANGED_BEACON_ENABLED) &&
1456 !bss_conf->enable_beacon) {
1457 priv->op_flags &= ~OP_ENABLE_BEACON;
1458 ath9k_htc_beacon_config(priv, vif);
1459 }
1460
1461 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
1462 ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed PREAMBLE %d\n",
1463 bss_conf->use_short_preamble);
1464 if (bss_conf->use_short_preamble)
1465 priv->op_flags |= OP_PREAMBLE_SHORT;
1466 else
1467 priv->op_flags &= ~OP_PREAMBLE_SHORT;
1468 }
1469
1470 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
1471 ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed CTS PROT %d\n",
1472 bss_conf->use_cts_prot);
1473 if (bss_conf->use_cts_prot &&
1474 hw->conf.channel->band != IEEE80211_BAND_5GHZ)
1475 priv->op_flags |= OP_PROTECT_ENABLE;
1476 else
1477 priv->op_flags &= ~OP_PROTECT_ENABLE;
1478 }
1479
1480 if (changed & BSS_CHANGED_ERP_SLOT) {
1481 if (bss_conf->use_short_slot)
1482 ah->slottime = 9;
1483 else
1484 ah->slottime = 20;
1485
1486 ath9k_hw_init_global_settings(ah);
1487 }
1488
1489 if (changed & BSS_CHANGED_HT)
1490 ath9k_htc_update_rate(priv, vif, bss_conf);
1491
1492 ath9k_htc_ps_restore(priv);
1493 mutex_unlock(&priv->mutex);
1494 }
1495
1496 static u64 ath9k_htc_get_tsf(struct ieee80211_hw *hw)
1497 {
1498 struct ath9k_htc_priv *priv = hw->priv;
1499 u64 tsf;
1500
1501 mutex_lock(&priv->mutex);
1502 ath9k_htc_ps_wakeup(priv);
1503 tsf = ath9k_hw_gettsf64(priv->ah);
1504 ath9k_htc_ps_restore(priv);
1505 mutex_unlock(&priv->mutex);
1506
1507 return tsf;
1508 }
1509
1510 static void ath9k_htc_set_tsf(struct ieee80211_hw *hw, u64 tsf)
1511 {
1512 struct ath9k_htc_priv *priv = hw->priv;
1513
1514 mutex_lock(&priv->mutex);
1515 ath9k_htc_ps_wakeup(priv);
1516 ath9k_hw_settsf64(priv->ah, tsf);
1517 ath9k_htc_ps_restore(priv);
1518 mutex_unlock(&priv->mutex);
1519 }
1520
1521 static void ath9k_htc_reset_tsf(struct ieee80211_hw *hw)
1522 {
1523 struct ath9k_htc_priv *priv = hw->priv;
1524
1525 mutex_lock(&priv->mutex);
1526 ath9k_htc_ps_wakeup(priv);
1527 ath9k_hw_reset_tsf(priv->ah);
1528 ath9k_htc_ps_restore(priv);
1529 mutex_unlock(&priv->mutex);
1530 }
1531
1532 static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw,
1533 struct ieee80211_vif *vif,
1534 enum ieee80211_ampdu_mlme_action action,
1535 struct ieee80211_sta *sta,
1536 u16 tid, u16 *ssn)
1537 {
1538 struct ath9k_htc_priv *priv = hw->priv;
1539 struct ath9k_htc_sta *ista;
1540 int ret = 0;
1541
1542 switch (action) {
1543 case IEEE80211_AMPDU_RX_START:
1544 break;
1545 case IEEE80211_AMPDU_RX_STOP:
1546 break;
1547 case IEEE80211_AMPDU_TX_START:
1548 ret = ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1549 if (!ret)
1550 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1551 break;
1552 case IEEE80211_AMPDU_TX_STOP:
1553 ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1554 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1555 break;
1556 case IEEE80211_AMPDU_TX_OPERATIONAL:
1557 ista = (struct ath9k_htc_sta *) sta->drv_priv;
1558 spin_lock_bh(&priv->tx_lock);
1559 ista->tid_state[tid] = AGGR_OPERATIONAL;
1560 spin_unlock_bh(&priv->tx_lock);
1561 break;
1562 default:
1563 ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
1564 }
1565
1566 return ret;
1567 }
1568
1569 static void ath9k_htc_sw_scan_start(struct ieee80211_hw *hw)
1570 {
1571 struct ath9k_htc_priv *priv = hw->priv;
1572
1573 mutex_lock(&priv->mutex);
1574 spin_lock_bh(&priv->beacon_lock);
1575 priv->op_flags |= OP_SCANNING;
1576 spin_unlock_bh(&priv->beacon_lock);
1577 cancel_work_sync(&priv->ps_work);
1578 if (priv->op_flags & OP_ASSOCIATED)
1579 cancel_delayed_work_sync(&priv->ath9k_ani_work);
1580 mutex_unlock(&priv->mutex);
1581 }
1582
1583 static void ath9k_htc_sw_scan_complete(struct ieee80211_hw *hw)
1584 {
1585 struct ath9k_htc_priv *priv = hw->priv;
1586
1587 mutex_lock(&priv->mutex);
1588 ath9k_htc_ps_wakeup(priv);
1589 spin_lock_bh(&priv->beacon_lock);
1590 priv->op_flags &= ~OP_SCANNING;
1591 spin_unlock_bh(&priv->beacon_lock);
1592 if (priv->op_flags & OP_ASSOCIATED) {
1593 ath9k_htc_beacon_config(priv, priv->vif);
1594 ath_start_ani(priv);
1595 }
1596 ath9k_htc_ps_restore(priv);
1597 mutex_unlock(&priv->mutex);
1598 }
1599
1600 static int ath9k_htc_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1601 {
1602 return 0;
1603 }
1604
1605 static void ath9k_htc_set_coverage_class(struct ieee80211_hw *hw,
1606 u8 coverage_class)
1607 {
1608 struct ath9k_htc_priv *priv = hw->priv;
1609
1610 mutex_lock(&priv->mutex);
1611 ath9k_htc_ps_wakeup(priv);
1612 priv->ah->coverage_class = coverage_class;
1613 ath9k_hw_init_global_settings(priv->ah);
1614 ath9k_htc_ps_restore(priv);
1615 mutex_unlock(&priv->mutex);
1616 }
1617
1618 struct ieee80211_ops ath9k_htc_ops = {
1619 .tx = ath9k_htc_tx,
1620 .start = ath9k_htc_start,
1621 .stop = ath9k_htc_stop,
1622 .add_interface = ath9k_htc_add_interface,
1623 .remove_interface = ath9k_htc_remove_interface,
1624 .config = ath9k_htc_config,
1625 .configure_filter = ath9k_htc_configure_filter,
1626 .sta_add = ath9k_htc_sta_add,
1627 .sta_remove = ath9k_htc_sta_remove,
1628 .conf_tx = ath9k_htc_conf_tx,
1629 .bss_info_changed = ath9k_htc_bss_info_changed,
1630 .set_key = ath9k_htc_set_key,
1631 .get_tsf = ath9k_htc_get_tsf,
1632 .set_tsf = ath9k_htc_set_tsf,
1633 .reset_tsf = ath9k_htc_reset_tsf,
1634 .ampdu_action = ath9k_htc_ampdu_action,
1635 .sw_scan_start = ath9k_htc_sw_scan_start,
1636 .sw_scan_complete = ath9k_htc_sw_scan_complete,
1637 .set_rts_threshold = ath9k_htc_set_rts_threshold,
1638 .rfkill_poll = ath9k_htc_rfkill_poll_state,
1639 .set_coverage_class = ath9k_htc_set_coverage_class,
1640 };
Ubuntu Artful kernel mirror