]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/net/wireless/ath/ath9k/htc_drv_main.c
51977caca47fd6d456e521cff4511e1079f2e09a
[~shefty/rdma-dev.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 };