iwl-core.c 79.2 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

150 151 152 153
	if (priv->band == IEEE80211_BAND_2GHZ &&
	    priv->bt_traffic_load >= IWL_BT_COEX_TRAFFIC_LOAD_HIGH)
		return 0;

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

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


167 168 169 170 171 172 173 174 175 176 177
/* 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) {
178
		pr_err("%s: Can not allocate network device\n",
179
		       cfg->name);
180 181 182 183 184 185 186 187 188 189 190
		goto out;
	}

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

out:
	return hw;
}
EXPORT_SYMBOL(iwl_alloc_all);

191 192 193
/*
 * QoS  support
*/
J
Johannes Berg 已提交
194
static void iwl_update_qos(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
195 196 197 198
{
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
		return;

199 200 201
	if (!ctx->is_active)
		return;

J
Johannes Berg 已提交
202
	ctx->qos_data.def_qos_parm.qos_flags = 0;
203

J
Johannes Berg 已提交
204 205
	if (ctx->qos_data.qos_active)
		ctx->qos_data.def_qos_parm.qos_flags |=
206 207
			QOS_PARAM_FLG_UPDATE_EDCA_MSK;

208
	if (ctx->ht.enabled)
J
Johannes Berg 已提交
209
		ctx->qos_data.def_qos_parm.qos_flags |= QOS_PARAM_FLG_TGN_MSK;
210

211
	IWL_DEBUG_QOS(priv, "send QoS cmd with Qos active=%d FLAGS=0x%X\n",
J
Johannes Berg 已提交
212 213
		      ctx->qos_data.qos_active,
		      ctx->qos_data.def_qos_parm.qos_flags);
214

J
Johannes Berg 已提交
215
	iwl_send_cmd_pdu_async(priv, ctx->qos_cmd,
216
			       sizeof(struct iwl_qosparam_cmd),
J
Johannes Berg 已提交
217
			       &ctx->qos_data.def_qos_parm, NULL);
218
}
R
Ron Rindjunsky 已提交
219

J
Johannes Berg 已提交
220 221
#define MAX_BIT_RATE_40_MHZ 150 /* Mbps */
#define MAX_BIT_RATE_20_MHZ 72 /* Mbps */
R
Ron Rindjunsky 已提交
222
static void iwlcore_init_ht_hw_capab(const struct iwl_priv *priv,
J
Johannes Berg 已提交
223
			      struct ieee80211_sta_ht_cap *ht_info,
R
Ron Rindjunsky 已提交
224 225
			      enum ieee80211_band band)
{
R
Ron Rindjunsky 已提交
226 227 228 229
	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 已提交
230
	ht_info->cap = 0;
J
Johannes Berg 已提交
231
	memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
R
Ron Rindjunsky 已提交
232

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

235 236
	if (priv->cfg->ht_params &&
	    priv->cfg->ht_params->ht_greenfield_support)
237
		ht_info->cap |= IEEE80211_HT_CAP_GRN_FLD;
J
Johannes Berg 已提交
238
	ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
R
Ron Rindjunsky 已提交
239
	max_bit_rate = MAX_BIT_RATE_20_MHZ;
240
	if (priv->hw_params.ht40_channel & BIT(band)) {
J
Johannes Berg 已提交
241 242 243
		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 已提交
244
		max_bit_rate = MAX_BIT_RATE_40_MHZ;
R
Ron Rindjunsky 已提交
245 246 247
	}

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

	ht_info->ampdu_factor = CFG_HT_RX_AMPDU_FACTOR_DEF;
251 252
	if (priv->cfg->bt_params && priv->cfg->bt_params->ampdu_factor)
		ht_info->ampdu_factor = priv->cfg->bt_params->ampdu_factor;
R
Ron Rindjunsky 已提交
253
	ht_info->ampdu_density = CFG_HT_MPDU_DENSITY_DEF;
254 255
	if (priv->cfg->bt_params && priv->cfg->bt_params->ampdu_density)
		ht_info->ampdu_density = priv->cfg->bt_params->ampdu_density;
R
Ron Rindjunsky 已提交
256

J
Johannes Berg 已提交
257
	ht_info->mcs.rx_mask[0] = 0xFF;
R
Ron Rindjunsky 已提交
258
	if (rx_chains_num >= 2)
J
Johannes Berg 已提交
259
		ht_info->mcs.rx_mask[1] = 0xFF;
R
Ron Rindjunsky 已提交
260
	if (rx_chains_num >= 3)
J
Johannes Berg 已提交
261
		ht_info->mcs.rx_mask[2] = 0xFF;
R
Ron Rindjunsky 已提交
262 263 264

	/* Highest supported Rx data rate */
	max_bit_rate *= rx_chains_num;
J
Johannes Berg 已提交
265 266
	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 已提交
267 268

	/* Tx MCS capabilities */
J
Johannes Berg 已提交
269
	ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
R
Ron Rindjunsky 已提交
270
	if (tx_chains_num != rx_chains_num) {
J
Johannes Berg 已提交
271 272 273
		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 已提交
274
	}
R
Ron Rindjunsky 已提交
275 276 277 278 279
}

/**
 * iwlcore_init_geos - Initialize mac80211's geo/channel info based from eeprom
 */
280
int iwlcore_init_geos(struct iwl_priv *priv)
R
Ron Rindjunsky 已提交
281 282 283 284 285 286 287 288 289 290
{
	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) {
291
		IWL_DEBUG_INFO(priv, "Geography modes already initialized.\n");
R
Ron Rindjunsky 已提交
292 293 294 295 296 297 298 299 300
		set_bit(STATUS_GEO_CONFIGURED, &priv->status);
		return 0;
	}

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

301
	rates = kzalloc((sizeof(struct ieee80211_rate) * IWL_RATE_COUNT_LEGACY),
R
Ron Rindjunsky 已提交
302 303 304 305 306 307 308 309 310 311 312
			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];
313
	sband->n_bitrates = IWL_RATE_COUNT_LEGACY - IWL_FIRST_OFDM_RATE;
R
Ron Rindjunsky 已提交
314

315
	if (priv->cfg->sku & IWL_SKU_N)
J
Johannes Berg 已提交
316
		iwlcore_init_ht_hw_capab(priv, &sband->ht_cap,
317
					 IEEE80211_BAND_5GHZ);
R
Ron Rindjunsky 已提交
318 319 320 321 322

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

325
	if (priv->cfg->sku & IWL_SKU_N)
J
Johannes Berg 已提交
326
		iwlcore_init_ht_hw_capab(priv, &sband->ht_cap,
327
					 IEEE80211_BAND_2GHZ);
R
Ron Rindjunsky 已提交
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 354 355 356 357 358 359 360 361

	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;

362
			geo_ch->flags |= ch->ht40_extension_channel;
363

364 365
			if (ch->max_power_avg > priv->tx_power_device_lmt)
				priv->tx_power_device_lmt = ch->max_power_avg;
R
Ron Rindjunsky 已提交
366 367 368 369
		} else {
			geo_ch->flags |= IEEE80211_CHAN_DISABLED;
		}

370
		IWL_DEBUG_INFO(priv, "Channel %d Freq=%d[%sGHz] %s flag=0x%X\n",
R
Ron Rindjunsky 已提交
371 372 373 374 375 376 377 378 379
				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 已提交
380 381
		IWL_INFO(priv, "Incorrectly detected BG card as ABG. "
			"Please send your PCI ID 0x%04X:0x%04X to maintainer.\n",
382 383
			   priv->pci_dev->device,
			   priv->pci_dev->subsystem_device);
R
Ron Rindjunsky 已提交
384 385 386
		priv->cfg->sku &= ~IWL_SKU_A;
	}

T
Tomas Winkler 已提交
387
	IWL_INFO(priv, "Tunable channels: %d 802.11bg, %d 802.11a channels\n",
388 389
		   priv->bands[IEEE80211_BAND_2GHZ].n_channels,
		   priv->bands[IEEE80211_BAND_5GHZ].n_channels);
