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