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