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