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