iwl-core.c 77.6 KB
Newer Older
T
Tomas Winkler 已提交
1 2 3 4
/******************************************************************************
 *
 * GPL LICENSE SUMMARY
 *
5
 * Copyright(c) 2008 - 2010 Intel Corporation. All rights reserved.
T
Tomas Winkler 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
 * USA
 *
 * The full GNU General Public License is included in this distribution
 * in the file called LICENSE.GPL.
 *
 * Contact Information:
25
 *  Intel Linux Wireless <ilw@linux.intel.com>
T
Tomas Winkler 已提交
26 27 28 29 30
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *****************************************************************************/

#include <linux/kernel.h>
#include <linux/module.h>
31
#include <linux/etherdevice.h>
32
#include <linux/sched.h>
33
#include <linux/slab.h>
34
#include <net/mac80211.h>
T
Tomas Winkler 已提交
35

A
Assaf Krauss 已提交
36
#include "iwl-eeprom.h"
37
#include "iwl-dev.h" /* FIXME: remove */
W
Winkler, Tomas 已提交
38
#include "iwl-debug.h"
T
Tomas Winkler 已提交
39
#include "iwl-core.h"
40
#include "iwl-io.h"
M
Mohamed Abbas 已提交
41
#include "iwl-power.h"
42
#include "iwl-sta.h"
M
Mohamed Abbas 已提交
43
#include "iwl-helpers.h"
T
Tomas Winkler 已提交
44

45

T
Tomas Winkler 已提交
46 47
MODULE_DESCRIPTION("iwl core");
MODULE_VERSION(IWLWIFI_VERSION);
48
MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
T
Tomas Winkler 已提交
49
MODULE_LICENSE("GPL");
T
Tomas Winkler 已提交
50

51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
/*
 * set bt_coex_active to true, uCode will do kill/defer
 * every time the priority line is asserted (BT is sending signals on the
 * priority line in the PCIx).
 * set bt_coex_active to false, uCode will ignore the BT activity and
 * perform the normal operation
 *
 * User might experience transmit issue on some platform due to WiFi/BT
 * co-exist problem. The possible behaviors are:
 *   Able to scan and finding all the available AP
 *   Not able to associate with any AP
 * On those platforms, WiFi communication can be restored by set
 * "bt_coex_active" module parameter to "false"
 *
 * default: bt_coex_active = true (BT_COEX_ENABLE)
 */
67 68
bool bt_coex_active = true;
EXPORT_SYMBOL_GPL(bt_coex_active);
69
module_param(bt_coex_active, bool, S_IRUGO);
70
MODULE_PARM_DESC(bt_coex_active, "enable wifi/bluetooth co-exist");
71

R
Ron Rindjunsky 已提交
72 73 74 75 76 77 78 79 80 81 82 83 84
#define IWL_DECLARE_RATE_INFO(r, s, ip, in, rp, rn, pp, np)    \
	[IWL_RATE_##r##M_INDEX] = { IWL_RATE_##r##M_PLCP,      \
				    IWL_RATE_SISO_##s##M_PLCP, \
				    IWL_RATE_MIMO2_##s##M_PLCP,\
				    IWL_RATE_MIMO3_##s##M_PLCP,\
				    IWL_RATE_##r##M_IEEE,      \
				    IWL_RATE_##ip##M_INDEX,    \
				    IWL_RATE_##in##M_INDEX,    \
				    IWL_RATE_##rp##M_INDEX,    \
				    IWL_RATE_##rn##M_INDEX,    \
				    IWL_RATE_##pp##M_INDEX,    \
				    IWL_RATE_##np##M_INDEX }

85 86 87
u32 iwl_debug_level;
EXPORT_SYMBOL(iwl_debug_level);

R
Ron Rindjunsky 已提交
88 89 90 91 92 93 94 95
/*
 * Parameter order:
 *   rate, ht rate, prev rate, next rate, prev tgg rate, next tgg rate
 *
 * If there isn't a valid next or previous rate then INV is used which
 * maps to IWL_RATE_INVALID
 *
 */
96
const struct iwl_rate_info iwl_rates[IWL_RATE_COUNT] = {
R
Ron Rindjunsky 已提交
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
	IWL_DECLARE_RATE_INFO(1, INV, INV, 2, INV, 2, INV, 2),    /*  1mbps */
	IWL_DECLARE_RATE_INFO(2, INV, 1, 5, 1, 5, 1, 5),          /*  2mbps */
	IWL_DECLARE_RATE_INFO(5, INV, 2, 6, 2, 11, 2, 11),        /*5.5mbps */
	IWL_DECLARE_RATE_INFO(11, INV, 9, 12, 9, 12, 5, 18),      /* 11mbps */
	IWL_DECLARE_RATE_INFO(6, 6, 5, 9, 5, 11, 5, 11),        /*  6mbps */
	IWL_DECLARE_RATE_INFO(9, 6, 6, 11, 6, 11, 5, 11),       /*  9mbps */
	IWL_DECLARE_RATE_INFO(12, 12, 11, 18, 11, 18, 11, 18),   /* 12mbps */
	IWL_DECLARE_RATE_INFO(18, 18, 12, 24, 12, 24, 11, 24),   /* 18mbps */
	IWL_DECLARE_RATE_INFO(24, 24, 18, 36, 18, 36, 18, 36),   /* 24mbps */
	IWL_DECLARE_RATE_INFO(36, 36, 24, 48, 24, 48, 24, 48),   /* 36mbps */
	IWL_DECLARE_RATE_INFO(48, 48, 36, 54, 36, 54, 36, 54),   /* 48mbps */
	IWL_DECLARE_RATE_INFO(54, 54, 48, INV, 48, INV, 48, INV),/* 54mbps */
	IWL_DECLARE_RATE_INFO(60, 60, 48, INV, 48, INV, 48, INV),/* 60mbps */
	/* FIXME:RS:          ^^    should be INV (legacy) */
};
112
EXPORT_SYMBOL(iwl_rates);
R
Ron Rindjunsky 已提交
113

114 115 116 117 118 119 120 121
int iwl_hwrate_to_plcp_idx(u32 rate_n_flags)
{
	int idx = 0;

	/* HT rate format */
	if (rate_n_flags & RATE_MCS_HT_MSK) {
		idx = (rate_n_flags & 0xff);

122 123 124
		if (idx >= IWL_RATE_MIMO3_6M_PLCP)
			idx = idx - IWL_RATE_MIMO3_6M_PLCP;
		else if (idx >= IWL_RATE_MIMO2_6M_PLCP)
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
			idx = idx - IWL_RATE_MIMO2_6M_PLCP;

		idx += IWL_FIRST_OFDM_RATE;
		/* skip 9M not supported in ht*/
		if (idx >= IWL_RATE_9M_INDEX)
			idx += 1;
		if ((idx >= IWL_FIRST_OFDM_RATE) && (idx <= IWL_LAST_OFDM_RATE))
			return idx;

	/* legacy rate format, search for match in table */
	} else {
		for (idx = 0; idx < ARRAY_SIZE(iwl_rates); idx++)
			if (iwl_rates[idx].plcp == (rate_n_flags & 0xFF))
				return idx;
	}

	return -1;
}
EXPORT_SYMBOL(iwl_hwrate_to_plcp_idx);

145
u8 iwl_toggle_tx_ant(struct iwl_priv *priv, u8 ant, u8 valid)
T
Tomas Winkler 已提交
146 147 148
{
	int i;
	u8 ind = ant;
149

T
Tomas Winkler 已提交
150 151
	for (i = 0; i < RATE_ANT_NUM - 1; i++) {
		ind = (ind + 1) < RATE_ANT_NUM ?  ind + 1 : 0;
152
		if (valid & BIT(ind))
T
Tomas Winkler 已提交
153 154 155 156
			return ind;
	}
	return ant;
}
157
EXPORT_SYMBOL(iwl_toggle_tx_ant);
158 159 160 161 162

const u8 iwl_bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
EXPORT_SYMBOL(iwl_bcast_addr);


163 164 165 166 167 168 169 170 171 172 173
/* This function both allocates and initializes hw and priv. */
struct ieee80211_hw *iwl_alloc_all(struct iwl_cfg *cfg,
		struct ieee80211_ops *hw_ops)
{
	struct iwl_priv *priv;

	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
	struct ieee80211_hw *hw =
		ieee80211_alloc_hw(sizeof(struct iwl_priv), hw_ops);
	if (hw == NULL) {
174
		pr_err("%s: Can not allocate network device\n",
175
		       cfg->name);
176 177 178 179 180 181 182 183 184 185 186
		goto out;
	}

	priv = hw->priv;
	priv->hw = hw;

out:
	return hw;
}
EXPORT_SYMBOL(iwl_alloc_all);

187 188 189
/*
 * QoS  support
*/
190
static void iwl_update_qos(struct iwl_priv *priv)
191 192 193 194 195 196 197 198 199 200 201 202 203
{
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
		return;

	priv->qos_data.def_qos_parm.qos_flags = 0;

	if (priv->qos_data.qos_active)
		priv->qos_data.def_qos_parm.qos_flags |=
			QOS_PARAM_FLG_UPDATE_EDCA_MSK;

	if (priv->current_ht_config.is_ht)
		priv->qos_data.def_qos_parm.qos_flags |= QOS_PARAM_FLG_TGN_MSK;

204 205 206
	IWL_DEBUG_QOS(priv, "send QoS cmd with Qos active=%d FLAGS=0x%X\n",
		      priv->qos_data.qos_active,
		      priv->qos_data.def_qos_parm.qos_flags);
207

208 209 210
	iwl_send_cmd_pdu_async(priv, REPLY_QOS_PARAM,
			       sizeof(struct iwl_qosparam_cmd),
			       &priv->qos_data.def_qos_parm, NULL);
211
}
R
Ron Rindjunsky 已提交
212

J
Johannes Berg 已提交
213 214
#define MAX_BIT_RATE_40_MHZ 150 /* Mbps */
#define MAX_BIT_RATE_20_MHZ 72 /* Mbps */
R
Ron Rindjunsky 已提交
215
static void iwlcore_init_ht_hw_capab(const struct iwl_priv *priv,
J
Johannes Berg 已提交
216
			      struct ieee80211_sta_ht_cap *ht_info,
R
Ron Rindjunsky 已提交
217 218
			      enum ieee80211_band band)
{
R
Ron Rindjunsky 已提交
219 220 221 222
	u16 max_bit_rate = 0;
	u8 rx_chains_num = priv->hw_params.rx_chains_num;
	u8 tx_chains_num = priv->hw_params.tx_chains_num;

R
Ron Rindjunsky 已提交
223
	ht_info->cap = 0;
J
Johannes Berg 已提交
224
	memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
R
Ron Rindjunsky 已提交
225

J
Johannes Berg 已提交
226
	ht_info->ht_supported = true;
R
Ron Rindjunsky 已提交
227

228 229
	if (priv->cfg->ht_greenfield_support)
		ht_info->cap |= IEEE80211_HT_CAP_GRN_FLD;
J
Johannes Berg 已提交
230
	ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
R
Ron Rindjunsky 已提交
231
	max_bit_rate = MAX_BIT_RATE_20_MHZ;
232
	if (priv->hw_params.ht40_channel & BIT(band)) {
J
Johannes Berg 已提交
233 234 235
		ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
		ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
		ht_info->mcs.rx_mask[4] = 0x01;
R
Ron Rindjunsky 已提交
236
		max_bit_rate = MAX_BIT_RATE_40_MHZ;
R
Ron Rindjunsky 已提交
237 238 239
	}

	if (priv->cfg->mod_params->amsdu_size_8K)
J
Johannes Berg 已提交
240
		ht_info->cap |= IEEE80211_HT_CAP_MAX_AMSDU;
R
Ron Rindjunsky 已提交
241 242

	ht_info->ampdu_factor = CFG_HT_RX_AMPDU_FACTOR_DEF;
243 244
	if (priv->cfg->ampdu_factor)
		ht_info->ampdu_factor = priv->cfg->ampdu_factor;
R
Ron Rindjunsky 已提交
245
	ht_info->ampdu_density = CFG_HT_MPDU_DENSITY_DEF;
246 247
	if (priv->cfg->ampdu_density)
		ht_info->ampdu_density = priv->cfg->ampdu_density;
R
Ron Rindjunsky 已提交
248

J
Johannes Berg 已提交
249
	ht_info->mcs.rx_mask[0] = 0xFF;
R
Ron Rindjunsky 已提交
250
	if (rx_chains_num >= 2)
J
Johannes Berg 已提交
251
		ht_info->mcs.rx_mask[1] = 0xFF;
R
Ron Rindjunsky 已提交
252
	if (rx_chains_num >= 3)
J
Johannes Berg 已提交
253
		ht_info->mcs.rx_mask[2] = 0xFF;
R
Ron Rindjunsky 已提交
254 255 256

	/* Highest supported Rx data rate */
	max_bit_rate *= rx_chains_num;
J
Johannes Berg 已提交
257 258
	WARN_ON(max_bit_rate & ~IEEE80211_HT_MCS_RX_HIGHEST_MASK);
	ht_info->mcs.rx_highest = cpu_to_le16(max_bit_rate);
R
Ron Rindjunsky 已提交
259 260

	/* Tx MCS capabilities */
J
Johannes Berg 已提交
261
	ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
R
Ron Rindjunsky 已提交
262
	if (tx_chains_num != rx_chains_num) {
J
Johannes Berg 已提交
263 264 265
		ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
		ht_info->mcs.tx_params |= ((tx_chains_num - 1) <<
				IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
R
Ron Rindjunsky 已提交
266
	}
R
Ron Rindjunsky 已提交
267 268 269 270 271
}

/**
 * iwlcore_init_geos - Initialize mac80211's geo/channel info based from eeprom
 */
272
int iwlcore_init_geos(struct iwl_priv *priv)
R
Ron Rindjunsky 已提交
273 274 275 276 277 278 279 280 281 282
{
	struct iwl_channel_info *ch;
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *channels;
	struct ieee80211_channel *geo_ch;
	struct ieee80211_rate *rates;
	int i = 0;

	if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
	    priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
283
		IWL_DEBUG_INFO(priv, "Geography modes already initialized.\n");
R
Ron Rindjunsky 已提交
284 285 286 287 288 289 290 291 292
		set_bit(STATUS_GEO_CONFIGURED, &priv->status);
		return 0;
	}

	channels = kzalloc(sizeof(struct ieee80211_channel) *
			   priv->channel_count, GFP_KERNEL);
	if (!channels)
		return -ENOMEM;

293
	rates = kzalloc((sizeof(struct ieee80211_rate) * IWL_RATE_COUNT_LEGACY),
R
Ron Rindjunsky 已提交
294 295 296 297 298 299 300 301 302 303 304
			GFP_KERNEL);
	if (!rates) {
		kfree(channels);
		return -ENOMEM;
	}

	/* 5.2GHz channels start after the 2.4GHz channels */
	sband = &priv->bands[IEEE80211_BAND_5GHZ];
	sband->channels = &channels[ARRAY_SIZE(iwl_eeprom_band_1)];
	/* just OFDM */
	sband->bitrates = &rates[IWL_FIRST_OFDM_RATE];
305
	sband->n_bitrates = IWL_RATE_COUNT_LEGACY - IWL_FIRST_OFDM_RATE;
R
Ron Rindjunsky 已提交
306

307
	if (priv->cfg->sku & IWL_SKU_N)
J
Johannes Berg 已提交
308
		iwlcore_init_ht_hw_capab(priv, &sband->ht_cap,
309
					 IEEE80211_BAND_5GHZ);
R
Ron Rindjunsky 已提交
310 311 312 313 314

	sband = &priv->bands[IEEE80211_BAND_2GHZ];
	sband->channels = channels;
	/* OFDM & CCK */
	sband->bitrates = rates;
315
	sband->n_bitrates = IWL_RATE_COUNT_LEGACY;
R
Ron Rindjunsky 已提交
316

317
	if (priv->cfg->sku & IWL_SKU_N)
J
Johannes Berg 已提交
318
		iwlcore_init_ht_hw_capab(priv, &sband->ht_cap,
319
					 IEEE80211_BAND_2GHZ);
R
Ron Rindjunsky 已提交
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353

	priv->ieee_channels = channels;
	priv->ieee_rates = rates;

	for (i = 0;  i < priv->channel_count; i++) {
		ch = &priv->channel_info[i];

		/* FIXME: might be removed if scan is OK */
		if (!is_channel_valid(ch))
			continue;

		if (is_channel_a_band(ch))
			sband =  &priv->bands[IEEE80211_BAND_5GHZ];
		else
			sband =  &priv->bands[IEEE80211_BAND_2GHZ];

		geo_ch = &sband->channels[sband->n_channels++];

		geo_ch->center_freq =
				ieee80211_channel_to_frequency(ch->channel);
		geo_ch->max_power = ch->max_power_avg;
		geo_ch->max_antenna_gain = 0xff;
		geo_ch->hw_value = ch->channel;

		if (is_channel_valid(ch)) {
			if (!(ch->flags & EEPROM_CHANNEL_IBSS))
				geo_ch->flags |= IEEE80211_CHAN_NO_IBSS;

			if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
				geo_ch->flags |= IEEE80211_CHAN_PASSIVE_SCAN;

			if (ch->flags & EEPROM_CHANNEL_RADAR)
				geo_ch->flags |= IEEE80211_CHAN_RADAR;

354
			geo_ch->flags |= ch->ht40_extension_channel;
355

356 357
			if (ch->max_power_avg > priv->tx_power_device_lmt)
				priv->tx_power_device_lmt = ch->max_power_avg;
R
Ron Rindjunsky 已提交
358 359 360 361
		} else {
			geo_ch->flags |= IEEE80211_CHAN_DISABLED;
		}

362
		IWL_DEBUG_INFO(priv, "Channel %d Freq=%d[%sGHz] %s flag=0x%X\n",
R
Ron Rindjunsky 已提交
363 364 365 366 367 368 369 370 371
				ch->channel, geo_ch->center_freq,
				is_channel_a_band(ch) ?  "5.2" : "2.4",
				geo_ch->flags & IEEE80211_CHAN_DISABLED ?
				"restricted" : "valid",
				 geo_ch->flags);
	}

	if ((priv->bands[IEEE80211_BAND_5GHZ].n_channels == 0) &&
	     priv->cfg->sku & IWL_SKU_A) {
T
Tomas Winkler 已提交
372 373
		IWL_INFO(priv, "Incorrectly detected BG card as ABG. "
			"Please send your PCI ID 0x%04X:0x%04X to maintainer.\n",
374 375
			   priv->pci_dev->device,
			   priv->pci_dev->subsystem_device);
R
Ron Rindjunsky 已提交
376 377 378
		priv->cfg->sku &= ~IWL_SKU_A;
	}

T
Tomas Winkler 已提交
379
	IWL_INFO(priv, "Tunable channels: %d 802.11bg, %d 802.11a channels\n",
380 381
		   priv->bands[IEEE80211_BAND_2GHZ].n_channels,
		   priv->bands[IEEE80211_BAND_5GHZ].n_channels);
R
Ron Rindjunsky 已提交
382 383 384 385 386

	set_bit(STATUS_GEO_CONFIGURED, &priv->status);

	return 0;
}
387
EXPORT_SYMBOL(iwlcore_init_geos);
R
Ron Rindjunsky 已提交
388 389 390 391

/*
 * iwlcore_free_geos - undo allocations in iwlcore_init_geos
 */
392
void iwlcore_free_geos(struct iwl_priv *priv)
R
Ron Rindjunsky 已提交
393 394 395 396 397
{
	kfree(priv->ieee_channels);
	kfree(priv->ieee_rates);
	clear_bit(STATUS_GEO_CONFIGURED, &priv->status);
}
398
EXPORT_SYMBOL(iwlcore_free_geos);
R
Ron Rindjunsky 已提交
399

400
/*
J
Johannes Berg 已提交
401
 *  iwlcore_tx_cmd_protection: Set rts/cts. 3945 and 4965 only share this
402 403
 *  function.
 */
J
Johannes Berg 已提交
404 405 406
void iwlcore_tx_cmd_protection(struct iwl_priv *priv,
			       struct ieee80211_tx_info *info,
			       __le16 fc, __le32 *tx_flags)
407 408 409 410
{
	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) {
		*tx_flags |= TX_CMD_FLG_RTS_MSK;
		*tx_flags &= ~TX_CMD_FLG_CTS_MSK;
J
Johannes Berg 已提交
411 412 413 414 415 416 417 418 419 420 421 422 423 424
		*tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;

		if (!ieee80211_is_mgmt(fc))
			return;

		switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
		case cpu_to_le16(IEEE80211_STYPE_AUTH):
		case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
		case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ):
		case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ):
			*tx_flags &= ~TX_CMD_FLG_RTS_MSK;
			*tx_flags |= TX_CMD_FLG_CTS_MSK;
			break;
		}
