iwl3945-base.c 146.3 KB
Newer Older
Z
Zhu Yi 已提交
1 2
/******************************************************************************
 *
3
 * Copyright(c) 2003 - 2009 Intel Corporation. All rights reserved.
Z
Zhu Yi 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * Portions of this file are derived from the ipw3945 project, as well
 * as portions of the ieee80211 subsystem header files.
 *
 * 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.
 *
 * Contact Information:
25
 *  Intel Linux Wireless <ilw@linux.intel.com>
Z
Zhu Yi 已提交
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/dma-mapping.h>
#include <linux/delay.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/wireless.h>
#include <linux/firmware.h>
#include <linux/etherdevice.h>
#include <linux/if_arp.h>

#include <net/ieee80211_radiotap.h>
44
#include <net/lib80211.h>
Z
Zhu Yi 已提交
45 46 47 48
#include <net/mac80211.h>

#include <asm/div64.h>

49 50
#define DRV_NAME	"iwl3945"

W
Winkler, Tomas 已提交
51 52
#include "iwl-fh.h"
#include "iwl-3945-fh.h"
53
#include "iwl-commands.h"
54
#include "iwl-sta.h"
Z
Zhu Yi 已提交
55 56
#include "iwl-3945.h"
#include "iwl-helpers.h"
K
Kolekar, Abhijeet 已提交
57
#include "iwl-core.h"
58
#include "iwl-dev.h"
Z
Zhu Yi 已提交
59 60 61 62 63 64 65 66

/*
 * module name, copyright, version, etc.
 */

#define DRV_DESCRIPTION	\
"Intel(R) PRO/Wireless 3945ABG/BG Network Connection driver for Linux"

S
Samuel Ortiz 已提交
67
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
68 69 70 71 72
#define VD "d"
#else
#define VD
#endif

73
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
74 75 76 77 78
#define VS "s"
#else
#define VS
#endif

79
#define IWL39_VERSION "1.2.26k" VD VS
80
#define DRV_COPYRIGHT	"Copyright(c) 2003-2009 Intel Corporation"
81
#define DRV_AUTHOR     "<ilw@linux.intel.com>"
82
#define DRV_VERSION     IWL39_VERSION
Z
Zhu Yi 已提交
83 84 85 86


MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_VERSION(DRV_VERSION);
87
MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
Z
Zhu Yi 已提交
88 89
MODULE_LICENSE("GPL");

90 91 92
 /* module parameters */
struct iwl_mod_params iwl3945_mod_params = {
	.num_of_queues = IWL39_MAX_NUM_QUEUES,
93
	.sw_crypto = 1,
94
	.restart_fw = 1,
95 96 97
	/* the rest are 0 by default */
};

Z
Zhu Yi 已提交
98
/*************** STATION TABLE MANAGEMENT ****
99
 * mac80211 should be examined to determine if sta_info is duplicating
Z
Zhu Yi 已提交
100 101 102 103
 * the functionality provided here
 */

/**************************************************************/
104
#if 0 /* temporary disable till we add real remove station */
105 106 107 108 109
/**
 * iwl3945_remove_station - Remove driver's knowledge of station.
 *
 * NOTE:  This does not remove station from device's station table.
 */
110
static u8 iwl3945_remove_station(struct iwl_priv *priv, const u8 *addr, int is_ap)
Z
Zhu Yi 已提交
111 112 113 114 115 116 117 118 119 120
{
	int index = IWL_INVALID_STATION;
	int i;
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);

	if (is_ap)
		index = IWL_AP_ID;
	else if (is_broadcast_ether_addr(addr))
121
		index = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
122
	else
123
		for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++)
124 125
			if (priv->stations_39[i].used &&
			    !compare_ether_addr(priv->stations_39[i].sta.sta.addr,
Z
Zhu Yi 已提交
126 127 128 129 130 131 132 133
						addr)) {
				index = i;
				break;
			}

	if (unlikely(index == IWL_INVALID_STATION))
		goto out;

134 135
	if (priv->stations_39[index].used) {
		priv->stations_39[index].used = 0;
Z
Zhu Yi 已提交
136 137 138 139 140 141 142 143 144
		priv->num_stations--;
	}

	BUG_ON(priv->num_stations < 0);

out:
	spin_unlock_irqrestore(&priv->sta_lock, flags);
	return 0;
}
145
#endif
146 147 148 149 150 151

/**
 * iwl3945_clear_stations_table - Clear the driver's station table
 *
 * NOTE:  This does not clear or otherwise alter the device's station table.
 */
152
static void iwl3945_clear_stations_table(struct iwl_priv *priv)
Z
Zhu Yi 已提交
153 154 155 156 157 158
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);

	priv->num_stations = 0;
159
	memset(priv->stations_39, 0, sizeof(priv->stations_39));
Z
Zhu Yi 已提交
160 161 162 163

	spin_unlock_irqrestore(&priv->sta_lock, flags);
}

164 165 166
/**
 * iwl3945_add_station - Add station to station tables in driver and device
 */
167
u8 iwl3945_add_station(struct iwl_priv *priv, const u8 *addr, int is_ap, u8 flags)
Z
Zhu Yi 已提交
168 169 170
{
	int i;
	int index = IWL_INVALID_STATION;
C
Christoph Hellwig 已提交
171
	struct iwl3945_station_entry *station;
Z
Zhu Yi 已提交
172
	unsigned long flags_spin;
173
	u8 rate;
Z
Zhu Yi 已提交
174 175 176 177 178

	spin_lock_irqsave(&priv->sta_lock, flags_spin);
	if (is_ap)
		index = IWL_AP_ID;
	else if (is_broadcast_ether_addr(addr))
179
		index = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
180
	else
181
		for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++) {
182
			if (!compare_ether_addr(priv->stations_39[i].sta.sta.addr,
Z
Zhu Yi 已提交
183 184 185 186 187
						addr)) {
				index = i;
				break;
			}

188
			if (!priv->stations_39[i].used &&
Z
Zhu Yi 已提交
189 190 191 192
			    index == IWL_INVALID_STATION)
				index = i;
		}

193
	/* These two conditions has the same outcome but keep them separate
Z
Zhu Yi 已提交
194 195 196 197 198 199
	  since they have different meaning */
	if (unlikely(index == IWL_INVALID_STATION)) {
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return index;
	}

200 201
	if (priv->stations_39[index].used &&
	   !compare_ether_addr(priv->stations_39[index].sta.sta.addr, addr)) {
Z
Zhu Yi 已提交
202 203 204 205
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return index;
	}

206
	IWL_DEBUG_ASSOC(priv, "Add STA ID %d: %pM\n", index, addr);
207
	station = &priv->stations_39[index];
Z
Zhu Yi 已提交
208 209 210
	station->used = 1;
	priv->num_stations++;

211
	/* Set up the REPLY_ADD_STA command to send to device */
C
Christoph Hellwig 已提交
212
	memset(&station->sta, 0, sizeof(struct iwl3945_addsta_cmd));
Z
Zhu Yi 已提交
213 214 215 216 217
	memcpy(station->sta.sta.addr, addr, ETH_ALEN);
	station->sta.mode = 0;
	station->sta.sta.sta_id = index;
	station->sta.station_flags = 0;

218
	if (priv->band == IEEE80211_BAND_5GHZ)
219 220 221
		rate = IWL_RATE_6M_PLCP;
	else
		rate =	IWL_RATE_1M_PLCP;
222 223 224

	/* Turn on both antennas for the station... */
	station->sta.rate_n_flags =
C
Christoph Hellwig 已提交
225
			iwl3945_hw_set_rate_n_flags(rate, RATE_MCS_ANT_AB_MSK);
226

Z
Zhu Yi 已提交
227
	spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
228 229

	/* Add station to device's station table */
230 231
	iwl_send_add_sta(priv,
			 (struct iwl_addsta_cmd *)&station->sta, flags);
Z
Zhu Yi 已提交
232 233 234 235
	return index;

}

236
static int iwl3945_send_rxon_assoc(struct iwl_priv *priv)
Z
Zhu Yi 已提交
237 238
{
	int rc = 0;
239
	struct iwl_rx_packet *res = NULL;
C
Christoph Hellwig 已提交
240
	struct iwl3945_rxon_assoc_cmd rxon_assoc;
241
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
242 243 244 245 246
		.id = REPLY_RXON_ASSOC,
		.len = sizeof(rxon_assoc),
		.meta.flags = CMD_WANT_SKB,
		.data = &rxon_assoc,
	};
247 248
	const struct iwl_rxon_cmd *rxon1 = &priv->staging_rxon;
	const struct iwl_rxon_cmd *rxon2 = &priv->active_rxon;
Z
Zhu Yi 已提交
249 250 251 252 253

	if ((rxon1->flags == rxon2->flags) &&
	    (rxon1->filter_flags == rxon2->filter_flags) &&
	    (rxon1->cck_basic_rates == rxon2->cck_basic_rates) &&
	    (rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) {
254
		IWL_DEBUG_INFO(priv, "Using current RXON_ASSOC.  Not resending.\n");
Z
Zhu Yi 已提交
255 256 257
		return 0;
	}

258 259 260 261
	rxon_assoc.flags = priv->staging_rxon.flags;
	rxon_assoc.filter_flags = priv->staging_rxon.filter_flags;
	rxon_assoc.ofdm_basic_rates = priv->staging_rxon.ofdm_basic_rates;
	rxon_assoc.cck_basic_rates = priv->staging_rxon.cck_basic_rates;
Z
Zhu Yi 已提交
262 263
	rxon_assoc.reserved = 0;

264
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
265 266 267
	if (rc)
		return rc;

268
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
269
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
270
		IWL_ERR(priv, "Bad return from REPLY_RXON_ASSOC command\n");
Z
Zhu Yi 已提交
271 272 273 274 275 276 277 278 279
		rc = -EIO;
	}

	priv->alloc_rxb_skb--;
	dev_kfree_skb_any(cmd.meta.u.skb);

	return rc;
}

280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
/**
 * iwl3945_get_antenna_flags - Get antenna flags for RXON command
 * @priv: eeprom and antenna fields are used to determine antenna flags
 *
 * priv->eeprom39  is used to determine if antenna AUX/MAIN are reversed
 * iwl3945_mod_params.antenna specifies the antenna diversity mode:
 *
 * IWL_ANTENNA_DIVERSITY - NIC selects best antenna by itself
 * IWL_ANTENNA_MAIN      - Force MAIN antenna
 * IWL_ANTENNA_AUX       - Force AUX antenna
 */
__le32 iwl3945_get_antenna_flags(const struct iwl_priv *priv)
{
	struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;

	switch (iwl3945_mod_params.antenna) {
	case IWL_ANTENNA_DIVERSITY:
		return 0;

	case IWL_ANTENNA_MAIN:
		if (eeprom->antenna_switch_type)
			return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_B_MSK;
		return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_A_MSK;

	case IWL_ANTENNA_AUX:
		if (eeprom->antenna_switch_type)
			return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_A_MSK;
		return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_B_MSK;
	}

	/* bad antenna selector value */
	IWL_ERR(priv, "Bad antenna selector value (0x%x)\n",
		iwl3945_mod_params.antenna);

	return 0;		/* "diversity" is default if error */
}

Z
Zhu Yi 已提交
317
/**
C
Christoph Hellwig 已提交
318
 * iwl3945_commit_rxon - commit staging_rxon to hardware
Z
Zhu Yi 已提交
319
 *
320
 * The RXON command in staging_rxon is committed to the hardware and
Z
Zhu Yi 已提交
321 322 323 324
 * the active_rxon structure is updated with the new data.  This
 * function correctly transitions out of the RXON_ASSOC_MSK state if
 * a HW tune is required based on the RXON structure changes.
 */
325
static int iwl3945_commit_rxon(struct iwl_priv *priv)
Z
Zhu Yi 已提交
326 327
{
	/* cast away the const for active_rxon in this function */
328 329
	struct iwl3945_rxon_cmd *active_rxon = (void *)&priv->active_rxon;
	struct iwl3945_rxon_cmd *staging_rxon = (void *)&priv->staging_rxon;
Z
Zhu Yi 已提交
330
	int rc = 0;
331 332
	bool new_assoc =
		!!(priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK);
Z
Zhu Yi 已提交
333

334
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
335 336 337
		return -1;

	/* always get timestamp with Rx frame */
338
	staging_rxon->flags |= RXON_FLG_TSF2HOST_MSK;
Z
Zhu Yi 已提交
339 340

	/* select antenna */
341
	staging_rxon->flags &=
Z
Zhu Yi 已提交
342
	    ~(RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_SEL_MSK);
343
	staging_rxon->flags |= iwl3945_get_antenna_flags(priv);
Z
Zhu Yi 已提交
344

345
	rc = iwl_check_rxon_cmd(priv);
Z
Zhu Yi 已提交
346
	if (rc) {
347
		IWL_ERR(priv, "Invalid RXON configuration.  Not committing.\n");
Z
Zhu Yi 已提交
348 349 350 351
		return -EINVAL;
	}

	/* If we don't need to send a full RXON, we can use
C
Christoph Hellwig 已提交
352
	 * iwl3945_rxon_assoc_cmd which is used to reconfigure filter
Z
Zhu Yi 已提交
353
	 * and other flags for the current radio configuration. */
354
	if (!iwl_full_rxon_required(priv)) {
C
Christoph Hellwig 已提交
355
		rc = iwl3945_send_rxon_assoc(priv);
Z
Zhu Yi 已提交
356
		if (rc) {
357
			IWL_ERR(priv, "Error setting RXON_ASSOC "
Z
Zhu Yi 已提交
358 359 360 361
				  "configuration (%d).\n", rc);
			return rc;
		}

362
		memcpy(active_rxon, staging_rxon, sizeof(*active_rxon));
Z
Zhu Yi 已提交
363 364 365 366 367 368 369 370

		return 0;
	}

	/* If we are currently associated and the new config requires
	 * an RXON_ASSOC and the new config wants the associated mask enabled,
	 * we must clear the associated from the active configuration
	 * before we apply the new config */
371
	if (iwl_is_associated(priv) && new_assoc) {
372
		IWL_DEBUG_INFO(priv, "Toggling associated bit on current RXON\n");
Z
Zhu Yi 已提交
373 374
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;

375 376 377 378 379 380
		/*
		 * reserved4 and 5 could have been filled by the iwlcore code.
		 * Let's clear them before pushing to the 3945.
		 */
		active_rxon->reserved4 = 0;
		active_rxon->reserved5 = 0;
381
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON,
C
Christoph Hellwig 已提交
382
				      sizeof(struct iwl3945_rxon_cmd),
383
				      &priv->active_rxon);
Z
Zhu Yi 已提交
384 385 386 387 388

		/* If the mask clearing failed then we set
		 * active_rxon back to what it was previously */
		if (rc) {
			active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
389
			IWL_ERR(priv, "Error clearing ASSOC_MSK on current "
Z
Zhu Yi 已提交
390 391 392 393 394
				  "configuration (%d).\n", rc);
			return rc;
		}
	}

395
	IWL_DEBUG_INFO(priv, "Sending RXON\n"
Z
Zhu Yi 已提交
396 397
		       "* with%s RXON_FILTER_ASSOC_MSK\n"
		       "* channel = %d\n"
J
Johannes Berg 已提交
398
		       "* bssid = %pM\n",
399
		       (new_assoc ? "" : "out"),
400 401 402 403 404 405 406 407 408
		       le16_to_cpu(staging_rxon->channel),
		       staging_rxon->bssid_addr);

	/*
	 * reserved4 and 5 could have been filled by the iwlcore code.
	 * Let's clear them before pushing to the 3945.
	 */
	staging_rxon->reserved4 = 0;
	staging_rxon->reserved5 = 0;
Z
Zhu Yi 已提交
409

410 411
	iwl_set_rxon_hwcrypto(priv, !priv->hw_params.sw_crypto);

Z
Zhu Yi 已提交
412
	/* Apply the new configuration */
413
	rc = iwl_send_cmd_pdu(priv, REPLY_RXON,
414 415
			      sizeof(struct iwl3945_rxon_cmd),
			      staging_rxon);
Z
Zhu Yi 已提交
416
	if (rc) {
417
		IWL_ERR(priv, "Error setting new configuration (%d).\n", rc);
Z
Zhu Yi 已提交
418 419 420
		return rc;
	}

421
	memcpy(active_rxon, staging_rxon, sizeof(*active_rxon));
Z
Zhu Yi 已提交
422

C
Christoph Hellwig 已提交
423
	iwl3945_clear_stations_table(priv);
424

Z
Zhu Yi 已提交
425 426
	/* If we issue a new RXON command which required a tune then we must
	 * send a new TXPOWER command or we won't be able to Tx any frames */
S
Samuel Ortiz 已提交
427
	rc = priv->cfg->ops->lib->send_tx_power(priv);
Z
Zhu Yi 已提交
428
	if (rc) {
429
		IWL_ERR(priv, "Error setting Tx power (%d).\n", rc);
Z
Zhu Yi 已提交
430 431 432 433
		return rc;
	}

	/* Add the broadcast address so we can send broadcast frames */
434
	if (iwl3945_add_station(priv, iwl_bcast_addr, 0, 0) ==
Z
Zhu Yi 已提交
435
	    IWL_INVALID_STATION) {
436
		IWL_ERR(priv, "Error adding BROADCAST address for transmit.\n");
Z
Zhu Yi 已提交
437 438 439 440 441
		return -EIO;
	}

	/* If we have set the ASSOC_MSK and we are in BSS mode then
	 * add the IWL_AP_ID to the station rate table */
442
	if (iwl_is_associated(priv) &&
443
	    (priv->iw_mode == NL80211_IFTYPE_STATION))
444 445
		if (iwl3945_add_station(priv, priv->active_rxon.bssid_addr,
					1, 0)
Z
Zhu Yi 已提交
446
		    == IWL_INVALID_STATION) {
447
			IWL_ERR(priv, "Error adding AP address for transmit\n");
Z
Zhu Yi 已提交
448 449 450
			return -EIO;
		}

451
	/* Init the hardware's rate fallback order based on the band */
Z
Zhu Yi 已提交
452 453
	rc = iwl3945_init_hw_rate_table(priv);
	if (rc) {
454
		IWL_ERR(priv, "Error setting HW rate table: %02X\n", rc);
Z
Zhu Yi 已提交
455 456 457 458 459 460
		return -EIO;
	}

	return 0;
}

461
static int iwl3945_set_ccmp_dynamic_key_info(struct iwl_priv *priv,
Z
Zhu Yi 已提交
462 463 464 465 466
				   struct ieee80211_key_conf *keyconf,
				   u8 sta_id)
{
	unsigned long flags;
	__le16 key_flags = 0;
467 468 469 470 471 472 473 474 475 476 477
	int ret;

	key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
	key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);

	if (sta_id == priv->hw_params.bcast_sta_id)
		key_flags |= STA_KEY_MULTICAST_MSK;

	keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
	keyconf->hw_key_idx = keyconf->keyidx;
	key_flags &= ~STA_KEY_FLG_INVALID;
Z
Zhu Yi 已提交
478 479

	spin_lock_irqsave(&priv->sta_lock, flags);
480 481 482
	priv->stations_39[sta_id].keyinfo.alg = keyconf->alg;
	priv->stations_39[sta_id].keyinfo.keylen = keyconf->keylen;
	memcpy(priv->stations_39[sta_id].keyinfo.key, keyconf->key,
Z
Zhu Yi 已提交
483 484
	       keyconf->keylen);

485
	memcpy(priv->stations_39[sta_id].sta.key.key, keyconf->key,
Z
Zhu Yi 已提交
486
	       keyconf->keylen);
487

