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, ATH_DBG_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, ATH_DBG_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, ATH_DBG_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, ATH_DBG_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, ATH_DBG_CONFIG,
 516			"Added a station entry for: %pM (idx: %d)\n",
 517			sta->addr, tsta.sta_index);
 518	} else {
 519		ath_dbg(common, ATH_DBG_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, ATH_DBG_CONFIG,
 560			"Removed a station entry for: %pM (idx: %d)\n",
 561			sta->addr, sta_idx);
 562	} else {
 563		ath_dbg(common, ATH_DBG_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, ATH_DBG_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, ATH_DBG_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, ATH_DBG_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, ATH_DBG_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, ATH_DBG_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, ATH_DBG_ANI,
 797				"shortcal @%lu\n", jiffies);
 798			common->ani.shortcal_timer = timestamp;
 799			common->ani.resetcal_timer = timestamp;
 800		}
 801	} else {
 802		if ((timestamp - common->ani.resetcal_timer) >=
 803		    ATH_RESTART_CALINTERVAL) {
 804			common->ani.caldone = ath9k_hw_reset_calvalid(ah);
 805			if (common->ani.caldone)
 806				common->ani.resetcal_timer = timestamp;
 807		}
 808	}
 809
 810	/* Verify whether we must check ANI */
 811	if ((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						   common->rx_chainmask,
 830						   longcal);
 831
 832		ath9k_htc_ps_restore(priv);
 833	}
 834
 835set_timer:
 836	/*
 837	* Set timer interval based on previous results.
 838	* The interval must be the shortest necessary to satisfy ANI,
 839	* short calibration and long calibration.
 840	*/
 841	cal_interval = ATH_LONG_CALINTERVAL;
 842	if (priv->ah->config.enable_ani)
 843		cal_interval = min(cal_interval, (u32)ATH_ANI_POLLINTERVAL);
 844	if (!common->ani.caldone)
 
 
 
 845		cal_interval = min(cal_interval, (u32)short_cal_interval);
 846
 847	ieee80211_queue_delayed_work(common->hw, &priv->ani_work,
 848				     msecs_to_jiffies(cal_interval));
 849}
 850
 851/**********************/
 852/* mac80211 Callbacks */
 853/**********************/
 854
 855static void ath9k_htc_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 
 
 856{
 857	struct ieee80211_hdr *hdr;
 858	struct ath9k_htc_priv *priv = hw->priv;
 859	struct ath_common *common = ath9k_hw_common(priv->ah);
 860	int padpos, padsize, ret, slot;
 861
 862	hdr = (struct ieee80211_hdr *) skb->data;
 863
 864	/* Add the padding after the header if this is not already done */
 865	padpos = ath9k_cmn_padpos(hdr->frame_control);
 866	padsize = padpos & 3;
 867	if (padsize && skb->len > padpos) {
 868		if (skb_headroom(skb) < padsize) {
 869			ath_dbg(common, ATH_DBG_XMIT, "No room for padding\n");
 870			goto fail_tx;
 871		}
 872		skb_push(skb, padsize);
 873		memmove(skb->data, skb->data + padsize, padpos);
 874	}
 875
 876	slot = ath9k_htc_tx_get_slot(priv);
 877	if (slot < 0) {
 878		ath_dbg(common, ATH_DBG_XMIT, "No free TX slot\n");
 879		goto fail_tx;
 880	}
 881
 882	ret = ath9k_htc_tx_start(priv, skb, slot, false);
 883	if (ret != 0) {
 884		ath_dbg(common, ATH_DBG_XMIT, "Tx failed\n");
 885		goto clear_slot;
 886	}
 887
 888	ath9k_htc_check_stop_queues(priv);
 889
 890	return;
 891
 892clear_slot:
 893	ath9k_htc_tx_clear_slot(priv, slot);
 894fail_tx:
 895	dev_kfree_skb_any(skb);
 896}
 897
 898static int ath9k_htc_start(struct ieee80211_hw *hw)
 899{
 900	struct ath9k_htc_priv *priv = hw->priv;
 901	struct ath_hw *ah = priv->ah;
 902	struct ath_common *common = ath9k_hw_common(ah);
 903	struct ieee80211_channel *curchan = hw->conf.channel;
 904	struct ath9k_channel *init_channel;
 905	int ret = 0;
 906	enum htc_phymode mode;
 907	__be16 htc_mode;
 908	u8 cmd_rsp;
 909
 910	mutex_lock(&priv->mutex);
 911
 912	ath_dbg(common, ATH_DBG_CONFIG,
 913		"Starting driver with initial channel: %d MHz\n",
 914		curchan->center_freq);
 915
 916	/* Ensure that HW is awake before flushing RX */
 917	ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
 918	WMI_CMD(WMI_FLUSH_RECV_CMDID);
 919
 920	/* setup initial channel */
 921	init_channel = ath9k_cmn_get_curchannel(hw, ah);
 922
 923	ath9k_hw_htc_resetinit(ah);
 924	ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
 925	if (ret) {
 926		ath_err(common,
 927			"Unable to reset hardware; reset status %d (freq %u MHz)\n",
 928			ret, curchan->center_freq);
 929		mutex_unlock(&priv->mutex);
 930		return ret;
 931	}
 932
 933	ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
 934			       &priv->curtxpow);
 935
 936	mode = ath9k_htc_get_curmode(priv, init_channel);
 937	htc_mode = cpu_to_be16(mode);
 938	WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
 939	WMI_CMD(WMI_ATH_INIT_CMDID);
 940	WMI_CMD(WMI_START_RECV_CMDID);
 941
 942	ath9k_host_rx_init(priv);
 943
 944	ret = ath9k_htc_update_cap_target(priv, 0);
 945	if (ret)
 946		ath_dbg(common, ATH_DBG_CONFIG,
 947			"Failed to update capability in target\n");
 948
 949	priv->op_flags &= ~OP_INVALID;
 950	htc_start(priv->htc);
 951
 952	spin_lock_bh(&priv->tx.tx_lock);
 953	priv->tx.flags &= ~ATH9K_HTC_OP_TX_QUEUES_STOP;
 954	spin_unlock_bh(&priv->tx.tx_lock);
 955
 956	ieee80211_wake_queues(hw);
 957
 958	mod_timer(&priv->tx.cleanup_timer,
 959		  jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL));
 960
 961	if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE) {
 962		ath9k_hw_btcoex_set_weight(ah, AR_BT_COEX_WGHT,
 963					   AR_STOMP_LOW_WLAN_WGHT);
 964		ath9k_hw_btcoex_enable(ah);
 965		ath_htc_resume_btcoex_work(priv);
 966	}
 967	mutex_unlock(&priv->mutex);
 968
 969	return ret;
 970}
 971
 972static void ath9k_htc_stop(struct ieee80211_hw *hw)
 973{
 974	struct ath9k_htc_priv *priv = hw->priv;
 975	struct ath_hw *ah = priv->ah;
 976	struct ath_common *common = ath9k_hw_common(ah);
 977	int ret __attribute__ ((unused));
 978	u8 cmd_rsp;
 979
 980	mutex_lock(&priv->mutex);
 981
 982	if (priv->op_flags & OP_INVALID) {
 983		ath_dbg(common, ATH_DBG_ANY, "Device not present\n");
 984		mutex_unlock(&priv->mutex);
 985		return;
 986	}
 987
 988	ath9k_htc_ps_wakeup(priv);
 989
 990	WMI_CMD(WMI_DISABLE_INTR_CMDID);
 991	WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
 992	WMI_CMD(WMI_STOP_RECV_CMDID);
 993
 994	tasklet_kill(&priv->rx_tasklet);
 995
 996	del_timer_sync(&priv->tx.cleanup_timer);
 997	ath9k_htc_tx_drain(priv);
 998	ath9k_wmi_event_drain(priv);
 999
1000	mutex_unlock(&priv->mutex);
1001
1002	/* Cancel all the running timers/work .. */
1003	cancel_work_sync(&priv->fatal_work);
1004	cancel_work_sync(&priv->ps_work);
1005
1006#ifdef CONFIG_MAC80211_LEDS
1007	cancel_work_sync(&priv->led_work);
1008#endif
1009	ath9k_htc_stop_ani(priv);
1010
1011	mutex_lock(&priv->mutex);
1012
1013	if (ah->btcoex_hw.enabled) {
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, ATH_DBG_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, ATH_DBG_CONFIG,
1124		"Attach a VIF of type: %d at idx: %d\n", 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, ATH_DBG_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, ATH_DBG_CONFIG,
1206				"not-idle: enabling radio\n");
1207			ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1208			ath9k_htc_radio_enable(hw);
1209		}
1210	}
1211
1212	/*
1213	 * Monitor interface should be added before
1214	 * IEEE80211_CONF_CHANGE_CHANNEL is handled.
1215	 */
1216	if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1217		if ((conf->flags & IEEE80211_CONF_MONITOR) &&
1218		    !priv->ah->is_monitoring)
1219			ath9k_htc_add_monitor_interface(priv);
1220		else if (priv->ah->is_monitoring)
1221			ath9k_htc_remove_monitor_interface(priv);
1222	}
1223
1224	if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1225		struct ieee80211_channel *curchan = hw->conf.channel;
1226		int pos = curchan->hw_value;
1227
1228		ath_dbg(common, ATH_DBG_CONFIG, "Set channel: %d MHz\n",
1229			curchan->center_freq);
1230
1231		ath9k_cmn_update_ichannel(&priv->ah->channels[pos],
1232					  hw->conf.channel,
1233					  hw->conf.channel_type);
1234
1235		if (ath9k_htc_set_channel(priv, hw, &priv->ah->channels[pos]) < 0) {
1236			ath_err(common, "Unable to set channel\n");
1237			mutex_unlock(&priv->mutex);
1238			return -EINVAL;
1239		}
1240
1241	}
1242
1243	if (changed & IEEE80211_CONF_CHANGE_PS) {
1244		if (conf->flags & IEEE80211_CONF_PS) {
1245			ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
1246			priv->ps_enabled = true;
1247		} else {
1248			priv->ps_enabled = false;
1249			cancel_work_sync(&priv->ps_work);
1250			ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1251		}
1252	}
1253
1254	if (changed & IEEE80211_CONF_CHANGE_POWER) {
1255		priv->txpowlimit = 2 * conf->power_level;
1256		ath9k_cmn_update_txpow(priv->ah, priv->curtxpow,
1257				       priv->txpowlimit, &priv->curtxpow);
1258	}
1259
1260	if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1261		mutex_lock(&priv->htc_pm_lock);
1262		if (!priv->ps_idle) {
1263			mutex_unlock(&priv->htc_pm_lock);
1264			goto out;
1265		}
1266		mutex_unlock(&priv->htc_pm_lock);
1267
1268		ath_dbg(common, ATH_DBG_CONFIG,
1269			"idle: disabling radio\n");
1270		ath9k_htc_radio_disable(hw);
1271	}
1272
1273out:
 