425 426 427
	} else if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
		*tx_flags &= ~TX_CMD_FLG_RTS_MSK;
		*tx_flags |= TX_CMD_FLG_CTS_MSK;
J
Johannes Berg 已提交
428
		*tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;
429 430
	}
}
J
Johannes Berg 已提交
431 432
EXPORT_SYMBOL(iwlcore_tx_cmd_protection);

433

434
static bool is_single_rx_stream(struct iwl_priv *priv)
R
Ron Rindjunsky 已提交
435
{
J
Johannes Berg 已提交
436
	return priv->current_ht_config.smps == IEEE80211_SMPS_STATIC ||
437
	       priv->current_ht_config.single_chain_sufficient;
R
Ron Rindjunsky 已提交
438
}
439

440 441 442 443 444 445 446 447 448 449
static u8 iwl_is_channel_extension(struct iwl_priv *priv,
				   enum ieee80211_band band,
				   u16 channel, u8 extension_chan_offset)
{
	const struct iwl_channel_info *ch_info;

	ch_info = iwl_get_channel_info(priv, band, channel);
	if (!is_channel_valid(ch_info))
		return 0;

J
Johannes Berg 已提交
450
	if (extension_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_ABOVE)
451
		return !(ch_info->ht40_extension_channel &
452
					IEEE80211_CHAN_NO_HT40PLUS);
J
Johannes Berg 已提交
453
	else if (extension_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_BELOW)
454
		return !(ch_info->ht40_extension_channel &
455
					IEEE80211_CHAN_NO_HT40MINUS);
456 457 458 459

	return 0;
}

460
u8 iwl_is_ht40_tx_allowed(struct iwl_priv *priv,
J
Johannes Berg 已提交
461
			 struct ieee80211_sta_ht_cap *sta_ht_inf)
462
{
J
Johannes Berg 已提交
463
	struct iwl_ht_config *ht_conf = &priv->current_ht_config;
464

J
Johannes Berg 已提交
465
	if (!ht_conf->is_ht || !ht_conf->is_40mhz)
466 467
		return 0;

468 469 470
	/* We do not check for IEEE80211_HT_CAP_SUP_WIDTH_20_40
	 * the bit will not set if it is pure 40MHz case
	 */
471
	if (sta_ht_inf) {
472
		if (!sta_ht_inf->ht_supported)
473 474
			return 0;
	}
475
#ifdef CONFIG_IWLWIFI_DEBUGFS
476 477 478
	if (priv->disable_ht40)
		return 0;
#endif
479 480
	return iwl_is_channel_extension(priv, priv->band,
			le16_to_cpu(priv->staging_rxon.channel),
J
Johannes Berg 已提交
481
			ht_conf->extension_chan_offset);
482
}
483
EXPORT_SYMBOL(iwl_is_ht40_tx_allowed);
484

485 486 487 488 489 490 491 492 493 494 495 496 497 498
static u16 iwl_adjust_beacon_interval(u16 beacon_val, u16 max_beacon_val)
{
	u16 new_val = 0;
	u16 beacon_factor = 0;

	beacon_factor = (beacon_val + max_beacon_val) / max_beacon_val;
	new_val = beacon_val / beacon_factor;

	if (!new_val)
		new_val = max_beacon_val;

	return new_val;
}

499
int iwl_send_rxon_timing(struct iwl_priv *priv, struct ieee80211_vif *vif)
500 501 502 503 504 505 506 507
{
	u64 tsf;
	s32 interval_tm, rem;
	struct ieee80211_conf *conf = NULL;
	u16 beacon_int;

	conf = ieee80211_get_hw_conf(priv->hw);

508 509 510 511
	lockdep_assert_held(&priv->mutex);

	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));

512 513 514
	priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
	priv->rxon_timing.listen_interval = cpu_to_le16(conf->listen_interval);

515
	beacon_int = vif->bss_conf.beacon_int;
516

517
	if (vif->type == NL80211_IFTYPE_ADHOC) {
518 519 520
		/* TODO: we need to get atim_window from upper stack
		 * for now we set to 0 */
		priv->rxon_timing.atim_window = 0;
521 522
	} else {
		priv->rxon_timing.atim_window = 0;
523 524 525
	}

	beacon_int = iwl_adjust_beacon_interval(beacon_int,
W
Wey-Yi Guy 已提交
526
				priv->hw_params.max_beacon_itrvl * TIME_UNIT);
527 528 529
	priv->rxon_timing.beacon_interval = cpu_to_le16(beacon_int);

	tsf = priv->timestamp; /* tsf is modifed by do_div: copy it */
W
Wey-Yi Guy 已提交
530
	interval_tm = beacon_int * TIME_UNIT;
531 532 533 534 535 536 537 538
	rem = do_div(tsf, interval_tm);
	priv->rxon_timing.beacon_init_val = cpu_to_le32(interval_tm - rem);

	IWL_DEBUG_ASSOC(priv,
			"beacon interval %d beacon timer %d beacon tim %d\n",
			le16_to_cpu(priv->rxon_timing.beacon_interval),
			le32_to_cpu(priv->rxon_timing.beacon_init_val),
			le16_to_cpu(priv->rxon_timing.atim_window));
539 540 541

	return iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
				sizeof(priv->rxon_timing), &priv->rxon_timing);
542
}
543
EXPORT_SYMBOL(iwl_send_rxon_timing);
544

545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
void iwl_set_rxon_hwcrypto(struct iwl_priv *priv, int hw_decrypt)
{
	struct iwl_rxon_cmd *rxon = &priv->staging_rxon;

	if (hw_decrypt)
		rxon->filter_flags &= ~RXON_FILTER_DIS_DECRYPT_MSK;
	else
		rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK;

}
EXPORT_SYMBOL(iwl_set_rxon_hwcrypto);

/**
 * iwl_check_rxon_cmd - validate RXON structure is valid
 *
 * NOTE:  This is really only useful during development and can eventually
 * be #ifdef'd out once the driver is stable and folks aren't actively
 * making changes
 */
int iwl_check_rxon_cmd(struct iwl_priv *priv)
{
	int error = 0;
	int counter = 1;
	struct iwl_rxon_cmd *rxon = &priv->staging_rxon;

	if (rxon->flags & RXON_FLG_BAND_24G_MSK) {
		error |= le32_to_cpu(rxon->flags &
				(RXON_FLG_TGJ_NARROW_BAND_MSK |
				 RXON_FLG_RADAR_DETECT_MSK));
		if (error)
			IWL_WARN(priv, "check 24G fields %d | %d\n",
				    counter++, error);
	} else {
		error |= (rxon->flags & RXON_FLG_SHORT_SLOT_MSK) ?
				0 : le32_to_cpu(RXON_FLG_SHORT_SLOT_MSK);
		if (error)
			IWL_WARN(priv, "check 52 fields %d | %d\n",
				    counter++, error);
		error |= le32_to_cpu(rxon->flags & RXON_FLG_CCK_MSK);
		if (error)
			IWL_WARN(priv, "check 52 CCK %d | %d\n",
				    counter++, error);
	}
	error |= (rxon->node_addr[0] | rxon->bssid_addr[0]) & 0x1;
	if (error)
		IWL_WARN(priv, "check mac addr %d | %d\n", counter++, error);

	/* make sure basic rates 6Mbps and 1Mbps are supported */
	error |= (((rxon->ofdm_basic_rates & IWL_RATE_6M_MASK) == 0) &&
		  ((rxon->cck_basic_rates & IWL_RATE_1M_MASK) == 0));
	if (error)
		IWL_WARN(priv, "check basic rate %d | %d\n", counter++, error);

	error |= (le16_to_cpu(rxon->assoc_id) > 2007);
	if (error)
		IWL_WARN(priv, "check assoc id %d | %d\n", counter++, error);

	error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK))
			== (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK));
	if (error)
		IWL_WARN(priv, "check CCK and short slot %d | %d\n",
			    counter++, error);

	error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK))
			== (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK));
	if (error)
		IWL_WARN(priv, "check CCK & auto detect %d | %d\n",
			    counter++, error);

	error |= ((rxon->flags & (RXON_FLG_AUTO_DETECT_MSK |
			RXON_FLG_TGG_PROTECT_MSK)) == RXON_FLG_TGG_PROTECT_MSK);
	if (error)
		IWL_WARN(priv, "check TGG and auto detect %d | %d\n",
			    counter++, error);

	if (error)
		IWL_WARN(priv, "Tuning to channel %d\n",
			    le16_to_cpu(rxon->channel));

	if (error) {
		IWL_ERR(priv, "Not a valid iwl_rxon_assoc_cmd field values\n");
		return -1;
	}
	return 0;
}
EXPORT_SYMBOL(iwl_check_rxon_cmd);