488
	if ((priv->stations_39[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
489
			== STA_KEY_FLG_NO_ENC)
490
		priv->stations_39[sta_id].sta.key.key_offset =
491 492 493 494
				 iwl_get_free_ucode_key_index(priv);
	/* else, we are overriding an existing key => no need to allocated room
	* in uCode. */

495
	WARN(priv->stations_39[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
496 497
		"no space for a new key");

498 499 500
	priv->stations_39[sta_id].sta.key.key_flags = key_flags;
	priv->stations_39[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations_39[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
Z
Zhu Yi 已提交
501

502 503 504 505 506
	IWL_DEBUG_INFO(priv, "hwcrypto: modify ucode station key info\n");

	ret = iwl_send_add_sta(priv,
		(struct iwl_addsta_cmd *)&priv->stations_39[sta_id].sta, CMD_ASYNC);

Z
Zhu Yi 已提交
507 508
	spin_unlock_irqrestore(&priv->sta_lock, flags);

509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
	return ret;
}

static int iwl3945_set_tkip_dynamic_key_info(struct iwl_priv *priv,
				  struct ieee80211_key_conf *keyconf,
				  u8 sta_id)
{
	return -EOPNOTSUPP;
}

static int iwl3945_set_wep_dynamic_key_info(struct iwl_priv *priv,
				  struct ieee80211_key_conf *keyconf,
				  u8 sta_id)
{
	return -EOPNOTSUPP;
Z
Zhu Yi 已提交
524 525
}

526
static int iwl3945_clear_sta_key_info(struct iwl_priv *priv, u8 sta_id)
Z
Zhu Yi 已提交
527 528 529 530
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);
531 532
	memset(&priv->stations_39[sta_id].keyinfo, 0, sizeof(struct iwl3945_hw_key));
	memset(&priv->stations_39[sta_id].sta.key, 0,
533
		sizeof(struct iwl4965_keyinfo));
534 535 536
	priv->stations_39[sta_id].sta.key.key_flags = STA_KEY_FLG_NO_ENC;
	priv->stations_39[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations_39[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
Z
Zhu Yi 已提交
537 538
	spin_unlock_irqrestore(&priv->sta_lock, flags);

539
	IWL_DEBUG_INFO(priv, "hwcrypto: clear ucode station key info\n");
540 541
	iwl_send_add_sta(priv,
		(struct iwl_addsta_cmd *)&priv->stations_39[sta_id].sta, 0);
Z
Zhu Yi 已提交
542 543 544
	return 0;
}

A
Abhijeet Kolekar 已提交
545
static int iwl3945_set_dynamic_key(struct iwl_priv *priv,
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
			struct ieee80211_key_conf *keyconf, u8 sta_id)
{
	int ret = 0;

	keyconf->hw_key_idx = HW_KEY_DYNAMIC;

	switch (keyconf->alg) {
	case ALG_CCMP:
		ret = iwl3945_set_ccmp_dynamic_key_info(priv, keyconf, sta_id);
		break;
	case ALG_TKIP:
		ret = iwl3945_set_tkip_dynamic_key_info(priv, keyconf, sta_id);
		break;
	case ALG_WEP:
		ret = iwl3945_set_wep_dynamic_key_info(priv, keyconf, sta_id);
		break;
	default:
563
		IWL_ERR(priv, "Unknown alg: %s alg = %d\n", __func__, keyconf->alg);
564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
		ret = -EINVAL;
	}

	IWL_DEBUG_WEP(priv, "Set dynamic key: alg= %d len=%d idx=%d sta=%d ret=%d\n",
		      keyconf->alg, keyconf->keylen, keyconf->keyidx,
		      sta_id, ret);

	return ret;
}

static int iwl3945_remove_static_key(struct iwl_priv *priv)
{
	int ret = -EOPNOTSUPP;

	return ret;
}

static int iwl3945_set_static_key(struct iwl_priv *priv,
				struct ieee80211_key_conf *key)
{
	if (key->alg == ALG_WEP)
		return -EOPNOTSUPP;

	IWL_ERR(priv, "Static key invalid: alg %d\n", key->alg);
	return -EINVAL;
}

591
static void iwl3945_clear_free_frames(struct iwl_priv *priv)
Z
Zhu Yi 已提交
592 593 594
{
	struct list_head *element;

595
	IWL_DEBUG_INFO(priv, "%d frames on pre-allocated heap on clear.\n",
Z
Zhu Yi 已提交
596 597 598 599 600
		       priv->frames_count);

	while (!list_empty(&priv->free_frames)) {
		element = priv->free_frames.next;
		list_del(element);
C
Christoph Hellwig 已提交
601
		kfree(list_entry(element, struct iwl3945_frame, list));
Z
Zhu Yi 已提交
602 603 604 605
		priv->frames_count--;
	}

	if (priv->frames_count) {
606
		IWL_WARN(priv, "%d frames still in use.  Did we lose one?\n",
Z
Zhu Yi 已提交
607 608 609 610 611
			    priv->frames_count);
		priv->frames_count = 0;
	}
}

612
static struct iwl3945_frame *iwl3945_get_free_frame(struct iwl_priv *priv)
Z
Zhu Yi 已提交
613
{
C
Christoph Hellwig 已提交
614
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
615 616 617 618
	struct list_head *element;
	if (list_empty(&priv->free_frames)) {
		frame = kzalloc(sizeof(*frame), GFP_KERNEL);
		if (!frame) {
619
			IWL_ERR(priv, "Could not allocate frame!\n");
Z
Zhu Yi 已提交
620 621 622 623 624 625 626 627 628
			return NULL;
		}

		priv->frames_count++;
		return frame;
	}

	element = priv->free_frames.next;
	list_del(element);
C
Christoph Hellwig 已提交
629
	return list_entry(element, struct iwl3945_frame, list);
Z
Zhu Yi 已提交
630 631
}

632
static void iwl3945_free_frame(struct iwl_priv *priv, struct iwl3945_frame *frame)
Z
Zhu Yi 已提交
633 634 635 636 637
{
	memset(frame, 0, sizeof(*frame));
	list_add(&frame->list, &priv->free_frames);
}

638
unsigned int iwl3945_fill_beacon_frame(struct iwl_priv *priv,
Z
Zhu Yi 已提交
639
				struct ieee80211_hdr *hdr,
640
				int left)
Z
Zhu Yi 已提交
641 642
{

643
	if (!iwl_is_associated(priv) || !priv->ibss_beacon ||
644 645
	    ((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
	     (priv->iw_mode != NL80211_IFTYPE_AP)))
Z
Zhu Yi 已提交
646 647 648 649 650 651 652 653 654 655
		return 0;

	if (priv->ibss_beacon->len > left)
		return 0;

	memcpy(hdr, priv->ibss_beacon->data, priv->ibss_beacon->len);

	return priv->ibss_beacon->len;
}

656
static int iwl3945_send_beacon_cmd(struct iwl_priv *priv)
Z
Zhu Yi 已提交
657
{
C
Christoph Hellwig 已提交
658
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
659 660 661 662
	unsigned int frame_size;
	int rc;
	u8 rate;

C
Christoph Hellwig 已提交
663
	frame = iwl3945_get_free_frame(priv);
Z
Zhu Yi 已提交
664 665

	if (!frame) {
666
		IWL_ERR(priv, "Could not obtain free frame buffer for beacon "
Z
Zhu Yi 已提交
667 668 669 670
			  "command.\n");
		return -ENOMEM;
	}

671
	rate = iwl_rate_get_lowest_plcp(priv);
Z
Zhu Yi 已提交
672

C
Christoph Hellwig 已提交
673
	frame_size = iwl3945_hw_get_beacon_cmd(priv, frame, rate);
Z
Zhu Yi 已提交
674

675
	rc = iwl_send_cmd_pdu(priv, REPLY_TX_BEACON, frame_size,
Z
Zhu Yi 已提交
676 677
			      &frame->u.cmd[0]);

C
Christoph Hellwig 已提交
678
	iwl3945_free_frame(priv, frame);
Z
Zhu Yi 已提交
679 680 681 682

	return rc;
}

683
static void iwl3945_unset_hw_params(struct iwl_priv *priv)
Z
Zhu Yi 已提交
684
{
685
	if (priv->shared_virt)
Z
Zhu Yi 已提交
686
		pci_free_consistent(priv->pci_dev,
C
Christoph Hellwig 已提交
687
				    sizeof(struct iwl3945_shared),
688 689
				    priv->shared_virt,
				    priv->shared_phys);
Z
Zhu Yi 已提交
690 691 692
}

#define MAX_UCODE_BEACON_INTERVAL	1024
693
#define INTEL_CONN_LISTEN_INTERVAL	cpu_to_le16(0xA)
Z
Zhu Yi 已提交
694

C
Christoph Hellwig 已提交
695
static __le16 iwl3945_adjust_beacon_interval(u16 beacon_val)
Z
Zhu Yi 已提交
696 697 698 699 700 701 702 703 704 705 706 707
{
	u16 new_val = 0;
	u16 beacon_factor = 0;

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

	return cpu_to_le16(new_val);
}

708
static void iwl3945_setup_rxon_timing(struct iwl_priv *priv)
Z
Zhu Yi 已提交
709 710 711 712 713 714 715 716 717 718
{
	u64 interval_tm_unit;
	u64 tsf, result;
	unsigned long flags;
	struct ieee80211_conf *conf = NULL;
	u16 beacon_int = 0;

	conf = ieee80211_get_hw_conf(priv->hw);

	spin_lock_irqsave(&priv->lock, flags);
719
	priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
Z
Zhu Yi 已提交
720 721
	priv->rxon_timing.listen_interval = INTEL_CONN_LISTEN_INTERVAL;

722
	tsf = priv->timestamp;
Z
Zhu Yi 已提交
723 724 725 726

	beacon_int = priv->beacon_int;
	spin_unlock_irqrestore(&priv->lock, flags);

727
	if (priv->iw_mode == NL80211_IFTYPE_STATION) {
Z
Zhu Yi 已提交
728 729 730 731 732 733 734
		if (beacon_int == 0) {
			priv->rxon_timing.beacon_interval = cpu_to_le16(100);
			priv->rxon_timing.beacon_init_val = cpu_to_le32(102400);
		} else {
			priv->rxon_timing.beacon_interval =
				cpu_to_le16(beacon_int);
			priv->rxon_timing.beacon_interval =
C
Christoph Hellwig 已提交
735
			    iwl3945_adjust_beacon_interval(
Z
Zhu Yi 已提交
736 737 738 739 740 741
				le16_to_cpu(priv->rxon_timing.beacon_interval));
		}

		priv->rxon_timing.atim_window = 0;
	} else {
		priv->rxon_timing.beacon_interval =
C
Christoph Hellwig 已提交
742
			iwl3945_adjust_beacon_interval(conf->beacon_int);
Z
Zhu Yi 已提交
743 744 745 746 747 748 749 750 751 752 753
		/* TODO: we need to get atim_window from upper stack
		 * for now we set to 0 */
		priv->rxon_timing.atim_window = 0;
	}

	interval_tm_unit =
		(le16_to_cpu(priv->rxon_timing.beacon_interval) * 1024);
	result = do_div(tsf, interval_tm_unit);
	priv->rxon_timing.beacon_init_val =
	    cpu_to_le32((u32) ((u64) interval_tm_unit - result));

754 755
	IWL_DEBUG_ASSOC(priv,
		"beacon interval %d beacon timer %d beacon tim %d\n",
Z
Zhu Yi 已提交
756 757 758 759 760
		le16_to_cpu(priv->rxon_timing.beacon_interval),
		le32_to_cpu(priv->rxon_timing.beacon_init_val),
		le16_to_cpu(priv->rxon_timing.atim_window));
}

761
static int iwl3945_set_mode(struct iwl_priv *priv, int mode)
Z
Zhu Yi 已提交
762
{
763
	if (mode == NL80211_IFTYPE_ADHOC) {
764
		const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
765

766
		ch_info = iwl_get_channel_info(priv,
767
			priv->band,
768
			le16_to_cpu(priv->staging_rxon.channel));
Z
Zhu Yi 已提交
769 770

		if (!ch_info || !is_channel_ibss(ch_info)) {
771
			IWL_ERR(priv, "channel %d not IBSS channel\n",
772
				  le16_to_cpu(priv->staging_rxon.channel));
Z
Zhu Yi 已提交
773 774 775 776
			return -EINVAL;
		}
	}

777
	iwl_connection_init_rx_config(priv, mode);
Z
Zhu Yi 已提交
778

C
Christoph Hellwig 已提交
779
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
780

T
Tomas Winkler 已提交
781
	/* don't commit rxon if rf-kill is on*/
782
	if (!iwl_is_ready_rf(priv))
783 784 785
		return -EAGAIN;

	cancel_delayed_work(&priv->scan_check);
786
	if (iwl_scan_cancel_timeout(priv, 100)) {
787
		IWL_WARN(priv, "Aborted scan still in progress after 100ms\n");
788
		IWL_DEBUG_MAC80211(priv, "leaving - scan abort failed.\n");
789 790 791
		return -EAGAIN;
	}

C
Christoph Hellwig 已提交
792
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
793 794 795 796

	return 0;
}

797
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl_priv *priv,
798
				      struct ieee80211_tx_info *info,
799
				      struct iwl_cmd *cmd,
Z
Zhu Yi 已提交
800
				      struct sk_buff *skb_frag,
801
				      int sta_id)
Z
Zhu Yi 已提交
802
{
803
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
804
	struct iwl3945_hw_key *keyinfo =
805
	    &priv->stations_39[sta_id].keyinfo;
Z
Zhu Yi 已提交
806 807 808

	switch (keyinfo->alg) {
	case ALG_CCMP:
809 810
		tx->sec_ctl = TX_CMD_SEC_CCM;
		memcpy(tx->key, keyinfo->key, keyinfo->keylen);
811
		IWL_DEBUG_TX(priv, "tx_cmd with AES hwcrypto\n");
Z
Zhu Yi 已提交
812 813 814 815 816 817
		break;

	case ALG_TKIP:
		break;

	case ALG_WEP:
818
		tx->sec_ctl = TX_CMD_SEC_WEP |
819
		    (info->control.hw_key->hw_key_idx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT;
Z
Zhu Yi 已提交
820 821

		if (keyinfo->keylen == 13)
822
			tx->sec_ctl |= TX_CMD_SEC_KEY128;
Z
Zhu Yi 已提交
823

824
		memcpy(&tx->key[3], keyinfo->key, keyinfo->keylen);
Z
Zhu Yi 已提交
825

826
		IWL_DEBUG_TX(priv, "Configuring packet for WEP encryption "
827
			     "with key %d\n", info->control.hw_key->hw_key_idx);
Z
Zhu Yi 已提交
828 829 830
		break;

	default:
T
Tomas Winkler 已提交
831
		IWL_ERR(priv, "Unknown encode alg %d\n", keyinfo->alg);
Z
Zhu Yi 已提交
832 833 834 835 836 837 838
		break;
	}
}

/*
 * handle build REPLY_TX command notification.
 */
839
static void iwl3945_build_tx_cmd_basic(struct iwl_priv *priv,
840
				  struct iwl_cmd *cmd,
841
				  struct ieee80211_tx_info *info,
842
				  struct ieee80211_hdr *hdr, u8 std_id)
Z
Zhu Yi 已提交
843
{
844 845
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
	__le32 tx_flags = tx->tx_flags;
846
	__le16 fc = hdr->frame_control;
847
	u8 rc_flags = info->control.rates[0].flags;
Z
Zhu Yi 已提交
848

849
	tx->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
850
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Z
Zhu Yi 已提交
851
		tx_flags |= TX_CMD_FLG_ACK_MSK;
852
		if (ieee80211_is_mgmt(fc))
Z
Zhu Yi 已提交
853
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
854
		if (ieee80211_is_probe_resp(fc) &&
Z
Zhu Yi 已提交
855 856 857 858 859 860 861
		    !(le16_to_cpu(hdr->seq_ctrl) & 0xf))
			tx_flags |= TX_CMD_FLG_TSF_MSK;
	} else {
		tx_flags &= (~TX_CMD_FLG_ACK_MSK);
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
	}

862
	tx->sta_id = std_id;
863
	if (ieee80211_has_morefrags(fc))
Z
Zhu Yi 已提交
864 865
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

866 867
	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
868
		tx->tid_tspec = qc[0] & 0xf;
Z
Zhu Yi 已提交
869
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
870
	} else {
Z
Zhu Yi 已提交
871
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
872
	}
Z
Zhu Yi 已提交
873

874
	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
Z
Zhu Yi 已提交
875 876
		tx_flags |= TX_CMD_FLG_RTS_MSK;
		tx_flags &= ~TX_CMD_FLG_CTS_MSK;
877
	} else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
Z
Zhu Yi 已提交
878 879 880 881 882 883 884 885
		tx_flags &= ~TX_CMD_FLG_RTS_MSK;
		tx_flags |= TX_CMD_FLG_CTS_MSK;
	}

	if ((tx_flags & TX_CMD_FLG_RTS_MSK) || (tx_flags & TX_CMD_FLG_CTS_MSK))
		tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;

	tx_flags &= ~(TX_CMD_FLG_ANT_SEL_MSK);
886 887
	if (ieee80211_is_mgmt(fc)) {
		if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
888
			tx->timeout.pm_frame_timeout = cpu_to_le16(3);
Z
Zhu Yi 已提交
889
		else
890
			tx->timeout.pm_frame_timeout = cpu_to_le16(2);
M
Mohamed Abbas 已提交
891
	} else {
892
		tx->timeout.pm_frame_timeout = 0;
893
#ifdef CONFIG_IWLWIFI_LEDS
M
Mohamed Abbas 已提交
894 895 896
		priv->rxtxpackets += le16_to_cpu(cmd->cmd.tx.len);
#endif
	}
Z
Zhu Yi 已提交
897

898 899 900
	tx->driver_txop = 0;
	tx->tx_flags = tx_flags;
	tx->next_frame_len = 0;
Z
Zhu Yi 已提交
901 902
}

903 904 905
/**
 * iwl3945_get_sta_id - Find station's index within station table
 */
906
static int iwl3945_get_sta_id(struct iwl_priv *priv, struct ieee80211_hdr *hdr)
Z
Zhu Yi 已提交
907 908 909 910
{
	int sta_id;
	u16 fc = le16_to_cpu(hdr->frame_control);

911
	/* If this frame is broadcast or management, use broadcast station id */
Z
Zhu Yi 已提交
912 913
	if (((fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA) ||
	    is_multicast_ether_addr(hdr->addr1))
914
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
915 916 917

	switch (priv->iw_mode) {

918 919
	/* If we are a client station in a BSS network, use the special
	 * AP station entry (that's the only station we communicate with) */
920
	case NL80211_IFTYPE_STATION:
Z
Zhu Yi 已提交
921 922 923
		return IWL_AP_ID;

	/* If we are an AP, then find the station, or use BCAST */
924
	case NL80211_IFTYPE_AP:
C
Christoph Hellwig 已提交
925
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
926 927
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;
928
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
929

930 931
	/* If this frame is going out to an IBSS network, find the station,
	 * or create a new station table entry */
932
	case NL80211_IFTYPE_ADHOC: {
933
		/* Create new station table entry */
C
Christoph Hellwig 已提交
934
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
935 936 937
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

C
Christoph Hellwig 已提交
938
		sta_id = iwl3945_add_station(priv, hdr->addr1, 0, CMD_ASYNC);
Z
Zhu Yi 已提交
939 940 941 942

		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

943
		IWL_DEBUG_DROP(priv, "Station %pM not in station map. "
Z
Zhu Yi 已提交
944
			       "Defaulting to broadcast...\n",
J
Johannes Berg 已提交
945
			       hdr->addr1);
946
		iwl_print_hex_dump(priv, IWL_DL_DROP, (u8 *) hdr, sizeof(*hdr));
947
		return priv->hw_params.bcast_sta_id;
948
	}
949 950
	/* If we are in monitor mode, use BCAST. This is required for
	 * packet injection. */
951
	case NL80211_IFTYPE_MONITOR:
952
		return priv->hw_params.bcast_sta_id;
953

Z
Zhu Yi 已提交
954
	default:
955 956
		IWL_WARN(priv, "Unknown mode of operation: %d\n",
			priv->iw_mode);
957
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
958 959 960 961 962 963
	}
}

/*
 * start REPLY_TX command process
 */
964
static int iwl3945_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
Z
Zhu Yi 已提交
965 966
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
967
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
968
	struct iwl3945_tx_cmd *tx;
969
	struct iwl_tx_queue *txq = NULL;
970
	struct iwl_queue *q = NULL;
971
	struct iwl_cmd *out_cmd = NULL;
Z
Zhu Yi 已提交
972 973
	dma_addr_t phys_addr;
	dma_addr_t txcmd_phys;
974
	int txq_id = skb_get_queue_mapping(skb);
975 976 977
	u16 len, idx, len_org, hdr_len;
	u8 id;
	u8 unicast;
Z
Zhu Yi 已提交
978
	u8 sta_id;
979
	u8 tid = 0;
Z
Zhu Yi 已提交
980
	u16 seq_number = 0;
981
	__le16 fc;
Z
Zhu Yi 已提交
982
	u8 wait_write_ptr = 0;
983
	u8 *qc = NULL;
Z
Zhu Yi 已提交
984 985 986 987
	unsigned long flags;
	int rc;

	spin_lock_irqsave(&priv->lock, flags);
988
	if (iwl_is_rfkill(priv)) {
989
		IWL_DEBUG_DROP(priv, "Dropping - RF KILL\n");
Z
Zhu Yi 已提交
990 991 992
		goto drop_unlock;
	}

993
	if ((ieee80211_get_tx_rate(priv->hw, info)->hw_value & 0xFF) == IWL_INVALID_RATE) {
994
		IWL_ERR(priv, "ERROR: No TX rate available.\n");
Z
Zhu Yi 已提交
995 996 997 998 999 1000
		goto drop_unlock;
	}

	unicast = !is_multicast_ether_addr(hdr->addr1);
	id = 0;

1001
	fc = hdr->frame_control;
Z
Zhu Yi 已提交
1002

S
Samuel Ortiz 已提交
1003
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1004
	if (ieee80211_is_auth(fc))
1005
		IWL_DEBUG_TX(priv, "Sending AUTH frame\n");
1006
	else if (ieee80211_is_assoc_req(fc))
1007
		IWL_DEBUG_TX(priv, "Sending ASSOC frame\n");
1008
	else if (ieee80211_is_reassoc_req(fc))
1009
		IWL_DEBUG_TX(priv, "Sending REASSOC frame\n");
Z
Zhu Yi 已提交
1010 1011
#endif

1012
	/* drop all data frame if we are not associated */
1013
	if (ieee80211_is_data(fc) &&
1014
	    (priv->iw_mode != NL80211_IFTYPE_MONITOR) && /* packet injection */
1015
	    (!iwl_is_associated(priv) ||
1016
	     ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id))) {
1017
		IWL_DEBUG_DROP(priv, "Dropping - !iwl_is_associated\n");
Z
Zhu Yi 已提交
1018 1019 1020 1021 1022
		goto drop_unlock;
	}

	spin_unlock_irqrestore(&priv->lock, flags);

1023
	hdr_len = ieee80211_hdrlen(fc);
1024 1025

	/* Find (or create) index into station table for destination station */
C
Christoph Hellwig 已提交
1026
	sta_id = iwl3945_get_sta_id(priv, hdr);
Z
Zhu Yi 已提交
1027
	if (sta_id == IWL_INVALID_STATION) {
1028
		IWL_DEBUG_DROP(priv, "Dropping - INVALID STATION: %pM\n",
J
Johannes Berg 已提交
1029
			       hdr->addr1);
Z
Zhu Yi 已提交
1030 1031 1032
		goto drop;
	}

1033
	IWL_DEBUG_RATE(priv, "station Id %d\n", sta_id);
Z
Zhu Yi 已提交
1034

1035 1036
	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
1037
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
1038
		seq_number = priv->stations_39[sta_id].tid[tid].seq_number &
Z
Zhu Yi 已提交
1039 1040 1041
				IEEE80211_SCTL_SEQ;
		hdr->seq_ctrl = cpu_to_le16(seq_number) |
			(hdr->seq_ctrl &
1042
				cpu_to_le16(IEEE80211_SCTL_FRAG));
Z
Zhu Yi 已提交
1043 1044
		seq_number += 0x10;
	}
1045 1046

	/* Descriptor for chosen Tx queue */
1047
	txq = &priv->txq[txq_id];
Z
Zhu Yi 已提交
1048 1049 1050 1051
	q = &txq->q;

	spin_lock_irqsave(&priv->lock, flags);

1052
	idx = get_cmd_index(q, q->write_ptr, 0);
Z
Zhu Yi 已提交
1053

1054
	/* Set up driver data for this TFD */
W
Winkler, Tomas 已提交
1055
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl_tx_info));
1056
	txq->txb[q->write_ptr].skb[0] = skb;
1057 1058

	/* Init first empty entry in queue's array of Tx/cmd buffers */
1059
	out_cmd = txq->cmd[idx];
1060
	tx = (struct iwl3945_tx_cmd *)out_cmd->cmd.payload;
Z
Zhu Yi 已提交
1061
	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
1062
	memset(tx, 0, sizeof(*tx));
1063 1064 1065 1066 1067 1068 1069

	/*
	 * Set up the Tx-command (not MAC!) header.
	 * Store the chosen Tx queue and TFD index within the sequence field;
	 * after Tx, uCode's Tx response will return this value so driver can
	 * locate the frame within the tx queue and do post-tx processing.
	 */
Z
Zhu Yi 已提交
1070 1071
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
1072
				INDEX_TO_SEQ(q->write_ptr)));
1073 1074

	/* Copy MAC header from skb into command buffer */
1075
	memcpy(tx->hdr, hdr, hdr_len);
Z
Zhu Yi 已提交
1076

1077 1078 1079 1080 1081 1082 1083 1084 1085
	/*
	 * Use the first empty entry in this queue's command buffer array
	 * to contain the Tx command and MAC header concatenated together
	 * (payload data will be in another buffer).
	 * Size of this varies, due to varying MAC header length.
	 * If end is not dword aligned, we'll have 2 extra bytes at the end
	 * of the MAC header (device reads on dword boundaries).
	 * We'll tell device about this padding later.
	 */
1086
	len = sizeof(struct iwl3945_tx_cmd) +
1087
			sizeof(struct iwl_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
1088 1089 1090 1091 1092 1093 1094 1095 1096

	len_org = len;
	len = (len + 3) & ~3;

	if (len_org != len)
		len_org = 1;
	else
		len_org = 0;

1097 1098
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
1099 1100 1101 1102 1103 1104 1105 1106
	txcmd_phys = pci_map_single(priv->pci_dev,
				    out_cmd, sizeof(struct iwl_cmd),
				    PCI_DMA_TODEVICE);
	pci_unmap_addr_set(&out_cmd->meta, mapping, txcmd_phys);
	pci_unmap_len_set(&out_cmd->meta, len, sizeof(struct iwl_cmd));
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
	txcmd_phys += offsetof(struct iwl_cmd, hdr);
Z
Zhu Yi 已提交
1107

1108 1109
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
1110 1111
	priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
						   txcmd_phys, len, 1, 0);
Z
Zhu Yi 已提交
1112

1113
	if (info->control.hw_key)
1114
		iwl3945_build_tx_cmd_hwcrypto(priv, info, out_cmd, skb, sta_id);
Z
Zhu Yi 已提交
1115

1116 1117
	/* Set up TFD's 2nd entry to point directly to remainder of skb,
	 * if any (802.11 null frames have no payload). */
Z
Zhu Yi 已提交
1118 1119 1120 1121
	len = skb->len - hdr_len;
	if (len) {
		phys_addr = pci_map_single(priv->pci_dev, skb->data + hdr_len,
					   len, PCI_DMA_TODEVICE);
1122 1123 1124
		priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
							   phys_addr, len,
							   0, U32_PAD(len));
Z
Zhu Yi 已提交
1125 1126
	}

1127
	/* Total # bytes to be transmitted */
Z
Zhu Yi 已提交
1128
	len = (u16)skb->len;
1129
	tx->len = cpu_to_le16(len);
Z
Zhu Yi 已提交
1130 1131

	/* TODO need this for burst mode later on */
1132
	iwl3945_build_tx_cmd_basic(priv, out_cmd, info, hdr, sta_id);