1274	mutex_unlock(&priv->mutex);
1275	return 0;
1276}
1277
1278#define SUPPORTED_FILTERS			\
1279	(FIF_PROMISC_IN_BSS |			\
1280	FIF_ALLMULTI |				\
1281	FIF_CONTROL |				\
1282	FIF_PSPOLL |				\
1283	FIF_OTHER_BSS |				\
1284	FIF_BCN_PRBRESP_PROMISC |		\
1285	FIF_PROBE_REQ |				\
 
1286	FIF_FCSFAIL)
1287
1288static void ath9k_htc_configure_filter(struct ieee80211_hw *hw,
1289				       unsigned int changed_flags,
1290				       unsigned int *total_flags,
1291				       u64 multicast)
1292{
1293	struct ath9k_htc_priv *priv = hw->priv;
 
1294	u32 rfilt;
1295
1296	mutex_lock(&priv->mutex);
1297	changed_flags &= SUPPORTED_FILTERS;
1298	*total_flags &= SUPPORTED_FILTERS;
1299
1300	if (priv->op_flags & OP_INVALID) {
1301		ath_dbg(ath9k_hw_common(priv->ah), ATH_DBG_ANY,
1302			"Unable to configure filter on invalid state\n");
 
1303		return;
1304	}
1305	ath9k_htc_ps_wakeup(priv);
1306
1307	priv->rxfilter = *total_flags;
1308	rfilt = ath9k_htc_calcrxfilter(priv);
1309	ath9k_hw_setrxfilter(priv->ah, rfilt);
1310
1311	ath_dbg(ath9k_hw_common(priv->ah), ATH_DBG_CONFIG,
1312		"Set HW RX filter: 0x%x\n", rfilt);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1313
1314	ath9k_htc_ps_restore(priv);
1315	mutex_unlock(&priv->mutex);
1316}
1317
1318static int ath9k_htc_sta_add(struct ieee80211_hw *hw,
1319			     struct ieee80211_vif *vif,
1320			     struct ieee80211_sta *sta)
1321{
1322	struct ath9k_htc_priv *priv = hw->priv;
 
1323	int ret;
1324
1325	mutex_lock(&priv->mutex);
1326	ath9k_htc_ps_wakeup(priv);
1327	ret = ath9k_htc_add_station(priv, vif, sta);
1328	if (!ret)
 
 
1329		ath9k_htc_init_rate(priv, sta);
 
1330	ath9k_htc_ps_restore(priv);
1331	mutex_unlock(&priv->mutex);
1332
1333	return ret;
1334}
1335
1336static int ath9k_htc_sta_remove(struct ieee80211_hw *hw,
1337				struct ieee80211_vif *vif,
1338				struct ieee80211_sta *sta)
1339{
1340	struct ath9k_htc_priv *priv = hw->priv;
1341	struct ath9k_htc_sta *ista;
1342	int ret;
1343
 
 
1344	mutex_lock(&priv->mutex);
1345	ath9k_htc_ps_wakeup(priv);
1346	ista = (struct ath9k_htc_sta *) sta->drv_priv;
1347	htc_sta_drain(priv->htc, ista->index);
1348	ret = ath9k_htc_remove_station(priv, vif, sta);
1349	ath9k_htc_ps_restore(priv);
1350	mutex_unlock(&priv->mutex);
1351
1352	return ret;
1353}
1354
1355static int ath9k_htc_conf_tx(struct ieee80211_hw *hw, 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, ATH_DBG_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, ATH_DBG_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, ATH_DBG_CONFIG,
1450		"BSSID: %pM aid: 0x%x\n",
1451		common->curbssid, common->curaid);
1452}
1453
1454static void ath9k_htc_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1455{
1456	struct ath9k_htc_priv *priv = (struct ath9k_htc_priv *)data;
1457	struct ath_common *common = ath9k_hw_common(priv->ah);
1458	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1459
1460	if ((vif->type == NL80211_IFTYPE_STATION) && bss_conf->assoc) {
1461		common->curaid = bss_conf->aid;
 
1462		memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
 
1463	}
1464}
1465
1466static void ath9k_htc_choose_set_bssid(struct ath9k_htc_priv *priv)
1467{
1468	if (priv->num_sta_assoc_vif == 1) {
1469		ieee80211_iterate_active_interfaces_atomic(priv->hw,
1470							   ath9k_htc_bss_iter, priv);
 
1471		ath9k_htc_set_bssid(priv);
1472	}
1473}
1474
1475static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
1476				       struct ieee80211_vif *vif,
1477				       struct ieee80211_bss_conf *bss_conf,
1478				       u32 changed)
1479{
1480	struct ath9k_htc_priv *priv = hw->priv;
1481	struct ath_hw *ah = priv->ah;
1482	struct ath_common *common = ath9k_hw_common(ah);
 
1483
1484	mutex_lock(&priv->mutex);
1485	ath9k_htc_ps_wakeup(priv);
1486
1487	if (changed & BSS_CHANGED_ASSOC) {
1488		ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed ASSOC %d\n",
1489			bss_conf->assoc);
1490
1491		bss_conf->assoc ?
1492			priv->num_sta_assoc_vif++ : priv->num_sta_assoc_vif--;
1493
 
 
 
1494		if (priv->ah->opmode == NL80211_IFTYPE_STATION) {
1495			if (bss_conf->assoc && (priv->num_sta_assoc_vif == 1))
 
1496				ath9k_htc_start_ani(priv);
1497			else if (priv->num_sta_assoc_vif == 0)
1498				ath9k_htc_stop_ani(priv);
1499		}
1500	}
1501
1502	if (changed & BSS_CHANGED_BSSID) {
1503		if (priv->ah->opmode == NL80211_IFTYPE_ADHOC) {
1504			common->curaid = bss_conf->aid;
1505			memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1506			ath9k_htc_set_bssid(priv);
1507		} else if (priv->ah->opmode == NL80211_IFTYPE_STATION) {
1508			ath9k_htc_choose_set_bssid(priv);
1509		}
1510	}
1511
1512	if ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon) {
1513		ath_dbg(common, ATH_DBG_CONFIG,
1514			"Beacon enabled for BSS: %pM\n", bss_conf->bssid);
1515		ath9k_htc_set_tsfadjust(priv, vif);
1516		priv->op_flags |= OP_ENABLE_BEACON;
1517		ath9k_htc_beacon_config(priv, vif);
1518	}
1519
1520	if ((changed & BSS_CHANGED_BEACON_ENABLED) && !bss_conf->enable_beacon) {
1521		/*
1522		 * Disable SWBA interrupt only if there are no
1523		 * AP/IBSS interfaces.
1524		 */
1525		if ((priv->num_ap_vif <= 1) || priv->num_ibss_vif) {
1526			ath_dbg(common, ATH_DBG_CONFIG,
 
1527				"Beacon disabled for BSS: %pM\n",
1528				bss_conf->bssid);
1529			priv->op_flags &= ~OP_ENABLE_BEACON;
1530			ath9k_htc_beacon_config(priv, vif);
1531		}
1532	}
1533
1534	if (changed & BSS_CHANGED_BEACON_INT) {
1535		/*
1536		 * Reset the HW TSF for the first AP interface.
1537		 */
1538		if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
1539		    (priv->nvifs == 1) &&
1540		    (priv->num_ap_vif == 1) &&
1541		    (vif->type == NL80211_IFTYPE_AP)) {
1542			priv->op_flags |= OP_TSF_RESET;
 
 
 
1543		}
1544		ath_dbg(common, ATH_DBG_CONFIG,
1545			"Beacon interval changed for BSS: %pM\n",
1546			bss_conf->bssid);
1547		ath9k_htc_beacon_config(priv, vif);
1548	}
1549
1550	if (changed & BSS_CHANGED_ERP_SLOT) {
1551		if (bss_conf->use_short_slot)
1552			ah->slottime = 9;
1553		else
1554			ah->slottime = 20;
1555
1556		ath9k_hw_init_global_settings(ah);
 
 
 
 
 
 
 
 
 
 
1557	}
1558
1559	if (changed & BSS_CHANGED_HT)
1560		ath9k_htc_update_rate(priv, vif, bss_conf);
1561
1562	ath9k_htc_ps_restore(priv);
1563	mutex_unlock(&priv->mutex);
1564}
1565
1566static u64 ath9k_htc_get_tsf(struct ieee80211_hw *hw)
 
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, u64 tsf)
 