/**
 * iwl_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
 * @priv: staging_rxon is compared to active_rxon
 *
 * If the RXON structure is changing enough to require a new tune,
 * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
 * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
 */
int iwl_full_rxon_required(struct iwl_priv *priv)
{

	/* These items are only settable from the full RXON command */
	if (!(iwl_is_associated(priv)) ||
	    compare_ether_addr(priv->staging_rxon.bssid_addr,
			       priv->active_rxon.bssid_addr) ||
	    compare_ether_addr(priv->staging_rxon.node_addr,
			       priv->active_rxon.node_addr) ||
	    compare_ether_addr(priv->staging_rxon.wlap_bssid_addr,
			       priv->active_rxon.wlap_bssid_addr) ||
	    (priv->staging_rxon.dev_type != priv->active_rxon.dev_type) ||
	    (priv->staging_rxon.channel != priv->active_rxon.channel) ||
	    (priv->staging_rxon.air_propagation !=
	     priv->active_rxon.air_propagation) ||
	    (priv->staging_rxon.ofdm_ht_single_stream_basic_rates !=
	     priv->active_rxon.ofdm_ht_single_stream_basic_rates) ||
	    (priv->staging_rxon.ofdm_ht_dual_stream_basic_rates !=
	     priv->active_rxon.ofdm_ht_dual_stream_basic_rates) ||
659 660
	    (priv->staging_rxon.ofdm_ht_triple_stream_basic_rates !=
	     priv->active_rxon.ofdm_ht_triple_stream_basic_rates) ||
661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
	    (priv->staging_rxon.assoc_id != priv->active_rxon.assoc_id))
		return 1;

	/* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
	 * be updated with the RXON_ASSOC command -- however only some
	 * flag transitions are allowed using RXON_ASSOC */

	/* Check if we are not switching bands */
	if ((priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) !=
	    (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK))
		return 1;

	/* Check if we are switching association toggle */
	if ((priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) !=
		(priv->active_rxon.filter_flags & RXON_FILTER_ASSOC_MSK))
		return 1;

	return 0;
}
EXPORT_SYMBOL(iwl_full_rxon_required);

u8 iwl_rate_get_lowest_plcp(struct iwl_priv *priv)
{
684 685 686 687
	/*
	 * Assign the lowest rate -- should really get this from
	 * the beacon skb from mac80211.
	 */
688 689 690 691 692 693 694
	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
		return IWL_RATE_1M_PLCP;
	else
		return IWL_RATE_6M_PLCP;
}
EXPORT_SYMBOL(iwl_rate_get_lowest_plcp);

J
Johannes Berg 已提交
695
void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_config *ht_conf)
696
{
G
Gregory Greenman 已提交
697
	struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
698

J
Johannes Berg 已提交
699
	if (!ht_conf->is_ht) {
700
		rxon->flags &= ~(RXON_FLG_CHANNEL_MODE_MSK |
701
			RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK |
702
			RXON_FLG_HT40_PROT_MSK |
703
			RXON_FLG_HT_PROT_MSK);
704
		return;
705
	}
706

707 708 709
	/* FIXME: if the definition of ht_protection changed, the "translation"
	 * will be needed for rxon->flags
	 */
J
Johannes Berg 已提交
710
	rxon->flags |= cpu_to_le32(ht_conf->ht_protection << RXON_FLG_HT_OPERATING_MODE_POS);
711 712

	/* Set up channel bandwidth:
713
	 * 20 MHz only, 20/40 mixed or pure 40 if ht40 ok */
714 715 716
	/* clear the HT channel mode before set the mode */
	rxon->flags &= ~(RXON_FLG_CHANNEL_MODE_MSK |
			 RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK);
717 718
	if (iwl_is_ht40_tx_allowed(priv, NULL)) {
		/* pure ht40 */
J
Johannes Berg 已提交
719
		if (ht_conf->ht_protection == IEEE80211_HT_OP_MODE_PROTECTION_20MHZ) {
720
			rxon->flags |= RXON_FLG_CHANNEL_MODE_PURE_40;
721
			/* Note: control channel is opposite of extension channel */
J
Johannes Berg 已提交
722
			switch (ht_conf->extension_chan_offset) {
723 724 725 726 727 728 729 730
			case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
				rxon->flags &= ~RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
				break;
			case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
				rxon->flags |= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
				break;
			}
		} else {
731
			/* Note: control channel is opposite of extension channel */
J
Johannes Berg 已提交
732
			switch (ht_conf->extension_chan_offset) {
733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749
			case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
				rxon->flags &= ~(RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK);
				rxon->flags |= RXON_FLG_CHANNEL_MODE_MIXED;
				break;
			case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
				rxon->flags |= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
				rxon->flags |= RXON_FLG_CHANNEL_MODE_MIXED;
				break;
			case IEEE80211_HT_PARAM_CHA_SEC_NONE:
			default:
				/* channel location only valid if in Mixed mode */
				IWL_ERR(priv, "invalid extension channel offset\n");
				break;
			}
		}
	} else {
		rxon->flags |= RXON_FLG_CHANNEL_MODE_LEGACY;
750 751
	}

752 753
	if (priv->cfg->ops->hcmd->set_rxon_chain)
		priv->cfg->ops->hcmd->set_rxon_chain(priv);
754

755
	IWL_DEBUG_ASSOC(priv, "rxon flags 0x%X operation mode :0x%X "
J
Johannes Berg 已提交
756
			"extension channel offset 0x%x\n",
J
Johannes Berg 已提交
757 758
			le32_to_cpu(rxon->flags), ht_conf->ht_protection,
			ht_conf->extension_chan_offset);
759 760 761
}
EXPORT_SYMBOL(iwl_set_rxon_ht);

762 763 764 765 766
#define IWL_NUM_RX_CHAINS_MULTIPLE	3
#define IWL_NUM_RX_CHAINS_SINGLE	2
#define IWL_NUM_IDLE_CHAINS_DUAL	2
#define IWL_NUM_IDLE_CHAINS_SINGLE	1

767 768 769 770 771 772 773
/*
 * Determine how many receiver/antenna chains to use.
 *
 * More provides better reception via diversity.  Fewer saves power
 * at the expense of throughput, but only when not in powersave to
 * start with.
 *
R
Ron Rindjunsky 已提交
774 775 776
 * MIMO (dual stream) requires at least 2, but works better with 3.
 * This does not determine *which* chains to use, just how many.
 */
777
static int iwl_get_active_rx_chain_count(struct iwl_priv *priv)
R
Ron Rindjunsky 已提交
778 779
{
	/* # of Rx chains to use when expecting MIMO. */
780
	if (is_single_rx_stream(priv))
781
		return IWL_NUM_RX_CHAINS_SINGLE;
R
Ron Rindjunsky 已提交
782
	else
783
		return IWL_NUM_RX_CHAINS_MULTIPLE;
784
}
R
Ron Rindjunsky 已提交
785

786
/*
787 788
 * When we are in power saving mode, unless device support spatial
 * multiplexing power save, use the active count for rx chain count.
789
 */
790 791
static int iwl_get_idle_rx_chain_count(struct iwl_priv *priv, int active_cnt)
{
J
Johannes Berg 已提交
792 793 794 795 796 797 798
	/* # Rx chains when idling, depending on SMPS mode */
	switch (priv->current_ht_config.smps) {
	case IEEE80211_SMPS_STATIC:
	case IEEE80211_SMPS_DYNAMIC:
		return IWL_NUM_IDLE_CHAINS_SINGLE;
	case IEEE80211_SMPS_OFF:
		return active_cnt;
799
	default:
J
Johannes Berg 已提交
800 801 802
		WARN(1, "invalid SMPS mode %d",
		     priv->current_ht_config.smps);
		return active_cnt;
803
	}
R
Ron Rindjunsky 已提交
804 805
}

806 807 808 809 810 811 812
/* up to 4 chains */
static u8 iwl_count_chain_bitmap(u32 chain_bitmap)
{
	u8 res;
	res = (chain_bitmap & BIT(0)) >> 0;
	res += (chain_bitmap & BIT(1)) >> 1;
	res += (chain_bitmap & BIT(2)) >> 2;
J
Johannes Berg 已提交
813
	res += (chain_bitmap & BIT(3)) >> 3;
814 815 816
	return res;
}

R
Ron Rindjunsky 已提交
817 818 819 820 821 822 823 824
/**
 * iwl_set_rxon_chain - Set up Rx chain usage in "staging" RXON image
 *
 * Selects how many and which Rx receivers/antennas/chains to use.
 * This should not be used for scan command ... it puts data in wrong place.
 */
void iwl_set_rxon_chain(struct iwl_priv *priv)
{
825 826
	bool is_single = is_single_rx_stream(priv);
	bool is_cam = !test_bit(STATUS_POWER_PMI, &priv->status);
827 828
	u8 idle_rx_cnt, active_rx_cnt, valid_rx_cnt;
	u32 active_chains;
829
	u16 rx_chain;
R
Ron Rindjunsky 已提交
830 831 832 833 834

	/* Tell uCode which antennas are actually connected.
	 * Before first association, we assume all antennas are connected.
	 * Just after first association, iwl_chain_noise_calibration()
	 *    checks which antennas actually *are* connected. */
835 836 837 838 839 840
	 if (priv->chain_noise_data.active_chains)
		active_chains = priv->chain_noise_data.active_chains;
	else
		active_chains = priv->hw_params.valid_rx_ant;

	rx_chain = active_chains << RXON_RX_CHAIN_VALID_POS;
R
Ron Rindjunsky 已提交
841 842

	/* How many receivers should we use? */
843 844 845 846
	active_rx_cnt = iwl_get_active_rx_chain_count(priv);
	idle_rx_cnt = iwl_get_idle_rx_chain_count(priv, active_rx_cnt);


847 848 849 850 851 852 853 854 855
	/* correct rx chain count according hw settings
	 * and chain noise calibration
	 */
	valid_rx_cnt = iwl_count_chain_bitmap(active_chains);
	if (valid_rx_cnt < active_rx_cnt)
		active_rx_cnt = valid_rx_cnt;

	if (valid_rx_cnt < idle_rx_cnt)
		idle_rx_cnt = valid_rx_cnt;
856 857 858 859 860 861

	rx_chain |= active_rx_cnt << RXON_RX_CHAIN_MIMO_CNT_POS;
	rx_chain |= idle_rx_cnt  << RXON_RX_CHAIN_CNT_POS;

	priv->staging_rxon.rx_chain = cpu_to_le16(rx_chain);

862
	if (!is_single && (active_rx_cnt >= IWL_NUM_RX_CHAINS_SINGLE) && is_cam)
R
Ron Rindjunsky 已提交
863 864 865 866
		priv->staging_rxon.rx_chain |= RXON_RX_CHAIN_MIMO_FORCE_MSK;
	else
		priv->staging_rxon.rx_chain &= ~RXON_RX_CHAIN_MIMO_FORCE_MSK;

867
	IWL_DEBUG_ASSOC(priv, "rx_chain=0x%X active=%d idle=%d\n",
868 869 870 871 872
			priv->staging_rxon.rx_chain,
			active_rx_cnt, idle_rx_cnt);

	WARN_ON(active_rx_cnt == 0 || idle_rx_cnt == 0 ||
		active_rx_cnt < idle_rx_cnt);
R
Ron Rindjunsky 已提交
873 874
}
EXPORT_SYMBOL(iwl_set_rxon_chain);
875

A
Abhijeet Kolekar 已提交
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
/* Return valid channel */
u8 iwl_get_single_channel_number(struct iwl_priv *priv,
				  enum ieee80211_band band)
{
	const struct iwl_channel_info *ch_info;
	int i;
	u8 channel = 0;

	/* only scan single channel, good enough to reset the RF */
	/* pick the first valid not in-use channel */
	if (band == IEEE80211_BAND_5GHZ) {
		for (i = 14; i < priv->channel_count; i++) {
			if (priv->channel_info[i].channel !=
			    le16_to_cpu(priv->staging_rxon.channel)) {
				channel = priv->channel_info[i].channel;
				ch_info = iwl_get_channel_info(priv,
					band, channel);
				if (is_channel_valid(ch_info))
					break;
			}
		}
	} else {
		for (i = 0; i < 14; i++) {
			if (priv->channel_info[i].channel !=
			    le16_to_cpu(priv->staging_rxon.channel)) {
					channel =
						priv->channel_info[i].channel;
					ch_info = iwl_get_channel_info(priv,
						band, channel);
					if (is_channel_valid(ch_info))
						break;
			}
		}
	}

	return channel;
}
EXPORT_SYMBOL(iwl_get_single_channel_number);

915
/**
916 917
 * iwl_set_rxon_channel - Set the band and channel values in staging RXON
 * @ch: requested channel as a pointer to struct ieee80211_channel
918

919
 * In addition to setting the staging RXON, priv->band is also set.
920 921
 *
 * NOTE:  Does not commit to the hardware; it sets appropriate bit fields
922
 * in the staging RXON flag structure based on the ch->band
923
 */
924
int iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch)
925
{
926
	enum ieee80211_band band = ch->band;
927
	u16 channel = ch->hw_value;
928

929 930 931 932 933 934 935 936 937 938 939 940
	if ((le16_to_cpu(priv->staging_rxon.channel) == channel) &&
	    (priv->band == band))
		return 0;

	priv->staging_rxon.channel = cpu_to_le16(channel);
	if (band == IEEE80211_BAND_5GHZ)
		priv->staging_rxon.flags &= ~RXON_FLG_BAND_24G_MSK;
	else
		priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;

	priv->band = band;

941
	IWL_DEBUG_INFO(priv, "Staging channel set to %d [%d]\n", channel, band);
942 943 944

	return 0;
}
R
Ron Rindjunsky 已提交
945
EXPORT_SYMBOL(iwl_set_rxon_channel);
946

947 948 949
void iwl_set_flags_for_band(struct iwl_priv *priv,
			    enum ieee80211_band band,
			    struct ieee80211_vif *vif)