R
Ron Rindjunsky 已提交
390 391 392 393 394

	set_bit(STATUS_GEO_CONFIGURED, &priv->status);

	return 0;
}
395
EXPORT_SYMBOL(iwlcore_init_geos);
R
Ron Rindjunsky 已提交
396 397 398 399

/*
 * iwlcore_free_geos - undo allocations in iwlcore_init_geos
 */
400
void iwlcore_free_geos(struct iwl_priv *priv)
R
Ron Rindjunsky 已提交
401 402 403 404 405
{
	kfree(priv->ieee_channels);
	kfree(priv->ieee_rates);
	clear_bit(STATUS_GEO_CONFIGURED, &priv->status);
}
406
EXPORT_SYMBOL(iwlcore_free_geos);
R
Ron Rindjunsky 已提交
407

408
/*
J
Johannes Berg 已提交
409
 *  iwlcore_tx_cmd_protection: Set rts/cts. 3945 and 4965 only share this
410 411
 *  function.
 */
J
Johannes Berg 已提交
412 413 414
void iwlcore_tx_cmd_protection(struct iwl_priv *priv,
			       struct ieee80211_tx_info *info,
			       __le16 fc, __le32 *tx_flags)
415 416 417 418
{
	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 已提交
419 420 421 422 423 424 425 426 427 428 429 430 431 432
		*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;
		}
433 434 435
	} 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 已提交
436
		*tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;
437 438
	}
}
J
Johannes Berg 已提交
439 440
EXPORT_SYMBOL(iwlcore_tx_cmd_protection);

441

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

	ch_info = iwl_get_channel_info(priv, band, channel);
	if (!is_channel_valid(ch_info))
450
		return false;
451

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

459
	return false;
460 461
}

462 463 464
bool iwl_is_ht40_tx_allowed(struct iwl_priv *priv,
			    struct iwl_rxon_context *ctx,
			    struct ieee80211_sta_ht_cap *ht_cap)
465
{
466 467
	if (!ctx->ht.enabled || !ctx->ht.is_40mhz)
		return false;
468

469 470
	/*
	 * We do not check for IEEE80211_HT_CAP_SUP_WIDTH_20_40
471 472
	 * the bit will not set if it is pure 40MHz case
	 */
473 474 475
	if (ht_cap && !ht_cap->ht_supported)
		return false;

476
#ifdef CONFIG_IWLWIFI_DEBUGFS
477
	if (priv->disable_ht40)
478
		return false;
479
#endif
480

481
	return iwl_is_channel_extension(priv, priv->band,
482
			le16_to_cpu(ctx->staging.channel),
483
			ctx->ht.extension_chan_offset);
484
}
485
EXPORT_SYMBOL(iwl_is_ht40_tx_allowed);
486

487 488
static u16 iwl_adjust_beacon_interval(u16 beacon_val, u16 max_beacon_val)
{
489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
	u16 new_val;
	u16 beacon_factor;

	/*
	 * If mac80211 hasn't given us a beacon interval, program
	 * the default into the device (not checking this here
	 * would cause the adjustment below to return the maximum
	 * value, which may break PAN.)
	 */
	if (!beacon_val)
		return DEFAULT_BEACON_INTERVAL;

	/*
	 * If the beacon interval we obtained from the peer
	 * is too large, we'll have to wake up more often
	 * (and in IBSS case, we'll beacon too much)
	 *
	 * For example, if max_beacon_val is 4096, and the
	 * requested beacon interval is 7000, we'll have to
	 * use 3500 to be able to wake up on the beacons.
	 *
	 * This could badly influence beacon detection stats.
	 */
512 513 514 515 516 517 518 519 520 521

	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;
}