Z
Zhu Yi 已提交
1133 1134

	/* set is_hcca to 0; it probably will never be implemented */
1135
	iwl3945_hw_build_tx_cmd_rate(priv, out_cmd, info, hdr, sta_id, 0);
Z
Zhu Yi 已提交
1136

1137 1138
	tx->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
	tx->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;
Z
Zhu Yi 已提交
1139

1140
	if (!ieee80211_has_morefrags(hdr->frame_control)) {
Z
Zhu Yi 已提交
1141
		txq->need_update = 1;
1142
		if (qc)
1143
			priv->stations_39[sta_id].tid[tid].seq_number = seq_number;
Z
Zhu Yi 已提交
1144 1145 1146 1147 1148
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

1149 1150 1151
	IWL_DEBUG_TX(priv, "sequence nr = 0X%x \n",
		     le16_to_cpu(out_cmd->hdr.sequence));
	IWL_DEBUG_TX(priv, "tx_flags = 0X%x \n", le32_to_cpu(tx->tx_flags));
1152 1153
	iwl_print_hex_dump(priv, IWL_DL_TX, tx, sizeof(*tx));
	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx->hdr,
1154
			   ieee80211_hdrlen(fc));
Z
Zhu Yi 已提交
1155

1156
	/* Tell device the write index *just past* this latest filled TFD */
T
Tomas Winkler 已提交
1157
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
1158
	rc = iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
1159 1160 1161 1162 1163
	spin_unlock_irqrestore(&priv->lock, flags);

	if (rc)
		return rc;

1164
	if ((iwl_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
1165 1166 1167 1168
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
1169
			iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
1170 1171 1172
			spin_unlock_irqrestore(&priv->lock, flags);
		}

1173
		iwl_stop_queue(priv, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183
	}

	return 0;

drop_unlock:
	spin_unlock_irqrestore(&priv->lock, flags);
drop:
	return -1;
}

1184
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198

#include "iwl-spectrum.h"

#define BEACON_TIME_MASK_LOW	0x00FFFFFF
#define BEACON_TIME_MASK_HIGH	0xFF000000
#define TIME_UNIT		1024

/*
 * extended beacon time format
 * time in usec will be changed into a 32-bit value in 8:24 format
 * the high 1 byte is the beacon counts
 * the lower 3 bytes is the time in usec within one beacon interval
 */

C
Christoph Hellwig 已提交
1199
static u32 iwl3945_usecs_to_beacons(u32 usec, u32 beacon_interval)
Z
Zhu Yi 已提交
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
{
	u32 quot;
	u32 rem;
	u32 interval = beacon_interval * 1024;

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

	quot = (usec / interval) & (BEACON_TIME_MASK_HIGH >> 24);
	rem = (usec % interval) & BEACON_TIME_MASK_LOW;

	return (quot << 24) + rem;
}

/* base is usually what we get from ucode with each received frame,
 * the same as HW timer counter counting down
 */

C
Christoph Hellwig 已提交
1218
static __le32 iwl3945_add_beacon_time(u32 base, u32 addon, u32 beacon_interval)
Z
Zhu Yi 已提交
1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
{
	u32 base_low = base & BEACON_TIME_MASK_LOW;
	u32 addon_low = addon & BEACON_TIME_MASK_LOW;
	u32 interval = beacon_interval * TIME_UNIT;
	u32 res = (base & BEACON_TIME_MASK_HIGH) +
	    (addon & BEACON_TIME_MASK_HIGH);

	if (base_low > addon_low)
		res += base_low - addon_low;
	else if (base_low < addon_low) {
		res += interval + base_low - addon_low;
		res += (1 << 24);
	} else
		res += (1 << 24);

	return cpu_to_le32(res);
}

1237
static int iwl3945_get_measurement(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1238 1239 1240
			       struct ieee80211_measurement_params *params,
			       u8 type)
{
1241
	struct iwl_spectrum_cmd spectrum;
1242
	struct iwl_rx_packet *res;
1243
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
1244 1245 1246 1247 1248 1249 1250 1251 1252
		.id = REPLY_SPECTRUM_MEASUREMENT_CMD,
		.data = (void *)&spectrum,
		.meta.flags = CMD_WANT_SKB,
	};
	u32 add_time = le64_to_cpu(params->start_time);
	int rc;
	int spectrum_resp_status;
	int duration = le16_to_cpu(params->duration);

1253
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
1254
		add_time =
C
Christoph Hellwig 已提交
1255
		    iwl3945_usecs_to_beacons(
Z
Zhu Yi 已提交
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
			le64_to_cpu(params->start_time) - priv->last_tsf,
			le16_to_cpu(priv->rxon_timing.beacon_interval));

	memset(&spectrum, 0, sizeof(spectrum));

	spectrum.channel_count = cpu_to_le16(1);
	spectrum.flags =
	    RXON_FLG_TSF2HOST_MSK | RXON_FLG_ANT_A_MSK | RXON_FLG_DIS_DIV_MSK;
	spectrum.filter_flags = MEASUREMENT_FILTER_FLAG;
	cmd.len = sizeof(spectrum);
	spectrum.len = cpu_to_le16(cmd.len - sizeof(spectrum.len));

1268
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
1269
		spectrum.start_time =
C
Christoph Hellwig 已提交
1270
		    iwl3945_add_beacon_time(priv->last_beacon_time,
Z
Zhu Yi 已提交
1271 1272 1273 1274 1275 1276 1277 1278
				add_time,
				le16_to_cpu(priv->rxon_timing.beacon_interval));
	else
		spectrum.start_time = 0;

	spectrum.channels[0].duration = cpu_to_le32(duration * TIME_UNIT);
	spectrum.channels[0].channel = params->channel;
	spectrum.channels[0].type = type;
1279
	if (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK)
Z
Zhu Yi 已提交
1280 1281 1282
		spectrum.flags |= RXON_FLG_BAND_24G_MSK |
		    RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK;

1283
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
1284 1285 1286
	if (rc)
		return rc;

1287
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1288
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
1289
		IWL_ERR(priv, "Bad return from REPLY_RX_ON_ASSOC command\n");
Z
Zhu Yi 已提交
1290 1291 1292 1293 1294 1295 1296
		rc = -EIO;
	}

	spectrum_resp_status = le16_to_cpu(res->u.spectrum.status);
	switch (spectrum_resp_status) {
	case 0:		/* Command will be handled */
		if (res->u.spectrum.id != 0xff) {
1297
			IWL_DEBUG_INFO(priv, "Replaced existing measurement: %d\n",
1298
						res->u.spectrum.id);
Z
Zhu Yi 已提交
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
			priv->measurement_status &= ~MEASUREMENT_READY;
		}
		priv->measurement_status |= MEASUREMENT_ACTIVE;
		rc = 0;
		break;

	case 1:		/* Command will not be handled */
		rc = -EAGAIN;
		break;
	}

	dev_kfree_skb_any(cmd.meta.u.skb);

	return rc;
}
#endif

1316
static void iwl3945_rx_reply_alive(struct iwl_priv *priv,
1317
			       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1318
{
1319 1320
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl_alive_resp *palive;
Z
Zhu Yi 已提交
1321 1322 1323 1324
	struct delayed_work *pwork;

	palive = &pkt->u.alive_frame;

1325
	IWL_DEBUG_INFO(priv, "Alive ucode status 0x%08X revision "
Z
Zhu Yi 已提交
1326 1327 1328 1329 1330
		       "0x%01X 0x%01X\n",
		       palive->is_valid, palive->ver_type,
		       palive->ver_subtype);

	if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
1331
		IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
1332 1333
		memcpy(&priv->card_alive_init, &pkt->u.alive_frame,
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
1334 1335
		pwork = &priv->init_alive_start;
	} else {
1336
		IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
1337
		memcpy(&priv->card_alive, &pkt->u.alive_frame,
1338
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
1339
		pwork = &priv->alive_start;
C
Christoph Hellwig 已提交
1340
		iwl3945_disable_events(priv);
Z
Zhu Yi 已提交
1341 1342 1343 1344 1345 1346 1347 1348
	}

	/* We delay the ALIVE response by 5ms to
	 * give the HW RF Kill time to activate... */
	if (palive->is_valid == UCODE_VALID_OK)
		queue_delayed_work(priv->workqueue, pwork,
				   msecs_to_jiffies(5));
	else
1349
		IWL_WARN(priv, "uCode did not respond OK.\n");
Z
Zhu Yi 已提交
1350 1351
}

1352
static void iwl3945_rx_reply_add_sta(struct iwl_priv *priv,
1353
				 struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1354
{
1355
#ifdef CONFIG_IWLWIFI_DEBUG
1356
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
1357
#endif
Z
Zhu Yi 已提交
1358

1359
	IWL_DEBUG_RX(priv, "Received REPLY_ADD_STA: 0x%02X\n", pkt->u.status);
Z
Zhu Yi 已提交
1360 1361 1362
	return;
}

C
Christoph Hellwig 已提交
1363
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
1364
{
1365 1366
	struct iwl_priv *priv =
		container_of(work, struct iwl_priv, beacon_update);
Z
Zhu Yi 已提交
1367 1368 1369
	struct sk_buff *beacon;

	/* Pull updated AP beacon from mac80211. will fail if not in AP mode */
1370
	beacon = ieee80211_beacon_get(priv->hw, priv->vif);
Z
Zhu Yi 已提交
1371 1372

	if (!beacon) {
1373
		IWL_ERR(priv, "update beacon failed\n");
Z
Zhu Yi 已提交
1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384
		return;
	}

	mutex_lock(&priv->mutex);
	/* new beacon skb is allocated every time; dispose previous.*/
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	priv->ibss_beacon = beacon;
	mutex_unlock(&priv->mutex);

C
Christoph Hellwig 已提交
1385
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
1386 1387
}

1388
static void iwl3945_rx_beacon_notif(struct iwl_priv *priv,
1389
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1390
{
S
Samuel Ortiz 已提交
1391
#ifdef CONFIG_IWLWIFI_DEBUG
1392
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
C
Christoph Hellwig 已提交
1393
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
1394 1395
	u8 rate = beacon->beacon_notify_hdr.rate;

1396
	IWL_DEBUG_RX(priv, "beacon status %x retries %d iss %d "
Z
Zhu Yi 已提交
1397 1398 1399 1400 1401 1402 1403 1404
		"tsf %d %d rate %d\n",
		le32_to_cpu(beacon->beacon_notify_hdr.status) & TX_STATUS_MSK,
		beacon->beacon_notify_hdr.failure_frame,
		le32_to_cpu(beacon->ibss_mgr_status),
		le32_to_cpu(beacon->high_tsf),
		le32_to_cpu(beacon->low_tsf), rate);
#endif

1405
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
1406 1407 1408 1409 1410 1411
	    (!test_bit(STATUS_EXIT_PENDING, &priv->status)))
		queue_work(priv->workqueue, &priv->beacon_update);
}

/* Handle notification from uCode that card's power state is changing
 * due to software, hardware, or critical temperature RFKILL */
1412
static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
1413
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1414
{
1415
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
1416 1417 1418
	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
	unsigned long status = priv->status;

1419
	IWL_DEBUG_RF_KILL(priv, "Card state received: HW:%s SW:%s\n",
Z
Zhu Yi 已提交
1420 1421 1422
			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
			  (flags & SW_CARD_DISABLED) ? "Kill" : "On");

1423
	iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

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


	if (flags & SW_CARD_DISABLED)
		set_bit(STATUS_RF_KILL_SW, &priv->status);
	else
		clear_bit(STATUS_RF_KILL_SW, &priv->status);

1437
	iwl_scan_cancel(priv);
Z
Zhu Yi 已提交
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448

	if ((test_bit(STATUS_RF_KILL_HW, &status) !=
	     test_bit(STATUS_RF_KILL_HW, &priv->status)) ||
	    (test_bit(STATUS_RF_KILL_SW, &status) !=
	     test_bit(STATUS_RF_KILL_SW, &priv->status)))
		queue_work(priv->workqueue, &priv->rf_kill);
	else
		wake_up_interruptible(&priv->wait_command_queue);
}

/**
C
Christoph Hellwig 已提交
1449
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
1450 1451 1452 1453 1454 1455 1456
 *
 * Setup the RX handlers for each of the reply types sent from the uCode
 * to the host.
 *
 * This function chains into the hardware specific files for them to setup
 * any hardware specific handlers as well.
 */
1457
static void iwl3945_setup_rx_handlers(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1458
{
C
Christoph Hellwig 已提交
1459 1460
	priv->rx_handlers[REPLY_ALIVE] = iwl3945_rx_reply_alive;
	priv->rx_handlers[REPLY_ADD_STA] = iwl3945_rx_reply_add_sta;
1461
	priv->rx_handlers[REPLY_ERROR] = iwl_rx_reply_error;
1462
	priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl_rx_csa;
A
Abhijeet Kolekar 已提交
1463
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
1464
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
A
Abhijeet Kolekar 已提交
1465
	    iwl_rx_pm_debug_statistics_notif;
C
Christoph Hellwig 已提交
1466
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
1467

1468 1469 1470 1471
	/*
	 * The same handler is used for both the REPLY to a discrete
	 * statistics request from the host as well as for the periodic
	 * statistics notifications (after received beacons) from the uCode.
Z
Zhu Yi 已提交
1472
	 */
C
Christoph Hellwig 已提交
1473 1474
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
1475

1476
	iwl_setup_spectrum_handlers(priv);
1477
	iwl_setup_rx_scan_handlers(priv);
C
Christoph Hellwig 已提交
1478
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
1479

1480
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
1481
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505
}

/************************** RX-FUNCTIONS ****************************/
/*
 * Rx theory of operation
 *
 * The host allocates 32 DMA target addresses and passes the host address
 * to the firmware at register IWL_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
 * 0 to 31
 *
 * Rx Queue Indexes
 * The host/firmware share two index registers for managing the Rx buffers.
 *
 * The READ index maps to the first position that the firmware may be writing
 * to -- the driver can read up to (but not including) this position and get
 * good data.
 * The READ index is managed by the firmware once the card is enabled.
 *
 * The WRITE index maps to the last position the driver has read from -- the
 * position preceding WRITE is the last slot the firmware can place a packet.
 *
 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
 * WRITE = READ.
 *
1506
 * During initialization, the host sets up the READ queue position to the first
Z
Zhu Yi 已提交
1507 1508
 * INDEX position, and WRITE to the last (READ - 1 wrapped)
 *
1509
 * When the firmware places a packet in a buffer, it will advance the READ index
Z
Zhu Yi 已提交
1510 1511 1512 1513 1514 1515 1516
 * and fire the RX interrupt.  The driver can then query the READ index and
 * process as many packets as possible, moving the WRITE index forward as it
 * resets the Rx queue buffers with new memory.
 *
 * The management in the driver is as follows:
 * + A list of pre-allocated SKBs is stored in iwl->rxq->rx_free.  When
 *   iwl->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
1517
 *   to replenish the iwl->rxq->rx_free.
C
Christoph Hellwig 已提交
1518
 * + In iwl3945_rx_replenish (scheduled) if 'processed' != 'read' then the
Z
Zhu Yi 已提交
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
 *   iwl->rxq is replenished and the READ INDEX is updated (updating the
 *   'processed' and 'read' driver indexes as well)
 * + A received packet is processed and handed to the kernel network stack,
 *   detached from the iwl->rxq.  The driver 'processed' index is updated.
 * + The Host/Firmware iwl->rxq is replenished at tasklet time from the rx_free
 *   list. If there are no allocated buffers in iwl->rxq->rx_free, the READ
 *   INDEX is not incremented and iwl->status(RX_STALLED) is set.  If there
 *   were enough free buffers and RX_STALLED is set it is cleared.
 *
 *
 * Driver sequence:
 *
1531
 * iwl3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
C
Christoph Hellwig 已提交
1532
 *                            iwl3945_rx_queue_restock
1533
 * iwl3945_rx_queue_restock() Moves available buffers from rx_free into Rx
Z
Zhu Yi 已提交
1534 1535
 *                            queue, updates firmware pointers, and updates
 *                            the WRITE index.  If insufficient rx_free buffers
C
Christoph Hellwig 已提交
1536
 *                            are available, schedules iwl3945_rx_replenish
Z
Zhu Yi 已提交
1537 1538
 *
 * -- enable interrupts --
1539
 * ISR - iwl3945_rx()         Detach iwl_rx_mem_buffers from pool up to the
Z
Zhu Yi 已提交
1540 1541
 *                            READ INDEX, detaching the SKB from the pool.
 *                            Moves the packet buffer from queue to rx_used.
C
Christoph Hellwig 已提交
1542
 *                            Calls iwl3945_rx_queue_restock to refill any empty
Z
Zhu Yi 已提交
1543 1544 1545 1546 1547 1548
 *                            slots.
 * ...
 *
 */

/**
1549
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
1550
 */
1551
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1552 1553 1554 1555 1556 1557
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

/**
C
Christoph Hellwig 已提交
1558
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
1559
 *
1560
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
1561
 * and we have free pre-allocated buffers, fill the ranks as much
1562
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
1563 1564 1565 1566 1567
 *
 * This moves the 'write' index forward to catch up with 'processed', and
 * also updates the memory address in the firmware to reference the new
 * target buffer.
 */
1568
static int iwl3945_rx_queue_restock(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1569
{
1570
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1571
	struct list_head *element;
1572
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1573 1574 1575 1576 1577
	unsigned long flags;
	int write, rc;

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
1578
	while ((iwl_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
1579
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
1580
		element = rxq->rx_free.next;
1581
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
Z
Zhu Yi 已提交
1582
		list_del(element);
1583 1584

		/* Point to Rx buffer via next RBD in circular buffer */
1585
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->real_dma_addr);
Z
Zhu Yi 已提交
1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
		rxq->queue[rxq->write] = rxb;
		rxq->write = (rxq->write + 1) & RX_QUEUE_MASK;
		rxq->free_count--;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);
	/* If the pre-allocated buffer pool is dropping low, schedule to
	 * refill it */
	if (rxq->free_count <= RX_LOW_WATERMARK)
		queue_work(priv->workqueue, &priv->rx_replenish);


1597 1598
	/* If we've added more space for the firmware to place data, tell it.
	 * Increment device's write pointer in multiples of 8. */
Z
Zhu Yi 已提交
1599 1600 1601 1602 1603
	if ((write != (rxq->write & ~0x7))
	    || (abs(rxq->write - rxq->read) > 7)) {
		spin_lock_irqsave(&rxq->lock, flags);
		rxq->need_update = 1;
		spin_unlock_irqrestore(&rxq->lock, flags);
1604
		rc = iwl_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
1605 1606 1607 1608 1609 1610 1611 1612
		if (rc)
			return rc;
	}

	return 0;
}

/**
C
Christoph Hellwig 已提交
1613
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
1614 1615 1616
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
1617
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
1618
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
1619
 */
1620
static void iwl3945_rx_allocate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1621
{
1622
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1623
	struct list_head *element;
1624
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1625 1626 1627 1628
	unsigned long flags;
	spin_lock_irqsave(&rxq->lock, flags);
	while (!list_empty(&rxq->rx_used)) {
		element = rxq->rx_used.next;
1629
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
1630 1631

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
1632
		rxb->skb =
1633 1634
		    alloc_skb(priv->hw_params.rx_buf_size,
				__GFP_NOWARN | GFP_ATOMIC);
Z
Zhu Yi 已提交
1635 1636
		if (!rxb->skb) {
			if (net_ratelimit())
T
Tomas Winkler 已提交
1637
				IWL_CRIT(priv, ": Can not allocate SKB buffers\n");
Z
Zhu Yi 已提交
1638 1639 1640 1641 1642
			/* We don't reschedule replenish work here -- we will
			 * call the restock method and if it still needs
			 * more buffers it will schedule replenish */
			break;
		}
Z
Zhu Yi 已提交
1643 1644 1645 1646 1647 1648 1649 1650 1651

		/* If radiotap head is required, reserve some headroom here.
		 * The physical head count is a variable rx_stats->phy_count.
		 * We reserve 4 bytes here. Plus these extra bytes, the
		 * headroom of the physical head should be enough for the
		 * radiotap head that iwl3945 supported. See iwl3945_rt.
		 */
		skb_reserve(rxb->skb, 4);

Z
Zhu Yi 已提交
1652 1653
		priv->alloc_rxb_skb++;
		list_del(element);
1654 1655

		/* Get physical address of RB/SKB */
1656 1657 1658 1659
		rxb->real_dma_addr = pci_map_single(priv->pci_dev,
						rxb->skb->data,
						priv->hw_params.rx_buf_size,
						PCI_DMA_FROMDEVICE);
Z
Zhu Yi 已提交
1660 1661 1662 1663
		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);
1664 1665 1666 1667 1668
}

/*
 * this should be called while priv->lock is locked
 */
1669
static void __iwl3945_rx_replenish(void *data)
1670
{
1671
	struct iwl_priv *priv = data;
1672 1673 1674 1675 1676 1677 1678 1679

	iwl3945_rx_allocate(priv);
	iwl3945_rx_queue_restock(priv);
}


void iwl3945_rx_replenish(void *data)
{
1680
	struct iwl_priv *priv = data;
1681 1682 1683
	unsigned long flags;

	iwl3945_rx_allocate(priv);
Z
Zhu Yi 已提交
1684 1685

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
1686
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707
	spin_unlock_irqrestore(&priv->lock, flags);
}

/* Convert linear signal-to-noise ratio into dB */
static u8 ratio2dB[100] = {
/*	 0   1   2   3   4   5   6   7   8   9 */
	 0,  0,  6, 10, 12, 14, 16, 17, 18, 19, /* 00 - 09 */
	20, 21, 22, 22, 23, 23, 24, 25, 26, 26, /* 10 - 19 */
	26, 26, 26, 27, 27, 28, 28, 28, 29, 29, /* 20 - 29 */
	29, 30, 30, 30, 31, 31, 31, 31, 32, 32, /* 30 - 39 */
	32, 32, 32, 33, 33, 33, 33, 33, 34, 34, /* 40 - 49 */
	34, 34, 34, 34, 35, 35, 35, 35, 35, 35, /* 50 - 59 */
	36, 36, 36, 36, 36, 36, 36, 37, 37, 37, /* 60 - 69 */
	37, 37, 37, 37, 37, 38, 38, 38, 38, 38, /* 70 - 79 */
	38, 38, 38, 38, 38, 39, 39, 39, 39, 39, /* 80 - 89 */
	39, 39, 39, 39, 39, 40, 40, 40, 40, 40  /* 90 - 99 */
};

/* Calculates a relative dB value from a ratio of linear
 *   (i.e. not dB) signal levels.
 * Conversion assumes that levels are voltages (20*log), not powers (10*log). */
C
Christoph Hellwig 已提交
1708
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
1709
{
1710 1711
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
1712 1713
		return 60;

1714
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
1715
	 *   add 20 dB to make up for divide by 10 */
1716
	if (sig_ratio >= 100)
1717
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733

	/* We shouldn't see this */
	if (sig_ratio < 1)
		return 0;

	/* Use table for ratios 1:1 - 99:1 */
	return (int)ratio2dB[sig_ratio];
}

#define PERFECT_RSSI (-20) /* dBm */
#define WORST_RSSI (-95)   /* dBm */
#define RSSI_RANGE (PERFECT_RSSI - WORST_RSSI)

/* Calculate an indication of rx signal quality (a percentage, not dBm!).
 * See http://www.ces.clemson.edu/linux/signal_quality.shtml for info
 *   about formulas used below. */
C
Christoph Hellwig 已提交
1734
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768
{
	int sig_qual;
	int degradation = PERFECT_RSSI - rssi_dbm;

	/* If we get a noise measurement, use signal-to-noise ratio (SNR)
	 * as indicator; formula is (signal dbm - noise dbm).
	 * SNR at or above 40 is a great signal (100%).
	 * Below that, scale to fit SNR of 0 - 40 dB within 0 - 100% indicator.
	 * Weakest usable signal is usually 10 - 15 dB SNR. */
	if (noise_dbm) {
		if (rssi_dbm - noise_dbm >= 40)
			return 100;
		else if (rssi_dbm < noise_dbm)
			return 0;
		sig_qual = ((rssi_dbm - noise_dbm) * 5) / 2;

	/* Else use just the signal level.
	 * This formula is a least squares fit of data points collected and
	 *   compared with a reference system that had a percentage (%) display
	 *   for signal quality. */
	} else
		sig_qual = (100 * (RSSI_RANGE * RSSI_RANGE) - degradation *
			    (15 * RSSI_RANGE + 62 * degradation)) /
			   (RSSI_RANGE * RSSI_RANGE);

	if (sig_qual > 100)
		sig_qual = 100;
	else if (sig_qual < 1)
		sig_qual = 0;

	return sig_qual;
}

/**
1769
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
1770 1771 1772 1773 1774
 *
 * Uses the priv->rx_handlers callback function array to invoke
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
1775
static void iwl3945_rx_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1776
{
1777
	struct iwl_rx_mem_buffer *rxb;
1778
	struct iwl_rx_packet *pkt;
1779
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1780 1781 1782
	u32 r, i;
	int reclaim;
	unsigned long flags;
1783
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
1784
	u32 count = 8;
Z
Zhu Yi 已提交
1785

1786 1787
	/* uCode's read index (stored in shared DRAM) indicates the last Rx
	 * buffer that the driver may process (last buffer filled by ucode). */
W
Winkler, Tomas 已提交
1788
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
1789 1790
	i = rxq->read;

1791
	if (iwl_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
1792
		fill_rx = 1;
Z
Zhu Yi 已提交
1793 1794
	/* Rx interrupt, but nothing sent from uCode */
	if (i == r)
1795
		IWL_DEBUG(priv, IWL_DL_RX | IWL_DL_ISR, "r = %d, i = %d\n", r, i);
Z
Zhu Yi 已提交
1796 1797 1798 1799

	while (i != r) {
		rxb = rxq->queue[i];

1800
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
1801 1802 1803 1804 1805 1806
		 * then a bug has been introduced in the queue refilling
		 * routines -- catch it here */
		BUG_ON(rxb == NULL);

		rxq->queue[i] = NULL;

1807
		pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->real_dma_addr,
1808
					    priv->hw_params.rx_buf_size,
Z
Zhu Yi 已提交
1809
					    PCI_DMA_FROMDEVICE);
1810
		pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823

		/* Reclaim a command buffer only if this packet is a response
		 *   to a (driver-originated) command.
		 * If the packet (e.g. Rx frame) originated from uCode,
		 *   there is no command buffer to reclaim.
		 * Ucode should set SEQ_RX_FRAME bit if ucode-originated,
		 *   but apparently a few don't get set; catch them here. */
		reclaim = !(pkt->hdr.sequence & SEQ_RX_FRAME) &&
			(pkt->hdr.cmd != STATISTICS_NOTIFICATION) &&
			(pkt->hdr.cmd != REPLY_TX);

		/* Based on type of command response or notification,
		 *   handle those that need handling via function in
C
Christoph Hellwig 已提交
1824
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
1825
		if (priv->rx_handlers[pkt->hdr.cmd]) {
1826
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1827 1828 1829 1830 1831
				"r = %d, i = %d, %s, 0x%02x\n", r, i,
				get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
			priv->rx_handlers[pkt->hdr.cmd] (priv, rxb);
		} else {
			/* No handling needed */
1832
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1833 1834 1835 1836 1837 1838
				"r %d i %d No handler needed for %s, 0x%02x\n",
				r, i, get_cmd_string(pkt->hdr.cmd),
				pkt->hdr.cmd);
		}

		if (reclaim) {
1839
			/* Invoke any callbacks, transfer the skb to caller, and
1840
			 * fire off the (possibly) blocking iwl_send_cmd()
Z
Zhu Yi 已提交
1841 1842
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
1843
				iwl_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
1844
			else
1845
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856
		}

		/* For now we just don't re-use anything.  We can tweak this
		 * later to try and re-use notification packets and SKBs that
		 * fail to Rx correctly */
		if (rxb->skb != NULL) {
			priv->alloc_rxb_skb--;
			dev_kfree_skb_any(rxb->skb);
			rxb->skb = NULL;
		}

1857
		pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
1858 1859
				priv->hw_params.rx_buf_size,
				PCI_DMA_FROMDEVICE);
Z
Zhu Yi 已提交
1860 1861 1862 1863
		spin_lock_irqsave(&rxq->lock, flags);
		list_add_tail(&rxb->list, &priv->rxq.rx_used);
		spin_unlock_irqrestore(&rxq->lock, flags);
		i = (i + 1) & RX_QUEUE_MASK;
1864 1865 1866 1867 1868 1869 1870 1871 1872 1873
		/* If there are a lot of unused frames,
		 * restock the Rx queue so ucode won't assert. */
		if (fill_rx) {
			count++;
			if (count >= 8) {
				priv->rxq.read = i;
				__iwl3945_rx_replenish(priv);
				count = 0;
			}
		}
Z
Zhu Yi 已提交
1874 1875 1876 1877
	}

	/* Backtrack one entry */
	priv->rxq.read = i;
C
Christoph Hellwig 已提交
1878
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1879 1880
}

1881
/* call this function to flush any scheduled tasklet */
1882
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
1883
{
T
Tomas Winkler 已提交
1884
	/* wait to make sure we flush pending tasklet*/
1885 1886 1887 1888
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}

Z
Zhu Yi 已提交
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911
static const char *desc_lookup(int i)
{
	switch (i) {
	case 1:
		return "FAIL";
	case 2:
		return "BAD_PARAM";
	case 3:
		return "BAD_CHECKSUM";
	case 4:
		return "NMI_INTERRUPT";
	case 5:
		return "SYSASSERT";
	case 6:
		return "FATAL_ERROR";
	}

	return "UNKNOWN";
}

#define ERROR_START_OFFSET  (1 * sizeof(u32))
#define ERROR_ELEM_SIZE     (7 * sizeof(u32))

1912
static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1913 1914 1915 1916 1917 1918 1919 1920
{
	u32 i;
	u32 desc, time, count, base, data1;
	u32 blink1, blink2, ilink1, ilink2;
	int rc;

	base = le32_to_cpu(priv->card_alive.error_event_table_ptr);

C
Christoph Hellwig 已提交
1921
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1922
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1923 1924 1925
		return;
	}

1926
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
1927
	if (rc) {
1928
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
1929 1930 1931
		return;
	}

1932
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
1933 1934

	if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
1935 1936 1937
		IWL_ERR(priv, "Start IWL Error Log Dump:\n");
		IWL_ERR(priv, "Status: 0x%08lX, count: %d\n",
			priv->status, count);
Z
Zhu Yi 已提交
1938 1939
	}

1940
	IWL_ERR(priv, "Desc       Time       asrtPC  blink2 "
Z
Zhu Yi 已提交
1941 1942 1943 1944
		  "ilink1  nmiPC   Line\n");
	for (i = ERROR_START_OFFSET;
	     i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
	     i += ERROR_ELEM_SIZE) {
1945
		desc = iwl_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
1946
		time =
1947
		    iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
1948
		blink1 =
1949
		    iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
1950
		blink2 =
1951
		    iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
1952
		ilink1 =
1953
		    iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
1954
		ilink2 =
1955
		    iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
1956
		data1 =
1957
		    iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
1958

1959 1960 1961 1962
		IWL_ERR(priv,
			"%-13s (#%d) %010u 0x%05X 0x%05X 0x%05X 0x%05X %u\n\n",
			desc_lookup(desc), desc, time, blink1, blink2,
			ilink1, ilink2, data1);
Z
Zhu Yi 已提交
1963 1964
	}

1965
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
1966 1967 1968

}