950 951 952 953 954 955 956 957
{
	if (band == IEEE80211_BAND_5GHZ) {
		priv->staging_rxon.flags &=
		    ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
		      | RXON_FLG_CCK_MSK);
		priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
	} else {
		/* Copied from iwl_post_associate() */
958
		if (vif && vif->bss_conf.use_short_slot)
959 960 961 962 963 964 965 966 967
			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
		else
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;

		priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;
		priv->staging_rxon.flags |= RXON_FLG_AUTO_DETECT_MSK;
		priv->staging_rxon.flags &= ~RXON_FLG_CCK_MSK;
	}
}
968
EXPORT_SYMBOL(iwl_set_flags_for_band);
969 970 971 972

/*
 * initialize rxon structure with default values from eeprom
 */
973 974
void iwl_connection_init_rx_config(struct iwl_priv *priv,
				   struct ieee80211_vif *vif)
975 976
{
	const struct iwl_channel_info *ch_info;
977 978 979 980
	enum nl80211_iftype type = NL80211_IFTYPE_STATION;

	if (vif)
		type = vif->type;
981 982 983

	memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));

984
	switch (type) {
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
	case NL80211_IFTYPE_AP:
		priv->staging_rxon.dev_type = RXON_DEV_TYPE_AP;
		break;

	case NL80211_IFTYPE_STATION:
		priv->staging_rxon.dev_type = RXON_DEV_TYPE_ESS;
		priv->staging_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
		break;

	case NL80211_IFTYPE_ADHOC:
		priv->staging_rxon.dev_type = RXON_DEV_TYPE_IBSS;
		priv->staging_rxon.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
		priv->staging_rxon.filter_flags = RXON_FILTER_BCON_AWARE_MSK |
						  RXON_FILTER_ACCEPT_GRP_MSK;
		break;

	default:
1002
		IWL_ERR(priv, "Unsupported interface type %d\n", type);
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
		break;
	}

#if 0
	/* TODO:  Figure out when short_preamble would be set and cache from
	 * that */
	if (!hw_to_local(priv->hw)->short_preamble)
		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
	else
		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
#endif

	ch_info = iwl_get_channel_info(priv, priv->band,
				       le16_to_cpu(priv->active_rxon.channel));

	if (!ch_info)
		ch_info = &priv->channel_info[0];

	priv->staging_rxon.channel = cpu_to_le16(ch_info->channel);
	priv->band = ch_info->band;

1024
	iwl_set_flags_for_band(priv, priv->band, vif);