522
int iwl_send_rxon_timing(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
523 524 525 526 527
{
	u64 tsf;
	s32 interval_tm, rem;
	struct ieee80211_conf *conf = NULL;
	u16 beacon_int;
528
	struct ieee80211_vif *vif = ctx->vif;
529 530 531

	conf = ieee80211_get_hw_conf(priv->hw);

532 533
	lockdep_assert_held(&priv->mutex);

534
	memset(&ctx->timing, 0, sizeof(struct iwl_rxon_time_cmd));
535

536 537
	ctx->timing.timestamp = cpu_to_le64(priv->timestamp);
	ctx->timing.listen_interval = cpu_to_le16(conf->listen_interval);
538

539
	beacon_int = vif ? vif->bss_conf.beacon_int : 0;
540

541 542 543 544 545
	/*
	 * TODO: For IBSS we need to get atim_window from mac80211,
	 *	 for now just always use 0
	 */
	ctx->timing.atim_window = 0;
546

547
	if (ctx->ctxid == IWL_RXON_CTX_PAN &&
548 549 550 551
	    (!ctx->vif || ctx->vif->type != NL80211_IFTYPE_STATION) &&
	    iwl_is_associated(priv, IWL_RXON_CTX_BSS) &&
	    priv->contexts[IWL_RXON_CTX_BSS].vif &&
	    priv->contexts[IWL_RXON_CTX_BSS].vif->bss_conf.beacon_int) {
552 553 554
		ctx->timing.beacon_interval =
			priv->contexts[IWL_RXON_CTX_BSS].timing.beacon_interval;
		beacon_int = le16_to_cpu(ctx->timing.beacon_interval);
555 556 557 558 559 560 561 562 563
	} else if (ctx->ctxid == IWL_RXON_CTX_BSS &&
		   iwl_is_associated(priv, IWL_RXON_CTX_PAN) &&
		   priv->contexts[IWL_RXON_CTX_PAN].vif &&
		   priv->contexts[IWL_RXON_CTX_PAN].vif->bss_conf.beacon_int &&
		   (!iwl_is_associated_ctx(ctx) || !ctx->vif ||
		    !ctx->vif->bss_conf.beacon_int)) {
		ctx->timing.beacon_interval =
			priv->contexts[IWL_RXON_CTX_PAN].timing.beacon_interval;
		beacon_int = le16_to_cpu(ctx->timing.beacon_interval);
564 565
	} else {
		beacon_int = iwl_adjust_beacon_interval(beacon_int,
W
Wey-Yi Guy 已提交
566
				priv->hw_params.max_beacon_itrvl * TIME_UNIT);
567 568
		ctx->timing.beacon_interval = cpu_to_le16(beacon_int);
	}
569 570

	tsf = priv->timestamp; /* tsf is modifed by do_div: copy it */
W
Wey-Yi Guy 已提交
571
	interval_tm = beacon_int * TIME_UNIT;
572
	rem = do_div(tsf, interval_tm);
573
	ctx->timing.beacon_init_val = cpu_to_le32(interval_tm - rem);
574

575
	ctx->timing.dtim_period = vif ? (vif->bss_conf.dtim_period ?: 1) : 1;
576

577 578
	IWL_DEBUG_ASSOC(priv,
			"beacon interval %d beacon timer %d beacon tim %d\n",
579 580 581
			le16_to_cpu(ctx->timing.beacon_interval),
			le32_to_cpu(ctx->timing.beacon_init_val),
			le16_to_cpu(ctx->timing.atim_window));
582

583
	return iwl_send_cmd_pdu(priv, ctx->rxon_timing_cmd,
584
				sizeof(ctx->timing), &ctx->timing);
585
}
586
EXPORT_SYMBOL(iwl_send_rxon_timing);
587

588 589
void iwl_set_rxon_hwcrypto(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
			   int hw_decrypt)
590
{
591
	struct iwl_rxon_cmd *rxon = &ctx->staging;
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607

	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
 */
608
int iwl_check_rxon_cmd(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
609 610 611
{
	int error = 0;
	int counter = 1;
612
	struct iwl_rxon_cmd *rxon = &ctx->staging;
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 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683

	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.
 */
684 685
int iwl_full_rxon_required(struct iwl_priv *priv,
			   struct iwl_rxon_context *ctx)
686
{
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
	const struct iwl_rxon_cmd *staging = &ctx->staging;
	const struct iwl_rxon_cmd *active = &ctx->active;

#define CHK(cond)							\
	if ((cond)) {							\
		IWL_DEBUG_INFO(priv, "need full RXON - " #cond "\n");	\
		return 1;						\
	}

#define CHK_NEQ(c1, c2)						\
	if ((c1) != (c2)) {					\
		IWL_DEBUG_INFO(priv, "need full RXON - "	\
			       #c1 " != " #c2 " - %d != %d\n",	\
			       (c1), (c2));			\
		return 1;					\
	}
703 704

	/* These items are only settable from the full RXON command */
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719
	CHK(!iwl_is_associated_ctx(ctx));
	CHK(compare_ether_addr(staging->bssid_addr, active->bssid_addr));
	CHK(compare_ether_addr(staging->node_addr, active->node_addr));
	CHK(compare_ether_addr(staging->wlap_bssid_addr,
				active->wlap_bssid_addr));
	CHK_NEQ(staging->dev_type, active->dev_type);
	CHK_NEQ(staging->channel, active->channel);
	CHK_NEQ(staging->air_propagation, active->air_propagation);
	CHK_NEQ(staging->ofdm_ht_single_stream_basic_rates,
		active->ofdm_ht_single_stream_basic_rates);
	CHK_NEQ(staging->ofdm_ht_dual_stream_basic_rates,
		active->ofdm_ht_dual_stream_basic_rates);
	CHK_NEQ(staging->ofdm_ht_triple_stream_basic_rates,
		active->ofdm_ht_triple_stream_basic_rates);
	CHK_NEQ(staging->assoc_id, active->assoc_id);
720 721 722 723 724 725

	/* 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 */
726 727
	CHK_NEQ(staging->flags & RXON_FLG_BAND_24G_MSK,
		active->flags & RXON_FLG_BAND_24G_MSK);
728 729

	/* Check if we are switching association toggle */
730 731 732 733 734
	CHK_NEQ(staging->filter_flags & RXON_FILTER_ASSOC_MSK,
		active->filter_flags & RXON_FILTER_ASSOC_MSK);

#undef CHK
#undef CHK_NEQ
735 736 737 738 739

	return 0;
}
EXPORT_SYMBOL(iwl_full_rxon_required);

740 741
u8 iwl_rate_get_lowest_plcp(struct iwl_priv *priv,
			    struct iwl_rxon_context *ctx)
742
{
743 744 745 746
	/*
	 * Assign the lowest rate -- should really get this from
	 * the beacon skb from mac80211.
	 */
747
	if (ctx->staging.flags & RXON_FLG_BAND_24G_MSK)
748 749 750 751 752 753
		return IWL_RATE_1M_PLCP;
	else
		return IWL_RATE_6M_PLCP;
}
EXPORT_SYMBOL(iwl_rate_get_lowest_plcp);

754 755 756
static void _iwl_set_rxon_ht(struct iwl_priv *priv,
			     struct iwl_ht_config *ht_conf,
			     struct iwl_rxon_context *ctx)
757
{
758
	struct iwl_rxon_cmd *rxon = &ctx->staging;
759

760
	if (!ctx->ht.enabled) {
761
		rxon->flags &= ~(RXON_FLG_CHANNEL_MODE_MSK |
762
			RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK |
763
			RXON_FLG_HT40_PROT_MSK |
764
			RXON_FLG_HT_PROT_MSK);
765
		return;
766
	}
767

768
	/* FIXME: if the definition of ht.protection changed, the "translation"
769 770
	 * will be needed for rxon->flags
	 */
771
	rxon->flags |= cpu_to_le32(ctx->ht.protection << RXON_FLG_HT_OPERATING_MODE_POS);
772 773

	/* Set up channel bandwidth:
774
	 * 20 MHz only, 20/40 mixed or pure 40 if ht40 ok */
775 776 777
	/* clear the HT channel mode before set the mode */
	rxon->flags &= ~(RXON_FLG_CHANNEL_MODE_MSK |
			 RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK);
778
	if (iwl_is_ht40_tx_allowed(priv, ctx, NULL)) {
779
		/* pure ht40 */
780
		if (ctx->ht.protection == IEEE80211_HT_OP_MODE_PROTECTION_20MHZ) {
781
			rxon->flags |= RXON_FLG_CHANNEL_MODE_PURE_40;
782
			/* Note: control channel is opposite of extension channel */
783
			switch (ctx->ht.extension_chan_offset) {
784 785 786 787 788 789 790 791
			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 {
792
			/* Note: control channel is opposite of extension channel */
793
			switch (ctx->ht.extension_chan_offset) {
794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810
			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;
811 812
	}

813
	if (priv->cfg->ops->hcmd->set_rxon_chain)
814
		priv->cfg->ops->hcmd->set_rxon_chain(priv, ctx);
815

816
	IWL_DEBUG_ASSOC(priv, "rxon flags 0x%X operation mode :0x%X "
J
Johannes Berg 已提交
817
			"extension channel offset 0x%x\n",
818 819
			le32_to_cpu(rxon->flags), ctx->ht.protection,
			ctx->ht.extension_chan_offset);
820
}
821 822 823 824 825 826 827 828

void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_config *ht_conf)
{
	struct iwl_rxon_context *ctx;

	for_each_context(priv, ctx)
		_iwl_set_rxon_ht(priv, ht_conf, ctx);
}
829 830
EXPORT_SYMBOL(iwl_set_rxon_ht);

831
/* Return valid, unused, channel for a passive scan to reset the RF */
A
Abhijeet Kolekar 已提交
832
u8 iwl_get_single_channel_number(struct iwl_priv *priv,
833
				 enum ieee80211_band band)
A
Abhijeet Kolekar 已提交
834 835 836 837
{
	const struct iwl_channel_info *ch_info;
	int i;
	u8 channel = 0;
838 839
	u8 min, max;
	struct iwl_rxon_context *ctx;
A
Abhijeet Kolekar 已提交
840 841

	if (band == IEEE80211_BAND_5GHZ) {
842 843
		min = 14;
		max = priv->channel_count;
A
Abhijeet Kolekar 已提交
844
	} else {
845 846 847 848 849 850 851 852 853 854 855 856
		min = 0;
		max = 14;
	}

	for (i = min; i < max; i++) {
		bool busy = false;

		for_each_context(priv, ctx) {
			busy = priv->channel_info[i].channel ==
				le16_to_cpu(ctx->staging.channel);
			if (busy)
				break;
A
Abhijeet Kolekar 已提交
857
		}
858 859 860 861 862 863 864 865

		if (busy)
			continue;

		channel = priv->channel_info[i].channel;
		ch_info = iwl_get_channel_info(priv, band, channel);
		if (is_channel_valid(ch_info))
			break;
A
Abhijeet Kolekar 已提交
866 867 868 869 870 871
	}

	return channel;
}
EXPORT_SYMBOL(iwl_get_single_channel_number);

872
/**
873 874
 * iwl_set_rxon_channel - Set the band and channel values in staging RXON
 * @ch: requested channel as a pointer to struct ieee80211_channel
875 876

 * NOTE:  Does not commit to the hardware; it sets appropriate bit fields
877
 * in the staging RXON flag structure based on the ch->band
878
 */
879 880
int iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch,
			 struct iwl_rxon_context *ctx)
881
{
882
	enum ieee80211_band band = ch->band;
883
	u16 channel = ch->hw_value;
884

885
	if ((le16_to_cpu(ctx->staging.channel) == channel) &&
886 887 888
	    (priv->band == band))
		return 0;

889
	ctx->staging.channel = cpu_to_le16(channel);
890
	if (band == IEEE80211_BAND_5GHZ)
891
		ctx->staging.flags &= ~RXON_FLG_BAND_24G_MSK;
892
	else
893
		ctx->staging.flags |= RXON_FLG_BAND_24G_MSK;
894 895 896

	priv->band = band;

897
	IWL_DEBUG_INFO(priv, "Staging channel set to %d [%d]\n", channel, band);
898 899 900

	return 0;
}
R
Ron Rindjunsky 已提交
901
EXPORT_SYMBOL(iwl_set_rxon_channel);
902

903
void iwl_set_flags_for_band(struct iwl_priv *priv,
904
			    struct iwl_rxon_context *ctx,
905 906
			    enum ieee80211_band band,
			    struct ieee80211_vif *vif)
907 908
{
	if (band == IEEE80211_BAND_5GHZ) {
909
		ctx->staging.flags &=
910 911
		    ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
		      | RXON_FLG_CCK_MSK);
912
		ctx->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
913 914
	} else {
		/* Copied from iwl_post_associate() */
915
		if (vif && vif->bss_conf.use_short_slot)
916
			ctx->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
917
		else
918
			ctx->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
919

920 921 922
		ctx->staging.flags |= RXON_FLG_BAND_24G_MSK;
		ctx->staging.flags |= RXON_FLG_AUTO_DETECT_MSK;
		ctx->staging.flags &= ~RXON_FLG_CCK_MSK;
923 924
	}
}
925
EXPORT_SYMBOL(iwl_set_flags_for_band);
926 927 928 929

/*
 * initialize rxon structure with default values from eeprom
 */
930
void iwl_connection_init_rx_config(struct iwl_priv *priv,
931
				   struct iwl_rxon_context *ctx)
932 933 934
{
	const struct iwl_channel_info *ch_info;

935
	memset(&ctx->staging, 0, sizeof(ctx->staging));
936

937 938 939
	if (!ctx->vif) {
		ctx->staging.dev_type = ctx->unused_devtype;
	} else switch (ctx->vif->type) {
940
	case NL80211_IFTYPE_AP:
941
		ctx->staging.dev_type = ctx->ap_devtype;
942 943 944
		break;

	case NL80211_IFTYPE_STATION:
945
		ctx->staging.dev_type = ctx->station_devtype;
946
		ctx->staging.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
947 948 949
		break;

	case NL80211_IFTYPE_ADHOC:
950
		ctx->staging.dev_type = ctx->ibss_devtype;
951 952
		ctx->staging.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
		ctx->staging.filter_flags = RXON_FILTER_BCON_AWARE_MSK |
953 954 955 956
						  RXON_FILTER_ACCEPT_GRP_MSK;
		break;

	default:
957 958
		IWL_ERR(priv, "Unsupported interface type %d\n",
			ctx->vif->type);
959 960 961 962 963 964 965
		break;
	}

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

	ch_info = iwl_get_channel_info(priv, priv->band,
972
				       le16_to_cpu(ctx->active.channel));
973 974 975 976

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

977
	ctx->staging.channel = cpu_to_le16(ch_info->channel);
978 979
	priv->band = ch_info->band;

980
	iwl_set_flags_for_band(priv, ctx, priv->band, ctx->vif);
981

982
	ctx->staging.ofdm_basic_rates =
983
	    (IWL_OFDM_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
984
	ctx->staging.cck_basic_rates =
985 986
	    (IWL_CCK_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;

987
	/* clear both MIX and PURE40 mode flag */
988
	ctx->staging.flags &= ~(RXON_FLG_CHANNEL_MODE_MIXED |
989
					RXON_FLG_CHANNEL_MODE_PURE_40);
990 991
	if (ctx->vif)
		memcpy(ctx->staging.node_addr, ctx->vif->addr, ETH_ALEN);
992

993 994 995
	ctx->staging.ofdm_ht_single_stream_basic_rates = 0xff;
	ctx->staging.ofdm_ht_dual_stream_basic_rates = 0xff;
	ctx->staging.ofdm_ht_triple_stream_basic_rates = 0xff;
996 997 998
}
EXPORT_SYMBOL(iwl_connection_init_rx_config);

999
void iwl_set_rate(struct iwl_priv *priv)
1000 1001 1002
{
	const struct ieee80211_supported_band *hw = NULL;
	struct ieee80211_rate *rate;
1003
	struct iwl_rxon_context *ctx;
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
	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]);
1016
		if (rate->hw_value < IWL_RATE_COUNT_LEGACY)
1017 1018 1019
			priv->active_rate |= (1 << rate->hw_value);
	}

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

1022 1023 1024
	for_each_context(priv, ctx) {
		ctx->staging.cck_basic_rates =
		    (IWL_CCK_BASIC_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
1025

1026 1027 1028
		ctx->staging.ofdm_basic_rates =
		   (IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
	}
1029
}
1030 1031 1032 1033
EXPORT_SYMBOL(iwl_set_rate);

void iwl_chswitch_done(struct iwl_priv *priv, bool is_success)
{
1034 1035 1036 1037 1038 1039
	/*
	 * MULTI-FIXME
	 * See iwl_mac_channel_switch.
	 */
	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];

1040 1041 1042 1043
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
		return;

	if (priv->switch_rxon.switch_in_progress) {
1044
		ieee80211_chswitch_done(ctx->vif, is_success);
1045 1046 1047 1048 1049 1050
		mutex_lock(&priv->mutex);
		priv->switch_rxon.switch_in_progress = false;
		mutex_unlock(&priv->mutex);
	}
}
EXPORT_SYMBOL(iwl_chswitch_done);
1051 1052 1053

void iwl_rx_csa(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
{
Z
Zhu Yi 已提交
1054
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
1055
	struct iwl_csa_notification *csa = &(pkt->u.csa_notif);
1056 1057 1058 1059
	/*
	 * MULTI-FIXME
	 * See iwl_mac_channel_switch.
	 */
1060 1061
	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
	struct iwl_rxon_cmd *rxon = (void *)&ctx->active;
1062

W
Wey-Yi Guy 已提交
1063 1064 1065 1066
	if (priv->switch_rxon.switch_in_progress) {
		if (!le32_to_cpu(csa->status) &&
		    (csa->channel == priv->switch_rxon.channel)) {
			rxon->channel = csa->channel;
1067
			ctx->staging.channel = csa->channel;
W
Wey-Yi Guy 已提交
1068 1069
			IWL_DEBUG_11H(priv, "CSA notif: channel %d\n",
			      le16_to_cpu(csa->channel));
1070 1071
			iwl_chswitch_done(priv, true);
		} else {
W
Wey-Yi Guy 已提交
1072 1073
			IWL_ERR(priv, "CSA notif (fail) : channel %d\n",
			      le16_to_cpu(csa->channel));
1074 1075
			iwl_chswitch_done(priv, false);
		}
W
Wey-Yi Guy 已提交
1076
	}
1077 1078 1079 1080
}
EXPORT_SYMBOL(iwl_rx_csa);

#ifdef CONFIG_IWLWIFI_DEBUG
1081 1082
void iwl_print_rx_config_cmd(struct iwl_priv *priv,
			     struct iwl_rxon_context *ctx)
1083
{
1084
	struct iwl_rxon_cmd *rxon = &ctx->staging;
1085

1086
	IWL_DEBUG_RADIO(priv, "RX CONFIG:\n");
1087
	iwl_print_hex_dump(priv, IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
1088 1089 1090
	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",
1091
			le32_to_cpu(rxon->filter_flags));
1092 1093
	IWL_DEBUG_RADIO(priv, "u8 dev_type: 0x%x\n", rxon->dev_type);
	IWL_DEBUG_RADIO(priv, "u8 ofdm_basic_rates: 0x%02x\n",
1094
			rxon->ofdm_basic_rates);
1095 1096 1097 1098
	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));
1099
}
1100
EXPORT_SYMBOL(iwl_print_rx_config_cmd);
1101
#endif
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
/**
 * 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);

1113 1114 1115
	IWL_ERR(priv, "Loaded firmware version: %s\n",
		priv->hw->wiphy->fw_version);

1116
	priv->cfg->ops->lib->dump_nic_error_log(priv);
1117 1118
	if (priv->cfg->ops->lib->dump_csr)
		priv->cfg->ops->lib->dump_csr(priv);
1119 1120
	if (priv->cfg->ops->lib->dump_fh)
		priv->cfg->ops->lib->dump_fh(priv, NULL, false);
W
Wey-Yi Guy 已提交
1121
	priv->cfg->ops->lib->dump_nic_event_log(priv, false, NULL, false);
1122
#ifdef CONFIG_IWLWIFI_DEBUG
1123
	if (iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS)
1124 1125
		iwl_print_rx_config_cmd(priv,
					&priv->contexts[IWL_RXON_CTX_BSS]);
1126 1127 1128 1129 1130 1131 1132 1133 1134
#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)) {
1135
		IWL_DEBUG(priv, IWL_DL_FW_ERRORS,
1136 1137 1138 1139 1140 1141 1142 1143
			  "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);

1144
static int iwl_apm_stop_master(struct iwl_priv *priv)
1145
{
1146
	int ret = 0;
1147

1148
	/* stop device's busmaster DMA activity */
1149 1150
	iwl_set_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_STOP_MASTER);

1151
	ret = iwl_poll_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_MASTER_DISABLED,
1152
			CSR_RESET_REG_FLAG_MASTER_DISABLED, 100);
1153 1154
	if (ret)
		IWL_WARN(priv, "Master Disable Timed Out, 100 usec\n");
1155 1156 1157

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

1158
	return ret;
1159 1160 1161 1162
}

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

1165
	/* Stop device's DMA activity */
1166 1167
	iwl_apm_stop_master(priv);

1168
	/* Reset the entire device */
1169 1170 1171
	iwl_set_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_SW_RESET);

	udelay(10);
1172 1173 1174 1175 1176

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

1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221

/*
 * 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);

	/*
1222 1223 1224 1225 1226 1227
	 * 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.
1228
	 */
1229
	if (priv->cfg->base_params->set_l0s) {
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
		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 */
1246 1247 1248
	if (priv->cfg->base_params->pll_cfg_val)
		iwl_set_bit(priv, CSR_ANA_PLL_CFG,
			    priv->cfg->base_params->pll_cfg_val);
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278

	/*
	 * 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.
	 */
1279
	if (priv->cfg->base_params->use_bsm)
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
		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);


1297 1298 1299
int iwl_set_tx_power(struct iwl_priv *priv, s8 tx_power, bool force)
{
	int ret = 0;
1300 1301
	s8 prev_tx_power = priv->tx_power_user_lmt;

1302 1303 1304
	if (tx_power < IWLAGN_TX_POWER_TARGET_POWER_MIN) {
		IWL_WARN(priv,
			 "Requested user TXPOWER %d below lower limit %d.\n",
1305
			 tx_power,
1306
			 IWLAGN_TX_POWER_TARGET_POWER_MIN);
1307 1308 1309
		return -EINVAL;
	}

1310
	if (tx_power > priv->tx_power_device_lmt) {
1311 1312
		IWL_WARN(priv,
			"Requested user TXPOWER %d above upper limit %d.\n",
1313
			 tx_power, priv->tx_power_device_lmt);
1314 1315 1316 1317 1318 1319
		return -EINVAL;
	}

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

1320
	/* if nic is not up don't send command */
1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332
	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;
	}
1333

1334 1335 1336 1337 1338 1339 1340
	/*
	 * 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
	 */
1341 1342 1343 1344
	return ret;
}
EXPORT_SYMBOL(iwl_set_tx_power);