1969
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
1970 1971

/**
C
Christoph Hellwig 已提交
1972
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
1973
 *
1974
 * NOTE: Must be called with iwl_grab_nic_access() already obtained!
Z
Zhu Yi 已提交
1975
 */
1976
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999
				u32 num_events, u32 mode)
{
	u32 i;
	u32 base;       /* SRAM byte address of event log header */
	u32 event_size;	/* 2 u32s, or 3 u32s if timestamp recorded */
	u32 ptr;        /* SRAM byte address of log data */
	u32 ev, time, data; /* event log data */

	if (num_events == 0)
		return;

	base = le32_to_cpu(priv->card_alive.log_event_table_ptr);

	if (mode == 0)
		event_size = 2 * sizeof(u32);
	else
		event_size = 3 * sizeof(u32);

	ptr = base + EVENT_START_OFFSET + (start_idx * event_size);

	/* "time" is actually "data" for mode 0 (no timestamp).
	 * place event id # at far right for easier visual parsing. */
	for (i = 0; i < num_events; i++) {
2000
		ev = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
2001
		ptr += sizeof(u32);
2002
		time = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
2003
		ptr += sizeof(u32);
2004 2005 2006 2007
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
		} else {
2008
			data = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
2009
			ptr += sizeof(u32);
2010
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
Z
Zhu Yi 已提交
2011 2012 2013 2014
		}
	}
}

2015
static void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
{
	int rc;
	u32 base;       /* SRAM byte address of event log header */
	u32 capacity;   /* event log capacity in # entries */
	u32 mode;       /* 0 - no timestamp, 1 - timestamp recorded */
	u32 num_wraps;  /* # times uCode wrapped to top of log */
	u32 next_entry; /* index of next entry to be written by uCode */
	u32 size;       /* # entries that we'll print */

	base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
C
Christoph Hellwig 已提交
2026
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
2027
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
2028 2029 2030
		return;
	}

2031
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2032
	if (rc) {
2033
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
2034 2035 2036 2037
		return;
	}

	/* event log header */
2038 2039 2040 2041
	capacity = iwl_read_targ_mem(priv, base);
	mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32)));
	num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32)));
	next_entry = iwl_read_targ_mem(priv, base + (3 * sizeof(u32)));
Z
Zhu Yi 已提交
2042 2043 2044 2045 2046

	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
2047
		IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
2048
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2049 2050 2051
		return;
	}

2052
	IWL_ERR(priv, "Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
2053 2054 2055 2056 2057
		  size, num_wraps);

	/* if uCode has wrapped back to top of log, start at the oldest entry,
	 * i.e the next one that uCode would fill. */
	if (num_wraps)
C
Christoph Hellwig 已提交
2058
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
2059 2060 2061
				    capacity - next_entry, mode);

	/* (then/else) start at top of log */
C
Christoph Hellwig 已提交
2062
	iwl3945_print_event_log(priv, 0, next_entry, mode);
Z
Zhu Yi 已提交
2063

2064
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2065 2066
}

2067
static void iwl3945_error_recovery(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2068 2069 2070
{
	unsigned long flags;

2071 2072 2073
	memcpy(&priv->staging_rxon, &priv->recovery_rxon,
	       sizeof(priv->staging_rxon));
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
2074
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
2075

C
Christoph Hellwig 已提交
2076
	iwl3945_add_station(priv, priv->bssid, 1, 0);
Z
Zhu Yi 已提交
2077 2078

	spin_lock_irqsave(&priv->lock, flags);
2079
	priv->assoc_id = le16_to_cpu(priv->staging_rxon.assoc_id);
Z
Zhu Yi 已提交
2080 2081 2082 2083
	priv->error_recovering = 0;
	spin_unlock_irqrestore(&priv->lock, flags);
}

2084
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2085 2086 2087 2088
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
S
Samuel Ortiz 已提交
2089
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
2090 2091 2092 2093 2094 2095 2096 2097
	u32 inta_mask;
#endif

	spin_lock_irqsave(&priv->lock, flags);

	/* Ack/clear/reset pending uCode interrupts.
	 * Note:  Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
	 *  and will clear only when CSR_FH_INT_STATUS gets cleared. */
2098 2099
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
2100 2101 2102 2103

	/* Ack/clear/reset pending flow-handler (DMA) interrupts.
	 * Any new interrupts that happen after this, either while we're
	 * in this tasklet, or later, will show up in next ISR/tasklet. */
2104 2105
	inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
	iwl_write32(priv, CSR_FH_INT_STATUS, inta_fh);
Z
Zhu Yi 已提交
2106

S
Samuel Ortiz 已提交
2107
#ifdef CONFIG_IWLWIFI_DEBUG
2108
	if (priv->debug_level & IWL_DL_ISR) {
2109
		/* just for debug */
2110
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
2111
		IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
Z
Zhu Yi 已提交
2112 2113 2114 2115 2116 2117 2118 2119
			      inta, inta_mask, inta_fh);
	}
#endif

	/* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
	 * atomic, make sure that inta covers all the interrupts that
	 * we've discovered, even if FH interrupt came in just after
	 * reading CSR_INT. */
T
Tomas Winkler 已提交
2120
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
2121
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
2122
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
2123 2124 2125 2126
		inta |= CSR_INT_BIT_FH_TX;

	/* Now service all interrupt bits discovered above. */
	if (inta & CSR_INT_BIT_HW_ERR) {
2127
		IWL_ERR(priv, "Microcode HW error detected.  Restarting.\n");
Z
Zhu Yi 已提交
2128 2129

		/* Tell the device to stop sending interrupts */
2130
		iwl_disable_interrupts(priv);
Z
Zhu Yi 已提交
2131

2132
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
2133 2134 2135 2136 2137 2138 2139 2140

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

S
Samuel Ortiz 已提交
2141
#ifdef CONFIG_IWLWIFI_DEBUG
2142
	if (priv->debug_level & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
2143
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
2144
		if (inta & CSR_INT_BIT_SCD)
2145
			IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
2146
				      "the frame/frames.\n");
Z
Zhu Yi 已提交
2147 2148 2149

		/* Alive notification via Rx interrupt will do the real work */
		if (inta & CSR_INT_BIT_ALIVE)
2150
			IWL_DEBUG_ISR(priv, "Alive interrupt\n");
Z
Zhu Yi 已提交
2151 2152 2153
	}
#endif
	/* Safely ignore these bits for debug checks below */
2154
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
2155 2156 2157

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
2158 2159
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
2160
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
2161 2162 2163 2164 2165
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
2166
		IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
2167
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
2168 2169 2170 2171 2172 2173
		iwl_txq_update_write_ptr(priv, &priv->txq[0]);
		iwl_txq_update_write_ptr(priv, &priv->txq[1]);
		iwl_txq_update_write_ptr(priv, &priv->txq[2]);
		iwl_txq_update_write_ptr(priv, &priv->txq[3]);
		iwl_txq_update_write_ptr(priv, &priv->txq[4]);
		iwl_txq_update_write_ptr(priv, &priv->txq[5]);
Z
Zhu Yi 已提交
2174 2175 2176 2177 2178 2179 2180 2181

		handled |= CSR_INT_BIT_WAKEUP;
	}

	/* All uCode command responses, including Tx command responses,
	 * Rx "responses" (frame-received notification), and other
	 * notifications from uCode come through here*/
	if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
C
Christoph Hellwig 已提交
2182
		iwl3945_rx_handle(priv);
Z
Zhu Yi 已提交
2183 2184 2185 2186
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

	if (inta & CSR_INT_BIT_FH_TX) {
2187
		IWL_DEBUG_ISR(priv, "Tx interrupt\n");
Z
Zhu Yi 已提交
2188

2189 2190 2191
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
		if (!iwl_grab_nic_access(priv)) {
			iwl_write_direct32(priv, FH39_TCSR_CREDIT
2192
					     (FH39_SRVC_CHNL), 0x0);
2193
			iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2194 2195 2196 2197 2198
		}
		handled |= CSR_INT_BIT_FH_TX;
	}

	if (inta & ~handled)
2199
		IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
Z
Zhu Yi 已提交
2200 2201

	if (inta & ~CSR_INI_SET_MASK) {
2202
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
Z
Zhu Yi 已提交
2203
			 inta & ~CSR_INI_SET_MASK);
2204
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
2205 2206 2207
	}

	/* Re-enable all interrupts */
2208 2209
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
2210
		iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
2211

S
Samuel Ortiz 已提交
2212
#ifdef CONFIG_IWLWIFI_DEBUG
2213
	if (priv->debug_level & (IWL_DL_ISR)) {
2214 2215 2216
		inta = iwl_read32(priv, CSR_INT);
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
2217
		IWL_DEBUG_ISR(priv, "End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
Z
Zhu Yi 已提交
2218 2219 2220 2221 2222 2223
			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
	}
#endif
	spin_unlock_irqrestore(&priv->lock, flags);
}

2224
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
2225
					 enum ieee80211_band band,
2226
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
2227
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
2228 2229
{
	const struct ieee80211_channel *channels = NULL;
2230
	const struct ieee80211_supported_band *sband;
2231
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
2232 2233 2234 2235
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
2236
	sband = iwl_get_hw_mode(priv, band);
2237
	if (!sband)
Z
Zhu Yi 已提交
2238 2239
		return 0;

2240
	channels = sband->channels;
Z
Zhu Yi 已提交
2241

S
Samuel Ortiz 已提交
2242 2243
	active_dwell = iwl_get_active_dwell_time(priv, band, n_probes);
	passive_dwell = iwl_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
2244

2245 2246 2247
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

2248
	for (i = 0, added = 0; i < sband->n_channels; i++) {
2249 2250 2251
		if (channels[i].flags & IEEE80211_CHAN_DISABLED)
			continue;

2252
		scan_ch->channel = channels[i].hw_value;
Z
Zhu Yi 已提交
2253

2254
		ch_info = iwl_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
2255
		if (!is_channel_valid(ch_info)) {
2256
			IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
2257 2258 2259 2260
				       scan_ch->channel);
			continue;
		}

2261 2262 2263 2264 2265
		scan_ch->active_dwell = cpu_to_le16(active_dwell);
		scan_ch->passive_dwell = cpu_to_le16(passive_dwell);
		/* If passive , set up for auto-switch
		 *  and use long active_dwell time.
		 */
Z
Zhu Yi 已提交
2266
		if (!is_active || is_channel_passive(ch_info) ||
2267
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
2268
			scan_ch->type = 0;	/* passive */
2269 2270 2271
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
2272
			scan_ch->type = 1;	/* active */
2273
		}
Z
Zhu Yi 已提交
2274

2275 2276 2277 2278 2279 2280
		/* Set direct probe bits. These may be used both for active
		 * scan channels (probes gets sent right away),
		 * or for passive channels (probes get se sent only after
		 * hearing clear Rx packet).*/
		if (IWL_UCODE_API(priv->ucode_ver) >= 2) {
			if (n_probes)
2281
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
2282 2283 2284 2285
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
2286
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
2287
		}
Z
Zhu Yi 已提交
2288

2289
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
2290 2291 2292 2293
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
2294
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
2295 2296 2297 2298
			scan_ch->tpc.tx_gain = ((1 << 5) | (3 << 3)) | 3;
		else {
			scan_ch->tpc.tx_gain = ((1 << 5) | (5 << 3));
			/* NOTE: if we were doing 6Mb OFDM for scans we'd use
2299
			 * power level:
2300
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
2301 2302 2303
			 */
		}

2304
		IWL_DEBUG_SCAN(priv, "Scanning %d [%s %d]\n",
Z
Zhu Yi 已提交
2305 2306 2307 2308 2309 2310 2311 2312 2313
			       scan_ch->channel,
			       (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
			       (scan_ch->type & 1) ?
			       active_dwell : passive_dwell);

		scan_ch++;
		added++;
	}

2314
	IWL_DEBUG_SCAN(priv, "total channels to scan %d \n", added);
Z
Zhu Yi 已提交
2315 2316 2317
	return added;
}

2318
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
2319 2320 2321 2322 2323
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
2324 2325 2326 2327
		rates[i].bitrate = iwl3945_rates[i].ieee * 5;
		rates[i].hw_value = i; /* Rate scaling will work on indexes */
		rates[i].hw_value_short = i;
		rates[i].flags = 0;
2328
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
2329
			/*
2330
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
2331
			 */
C
Christoph Hellwig 已提交
2332
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
2333
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
2334 2335 2336 2337 2338 2339 2340 2341 2342 2343
		}
	}
}

/******************************************************************************
 *
 * uCode download functions
 *
 ******************************************************************************/

2344
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2345
{
2346 2347 2348 2349 2350 2351
	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_code);
	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_data);
	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_data_backup);
	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_init);
	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_init_data);
	iwl_free_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
2352 2353 2354
}

/**
C
Christoph Hellwig 已提交
2355
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2356 2357
 *     looking at all data.
 */
2358
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2359 2360 2361 2362 2363 2364
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

2365
	IWL_DEBUG_INFO(priv, "ucode inst image size is %u\n", len);
Z
Zhu Yi 已提交
2366

2367
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2368 2369 2370
	if (rc)
		return rc;

2371
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2372
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
2373 2374 2375 2376 2377 2378

	errcnt = 0;
	for (; len > 0; len -= sizeof(u32), image++) {
		/* read data comes through single port, auto-incr addr */
		/* NOTE: Use the debugless read so we don't flood kernel log
		 * if IWL_DL_IO is set */
2379
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2380
		if (val != le32_to_cpu(*image)) {
2381
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2382 2383 2384 2385 2386 2387 2388 2389 2390
				  "offset 0x%x, is 0x%x, s/b 0x%x\n",
				  save_len - len, val, le32_to_cpu(*image));
			rc = -EIO;
			errcnt++;
			if (errcnt >= 20)
				break;
		}
	}

2391
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2392 2393

	if (!errcnt)
2394 2395
		IWL_DEBUG_INFO(priv,
			"ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
2396 2397 2398 2399 2400 2401

	return rc;
}


/**
C
Christoph Hellwig 已提交
2402
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2403 2404 2405
 *   using sample data 100 bytes apart.  If these sample points are good,
 *   it's a pretty good bet that everything between them is good, too.
 */
2406
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2407 2408 2409 2410 2411 2412
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

2413
	IWL_DEBUG_INFO(priv, "ucode inst image size is %u\n", len);
Z
Zhu Yi 已提交
2414

2415
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2416 2417 2418 2419 2420 2421 2422
	if (rc)
		return rc;

	for (i = 0; i < len; i += 100, image += 100/sizeof(u32)) {
		/* read data comes through single port, auto-incr addr */
		/* NOTE: Use the debugless read so we don't flood kernel log
		 * if IWL_DL_IO is set */
2423
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2424
			i + IWL39_RTC_INST_LOWER_BOUND);
2425
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2426 2427
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
2428
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2429 2430 2431 2432 2433 2434 2435 2436 2437 2438
				  "offset 0x%x, is 0x%x, s/b 0x%x\n",
				  i, val, *image);
#endif
			rc = -EIO;
			errcnt++;
			if (errcnt >= 3)
				break;
		}
	}

2439
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2440 2441 2442 2443 2444 2445

	return rc;
}


/**
C
Christoph Hellwig 已提交
2446
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
2447 2448
 *    and verify its contents
 */
