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