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