2449
static int iwl3945_verify_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2450 2451 2452 2453 2454 2455 2456 2457
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2458
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2459
	if (rc == 0) {
2460
		IWL_DEBUG_INFO(priv, "Bootstrap uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2461 2462 2463 2464 2465 2466
		return 0;
	}

	/* Try initialize */
	image = (__le32 *)priv->ucode_init.v_addr;
	len = priv->ucode_init.len;
C
Christoph Hellwig 已提交
2467
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2468
	if (rc == 0) {
2469
		IWL_DEBUG_INFO(priv, "Initialize uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2470 2471 2472 2473 2474 2475
		return 0;
	}

	/* Try runtime/protocol */
	image = (__le32 *)priv->ucode_code.v_addr;
	len = priv->ucode_code.len;
C
Christoph Hellwig 已提交
2476
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2477
	if (rc == 0) {
2478
		IWL_DEBUG_INFO(priv, "Runtime uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2479 2480 2481
		return 0;
	}

2482
	IWL_ERR(priv, "NO VALID UCODE IMAGE IN INSTRUCTION SRAM!!\n");
Z
Zhu Yi 已提交
2483

2484 2485 2486
	/* Since nothing seems to match, show first several data entries in
	 * instruction SRAM, so maybe visual inspection will give a clue.
	 * Selection of bootstrap image (vs. other images) is arbitrary. */
Z
Zhu Yi 已提交
2487 2488
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2489
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
2490 2491 2492 2493

	return rc;
}

2494
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2495 2496
{
	/* Remove all resets to allow NIC to operate */
2497
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
2498 2499 2500
}

/**
C
Christoph Hellwig 已提交
2501
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
2502 2503 2504
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
2505
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2506
{
2507
	struct iwl_ucode *ucode;
2508
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
2509 2510
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
2511 2512 2513 2514
	const char *name_pre = priv->cfg->fw_name_pre;
	const unsigned int api_max = priv->cfg->ucode_api_max;
	const unsigned int api_min = priv->cfg->ucode_api_min;
	char buf[25];
Z
Zhu Yi 已提交
2515 2516
	u8 *src;
	size_t len;
2517
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
2518 2519 2520

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
2521 2522 2523 2524
	for (index = api_max; index >= api_min; index--) {
		sprintf(buf, "%s%u%s", name_pre, index, ".ucode");
		ret = request_firmware(&ucode_raw, buf, &priv->pci_dev->dev);
		if (ret < 0) {
2525
			IWL_ERR(priv, "%s firmware file req failed: %d\n",
2526 2527 2528 2529 2530 2531 2532
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
2533 2534 2535
				IWL_ERR(priv, "Loaded firmware %s, "
					"which is deprecated. "
					" Please use API v%u instead.\n",
2536
					  buf, api_max);
2537 2538
			IWL_DEBUG_INFO(priv, "Got firmware '%s' file "
				       "(%zd bytes) from disk\n",
2539 2540 2541
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
2542 2543
	}

2544 2545
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
2546 2547 2548

	/* Make sure that we got at least our header! */
	if (ucode_raw->size < sizeof(*ucode)) {
2549
		IWL_ERR(priv, "File size way too small!\n");
2550
		ret = -EINVAL;
Z
Zhu Yi 已提交
2551 2552 2553 2554 2555 2556
		goto err_release;
	}

	/* Data from ucode file:  header followed by uCode images */
	ucode = (void *)ucode_raw->data;

2557
	priv->ucode_ver = le32_to_cpu(ucode->ver);
2558
	api_ver = IWL_UCODE_API(priv->ucode_ver);
Z
Zhu Yi 已提交
2559 2560 2561 2562 2563 2564
	inst_size = le32_to_cpu(ucode->inst_size);
	data_size = le32_to_cpu(ucode->data_size);
	init_size = le32_to_cpu(ucode->init_size);
	init_data_size = le32_to_cpu(ucode->init_data_size);
	boot_size = le32_to_cpu(ucode->boot_size);

2565 2566
	/* api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
2567
	 * on the API version read from firmware header from here on forward */
2568 2569

	if (api_ver < api_min || api_ver > api_max) {
2570
		IWL_ERR(priv, "Driver unable to support your firmware API. "
2571 2572 2573 2574 2575 2576 2577
			  "Driver supports v%u, firmware is v%u.\n",
			  api_max, api_ver);
		priv->ucode_ver = 0;
		ret = -EINVAL;
		goto err_release;
	}
	if (api_ver != api_max)
2578
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
2579 2580 2581 2582
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
2583 2584 2585 2586 2587 2588
	IWL_INFO(priv, "loaded firmware version %u.%u.%u.%u\n",
		IWL_UCODE_MAJOR(priv->ucode_ver),
		IWL_UCODE_MINOR(priv->ucode_ver),
		IWL_UCODE_API(priv->ucode_ver),
		IWL_UCODE_SERIAL(priv->ucode_ver));

2589
	IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
2590
		       priv->ucode_ver);
2591 2592 2593 2594 2595 2596 2597 2598 2599 2600
	IWL_DEBUG_INFO(priv, "f/w package hdr runtime inst size = %u\n",
		       inst_size);
	IWL_DEBUG_INFO(priv, "f/w package hdr runtime data size = %u\n",
		       data_size);
	IWL_DEBUG_INFO(priv, "f/w package hdr init inst size = %u\n",
		       init_size);
	IWL_DEBUG_INFO(priv, "f/w package hdr init data size = %u\n",
		       init_data_size);
	IWL_DEBUG_INFO(priv, "f/w package hdr boot inst size = %u\n",
		       boot_size);
Z
Zhu Yi 已提交
2601

2602

Z
Zhu Yi 已提交
2603 2604 2605 2606 2607
	/* Verify size of file vs. image size info in file's header */
	if (ucode_raw->size < sizeof(*ucode) +
		inst_size + data_size + init_size +
		init_data_size + boot_size) {

2608 2609
		IWL_DEBUG_INFO(priv, "uCode file size %zd too small\n",
			       ucode_raw->size);
2610
		ret = -EINVAL;
Z
Zhu Yi 已提交
2611 2612 2613 2614
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
2615
	if (inst_size > IWL39_MAX_INST_SIZE) {
2616
		IWL_DEBUG_INFO(priv, "uCode instr len %d too large to fit in\n",
2617 2618
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2619 2620 2621
		goto err_release;
	}

2622
	if (data_size > IWL39_MAX_DATA_SIZE) {
2623
		IWL_DEBUG_INFO(priv, "uCode data len %d too large to fit in\n",
2624 2625
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2626 2627
		goto err_release;
	}
2628
	if (init_size > IWL39_MAX_INST_SIZE) {
2629 2630
		IWL_DEBUG_INFO(priv,
				"uCode init instr len %d too large to fit in\n",
2631 2632
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2633 2634
		goto err_release;
	}
2635
	if (init_data_size > IWL39_MAX_DATA_SIZE) {
2636 2637
		IWL_DEBUG_INFO(priv,
				"uCode init data len %d too large to fit in\n",
2638 2639
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2640 2641
		goto err_release;
	}
2642
	if (boot_size > IWL39_MAX_BSM_SIZE) {
2643 2644
		IWL_DEBUG_INFO(priv,
				"uCode boot instr len %d too large to fit in\n",
2645 2646
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2647 2648 2649 2650 2651 2652 2653 2654 2655
		goto err_release;
	}

	/* Allocate ucode buffers for card's bus-master loading ... */

	/* Runtime instructions and 2 copies of data:
	 * 1) unmodified from disk
	 * 2) backup cache for save/restore during power-downs */
	priv->ucode_code.len = inst_size;
2656
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
2657 2658

	priv->ucode_data.len = data_size;
2659
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
2660 2661

	priv->ucode_data_backup.len = data_size;
2662
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data_backup);
Z
Zhu Yi 已提交
2663

2664 2665 2666
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
2667 2668

	/* Initialization instructions and data */
2669 2670
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
2671
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
2672 2673

		priv->ucode_init_data.len = init_data_size;
2674
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
2675 2676 2677 2678

		if (!priv->ucode_init.v_addr || !priv->ucode_init_data.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
2679 2680

	/* Bootstrap (instructions only, no data) */
2681 2682
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
2683
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
2684

2685 2686 2687
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
2688 2689 2690 2691 2692 2693

	/* Copy images into buffers for card's bus-master reads ... */

	/* Runtime instructions (first block of data in file) */
	src = &ucode->data[0];
	len = priv->ucode_code.len;
2694 2695
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode instr len %zd\n", len);
Z
Zhu Yi 已提交
2696
	memcpy(priv->ucode_code.v_addr, src, len);
2697
	IWL_DEBUG_INFO(priv, "uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
Z
Zhu Yi 已提交
2698 2699 2700
		priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
2701
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
Z
Zhu Yi 已提交
2702 2703
	src = &ucode->data[inst_size];
	len = priv->ucode_data.len;
2704 2705
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode data len %zd\n", len);
Z
Zhu Yi 已提交
2706 2707 2708 2709 2710 2711 2712
	memcpy(priv->ucode_data.v_addr, src, len);
	memcpy(priv->ucode_data_backup.v_addr, src, len);

	/* Initialization instructions (3rd block) */
	if (init_size) {
		src = &ucode->data[inst_size + data_size];
		len = priv->ucode_init.len;
2713 2714
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init instr len %zd\n", len);
Z
Zhu Yi 已提交
2715 2716 2717 2718 2719 2720 2721
		memcpy(priv->ucode_init.v_addr, src, len);
	}

	/* Initialization data (4th block) */
	if (init_data_size) {
		src = &ucode->data[inst_size + data_size + init_size];
		len = priv->ucode_init_data.len;
2722 2723
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init data len %zd\n", len);
Z
Zhu Yi 已提交
2724 2725 2726 2727 2728 2729
		memcpy(priv->ucode_init_data.v_addr, src, len);
	}

	/* Bootstrap instructions (5th block) */
	src = &ucode->data[inst_size + data_size + init_size + init_data_size];
	len = priv->ucode_boot.len;
2730 2731
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) boot instr len %zd\n", len);
Z
Zhu Yi 已提交
2732 2733 2734 2735 2736 2737 2738
	memcpy(priv->ucode_boot.v_addr, src, len);

	/* We have our copies now, allow OS release its copies */
	release_firmware(ucode_raw);
	return 0;

 err_pci_alloc:
2739
	IWL_ERR(priv, "failed to allocate pci memory\n");
2740
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
2741
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
2742 2743 2744 2745 2746

 err_release:
	release_firmware(ucode_raw);

 error:
2747
	return ret;
Z
Zhu Yi 已提交
2748 2749 2750 2751
}


/**
C
Christoph Hellwig 已提交
2752
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
2753 2754 2755 2756 2757 2758 2759
 *
 * Tell initialization uCode where to find runtime uCode.
 *
 * BSM registers initially contain pointers to initialization uCode.
 * We need to replace them to load runtime uCode inst and data,
 * and to save runtime data when powering down.
 */
2760
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771
{
	dma_addr_t pinst;
	dma_addr_t pdata;
	int rc = 0;
	unsigned long flags;

	/* bits 31:0 for 3945 */
	pinst = priv->ucode_code.p_addr;
	pdata = priv->ucode_data_backup.p_addr;

	spin_lock_irqsave(&priv->lock, flags);
2772
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2773 2774 2775 2776 2777 2778
	if (rc) {
		spin_unlock_irqrestore(&priv->lock, flags);
		return rc;
	}

	/* Tell bootstrap uCode where to find image to load */
2779 2780 2781
	iwl_write_prph(priv, BSM_DRAM_INST_PTR_REG, pinst);
	iwl_write_prph(priv, BSM_DRAM_DATA_PTR_REG, pdata);
	iwl_write_prph(priv, BSM_DRAM_DATA_BYTECOUNT_REG,
Z
Zhu Yi 已提交
2782 2783
				 priv->ucode_data.len);

T
Tomas Winkler 已提交
2784
	/* Inst byte count must be last to set up, bit 31 signals uCode
Z
Zhu Yi 已提交
2785
	 *   that all new ptr/size info is in place */
2786
	iwl_write_prph(priv, BSM_DRAM_INST_BYTECOUNT_REG,
Z
Zhu Yi 已提交
2787 2788
				 priv->ucode_code.len | BSM_DRAM_INST_LOAD);

2789
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2790 2791 2792

	spin_unlock_irqrestore(&priv->lock, flags);

2793
	IWL_DEBUG_INFO(priv, "Runtime uCode pointers are set.\n");
Z
Zhu Yi 已提交
2794 2795 2796 2797 2798

	return rc;
}

/**
C
Christoph Hellwig 已提交
2799
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2800 2801 2802 2803
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
2804
 */
2805
static void iwl3945_init_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2806 2807 2808 2809 2810
{
	/* Check alive response for "valid" sign from uCode */
	if (priv->card_alive_init.is_valid != UCODE_VALID_OK) {
		/* We had an error bringing up the hardware, so take it
		 * all the way back down so we can try again */
2811
		IWL_DEBUG_INFO(priv, "Initialize Alive failed.\n");
Z
Zhu Yi 已提交
2812 2813 2814 2815 2816 2817
		goto restart;
	}

	/* Bootstrap uCode has loaded initialize uCode ... verify inst image.
	 * This is a paranoid check, because we would not have gotten the
	 * "initialize" alive if code weren't properly loaded.  */
C
Christoph Hellwig 已提交
2818
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2819 2820
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2821
		IWL_DEBUG_INFO(priv, "Bad \"initialize\" uCode load.\n");
Z
Zhu Yi 已提交
2822 2823 2824 2825 2826 2827
		goto restart;
	}

	/* Send pointers to protocol/runtime uCode image ... init code will
	 * load and launch runtime uCode, which will send us another "Alive"
	 * notification. */
2828
	IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
C
Christoph Hellwig 已提交
2829
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
2830 2831
		/* Runtime instruction load won't happen;
		 * take it all the way back down so we can try again */
2832
		IWL_DEBUG_INFO(priv, "Couldn't set up uCode pointers.\n");
Z
Zhu Yi 已提交
2833 2834 2835 2836 2837 2838 2839 2840 2841
		goto restart;
	}
	return;

 restart:
	queue_work(priv->workqueue, &priv->restart);
}


2842 2843 2844 2845
/* temporary */
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw,
				     struct sk_buff *skb);

Z
Zhu Yi 已提交
2846
/**
C
Christoph Hellwig 已提交
2847
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2848
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
2849
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
2850
 */
2851
static void iwl3945_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2852 2853 2854 2855 2856
{
	int rc = 0;
	int thermal_spin = 0;
	u32 rfkill;

2857
	IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
2858 2859 2860 2861

	if (priv->card_alive.is_valid != UCODE_VALID_OK) {
		/* We had an error bringing up the hardware, so take it
		 * all the way back down so we can try again */
2862
		IWL_DEBUG_INFO(priv, "Alive failed.\n");
Z
Zhu Yi 已提交
2863 2864 2865 2866 2867 2868
		goto restart;
	}

	/* Initialize uCode has loaded Runtime uCode ... verify inst image.
	 * This is a paranoid check, because we would not have gotten the
	 * "runtime" alive if code weren't properly loaded.  */
C
Christoph Hellwig 已提交
2869
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2870 2871
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2872
		IWL_DEBUG_INFO(priv, "Bad runtime uCode load.\n");
Z
Zhu Yi 已提交
2873 2874 2875
		goto restart;
	}

C
Christoph Hellwig 已提交
2876
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
2877

2878
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2879
	if (rc) {
2880
		IWL_WARN(priv, "Can not read RFKILL status from adapter\n");
Z
Zhu Yi 已提交
2881 2882 2883
		return;
	}

2884
	rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
2885
	IWL_DEBUG_INFO(priv, "RFKILL status: 0x%x\n", rfkill);
2886
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2887 2888 2889

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
2890
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
2891
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
2892
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
2893 2894 2895 2896 2897
			thermal_spin++;
			udelay(10);
		}

		if (thermal_spin)
2898
			IWL_DEBUG_INFO(priv, "Thermal calibration took %dus\n",
Z
Zhu Yi 已提交
2899 2900 2901 2902
				       thermal_spin * 10);
	} else
		set_bit(STATUS_RF_KILL_HW, &priv->status);

2903
	/* After the ALIVE response, we can send commands to 3945 uCode */
Z
Zhu Yi 已提交
2904 2905 2906 2907 2908
	set_bit(STATUS_ALIVE, &priv->status);

	/* Clear out the uCode error bit if it is set */
	clear_bit(STATUS_FW_ERROR, &priv->status);

2909
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
2910 2911
		return;

2912
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
2913 2914 2915 2916

	priv->active_rate = priv->rates_mask;
	priv->active_rate_basic = priv->rates_mask & IWL_BASIC_RATES_MASK;

2917
	iwl_power_update_mode(priv, false);
Z
Zhu Yi 已提交
2918

2919
	if (iwl_is_associated(priv)) {
C
Christoph Hellwig 已提交
2920
		struct iwl3945_rxon_cmd *active_rxon =
2921
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
2922

2923 2924
		memcpy(&priv->staging_rxon, &priv->active_rxon,
		       sizeof(priv->staging_rxon));
Z
Zhu Yi 已提交
2925 2926 2927
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
2928
		iwl_connection_init_rx_config(priv, priv->iw_mode);
Z
Zhu Yi 已提交
2929 2930
	}

2931
	/* Configure Bluetooth device coexistence support */
2932
	iwl_send_bt_config(priv);
Z
Zhu Yi 已提交
2933 2934

	/* Configure the adapter for unassociated operation */
C
Christoph Hellwig 已提交
2935
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
2936 2937 2938

	iwl3945_reg_txpower_periodic(priv);

2939 2940
	iwl3945_led_register(priv);

2941
	IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
2942
	set_bit(STATUS_READY, &priv->status);
2943
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
2944 2945

	if (priv->error_recovering)
C
Christoph Hellwig 已提交
2946
		iwl3945_error_recovery(priv);
Z
Zhu Yi 已提交
2947

2948 2949 2950 2951 2952 2953 2954 2955
	/* reassociate for ADHOC mode */
	if (priv->vif && (priv->iw_mode == NL80211_IFTYPE_ADHOC)) {
		struct sk_buff *beacon = ieee80211_beacon_get(priv->hw,
								priv->vif);
		if (beacon)
			iwl3945_mac_beacon_update(priv->hw, beacon);
	}

Z
Zhu Yi 已提交
2956 2957 2958 2959 2960 2961
	return;

 restart:
	queue_work(priv->workqueue, &priv->restart);
}

2962
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv);
Z
Zhu Yi 已提交
2963

2964
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2965 2966 2967 2968 2969
{
	unsigned long flags;
	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
	struct ieee80211_conf *conf = NULL;

2970
	IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
Z
Zhu Yi 已提交
2971 2972 2973 2974 2975 2976

	conf = ieee80211_get_hw_conf(priv->hw);

	if (!exit_pending)
		set_bit(STATUS_EXIT_PENDING, &priv->status);

M
Mohamed Abbas 已提交
2977
	iwl3945_led_unregister(priv);
C
Christoph Hellwig 已提交
2978
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
2979 2980 2981 2982 2983 2984 2985 2986 2987 2988

	/* Unblock any waiting calls */
	wake_up_interruptible_all(&priv->wait_command_queue);

	/* Wipe out the EXIT_PENDING status bit if we are not actually
	 * exiting the module */
	if (!exit_pending)
		clear_bit(STATUS_EXIT_PENDING, &priv->status);

	/* stop and reset the on-board processor */
2989
	iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
Z
Zhu Yi 已提交
2990 2991

	/* tell the device to stop sending interrupts */
2992
	spin_lock_irqsave(&priv->lock, flags);
2993
	iwl_disable_interrupts(priv);
2994 2995
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
2996 2997 2998 2999

	if (priv->mac80211_registered)
		ieee80211_stop_queues(priv->hw);

C
Christoph Hellwig 已提交
3000
	/* If we have not previously called iwl3945_init() then
Z
Zhu Yi 已提交
3001
	 * clear all bits but the RF Kill and SUSPEND bits and return */
3002
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
3003 3004 3005 3006
		priv->status = test_bit(STATUS_RF_KILL_HW, &priv->status) <<
					STATUS_RF_KILL_HW |
			       test_bit(STATUS_RF_KILL_SW, &priv->status) <<
					STATUS_RF_KILL_SW |
3007 3008
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
3009
			       test_bit(STATUS_IN_SUSPEND, &priv->status) <<
3010 3011 3012
					STATUS_IN_SUSPEND |
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
3013 3014 3015 3016 3017 3018 3019 3020 3021
		goto exit;
	}

	/* ...otherwise clear out all the status bits but the RF Kill and
	 * SUSPEND bits and continue taking the NIC down. */
	priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
				STATUS_RF_KILL_HW |
			test_bit(STATUS_RF_KILL_SW, &priv->status) <<
				STATUS_RF_KILL_SW |
3022 3023
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
3024 3025 3026
			test_bit(STATUS_IN_SUSPEND, &priv->status) <<
				STATUS_IN_SUSPEND |
			test_bit(STATUS_FW_ERROR, &priv->status) <<
3027 3028 3029
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
3030

3031
	priv->cfg->ops->lib->apm_ops.reset(priv);
Z
Zhu Yi 已提交
3032
	spin_lock_irqsave(&priv->lock, flags);
3033
	iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
Z
Zhu Yi 已提交
3034 3035
	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
3036 3037
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
3038 3039

	spin_lock_irqsave(&priv->lock, flags);
3040 3041
	if (!iwl_grab_nic_access(priv)) {
		iwl_write_prph(priv, APMG_CLK_DIS_REG,
Z
Zhu Yi 已提交
3042
					 APMG_CLK_VAL_DMA_CLK_RQT);
3043
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3044 3045 3046 3047 3048
	}
	spin_unlock_irqrestore(&priv->lock, flags);

	udelay(5);

3049 3050 3051 3052 3053
	if (exit_pending || test_bit(STATUS_IN_SUSPEND, &priv->status))
		priv->cfg->ops->lib->apm_ops.stop(priv);
	else
		priv->cfg->ops->lib->apm_ops.reset(priv);

Z
Zhu Yi 已提交
3054
 exit:
3055
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
3056 3057 3058 3059 3060 3061

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
3062
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
3063 3064
}

3065
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3066 3067
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3068
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
3069
	mutex_unlock(&priv->mutex);
3070

C
Christoph Hellwig 已提交
3071
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
3072 3073 3074 3075
}

#define MAX_HW_RESTARTS 5

3076
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3077 3078 3079 3080
{
	int rc, i;

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
3081
		IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
Z
Zhu Yi 已提交
3082 3083 3084 3085
		return -EIO;
	}

	if (test_bit(STATUS_RF_KILL_SW, &priv->status)) {
3086
		IWL_WARN(priv, "Radio disabled by SW RF kill (module "
Z
Zhu Yi 已提交
3087
			    "parameter)\n");
3088 3089 3090
		return -ENODEV;
	}

3091
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
3092
		IWL_ERR(priv, "ucode not available for device bring up\n");
3093 3094 3095
		return -EIO;
	}

3096
	/* If platform's RF_KILL switch is NOT set to KILL */
3097
	if (iwl_read32(priv, CSR_GP_CNTRL) &
3098 3099 3100 3101 3102
				CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
	else {
		set_bit(STATUS_RF_KILL_HW, &priv->status);
		if (!test_bit(STATUS_IN_SUSPEND, &priv->status)) {
3103
			IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
3104 3105
			return -ENODEV;
		}
Z
Zhu Yi 已提交
3106
	}
3107

3108
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
3109

C
Christoph Hellwig 已提交
3110
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
3111
	if (rc) {
3112
		IWL_ERR(priv, "Unable to int nic\n");
Z
Zhu Yi 已提交
3113 3114 3115 3116
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
3117 3118
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
3119 3120 3121
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
3122
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
3123
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
3124 3125

	/* really make sure rfkill handshake bits are cleared */
3126 3127
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
Z
Zhu Yi 已提交
3128 3129 3130 3131 3132

	/* Copy original ucode data image from disk into backup cache.
	 * This will be used to initialize the on-board processor's
	 * data SRAM for a clean start when the runtime program first loads. */
	memcpy(priv->ucode_data_backup.v_addr, priv->ucode_data.v_addr,
3133
	       priv->ucode_data.len);
Z
Zhu Yi 已提交
3134

3135 3136 3137 3138
	/* We return success when we resume from suspend and rf_kill is on. */
	if (test_bit(STATUS_RF_KILL_HW, &priv->status))
		return 0;

Z
Zhu Yi 已提交
3139 3140
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

C
Christoph Hellwig 已提交
3141
		iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
3142 3143 3144 3145

		/* load bootstrap state machine,
		 * load bootstrap program into processor's memory,
		 * prepare to load the "initialize" uCode */
K
Kolekar, Abhijeet 已提交
3146
		priv->cfg->ops->lib->load_ucode(priv);
Z
Zhu Yi 已提交
3147 3148

		if (rc) {
3149 3150
			IWL_ERR(priv,
				"Unable to set up bootstrap uCode: %d\n", rc);
Z
Zhu Yi 已提交
3151 3152 3153 3154
			continue;
		}

		/* start card; "initialize" will load runtime ucode */
C
Christoph Hellwig 已提交
3155
		iwl3945_nic_start(priv);
Z
Zhu Yi 已提交
3156

3157
		IWL_DEBUG_INFO(priv, DRV_NAME " is coming up\n");
Z
Zhu Yi 已提交
3158 3159 3160 3161 3162

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
3163
	__iwl3945_down(priv);
3164
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
3165 3166 3167

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
3168
	IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
Z
Zhu Yi 已提交
3169 3170 3171 3172 3173 3174 3175 3176 3177 3178
	return -EIO;
}


/*****************************************************************************
 *
 * Workqueue callbacks
 *
 *****************************************************************************/

C
Christoph Hellwig 已提交
3179
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
3180
{
3181 3182
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, init_alive_start.work);
Z
Zhu Yi 已提交
3183 3184 3185 3186 3187

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3188
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
3189 3190 3191
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
3192
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
3193
{
3194 3195
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, alive_start.work);
Z
Zhu Yi 已提交
3196 3197 3198 3199 3200

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3201
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
3202 3203 3204
	mutex_unlock(&priv->mutex);
}