1581{
1582	struct ath9k_htc_priv *priv = hw->priv;
1583
1584	mutex_lock(&priv->mutex);
1585	ath9k_htc_ps_wakeup(priv);
1586	ath9k_hw_settsf64(priv->ah, tsf);
1587	ath9k_htc_ps_restore(priv);
1588	mutex_unlock(&priv->mutex);
1589}
1590
1591static void ath9k_htc_reset_tsf(struct ieee80211_hw *hw)
 
1592{
1593	struct ath9k_htc_priv *priv = hw->priv;
1594
1595	mutex_lock(&priv->mutex);
1596	ath9k_htc_ps_wakeup(priv);
1597	ath9k_hw_reset_tsf(priv->ah);
1598	ath9k_htc_ps_restore(priv);
1599	mutex_unlock(&priv->mutex);
1600}
1601
1602static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw,
1603				  struct ieee80211_vif *vif,
1604				  enum ieee80211_ampdu_mlme_action action,
1605				  struct ieee80211_sta *sta,
1606				  u16 tid, u16 *ssn, u8 buf_size)
1607{
1608	struct ath9k_htc_priv *priv = hw->priv;
1609	struct ath9k_htc_sta *ista;
1610	int ret = 0;
 
 
 
1611
1612	mutex_lock(&priv->mutex);
1613	ath9k_htc_ps_wakeup(priv);
1614
1615	switch (action) {
1616	case IEEE80211_AMPDU_RX_START:
1617		break;
1618	case IEEE80211_AMPDU_RX_STOP:
1619		break;
1620	case IEEE80211_AMPDU_TX_START:
1621		ret = ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1622		if (!ret)
1623			ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1624		break;
1625	case IEEE80211_AMPDU_TX_STOP:
 
 
1626		ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1627		ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1628		break;
1629	case IEEE80211_AMPDU_TX_OPERATIONAL:
 
 
 
 
1630		ista = (struct ath9k_htc_sta *) sta->drv_priv;
1631		spin_lock_bh(&priv->tx.tx_lock);
1632		ista->tid_state[tid] = AGGR_OPERATIONAL;
1633		spin_unlock_bh(&priv->tx.tx_lock);
1634		break;
1635	default:
1636		ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
1637	}
1638
1639	ath9k_htc_ps_restore(priv);
1640	mutex_unlock(&priv->mutex);
1641
1642	return ret;
1643}
1644
1645static void ath9k_htc_sw_scan_start(struct ieee80211_hw *hw)
 
 
1646{
1647	struct ath9k_htc_priv *priv = hw->priv;
 
1648
1649	mutex_lock(&priv->mutex);
1650	spin_lock_bh(&priv->beacon_lock);
1651	priv->op_flags |= OP_SCANNING;
1652	spin_unlock_bh(&priv->beacon_lock);
1653	cancel_work_sync(&priv->ps_work);
1654	ath9k_htc_stop_ani(priv);
1655	mutex_unlock(&priv->mutex);
1656}
1657
1658static void ath9k_htc_sw_scan_complete(struct ieee80211_hw *hw)
 
