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