3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223
static void iwl3945_rfkill_poll(struct work_struct *data)
{
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rfkill_poll.work);
	unsigned long status = priv->status;

	if (iwl_read32(priv, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
	else
		set_bit(STATUS_RF_KILL_HW, &priv->status);

	if (test_bit(STATUS_RF_KILL_HW, &status) != test_bit(STATUS_RF_KILL_HW, &priv->status))
		queue_work(priv->workqueue, &priv->rf_kill);

	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   round_jiffies_relative(2 * HZ));

}

Z
Zhu Yi 已提交
3224
#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)
C
Christoph Hellwig 已提交
3225
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
3226
{
3227 3228
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
3229
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
3230
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
3231
		.len = sizeof(struct iwl3945_scan_cmd),
Z
Zhu Yi 已提交
3232 3233 3234
		.meta.flags = CMD_SIZE_HUGE,
	};
	int rc = 0;
C
Christoph Hellwig 已提交
3235
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
3236
	struct ieee80211_conf *conf = NULL;
3237
	u8 n_probes = 2;
3238
	enum ieee80211_band band;
3239
	DECLARE_SSID_BUF(ssid);
Z
Zhu Yi 已提交
3240 3241 3242 3243 3244

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

3245
	if (!iwl_is_ready(priv)) {
3246
		IWL_WARN(priv, "request scan called when driver not ready.\n");
Z
Zhu Yi 已提交
3247 3248 3249
		goto done;
	}

T
Tomas Winkler 已提交
3250
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
3251 3252 3253 3254 3255 3256 3257
	 * was given the chance to run... */
	if (!test_bit(STATUS_SCANNING, &priv->status))
		goto done;

	/* This should never be called or scheduled if there is currently
	 * a scan active in the hardware. */
	if (test_bit(STATUS_SCAN_HW, &priv->status)) {
3258 3259
		IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests  "
				"Ignoring second request.\n");
Z
Zhu Yi 已提交
3260 3261 3262 3263 3264
		rc = -EIO;
		goto done;
	}

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
3265
		IWL_DEBUG_SCAN(priv, "Aborting scan due to device shutdown\n");
Z
Zhu Yi 已提交
3266 3267 3268 3269
		goto done;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
3270 3271
		IWL_DEBUG_HC(priv,
			"Scan request while abort pending. Queuing.\n");
Z
Zhu Yi 已提交
3272 3273 3274
		goto done;
	}

3275
	if (iwl_is_rfkill(priv)) {
3276
		IWL_DEBUG_HC(priv, "Aborting scan due to RF Kill activation\n");
Z
Zhu Yi 已提交
3277 3278 3279 3280
		goto done;
	}

	if (!test_bit(STATUS_READY, &priv->status)) {
3281 3282
		IWL_DEBUG_HC(priv,
			"Scan request while uninitialized. Queuing.\n");
Z
Zhu Yi 已提交
3283 3284 3285 3286
		goto done;
	}

	if (!priv->scan_bands) {
3287
		IWL_DEBUG_HC(priv, "Aborting scan due to no requested bands\n");
Z
Zhu Yi 已提交
3288 3289 3290
		goto done;
	}

W
Winkler, Tomas 已提交
3291 3292
	if (!priv->scan) {
		priv->scan = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
3293
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
W
Winkler, Tomas 已提交
3294
		if (!priv->scan) {
Z
Zhu Yi 已提交
3295 3296 3297 3298
			rc = -ENOMEM;
			goto done;
		}
	}
W
Winkler, Tomas 已提交
3299
	scan = priv->scan;
C
Christoph Hellwig 已提交
3300
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
3301 3302 3303 3304

	scan->quiet_plcp_th = IWL_PLCP_QUIET_THRESH;
	scan->quiet_time = IWL_ACTIVE_QUIET_TIME;

3305
	if (iwl_is_associated(priv)) {
Z
Zhu Yi 已提交
3306 3307 3308 3309 3310 3311
		u16 interval = 0;
		u32 extra;
		u32 suspend_time = 100;
		u32 scan_suspend_time = 100;
		unsigned long flags;

3312
		IWL_DEBUG_INFO(priv, "Scanning while associated...\n");
Z
Zhu Yi 已提交
3313 3314 3315 3316 3317 3318

		spin_lock_irqsave(&priv->lock, flags);
		interval = priv->beacon_int;
		spin_unlock_irqrestore(&priv->lock, flags);

		scan->suspend_time = 0;
3319
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333
		if (!interval)
			interval = suspend_time;
		/*
		 * suspend time format:
		 *  0-19: beacon interval in usec (time before exec.)
		 * 20-23: 0
		 * 24-31: number of beacons (suspend between channels)
		 */

		extra = (suspend_time / interval) << 24;
		scan_suspend_time = 0xFF0FFFFF &
		    (extra | ((suspend_time % interval) * 1024));

		scan->suspend_time = cpu_to_le32(scan_suspend_time);
3334
		IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n",
Z
Zhu Yi 已提交
3335 3336 3337 3338 3339
			       scan_suspend_time, interval);
	}

	/* We should add the ability for user to lock to PASSIVE ONLY */
	if (priv->one_direct_scan) {
3340 3341
		IWL_DEBUG_SCAN(priv, "Kicking off one direct scan for '%s'\n",
				print_ssid(ssid, priv->direct_ssid,
3342
				priv->direct_ssid_len));
Z
Zhu Yi 已提交
3343 3344 3345 3346
		scan->direct_scan[0].id = WLAN_EID_SSID;
		scan->direct_scan[0].len = priv->direct_ssid_len;
		memcpy(scan->direct_scan[0].ssid,
		       priv->direct_ssid, priv->direct_ssid_len);
3347 3348
		n_probes++;
	} else
3349
		IWL_DEBUG_SCAN(priv, "Kicking off one indirect scan.\n");
Z
Zhu Yi 已提交
3350 3351 3352 3353

	/* We don't build a direct scan probe request; the uCode will do
	 * that based on the direct_mask added to each channel entry */
	scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
3354
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
3355 3356 3357 3358
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

3359
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
3360 3361 3362
		scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
		scan->tx_cmd.rate = IWL_RATE_1M_PLCP;
		scan->good_CRC_th = 0;
3363
		band = IEEE80211_BAND_2GHZ;
3364
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
3365 3366
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
		scan->good_CRC_th = IWL_GOOD_CRC_TH;
3367
		band = IEEE80211_BAND_5GHZ;
3368
	} else {
3369
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
3370 3371 3372
		goto done;
	}

S
Samuel Ortiz 已提交
3373 3374 3375 3376 3377
	scan->tx_cmd.len = cpu_to_le16(
		iwl_fill_probe_req(priv, band,
				   (struct ieee80211_mgmt *)scan->data,
				   IWL_MAX_SCAN_SIZE - sizeof(*scan)));

Z
Zhu Yi 已提交
3378 3379 3380
	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

3381
	if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
Z
Zhu Yi 已提交
3382 3383
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

3384 3385 3386 3387
	scan->channel_count =
		iwl3945_get_channels_for_scan(priv, band, 1, /* active */
					      n_probes,
			(void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);
Z
Zhu Yi 已提交
3388

3389
	if (scan->channel_count == 0) {
3390
		IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count);
3391 3392 3393
		goto done;
	}

Z
Zhu Yi 已提交
3394
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
3395
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
3396 3397 3398 3399
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
3400
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
3401 3402 3403 3404 3405 3406 3407 3408 3409 3410
	if (rc)
		goto done;

	queue_delayed_work(priv->workqueue, &priv->scan_check,
			   IWL_SCAN_CHECK_WATCHDOG);

	mutex_unlock(&priv->mutex);
	return;

 done:
3411 3412 3413 3414 3415 3416 3417 3418
	/* can not perform scan make sure we clear scanning
	 * bits from status so next scan request can be performed.
	 * if we dont clear scanning status bit here all next scan
	 * will fail
	*/
	clear_bit(STATUS_SCAN_HW, &priv->status);
	clear_bit(STATUS_SCANNING, &priv->status);

3419
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
3420 3421 3422 3423
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
3424
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
3425
{
3426
	struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
Z
Zhu Yi 已提交
3427 3428 3429 3430 3431

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3432
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
3433
	mutex_unlock(&priv->mutex);
S
Samuel Ortiz 已提交
3434
	iwl_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
3435 3436
}

C
Christoph Hellwig 已提交
3437
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
3438
{
3439
	struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
Z
Zhu Yi 已提交
3440 3441 3442 3443

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

C
Christoph Hellwig 已提交
3444
	iwl3945_down(priv);
Z
Zhu Yi 已提交
3445 3446 3447
	queue_work(priv->workqueue, &priv->up);
}

C
Christoph Hellwig 已提交
3448
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
3449
{
3450 3451
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rx_replenish);
Z
Zhu Yi 已提交
3452 3453 3454 3455 3456

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3457
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
3458 3459 3460
	mutex_unlock(&priv->mutex);
}

3461 3462
#define IWL_DELAY_NEXT_SCAN (HZ*2)

3463
static void iwl3945_post_associate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3464 3465 3466 3467
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

3468
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
3469
		IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
3470 3471 3472 3473
		return;
	}


3474
	IWL_DEBUG_ASSOC(priv, "Associated as %d to: %pM\n",
3475
			priv->assoc_id, priv->active_rxon.bssid_addr);
Z
Zhu Yi 已提交
3476 3477 3478 3479

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

A
Abhijeet Kolekar 已提交
3480
	if (!priv->vif || !priv->is_open)
3481
		return;
A
Abhijeet Kolekar 已提交
3482

3483
	iwl_scan_cancel_timeout(priv, 200);
3484

Z
Zhu Yi 已提交
3485 3486
	conf = ieee80211_get_hw_conf(priv->hw);

3487
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
3488
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3489

3490
	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
3491
	iwl3945_setup_rxon_timing(priv);
3492
	rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
3493 3494
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
3495
		IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3496 3497
			    "Attempting to continue.\n");

3498
	priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
Z
Zhu Yi 已提交
3499

3500
	priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
3501

3502
	IWL_DEBUG_ASSOC(priv, "assoc id %d beacon interval %d\n",
Z
Zhu Yi 已提交
3503 3504 3505
			priv->assoc_id, priv->beacon_int);

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3506
		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3507
	else
3508
		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3509

3510
	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3511
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
3512
			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3513
		else
3514
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3515

3516
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3517
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3518 3519 3520

	}

C
Christoph Hellwig 已提交
3521
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3522 3523

	switch (priv->iw_mode) {
3524
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
3525
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
3526 3527
		break;

3528
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
3529

3530
		priv->assoc_id = 1;
C
Christoph Hellwig 已提交
3531
		iwl3945_add_station(priv, priv->bssid, 0, 0);
Z
Zhu Yi 已提交
3532
		iwl3945_sync_sta(priv, IWL_STA_ID,
3533
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
3534 3535
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
3536 3537
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3538 3539 3540 3541

		break;

	default:
3542
		 IWL_ERR(priv, "%s Should not be called in %d mode\n",
3543
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
3544 3545 3546
		break;
	}

3547
	iwl_activate_qos(priv, 0);
3548

3549 3550
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
3551 3552
}

3553
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed);
3554

Z
Zhu Yi 已提交
3555 3556 3557 3558 3559 3560
/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

3561 3562
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
3563
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3564
{
3565
	struct iwl_priv *priv = hw->priv;
3566
	int ret;
Z
Zhu Yi 已提交
3567

3568
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3569 3570 3571 3572

	/* we should be verifying the device is ready to be opened */
	mutex_lock(&priv->mutex);

3573
	memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
3574 3575 3576 3577 3578 3579
	/* fetch ucode file from disk, alloc and copy to bus-master buffers ...
	 * ucode filename and max sizes are card-specific. */

	if (!priv->ucode_code.len) {
		ret = iwl3945_read_ucode(priv);
		if (ret) {
3580
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
3581 3582 3583 3584
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
3585

3586
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
3587 3588

	mutex_unlock(&priv->mutex);
3589

S
Samuel Ortiz 已提交
3590
	iwl_rfkill_set_hw_state(priv);
3591

3592 3593 3594
	if (ret)
		goto out_release_irq;

3595
	IWL_DEBUG_INFO(priv, "Start UP work.\n");
3596 3597 3598 3599

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

3600 3601 3602 3603 3604 3605 3606
	/* Wait for START_ALIVE from ucode. Otherwise callbacks from
	 * mac80211 will not be run successfully. */
	ret = wait_event_interruptible_timeout(priv->wait_command_queue,
			test_bit(STATUS_READY, &priv->status),
			UCODE_READY_TIMEOUT);
	if (!ret) {
		if (!test_bit(STATUS_READY, &priv->status)) {
3607 3608 3609
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
3610 3611 3612 3613 3614
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

3615 3616 3617 3618
	/* ucode is running and will send rfkill notifications,
	 * no need to poll the killswitch state anymore */
	cancel_delayed_work(&priv->rfkill_poll);

3619
	priv->is_open = 1;
3620
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3621
	return 0;
3622 3623

out_release_irq:
3624
	priv->is_open = 0;
3625
	IWL_DEBUG_MAC80211(priv, "leave - failed\n");
3626
	return ret;
Z
Zhu Yi 已提交
3627 3628
}

C
Christoph Hellwig 已提交
3629
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3630
{
3631
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3632

3633
	IWL_DEBUG_MAC80211(priv, "enter\n");
3634

3635
	if (!priv->is_open) {
3636
		IWL_DEBUG_MAC80211(priv, "leave - skip\n");
3637 3638 3639
		return;
	}

Z
Zhu Yi 已提交
3640
	priv->is_open = 0;
3641

3642
	if (iwl_is_ready_rf(priv)) {
3643 3644 3645
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
3646
		mutex_lock(&priv->mutex);
3647
		iwl_scan_cancel_timeout(priv, 100);
3648 3649 3650
		mutex_unlock(&priv->mutex);
	}

3651 3652 3653
	iwl3945_down(priv);

	flush_workqueue(priv->workqueue);
3654 3655 3656 3657

	/* start polling the killswitch state again */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   round_jiffies_relative(2 * HZ));
3658

3659
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3660 3661
}

3662
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
3663
{
3664
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3665

3666
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3667

3668
	IWL_DEBUG_TX(priv, "dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
3669
		     ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
Z
Zhu Yi 已提交
3670

3671
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
3672 3673
		dev_kfree_skb_any(skb);

3674
	IWL_DEBUG_MAC80211(priv, "leave\n");
3675
	return NETDEV_TX_OK;
Z
Zhu Yi 已提交
3676 3677
}

C
Christoph Hellwig 已提交
3678
static int iwl3945_mac_add_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
3679 3680
				 struct ieee80211_if_init_conf *conf)
{
3681
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3682 3683
	unsigned long flags;

3684
	IWL_DEBUG_MAC80211(priv, "enter: type %d\n", conf->type);
Z
Zhu Yi 已提交
3685

3686
	if (priv->vif) {
3687
		IWL_DEBUG_MAC80211(priv, "leave - vif != NULL\n");
3688
		return -EOPNOTSUPP;
Z
Zhu Yi 已提交
3689 3690 3691
	}

	spin_lock_irqsave(&priv->lock, flags);
3692
	priv->vif = conf->vif;
3693
	priv->iw_mode = conf->type;
Z
Zhu Yi 已提交
3694 3695 3696 3697

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
3698 3699

	if (conf->mac_addr) {
3700
		IWL_DEBUG_MAC80211(priv, "Set: %pM\n", conf->mac_addr);
3701 3702 3703
		memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
	}

3704
	if (iwl_is_ready(priv))
3705
		iwl3945_set_mode(priv, conf->type);
Z
Zhu Yi 已提交
3706 3707 3708

	mutex_unlock(&priv->mutex);

3709
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3710 3711 3712 3713
	return 0;
}

/**
C
Christoph Hellwig 已提交
3714
 * iwl3945_mac_config - mac80211 config callback
Z
Zhu Yi 已提交
3715 3716 3717 3718 3719
 *
 * We ignore conf->flags & IEEE80211_CONF_SHORT_SLOT_TIME since it seems to
 * be set inappropriately and the driver currently sets the hardware up to
 * use it whenever needed.
 */
3720
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed)
Z
Zhu Yi 已提交
3721
{
3722
	struct iwl_priv *priv = hw->priv;
3723
	const struct iwl_channel_info *ch_info;
3724
	struct ieee80211_conf *conf = &hw->conf;
Z
Zhu Yi 已提交
3725
	unsigned long flags;
3726
	int ret = 0;
Z
Zhu Yi 已提交
3727 3728

	mutex_lock(&priv->mutex);
3729 3730
	IWL_DEBUG_MAC80211(priv, "enter to channel %d\n",
				conf->channel->hw_value);
Z
Zhu Yi 已提交
3731

3732
	if (!iwl_is_ready(priv)) {
3733
		IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
3734 3735
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
3736 3737
	}

3738
	if (unlikely(!iwl3945_mod_params.disable_hw_scan &&
Z
Zhu Yi 已提交
3739
		     test_bit(STATUS_SCANNING, &priv->status))) {
3740
		IWL_DEBUG_MAC80211(priv, "leave - scanning\n");
3741
		set_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
3742
		mutex_unlock(&priv->mutex);
3743
		return 0;
Z
Zhu Yi 已提交
3744 3745 3746 3747
	}

	spin_lock_irqsave(&priv->lock, flags);

3748 3749
	ch_info = iwl_get_channel_info(priv, conf->channel->band,
				       conf->channel->hw_value);
Z
Zhu Yi 已提交
3750
	if (!is_channel_valid(ch_info)) {
3751 3752 3753 3754
		IWL_DEBUG_SCAN(priv,
				"Channel %d [%d] is INVALID for this band.\n",
				conf->channel->hw_value, conf->channel->band);
		IWL_DEBUG_MAC80211(priv, "leave - invalid channel\n");
Z
Zhu Yi 已提交
3755
		spin_unlock_irqrestore(&priv->lock, flags);
3756 3757
		ret = -EINVAL;
		goto out;
Z
Zhu Yi 已提交
3758 3759
	}

3760
	iwl_set_rxon_channel(priv, conf->channel);
Z
Zhu Yi 已提交
3761

3762
	iwl_set_flags_for_band(priv, conf->channel->band);
Z
Zhu Yi 已提交
3763 3764 3765 3766

	/* The list of supported rates and rate mask can be different
	 * for each phymode; since the phymode may have changed, reset
	 * the rate mask to what mac80211 lists */
3767
	iwl_set_rate(priv);
Z
Zhu Yi 已提交
3768 3769 3770 3771 3772

	spin_unlock_irqrestore(&priv->lock, flags);

#ifdef IEEE80211_CONF_CHANNEL_SWITCH
	if (conf->flags & IEEE80211_CONF_CHANNEL_SWITCH) {
C
Christoph Hellwig 已提交
3773
		iwl3945_hw_channel_switch(priv, conf->channel);
3774
		goto out;
Z
Zhu Yi 已提交
3775 3776 3777
	}
#endif

3778 3779 3780 3781 3782 3783 3784
	if (changed & IEEE80211_CONF_CHANGE_RADIO_ENABLED) {
		if (conf->radio_enabled &&
		    iwl_radio_kill_sw_enable_radio(priv)) {
			IWL_DEBUG_MAC80211(priv, "leave - RF-KILL - "
						 "waiting for uCode\n");
			goto out;
		}
Z
Zhu Yi 已提交
3785

3786 3787 3788 3789 3790
		if (!conf->radio_enabled) {
			iwl_radio_kill_sw_disable_radio(priv);
			IWL_DEBUG_MAC80211(priv, "leave - radio disabled\n");
			goto out;
		}
Z
Zhu Yi 已提交
3791 3792
	}

3793
	if (iwl_is_rfkill(priv)) {
3794
		IWL_DEBUG_MAC80211(priv, "leave - RF kill\n");
3795 3796
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
3797 3798
	}

3799
	iwl_set_rate(priv);
Z
Zhu Yi 已提交
3800

3801 3802
	if (memcmp(&priv->active_rxon,
		   &priv->staging_rxon, sizeof(priv->staging_rxon)))
C
Christoph Hellwig 已提交
3803
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3804
	else
3805
		IWL_DEBUG_INFO(priv, "Not re-sending same RXON configuration\n");
Z
Zhu Yi 已提交
3806

3807
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3808

3809
out:
3810
	clear_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
3811
	mutex_unlock(&priv->mutex);
3812
	return ret;
Z
Zhu Yi 已提交
3813 3814
}

3815
static void iwl3945_config_ap(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3816 3817 3818
{
	int rc = 0;

3819
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
3820 3821 3822
		return;

	/* The following should be done only at AP bring up */
3823
	if (!(iwl_is_associated(priv))) {
Z
Zhu Yi 已提交
3824 3825

		/* RXON - unassoc (to set timing command) */
3826
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
3827
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3828 3829

		/* RXON Timing */
3830
		memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
3831
		iwl3945_setup_rxon_timing(priv);
3832 3833 3834
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
				      sizeof(priv->rxon_timing),
				      &priv->rxon_timing);
Z
Zhu Yi 已提交
3835
		if (rc)
3836
			IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3837 3838 3839
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
3840
		priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
3841
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3842
			priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3843 3844
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
3845
			priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3846 3847
				~RXON_FLG_SHORT_PREAMBLE_MSK;

3848
		if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3849 3850
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
3851
				priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3852 3853
					RXON_FLG_SHORT_SLOT_MSK;
			else
3854
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3855 3856
					~RXON_FLG_SHORT_SLOT_MSK;

3857
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3858
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3859 3860 3861
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
3862
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
3863
		iwl3945_commit_rxon(priv);
3864
		iwl3945_add_station(priv, iwl_bcast_addr, 0, 0);
3865
	}
C
Christoph Hellwig 已提交
3866
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3867 3868 3869 3870 3871 3872

	/* FIXME - we need to add code here to detect a totally new
	 * configuration, reset the AP, unassoc, rxon timing, assoc,
	 * clear sta table, add BCAST sta... */
}

3873 3874
static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
3875
					struct ieee80211_if_conf *conf)
Z
Zhu Yi 已提交
3876
{
3877
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3878 3879 3880 3881 3882
	int rc;

	if (conf == NULL)
		return -EIO;

3883
	if (priv->vif != vif) {
3884
		IWL_DEBUG_MAC80211(priv, "leave - priv->vif != vif\n");
3885 3886 3887
		return 0;
	}

3888
	/* handle this temporarily here */
3889
	if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
3890 3891 3892 3893
	    conf->changed & IEEE80211_IFCC_BEACON) {
		struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
		if (!beacon)
			return -ENOMEM;
3894
		mutex_lock(&priv->mutex);
3895
		rc = iwl3945_mac_beacon_update(hw, beacon);
3896
		mutex_unlock(&priv->mutex);
3897 3898 3899 3900
		if (rc)
			return rc;
	}

3901
	if (!iwl_is_alive(priv))
3902 3903
		return -EAGAIN;

Z
Zhu Yi 已提交
3904 3905 3906
	mutex_lock(&priv->mutex);

	if (conf->bssid)
3907
		IWL_DEBUG_MAC80211(priv, "bssid: %pM\n", conf->bssid);
Z
Zhu Yi 已提交
3908

3909 3910 3911
/*
 * very dubious code was here; the probe filtering flag is never set:
 *
Z
Zhu Yi 已提交
3912 3913
	if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
	    !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
3914
 */
Z
Zhu Yi 已提交
3915

3916
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
3917 3918 3919
		if (!conf->bssid) {
			conf->bssid = priv->mac_addr;
			memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
3920
			IWL_DEBUG_MAC80211(priv, "bssid was set to: %pM\n",
J
Johannes Berg 已提交
3921
					   conf->bssid);
Z
Zhu Yi 已提交
3922 3923 3924 3925
		}
		if (priv->ibss_beacon)
			dev_kfree_skb(priv->ibss_beacon);

3926
		priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
Z
Zhu Yi 已提交
3927 3928
	}