1659{
1660	struct ath9k_htc_priv *priv = hw->priv;
 
1661
1662	mutex_lock(&priv->mutex);
1663	spin_lock_bh(&priv->beacon_lock);
1664	priv->op_flags &= ~OP_SCANNING;
1665	spin_unlock_bh(&priv->beacon_lock);
1666	ath9k_htc_ps_wakeup(priv);
1667	ath9k_htc_vif_reconfig(priv);
1668	ath9k_htc_ps_restore(priv);
1669	mutex_unlock(&priv->mutex);
1670}
1671
1672static int ath9k_htc_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1673{
1674	return 0;
1675}
1676
1677static void ath9k_htc_set_coverage_class(struct ieee80211_hw *hw,
1678					 u8 coverage_class)
1679{
1680	struct ath9k_htc_priv *priv = hw->priv;
1681
1682	mutex_lock(&priv->mutex);
1683	ath9k_htc_ps_wakeup(priv);
1684	priv->ah->coverage_class = coverage_class;
1685	ath9k_hw_init_global_settings(priv->ah);
1686	ath9k_htc_ps_restore(priv);
1687	mutex_unlock(&priv->mutex);
1688}
1689
1690/*
1691 * Currently, this is used only for selecting the minimum rate
1692 * for management frames, rate selection for data frames remain
1693 * unaffected.
1694 */
1695static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw,
1696				      struct ieee80211_vif *vif,
1697				      const struct cfg80211_bitrate_mask *mask)
1698{
1699	struct ath9k_htc_priv *priv = hw->priv;
1700	struct ath_common *common = ath9k_hw_common(priv->ah);
1701	struct ath9k_htc_target_rate_mask tmask;
1702	struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1703	int ret = 0;
1704	u8 cmd_rsp;
1705
1706	memset(&tmask, 0, sizeof(struct ath9k_htc_target_rate_mask));
1707
1708	tmask.vif_index = avp->index;
1709	tmask.band = IEEE80211_BAND_2GHZ;
1710	tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_2GHZ].legacy);
1711
1712	WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1713	if (ret) {
1714		ath_err(common,
1715			"Unable to set 2G rate mask for "
1716			"interface at idx: %d\n", avp->index);
1717		goto out;
1718	}
1719
1720	tmask.band = IEEE80211_BAND_5GHZ;
1721	tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_5GHZ].legacy);
1722
1723	WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1724	if (ret) {
1725		ath_err(common,
1726			"Unable to set 5G rate mask for "
1727			"interface at idx: %d\n", avp->index);
1728		goto out;
1729	}
1730
1731	ath_dbg(common, ATH_DBG_CONFIG,
1732		"Set bitrate masks: 0x%x, 0x%x\n",
1733		mask->control[IEEE80211_BAND_2GHZ].legacy,
1734		mask->control[IEEE80211_BAND_5GHZ].legacy);
1735out:
1736	return ret;
1737}
1738
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1739struct ieee80211_ops ath9k_htc_ops = {
1740	.tx                 = ath9k_htc_tx,
 
1741	.start              = ath9k_htc_start,
1742	.stop               = ath9k_htc_stop,
1743	.add_interface      = ath9k_htc_add_interface,
1744	.remove_interface   = ath9k_htc_remove_interface,
1745	.config             = ath9k_htc_config,
1746	.configure_filter   = ath9k_htc_configure_filter,
1747	.sta_add            = ath9k_htc_sta_add,
1748	.sta_remove         = ath9k_htc_sta_remove,
1749	.conf_tx            = ath9k_htc_conf_tx,
 
1750	.bss_info_changed   = ath9k_htc_bss_info_changed,
1751	.set_key            = ath9k_htc_set_key,
1752	.get_tsf            = ath9k_htc_get_tsf,
1753	.set_tsf            = ath9k_htc_set_tsf,
1754	.reset_tsf          = ath9k_htc_reset_tsf,
1755	.ampdu_action       = ath9k_htc_ampdu_action,
1756	.sw_scan_start      = ath9k_htc_sw_scan_start,
1757	.sw_scan_complete   = ath9k_htc_sw_scan_complete,
1758	.set_rts_threshold  = ath9k_htc_set_rts_threshold,
1759	.rfkill_poll        = ath9k_htc_rfkill_poll_state,
1760	.set_coverage_class = ath9k_htc_set_coverage_class,
1761	.set_bitrate_mask   = ath9k_htc_set_bitrate_mask,
 
 
 
 
 
 
 
 
 
1762};