M
Mohamed Abbas 已提交
1345
irqreturn_t iwl_isr_legacy(int irq, void *data)
A
Abhijeet Kolekar 已提交
1346 1347 1348 1349
{
	struct iwl_priv *priv = data;
	u32 inta, inta_mask;
	u32 inta_fh;
1350
	unsigned long flags;
A
Abhijeet Kolekar 已提交
1351 1352 1353
	if (!priv)
		return IRQ_NONE;

1354
	spin_lock_irqsave(&priv->lock, flags);
A
Abhijeet Kolekar 已提交
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391

	/* 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:
1392
	spin_unlock_irqrestore(&priv->lock, flags);
A
Abhijeet Kolekar 已提交
1393 1394 1395 1396 1397 1398 1399
	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);
1400
	spin_unlock_irqrestore(&priv->lock, flags);
A
Abhijeet Kolekar 已提交
1401 1402
	return IRQ_NONE;
}
M
Mohamed Abbas 已提交
1403
EXPORT_SYMBOL(iwl_isr_legacy);
A
Abhijeet Kolekar 已提交
1404

1405
void iwl_send_bt_config(struct iwl_priv *priv)
1406 1407
{
	struct iwl_bt_cmd bt_cmd = {
1408 1409
		.lead_time = BT_LEAD_TIME_DEF,
		.max_kill = BT_MAX_KILL_DEF,
1410 1411 1412 1413
		.kill_ack_mask = 0,
		.kill_cts_mask = 0,
	};

1414 1415 1416 1417 1418 1419 1420 1421
	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");

1422 1423 1424
	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");
1425 1426 1427
}
EXPORT_SYMBOL(iwl_send_bt_config);

1428
int iwl_send_statistics_request(struct iwl_priv *priv, u8 flags, bool clear)
1429
{
1430 1431 1432
	struct iwl_statistics_cmd statistics_cmd = {
		.configuration_flags =
			clear ? IWL_STATS_CONF_CLEAR_STATS : 0,
1433
	};
1434 1435 1436 1437 1438 1439 1440 1441 1442

	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);
1443 1444
}
EXPORT_SYMBOL(iwl_send_statistics_request);
1445

A
Abhijeet Kolekar 已提交
1446 1447 1448 1449
void iwl_rx_pm_sleep_notif(struct iwl_priv *priv,
			   struct iwl_rx_mem_buffer *rxb)
{
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1450
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
A
Abhijeet Kolekar 已提交
1451 1452 1453 1454 1455 1456 1457 1458 1459 1460
	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 已提交
1461
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
1462
	u32 len = le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
A
Abhijeet Kolekar 已提交
1463
	IWL_DEBUG_RADIO(priv, "Dumping %d bytes of unhandled "
1464 1465 1466
			"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 已提交
1467 1468
}
EXPORT_SYMBOL(iwl_rx_pm_debug_statistics_notif);
1469 1470 1471 1472

void iwl_rx_reply_error(struct iwl_priv *priv,
			struct iwl_rx_mem_buffer *rxb)
{
Z
Zhu Yi 已提交
1473
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484

	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);

1485 1486 1487 1488 1489
void iwl_clear_isr_stats(struct iwl_priv *priv)
{
	memset(&priv->isr_stats, 0, sizeof(priv->isr_stats));
}

A
Abhijeet Kolekar 已提交
1490 1491 1492 1493
int iwl_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
			   const struct ieee80211_tx_queue_params *params)
{
	struct iwl_priv *priv = hw->priv;
J
Johannes Berg 已提交
1494
	struct iwl_rxon_context *ctx;
A
Abhijeet Kolekar 已提交
1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513
	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);

J
Johannes Berg 已提交
1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
	/*
	 * MULTI-FIXME
	 * This may need to be done per interface in nl80211/cfg80211/mac80211.
	 */
	for_each_context(priv, ctx) {
		ctx->qos_data.def_qos_parm.ac[q].cw_min =
			cpu_to_le16(params->cw_min);
		ctx->qos_data.def_qos_parm.ac[q].cw_max =
			cpu_to_le16(params->cw_max);
		ctx->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
		ctx->qos_data.def_qos_parm.ac[q].edca_txop =
				cpu_to_le16((params->txop * 32));

		ctx->qos_data.def_qos_parm.ac[q].reserved1 = 0;
	}
A
Abhijeet Kolekar 已提交
1529 1530 1531 1532 1533 1534 1535

	spin_unlock_irqrestore(&priv->lock, flags);

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

1537 1538 1539 1540 1541 1542 1543 1544
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);