1025 1026 1027 1028 1029 1030

	priv->staging_rxon.ofdm_basic_rates =
	    (IWL_OFDM_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
	priv->staging_rxon.cck_basic_rates =
	    (IWL_CCK_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;

1031 1032 1033
	/* clear both MIX and PURE40 mode flag */
	priv->staging_rxon.flags &= ~(RXON_FLG_CHANNEL_MODE_MIXED |
					RXON_FLG_CHANNEL_MODE_PURE_40);
1034 1035 1036 1037

	if (vif)
		memcpy(priv->staging_rxon.node_addr, vif->addr, ETH_ALEN);

1038 1039
	priv->staging_rxon.ofdm_ht_single_stream_basic_rates = 0xff;
	priv->staging_rxon.ofdm_ht_dual_stream_basic_rates = 0xff;
1040
	priv->staging_rxon.ofdm_ht_triple_stream_basic_rates = 0xff;
1041 1042 1043
}
EXPORT_SYMBOL(iwl_connection_init_rx_config);

1044
void iwl_set_rate(struct iwl_priv *priv)
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
{
	const struct ieee80211_supported_band *hw = NULL;
	struct ieee80211_rate *rate;
	int i;

	hw = iwl_get_hw_mode(priv, priv->band);
	if (!hw) {
		IWL_ERR(priv, "Failed to set rate: unable to get hw mode\n");
		return;
	}

	priv->active_rate = 0;

	for (i = 0; i < hw->n_bitrates; i++) {
		rate = &(hw->bitrates[i]);
1060
		if (rate->hw_value < IWL_RATE_COUNT_LEGACY)
1061 1062 1063
			priv->active_rate |= (1 << rate->hw_value);
	}

1064
	IWL_DEBUG_RATE(priv, "Set active_rate = %0x\n", priv->active_rate);
1065

1066 1067 1068 1069 1070
	priv->staging_rxon.cck_basic_rates =
	    (IWL_CCK_BASIC_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;

	priv->staging_rxon.ofdm_basic_rates =
	   (IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
1071
}
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
EXPORT_SYMBOL(iwl_set_rate);

void iwl_chswitch_done(struct iwl_priv *priv, bool is_success)
{
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
		return;

	if (priv->switch_rxon.switch_in_progress) {
		ieee80211_chswitch_done(priv->vif, is_success);
		mutex_lock(&priv->mutex);
		priv->switch_rxon.switch_in_progress = false;
		mutex_unlock(&priv->mutex);
	}
}
EXPORT_SYMBOL(iwl_chswitch_done);
1087 1088 1089

void iwl_rx_csa(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
{
Z
Zhu Yi 已提交
1090
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
1091 1092
	struct iwl_rxon_cmd *rxon = (void *)&priv->active_rxon;
	struct iwl_csa_notification *csa = &(pkt->u.csa_notif);
1093

W
Wey-Yi Guy 已提交
1094 1095 1096 1097 1098 1099 1100
	if (priv->switch_rxon.switch_in_progress) {
		if (!le32_to_cpu(csa->status) &&
		    (csa->channel == priv->switch_rxon.channel)) {
			rxon->channel = csa->channel;
			priv->staging_rxon.channel = csa->channel;
			IWL_DEBUG_11H(priv, "CSA notif: channel %d\n",
			      le16_to_cpu(csa->channel));
1101 1102
			iwl_chswitch_done(priv, true);
		} else {
W
Wey-Yi Guy 已提交
1103 1104
			IWL_ERR(priv, "CSA notif (fail) : channel %d\n",
			      le16_to_cpu(csa->channel));
1105 1106
			iwl_chswitch_done(priv, false);
		}
W
Wey-Yi Guy 已提交
1107
	}
1108 1109 1110 1111
}
EXPORT_SYMBOL(iwl_rx_csa);

#ifdef CONFIG_IWLWIFI_DEBUG
1112
void iwl_print_rx_config_cmd(struct iwl_priv *priv)
1113 1114 1115
{
	struct iwl_rxon_cmd *rxon = &priv->staging_rxon;

1116
	IWL_DEBUG_RADIO(priv, "RX CONFIG:\n");
1117
	iwl_print_hex_dump(priv, IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
1118 1119 1120
	IWL_DEBUG_RADIO(priv, "u16 channel: 0x%x\n", le16_to_cpu(rxon->channel));
	IWL_DEBUG_RADIO(priv, "u32 flags: 0x%08X\n", le32_to_cpu(rxon->flags));
	IWL_DEBUG_RADIO(priv, "u32 filter_flags: 0x%08x\n",
1121
			le32_to_cpu(rxon->filter_flags));
1122 1123
	IWL_DEBUG_RADIO(priv, "u8 dev_type: 0x%x\n", rxon->dev_type);
	IWL_DEBUG_RADIO(priv, "u8 ofdm_basic_rates: 0x%02x\n",
1124
			rxon->ofdm_basic_rates);
1125 1126 1127 1128
	IWL_DEBUG_RADIO(priv, "u8 cck_basic_rates: 0x%02x\n", rxon->cck_basic_rates);
	IWL_DEBUG_RADIO(priv, "u8[6] node_addr: %pM\n", rxon->node_addr);
	IWL_DEBUG_RADIO(priv, "u8[6] bssid_addr: %pM\n", rxon->bssid_addr);
	IWL_DEBUG_RADIO(priv, "u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
1129
}
1130
EXPORT_SYMBOL(iwl_print_rx_config_cmd);
1131
#endif
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
/**
 * iwl_irq_handle_error - called for HW or SW error interrupt from card
 */
void iwl_irq_handle_error(struct iwl_priv *priv)
{
	/* Set the FW error flag -- cleared on iwl_down */
	set_bit(STATUS_FW_ERROR, &priv->status);

	/* Cancel currently queued command. */
	clear_bit(STATUS_HCMD_ACTIVE, &priv->status);

1143 1144 1145
	IWL_ERR(priv, "Loaded firmware version: %s\n",
		priv->hw->wiphy->fw_version);

1146
	priv->cfg->ops->lib->dump_nic_error_log(priv);
1147 1148
	if (priv->cfg->ops->lib->dump_csr)
		priv->cfg->ops->lib->dump_csr(priv);
1149 1150
	if (priv->cfg->ops->lib->dump_fh)
		priv->cfg->ops->lib->dump_fh(priv, NULL, false);
W
Wey-Yi Guy 已提交
1151
	priv->cfg->ops->lib->dump_nic_event_log(priv, false, NULL, false);
1152
#ifdef CONFIG_IWLWIFI_DEBUG
1153
	if (iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS)
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
		iwl_print_rx_config_cmd(priv);
#endif

	wake_up_interruptible(&priv->wait_command_queue);

	/* Keep the restart process from trying to send host
	 * commands by clearing the INIT status bit */
	clear_bit(STATUS_READY, &priv->status);

	if (!test_bit(STATUS_EXIT_PENDING, &priv->status)) {
1164
		IWL_DEBUG(priv, IWL_DL_FW_ERRORS,
1165 1166 1167 1168 1169 1170 1171 1172
			  "Restarting adapter due to uCode error.\n");

		if (priv->cfg->mod_params->restart_fw)
			queue_work(priv->workqueue, &priv->restart);
	}
}
EXPORT_SYMBOL(iwl_irq_handle_error);

1173
static int iwl_apm_stop_master(struct iwl_priv *priv)
1174
{
1175
	int ret = 0;
1176

1177
	/* stop device's busmaster DMA activity */
1178 1179
	iwl_set_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_STOP_MASTER);

1180
	ret = iwl_poll_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_MASTER_DISABLED,
1181
			CSR_RESET_REG_FLAG_MASTER_DISABLED, 100);
1182 1183
	if (ret)
		IWL_WARN(priv, "Master Disable Timed Out, 100 usec\n");
1184 1185 1186

	IWL_DEBUG_INFO(priv, "stop master\n");

1187
	return ret;
1188 1189 1190 1191
}

void iwl_apm_stop(struct iwl_priv *priv)
{
1192 1193
	IWL_DEBUG_INFO(priv, "Stop card, put in low power state\n");

1194
	/* Stop device's DMA activity */
1195 1196
	iwl_apm_stop_master(priv);

1197
	/* Reset the entire device */
1198 1199 1200
	iwl_set_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_SW_RESET);

	udelay(10);
1201 1202 1203 1204 1205

	/*
	 * Clear "initialization complete" bit to move adapter from
	 * D0A* (powered-up Active) --> D0U* (Uninitialized) state.
	 */
1206 1207 1208 1209
	iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
}
EXPORT_SYMBOL(iwl_apm_stop);

1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250

/*
 * Start up NIC's basic functionality after it has been reset
 * (e.g. after platform boot, or shutdown via iwl_apm_stop())
 * NOTE:  This does not load uCode nor start the embedded processor
 */
int iwl_apm_init(struct iwl_priv *priv)
{
	int ret = 0;
	u16 lctl;

	IWL_DEBUG_INFO(priv, "Init card's basic functions\n");

	/*
	 * Use "set_bit" below rather than "write", to preserve any hardware
	 * bits already set by default after reset.
	 */

	/* Disable L0S exit timer (platform NMI Work/Around) */
	iwl_set_bit(priv, CSR_GIO_CHICKEN_BITS,
			  CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);

	/*
	 * Disable L0s without affecting L1;
	 *  don't wait for ICH L0s (ICH bug W/A)
	 */
	iwl_set_bit(priv, CSR_GIO_CHICKEN_BITS,
			  CSR_GIO_CHICKEN_BITS_REG_BIT_L1A_NO_L0S_RX);

	/* Set FH wait threshold to maximum (HW error during stress W/A) */
	iwl_set_bit(priv, CSR_DBG_HPET_MEM_REG, CSR_DBG_HPET_MEM_REG_VAL);

	/*
	 * Enable HAP INTA (interrupt from management bus) to
	 * wake device's PCI Express link L1a -> L0s
	 * NOTE:  This is no-op for 3945 (non-existant bit)
	 */
	iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
				    CSR_HW_IF_CONFIG_REG_BIT_HAP_WAKE_L1A);

	/*
1251 1252 1253 1254 1255 1256
	 * HW bug W/A for instability in PCIe bus L0->L0S->L1 transition.
	 * Check if BIOS (or OS) enabled L1-ASPM on this device.
	 * If so (likely), disable L0S, so device moves directly L0->L1;
	 *    costs negligible amount of power savings.
	 * If not (unlikely), enable L0S, so there is at least some
	 *    power savings, even without L1.
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324
	 */
	if (priv->cfg->set_l0s) {
		lctl = iwl_pcie_link_ctl(priv);
		if ((lctl & PCI_CFG_LINK_CTRL_VAL_L1_EN) ==
					PCI_CFG_LINK_CTRL_VAL_L1_EN) {
			/* L1-ASPM enabled; disable(!) L0S  */
			iwl_set_bit(priv, CSR_GIO_REG,
					CSR_GIO_REG_VAL_L0S_ENABLED);
			IWL_DEBUG_POWER(priv, "L1 Enabled; Disabling L0S\n");
		} else {
			/* L1-ASPM disabled; enable(!) L0S */
			iwl_clear_bit(priv, CSR_GIO_REG,
					CSR_GIO_REG_VAL_L0S_ENABLED);
			IWL_DEBUG_POWER(priv, "L1 Disabled; Enabling L0S\n");
		}
	}

	/* Configure analog phase-lock-loop before activating to D0A */
	if (priv->cfg->pll_cfg_val)
		iwl_set_bit(priv, CSR_ANA_PLL_CFG, priv->cfg->pll_cfg_val);

	/*
	 * Set "initialization complete" bit to move adapter from
	 * D0U* --> D0A* (powered-up active) state.
	 */
	iwl_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);

	/*
	 * Wait for clock stabilization; once stabilized, access to
	 * device-internal resources is supported, e.g. iwl_write_prph()
	 * and accesses to uCode SRAM.
	 */
	ret = iwl_poll_bit(priv, CSR_GP_CNTRL,
			CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY,
			CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
	if (ret < 0) {
		IWL_DEBUG_INFO(priv, "Failed to init the card\n");
		goto out;
	}

	/*
	 * Enable DMA and BSM (if used) clocks, wait for them to stabilize.
	 * BSM (Boostrap State Machine) is only in 3945 and 4965;
	 * later devices (i.e. 5000 and later) have non-volatile SRAM,
	 * and don't need BSM to restore data after power-saving sleep.
	 *
	 * Write to "CLK_EN_REG"; "1" bits enable clocks, while "0" bits
	 * do not disable clocks.  This preserves any hardware bits already
	 * set by default in "CLK_CTRL_REG" after reset.
	 */
	if (priv->cfg->use_bsm)
		iwl_write_prph(priv, APMG_CLK_EN_REG,
			APMG_CLK_VAL_DMA_CLK_RQT | APMG_CLK_VAL_BSM_CLK_RQT);
	else
		iwl_write_prph(priv, APMG_CLK_EN_REG,
			APMG_CLK_VAL_DMA_CLK_RQT);
	udelay(20);

	/* Disable L1-Active */
	iwl_set_bits_prph(priv, APMG_PCIDEV_STT_REG,
			  APMG_PCIDEV_STT_VAL_L1_ACT_DIS);

out:
	return ret;
}
EXPORT_SYMBOL(iwl_apm_init);


1325 1326 1327
int iwl_set_tx_power(struct iwl_priv *priv, s8 tx_power, bool force)
{
	int ret = 0;
1328 1329
	s8 prev_tx_power = priv->tx_power_user_lmt;

1330 1331 1332
	if (tx_power < IWLAGN_TX_POWER_TARGET_POWER_MIN) {
		IWL_WARN(priv,
			 "Requested user TXPOWER %d below lower limit %d.\n",
1333
			 tx_power,
1334
			 IWLAGN_TX_POWER_TARGET_POWER_MIN);
1335 1336 1337
		return -EINVAL;
	}

1338
	if (tx_power > priv->tx_power_device_lmt) {
1339 1340
		IWL_WARN(priv,
			"Requested user TXPOWER %d above upper limit %d.\n",
1341
			 tx_power, priv->tx_power_device_lmt);
1342 1343 1344 1345 1346 1347
		return -EINVAL;
	}

	if (priv->tx_power_user_lmt != tx_power)
		force = true;

1348
	/* if nic is not up don't send command */
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360
	if (iwl_is_ready_rf(priv)) {
		priv->tx_power_user_lmt = tx_power;
		if (force && priv->cfg->ops->lib->send_tx_power)
			ret = priv->cfg->ops->lib->send_tx_power(priv);
		else if (!priv->cfg->ops->lib->send_tx_power)
			ret = -EOPNOTSUPP;
		/*
		 * if fail to set tx_power, restore the orig. tx power
		 */
		if (ret)
			priv->tx_power_user_lmt = prev_tx_power;
	}
1361

1362 1363 1364 1365 1366 1367 1368
	/*
	 * Even this is an async host command, the command
	 * will always report success from uCode
	 * So once driver can placing the command into the queue
	 * successfully, driver can use priv->tx_power_user_lmt
	 * to reflect the current tx power
	 */
1369 1370 1371 1372
	return ret;
}
EXPORT_SYMBOL(iwl_set_tx_power);

M
Mohamed Abbas 已提交
1373
irqreturn_t iwl_isr_legacy(int irq, void *data)
A
Abhijeet Kolekar 已提交
1374 1375 1376 1377
{
	struct iwl_priv *priv = data;
	u32 inta, inta_mask;
	u32 inta_fh;
1378
	unsigned long flags;
A
Abhijeet Kolekar 已提交
1379 1380 1381
	if (!priv)
		return IRQ_NONE;

1382
	spin_lock_irqsave(&priv->lock, flags);
A
Abhijeet Kolekar 已提交
1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419

	/* Disable (but don't clear!) interrupts here to avoid
	 *    back-to-back ISRs and sporadic interrupts from our NIC.
	 * If we have something to service, the tasklet will re-enable ints.
	 * If we *don't* have something, we'll re-enable before leaving here. */
	inta_mask = iwl_read32(priv, CSR_INT_MASK);  /* just for debug */
	iwl_write32(priv, CSR_INT_MASK, 0x00000000);

	/* Discover which interrupts are active/pending */
	inta = iwl_read32(priv, CSR_INT);
	inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);

	/* Ignore interrupt if there's nothing in NIC to service.
	 * This may be due to IRQ shared with another device,
	 * or due to sporadic interrupts thrown from our NIC. */
	if (!inta && !inta_fh) {
		IWL_DEBUG_ISR(priv, "Ignore interrupt, inta == 0, inta_fh == 0\n");
		goto none;
	}

	if ((inta == 0xFFFFFFFF) || ((inta & 0xFFFFFFF0) == 0xa5a5a5a0)) {
		/* Hardware disappeared. It might have already raised
		 * an interrupt */
		IWL_WARN(priv, "HARDWARE GONE?? INTA == 0x%08x\n", inta);
		goto unplugged;
	}

	IWL_DEBUG_ISR(priv, "ISR inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
		      inta, inta_mask, inta_fh);

	inta &= ~CSR_INT_BIT_SCD;

	/* iwl_irq_tasklet() will service interrupts and re-enable them */
	if (likely(inta || inta_fh))
		tasklet_schedule(&priv->irq_tasklet);

 unplugged:
1420
	spin_unlock_irqrestore(&priv->lock, flags);
A
Abhijeet Kolekar 已提交
1421 1422 1423 1424 1425 1426 1427
	return IRQ_HANDLED;

 none:
	/* re-enable interrupts here since we don't have anything to service. */
	/* only Re-enable if diabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
		iwl_enable_interrupts(priv);
1428
	spin_unlock_irqrestore(&priv->lock, flags);
A
Abhijeet Kolekar 已提交
1429 1430
	return IRQ_NONE;
}
M
Mohamed Abbas 已提交
1431
EXPORT_SYMBOL(iwl_isr_legacy);
A
Abhijeet Kolekar 已提交
1432

1433
void iwl_send_bt_config(struct iwl_priv *priv)
1434 1435
{
	struct iwl_bt_cmd bt_cmd = {
1436 1437
		.lead_time = BT_LEAD_TIME_DEF,
		.max_kill = BT_MAX_KILL_DEF,
1438 1439 1440 1441
		.kill_ack_mask = 0,
		.kill_cts_mask = 0,
	};

1442 1443 1444 1445 1446 1447 1448 1449
	if (!bt_coex_active)
		bt_cmd.flags = BT_COEX_DISABLE;
	else
		bt_cmd.flags = BT_COEX_ENABLE;

	IWL_DEBUG_INFO(priv, "BT coex %s\n",
		(bt_cmd.flags == BT_COEX_DISABLE) ? "disable" : "active");

1450 1451 1452
	if (iwl_send_cmd_pdu(priv, REPLY_BT_CONFIG,
			     sizeof(struct iwl_bt_cmd), &bt_cmd))
		IWL_ERR(priv, "failed to send BT Coex Config\n");
1453 1454 1455
}
EXPORT_SYMBOL(iwl_send_bt_config);

1456
int iwl_send_statistics_request(struct iwl_priv *priv, u8 flags, bool clear)
1457
{
1458 1459 1460
	struct iwl_statistics_cmd statistics_cmd = {
		.configuration_flags =
			clear ? IWL_STATS_CONF_CLEAR_STATS : 0,
1461
	};
1462 1463 1464 1465 1466 1467 1468 1469 1470

	if (flags & CMD_ASYNC)
		return iwl_send_cmd_pdu_async(priv, REPLY_STATISTICS_CMD,
					       sizeof(struct iwl_statistics_cmd),
					       &statistics_cmd, NULL);
	else
		return iwl_send_cmd_pdu(priv, REPLY_STATISTICS_CMD,
					sizeof(struct iwl_statistics_cmd),
					&statistics_cmd);
1471 1472
}
EXPORT_SYMBOL(iwl_send_statistics_request);
1473

A
Abhijeet Kolekar 已提交
1474 1475 1476 1477
void iwl_rx_pm_sleep_notif(struct iwl_priv *priv,
			   struct iwl_rx_mem_buffer *rxb)
{
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1478
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
A
Abhijeet Kolekar 已提交
1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
	struct iwl_sleep_notification *sleep = &(pkt->u.sleep_notif);
	IWL_DEBUG_RX(priv, "sleep mode: %d, src: %d\n",
		     sleep->pm_sleep_mode, sleep->pm_wakeup_src);
#endif
}
EXPORT_SYMBOL(iwl_rx_pm_sleep_notif);

void iwl_rx_pm_debug_statistics_notif(struct iwl_priv *priv,
				      struct iwl_rx_mem_buffer *rxb)
{
Z
Zhu Yi 已提交
1489
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
1490
	u32 len = le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
A
Abhijeet Kolekar 已提交
1491
	IWL_DEBUG_RADIO(priv, "Dumping %d bytes of unhandled "
1492 1493 1494
			"notification for %s:\n", len,
			get_cmd_string(pkt->hdr.cmd));
	iwl_print_hex_dump(priv, IWL_DL_RADIO, pkt->u.raw, len);
A
Abhijeet Kolekar 已提交
1495 1496
}
EXPORT_SYMBOL(iwl_rx_pm_debug_statistics_notif);
1497 1498 1499 1500

void iwl_rx_reply_error(struct iwl_priv *priv,
			struct iwl_rx_mem_buffer *rxb)
{
Z
Zhu Yi 已提交
1501
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512

	IWL_ERR(priv, "Error Reply type 0x%08X cmd %s (0x%02X) "
		"seq 0x%04X ser 0x%08X\n",
		le32_to_cpu(pkt->u.err_resp.error_type),
		get_cmd_string(pkt->u.err_resp.cmd_id),
		pkt->u.err_resp.cmd_id,
		le16_to_cpu(pkt->u.err_resp.bad_cmd_seq_num),
		le32_to_cpu(pkt->u.err_resp.error_info));
}
EXPORT_SYMBOL(iwl_rx_reply_error);

1513 1514 1515 1516 1517
void iwl_clear_isr_stats(struct iwl_priv *priv)
{
	memset(&priv->isr_stats, 0, sizeof(priv->isr_stats));
}

A
Abhijeet Kolekar 已提交
1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554
int iwl_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
			   const struct ieee80211_tx_queue_params *params)
{
	struct iwl_priv *priv = hw->priv;
	unsigned long flags;
	int q;

	IWL_DEBUG_MAC80211(priv, "enter\n");

	if (!iwl_is_ready_rf(priv)) {
		IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
		return -EIO;
	}

	if (queue >= AC_NUM) {
		IWL_DEBUG_MAC80211(priv, "leave - queue >= AC_NUM %d\n", queue);
		return 0;
	}

	q = AC_NUM - 1 - queue;

	spin_lock_irqsave(&priv->lock, flags);

	priv->qos_data.def_qos_parm.ac[q].cw_min = cpu_to_le16(params->cw_min);
	priv->qos_data.def_qos_parm.ac[q].cw_max = cpu_to_le16(params->cw_max);
	priv->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
	priv->qos_data.def_qos_parm.ac[q].edca_txop =
			cpu_to_le16((params->txop * 32));

	priv->qos_data.def_qos_parm.ac[q].reserved1 = 0;

	spin_unlock_irqrestore(&priv->lock, flags);

	IWL_DEBUG_MAC80211(priv, "leave\n");
	return 0;
}
EXPORT_SYMBOL(iwl_mac_conf_tx);
1555

1556 1557 1558 1559 1560 1561 1562 1563
int iwl_mac_tx_last_beacon(struct ieee80211_hw *hw)
{
	struct iwl_priv *priv = hw->priv;

	return priv->ibss_manager == IWL_IBSS_MANAGER;
}
EXPORT_SYMBOL_GPL(iwl_mac_tx_last_beacon);

1564
static void iwl_ht_conf(struct iwl_priv *priv,
J
Johannes Berg 已提交
1565
			struct ieee80211_vif *vif)
1566
{
J
Johannes Berg 已提交
1567
	struct iwl_ht_config *ht_conf = &priv->current_ht_config;
1568
	struct ieee80211_sta *sta;
J
Johannes Berg 已提交
1569
	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1570

1571
	IWL_DEBUG_MAC80211(priv, "enter:\n");
1572

J
Johannes Berg 已提交
1573
	if (!ht_conf->is_ht)
1574 1575
		return;

J
Johannes Berg 已提交
1576
	ht_conf->ht_protection =
1577
		bss_conf->ht_operation_mode & IEEE80211_HT_OP_MODE_PROTECTION;
J
Johannes Berg 已提交
1578
	ht_conf->non_GF_STA_present =
1579
		!!(bss_conf->ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
1580

1581 1582
	ht_conf->single_chain_sufficient = false;

J
Johannes Berg 已提交
1583
	switch (vif->type) {
1584 1585
	case NL80211_IFTYPE_STATION:
		rcu_read_lock();
J
Johannes Berg 已提交
1586
		sta = ieee80211_find_sta(vif, bss_conf->bssid);
1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
		if (sta) {
			struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
			int maxstreams;

			maxstreams = (ht_cap->mcs.tx_params &
				      IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK)
					>> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
			maxstreams += 1;

			if ((ht_cap->mcs.rx_mask[1] == 0) &&
			    (ht_cap->mcs.rx_mask[2] == 0))
				ht_conf->single_chain_sufficient = true;
			if (maxstreams <= 1)
				ht_conf->single_chain_sufficient = true;
		} else {
			/*
			 * If at all, this can only happen through a race
			 * when the AP disconnects us while we're still
			 * setting up the connection, in that case mac80211
			 * will soon tell us about that.
			 */
			ht_conf->single_chain_sufficient = true;
		}
		rcu_read_unlock();
		break;
	case NL80211_IFTYPE_ADHOC:
		ht_conf->single_chain_sufficient = true;
		break;
	default:
		break;
	}
1618 1619 1620 1621

	IWL_DEBUG_MAC80211(priv, "leave\n");
}

1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
static inline void iwl_set_no_assoc(struct iwl_priv *priv)
{
	iwl_led_disassociate(priv);
	/*
	 * inform the ucode that there is no longer an
	 * association and that no more packets should be
	 * sent
	 */
	priv->staging_rxon.filter_flags &=
		~RXON_FILTER_ASSOC_MSK;
	priv->staging_rxon.assoc_id = 0;
	iwlcore_commit_rxon(priv);
}