3929
	if (iwl_is_rfkill(priv))
3930 3931
		goto done;

Z
Zhu Yi 已提交
3932 3933 3934 3935
	if (conf->bssid && !is_zero_ether_addr(conf->bssid) &&
	    !is_multicast_ether_addr(conf->bssid)) {
		/* If there is currently a HW scan going on in the background
		 * then we need to cancel it else the RXON below will fail. */
3936
		if (iwl_scan_cancel_timeout(priv, 100)) {
3937
			IWL_WARN(priv, "Aborted scan still in progress "
Z
Zhu Yi 已提交
3938
				    "after 100ms\n");
3939
			IWL_DEBUG_MAC80211(priv, "leaving:scan abort failed\n");
Z
Zhu Yi 已提交
3940 3941 3942
			mutex_unlock(&priv->mutex);
			return -EAGAIN;
		}
3943
		memcpy(priv->staging_rxon.bssid_addr, conf->bssid, ETH_ALEN);
Z
Zhu Yi 已提交
3944 3945 3946 3947 3948 3949 3950

		/* TODO: Audit driver for usage of these members and see
		 * if mac80211 deprecates them (priv->bssid looks like it
		 * shouldn't be there, but I haven't scanned the IBSS code
		 * to verify) - jpk */
		memcpy(priv->bssid, conf->bssid, ETH_ALEN);

3951
		if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
3952
			iwl3945_config_ap(priv);
Z
Zhu Yi 已提交
3953
		else {
C
Christoph Hellwig 已提交
3954
			rc = iwl3945_commit_rxon(priv);
3955
			if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
C
Christoph Hellwig 已提交
3956
				iwl3945_add_station(priv,
3957
					priv->active_rxon.bssid_addr, 1, 0);
Z
Zhu Yi 已提交
3958 3959 3960
		}

	} else {
3961
		iwl_scan_cancel_timeout(priv, 100);
3962
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
3963
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3964 3965
	}

3966
 done:
3967
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3968 3969 3970 3971 3972
	mutex_unlock(&priv->mutex);

	return 0;
}

C
Christoph Hellwig 已提交
3973
static void iwl3945_mac_remove_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
3974 3975
				     struct ieee80211_if_init_conf *conf)
{
3976
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3977

3978
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3979 3980

	mutex_lock(&priv->mutex);
3981

3982
	if (iwl_is_ready_rf(priv)) {
3983
		iwl_scan_cancel_timeout(priv, 100);
3984
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
3985 3986
		iwl3945_commit_rxon(priv);
	}
3987 3988
	if (priv->vif == conf->vif) {
		priv->vif = NULL;
Z
Zhu Yi 已提交
3989 3990 3991 3992
		memset(priv->bssid, 0, ETH_ALEN);
	}
	mutex_unlock(&priv->mutex);

3993
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3994 3995
}

3996 3997 3998 3999 4000 4001 4002
#define IWL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)

static void iwl3945_bss_info_changed(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif,
				     struct ieee80211_bss_conf *bss_conf,
				     u32 changes)
{
4003
	struct iwl_priv *priv = hw->priv;
4004

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

	if (changes & BSS_CHANGED_ERP_PREAMBLE) {
4008
		IWL_DEBUG_MAC80211(priv, "ERP_PREAMBLE %d\n",
4009 4010
				   bss_conf->use_short_preamble);
		if (bss_conf->use_short_preamble)
4011
			priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
4012
		else
4013 4014
			priv->staging_rxon.flags &=
				~RXON_FLG_SHORT_PREAMBLE_MSK;
4015 4016 4017
	}

	if (changes & BSS_CHANGED_ERP_CTS_PROT) {
4018 4019
		IWL_DEBUG_MAC80211(priv, "ERP_CTS %d\n",
				   bss_conf->use_cts_prot);
4020
		if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
4021
			priv->staging_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
4022
		else
4023
			priv->staging_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
4024 4025 4026
	}

	if (changes & BSS_CHANGED_ASSOC) {
4027
		IWL_DEBUG_MAC80211(priv, "ASSOC %d\n", bss_conf->assoc);
4028 4029 4030 4031 4032 4033 4034
		/* This should never happen as this function should
		 * never be called from interrupt context. */
		if (WARN_ON_ONCE(in_interrupt()))
			return;
		if (bss_conf->assoc) {
			priv->assoc_id = bss_conf->aid;
			priv->beacon_int = bss_conf->beacon_int;
4035
			priv->timestamp = bss_conf->timestamp;
4036
			priv->assoc_capability = bss_conf->assoc_capability;
4037
			priv->power_data.dtim_period = bss_conf->dtim_period;
4038 4039 4040 4041 4042 4043 4044
			priv->next_scan_jiffies = jiffies +
					IWL_DELAY_NEXT_SCAN_AFTER_ASSOC;
			mutex_lock(&priv->mutex);
			iwl3945_post_associate(priv);
			mutex_unlock(&priv->mutex);
		} else {
			priv->assoc_id = 0;
4045 4046
			IWL_DEBUG_MAC80211(priv,
					"DISASSOC %d\n", bss_conf->assoc);
4047
		}
4048
	} else if (changes && iwl_is_associated(priv) && priv->assoc_id) {
4049 4050
			IWL_DEBUG_MAC80211(priv,
					"Associated Changes %d\n", changes);
4051 4052 4053 4054 4055
			iwl3945_send_rxon_assoc(priv);
	}

}

C
Christoph Hellwig 已提交
4056
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
4057 4058 4059
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
Z
Zhu Yi 已提交
4060
{
4061
	struct iwl_priv *priv = hw->priv;
4062
	const u8 *addr;
4063 4064 4065
	int ret = 0;
	u8 sta_id = IWL_INVALID_STATION;
	u8 static_key;
Z
Zhu Yi 已提交
4066

4067
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
4068

4069
	if (iwl3945_mod_params.sw_crypto) {
4070
		IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
Z
Zhu Yi 已提交
4071 4072 4073
		return -EOPNOTSUPP;
	}

4074
	addr = sta ? sta->addr : iwl_bcast_addr;
4075 4076 4077 4078 4079
	static_key = !iwl_is_associated(priv);

	if (!static_key) {
		sta_id = iwl3945_hw_find_station(priv, addr);
		if (sta_id == IWL_INVALID_STATION) {
4080
			IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
4081 4082 4083
					    addr);
			return -EINVAL;
		}
Z
Zhu Yi 已提交
4084 4085 4086
	}

	mutex_lock(&priv->mutex);
4087
	iwl_scan_cancel_timeout(priv, 100);
4088
	mutex_unlock(&priv->mutex);
4089

Z
Zhu Yi 已提交
4090
	switch (cmd) {
4091 4092 4093 4094 4095 4096
	case SET_KEY:
		if (static_key)
			ret = iwl3945_set_static_key(priv, key);
		else
			ret = iwl3945_set_dynamic_key(priv, key, sta_id);
		IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
Z
Zhu Yi 已提交
4097 4098
		break;
	case DISABLE_KEY:
4099 4100 4101 4102 4103
		if (static_key)
			ret = iwl3945_remove_static_key(priv);
		else
			ret = iwl3945_clear_sta_key_info(priv, sta_id);
		IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
Z
Zhu Yi 已提交
4104 4105
		break;
	default:
4106
		ret = -EINVAL;
Z
Zhu Yi 已提交
4107 4108
	}

4109
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4110

4111
	return ret;
Z
Zhu Yi 已提交
4112 4113
}

J
Johannes Berg 已提交
4114
static int iwl3945_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
Z
Zhu Yi 已提交
4115 4116
			   const struct ieee80211_tx_queue_params *params)
{
4117
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
4118 4119 4120
	unsigned long flags;
	int q;

4121
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
4122

4123
	if (!iwl_is_ready_rf(priv)) {
4124
		IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
Z
Zhu Yi 已提交
4125 4126 4127 4128
		return -EIO;
	}

	if (queue >= AC_NUM) {
4129
		IWL_DEBUG_MAC80211(priv, "leave - queue >= AC_NUM %d\n", queue);
Z
Zhu Yi 已提交
4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140
		return 0;
	}

	q = AC_NUM - 1 - queue;

	spin_lock_irqsave(&priv->lock, flags);

	priv->qos_data.def_qos_parm.ac[q].cw_min = cpu_to_le16(params->cw_min);
	priv->qos_data.def_qos_parm.ac[q].cw_max = cpu_to_le16(params->cw_max);
	priv->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
	priv->qos_data.def_qos_parm.ac[q].edca_txop =
4141
			cpu_to_le16((params->txop * 32));
Z
Zhu Yi 已提交
4142 4143 4144 4145 4146 4147 4148

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

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
4149
	if (priv->iw_mode == NL80211_IFTYPE_AP)
4150
		iwl_activate_qos(priv, 1);
4151
	else if (priv->assoc_id && iwl_is_associated(priv))
4152
		iwl_activate_qos(priv, 0);
Z
Zhu Yi 已提交
4153 4154 4155

	mutex_unlock(&priv->mutex);

4156
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4157 4158 4159
	return 0;
}

C
Christoph Hellwig 已提交
4160
static int iwl3945_mac_get_tx_stats(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
4161 4162
				struct ieee80211_tx_queue_stats *stats)
{
4163
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
4164
	int i, avail;
4165
	struct iwl_tx_queue *txq;
4166
	struct iwl_queue *q;
Z
Zhu Yi 已提交
4167 4168
	unsigned long flags;

4169
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
4170

4171
	if (!iwl_is_ready_rf(priv)) {
4172
		IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
Z
Zhu Yi 已提交
4173 4174 4175 4176 4177 4178
		return -EIO;
	}

	spin_lock_irqsave(&priv->lock, flags);

	for (i = 0; i < AC_NUM; i++) {
4179
		txq = &priv->txq[i];
Z
Zhu Yi 已提交
4180
		q = &txq->q;
4181
		avail = iwl_queue_space(q);
Z
Zhu Yi 已提交
4182

4183 4184 4185
		stats[i].len = q->n_window - avail;
		stats[i].limit = q->n_window - q->high_mark;
		stats[i].count = q->n_window;
Z
Zhu Yi 已提交
4186 4187 4188 4189

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

4190
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4191 4192 4193 4194

	return 0;
}

C
Christoph Hellwig 已提交
4195
static void iwl3945_mac_reset_tsf(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
4196
{
4197
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
4198 4199 4200
	unsigned long flags;

	mutex_lock(&priv->mutex);
4201
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
4202

4203
	iwl_reset_qos(priv);
4204

Z
Zhu Yi 已提交
4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215
	spin_lock_irqsave(&priv->lock, flags);
	priv->assoc_id = 0;
	priv->assoc_capability = 0;

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

	priv->ibss_beacon = NULL;

	priv->beacon_int = priv->hw->conf.beacon_int;
4216
	priv->timestamp = 0;
4217
	if ((priv->iw_mode == NL80211_IFTYPE_STATION))
Z
Zhu Yi 已提交
4218 4219 4220 4221
		priv->beacon_int = 0;

	spin_unlock_irqrestore(&priv->lock, flags);

4222
	if (!iwl_is_ready_rf(priv)) {
4223
		IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
4224 4225 4226 4227
		mutex_unlock(&priv->mutex);
		return;
	}

4228 4229 4230
	/* we are restarting association process
	 * clear RXON_FILTER_ASSOC_MSK bit
	*/
4231
	if (priv->iw_mode != NL80211_IFTYPE_AP) {
4232
		iwl_scan_cancel_timeout(priv, 100);
4233
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
4234
		iwl3945_commit_rxon(priv);
4235 4236
	}

Z
Zhu Yi 已提交
4237
	/* Per mac80211.h: This is only used in IBSS mode... */
4238
	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
4239

4240
		IWL_DEBUG_MAC80211(priv, "leave - not in IBSS\n");
Z
Zhu Yi 已提交
4241 4242 4243 4244
		mutex_unlock(&priv->mutex);
		return;
	}

4245
	iwl_set_rate(priv);
Z
Zhu Yi 已提交
4246 4247 4248

	mutex_unlock(&priv->mutex);

4249
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4250 4251 4252

}

4253
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
4254
{
4255
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
4256
	unsigned long flags;
4257
	__le64 timestamp;
Z
Zhu Yi 已提交
4258

4259
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
4260

4261
	if (!iwl_is_ready_rf(priv)) {
4262
		IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
Z
Zhu Yi 已提交
4263 4264 4265
		return -EIO;
	}

4266
	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
4267
		IWL_DEBUG_MAC80211(priv, "leave - not IBSS\n");
Z
Zhu Yi 已提交
4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278
		return -EIO;
	}

	spin_lock_irqsave(&priv->lock, flags);

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

	priv->ibss_beacon = skb;

	priv->assoc_id = 0;
4279 4280
	timestamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
	priv->timestamp = le64_to_cpu(timestamp);
Z
Zhu Yi 已提交
4281

4282
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4283 4284
	spin_unlock_irqrestore(&priv->lock, flags);

4285
	iwl_reset_qos(priv);
Z
Zhu Yi 已提交
4286

4287
	iwl3945_post_associate(priv);
Z
Zhu Yi 已提交
4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298


	return 0;
}

/*****************************************************************************
 *
 * sysfs attributes
 *
 *****************************************************************************/

S
Samuel Ortiz 已提交
4299
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
4300 4301 4302 4303 4304 4305 4306 4307

/*
 * The following adds a new attribute to the sysfs representation
 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/iwl/)
 * used for controlling the debug level.
 *
 * See the level definitions in iwl for details.
 */
4308 4309
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
4310
{
4311
	struct iwl_priv *priv = d->driver_data;
4312 4313

	return sprintf(buf, "0x%08X\n", priv->debug_level);
Z
Zhu Yi 已提交
4314
}
4315 4316
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
4317 4318
				 const char *buf, size_t count)
{
4319
	struct iwl_priv *priv = d->driver_data;
4320 4321
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
4322

4323 4324
	ret = strict_strtoul(buf, 0, &val);
	if (ret)
T
Tomas Winkler 已提交
4325
		IWL_INFO(priv, "%s is not in hex or decimal form.\n", buf);
Z
Zhu Yi 已提交
4326
	else
4327
		priv->debug_level = val;
Z
Zhu Yi 已提交
4328 4329 4330 4331

	return strnlen(buf, count);
}

4332 4333
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
4334

S
Samuel Ortiz 已提交
4335
#endif /* CONFIG_IWLWIFI_DEBUG */
Z
Zhu Yi 已提交
4336 4337 4338 4339

static ssize_t show_temperature(struct device *d,
				struct device_attribute *attr, char *buf)
{
4340
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
4341

4342
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
4343 4344
		return -EAGAIN;

C
Christoph Hellwig 已提交
4345
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
4346 4347 4348 4349 4350 4351 4352
}

static DEVICE_ATTR(temperature, S_IRUGO, show_temperature, NULL);

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
4353
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
4354
	return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
Z
Zhu Yi 已提交
4355 4356 4357 4358 4359 4360
}

static ssize_t store_tx_power(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
4361
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
4362 4363 4364 4365 4366
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
4367
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
4368
	else
C
Christoph Hellwig 已提交
4369
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
4370 4371 4372 4373 4374 4375 4376 4377 4378

	return count;
}

static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, show_tx_power, store_tx_power);

static ssize_t show_flags(struct device *d,
			  struct device_attribute *attr, char *buf)
{
4379
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
4380

4381
	return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
Z
Zhu Yi 已提交
4382 4383 4384 4385 4386 4387
}