1545
static void iwl_ht_conf(struct iwl_priv *priv,
J
Johannes Berg 已提交
1546
			struct ieee80211_vif *vif)
1547
{
J
Johannes Berg 已提交
1548
	struct iwl_ht_config *ht_conf = &priv->current_ht_config;
1549
	struct ieee80211_sta *sta;
J
Johannes Berg 已提交
1550
	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1551
	struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
1552

1553
	IWL_DEBUG_MAC80211(priv, "enter:\n");
1554

1555
	if (!ctx->ht.enabled)
1556 1557
		return;

1558
	ctx->ht.protection =
1559
		bss_conf->ht_operation_mode & IEEE80211_HT_OP_MODE_PROTECTION;
1560
	ctx->ht.non_gf_sta_present =
1561
		!!(bss_conf->ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
1562

1563 1564
	ht_conf->single_chain_sufficient = false;

J
Johannes Berg 已提交
1565
	switch (vif->type) {
1566 1567
	case NL80211_IFTYPE_STATION:
		rcu_read_lock();
J
Johannes Berg 已提交
1568
		sta = ieee80211_find_sta(vif, bss_conf->bssid);
1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599
		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;
	}
1600 1601 1602 1603

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

1604 1605
static inline void iwl_set_no_assoc(struct iwl_priv *priv,
				    struct ieee80211_vif *vif)
1606
{
1607 1608
	struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);

1609 1610 1611 1612 1613 1614
	iwl_led_disassociate(priv);
	/*
	 * inform the ucode that there is no longer an
	 * association and that no more packets should be
	 * sent
	 */
1615 1616 1617
	ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	ctx->staging.assoc_id = 0;
	iwlcore_commit_rxon(priv, ctx);
1618 1619
}

1620 1621 1622 1623 1624 1625 1626 1627
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");

1628 1629 1630 1631 1632 1633 1634 1635
	lockdep_assert_held(&priv->mutex);

	if (!priv->beacon_ctx) {
		IWL_ERR(priv, "update beacon but no beacon context!\n");
		dev_kfree_skb(skb);
		return -EINVAL;
	}

1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653
	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);