1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
static int iwl_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
{
	struct iwl_priv *priv = hw->priv;
	unsigned long flags;
	__le64 timestamp;

	IWL_DEBUG_MAC80211(priv, "enter\n");

	if (!iwl_is_ready_rf(priv)) {
		IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
		return -EIO;
	}

	spin_lock_irqsave(&priv->lock, flags);

	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	priv->ibss_beacon = skb;

	timestamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
	priv->timestamp = le64_to_cpu(timestamp);

	IWL_DEBUG_MAC80211(priv, "leave\n");
	spin_unlock_irqrestore(&priv->lock, flags);

	priv->cfg->ops->lib->post_associate(priv, priv->vif);

	return 0;
}

1667
void iwl_bss_info_changed(struct ieee80211_hw *hw,
1668 1669 1670
			  struct ieee80211_vif *vif,
			  struct ieee80211_bss_conf *bss_conf,
			  u32 changes)
1671 1672
{
	struct iwl_priv *priv = hw->priv;
1673
	int ret;
1674 1675 1676

	IWL_DEBUG_MAC80211(priv, "changes = 0x%X\n", changes);

1677 1678 1679 1680 1681
	if (!iwl_is_alive(priv))
		return;

	mutex_lock(&priv->mutex);

1682 1683 1684 1685 1686 1687 1688 1689 1690
	if (changes & BSS_CHANGED_QOS) {
		unsigned long flags;

		spin_lock_irqsave(&priv->lock, flags);
		priv->qos_data.qos_active = bss_conf->qos;
		iwl_update_qos(priv);
		spin_unlock_irqrestore(&priv->lock, flags);
	}

1691
	if (changes & BSS_CHANGED_BEACON && vif->type == NL80211_IFTYPE_AP) {
1692 1693 1694 1695
		dev_kfree_skb(priv->ibss_beacon);
		priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
	}

J
Johannes Berg 已提交
1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707
	if (changes & BSS_CHANGED_BEACON_INT) {
		/* TODO: in AP mode, do something to make this take effect */
	}

	if (changes & BSS_CHANGED_BSSID) {
		IWL_DEBUG_MAC80211(priv, "BSSID %pM\n", bss_conf->bssid);

		/*
		 * If there is currently a HW scan going on in the
		 * background then we need to cancel it else the RXON
		 * below/in post_associate will fail.
		 */
1708
		if (iwl_scan_cancel_timeout(priv, 100)) {
J
Johannes Berg 已提交
1709
			IWL_WARN(priv, "Aborted scan still in progress after 100ms\n");
1710 1711 1712 1713 1714
			IWL_DEBUG_MAC80211(priv, "leaving - scan abort failed.\n");
			mutex_unlock(&priv->mutex);
			return;
		}

J
Johannes Berg 已提交
1715
		/* mac80211 only sets assoc when in STATION mode */
1716
		if (vif->type == NL80211_IFTYPE_ADHOC || bss_conf->assoc) {
J
Johannes Berg 已提交
1717 1718
			memcpy(priv->staging_rxon.bssid_addr,
			       bss_conf->bssid, ETH_ALEN);
1719

J
Johannes Berg 已提交
1720 1721 1722 1723 1724
			/* currently needed in a few places */
			memcpy(priv->bssid, bss_conf->bssid, ETH_ALEN);
		} else {
			priv->staging_rxon.filter_flags &=
				~RXON_FILTER_ASSOC_MSK;
1725
		}
J
Johannes Berg 已提交
1726

1727 1728
	}

J
Johannes Berg 已提交
1729 1730 1731 1732 1733
	/*
	 * This needs to be after setting the BSSID in case
	 * mac80211 decides to do both changes at once because
	 * it will invoke post_associate.
	 */
1734
	if (vif->type == NL80211_IFTYPE_ADHOC &&
1735 1736 1737 1738 1739 1740 1741
	    changes & BSS_CHANGED_BEACON) {
		struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);

		if (beacon)
			iwl_mac_beacon_update(hw, beacon);
	}

1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756
	if (changes & BSS_CHANGED_ERP_PREAMBLE) {
		IWL_DEBUG_MAC80211(priv, "ERP_PREAMBLE %d\n",
				   bss_conf->use_short_preamble);
		if (bss_conf->use_short_preamble)
			priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
		else
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
	}

	if (changes & BSS_CHANGED_ERP_CTS_PROT) {
		IWL_DEBUG_MAC80211(priv, "ERP_CTS %d\n", bss_conf->use_cts_prot);
		if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
			priv->staging_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
		else
			priv->staging_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
J
Johannes Berg 已提交
1757 1758 1759 1760
		if (bss_conf->use_cts_prot)
			priv->staging_rxon.flags |= RXON_FLG_SELF_CTS_EN;
		else
			priv->staging_rxon.flags &= ~RXON_FLG_SELF_CTS_EN;
1761 1762
	}

J
Johannes Berg 已提交
1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
	if (changes & BSS_CHANGED_BASIC_RATES) {
		/* XXX use this information
		 *
		 * To do that, remove code from iwl_set_rate() and put something
		 * like this here:
		 *
		if (A-band)
			priv->staging_rxon.ofdm_basic_rates =
				bss_conf->basic_rates;
		else
			priv->staging_rxon.ofdm_basic_rates =
				bss_conf->basic_rates >> 4;
			priv->staging_rxon.cck_basic_rates =
				bss_conf->basic_rates & 0xF;
		 */
	}

1780
	if (changes & BSS_CHANGED_HT) {
J
Johannes Berg 已提交
1781
		iwl_ht_conf(priv, vif);
1782 1783 1784

		if (priv->cfg->ops->hcmd->set_rxon_chain)
			priv->cfg->ops->hcmd->set_rxon_chain(priv);
1785 1786 1787 1788 1789 1790 1791
	}

	if (changes & BSS_CHANGED_ASSOC) {
		IWL_DEBUG_MAC80211(priv, "ASSOC %d\n", bss_conf->assoc);
		if (bss_conf->assoc) {
			priv->timestamp = bss_conf->timestamp;

J
Johannes Berg 已提交
1792 1793
			iwl_led_associate(priv);

J
Johannes Berg 已提交
1794
			if (!iwl_is_rfkill(priv))
1795
				priv->cfg->ops->lib->post_associate(priv, vif);
1796 1797
		} else
			iwl_set_no_assoc(priv);
J
Johannes Berg 已提交
1798 1799
	}

1800
	if (changes && iwl_is_associated(priv) && bss_conf->aid) {
J
Johannes Berg 已提交
1801 1802 1803 1804 1805 1806 1807 1808
		IWL_DEBUG_MAC80211(priv, "Changes (%#x) while associated\n",
				   changes);
		ret = iwl_send_rxon_assoc(priv);
		if (!ret) {
			/* Sync active_rxon with latest change. */
			memcpy((void *)&priv->active_rxon,
				&priv->staging_rxon,
				sizeof(struct iwl_rxon_cmd));
1809 1810
		}
	}
J
Johannes Berg 已提交
1811

1812 1813 1814 1815 1816
	if (changes & BSS_CHANGED_BEACON_ENABLED) {
		if (vif->bss_conf.enable_beacon) {
			memcpy(priv->staging_rxon.bssid_addr,
			       bss_conf->bssid, ETH_ALEN);
			memcpy(priv->bssid, bss_conf->bssid, ETH_ALEN);
1817
			iwlcore_config_ap(priv, vif);
1818 1819
		} else
			iwl_set_no_assoc(priv);
1820 1821
	}

1822 1823 1824 1825 1826 1827 1828 1829 1830
	if (changes & BSS_CHANGED_IBSS) {
		ret = priv->cfg->ops->lib->manage_ibss_station(priv, vif,
							bss_conf->ibss_joined);
		if (ret)
			IWL_ERR(priv, "failed to %s IBSS station %pM\n",
				bss_conf->ibss_joined ? "add" : "remove",
				bss_conf->bssid);
	}

J
Johannes Berg 已提交
1831 1832
	mutex_unlock(&priv->mutex);

1833
	IWL_DEBUG_MAC80211(priv, "leave\n");
1834 1835 1836
}
EXPORT_SYMBOL(iwl_bss_info_changed);

1837
static int iwl_set_mode(struct iwl_priv *priv, struct ieee80211_vif *vif)
1838
{
1839
	iwl_connection_init_rx_config(priv, vif);
1840 1841 1842 1843

	if (priv->cfg->ops->hcmd->set_rxon_chain)
		priv->cfg->ops->hcmd->set_rxon_chain(priv);

1844
	return iwlcore_commit_rxon(priv);
1845 1846
}

1847
int iwl_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1848 1849
{
	struct iwl_priv *priv = hw->priv;
1850
	int err = 0;
1851

J
Johannes Berg 已提交
1852 1853
	IWL_DEBUG_MAC80211(priv, "enter: type %d, addr %pM\n",
			   vif->type, vif->addr);
1854

1855 1856
	mutex_lock(&priv->mutex);

1857 1858 1859 1860 1861
	if (WARN_ON(!iwl_is_ready_rf(priv))) {
		err = -EINVAL;
		goto out;
	}

1862 1863
	if (priv->vif) {
		IWL_DEBUG_MAC80211(priv, "leave - vif != NULL\n");
1864 1865
		err = -EOPNOTSUPP;
		goto out;
1866 1867
	}

1868 1869
	priv->vif = vif;
	priv->iw_mode = vif->type;
1870

1871 1872 1873
	err = iwl_set_mode(priv, vif);
	if (err)
		goto out_err;
1874

1875
	goto out;
1876

1877 1878 1879
 out_err:
	priv->vif = NULL;
	priv->iw_mode = NL80211_IFTYPE_STATION;
1880
 out:
1881 1882 1883
	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211(priv, "leave\n");
1884
	return err;
1885 1886 1887
}
EXPORT_SYMBOL(iwl_mac_add_interface);

1888
void iwl_mac_remove_interface(struct ieee80211_hw *hw,
1889
			      struct ieee80211_vif *vif)
1890 1891
{
	struct iwl_priv *priv = hw->priv;
1892
	bool scan_completed = false;
1893 1894 1895 1896 1897 1898 1899 1900 1901 1902

	IWL_DEBUG_MAC80211(priv, "enter\n");

	mutex_lock(&priv->mutex);

	if (iwl_is_ready_rf(priv)) {
		iwl_scan_cancel_timeout(priv, 100);
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
		iwlcore_commit_rxon(priv);
	}
1903
	if (priv->vif == vif) {
1904
		priv->vif = NULL;
1905
		if (priv->scan_vif == vif) {
1906
			scan_completed = true;
1907 1908 1909
			priv->scan_vif = NULL;
			priv->scan_request = NULL;
		}
1910 1911 1912 1913
		memset(priv->bssid, 0, ETH_ALEN);
	}
	mutex_unlock(&priv->mutex);

1914 1915 1916
	if (scan_completed)
		ieee80211_scan_completed(priv->hw, true);

1917 1918 1919 1920 1921
	IWL_DEBUG_MAC80211(priv, "leave\n");

}
EXPORT_SYMBOL(iwl_mac_remove_interface);

1922 1923 1924 1925 1926 1927 1928 1929
/**
 * iwl_mac_config - mac80211 config callback
 */
