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