1654
	priv->cfg->ops->lib->post_associate(priv, priv->beacon_ctx->vif);
1655 1656 1657 1658

	return 0;
}

1659
void iwl_bss_info_changed(struct ieee80211_hw *hw,
1660 1661 1662
			  struct ieee80211_vif *vif,
			  struct ieee80211_bss_conf *bss_conf,
			  u32 changes)
1663 1664
{
	struct iwl_priv *priv = hw->priv;
1665
	struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
1666
	int ret;
1667 1668 1669

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

1670 1671 1672 1673 1674
	if (!iwl_is_alive(priv))
		return;

	mutex_lock(&priv->mutex);

1675 1676 1677 1678
	if (changes & BSS_CHANGED_QOS) {
		unsigned long flags;

		spin_lock_irqsave(&priv->lock, flags);
J
Johannes Berg 已提交
1679 1680
		ctx->qos_data.qos_active = bss_conf->qos;
		iwl_update_qos(priv, ctx);
1681 1682 1683
		spin_unlock_irqrestore(&priv->lock, flags);
	}

1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695
	if (changes & BSS_CHANGED_BEACON_ENABLED) {
		/*
		 * the add_interface code must make sure we only ever
		 * have a single interface that could be beaconing at
		 * any time.
		 */
		if (vif->bss_conf.enable_beacon)
			priv->beacon_ctx = ctx;
		else
			priv->beacon_ctx = NULL;
	}

1696
	if (changes & BSS_CHANGED_BEACON && vif->type == NL80211_IFTYPE_AP) {
1697 1698 1699 1700
		dev_kfree_skb(priv->ibss_beacon);
		priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
	}

1701 1702
	if (changes & BSS_CHANGED_BEACON_INT && vif->type == NL80211_IFTYPE_AP)
		iwl_send_rxon_timing(priv, ctx);
J
Johannes Berg 已提交
1703 1704 1705 1706 1707 1708 1709 1710 1711

	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.
		 */
1712
		if (iwl_scan_cancel_timeout(priv, 100)) {
J
Johannes Berg 已提交
1713
			IWL_WARN(priv, "Aborted scan still in progress after 100ms\n");
1714 1715 1716 1717 1718
			IWL_DEBUG_MAC80211(priv, "leaving - scan abort failed.\n");
			mutex_unlock(&priv->mutex);
			return;
		}

J
Johannes Berg 已提交
1719
		/* mac80211 only sets assoc when in STATION mode */
1720
		if (vif->type == NL80211_IFTYPE_ADHOC || bss_conf->assoc) {
1721
			memcpy(ctx->staging.bssid_addr,
J
Johannes Berg 已提交
1722
			       bss_conf->bssid, ETH_ALEN);
1723

J
Johannes Berg 已提交
1724 1725 1726
			/* currently needed in a few places */
			memcpy(priv->bssid, bss_conf->bssid, ETH_ALEN);
		} else {
1727
			ctx->staging.filter_flags &=
J
Johannes Berg 已提交
1728
				~RXON_FILTER_ASSOC_MSK;
1729
		}
J
Johannes Berg 已提交
1730

1731 1732
	}

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

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

1746 1747 1748 1749
	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)
1750
			ctx->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
1751
		else
1752
			ctx->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
1753 1754 1755 1756 1757
	}

	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))
1758
			ctx->staging.flags |= RXON_FLG_TGG_PROTECT_MSK;
1759
		else
1760
			ctx->staging.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
J
Johannes Berg 已提交
1761
		if (bss_conf->use_cts_prot)
1762
			ctx->staging.flags |= RXON_FLG_SELF_CTS_EN;
J
Johannes Berg 已提交
1763
		else
1764
			ctx->staging.flags &= ~RXON_FLG_SELF_CTS_EN;
1765 1766
	}

J
Johannes Berg 已提交
1767 1768 1769 1770 1771 1772 1773
	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)
1774
			ctx->staging.ofdm_basic_rates =
J
Johannes Berg 已提交
1775 1776
				bss_conf->basic_rates;
		else
1777
			ctx->staging.ofdm_basic_rates =
J
Johannes Berg 已提交
1778
				bss_conf->basic_rates >> 4;
1779
			ctx->staging.cck_basic_rates =
J
Johannes Berg 已提交
1780 1781 1782 1783
				bss_conf->basic_rates & 0xF;
		 */
	}

1784
	if (changes & BSS_CHANGED_HT) {
J
Johannes Berg 已提交
1785
		iwl_ht_conf(priv, vif);
1786 1787

		if (priv->cfg->ops->hcmd->set_rxon_chain)
1788
			priv->cfg->ops->hcmd->set_rxon_chain(priv, ctx);
1789 1790 1791 1792 1793 1794 1795
	}

	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 已提交
1796 1797
			iwl_led_associate(priv);

J
Johannes Berg 已提交
1798
			if (!iwl_is_rfkill(priv))
1799
				priv->cfg->ops->lib->post_associate(priv, vif);
1800
		} else
1801
			iwl_set_no_assoc(priv, vif);
J
Johannes Berg 已提交
1802 1803
	}