int iwl_mac_config(struct ieee80211_hw *hw, u32 changed)
{
	struct iwl_priv *priv = hw->priv;
	const struct iwl_channel_info *ch_info;
	struct ieee80211_conf *conf = &hw->conf;
1930
	struct ieee80211_channel *channel = conf->channel;
J
Johannes Berg 已提交
1931
	struct iwl_ht_config *ht_conf = &priv->current_ht_config;
1932 1933 1934 1935 1936 1937 1938 1939
	unsigned long flags = 0;
	int ret = 0;
	u16 ch;
	int scan_active = 0;

	mutex_lock(&priv->mutex);

	IWL_DEBUG_MAC80211(priv, "enter to channel %d changed 0x%X\n",
1940
					channel->hw_value, changed);
1941 1942 1943 1944 1945 1946 1947

	if (unlikely(!priv->cfg->mod_params->disable_hw_scan &&
			test_bit(STATUS_SCANNING, &priv->status))) {
		scan_active = 1;
		IWL_DEBUG_MAC80211(priv, "leave - scanning\n");
	}

J
Johannes Berg 已提交
1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
	if (changed & (IEEE80211_CONF_CHANGE_SMPS |
		       IEEE80211_CONF_CHANGE_CHANNEL)) {
		/* mac80211 uses static for non-HT which is what we want */
		priv->current_ht_config.smps = conf->smps_mode;

		/*
		 * Recalculate chain counts.
		 *
		 * If monitor mode is enabled then mac80211 will
		 * set up the SM PS mode to OFF if an HT channel is
		 * configured.
		 */
		if (priv->cfg->ops->hcmd->set_rxon_chain)
			priv->cfg->ops->hcmd->set_rxon_chain(priv);
	}
1963 1964 1965 1966 1967 1968 1969 1970

	/* during scanning mac80211 will delay channel setting until
	 * scan finish with changed = 0
	 */
	if (!changed || (changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
		if (scan_active)
			goto set_ch_out;

1971 1972
		ch = channel->hw_value;
		ch_info = iwl_get_channel_info(priv, channel->band, ch);
1973 1974 1975 1976 1977 1978 1979 1980
		if (!is_channel_valid(ch_info)) {
			IWL_DEBUG_MAC80211(priv, "leave - invalid channel\n");
			ret = -EINVAL;
			goto set_ch_out;
		}

		spin_lock_irqsave(&priv->lock, flags);

1981 1982 1983 1984 1985 1986
		/* Configure HT40 channels */
		ht_conf->is_ht = conf_is_ht(conf);
		if (ht_conf->is_ht) {
			if (conf_is_ht40_minus(conf)) {
				ht_conf->extension_chan_offset =
					IEEE80211_HT_PARAM_CHA_SEC_BELOW;
1987
				ht_conf->is_40mhz = true;
1988 1989 1990
			} else if (conf_is_ht40_plus(conf)) {
				ht_conf->extension_chan_offset =
					IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
1991
				ht_conf->is_40mhz = true;
1992 1993 1994
			} else {
				ht_conf->extension_chan_offset =
					IEEE80211_HT_PARAM_CHA_SEC_NONE;
1995
				ht_conf->is_40mhz = false;
1996 1997
			}
		} else
1998
			ht_conf->is_40mhz = false;
1999 2000 2001
		/* Default to no protection. Protection mode will later be set
		 * from BSS config in iwl_ht_conf */
		ht_conf->ht_protection = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
2002 2003 2004 2005

		if ((le16_to_cpu(priv->staging_rxon.channel) != ch))
			priv->staging_rxon.flags = 0;

2006
		iwl_set_rxon_channel(priv, channel);
2007
		iwl_set_rxon_ht(priv, ht_conf);
2008

2009
		iwl_set_flags_for_band(priv, channel->band, priv->vif);
2010
		spin_unlock_irqrestore(&priv->lock, flags);
2011

2012 2013 2014
		if (priv->cfg->ops->lib->update_bcast_station)
			ret = priv->cfg->ops->lib->update_bcast_station(priv);

2015 2016 2017 2018 2019 2020 2021
 set_ch_out:
		/* The list of supported rates and rate mask can be different
		 * for each band; since the band may have changed, reset
		 * the rate mask to what mac80211 lists */
		iwl_set_rate(priv);
	}

2022 2023
	if (changed & (IEEE80211_CONF_CHANGE_PS |
			IEEE80211_CONF_CHANGE_IDLE)) {
2024
		ret = iwl_power_update_mode(priv, false);
2025
		if (ret)
2026
			IWL_DEBUG_MAC80211(priv, "Error setting sleep level\n");
2027 2028 2029 2030 2031 2032 2033 2034 2035
	}

	if (changed & IEEE80211_CONF_CHANGE_POWER) {
		IWL_DEBUG_MAC80211(priv, "TX Power old=%d new=%d\n",
			priv->tx_power_user_lmt, conf->power_level);

		iwl_set_tx_power(priv, conf->power_level, false);
	}

2036 2037 2038 2039 2040
	if (!iwl_is_ready(priv)) {
		IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
		goto out;
	}

2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057
	if (scan_active)
		goto out;

	if (memcmp(&priv->active_rxon,
		   &priv->staging_rxon, sizeof(priv->staging_rxon)))
		iwlcore_commit_rxon(priv);
	else
		IWL_DEBUG_INFO(priv, "Not re-sending same RXON configuration.\n");


out:
	IWL_DEBUG_MAC80211(priv, "leave\n");
	mutex_unlock(&priv->mutex);
	return ret;
}
EXPORT_SYMBOL(iwl_mac_config);

2058 2059 2060 2061 2062 2063 2064 2065 2066
void iwl_mac_reset_tsf(struct ieee80211_hw *hw)
{
	struct iwl_priv *priv = hw->priv;
	unsigned long flags;

	mutex_lock(&priv->mutex);
	IWL_DEBUG_MAC80211(priv, "enter\n");

	spin_lock_irqsave(&priv->lock, flags);
J
Johannes Berg 已提交
2067
	memset(&priv->current_ht_config, 0, sizeof(struct iwl_ht_config));
2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090
	spin_unlock_irqrestore(&priv->lock, flags);

	spin_lock_irqsave(&priv->lock, flags);

	/* new association get rid of ibss beacon skb */
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	priv->ibss_beacon = NULL;

	priv->timestamp = 0;

	spin_unlock_irqrestore(&priv->lock, flags);

	if (!iwl_is_ready_rf(priv)) {
		IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
		mutex_unlock(&priv->mutex);
		return;
	}

	/* we are restarting association process
	 * clear RXON_FILTER_ASSOC_MSK bit
	 */
2091 2092 2093
	iwl_scan_cancel_timeout(priv, 100);
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	iwlcore_commit_rxon(priv);
2094 2095 2096 2097 2098 2099 2100 2101 2102

	iwl_set_rate(priv);

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211(priv, "leave\n");
}
EXPORT_SYMBOL(iwl_mac_reset_tsf);

2103 2104 2105 2106 2107 2108 2109
int iwl_alloc_txq_mem(struct iwl_priv *priv)
{
	if (!priv->txq)
		priv->txq = kzalloc(
			sizeof(struct iwl_tx_queue) * priv->cfg->num_of_queues,
			GFP_KERNEL);
	if (!priv->txq) {
2110
		IWL_ERR(priv, "Not enough memory for txq\n");
2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123
		return -ENOMEM;
	}
	return 0;
}
EXPORT_SYMBOL(iwl_alloc_txq_mem);

void iwl_free_txq_mem(struct iwl_priv *priv)
{
	kfree(priv->txq);
	priv->txq = NULL;
}
EXPORT_SYMBOL(iwl_free_txq_mem);

2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221
#ifdef CONFIG_IWLWIFI_DEBUGFS

#define IWL_TRAFFIC_DUMP_SIZE	(IWL_TRAFFIC_ENTRY_SIZE * IWL_TRAFFIC_ENTRIES)

void iwl_reset_traffic_log(struct iwl_priv *priv)
{
	priv->tx_traffic_idx = 0;
	priv->rx_traffic_idx = 0;
	if (priv->tx_traffic)
		memset(priv->tx_traffic, 0, IWL_TRAFFIC_DUMP_SIZE);
	if (priv->rx_traffic)
		memset(priv->rx_traffic, 0, IWL_TRAFFIC_DUMP_SIZE);
}

int iwl_alloc_traffic_mem(struct iwl_priv *priv)
{
	u32 traffic_size = IWL_TRAFFIC_DUMP_SIZE;

	if (iwl_debug_level & IWL_DL_TX) {
		if (!priv->tx_traffic) {
			priv->tx_traffic =
				kzalloc(traffic_size, GFP_KERNEL);
			if (!priv->tx_traffic)
				return -ENOMEM;
		}
	}
	if (iwl_debug_level & IWL_DL_RX) {
		if (!priv->rx_traffic) {
			priv->rx_traffic =
				kzalloc(traffic_size, GFP_KERNEL);
			if (!priv->rx_traffic)
				return -ENOMEM;
		}
	}
	iwl_reset_traffic_log(priv);
	return 0;
}
EXPORT_SYMBOL(iwl_alloc_traffic_mem);

void iwl_free_traffic_mem(struct iwl_priv *priv)
{
	kfree(priv->tx_traffic);
	priv->tx_traffic = NULL;

	kfree(priv->rx_traffic);
	priv->rx_traffic = NULL;
}
EXPORT_SYMBOL(iwl_free_traffic_mem);

void iwl_dbg_log_tx_data_frame(struct iwl_priv *priv,
		      u16 length, struct ieee80211_hdr *header)
{
	__le16 fc;
	u16 len;

	if (likely(!(iwl_debug_level & IWL_DL_TX)))
		return;

	if (!priv->tx_traffic)
		return;

	fc = header->frame_control;
	if (ieee80211_is_data(fc)) {
		len = (length > IWL_TRAFFIC_ENTRY_SIZE)
		       ? IWL_TRAFFIC_ENTRY_SIZE : length;
		memcpy((priv->tx_traffic +
		       (priv->tx_traffic_idx * IWL_TRAFFIC_ENTRY_SIZE)),
		       header, len);
		priv->tx_traffic_idx =
			(priv->tx_traffic_idx + 1) % IWL_TRAFFIC_ENTRIES;
	}
}
EXPORT_SYMBOL(iwl_dbg_log_tx_data_frame);

void iwl_dbg_log_rx_data_frame(struct iwl_priv *priv,
		      u16 length, struct ieee80211_hdr *header)
{
	__le16 fc;
	u16 len;

	if (likely(!(iwl_debug_level & IWL_DL_RX)))
		return;

	if (!priv->rx_traffic)
		return;

	fc = header->frame_control;
	if (ieee80211_is_data(fc)) {
		len = (length > IWL_TRAFFIC_ENTRY_SIZE)
		       ? IWL_TRAFFIC_ENTRY_SIZE : length;
		memcpy((priv->rx_traffic +
		       (priv->rx_traffic_idx * IWL_TRAFFIC_ENTRY_SIZE)),
		       header, len);
		priv->rx_traffic_idx =
			(priv->rx_traffic_idx + 1) % IWL_TRAFFIC_ENTRIES;
	}
}
EXPORT_SYMBOL(iwl_dbg_log_rx_data_frame);
2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260

const char *get_mgmt_string(int cmd)
{
	switch (cmd) {
		IWL_CMD(MANAGEMENT_ASSOC_REQ);
		IWL_CMD(MANAGEMENT_ASSOC_RESP);
		IWL_CMD(MANAGEMENT_REASSOC_REQ);
		IWL_CMD(MANAGEMENT_REASSOC_RESP);
		IWL_CMD(MANAGEMENT_PROBE_REQ);
		IWL_CMD(MANAGEMENT_PROBE_RESP);
		IWL_CMD(MANAGEMENT_BEACON);
		IWL_CMD(MANAGEMENT_ATIM);
		IWL_CMD(MANAGEMENT_DISASSOC);
		IWL_CMD(MANAGEMENT_AUTH);
		IWL_CMD(MANAGEMENT_DEAUTH);
		IWL_CMD(MANAGEMENT_ACTION);
	default:
		return "UNKNOWN";

	}
}

const char *get_ctrl_string(int cmd)
{
	switch (cmd) {
		IWL_CMD(CONTROL_BACK_REQ);
		IWL_CMD(CONTROL_BACK);
		IWL_CMD(CONTROL_PSPOLL);
		IWL_CMD(CONTROL_RTS);
		IWL_CMD(CONTROL_CTS);
		IWL_CMD(CONTROL_ACK);
		IWL_CMD(CONTROL_CFEND);
		IWL_CMD(CONTROL_CFENDACK);
	default:
		return "UNKNOWN";

	}
}

2261
void iwl_clear_traffic_stats(struct iwl_priv *priv)
2262 2263 2264
{
	memset(&priv->tx_stats, 0, sizeof(struct traffic_stats));
	memset(&priv->rx_stats, 0, sizeof(struct traffic_stats));
2265
	priv->led_tpt = 0;
2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357
}

/*
 * if CONFIG_IWLWIFI_DEBUGFS defined, iwl_update_stats function will
 * record all the MGMT, CTRL and DATA pkt for both TX and Rx pass.
 * Use debugFs to display the rx/rx_statistics
 * if CONFIG_IWLWIFI_DEBUGFS not being defined, then no MGMT and CTRL
 * information will be recorded, but DATA pkt still will be recorded
 * for the reason of iwl_led.c need to control the led blinking based on
 * number of tx and rx data.
 *
 */
void iwl_update_stats(struct iwl_priv *priv, bool is_tx, __le16 fc, u16 len)
{
	struct traffic_stats	*stats;

	if (is_tx)
		stats = &priv->tx_stats;
	else
		stats = &priv->rx_stats;

	if (ieee80211_is_mgmt(fc)) {
		switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
		case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ):
			stats->mgmt[MANAGEMENT_ASSOC_REQ]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP):
			stats->mgmt[MANAGEMENT_ASSOC_RESP]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ):
			stats->mgmt[MANAGEMENT_REASSOC_REQ]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP):
			stats->mgmt[MANAGEMENT_REASSOC_RESP]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_PROBE_REQ):
			stats->mgmt[MANAGEMENT_PROBE_REQ]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
			stats->mgmt[MANAGEMENT_PROBE_RESP]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_BEACON):
			stats->mgmt[MANAGEMENT_BEACON]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_ATIM):
			stats->mgmt[MANAGEMENT_ATIM]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_DISASSOC):
			stats->mgmt[MANAGEMENT_DISASSOC]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_AUTH):
			stats->mgmt[MANAGEMENT_AUTH]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
			stats->mgmt[MANAGEMENT_DEAUTH]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_ACTION):
			stats->mgmt[MANAGEMENT_ACTION]++;
			break;
		}
	} else if (ieee80211_is_ctl(fc)) {
		switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
		case cpu_to_le16(IEEE80211_STYPE_BACK_REQ):
			stats->ctrl[CONTROL_BACK_REQ]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_BACK):
			stats->ctrl[CONTROL_BACK]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_PSPOLL):
			stats->ctrl[CONTROL_PSPOLL]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_RTS):
			stats->ctrl[CONTROL_RTS]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_CTS):
			stats->ctrl[CONTROL_CTS]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_ACK):
			stats->ctrl[CONTROL_ACK]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_CFEND):
			stats->ctrl[CONTROL_CFEND]++;
			break;
		case cpu_to_le16(IEEE80211_STYPE_CFENDACK):
			stats->ctrl[CONTROL_CFENDACK]++;
			break;
		}
	} else {
		/* data */
		stats->data_cnt++;
		stats->data_bytes += len;
	}
2358
	iwl_leds_background(priv);
2359 2360
}
EXPORT_SYMBOL(iwl_update_stats);
2361 2362
#endif

2363
static const char *get_csr_string(int cmd)
2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433
{
	switch (cmd) {
		IWL_CMD(CSR_HW_IF_CONFIG_REG);
		IWL_CMD(CSR_INT_COALESCING);
		IWL_CMD(CSR_INT);
		IWL_CMD(CSR_INT_MASK);
		IWL_CMD(CSR_FH_INT_STATUS);
		IWL_CMD(CSR_GPIO_IN);
		IWL_CMD(CSR_RESET);
		IWL_CMD(CSR_GP_CNTRL);
		IWL_CMD(CSR_HW_REV);
		IWL_CMD(CSR_EEPROM_REG);
		IWL_CMD(CSR_EEPROM_GP);
		IWL_CMD(CSR_OTP_GP_REG);
		IWL_CMD(CSR_GIO_REG);
		IWL_CMD(CSR_GP_UCODE_REG);
		IWL_CMD(CSR_GP_DRIVER_REG);
		IWL_CMD(CSR_UCODE_DRV_GP1);
		IWL_CMD(CSR_UCODE_DRV_GP2);
		IWL_CMD(CSR_LED_REG);
		IWL_CMD(CSR_DRAM_INT_TBL_REG);
		IWL_CMD(CSR_GIO_CHICKEN_BITS);
		IWL_CMD(CSR_ANA_PLL_CFG);
		IWL_CMD(CSR_HW_REV_WA_REG);
		IWL_CMD(CSR_DBG_HPET_MEM_REG);
	default:
		return "UNKNOWN";

	}
}