static ssize_t store_flags(struct device *d,
			   struct device_attribute *attr,
			   const char *buf, size_t count)
{
4388
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
4389 4390 4391
	u32 flags = simple_strtoul(buf, NULL, 0);

	mutex_lock(&priv->mutex);
4392
	if (le32_to_cpu(priv->staging_rxon.flags) != flags) {
Z
Zhu Yi 已提交
4393
		/* Cancel any currently running scans... */
4394
		if (iwl_scan_cancel_timeout(priv, 100))
4395
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
4396
		else {
4397
			IWL_DEBUG_INFO(priv, "Committing rxon.flags = 0x%04X\n",
Z
Zhu Yi 已提交
4398
				       flags);
4399
			priv->staging_rxon.flags = cpu_to_le32(flags);
C
Christoph Hellwig 已提交
4400
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

static DEVICE_ATTR(flags, S_IWUSR | S_IRUGO, show_flags, store_flags);

static ssize_t show_filter_flags(struct device *d,
				 struct device_attribute *attr, char *buf)
{
4413
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
4414 4415

	return sprintf(buf, "0x%04X\n",
4416
		le32_to_cpu(priv->active_rxon.filter_flags));
Z
Zhu Yi 已提交
4417 4418 4419 4420 4421 4422
}

static ssize_t store_filter_flags(struct device *d,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
{
4423
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
4424 4425 4426
	u32 filter_flags = simple_strtoul(buf, NULL, 0);

	mutex_lock(&priv->mutex);
4427
	if (le32_to_cpu(priv->staging_rxon.filter_flags) != filter_flags) {
Z
Zhu Yi 已提交
4428
		/* Cancel any currently running scans... */
4429
		if (iwl_scan_cancel_timeout(priv, 100))
4430
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
4431
		else {
4432
			IWL_DEBUG_INFO(priv, "Committing rxon.filter_flags = "
Z
Zhu Yi 已提交
4433
				       "0x%04X\n", filter_flags);
4434
			priv->staging_rxon.filter_flags =
Z
Zhu Yi 已提交
4435
				cpu_to_le32(filter_flags);
C
Christoph Hellwig 已提交
4436
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
4437 4438 4439 4440 4441 4442 4443 4444 4445 4446
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

static DEVICE_ATTR(filter_flags, S_IWUSR | S_IRUGO, show_filter_flags,
		   store_filter_flags);

4447
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
4448 4449 4450 4451

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
4452
	struct iwl_priv *priv = dev_get_drvdata(d);
4453
	struct iwl_spectrum_notification measure_report;
Z
Zhu Yi 已提交
4454
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
4455
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484
	unsigned long flags;

	spin_lock_irqsave(&priv->lock, flags);
	if (!(priv->measurement_status & MEASUREMENT_READY)) {
		spin_unlock_irqrestore(&priv->lock, flags);
		return 0;
	}
	memcpy(&measure_report, &priv->measure_report, size);
	priv->measurement_status = 0;
	spin_unlock_irqrestore(&priv->lock, flags);

	while (size && (PAGE_SIZE - len)) {
		hex_dump_to_buffer(data + ofs, size, 16, 1, buf + len,
				   PAGE_SIZE - len, 1);
		len = strlen(buf);
		if (PAGE_SIZE - len)
			buf[len++] = '\n';

		ofs += 16;
		size -= min(size, 16U);
	}

	return len;
}

static ssize_t store_measurement(struct device *d,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
4485
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4486
	struct ieee80211_measurement_params params = {
4487
		.channel = le16_to_cpu(priv->active_rxon.channel),
Z
Zhu Yi 已提交
4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508
		.start_time = cpu_to_le64(priv->last_tsf),
		.duration = cpu_to_le16(1),
	};
	u8 type = IWL_MEASURE_BASIC;
	u8 buffer[32];
	u8 channel;

	if (count) {
		char *p = buffer;
		strncpy(buffer, buf, min(sizeof(buffer), count));
		channel = simple_strtoul(p, NULL, 0);
		if (channel)
			params.channel = channel;

		p = buffer;
		while (*p && *p != ' ')
			p++;
		if (*p)
			type = simple_strtoul(p + 1, NULL, 0);
	}

4509
	IWL_DEBUG_INFO(priv, "Invoking measurement of type %d on "
Z
Zhu Yi 已提交
4510
		       "channel %d (for '%s')\n", type, params.channel, buf);
C
Christoph Hellwig 已提交
4511
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
4512 4513 4514 4515 4516 4517

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
4518
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
4519 4520 4521 4522 4523

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
4524
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535

	priv->retry_rate = simple_strtoul(buf, NULL, 0);
	if (priv->retry_rate <= 0)
		priv->retry_rate = 1;

	return count;
}

static ssize_t show_retry_rate(struct device *d,
			       struct device_attribute *attr, char *buf)
{
4536
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4537 4538 4539 4540 4541 4542
	return sprintf(buf, "%d", priv->retry_rate);
}

static DEVICE_ATTR(retry_rate, S_IWUSR | S_IRUSR, show_retry_rate,
		   store_retry_rate);

4543

Z
Zhu Yi 已提交
4544 4545 4546 4547
static ssize_t store_power_level(struct device *d,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
4548
	struct iwl_priv *priv = dev_get_drvdata(d);
4549 4550 4551
	int ret;
	unsigned long mode;

Z
Zhu Yi 已提交
4552 4553 4554

	mutex_lock(&priv->mutex);

4555 4556 4557
	ret = strict_strtoul(buf, 10, &mode);
	if (ret)
		goto out;
Z
Zhu Yi 已提交
4558

4559 4560 4561 4562
	ret = iwl_power_set_user_mode(priv, mode);
	if (ret) {
		IWL_DEBUG_MAC80211(priv, "failed setting power mode.\n");
		goto out;
Z
Zhu Yi 已提交
4563
	}
4564
	ret = count;
Z
Zhu Yi 已提交
4565 4566 4567

 out:
	mutex_unlock(&priv->mutex);
4568
	return ret;
Z
Zhu Yi 已提交
4569 4570
}

4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601
static ssize_t show_power_level(struct device *d,
				struct device_attribute *attr, char *buf)
{
	struct iwl_priv *priv = dev_get_drvdata(d);
	int mode = priv->power_data.user_power_setting;
	int system = priv->power_data.system_power_setting;
	int level = priv->power_data.power_mode;
	char *p = buf;

	switch (system) {
	case IWL_POWER_SYS_AUTO:
		p += sprintf(p, "SYSTEM:auto");
		break;
	case IWL_POWER_SYS_AC:
		p += sprintf(p, "SYSTEM:ac");
		break;
	case IWL_POWER_SYS_BATTERY:
		p += sprintf(p, "SYSTEM:battery");
		break;
	}

	p += sprintf(p, "\tMODE:%s", (mode < IWL_POWER_AUTO) ?
			"fixed" : "auto");
	p += sprintf(p, "\tINDEX:%d", level);
	p += sprintf(p, "\n");
	return p - buf + 1;
}

static DEVICE_ATTR(power_level, S_IWUSR | S_IRUSR,
		   show_power_level, store_power_level);

Z
Zhu Yi 已提交
4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622
#define MAX_WX_STRING 80

/* Values are in microsecond */
static const s32 timeout_duration[] = {
	350000,
	250000,
	75000,
	37000,
	25000,
};
static const s32 period_duration[] = {
	400000,
	700000,
	1000000,
	1000000,
	1000000
};

static ssize_t show_channels(struct device *d,
			     struct device_attribute *attr, char *buf)
{
4623 4624
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
4625 4626 4627 4628 4629 4630 4631
}

static DEVICE_ATTR(channels, S_IRUSR, show_channels, NULL);

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
4632
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
4633
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
4634
	u32 len = 0, ofs = 0;
4635
	u8 *data = (u8 *)&priv->statistics_39;
Z
Zhu Yi 已提交
4636 4637
	int rc = 0;

4638
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
4639 4640 4641
		return -EAGAIN;

	mutex_lock(&priv->mutex);
4642
	rc = iwl_send_statistics_request(priv, 0);
Z
Zhu Yi 已提交
4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669
	mutex_unlock(&priv->mutex);

	if (rc) {
		len = sprintf(buf,
			      "Error sending statistics request: 0x%08X\n", rc);
		return len;
	}

	while (size && (PAGE_SIZE - len)) {
		hex_dump_to_buffer(data + ofs, size, 16, 1, buf + len,
				   PAGE_SIZE - len, 1);
		len = strlen(buf);
		if (PAGE_SIZE - len)
			buf[len++] = '\n';

		ofs += 16;
		size -= min(size, 16U);
	}

	return len;
}

static DEVICE_ATTR(statistics, S_IRUGO, show_statistics, NULL);

static ssize_t show_antenna(struct device *d,
			    struct device_attribute *attr, char *buf)
{
4670
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4671

4672
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
4673 4674
		return -EAGAIN;

4675
	return sprintf(buf, "%d\n", iwl3945_mod_params.antenna);
Z
Zhu Yi 已提交
4676 4677 4678 4679 4680 4681
}

static ssize_t store_antenna(struct device *d,
			     struct device_attribute *attr,
			     const char *buf, size_t count)
{
4682
	struct iwl_priv *priv __maybe_unused = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4683 4684 4685 4686 4687 4688
	int ant;

	if (count == 0)
		return 0;

	if (sscanf(buf, "%1i", &ant) != 1) {
4689
		IWL_DEBUG_INFO(priv, "not in hex or decimal form.\n");
Z
Zhu Yi 已提交
4690 4691 4692 4693
		return count;
	}

	if ((ant >= 0) && (ant <= 2)) {
4694
		IWL_DEBUG_INFO(priv, "Setting antenna select to %d.\n", ant);
4695
		iwl3945_mod_params.antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
4696
	} else
4697
		IWL_DEBUG_INFO(priv, "Bad antenna select value %d.\n", ant);
Z
Zhu Yi 已提交
4698 4699 4700 4701 4702 4703 4704 4705 4706 4707


	return count;
}

static DEVICE_ATTR(antenna, S_IWUSR | S_IRUGO, show_antenna, store_antenna);

static ssize_t show_status(struct device *d,
			   struct device_attribute *attr, char *buf)
{
4708
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
4709
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722
		return -EAGAIN;
	return sprintf(buf, "0x%08x\n", (int)priv->status);
}

static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);

static ssize_t dump_error_log(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
	char *p = (char *)buf;

	if (p[0] == '1')
4723
		iwl3945_dump_nic_error_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736

	return strnlen(buf, count);
}

static DEVICE_ATTR(dump_errors, S_IWUSR, NULL, dump_error_log);

static ssize_t dump_event_log(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
	char *p = (char *)buf;

	if (p[0] == '1')
4737
		iwl3945_dump_nic_event_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
4738 4739 4740 4741 4742 4743 4744 4745

	return strnlen(buf, count);
}

static DEVICE_ATTR(dump_events, S_IWUSR, NULL, dump_event_log);

/*****************************************************************************
 *
T
Tomas Winkler 已提交
4746
 * driver setup and tear down
Z
Zhu Yi 已提交
4747 4748 4749
 *
 *****************************************************************************/

4750
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4751
{
4752
	priv->workqueue = create_singlethread_workqueue(DRV_NAME);
Z
Zhu Yi 已提交
4753 4754 4755

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
4756 4757 4758
	INIT_WORK(&priv->up, iwl3945_bg_up);
	INIT_WORK(&priv->restart, iwl3945_bg_restart);
	INIT_WORK(&priv->rx_replenish, iwl3945_bg_rx_replenish);
S
Samuel Ortiz 已提交
4759
	INIT_WORK(&priv->rf_kill, iwl_bg_rf_kill);
C
Christoph Hellwig 已提交
4760 4761 4762
	INIT_WORK(&priv->beacon_update, iwl3945_bg_beacon_update);
	INIT_DELAYED_WORK(&priv->init_alive_start, iwl3945_bg_init_alive_start);
	INIT_DELAYED_WORK(&priv->alive_start, iwl3945_bg_alive_start);
4763
	INIT_DELAYED_WORK(&priv->rfkill_poll, iwl3945_rfkill_poll);
S
Samuel Ortiz 已提交
4764 4765 4766 4767
	INIT_WORK(&priv->scan_completed, iwl_bg_scan_completed);
	INIT_WORK(&priv->request_scan, iwl3945_bg_request_scan);
	INIT_WORK(&priv->abort_scan, iwl_bg_abort_scan);
	INIT_DELAYED_WORK(&priv->scan_check, iwl_bg_scan_check);
C
Christoph Hellwig 已提交
4768 4769

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
4770 4771

	tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
C
Christoph Hellwig 已提交
4772
		     iwl3945_irq_tasklet, (unsigned long)priv);
Z
Zhu Yi 已提交
4773 4774
}

4775
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4776
{
C
Christoph Hellwig 已提交
4777
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
4778

4779
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
4780 4781 4782 4783 4784
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
4785
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
4786 4787 4788 4789 4790 4791
	&dev_attr_antenna.attr,
	&dev_attr_channels.attr,
	&dev_attr_dump_errors.attr,
	&dev_attr_dump_events.attr,
	&dev_attr_flags.attr,
	&dev_attr_filter_flags.attr,
4792
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
4793 4794 4795 4796 4797 4798 4799 4800
	&dev_attr_measurement.attr,
#endif
	&dev_attr_power_level.attr,
	&dev_attr_retry_rate.attr,
	&dev_attr_statistics.attr,
	&dev_attr_status.attr,
	&dev_attr_temperature.attr,
	&dev_attr_tx_power.attr,
S
Samuel Ortiz 已提交
4801
#ifdef CONFIG_IWLWIFI_DEBUG
4802 4803
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
4804 4805 4806
	NULL
};

C
Christoph Hellwig 已提交
4807
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
4808
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
4809
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
4810 4811
};

C
Christoph Hellwig 已提交
4812 4813 4814 4815 4816 4817 4818 4819
static struct ieee80211_ops iwl3945_hw_ops = {
	.tx = iwl3945_mac_tx,
	.start = iwl3945_mac_start,
	.stop = iwl3945_mac_stop,
	.add_interface = iwl3945_mac_add_interface,
	.remove_interface = iwl3945_mac_remove_interface,
	.config = iwl3945_mac_config,
	.config_interface = iwl3945_mac_config_interface,
4820
	.configure_filter = iwl_configure_filter,
C
Christoph Hellwig 已提交
4821 4822 4823 4824
	.set_key = iwl3945_mac_set_key,
	.get_tx_stats = iwl3945_mac_get_tx_stats,
	.conf_tx = iwl3945_mac_conf_tx,
	.reset_tsf = iwl3945_mac_reset_tsf,
4825
	.bss_info_changed = iwl3945_bss_info_changed,
4826
	.hw_scan = iwl_mac_hw_scan
Z
Zhu Yi 已提交
4827 4828
};

4829
static int iwl3945_init_drv(struct iwl_priv *priv)
4830 4831
{
	int ret;
4832
	struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
4833 4834 4835 4836 4837

	priv->retry_rate = 1;
	priv->ibss_beacon = NULL;

	spin_lock_init(&priv->lock);
4838
	spin_lock_init(&priv->power_data.lock);
4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861
	spin_lock_init(&priv->sta_lock);
	spin_lock_init(&priv->hcmd_lock);

	INIT_LIST_HEAD(&priv->free_frames);

	mutex_init(&priv->mutex);

	/* Clear the driver's (not device's) station table */
	iwl3945_clear_stations_table(priv);

	priv->data_retry_limit = -1;
	priv->ieee_channels = NULL;
	priv->ieee_rates = NULL;
	priv->band = IEEE80211_BAND_2GHZ;

	priv->iw_mode = NL80211_IFTYPE_STATION;

	iwl_reset_qos(priv);

	priv->qos_data.qos_active = 0;
	priv->qos_data.qos_cap.val = 0;

	priv->rates_mask = IWL_RATES_MASK;
4862 4863
	/* If power management is turned on, default to CAM mode */
	priv->power_mode = IWL_POWER_MODE_CAM;
4864
	priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
4865

4866 4867 4868 4869 4870 4871 4872
	if (eeprom->version < EEPROM_3945_EEPROM_VERSION) {
		IWL_WARN(priv, "Unsupported EEPROM version: 0x%04X\n",
			 eeprom->version);
		ret = -EINVAL;
		goto err;
	}
	ret = iwl_init_channel_map(priv);
4873 4874 4875 4876 4877
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

4878 4879 4880 4881 4882 4883
	/* Set up txpower settings in driver for all channels */
	if (iwl3945_txpower_set_from_eeprom(priv)) {
		ret = -EIO;
		goto err_free_channel_map;
	}

4884
	ret = iwlcore_init_geos(priv);
4885 4886 4887 4888
	if (ret) {
		IWL_ERR(priv, "initializing geos failed: %d\n", ret);
		goto err_free_channel_map;
	}
4889 4890
	iwl3945_init_hw_rates(priv, priv->ieee_rates);

4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908
	return 0;

err_free_channel_map:
	iwl_free_channel_map(priv);
err:
	return ret;
}

static int iwl3945_setup_mac(struct iwl_priv *priv)
{
	int ret;
	struct ieee80211_hw *hw = priv->hw;

	hw->rate_control_algorithm = "iwl-3945-rs";
	hw->sta_data_size = sizeof(struct iwl3945_sta_priv);

	/* Tell mac80211 our characteristics */
	hw->flags = IEEE80211_HW_SIGNAL_DBM |
M
Mohamed Abbas 已提交
4909 4910
		    IEEE80211_HW_NOISE_DBM |
		    IEEE80211_HW_SPECTRUM_MGMT;
4911 4912 4913 4914 4915 4916 4917

	hw->wiphy->interface_modes =
		BIT(NL80211_IFTYPE_STATION) |
		BIT(NL80211_IFTYPE_ADHOC);

	hw->wiphy->custom_regulatory = true;

4918 4919
	hw->wiphy->max_scan_ssids = 1; /* WILL FIX */

4920 4921 4922 4923 4924
	/* Default value; 4 EDCA QOS priorities */
	hw->queues = 4;

	hw->conf.beacon_int = 100;

4925 4926 4927
	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
4928

4929 4930 4931
	if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&priv->bands[IEEE80211_BAND_5GHZ];
4932

4933 4934 4935 4936 4937 4938
	ret = ieee80211_register_hw(priv->hw);
	if (ret) {
		IWL_ERR(priv, "Failed to register hw (error %d)\n", ret);
		return ret;
	}
	priv->mac80211_registered = 1;
4939

4940
	return 0;
4941 4942
}

C
Christoph Hellwig 已提交
4943
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
4944 4945
{
	int err = 0;
4946
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
4947
	struct ieee80211_hw *hw;
4948
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
4949
	struct iwl3945_eeprom *eeprom;
4950
	unsigned long flags;
Z
Zhu Yi 已提交
4951

4952 4953 4954 4955
	/***********************
	 * 1. Allocating HW data
	 * ********************/

Z
Zhu Yi 已提交
4956 4957
	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
4958
	hw = iwl_alloc_all(cfg, &iwl3945_hw_ops);
Z
Zhu Yi 已提交
4959
	if (hw == NULL) {
4960
		printk(KERN_ERR DRV_NAME "Can not allocate network device\n");
Z
Zhu Yi 已提交
4961 4962 4963 4964
		err = -ENOMEM;
		goto out;
	}
	priv = hw->priv;
4965
	SET_IEEE80211_DEV(hw, &pdev->dev);
4966

4967 4968
	if ((iwl3945_mod_params.num_of_queues > IWL39_MAX_NUM_QUEUES) ||
	     (iwl3945_mod_params.num_of_queues < IWL_MIN_NUM_QUEUES)) {
4969 4970 4971
		IWL_ERR(priv,
			"invalid queues_num, should be between %d and %d\n",
			IWL_MIN_NUM_QUEUES, IWL39_MAX_NUM_QUEUES);
4972
		err = -EINVAL;
4973
		goto out_ieee80211_free_hw;
4974 4975
	}

4976 4977 4978 4979
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
4980
	if (iwl3945_mod_params.disable_hw_scan) {
4981
		IWL_DEBUG_INFO(priv, "Disabling hw_scan\n");
4982 4983 4984
		iwl3945_hw_ops.hw_scan = NULL;
	}

4985

4986
	IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
4987 4988
	priv->cfg = cfg;
	priv->pci_dev = pdev;
4989

S
Samuel Ortiz 已提交
4990
#ifdef CONFIG_IWLWIFI_DEBUG
4991
	priv->debug_level = iwl3945_mod_params.debug;
Z
Zhu Yi 已提交
4992 4993 4994
	atomic_set(&priv->restrict_refcnt, 0);
#endif

4995 4996 4997
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
4998 4999 5000 5001 5002 5003 5004
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

5005
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
5006
	if (!err)
5007
		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
5008
	if (err) {
T
Tomas Winkler 已提交
5009
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
5010 5011 5012 5013 5014 5015 5016
		goto out_pci_disable_device;
	}

	pci_set_drvdata(pdev, priv);
	err = pci_request_regions(pdev, DRV_NAME);
	if (err)
		goto out_pci_disable_device;
5017

5018 5019 5020
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
5021 5022 5023 5024 5025 5026
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

5027
	IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
Z
Zhu Yi 已提交
5028
			(unsigned long long) pci_resource_len(pdev, 0));
5029
	IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
Z
Zhu Yi 已提交
5030

5031 5032 5033
	/* We disable the RETRY_TIMEOUT register (0x41) to keep
	 * PCI Tx retries from interfering with C3 CPU state */
	pci_write_config_byte(pdev, 0x41, 0x00);
Z
Zhu Yi 已提交
5034

5035 5036
	/* amp init */
	err = priv->cfg->ops->lib->apm_ops.init(priv);
5037
	if (err < 0) {
5038
		IWL_DEBUG_INFO(priv, "Failed to init the card\n");
5039
		goto out_iounmap;
5040
	}
Z
Zhu Yi 已提交
5041

5042 5043 5044
	/***********************
	 * 4. Read EEPROM
	 * ********************/
5045

5046
	/* Read the EEPROM */
5047
	err = iwl_eeprom_init(priv);
5048
	if (err) {
5049
		IWL_ERR(priv, "Unable to init EEPROM\n");
5050
		goto out_iounmap;
5051 5052
	}
	/* MAC Address location in EEPROM same for 3945/4965 */
5053 5054
	eeprom = (struct iwl3945_eeprom *)priv->eeprom;
	memcpy(priv->mac_addr, eeprom->mac_address, ETH_ALEN);
5055
	IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->mac_addr);
5056
	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
Z
Zhu Yi 已提交
5057

5058 5059 5060
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
5061
	/* Device-specific setup */
5062
	if (iwl3945_hw_set_hw_params(priv)) {
5063
		IWL_ERR(priv, "failed to set hw settings\n");
5064
		goto out_eeprom_free;
Z
Zhu Yi 已提交
5065 5066
	}

5067 5068 5069 5070
	/***********************
	 * 6. Setup priv
	 * ********************/

5071
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
5072
	if (err) {
5073
		IWL_ERR(priv, "initializing driver failed\n");
5074
		goto out_unset_hw_params;
Z
Zhu Yi 已提交
5075 5076
	}

T
Tomas Winkler 已提交
5077 5078
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
5079 5080 5081 5082 5083 5084 5085

	/***********************************
	 * 7. Initialize Module Parameters
	 * **********************************/

	/* Initialize module parameter values here */
	/* Disable radio (SW RF KILL) via parameter when loading driver */
5086
	if (iwl3945_mod_params.disable) {
5087
		set_bit(STATUS_RF_KILL_SW, &priv->status);
5088
		IWL_DEBUG_INFO(priv, "Radio disabled.\n");
5089 5090
	}

5091 5092 5093 5094 5095 5096

	/***********************
	 * 8. Setup Services
	 * ********************/

	spin_lock_irqsave(&priv->lock, flags);
5097
	iwl_disable_interrupts(priv);
5098 5099
	spin_unlock_irqrestore(&priv->lock, flags);

5100 5101
	pci_enable_msi(priv->pci_dev);

A
Abhijeet Kolekar 已提交
5102
	err = request_irq(priv->pci_dev->irq, iwl_isr, IRQF_SHARED,
5103 5104 5105 5106 5107 5108
			  DRV_NAME, priv);
	if (err) {
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

5109
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
5110
	if (err) {
5111
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
5112
		goto out_release_irq;
5113 5114
	}

5115 5116
	iwl_set_rxon_channel(priv,
			     &priv->bands[IEEE80211_BAND_2GHZ].channels[5]);
5117 5118 5119 5120
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);

	/*********************************
5121
	 * 9. Setup and Register mac80211
5122 5123
	 * *******************************/

5124
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
5125

5126 5127 5128
	err = iwl3945_setup_mac(priv);
	if (err)
		goto  out_remove_sysfs;
5129

S
Samuel Ortiz 已提交
5130
	err = iwl_rfkill_init(priv);
5131
	if (err)
5132
		IWL_ERR(priv, "Unable to initialize RFKILL system. "
5133
				  "Ignoring error: %d\n", err);
5134 5135
	else
		iwl_rfkill_set_hw_state(priv);
5136

5137 5138 5139 5140
	/* Start monitoring the killswitch */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   2 * HZ);

Z
Zhu Yi 已提交
5141 5142
	return 0;

5143
 out_remove_sysfs:
5144 5145
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
5146
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
5147
 out_release_irq:
5148 5149 5150
	free_irq(priv->pci_dev->irq, priv);
 out_disable_msi:
	pci_disable_msi(priv->pci_dev);
5151 5152 5153 5154 5155 5156
	iwlcore_free_geos(priv);
	iwl_free_channel_map(priv);
 out_unset_hw_params:
	iwl3945_unset_hw_params(priv);
 out_eeprom_free:
	iwl_eeprom_free(priv);
Z
Zhu Yi 已提交
5157 5158 5159 5160 5161 5162
 out_iounmap:
	pci_iounmap(pdev, priv->hw_base);
 out_pci_release_regions:
	pci_release_regions(pdev);
 out_pci_disable_device:
	pci_set_drvdata(pdev, NULL);
5163
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
5164 5165 5166 5167 5168 5169
 out_ieee80211_free_hw:
	ieee80211_free_hw(priv->hw);
 out:
	return err;
}

5170
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
5171
{
5172
	struct iwl_priv *priv = pci_get_drvdata(pdev);
5173
	unsigned long flags;
Z
Zhu Yi 已提交
5174 5175 5176 5177

	if (!priv)
		return;

5178
	IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
Z
Zhu Yi 已提交
5179 5180

	set_bit(STATUS_EXIT_PENDING, &priv->status);
5181

5182 5183 5184 5185 5186 5187
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
5188

5189 5190 5191 5192
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
5193
	iwl_disable_interrupts(priv);
5194 5195 5196 5197
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

C
Christoph Hellwig 已提交
5198
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
5199

S
Samuel Ortiz 已提交
5200
	iwl_rfkill_unregister(priv);
5201
	cancel_delayed_work_sync(&priv->rfkill_poll);
5202

C
Christoph Hellwig 已提交
5203
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
5204 5205

	if (priv->rxq.bd)
5206
		iwl_rx_queue_free(priv, &priv->rxq);
C
Christoph Hellwig 已提交
5207
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
5208

5209
	iwl3945_unset_hw_params(priv);
C
Christoph Hellwig 已提交
5210
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5211

5212 5213 5214
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
5215
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
5216 5217 5218 5219 5220
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;

5221 5222 5223
	free_irq(pdev->irq, priv);
	pci_disable_msi(pdev);

Z
Zhu Yi 已提交
5224 5225 5226 5227 5228
	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

5229
	iwl_free_channel_map(priv);
5230
	iwlcore_free_geos(priv);
W
Winkler, Tomas 已提交
5231
	kfree(priv->scan);
Z
Zhu Yi 已提交
5232 5233 5234 5235 5236 5237 5238 5239
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}

#ifdef CONFIG_PM

C
Christoph Hellwig 已提交
5240
static int iwl3945_pci_suspend(struct pci_dev *pdev, pm_message_t state)
Z
Zhu Yi 已提交
5241
{
5242
	struct iwl_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
5243

5244 5245 5246 5247 5248
	if (priv->is_open) {
		set_bit(STATUS_IN_SUSPEND, &priv->status);
		iwl3945_mac_stop(priv->hw);
		priv->is_open = 1;
	}
5249 5250
	pci_save_state(pdev);
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
5251 5252 5253 5254 5255
	pci_set_power_state(pdev, PCI_D3hot);

	return 0;
}

C
Christoph Hellwig 已提交
5256
static int iwl3945_pci_resume(struct pci_dev *pdev)
Z
Zhu Yi 已提交
5257
{
5258
	struct iwl_priv *priv = pci_get_drvdata(pdev);
5259
	int ret;
Z
Zhu Yi 已提交
5260 5261

	pci_set_power_state(pdev, PCI_D0);
5262 5263 5264
	ret = pci_enable_device(pdev);
	if (ret)
		return ret;
5265
	pci_restore_state(pdev);
Z
Zhu Yi 已提交
5266

5267 5268
	if (priv->is_open)
		iwl3945_mac_start(priv->hw);
Z
Zhu Yi 已提交
5269

5270
	clear_bit(STATUS_IN_SUSPEND, &priv->status);
Z
Zhu Yi 已提交
5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281
	return 0;
}

#endif /* CONFIG_PM */

/*****************************************************************************
 *
 * driver and module entry point
 *
 *****************************************************************************/

C
Christoph Hellwig 已提交
5282
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
5283
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
5284 5285 5286
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
5287
#ifdef CONFIG_PM
C
Christoph Hellwig 已提交
5288 5289
	.suspend = iwl3945_pci_suspend,
	.resume = iwl3945_pci_resume,
Z
Zhu Yi 已提交
5290 5291 5292
#endif
};

C
Christoph Hellwig 已提交
5293
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
5294 5295 5296 5297 5298
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
5299 5300 5301

	ret = iwl3945_rate_control_register();
	if (ret) {
5302 5303
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
5304 5305 5306
		return ret;
	}

C
Christoph Hellwig 已提交
5307
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
5308
	if (ret) {
5309
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
5310
		goto error_register;
Z
Zhu Yi 已提交
5311 5312 5313
	}

	return ret;
5314 5315 5316 5317

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
5318 5319
}

C
Christoph Hellwig 已提交
5320
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
5321
{
C
Christoph Hellwig 已提交
5322
	pci_unregister_driver(&iwl3945_driver);
5323
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
5324 5325
}

5326
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
5327

5328
module_param_named(antenna, iwl3945_mod_params.antenna, int, 0444);
Z
Zhu Yi 已提交
5329
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
5330
module_param_named(disable, iwl3945_mod_params.disable, int, 0444);
Z
Zhu Yi 已提交
5331
MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
5332 5333 5334
module_param_named(swcrypto, iwl3945_mod_params.sw_crypto, int, 0444);
MODULE_PARM_DESC(swcrypto,
		 "using software crypto (default 1 [software])\n");
5335
module_param_named(debug, iwl3945_mod_params.debug, uint, 0444);
Z
Zhu Yi 已提交
5336
MODULE_PARM_DESC(debug, "debug output mask");
5337
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
5338 5339
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

5340
module_param_named(queues_num, iwl3945_mod_params.num_of_queues, int, 0444);
Z
Zhu Yi 已提交
5341 5342
MODULE_PARM_DESC(queues_num, "number of hw queues.");

5343 5344 5345
module_param_named(fw_restart3945, iwl3945_mod_params.restart_fw, int, 0444);
MODULE_PARM_DESC(fw_restart3945, "restart firmware in case of error");

C
Christoph Hellwig 已提交
5346 5347
module_exit(iwl3945_exit);
module_init(iwl3945_init);