1804
	if (changes && iwl_is_associated_ctx(ctx) && bss_conf->aid) {
J
Johannes Berg 已提交
1805 1806
		IWL_DEBUG_MAC80211(priv, "Changes (%#x) while associated\n",
				   changes);
1807
		ret = iwl_send_rxon_assoc(priv, ctx);
J
Johannes Berg 已提交
1808 1809
		if (!ret) {
			/* Sync active_rxon with latest change. */
1810 1811
			memcpy((void *)&ctx->active,
				&ctx->staging,
J
Johannes Berg 已提交
1812
				sizeof(struct iwl_rxon_cmd));
1813 1814
		}
	}
J
Johannes Berg 已提交
1815

1816 1817
	if (changes & BSS_CHANGED_BEACON_ENABLED) {
		if (vif->bss_conf.enable_beacon) {
1818
			memcpy(ctx->staging.bssid_addr,
1819 1820
			       bss_conf->bssid, ETH_ALEN);
			memcpy(priv->bssid, bss_conf->bssid, ETH_ALEN);
1821
			iwlcore_config_ap(priv, vif);
1822
		} else
1823
			iwl_set_no_assoc(priv, vif);
1824 1825
	}

1826 1827 1828 1829 1830 1831 1832 1833 1834
	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 已提交
1835 1836 1837 1838 1839 1840
	if (changes & BSS_CHANGED_IDLE &&
	    priv->cfg->ops->hcmd->set_pan_params) {
		if (priv->cfg->ops->hcmd->set_pan_params(priv))
			IWL_ERR(priv, "failed to update PAN params\n");
	}

J
Johannes Berg 已提交
1841 1842
	mutex_unlock(&priv->mutex);

1843
	IWL_DEBUG_MAC80211(priv, "leave\n");
1844 1845 1846
}
EXPORT_SYMBOL(iwl_bss_info_changed);

1847
static int iwl_set_mode(struct iwl_priv *priv, struct ieee80211_vif *vif)
1848
{
1849 1850
	struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);

1851
	iwl_connection_init_rx_config(priv, ctx);
1852 1853

	if (priv->cfg->ops->hcmd->set_rxon_chain)
1854
		priv->cfg->ops->hcmd->set_rxon_chain(priv, ctx);
1855

1856
	return iwlcore_commit_rxon(priv, ctx);
1857 1858
}

1859
int iwl_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1860 1861
{
	struct iwl_priv *priv = hw->priv;
1862
	struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
1863
	struct iwl_rxon_context *tmp, *ctx = NULL;
1864
	int err = 0;
1865

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

1869 1870
	mutex_lock(&priv->mutex);

1871 1872
	if (!iwl_is_ready_rf(priv)) {
		IWL_WARN(priv, "Try to add interface when device not ready\n");
1873 1874 1875 1876
		err = -EINVAL;
		goto out;
	}

1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899
	for_each_context(priv, tmp) {
		u32 possible_modes =
			tmp->interface_modes | tmp->exclusive_interface_modes;

		if (tmp->vif) {
			/* check if this busy context is exclusive */
			if (tmp->exclusive_interface_modes &
						BIT(tmp->vif->type)) {
				err = -EINVAL;
				goto out;
			}
			continue;
		}

		if (!(possible_modes & BIT(vif->type)))
			continue;

		/* have maybe usable context w/o interface */
		ctx = tmp;
		break;
	}

	if (!ctx) {
1900 1901
		err = -EOPNOTSUPP;
		goto out;
1902 1903
	}

1904
	vif_priv->ctx = ctx;
1905
	ctx->vif = vif;
1906 1907 1908 1909 1910
	/*
	 * This variable will be correct only when there's just
	 * a single context, but all code using it is for hardware
	 * that supports only one context.
	 */
1911
	priv->iw_mode = vif->type;
1912

1913 1914
	ctx->is_active = true;

1915
	err = iwl_set_mode(priv, vif);
1916 1917 1918
	if (err) {
		if (!ctx->always_active)
			ctx->is_active = false;
1919
		goto out_err;
1920
	}
1921

1922 1923
	if (priv->cfg->bt_params &&
	    priv->cfg->bt_params->advanced_bt_coexist &&
1924 1925 1926 1927 1928 1929 1930 1931 1932
	    vif->type == NL80211_IFTYPE_ADHOC) {
		/*
		 * pretend to have high BT traffic as long as we
		 * are operating in IBSS mode, as this will cause
		 * the rate scaling etc. to behave as intended.
		 */
		priv->bt_traffic_load = IWL_BT_COEX_TRAFFIC_LOAD_HIGH;
	}

1933
	goto out;
1934

1935
 out_err:
1936
	ctx->vif = NULL;
1937
	priv->iw_mode = NL80211_IFTYPE_STATION;
1938
 out:
1939 1940 1941
	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211(priv, "leave\n");
1942
	return err;
1943 1944 1945
}
EXPORT_SYMBOL(iwl_mac_add_interface);

1946
void iwl_mac_remove_interface(struct ieee80211_hw *hw,
1947
			      struct ieee80211_vif *vif)
1948 1949
{
	struct iwl_priv *priv = hw->priv;
1950
	struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
1951 1952 1953 1954 1955

	IWL_DEBUG_MAC80211(priv, "enter\n");

	mutex_lock(&priv->mutex);

1956 1957 1958
	WARN_ON(ctx->vif != vif);
	ctx->vif = NULL;

1959 1960 1961 1962
	if (priv->scan_vif == vif) {
		iwl_scan_cancel_timeout(priv, 200);
		iwl_force_scan_end(priv);
	}
1963
	iwl_set_mode(priv, vif);
1964

1965 1966 1967
	if (!ctx->always_active)
		ctx->is_active = false;

1968 1969 1970 1971 1972 1973 1974 1975 1976 1977
	/*
	 * When removing the IBSS interface, overwrite the
	 * BT traffic load with the stored one from the last
	 * notification, if any. If this is a device that
	 * doesn't implement this, this has no effect since
	 * both values are the same and zero.
	 */
	if (vif->type == NL80211_IFTYPE_ADHOC)
		priv->bt_traffic_load = priv->notif_bt_traffic_load;

1978
	memset(priv->bssid, 0, ETH_ALEN);
1979 1980 1981 1982 1983 1984 1985
	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211(priv, "leave\n");

}
EXPORT_SYMBOL(iwl_mac_remove_interface);

1986 1987 1988 1989 1990 1991 1992 1993
/**
 * 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;
1994
	struct ieee80211_channel *channel = conf->channel;
J
Johannes Berg 已提交
1995
	struct iwl_ht_config *ht_conf = &priv->current_ht_config;
1996
	struct iwl_rxon_context *ctx;
1997 1998 1999 2000 2001 2002 2003 2004
	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",
2005
					channel->hw_value, changed);
2006 2007 2008 2009 2010 2011 2012

	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 已提交
2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
	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)
2026 2027
			for_each_context(priv, ctx)
				priv->cfg->ops->hcmd->set_rxon_chain(priv, ctx);
J
Johannes Berg 已提交
2028
	}
2029 2030 2031 2032 2033 2034 2035 2036

	/* 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;

2037 2038
		ch = channel->hw_value;
		ch_info = iwl_get_channel_info(priv, channel->band, ch);
2039 2040 2041 2042 2043 2044 2045 2046
		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);

2047
		for_each_context(priv, ctx) {
2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072
			/* Configure HT40 channels */
			ctx->ht.enabled = conf_is_ht(conf);
			if (ctx->ht.enabled) {
				if (conf_is_ht40_minus(conf)) {
					ctx->ht.extension_chan_offset =
						IEEE80211_HT_PARAM_CHA_SEC_BELOW;
					ctx->ht.is_40mhz = true;
				} else if (conf_is_ht40_plus(conf)) {
					ctx->ht.extension_chan_offset =
						IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
					ctx->ht.is_40mhz = true;
				} else {
					ctx->ht.extension_chan_offset =
						IEEE80211_HT_PARAM_CHA_SEC_NONE;
					ctx->ht.is_40mhz = false;
				}
			} else
				ctx->ht.is_40mhz = false;

			/*
			 * Default to no protection. Protection mode will
			 * later be set from BSS config in iwl_ht_conf
			 */
			ctx->ht.protection = IEEE80211_HT_OP_MODE_PROTECTION_NONE;

