htc_drv_main.c

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