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