2073 2074 2075 2076 2077
			/* if we are switching from ht to 2.4 clear flags
			 * from any ht related info since 2.4 does not
			 * support ht */
			if ((le16_to_cpu(ctx->staging.channel) != ch))
				ctx->staging.flags = 0;
2078

2079 2080 2081 2082
			iwl_set_rxon_channel(priv, channel, ctx);
			iwl_set_rxon_ht(priv, ht_conf);

			iwl_set_flags_for_band(priv, ctx, channel->band,
2083
					       ctx->vif);
2084
		}
2085 2086

		spin_unlock_irqrestore(&priv->lock, flags);
2087

2088 2089
		if (priv->cfg->ops->lib->update_bcast_stations)
			ret = priv->cfg->ops->lib->update_bcast_stations(priv);
2090

2091 2092 2093 2094 2095 2096 2097
 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);
	}

2098 2099
	if (changed & (IEEE80211_CONF_CHANGE_PS |
			IEEE80211_CONF_CHANGE_IDLE)) {
2100
		ret = iwl_power_update_mode(priv, false);
2101
		if (ret)
2102
			IWL_DEBUG_MAC80211(priv, "Error setting sleep level\n");
2103 2104 2105 2106 2107 2108 2109 2110 2111
	}

	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);
	}

2112 2113 2114 2115 2116
	if (!iwl_is_ready(priv)) {
		IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
		goto out;
	}

2117 2118 2119
	if (scan_active)
		goto out;

2120 2121 2122 2123 2124 2125 2126
	for_each_context(priv, ctx) {
		if (memcmp(&ctx->active, &ctx->staging, sizeof(ctx->staging)))
			iwlcore_commit_rxon(priv, ctx);
		else
			IWL_DEBUG_INFO(priv,
				"Not re-sending same RXON configuration.\n");
	}
2127 2128 2129 2130 2131 2132 2133 2134

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

2135 2136 2137 2138
void iwl_mac_reset_tsf(struct ieee80211_hw *hw)
{
	struct iwl_priv *priv = hw->priv;
	unsigned long flags;
2139 2140
	/* IBSS can only be the IWL_RXON_CTX_BSS context */
	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
2141 2142 2143 2144 2145

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

	spin_lock_irqsave(&priv->lock, flags);
J
Johannes Berg 已提交
2146
	memset(&priv->current_ht_config, 0, sizeof(struct iwl_ht_config));
2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160
	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);

2161
	iwl_scan_cancel_timeout(priv, 100);
2162 2163 2164 2165 2166 2167 2168 2169 2170
	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
	 */
2171 2172
	ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	iwlcore_commit_rxon(priv, ctx);
2173 2174 2175 2176 2177 2178 2179 2180 2181

	iwl_set_rate(priv);

	mutex_unlock(&priv->mutex);

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

2182 2183 2184 2185
int iwl_alloc_txq_mem(struct iwl_priv *priv)
{
	if (!priv->txq)
		priv->txq = kzalloc(
2186 2187
			sizeof(struct iwl_tx_queue) *
				priv->cfg->base_params->num_of_queues,
2188 2189
			GFP_KERNEL);
	if (!priv->txq) {
2190
		IWL_ERR(priv, "Not enough memory for txq\n");
2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203
		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);

2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 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 2261 2262 2263 2264 2265 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
#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);
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

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";

	}
}

2341
void iwl_clear_traffic_stats(struct iwl_priv *priv)
2342 2343 2344
{
	memset(&priv->tx_stats, 0, sizeof(struct traffic_stats));
	memset(&priv->rx_stats, 0, sizeof(struct traffic_stats));
2345
	priv->led_tpt = 0;
2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 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 2434 2435 2436 2437
}

/*
 * 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;
	}
2438
	iwl_leds_background(priv);
2439 2440
}
EXPORT_SYMBOL(iwl_update_stats);
2441 2442
#endif

2443
static const char *get_csr_string(int cmd)
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 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513
{
	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);

2514
static const char *get_fh_string(int cmd)
2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576
{
	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 已提交
2577
static void iwl_force_rf_reset(struct iwl_priv *priv)
2578 2579 2580 2581
{
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
		return;

2582
	if (!iwl_is_any_associated(priv)) {
2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597
		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 已提交
2598 2599


2600
int iwl_force_reset(struct iwl_priv *priv, int mode, bool external)
W
Wey-Yi Guy 已提交
2601
{
2602 2603
	struct iwl_force_reset *force_reset;

W
Wey-Yi Guy 已提交
2604 2605 2606
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
		return -EINVAL;

2607 2608 2609 2610 2611 2612
	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++;
2613 2614 2615 2616 2617 2618 2619 2620
	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 已提交
2621
	}
2622 2623
	force_reset->reset_success_count++;
	force_reset->last_force_reset_jiffies = jiffies;
W
Wey-Yi Guy 已提交
2624 2625 2626 2627 2628 2629
	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:
2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642
		/*
		 * 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 已提交
2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656
		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;
}
2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692
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 */
2693 2694 2695 2696 2697 2698 2699 2700 2701
	if (q->read_ptr == q->write_ptr)
		return 0;

	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);
2702
			q->repeat_same_read_ptr = 0;
2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716
			iwl_force_reset(priv, IWL_FW_RESET, false);
		} else {
			q->repeat_same_read_ptr++;
			IWL_DEBUG_RADIO(priv,
					"queue %d, not read %d time\n",
					q->id,
					q->repeat_same_read_ptr);
			if (priv->cfg->bt_params &&
			    !priv->cfg->bt_params->advanced_bt_coexist) {
				mod_timer(&priv->monitor_recover,
					jiffies + msecs_to_jiffies(
					IWL_ONE_HUNDRED_MSECS));
				return 1;
			}
2717
		}
2718 2719 2720
	} else {
		q->last_read_ptr = q->read_ptr;
		q->repeat_same_read_ptr = 0;
2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733
	}
	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 */
2734
	if (iwl_check_stuck_queue(priv, priv->cmd_queue))
2735 2736 2737
		return;

	/* monitor and check for other stuck queues */
2738
	if (iwl_is_any_associated(priv)) {
2739 2740
		for (cnt = 0; cnt < priv->hw_params.max_txq_num; cnt++) {
			/* skip as we already checked the command queue */
2741
			if (cnt == priv->cmd_queue)
2742 2743 2744 2745 2746
				continue;
			if (iwl_check_stuck_queue(priv, cnt))
				return;
		}
	}
2747
	if (priv->cfg->base_params->monitor_recover_period) {
2748 2749
		/*
		 * Reschedule the timer to occur in
2750
		 * priv->cfg->base_params->monitor_recover_period
2751 2752
		 */
		mod_timer(&priv->monitor_recover, jiffies + msecs_to_jiffies(
2753
			  priv->cfg->base_params->monitor_recover_period));
2754
	}
2755 2756
}
EXPORT_SYMBOL(iwl_bg_monitor_recover);
2757

2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812

/*
 * 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);

2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839
#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;
2840
	bool hw_rfkill = false;
2841

2842 2843 2844 2845 2846 2847
	/*
	 * 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);

2848 2849 2850 2851 2852 2853 2854
	pci_set_power_state(pdev, PCI_D0);
	ret = pci_enable_device(pdev);
	if (ret)
		return ret;
	pci_restore_state(pdev);
	iwl_enable_interrupts(priv);

2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865
	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);

2866 2867 2868 2869 2870
	return 0;
}
EXPORT_SYMBOL(iwl_pci_resume);

#endif /* CONFIG_PM */