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 (vif->cfg.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->deflink.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->deflink.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->deflink.ht_cap.ht_supported) {
614 		for (i = 0, j = 0; i < 77; i++) {
615 			if (sta->deflink.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->deflink.ht_cap.cap & IEEE80211_HT_CAP_RX_STBC)
624 			caps |= ATH_RC_TX_STBC_FLAG;
625 		if (sta->deflink.ht_cap.mcs.rx_mask[1])
626 			caps |= WLAN_RC_DS_FLAG;
627 		if ((sta->deflink.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->deflink.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->deflink.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_MCAST_ACTION |			\
1255 	FIF_FCSFAIL)
1256 
1257 static void ath9k_htc_configure_filter(struct ieee80211_hw *hw,
1258 				       unsigned int changed_flags,
1259 				       unsigned int *total_flags,
1260 				       u64 multicast)
1261 {
1262 	struct ath9k_htc_priv *priv = hw->priv;
1263 	struct ath_common *common = ath9k_hw_common(priv->ah);
1264 	u32 rfilt;
1265 
1266 	mutex_lock(&priv->mutex);
1267 	changed_flags &= SUPPORTED_FILTERS;
1268 	*total_flags &= SUPPORTED_FILTERS;
1269 
1270 	if (test_bit(ATH_OP_INVALID, &common->op_flags)) {
1271 		ath_dbg(ath9k_hw_common(priv->ah), ANY,
1272 			"Unable to configure filter on invalid state\n");
1273 		mutex_unlock(&priv->mutex);
1274 		return;
1275 	}
1276 	ath9k_htc_ps_wakeup(priv);
1277 
1278 	priv->rxfilter = *total_flags;
1279 	rfilt = ath9k_htc_calcrxfilter(priv);
1280 	ath9k_hw_setrxfilter(priv->ah, rfilt);
1281 
1282 	ath_dbg(ath9k_hw_common(priv->ah), CONFIG, "Set HW RX filter: 0x%x\n",
1283 		rfilt);
1284 
1285 	ath9k_htc_ps_restore(priv);
1286 	mutex_unlock(&priv->mutex);
1287 }
1288 
1289 static void ath9k_htc_sta_rc_update_work(struct work_struct *work)
1290 {
1291 	struct ath9k_htc_sta *ista =
1292 	    container_of(work, struct ath9k_htc_sta, rc_update_work);
1293 	struct ieee80211_sta *sta =
1294 	    container_of((void *)ista, struct ieee80211_sta, drv_priv);
1295 	struct ath9k_htc_priv *priv = ista->htc_priv;
1296 	struct ath_common *common = ath9k_hw_common(priv->ah);
1297 	struct ath9k_htc_target_rate trate;
1298 
1299 	mutex_lock(&priv->mutex);
1300 	ath9k_htc_ps_wakeup(priv);
1301 
1302 	memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
1303 	ath9k_htc_setup_rate(priv, sta, &trate);
1304 	if (!ath9k_htc_send_rate_cmd(priv, &trate))
1305 		ath_dbg(common, CONFIG,
1306 			"Supported rates for sta: %pM updated, rate caps: 0x%X\n",
1307 			sta->addr, be32_to_cpu(trate.capflags));
1308 	else
1309 		ath_dbg(common, CONFIG,
1310 			"Unable to update supported rates for sta: %pM\n",
1311 			sta->addr);
1312 
1313 	ath9k_htc_ps_restore(priv);
1314 	mutex_unlock(&priv->mutex);
1315 }
1316 
1317 static int ath9k_htc_sta_add(struct ieee80211_hw *hw,
1318 			     struct ieee80211_vif *vif,
1319 			     struct ieee80211_sta *sta)
1320 {
1321 	struct ath9k_htc_priv *priv = hw->priv;
1322 	struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
1323 	int ret;
1324 
1325 	mutex_lock(&priv->mutex);
1326 	ath9k_htc_ps_wakeup(priv);
1327 	ret = ath9k_htc_add_station(priv, vif, sta);
1328 	if (!ret) {
1329 		INIT_WORK(&ista->rc_update_work, ath9k_htc_sta_rc_update_work);
1330 		ista->htc_priv = priv;
1331 		ath9k_htc_init_rate(priv, sta);
1332 	}
1333 	ath9k_htc_ps_restore(priv);
1334 	mutex_unlock(&priv->mutex);
1335 
1336 	return ret;
1337 }
1338 
1339 static int ath9k_htc_sta_remove(struct ieee80211_hw *hw,
1340 				struct ieee80211_vif *vif,
1341 				struct ieee80211_sta *sta)
1342 {
1343 	struct ath9k_htc_priv *priv = hw->priv;
1344 	struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
1345 	int ret;
1346 
1347 	cancel_work_sync(&ista->rc_update_work);
1348 
1349 	mutex_lock(&priv->mutex);
1350 	ath9k_htc_ps_wakeup(priv);
1351 	htc_sta_drain(priv->htc, ista->index);
1352 	ret = ath9k_htc_remove_station(priv, vif, sta);
1353 	ath9k_htc_ps_restore(priv);
1354 	mutex_unlock(&priv->mutex);
1355 
1356 	return ret;
1357 }
1358 
1359 static void ath9k_htc_sta_rc_update(struct ieee80211_hw *hw,
1360 				    struct ieee80211_vif *vif,
1361 				    struct ieee80211_sta *sta, u32 changed)
1362 {
1363 	struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
1364 
1365 	if (!(changed & IEEE80211_RC_SUPP_RATES_CHANGED))
1366 		return;
1367 
1368 	schedule_work(&ista->rc_update_work);
1369 }
1370 
1371 static int ath9k_htc_conf_tx(struct ieee80211_hw *hw,
1372 			     struct ieee80211_vif *vif,
1373 			     unsigned int link_id, u16 queue,
1374 			     const struct ieee80211_tx_queue_params *params)
1375 {
1376 	struct ath9k_htc_priv *priv = hw->priv;
1377 	struct ath_common *common = ath9k_hw_common(priv->ah);
1378 	struct ath9k_tx_queue_info qi;
1379 	int ret = 0, qnum;
1380 
1381 	if (queue >= IEEE80211_NUM_ACS)
1382 		return 0;
1383 
1384 	mutex_lock(&priv->mutex);
1385 	ath9k_htc_ps_wakeup(priv);
1386 
1387 	memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1388 
1389 	qi.tqi_aifs = params->aifs;
1390 	qi.tqi_cwmin = params->cw_min;
1391 	qi.tqi_cwmax = params->cw_max;
1392 	qi.tqi_burstTime = params->txop * 32;
1393 
1394 	qnum = get_hw_qnum(queue, priv->hwq_map);
1395 
1396 	ath_dbg(common, CONFIG,
1397 		"Configure tx [queue/hwq] [%d/%d],  aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1398 		queue, qnum, params->aifs, params->cw_min,
1399 		params->cw_max, params->txop);
1400 
1401 	ret = ath_htc_txq_update(priv, qnum, &qi);
1402 	if (ret) {
1403 		ath_err(common, "TXQ Update failed\n");
1404 		goto out;
1405 	}
1406 
1407 	if ((priv->ah->opmode == NL80211_IFTYPE_ADHOC) &&
1408 	    (qnum == priv->hwq_map[IEEE80211_AC_BE]))
1409 		    ath9k_htc_beaconq_config(priv);
1410 out:
1411 	ath9k_htc_ps_restore(priv);
1412 	mutex_unlock(&priv->mutex);
1413 
1414 	return ret;
1415 }
1416 
1417 static int ath9k_htc_set_key(struct ieee80211_hw *hw,
1418 			     enum set_key_cmd cmd,
1419 			     struct ieee80211_vif *vif,
1420 			     struct ieee80211_sta *sta,
1421 			     struct ieee80211_key_conf *key)
1422 {
1423 	struct ath9k_htc_priv *priv = hw->priv;
1424 	struct ath_common *common = ath9k_hw_common(priv->ah);
1425 	int ret = 0;
1426 
1427 	if (htc_modparam_nohwcrypt)
1428 		return -ENOSPC;
1429 
1430 	if ((vif->type == NL80211_IFTYPE_ADHOC ||
1431 	     vif->type == NL80211_IFTYPE_MESH_POINT) &&
1432 	    (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
1433 	     key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
1434 	    !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1435 		/*
1436 		 * For now, disable hw crypto for the RSN IBSS group keys. This
1437 		 * could be optimized in the future to use a modified key cache
1438 		 * design to support per-STA RX GTK, but until that gets
1439 		 * implemented, use of software crypto for group addressed
1440 		 * frames is a acceptable to allow RSN IBSS to be used.
1441 		 */
1442 		return -EOPNOTSUPP;
1443 	}
1444 
1445 	mutex_lock(&priv->mutex);
1446 	ath_dbg(common, CONFIG, "Set HW Key\n");
1447 	ath9k_htc_ps_wakeup(priv);
1448 
1449 	switch (cmd) {
1450 	case SET_KEY:
1451 		ret = ath_key_config(common, vif, sta, key);
1452 		if (ret >= 0) {
1453 			key->hw_key_idx = ret;
1454 			/* push IV and Michael MIC generation to stack */
1455 			key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1456 			if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
1457 				key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1458 			if (priv->ah->sw_mgmt_crypto_tx &&
1459 			    key->cipher == WLAN_CIPHER_SUITE_CCMP)
1460 				key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
1461 			ret = 0;
1462 		}
1463 		break;
1464 	case DISABLE_KEY:
1465 		ath_key_delete(common, key->hw_key_idx);
1466 		break;
1467 	default:
1468 		ret = -EINVAL;
1469 	}
1470 
1471 	ath9k_htc_ps_restore(priv);
1472 	mutex_unlock(&priv->mutex);
1473 
1474 	return ret;
1475 }
1476 
1477 static void ath9k_htc_set_bssid(struct ath9k_htc_priv *priv)
1478 {
1479 	struct ath_common *common = ath9k_hw_common(priv->ah);
1480 
1481 	ath9k_hw_write_associd(priv->ah);
1482 	ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n",
1483 		common->curbssid, common->curaid);
1484 }
1485 
1486 static void ath9k_htc_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1487 {
1488 	struct ath9k_htc_priv *priv = data;
1489 	struct ath_common *common = ath9k_hw_common(priv->ah);
1490 	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1491 
1492 	if ((vif->type == NL80211_IFTYPE_STATION) && vif->cfg.assoc) {
1493 		common->curaid = vif->cfg.aid;
1494 		common->last_rssi = ATH_RSSI_DUMMY_MARKER;
1495 		memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1496 		set_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags);
1497 	}
1498 }
1499 
1500 static void ath9k_htc_choose_set_bssid(struct ath9k_htc_priv *priv)
1501 {
1502 	if (priv->num_sta_assoc_vif == 1) {
1503 		ieee80211_iterate_active_interfaces_atomic(
1504 			priv->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
1505 			ath9k_htc_bss_iter, priv);
1506 		ath9k_htc_set_bssid(priv);
1507 	}
1508 }
1509 
1510 static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
1511 				       struct ieee80211_vif *vif,
1512 				       struct ieee80211_bss_conf *bss_conf,
1513 				       u64 changed)
1514 {
1515 	struct ath9k_htc_priv *priv = hw->priv;
1516 	struct ath_hw *ah = priv->ah;
1517 	struct ath_common *common = ath9k_hw_common(ah);
1518 	int slottime;
1519 
1520 	mutex_lock(&priv->mutex);
1521 	ath9k_htc_ps_wakeup(priv);
1522 
1523 	if (changed & BSS_CHANGED_ASSOC) {
1524 		ath_dbg(common, CONFIG, "BSS Changed ASSOC %d\n",
1525 			vif->cfg.assoc);
1526 
1527 		vif->cfg.assoc ?
1528 			priv->num_sta_assoc_vif++ : priv->num_sta_assoc_vif--;
1529 
1530 		if (!vif->cfg.assoc)
1531 			clear_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags);
1532 
1533 		if (priv->ah->opmode == NL80211_IFTYPE_STATION) {
1534 			ath9k_htc_choose_set_bssid(priv);
1535 			if (vif->cfg.assoc && (priv->num_sta_assoc_vif == 1))
1536 				ath9k_htc_start_ani(priv);
1537 			else if (priv->num_sta_assoc_vif == 0)
1538 				ath9k_htc_stop_ani(priv);
1539 		}
1540 	}
1541 
1542 	if (changed & BSS_CHANGED_IBSS) {
1543 		if (priv->ah->opmode == NL80211_IFTYPE_ADHOC) {
1544 			common->curaid = vif->cfg.aid;
1545 			memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1546 			ath9k_htc_set_bssid(priv);
1547 		}
1548 	}
1549 
1550 	if ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon) {
1551 		ath_dbg(common, CONFIG, "Beacon enabled for BSS: %pM\n",
1552 			bss_conf->bssid);
1553 		ath9k_htc_set_tsfadjust(priv, vif);
1554 		priv->cur_beacon_conf.enable_beacon = 1;
1555 		ath9k_htc_beacon_config(priv, vif);
1556 	}
1557 
1558 	if ((changed & BSS_CHANGED_BEACON_ENABLED) && !bss_conf->enable_beacon) {
1559 		/*
1560 		 * Disable SWBA interrupt only if there are no
1561 		 * concurrent AP/mesh or IBSS interfaces.
1562 		 */
1563 		if ((priv->num_ap_vif + priv->num_mbss_vif <= 1) ||
1564 		     priv->num_ibss_vif) {
1565 			ath_dbg(common, CONFIG,
1566 				"Beacon disabled for BSS: %pM\n",
1567 				bss_conf->bssid);
1568 			priv->cur_beacon_conf.enable_beacon = 0;
1569 			ath9k_htc_beacon_config(priv, vif);
1570 		}
1571 	}
1572 
1573 	if (changed & BSS_CHANGED_BEACON_INT) {
1574 		/*
1575 		 * Reset the HW TSF for the first AP or mesh interface.
1576 		 */
1577 		if (priv->nvifs == 1 &&
1578 		    ((priv->ah->opmode == NL80211_IFTYPE_AP &&
1579 		      vif->type == NL80211_IFTYPE_AP &&
1580 		      priv->num_ap_vif == 1) ||
1581 		    (priv->ah->opmode == NL80211_IFTYPE_MESH_POINT &&
1582 		      vif->type == NL80211_IFTYPE_MESH_POINT &&
1583 		      priv->num_mbss_vif == 1))) {
1584 			set_bit(OP_TSF_RESET, &priv->op_flags);
1585 		}
1586 		ath_dbg(common, CONFIG,
1587 			"Beacon interval changed for BSS: %pM\n",
1588 			bss_conf->bssid);
1589 		ath9k_htc_beacon_config(priv, vif);
1590 	}
1591 
1592 	if (changed & BSS_CHANGED_ERP_SLOT) {
1593 		if (bss_conf->use_short_slot)
1594 			slottime = 9;
1595 		else
1596 			slottime = 20;
1597 		if (vif->type == NL80211_IFTYPE_AP) {
1598 			/*
1599 			 * Defer update, so that connected stations can adjust
1600 			 * their settings at the same time.
1601 			 * See beacon.c for more details
1602 			 */
1603 			priv->beacon.slottime = slottime;
1604 			priv->beacon.updateslot = UPDATE;
1605 		} else {
1606 			ah->slottime = slottime;
1607 			ath9k_hw_init_global_settings(ah);
1608 		}
1609 	}
1610 
1611 	if (changed & BSS_CHANGED_HT)
1612 		ath9k_htc_update_rate(priv, vif, bss_conf);
1613 
1614 	ath9k_htc_ps_restore(priv);
1615 	mutex_unlock(&priv->mutex);
1616 }
1617 
1618 static u64 ath9k_htc_get_tsf(struct ieee80211_hw *hw,
1619 			     struct ieee80211_vif *vif)
1620 {
1621 	struct ath9k_htc_priv *priv = hw->priv;
1622 	u64 tsf;
1623 
1624 	mutex_lock(&priv->mutex);
1625 	ath9k_htc_ps_wakeup(priv);
1626 	tsf = ath9k_hw_gettsf64(priv->ah);
1627 	ath9k_htc_ps_restore(priv);
1628 	mutex_unlock(&priv->mutex);
1629 
1630 	return tsf;
1631 }
1632 
1633 static void ath9k_htc_set_tsf(struct ieee80211_hw *hw,
1634 			      struct ieee80211_vif *vif, u64 tsf)
1635 {
1636 	struct ath9k_htc_priv *priv = hw->priv;
1637 
1638 	mutex_lock(&priv->mutex);
1639 	ath9k_htc_ps_wakeup(priv);
1640 	ath9k_hw_settsf64(priv->ah, tsf);
1641 	ath9k_htc_ps_restore(priv);
1642 	mutex_unlock(&priv->mutex);
1643 }
1644 
1645 static void ath9k_htc_reset_tsf(struct ieee80211_hw *hw,
1646 				struct ieee80211_vif *vif)
1647 {
1648 	struct ath9k_htc_priv *priv = hw->priv;
1649 
1650 	mutex_lock(&priv->mutex);
1651 	ath9k_htc_ps_wakeup(priv);
1652 	ath9k_hw_reset_tsf(priv->ah);
1653 	ath9k_htc_ps_restore(priv);
1654 	mutex_unlock(&priv->mutex);
1655 }
1656 
1657 static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw,
1658 				  struct ieee80211_vif *vif,
1659 				  struct ieee80211_ampdu_params *params)
1660 {
1661 	struct ath9k_htc_priv *priv = hw->priv;
1662 	struct ath9k_htc_sta *ista;
1663 	int ret = 0;
1664 	struct ieee80211_sta *sta = params->sta;
1665 	enum ieee80211_ampdu_mlme_action action = params->action;
1666 	u16 tid = params->tid;
1667 
1668 	mutex_lock(&priv->mutex);
1669 	ath9k_htc_ps_wakeup(priv);
1670 
1671 	switch (action) {
1672 	case IEEE80211_AMPDU_RX_START:
1673 		break;
1674 	case IEEE80211_AMPDU_RX_STOP:
1675 		break;
1676 	case IEEE80211_AMPDU_TX_START:
1677 		ret = ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1678 		if (!ret)
1679 			ret = IEEE80211_AMPDU_TX_START_IMMEDIATE;
1680 		break;
1681 	case IEEE80211_AMPDU_TX_STOP_CONT:
1682 	case IEEE80211_AMPDU_TX_STOP_FLUSH:
1683 	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1684 		ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1685 		ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1686 		break;
1687 	case IEEE80211_AMPDU_TX_OPERATIONAL:
1688 		if (tid >= ATH9K_HTC_MAX_TID) {
1689 			ret = -EINVAL;
1690 			break;
1691 		}
1692 		ista = (struct ath9k_htc_sta *) sta->drv_priv;
1693 		spin_lock_bh(&priv->tx.tx_lock);
1694 		ista->tid_state[tid] = AGGR_OPERATIONAL;
1695 		spin_unlock_bh(&priv->tx.tx_lock);
1696 		break;
1697 	default:
1698 		ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
1699 	}
1700 
1701 	ath9k_htc_ps_restore(priv);
1702 	mutex_unlock(&priv->mutex);
1703 
1704 	return ret;
1705 }
1706 
1707 static void ath9k_htc_sw_scan_start(struct ieee80211_hw *hw,
1708 				    struct ieee80211_vif *vif,
1709 				    const u8 *mac_addr)
1710 {
1711 	struct ath9k_htc_priv *priv = hw->priv;
1712 	struct ath_common *common = ath9k_hw_common(priv->ah);
1713 
1714 	mutex_lock(&priv->mutex);
1715 	spin_lock_bh(&priv->beacon_lock);
1716 	set_bit(ATH_OP_SCANNING, &common->op_flags);
1717 	spin_unlock_bh(&priv->beacon_lock);
1718 	cancel_work_sync(&priv->ps_work);
1719 	ath9k_htc_stop_ani(priv);
1720 	mutex_unlock(&priv->mutex);
1721 }
1722 
1723 static void ath9k_htc_sw_scan_complete(struct ieee80211_hw *hw,
1724 				       struct ieee80211_vif *vif)
1725 {
1726 	struct ath9k_htc_priv *priv = hw->priv;
1727 	struct ath_common *common = ath9k_hw_common(priv->ah);
1728 
1729 	mutex_lock(&priv->mutex);
1730 	spin_lock_bh(&priv->beacon_lock);
1731 	clear_bit(ATH_OP_SCANNING, &common->op_flags);
1732 	spin_unlock_bh(&priv->beacon_lock);
1733 	ath9k_htc_ps_wakeup(priv);
1734 	ath9k_htc_vif_reconfig(priv);
1735 	ath9k_htc_ps_restore(priv);
1736 	mutex_unlock(&priv->mutex);
1737 }
1738 
1739 static int ath9k_htc_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1740 {
1741 	return 0;
1742 }
1743 
1744 static void ath9k_htc_set_coverage_class(struct ieee80211_hw *hw,
1745 					 s16 coverage_class)
1746 {
1747 	struct ath9k_htc_priv *priv = hw->priv;
1748 
1749 	mutex_lock(&priv->mutex);
1750 	ath9k_htc_ps_wakeup(priv);
1751 	priv->ah->coverage_class = coverage_class;
1752 	ath9k_hw_init_global_settings(priv->ah);
1753 	ath9k_htc_ps_restore(priv);
1754 	mutex_unlock(&priv->mutex);
1755 }
1756 
1757 /*
1758  * Currently, this is used only for selecting the minimum rate
1759  * for management frames, rate selection for data frames remain
1760  * unaffected.
1761  */
1762 static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw,
1763 				      struct ieee80211_vif *vif,
1764 				      const struct cfg80211_bitrate_mask *mask)
1765 {
1766 	struct ath9k_htc_priv *priv = hw->priv;
1767 	struct ath_common *common = ath9k_hw_common(priv->ah);
1768 	struct ath9k_htc_target_rate_mask tmask;
1769 	struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1770 	int ret = 0;
1771 	u8 cmd_rsp;
1772 
1773 	memset(&tmask, 0, sizeof(struct ath9k_htc_target_rate_mask));
1774 
1775 	tmask.vif_index = avp->index;
1776 	tmask.band = NL80211_BAND_2GHZ;
1777 	tmask.mask = cpu_to_be32(mask->control[NL80211_BAND_2GHZ].legacy);
1778 
1779 	WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1780 	if (ret) {
1781 		ath_err(common,
1782 			"Unable to set 2G rate mask for "
1783 			"interface at idx: %d\n", avp->index);
1784 		goto out;
1785 	}
1786 
1787 	tmask.band = NL80211_BAND_5GHZ;
1788 	tmask.mask = cpu_to_be32(mask->control[NL80211_BAND_5GHZ].legacy);
1789 
1790 	WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1791 	if (ret) {
1792 		ath_err(common,
1793 			"Unable to set 5G rate mask for "
1794 			"interface at idx: %d\n", avp->index);
1795 		goto out;
1796 	}
1797 
1798 	ath_dbg(common, CONFIG, "Set bitrate masks: 0x%x, 0x%x\n",
1799 		mask->control[NL80211_BAND_2GHZ].legacy,
1800 		mask->control[NL80211_BAND_5GHZ].legacy);
1801 out:
1802 	return ret;
1803 }
1804 
1805 
1806 static int ath9k_htc_get_stats(struct ieee80211_hw *hw,
1807 			       struct ieee80211_low_level_stats *stats)
1808 {
1809 	struct ath9k_htc_priv *priv = hw->priv;
1810 	struct ath_hw *ah = priv->ah;
1811 	struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
1812 
1813 	stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
1814 	stats->dot11RTSFailureCount = mib_stats->rts_bad;
1815 	stats->dot11FCSErrorCount = mib_stats->fcs_bad;
1816 	stats->dot11RTSSuccessCount = mib_stats->rts_good;
1817 
1818 	return 0;
1819 }
1820 
1821 struct base_eep_header *ath9k_htc_get_eeprom_base(struct ath9k_htc_priv *priv)
1822 {
1823 	struct base_eep_header *pBase = NULL;
1824 	/*
1825 	 * This can be done since all the 3 EEPROM families have the
1826 	 * same base header upto a certain point, and we are interested in
1827 	 * the data only upto that point.
1828 	 */
1829 
1830 	if (AR_SREV_9271(priv->ah))
1831 		pBase = (struct base_eep_header *)
1832 			&priv->ah->eeprom.map4k.baseEepHeader;
1833 	else if (priv->ah->hw_version.usbdev == AR9280_USB)
1834 		pBase = (struct base_eep_header *)
1835 			&priv->ah->eeprom.def.baseEepHeader;
1836 	else if (priv->ah->hw_version.usbdev == AR9287_USB)
1837 		pBase = (struct base_eep_header *)
1838 			&priv->ah->eeprom.map9287.baseEepHeader;
1839 	return pBase;
1840 }
1841 
1842 
1843 static int ath9k_htc_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant,
1844 				 u32 *rx_ant)
1845 {
1846 	struct ath9k_htc_priv *priv = hw->priv;
1847 	struct base_eep_header *pBase = ath9k_htc_get_eeprom_base(priv);
1848 	if (pBase) {
1849 		*tx_ant = pBase->txMask;
1850 		*rx_ant = pBase->rxMask;
1851 	} else {
1852 		*tx_ant = 0;
1853 		*rx_ant = 0;
1854 	}
1855 	return 0;
1856 }
1857 
1858 static void ath9k_htc_channel_switch_beacon(struct ieee80211_hw *hw,
1859 					    struct ieee80211_vif *vif,
1860 					    struct cfg80211_chan_def *chandef)
1861 {
1862 	struct ath9k_htc_priv *priv = hw->priv;
1863 
1864 	/* mac80211 does not support CSA in multi-if cases (yet) */
1865 	if (WARN_ON(priv->csa_vif))
1866 		return;
1867 
1868 	priv->csa_vif = vif;
1869 }
1870 
1871 struct ieee80211_ops ath9k_htc_ops = {
1872 	.tx                 = ath9k_htc_tx,
1873 	.wake_tx_queue      = ieee80211_handle_wake_tx_queue,
1874 	.start              = ath9k_htc_start,
1875 	.stop               = ath9k_htc_stop,
1876 	.add_interface      = ath9k_htc_add_interface,
1877 	.remove_interface   = ath9k_htc_remove_interface,
1878 	.config             = ath9k_htc_config,
1879 	.configure_filter   = ath9k_htc_configure_filter,
1880 	.sta_add            = ath9k_htc_sta_add,
1881 	.sta_remove         = ath9k_htc_sta_remove,
1882 	.conf_tx            = ath9k_htc_conf_tx,
1883 	.sta_rc_update      = ath9k_htc_sta_rc_update,
1884 	.bss_info_changed   = ath9k_htc_bss_info_changed,
1885 	.set_key            = ath9k_htc_set_key,
1886 	.get_tsf            = ath9k_htc_get_tsf,
1887 	.set_tsf            = ath9k_htc_set_tsf,
1888 	.reset_tsf          = ath9k_htc_reset_tsf,
1889 	.ampdu_action       = ath9k_htc_ampdu_action,
1890 	.sw_scan_start      = ath9k_htc_sw_scan_start,
1891 	.sw_scan_complete   = ath9k_htc_sw_scan_complete,
1892 	.set_rts_threshold  = ath9k_htc_set_rts_threshold,
1893 	.rfkill_poll        = ath9k_htc_rfkill_poll_state,
1894 	.set_coverage_class = ath9k_htc_set_coverage_class,
1895 	.set_bitrate_mask   = ath9k_htc_set_bitrate_mask,
1896 	.get_stats	    = ath9k_htc_get_stats,
1897 	.get_antenna	    = ath9k_htc_get_antenna,
1898 	.channel_switch_beacon	= ath9k_htc_channel_switch_beacon,
1899 
1900 #ifdef CONFIG_ATH9K_HTC_DEBUGFS
1901 	.get_et_sset_count  = ath9k_htc_get_et_sset_count,
1902 	.get_et_stats       = ath9k_htc_get_et_stats,
1903 	.get_et_strings     = ath9k_htc_get_et_strings,
1904 #endif
1905 };
1906