void iwl_dump_csr(struct iwl_priv *priv)
{
	int i;
	u32 csr_tbl[] = {
		CSR_HW_IF_CONFIG_REG,
		CSR_INT_COALESCING,
		CSR_INT,
		CSR_INT_MASK,
		CSR_FH_INT_STATUS,
		CSR_GPIO_IN,
		CSR_RESET,
		CSR_GP_CNTRL,
		CSR_HW_REV,
		CSR_EEPROM_REG,
		CSR_EEPROM_GP,
		CSR_OTP_GP_REG,
		CSR_GIO_REG,
		CSR_GP_UCODE_REG,
		CSR_GP_DRIVER_REG,
		CSR_UCODE_DRV_GP1,
		CSR_UCODE_DRV_GP2,
		CSR_LED_REG,
		CSR_DRAM_INT_TBL_REG,
		CSR_GIO_CHICKEN_BITS,
		CSR_ANA_PLL_CFG,
		CSR_HW_REV_WA_REG,
		CSR_DBG_HPET_MEM_REG
	};
	IWL_ERR(priv, "CSR values:\n");
	IWL_ERR(priv, "(2nd byte of CSR_INT_COALESCING is "
		"CSR_INT_PERIODIC_REG)\n");
	for (i = 0; i <  ARRAY_SIZE(csr_tbl); i++) {
		IWL_ERR(priv, "  %25s: 0X%08x\n",
			get_csr_string(csr_tbl[i]),
			iwl_read32(priv, csr_tbl[i]));
	}
}
EXPORT_SYMBOL(iwl_dump_csr);

2434
static const char *get_fh_string(int cmd)
2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496
{
	switch (cmd) {
		IWL_CMD(FH_RSCSR_CHNL0_STTS_WPTR_REG);
		IWL_CMD(FH_RSCSR_CHNL0_RBDCB_BASE_REG);
		IWL_CMD(FH_RSCSR_CHNL0_WPTR);
		IWL_CMD(FH_MEM_RCSR_CHNL0_CONFIG_REG);
		IWL_CMD(FH_MEM_RSSR_SHARED_CTRL_REG);
		IWL_CMD(FH_MEM_RSSR_RX_STATUS_REG);
		IWL_CMD(FH_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV);
		IWL_CMD(FH_TSSR_TX_STATUS_REG);
		IWL_CMD(FH_TSSR_TX_ERROR_REG);
	default:
		return "UNKNOWN";

	}
}

int iwl_dump_fh(struct iwl_priv *priv, char **buf, bool display)
{
	int i;
#ifdef CONFIG_IWLWIFI_DEBUG
	int pos = 0;
	size_t bufsz = 0;
#endif
	u32 fh_tbl[] = {
		FH_RSCSR_CHNL0_STTS_WPTR_REG,
		FH_RSCSR_CHNL0_RBDCB_BASE_REG,
		FH_RSCSR_CHNL0_WPTR,
		FH_MEM_RCSR_CHNL0_CONFIG_REG,
		FH_MEM_RSSR_SHARED_CTRL_REG,
		FH_MEM_RSSR_RX_STATUS_REG,
		FH_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV,
		FH_TSSR_TX_STATUS_REG,
		FH_TSSR_TX_ERROR_REG
	};
#ifdef CONFIG_IWLWIFI_DEBUG
	if (display) {
		bufsz = ARRAY_SIZE(fh_tbl) * 48 + 40;
		*buf = kmalloc(bufsz, GFP_KERNEL);
		if (!*buf)
			return -ENOMEM;
		pos += scnprintf(*buf + pos, bufsz - pos,
				"FH register values:\n");
		for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
			pos += scnprintf(*buf + pos, bufsz - pos,
				"  %34s: 0X%08x\n",
				get_fh_string(fh_tbl[i]),
				iwl_read_direct32(priv, fh_tbl[i]));
		}
		return pos;
	}
#endif
	IWL_ERR(priv, "FH register values:\n");
	for (i = 0; i <  ARRAY_SIZE(fh_tbl); i++) {
		IWL_ERR(priv, "  %34s: 0X%08x\n",
			get_fh_string(fh_tbl[i]),
			iwl_read_direct32(priv, fh_tbl[i]));
	}
	return 0;
}
EXPORT_SYMBOL(iwl_dump_fh);

W
Wey-Yi Guy 已提交
2497
static void iwl_force_rf_reset(struct iwl_priv *priv)
2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517
{
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
		return;

	if (!iwl_is_associated(priv)) {
		IWL_DEBUG_SCAN(priv, "force reset rejected: not associated\n");
		return;
	}
	/*
	 * There is no easy and better way to force reset the radio,
	 * the only known method is switching channel which will force to
	 * reset and tune the radio.
	 * Use internal short scan (single channel) operation to should
	 * achieve this objective.
	 * Driver should reset the radio when number of consecutive missed
	 * beacon, or any other uCode error condition detected.
	 */
	IWL_DEBUG_INFO(priv, "perform radio reset.\n");
	iwl_internal_short_hw_scan(priv);
}
W
Wey-Yi Guy 已提交
2518 2519


2520
int iwl_force_reset(struct iwl_priv *priv, int mode, bool external)
W
Wey-Yi Guy 已提交
2521
{
2522 2523
	struct iwl_force_reset *force_reset;

W
Wey-Yi Guy 已提交
2524 2525 2526
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
		return -EINVAL;

2527 2528 2529 2530 2531 2532
	if (mode >= IWL_MAX_FORCE_RESET) {
		IWL_DEBUG_INFO(priv, "invalid reset request.\n");
		return -EINVAL;
	}
	force_reset = &priv->force_reset[mode];
	force_reset->reset_request_count++;
2533 2534 2535 2536 2537 2538 2539 2540
	if (!external) {
		if (force_reset->last_force_reset_jiffies &&
		    time_after(force_reset->last_force_reset_jiffies +
		    force_reset->reset_duration, jiffies)) {
			IWL_DEBUG_INFO(priv, "force reset rejected\n");
			force_reset->reset_reject_count++;
			return -EAGAIN;
		}
W
Wey-Yi Guy 已提交
2541
	}
2542 2543
	force_reset->reset_success_count++;
	force_reset->last_force_reset_jiffies = jiffies;
W
Wey-Yi Guy 已提交
2544 2545 2546 2547 2548 2549
	IWL_DEBUG_INFO(priv, "perform force reset (%d)\n", mode);
	switch (mode) {
	case IWL_RF_RESET:
		iwl_force_rf_reset(priv);
		break;
	case IWL_FW_RESET:
2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562
		/*
		 * if the request is from external(ex: debugfs),
		 * then always perform the request in regardless the module
		 * parameter setting
		 * if the request is from internal (uCode error or driver
		 * detect failure), then fw_restart module parameter
		 * need to be check before performing firmware reload
		 */
		if (!external && !priv->cfg->mod_params->restart_fw) {
			IWL_DEBUG_INFO(priv, "Cancel firmware reload based on "
				       "module parameter setting\n");
			break;
		}
W
Wey-Yi Guy 已提交
2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576
		IWL_ERR(priv, "On demand firmware reload\n");
		/* Set the FW error flag -- cleared on iwl_down */
		set_bit(STATUS_FW_ERROR, &priv->status);
		wake_up_interruptible(&priv->wait_command_queue);
		/*
		 * Keep the restart process from trying to send host
		 * commands by clearing the INIT status bit
		 */
		clear_bit(STATUS_READY, &priv->status);
		queue_work(priv->workqueue, &priv->restart);
		break;
	}
	return 0;
}
2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620
EXPORT_SYMBOL(iwl_force_reset);

/**
 * iwl_bg_monitor_recover - Timer callback to check for stuck queue and recover
 *
 * During normal condition (no queue is stuck), the timer is continually set to
 * execute every monitor_recover_period milliseconds after the last timer
 * expired.  When the queue read_ptr is at the same place, the timer is
 * shorten to 100mSecs.  This is
 *      1) to reduce the chance that the read_ptr may wrap around (not stuck)
 *      2) to detect the stuck queues quicker before the station and AP can
 *      disassociate each other.
 *
 * This function monitors all the tx queues and recover from it if any
 * of the queues are stuck.
 * 1. It first check the cmd queue for stuck conditions.  If it is stuck,
 *      it will recover by resetting the firmware and return.
 * 2. Then, it checks for station association.  If it associates it will check
 *      other queues.  If any queue is stuck, it will recover by resetting
 *      the firmware.
 * Note: It the number of times the queue read_ptr to be at the same place to
 *      be MAX_REPEAT+1 in order to consider to be stuck.
 */
/*
 * The maximum number of times the read pointer of the tx queue at the
 * same place without considering to be stuck.
 */
#define MAX_REPEAT      (2)
static int iwl_check_stuck_queue(struct iwl_priv *priv, int cnt)
{
	struct iwl_tx_queue *txq;
	struct iwl_queue *q;

	txq = &priv->txq[cnt];
	q = &txq->q;
	/* queue is empty, skip */
	if (q->read_ptr != q->write_ptr) {
		if (q->read_ptr == q->last_read_ptr) {
			/* a queue has not been read from last time */
			if (q->repeat_same_read_ptr > MAX_REPEAT) {
				IWL_ERR(priv,
					"queue %d stuck %d time. Fw reload.\n",
					q->id, q->repeat_same_read_ptr);
				q->repeat_same_read_ptr = 0;
2621
				iwl_force_reset(priv, IWL_FW_RESET, false);
2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669
			} else {
				q->repeat_same_read_ptr++;
				IWL_DEBUG_RADIO(priv,
						"queue %d, not read %d time\n",
						q->id,
						q->repeat_same_read_ptr);
				mod_timer(&priv->monitor_recover, jiffies +
					msecs_to_jiffies(IWL_ONE_HUNDRED_MSECS));
			}
			return 1;
		} else {
			q->last_read_ptr = q->read_ptr;
			q->repeat_same_read_ptr = 0;
		}
	}
	return 0;
}

void iwl_bg_monitor_recover(unsigned long data)
{
	struct iwl_priv *priv = (struct iwl_priv *)data;
	int cnt;

	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
		return;

	/* monitor and check for stuck cmd queue */
	if (iwl_check_stuck_queue(priv, IWL_CMD_QUEUE_NUM))
		return;

	/* monitor and check for other stuck queues */
	if (iwl_is_associated(priv)) {
		for (cnt = 0; cnt < priv->hw_params.max_txq_num; cnt++) {
			/* skip as we already checked the command queue */
			if (cnt == IWL_CMD_QUEUE_NUM)
				continue;
			if (iwl_check_stuck_queue(priv, cnt))
				return;
		}
	}
	/*
	 * Reschedule the timer to occur in
	 * priv->cfg->monitor_recover_period
	 */
	mod_timer(&priv->monitor_recover,
		jiffies + msecs_to_jiffies(priv->cfg->monitor_recover_period));
}
EXPORT_SYMBOL(iwl_bg_monitor_recover);
2670

2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725

/*
 * extended beacon time format
 * time in usec will be changed into a 32-bit value in extended:internal format
 * the extended part is the beacon counts
 * the internal part is the time in usec within one beacon interval
 */
u32 iwl_usecs_to_beacons(struct iwl_priv *priv, u32 usec, u32 beacon_interval)
{
	u32 quot;
	u32 rem;
	u32 interval = beacon_interval * TIME_UNIT;

	if (!interval || !usec)
		return 0;

	quot = (usec / interval) &
		(iwl_beacon_time_mask_high(priv,
		priv->hw_params.beacon_time_tsf_bits) >>
		priv->hw_params.beacon_time_tsf_bits);
	rem = (usec % interval) & iwl_beacon_time_mask_low(priv,
				   priv->hw_params.beacon_time_tsf_bits);

	return (quot << priv->hw_params.beacon_time_tsf_bits) + rem;
}
EXPORT_SYMBOL(iwl_usecs_to_beacons);

/* base is usually what we get from ucode with each received frame,
 * the same as HW timer counter counting down
 */
__le32 iwl_add_beacon_time(struct iwl_priv *priv, u32 base,
			   u32 addon, u32 beacon_interval)
{
	u32 base_low = base & iwl_beacon_time_mask_low(priv,
					priv->hw_params.beacon_time_tsf_bits);
	u32 addon_low = addon & iwl_beacon_time_mask_low(priv,
					priv->hw_params.beacon_time_tsf_bits);
	u32 interval = beacon_interval * TIME_UNIT;
	u32 res = (base & iwl_beacon_time_mask_high(priv,
				priv->hw_params.beacon_time_tsf_bits)) +
				(addon & iwl_beacon_time_mask_high(priv,
				priv->hw_params.beacon_time_tsf_bits));

	if (base_low > addon_low)
		res += base_low - addon_low;
	else if (base_low < addon_low) {
		res += interval + base_low - addon_low;
		res += (1 << priv->hw_params.beacon_time_tsf_bits);
	} else
		res += (1 << priv->hw_params.beacon_time_tsf_bits);

	return cpu_to_le32(res);
}
EXPORT_SYMBOL(iwl_add_beacon_time);

2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752
#ifdef CONFIG_PM

int iwl_pci_suspend(struct pci_dev *pdev, pm_message_t state)
{
	struct iwl_priv *priv = pci_get_drvdata(pdev);

	/*
	 * This function is called when system goes into suspend state
	 * mac80211 will call iwl_mac_stop() from the mac80211 suspend function
	 * first but since iwl_mac_stop() has no knowledge of who the caller is,
	 * it will not call apm_ops.stop() to stop the DMA operation.
	 * Calling apm_ops.stop here to make sure we stop the DMA.
	 */
	priv->cfg->ops->lib->apm_ops.stop(priv);

	pci_save_state(pdev);
	pci_disable_device(pdev);
	pci_set_power_state(pdev, PCI_D3hot);

	return 0;
}
EXPORT_SYMBOL(iwl_pci_suspend);

int iwl_pci_resume(struct pci_dev *pdev)
{
	struct iwl_priv *priv = pci_get_drvdata(pdev);
	int ret;
2753
	bool hw_rfkill = false;
2754

2755 2756 2757 2758 2759 2760
	/*
	 * We disable the RETRY_TIMEOUT register (0x41) to keep
	 * PCI Tx retries from interfering with C3 CPU state.
	 */
	pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);

2761 2762 2763 2764 2765 2766 2767
	pci_set_power_state(pdev, PCI_D0);
	ret = pci_enable_device(pdev);
	if (ret)
		return ret;
	pci_restore_state(pdev);
	iwl_enable_interrupts(priv);

2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778
	if (!(iwl_read32(priv, CSR_GP_CNTRL) &
				CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
		hw_rfkill = true;

	if (hw_rfkill)
		set_bit(STATUS_RF_KILL_HW, &priv->status);
	else
		clear_bit(STATUS_RF_KILL_HW, &priv->status);

	wiphy_rfkill_set_hw_state(priv->hw->wiphy, hw_rfkill);

2779 2780 2781 2782 2783
	return 0;
}
EXPORT_SYMBOL(iwl_pci_resume);

#endif /* CONFIG_PM */