iwl3945-base.c 147.4 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 331
	int rc = 0;

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

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

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

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

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

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

		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 */
369 370
	if (iwl_is_associated(priv) &&
	    (staging_rxon->filter_flags & RXON_FILTER_ASSOC_MSK)) {
371
		IWL_DEBUG_INFO(priv, "Toggling associated bit on current RXON\n");
Z
Zhu Yi 已提交
372 373
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;

374 375 376 377 378 379
		/*
		 * 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;
380
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON,
C
Christoph Hellwig 已提交
381
				      sizeof(struct iwl3945_rxon_cmd),
382
				      &priv->active_rxon);
Z
Zhu Yi 已提交
383 384 385 386 387

		/* 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;
388
			IWL_ERR(priv, "Error clearing ASSOC_MSK on current "
Z
Zhu Yi 已提交
389 390 391 392 393
				  "configuration (%d).\n", rc);
			return rc;
		}
	}

394
	IWL_DEBUG_INFO(priv, "Sending RXON\n"
Z
Zhu Yi 已提交
395 396
		       "* with%s RXON_FILTER_ASSOC_MSK\n"
		       "* channel = %d\n"
J
Johannes Berg 已提交
397
		       "* bssid = %pM\n",
398
		       ((priv->staging_rxon.filter_flags &
Z
Zhu Yi 已提交
399
			 RXON_FILTER_ASSOC_MSK) ? "" : "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

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

419
	memcpy(active_rxon, staging_rxon, sizeof(*active_rxon));
Z
Zhu Yi 已提交
420

C
Christoph Hellwig 已提交
421
	iwl3945_clear_stations_table(priv);
422

Z
Zhu Yi 已提交
423 424
	/* 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 已提交
425
	rc = priv->cfg->ops->lib->send_tx_power(priv);
Z
Zhu Yi 已提交
426
	if (rc) {
427
		IWL_ERR(priv, "Error setting Tx power (%d).\n", rc);
Z
Zhu Yi 已提交
428 429 430 431
		return rc;
	}

	/* Add the broadcast address so we can send broadcast frames */
432
	if (iwl3945_add_station(priv, iwl_bcast_addr, 0, 0) ==
Z
Zhu Yi 已提交
433
	    IWL_INVALID_STATION) {
434
		IWL_ERR(priv, "Error adding BROADCAST address for transmit.\n");
Z
Zhu Yi 已提交
435 436 437 438 439
		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 */
440
	if (iwl_is_associated(priv) &&
441
	    (priv->iw_mode == NL80211_IFTYPE_STATION))
442 443
		if (iwl3945_add_station(priv, priv->active_rxon.bssid_addr,
					1, 0)
Z
Zhu Yi 已提交
444
		    == IWL_INVALID_STATION) {
445
			IWL_ERR(priv, "Error adding AP address for transmit\n");
Z
Zhu Yi 已提交
446 447 448
			return -EIO;
		}

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

	return 0;
}

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

	switch (keyconf->alg) {
	case ALG_CCMP:
		key_flags |= STA_KEY_FLG_CCMP;
		key_flags |= cpu_to_le16(
				keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
		key_flags &= ~STA_KEY_FLG_INVALID;
		break;
	case ALG_TKIP:
	case ALG_WEP:
	default:
		return -EINVAL;
	}
	spin_lock_irqsave(&priv->sta_lock, flags);
479 480 481
	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 已提交
482 483
	       keyconf->keylen);

484
	memcpy(priv->stations_39[sta_id].sta.key.key, keyconf->key,
Z
Zhu Yi 已提交
485
	       keyconf->keylen);
486 487 488
	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 已提交
489 490 491

	spin_unlock_irqrestore(&priv->sta_lock, flags);

492
	IWL_DEBUG_INFO(priv, "hwcrypto: modify ucode station key info\n");
493 494
	iwl_send_add_sta(priv,
		(struct iwl_addsta_cmd *)&priv->stations_39[sta_id].sta, 0);
Z
Zhu Yi 已提交
495 496 497
	return 0;
}

498
static int iwl3945_clear_sta_key_info(struct iwl_priv *priv, u8 sta_id)
Z
Zhu Yi 已提交
499 500 501 502
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);
503 504
	memset(&priv->stations_39[sta_id].keyinfo, 0, sizeof(struct iwl3945_hw_key));
	memset(&priv->stations_39[sta_id].sta.key, 0,
505
		sizeof(struct iwl4965_keyinfo));
506 507 508
	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 已提交
509 510
	spin_unlock_irqrestore(&priv->sta_lock, flags);

511
	IWL_DEBUG_INFO(priv, "hwcrypto: clear ucode station key info\n");
512 513
	iwl_send_add_sta(priv,
		(struct iwl_addsta_cmd *)&priv->stations_39[sta_id].sta, 0);
Z
Zhu Yi 已提交
514 515 516
	return 0;
}

517
static void iwl3945_clear_free_frames(struct iwl_priv *priv)
Z
Zhu Yi 已提交
518 519 520
{
	struct list_head *element;

521
	IWL_DEBUG_INFO(priv, "%d frames on pre-allocated heap on clear.\n",
Z
Zhu Yi 已提交
522 523 524 525 526
		       priv->frames_count);

	while (!list_empty(&priv->free_frames)) {
		element = priv->free_frames.next;
		list_del(element);
C
Christoph Hellwig 已提交
527
		kfree(list_entry(element, struct iwl3945_frame, list));
Z
Zhu Yi 已提交
528 529 530 531
		priv->frames_count--;
	}

	if (priv->frames_count) {
532
		IWL_WARN(priv, "%d frames still in use.  Did we lose one?\n",
Z
Zhu Yi 已提交
533 534 535 536 537
			    priv->frames_count);
		priv->frames_count = 0;
	}
}

538
static struct iwl3945_frame *iwl3945_get_free_frame(struct iwl_priv *priv)
Z
Zhu Yi 已提交
539
{
C
Christoph Hellwig 已提交
540
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
541 542 543 544
	struct list_head *element;
	if (list_empty(&priv->free_frames)) {
		frame = kzalloc(sizeof(*frame), GFP_KERNEL);
		if (!frame) {
545
			IWL_ERR(priv, "Could not allocate frame!\n");
Z
Zhu Yi 已提交
546 547 548 549 550 551 552 553 554
			return NULL;
		}

		priv->frames_count++;
		return frame;
	}

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

558
static void iwl3945_free_frame(struct iwl_priv *priv, struct iwl3945_frame *frame)
Z
Zhu Yi 已提交
559 560 561 562 563
{
	memset(frame, 0, sizeof(*frame));
	list_add(&frame->list, &priv->free_frames);
}

564
unsigned int iwl3945_fill_beacon_frame(struct iwl_priv *priv,
Z
Zhu Yi 已提交
565
				struct ieee80211_hdr *hdr,
566
				int left)
Z
Zhu Yi 已提交
567 568
{

569
	if (!iwl_is_associated(priv) || !priv->ibss_beacon ||
570 571
	    ((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
	     (priv->iw_mode != NL80211_IFTYPE_AP)))
Z
Zhu Yi 已提交
572 573 574 575 576 577 578 579 580 581
		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;
}

582
static int iwl3945_send_beacon_cmd(struct iwl_priv *priv)
Z
Zhu Yi 已提交
583
{
C
Christoph Hellwig 已提交
584
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
585 586 587 588
	unsigned int frame_size;
	int rc;
	u8 rate;

C
Christoph Hellwig 已提交
589
	frame = iwl3945_get_free_frame(priv);
Z
Zhu Yi 已提交
590 591

	if (!frame) {
592
		IWL_ERR(priv, "Could not obtain free frame buffer for beacon "
Z
Zhu Yi 已提交
593 594 595 596
			  "command.\n");
		return -ENOMEM;
	}

597
	rate = iwl_rate_get_lowest_plcp(priv);
Z
Zhu Yi 已提交
598

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

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

C
Christoph Hellwig 已提交
604
	iwl3945_free_frame(priv, frame);
Z
Zhu Yi 已提交
605 606 607 608

	return rc;
}

609
static void iwl3945_unset_hw_params(struct iwl_priv *priv)
Z
Zhu Yi 已提交
610
{
611
	if (priv->shared_virt)
Z
Zhu Yi 已提交
612
		pci_free_consistent(priv->pci_dev,
C
Christoph Hellwig 已提交
613
				    sizeof(struct iwl3945_shared),
614 615
				    priv->shared_virt,
				    priv->shared_phys);
Z
Zhu Yi 已提交
616 617 618 619 620
}

/*
 * QoS  support
*/
621
static int iwl3945_send_qos_params_command(struct iwl_priv *priv,
622
				       struct iwl_qosparam_cmd *qos)
Z
Zhu Yi 已提交
623 624
{

625
	return iwl_send_cmd_pdu(priv, REPLY_QOS_PARAM,
626
				sizeof(struct iwl_qosparam_cmd), qos);
Z
Zhu Yi 已提交
627 628
}

629
static void iwl3945_activate_qos(struct iwl_priv *priv, u8 force)
Z
Zhu Yi 已提交
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
{
	unsigned long flags;

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

	spin_lock_irqsave(&priv->lock, flags);
	priv->qos_data.def_qos_parm.qos_flags = 0;

	if (priv->qos_data.qos_cap.q_AP.queue_request &&
	    !priv->qos_data.qos_cap.q_AP.txop_request)
		priv->qos_data.def_qos_parm.qos_flags |=
			QOS_PARAM_FLG_TXOP_TYPE_MSK;

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

	spin_unlock_irqrestore(&priv->lock, flags);

650
	if (force || iwl_is_associated(priv)) {
651
		IWL_DEBUG_QOS(priv, "send QoS cmd with QoS active %d \n",
Z
Zhu Yi 已提交
652 653
			      priv->qos_data.qos_active);

C
Christoph Hellwig 已提交
654
		iwl3945_send_qos_params_command(priv,
Z
Zhu Yi 已提交
655 656 657 658 659 660
				&(priv->qos_data.def_qos_parm));
	}
}


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

C
Christoph Hellwig 已提交
663
static __le16 iwl3945_adjust_beacon_interval(u16 beacon_val)
Z
Zhu Yi 已提交
664 665 666 667 668 669 670 671 672 673 674 675
{
	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);
}

676
static void iwl3945_setup_rxon_timing(struct iwl_priv *priv)
Z
Zhu Yi 已提交
677 678 679 680 681 682 683 684 685 686
{
	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);
687
	priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
Z
Zhu Yi 已提交
688 689
	priv->rxon_timing.listen_interval = INTEL_CONN_LISTEN_INTERVAL;

690
	tsf = priv->timestamp;
Z
Zhu Yi 已提交
691 692 693 694

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

695
	if (priv->iw_mode == NL80211_IFTYPE_STATION) {
Z
Zhu Yi 已提交
696 697 698 699 700 701 702
		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 已提交
703
			    iwl3945_adjust_beacon_interval(
Z
Zhu Yi 已提交
704 705 706 707 708 709
				le16_to_cpu(priv->rxon_timing.beacon_interval));
		}

		priv->rxon_timing.atim_window = 0;
	} else {
		priv->rxon_timing.beacon_interval =
C
Christoph Hellwig 已提交
710
			iwl3945_adjust_beacon_interval(conf->beacon_int);
Z
Zhu Yi 已提交
711 712 713 714 715 716 717 718 719 720 721
		/* 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));

722 723
	IWL_DEBUG_ASSOC(priv,
		"beacon interval %d beacon timer %d beacon tim %d\n",
Z
Zhu Yi 已提交
724 725 726 727 728
		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));
}

729
static int iwl3945_set_mode(struct iwl_priv *priv, int mode)
Z
Zhu Yi 已提交
730
{
731
	if (mode == NL80211_IFTYPE_ADHOC) {
732
		const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
733

734
		ch_info = iwl_get_channel_info(priv,
735
			priv->band,
736
			le16_to_cpu(priv->staging_rxon.channel));
Z
Zhu Yi 已提交
737 738

		if (!ch_info || !is_channel_ibss(ch_info)) {
739
			IWL_ERR(priv, "channel %d not IBSS channel\n",
740
				  le16_to_cpu(priv->staging_rxon.channel));
Z
Zhu Yi 已提交
741 742 743 744
			return -EINVAL;
		}
	}

745
	iwl_connection_init_rx_config(priv, mode);
Z
Zhu Yi 已提交
746

C
Christoph Hellwig 已提交
747
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
748

T
Tomas Winkler 已提交
749
	/* don't commit rxon if rf-kill is on*/
750
	if (!iwl_is_ready_rf(priv))
751 752 753
		return -EAGAIN;

	cancel_delayed_work(&priv->scan_check);
754
	if (iwl_scan_cancel_timeout(priv, 100)) {
755
		IWL_WARN(priv, "Aborted scan still in progress after 100ms\n");
756
		IWL_DEBUG_MAC80211(priv, "leaving - scan abort failed.\n");
757 758 759
		return -EAGAIN;
	}

C
Christoph Hellwig 已提交
760
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
761 762 763 764

	return 0;
}

765
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl_priv *priv,
766
				      struct ieee80211_tx_info *info,
767
				      struct iwl_cmd *cmd,
Z
Zhu Yi 已提交
768 769 770
				      struct sk_buff *skb_frag,
				      int last_frag)
{
771
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
772
	struct iwl3945_hw_key *keyinfo =
773
	    &priv->stations_39[info->control.hw_key->hw_key_idx].keyinfo;
Z
Zhu Yi 已提交
774 775 776

	switch (keyinfo->alg) {
	case ALG_CCMP:
777 778
		tx->sec_ctl = TX_CMD_SEC_CCM;
		memcpy(tx->key, keyinfo->key, keyinfo->keylen);
779
		IWL_DEBUG_TX(priv, "tx_cmd with AES hwcrypto\n");
Z
Zhu Yi 已提交
780 781 782 783
		break;

	case ALG_TKIP:
#if 0
784
		tx->sec_ctl = TX_CMD_SEC_TKIP;
Z
Zhu Yi 已提交
785 786

		if (last_frag)
787
			memcpy(tx->tkip_mic.byte, skb_frag->tail - 8,
Z
Zhu Yi 已提交
788 789
			       8);
		else
790
			memset(tx->tkip_mic.byte, 0, 8);
Z
Zhu Yi 已提交
791 792 793 794
#endif
		break;

	case ALG_WEP:
795
		tx->sec_ctl = TX_CMD_SEC_WEP |
796
		    (info->control.hw_key->hw_key_idx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT;
Z
Zhu Yi 已提交
797 798

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

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

803
		IWL_DEBUG_TX(priv, "Configuring packet for WEP encryption "
804
			     "with key %d\n", info->control.hw_key->hw_key_idx);
Z
Zhu Yi 已提交
805 806 807
		break;

	default:
T
Tomas Winkler 已提交
808
		IWL_ERR(priv, "Unknown encode alg %d\n", keyinfo->alg);
Z
Zhu Yi 已提交
809 810 811 812 813 814 815
		break;
	}
}

/*
 * handle build REPLY_TX command notification.
 */
816
static void iwl3945_build_tx_cmd_basic(struct iwl_priv *priv,
817
				  struct iwl_cmd *cmd,
818
				  struct ieee80211_tx_info *info,
819
				  struct ieee80211_hdr *hdr, u8 std_id)
Z
Zhu Yi 已提交
820
{
821 822
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
	__le32 tx_flags = tx->tx_flags;
823
	__le16 fc = hdr->frame_control;
824
	u8 rc_flags = info->control.rates[0].flags;
Z
Zhu Yi 已提交
825

826
	tx->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
827
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Z
Zhu Yi 已提交
828
		tx_flags |= TX_CMD_FLG_ACK_MSK;
829
		if (ieee80211_is_mgmt(fc))
Z
Zhu Yi 已提交
830
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
831
		if (ieee80211_is_probe_resp(fc) &&
Z
Zhu Yi 已提交
832 833 834 835 836 837 838
		    !(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;
	}

839
	tx->sta_id = std_id;
840
	if (ieee80211_has_morefrags(fc))
Z
Zhu Yi 已提交
841 842
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

843 844
	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
845
		tx->tid_tspec = qc[0] & 0xf;
Z
Zhu Yi 已提交
846
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
847
	} else {
Z
Zhu Yi 已提交
848
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
849
	}
Z
Zhu Yi 已提交
850

851
	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
Z
Zhu Yi 已提交
852 853
		tx_flags |= TX_CMD_FLG_RTS_MSK;
		tx_flags &= ~TX_CMD_FLG_CTS_MSK;
854
	} else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
Z
Zhu Yi 已提交
855 856 857 858 859 860 861 862
		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);
863 864
	if (ieee80211_is_mgmt(fc)) {
		if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
865
			tx->timeout.pm_frame_timeout = cpu_to_le16(3);
Z
Zhu Yi 已提交
866
		else
867
			tx->timeout.pm_frame_timeout = cpu_to_le16(2);
M
Mohamed Abbas 已提交
868
	} else {
869
		tx->timeout.pm_frame_timeout = 0;
M
Mohamed Abbas 已提交
870 871 872 873
#ifdef CONFIG_IWL3945_LEDS
		priv->rxtxpackets += le16_to_cpu(cmd->cmd.tx.len);
#endif
	}
Z
Zhu Yi 已提交
874

875 876 877
	tx->driver_txop = 0;
	tx->tx_flags = tx_flags;
	tx->next_frame_len = 0;
Z
Zhu Yi 已提交
878 879
}

880 881 882
/**
 * iwl3945_get_sta_id - Find station's index within station table
 */
883
static int iwl3945_get_sta_id(struct iwl_priv *priv, struct ieee80211_hdr *hdr)
Z
Zhu Yi 已提交
884 885 886 887
{
	int sta_id;
	u16 fc = le16_to_cpu(hdr->frame_control);

888
	/* If this frame is broadcast or management, use broadcast station id */
Z
Zhu Yi 已提交
889 890
	if (((fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA) ||
	    is_multicast_ether_addr(hdr->addr1))
891
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
892 893 894

	switch (priv->iw_mode) {

895 896
	/* If we are a client station in a BSS network, use the special
	 * AP station entry (that's the only station we communicate with) */
897
	case NL80211_IFTYPE_STATION:
Z
Zhu Yi 已提交
898 899 900
		return IWL_AP_ID;

	/* If we are an AP, then find the station, or use BCAST */
901
	case NL80211_IFTYPE_AP:
C
Christoph Hellwig 已提交
902
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
903 904
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;
905
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
906

907 908
	/* If this frame is going out to an IBSS network, find the station,
	 * or create a new station table entry */
909
	case NL80211_IFTYPE_ADHOC: {
910
		/* Create new station table entry */
C
Christoph Hellwig 已提交
911
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
912 913 914
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

C
Christoph Hellwig 已提交
915
		sta_id = iwl3945_add_station(priv, hdr->addr1, 0, CMD_ASYNC);
Z
Zhu Yi 已提交
916 917 918 919

		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

920
		IWL_DEBUG_DROP(priv, "Station %pM not in station map. "
Z
Zhu Yi 已提交
921
			       "Defaulting to broadcast...\n",
J
Johannes Berg 已提交
922
			       hdr->addr1);
923
		iwl_print_hex_dump(priv, IWL_DL_DROP, (u8 *) hdr, sizeof(*hdr));
924
		return priv->hw_params.bcast_sta_id;
925
	}
926 927
	/* If we are in monitor mode, use BCAST. This is required for
	 * packet injection. */
928
	case NL80211_IFTYPE_MONITOR:
929
		return priv->hw_params.bcast_sta_id;
930

Z
Zhu Yi 已提交
931
	default:
932 933
		IWL_WARN(priv, "Unknown mode of operation: %d\n",
			priv->iw_mode);
934
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
935 936 937 938 939 940
	}
}

/*
 * start REPLY_TX command process
 */
941
static int iwl3945_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
Z
Zhu Yi 已提交
942 943
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
944
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
945
	struct iwl3945_tx_cmd *tx;
946
	struct iwl_tx_queue *txq = NULL;
947
	struct iwl_queue *q = NULL;
948
	struct iwl_cmd *out_cmd = NULL;
Z
Zhu Yi 已提交
949 950
	dma_addr_t phys_addr;
	dma_addr_t txcmd_phys;
951
	int txq_id = skb_get_queue_mapping(skb);
952 953 954
	u16 len, idx, len_org, hdr_len;
	u8 id;
	u8 unicast;
Z
Zhu Yi 已提交
955
	u8 sta_id;
956
	u8 tid = 0;
Z
Zhu Yi 已提交
957
	u16 seq_number = 0;
958
	__le16 fc;
Z
Zhu Yi 已提交
959
	u8 wait_write_ptr = 0;
960
	u8 *qc = NULL;
Z
Zhu Yi 已提交
961 962 963 964
	unsigned long flags;
	int rc;

	spin_lock_irqsave(&priv->lock, flags);
965
	if (iwl_is_rfkill(priv)) {
966
		IWL_DEBUG_DROP(priv, "Dropping - RF KILL\n");
Z
Zhu Yi 已提交
967 968 969
		goto drop_unlock;
	}

970
	if ((ieee80211_get_tx_rate(priv->hw, info)->hw_value & 0xFF) == IWL_INVALID_RATE) {
971
		IWL_ERR(priv, "ERROR: No TX rate available.\n");
Z
Zhu Yi 已提交
972 973 974 975 976 977
		goto drop_unlock;
	}

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

978
	fc = hdr->frame_control;
Z
Zhu Yi 已提交
979

S
Samuel Ortiz 已提交
980
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
981
	if (ieee80211_is_auth(fc))
982
		IWL_DEBUG_TX(priv, "Sending AUTH frame\n");
983
	else if (ieee80211_is_assoc_req(fc))
984
		IWL_DEBUG_TX(priv, "Sending ASSOC frame\n");
985
	else if (ieee80211_is_reassoc_req(fc))
986
		IWL_DEBUG_TX(priv, "Sending REASSOC frame\n");
Z
Zhu Yi 已提交
987 988
#endif

989
	/* drop all data frame if we are not associated */
990
	if (ieee80211_is_data(fc) &&
991
	    (priv->iw_mode != NL80211_IFTYPE_MONITOR) && /* packet injection */
992
	    (!iwl_is_associated(priv) ||
993
	     ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id))) {
994
		IWL_DEBUG_DROP(priv, "Dropping - !iwl_is_associated\n");
Z
Zhu Yi 已提交
995 996 997 998 999
		goto drop_unlock;
	}

	spin_unlock_irqrestore(&priv->lock, flags);

1000
	hdr_len = ieee80211_hdrlen(fc);
1001 1002

	/* Find (or create) index into station table for destination station */
C
Christoph Hellwig 已提交
1003
	sta_id = iwl3945_get_sta_id(priv, hdr);
Z
Zhu Yi 已提交
1004
	if (sta_id == IWL_INVALID_STATION) {
1005
		IWL_DEBUG_DROP(priv, "Dropping - INVALID STATION: %pM\n",
J
Johannes Berg 已提交
1006
			       hdr->addr1);
Z
Zhu Yi 已提交
1007 1008 1009
		goto drop;
	}

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

1012 1013
	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
1014
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
1015
		seq_number = priv->stations_39[sta_id].tid[tid].seq_number &
Z
Zhu Yi 已提交
1016 1017 1018
				IEEE80211_SCTL_SEQ;
		hdr->seq_ctrl = cpu_to_le16(seq_number) |
			(hdr->seq_ctrl &
1019
				cpu_to_le16(IEEE80211_SCTL_FRAG));
Z
Zhu Yi 已提交
1020 1021
		seq_number += 0x10;
	}
1022 1023

	/* Descriptor for chosen Tx queue */
1024
	txq = &priv->txq[txq_id];
Z
Zhu Yi 已提交
1025 1026 1027 1028
	q = &txq->q;

	spin_lock_irqsave(&priv->lock, flags);

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

1031
	/* Set up driver data for this TFD */
W
Winkler, Tomas 已提交
1032
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl_tx_info));
1033
	txq->txb[q->write_ptr].skb[0] = skb;
1034 1035

	/* Init first empty entry in queue's array of Tx/cmd buffers */
1036
	out_cmd = txq->cmd[idx];
1037
	tx = (struct iwl3945_tx_cmd *)out_cmd->cmd.payload;
Z
Zhu Yi 已提交
1038
	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
1039
	memset(tx, 0, sizeof(*tx));
1040 1041 1042 1043 1044 1045 1046

	/*
	 * 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 已提交
1047 1048
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
1049
				INDEX_TO_SEQ(q->write_ptr)));
1050 1051

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

1054 1055 1056 1057 1058 1059 1060 1061 1062
	/*
	 * 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.
	 */
1063
	len = sizeof(struct iwl3945_tx_cmd) +
1064
			sizeof(struct iwl_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
1065 1066 1067 1068 1069 1070 1071 1072 1073

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

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

1074 1075
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
1076 1077 1078 1079 1080 1081 1082 1083
	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 已提交
1084

1085 1086
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
1087 1088
	priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
						   txcmd_phys, len, 1, 0);
Z
Zhu Yi 已提交
1089

1090
	if (info->control.hw_key)
1091
		iwl3945_build_tx_cmd_hwcrypto(priv, info, out_cmd, skb, 0);
Z
Zhu Yi 已提交
1092

1093 1094
	/* 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 已提交
1095 1096 1097 1098
	len = skb->len - hdr_len;
	if (len) {
		phys_addr = pci_map_single(priv->pci_dev, skb->data + hdr_len,
					   len, PCI_DMA_TODEVICE);
1099 1100 1101
		priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
							   phys_addr, len,
							   0, U32_PAD(len));
Z
Zhu Yi 已提交
1102 1103
	}

1104
	/* Total # bytes to be transmitted */
Z
Zhu Yi 已提交
1105
	len = (u16)skb->len;
1106
	tx->len = cpu_to_le16(len);
Z
Zhu Yi 已提交
1107 1108

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

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

1114 1115
	tx->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
	tx->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;
Z
Zhu Yi 已提交
1116

1117
	if (!ieee80211_has_morefrags(hdr->frame_control)) {
Z
Zhu Yi 已提交
1118
		txq->need_update = 1;
1119
		if (qc)
1120
			priv->stations_39[sta_id].tid[tid].seq_number = seq_number;
Z
Zhu Yi 已提交
1121 1122 1123 1124 1125
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

1126
	iwl_print_hex_dump(priv, IWL_DL_TX, tx, sizeof(*tx));
Z
Zhu Yi 已提交
1127

1128
	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx->hdr,
1129
			   ieee80211_hdrlen(fc));
Z
Zhu Yi 已提交
1130

1131
	/* Tell device the write index *just past* this latest filled TFD */
T
Tomas Winkler 已提交
1132
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
1133
	rc = iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
1134 1135 1136 1137 1138
	spin_unlock_irqrestore(&priv->lock, flags);

	if (rc)
		return rc;

1139
	if ((iwl_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
1140 1141 1142 1143
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
1144
			iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
1145 1146 1147
			spin_unlock_irqrestore(&priv->lock, flags);
		}

1148
		ieee80211_stop_queue(priv->hw, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
	}

	return 0;

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

1159
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173

#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 已提交
1174
static u32 iwl3945_usecs_to_beacons(u32 usec, u32 beacon_interval)
Z
Zhu Yi 已提交
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
{
	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 已提交
1193
static __le32 iwl3945_add_beacon_time(u32 base, u32 addon, u32 beacon_interval)
Z
Zhu Yi 已提交
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
{
	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);
}

1212
static int iwl3945_get_measurement(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1213 1214 1215
			       struct ieee80211_measurement_params *params,
			       u8 type)
{
1216
	struct iwl_spectrum_cmd spectrum;
1217
	struct iwl_rx_packet *res;
1218
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
1219 1220 1221 1222 1223 1224 1225 1226 1227
		.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);

1228
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
1229
		add_time =
C
Christoph Hellwig 已提交
1230
		    iwl3945_usecs_to_beacons(
Z
Zhu Yi 已提交
1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242
			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));

1243
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
1244
		spectrum.start_time =
C
Christoph Hellwig 已提交
1245
		    iwl3945_add_beacon_time(priv->last_beacon_time,
Z
Zhu Yi 已提交
1246 1247 1248 1249 1250 1251 1252 1253
				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;
1254
	if (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK)
Z
Zhu Yi 已提交
1255 1256 1257
		spectrum.flags |= RXON_FLG_BAND_24G_MSK |
		    RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK;

1258
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
1259 1260 1261
	if (rc)
		return rc;

1262
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1263
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
1264
		IWL_ERR(priv, "Bad return from REPLY_RX_ON_ASSOC command\n");
Z
Zhu Yi 已提交
1265 1266 1267 1268 1269 1270 1271
		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) {
1272
			IWL_DEBUG_INFO(priv, "Replaced existing measurement: %d\n",
1273
						res->u.spectrum.id);
Z
Zhu Yi 已提交
1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
			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

1291
static void iwl3945_rx_reply_alive(struct iwl_priv *priv,
1292
			       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1293
{
1294 1295
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl_alive_resp *palive;
Z
Zhu Yi 已提交
1296 1297 1298 1299
	struct delayed_work *pwork;

	palive = &pkt->u.alive_frame;

1300
	IWL_DEBUG_INFO(priv, "Alive ucode status 0x%08X revision "
Z
Zhu Yi 已提交
1301 1302 1303 1304 1305
		       "0x%01X 0x%01X\n",
		       palive->is_valid, palive->ver_type,
		       palive->ver_subtype);

	if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
1306
		IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
1307 1308
		memcpy(&priv->card_alive_init, &pkt->u.alive_frame,
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
1309 1310
		pwork = &priv->init_alive_start;
	} else {
1311
		IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
1312
		memcpy(&priv->card_alive, &pkt->u.alive_frame,
1313
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
1314
		pwork = &priv->alive_start;
C
Christoph Hellwig 已提交
1315
		iwl3945_disable_events(priv);
Z
Zhu Yi 已提交
1316 1317 1318 1319 1320 1321 1322 1323
	}

	/* 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
1324
		IWL_WARN(priv, "uCode did not respond OK.\n");
Z
Zhu Yi 已提交
1325 1326
}

1327
static void iwl3945_rx_reply_add_sta(struct iwl_priv *priv,
1328
				 struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1329
{
1330
#ifdef CONFIG_IWLWIFI_DEBUG
1331
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
1332
#endif
Z
Zhu Yi 已提交
1333

1334
	IWL_DEBUG_RX(priv, "Received REPLY_ADD_STA: 0x%02X\n", pkt->u.status);
Z
Zhu Yi 已提交
1335 1336 1337
	return;
}

C
Christoph Hellwig 已提交
1338
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
1339
{
1340 1341
	struct iwl_priv *priv =
		container_of(work, struct iwl_priv, beacon_update);
Z
Zhu Yi 已提交
1342 1343 1344
	struct sk_buff *beacon;

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

	if (!beacon) {
1348
		IWL_ERR(priv, "update beacon failed\n");
Z
Zhu Yi 已提交
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
		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 已提交
1360
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
1361 1362
}

1363
static void iwl3945_rx_beacon_notif(struct iwl_priv *priv,
1364
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1365
{
S
Samuel Ortiz 已提交
1366
#ifdef CONFIG_IWLWIFI_DEBUG
1367
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
C
Christoph Hellwig 已提交
1368
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
1369 1370
	u8 rate = beacon->beacon_notify_hdr.rate;

1371
	IWL_DEBUG_RX(priv, "beacon status %x retries %d iss %d "
Z
Zhu Yi 已提交
1372 1373 1374 1375 1376 1377 1378 1379
		"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

1380
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
1381 1382 1383 1384 1385 1386
	    (!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 */
1387
static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
1388
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1389
{
1390
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
1391 1392 1393
	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
	unsigned long status = priv->status;

1394
	IWL_DEBUG_RF_KILL(priv, "Card state received: HW:%s SW:%s\n",
Z
Zhu Yi 已提交
1395 1396 1397
			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
			  (flags & SW_CARD_DISABLED) ? "Kill" : "On");

1398
	iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
		    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);

1412
	iwl_scan_cancel(priv);
Z
Zhu Yi 已提交
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423

	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 已提交
1424
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
1425 1426 1427 1428 1429 1430 1431
 *
 * 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.
 */
1432
static void iwl3945_setup_rx_handlers(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1433
{
C
Christoph Hellwig 已提交
1434 1435
	priv->rx_handlers[REPLY_ALIVE] = iwl3945_rx_reply_alive;
	priv->rx_handlers[REPLY_ADD_STA] = iwl3945_rx_reply_add_sta;
1436
	priv->rx_handlers[REPLY_ERROR] = iwl_rx_reply_error;
1437
	priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl_rx_csa;
A
Abhijeet Kolekar 已提交
1438
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
1439
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
A
Abhijeet Kolekar 已提交
1440
	    iwl_rx_pm_debug_statistics_notif;
C
Christoph Hellwig 已提交
1441
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
1442

1443 1444 1445 1446
	/*
	 * 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 已提交
1447
	 */
C
Christoph Hellwig 已提交
1448 1449
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
1450

1451
	iwl_setup_spectrum_handlers(priv);
1452
	iwl_setup_rx_scan_handlers(priv);
C
Christoph Hellwig 已提交
1453
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
1454

1455
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
1456
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
1457 1458
}

1459 1460 1461 1462 1463
/**
 * iwl3945_cmd_queue_reclaim - Reclaim CMD queue entries
 * When FW advances 'R' index, all entries between old and new 'R' index
 * need to be reclaimed.
 */
1464
static void iwl3945_cmd_queue_reclaim(struct iwl_priv *priv,
1465 1466
				      int txq_id, int index)
{
1467
	struct iwl_tx_queue *txq = &priv->txq[txq_id];
1468
	struct iwl_queue *q = &txq->q;
1469 1470
	int nfreed = 0;

1471
	if ((index >= q->n_bd) || (iwl_queue_used(q, index) == 0)) {
1472
		IWL_ERR(priv, "Read index for DMA queue txq id (%d), index %d, "
1473 1474 1475 1476 1477 1478 1479 1480
			  "is out of range [0-%d] %d %d.\n", txq_id,
			  index, q->n_bd, q->write_ptr, q->read_ptr);
		return;
	}

	for (index = iwl_queue_inc_wrap(index, q->n_bd); q->read_ptr != index;
		q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd)) {
		if (nfreed > 1) {
1481
			IWL_ERR(priv, "HCMD skipped: index (%d) %d %d\n", index,
1482 1483 1484 1485 1486 1487 1488 1489 1490
					q->write_ptr, q->read_ptr);
			queue_work(priv->workqueue, &priv->restart);
			break;
		}
		nfreed++;
	}
}


Z
Zhu Yi 已提交
1491
/**
C
Christoph Hellwig 已提交
1492
 * iwl3945_tx_cmd_complete - Pull unused buffers off the queue and reclaim them
Z
Zhu Yi 已提交
1493 1494 1495 1496 1497 1498
 * @rxb: Rx buffer to reclaim
 *
 * If an Rx buffer has an async callback associated with it the callback
 * will be executed.  The attached skb (if present) will only be freed
 * if the callback returns 1
 */
1499
static void iwl3945_tx_cmd_complete(struct iwl_priv *priv,
1500
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1501
{
1502
	struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
1503 1504 1505
	u16 sequence = le16_to_cpu(pkt->hdr.sequence);
	int txq_id = SEQ_TO_QUEUE(sequence);
	int index = SEQ_TO_INDEX(sequence);
1506
	int huge =  !!(pkt->hdr.sequence & SEQ_HUGE_FRAME);
Z
Zhu Yi 已提交
1507
	int cmd_index;
1508
	struct iwl_cmd *cmd;
Z
Zhu Yi 已提交
1509

1510 1511 1512 1513 1514 1515 1516 1517
	if (WARN(txq_id != IWL_CMD_QUEUE_NUM,
		 "wrong command queue %d, sequence 0x%X readp=%d writep=%d\n",
		  txq_id, sequence,
		  priv->txq[IWL_CMD_QUEUE_NUM].q.read_ptr,
		  priv->txq[IWL_CMD_QUEUE_NUM].q.write_ptr)) {
		iwl_print_hex_dump(priv, IWL_DL_INFO , rxb, 32);
		return;
	}
Z
Zhu Yi 已提交
1518

1519 1520
	cmd_index = get_cmd_index(&priv->txq[IWL_CMD_QUEUE_NUM].q, index, huge);
	cmd = priv->txq[IWL_CMD_QUEUE_NUM].cmd[cmd_index];
Z
Zhu Yi 已提交
1521 1522 1523 1524 1525 1526 1527 1528 1529

	/* Input error checking is done when commands are added to queue. */
	if (cmd->meta.flags & CMD_WANT_SKB) {
		cmd->meta.source->u.skb = rxb->skb;
		rxb->skb = NULL;
	} else if (cmd->meta.u.callback &&
		   !cmd->meta.u.callback(priv, cmd, rxb->skb))
		rxb->skb = NULL;

1530
	iwl3945_cmd_queue_reclaim(priv, txq_id, index);
Z
Zhu Yi 已提交
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559

	if (!(cmd->meta.flags & CMD_ASYNC)) {
		clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
		wake_up_interruptible(&priv->wait_command_queue);
	}
}

/************************** 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.
 *
1560
 * During initialization, the host sets up the READ queue position to the first
Z
Zhu Yi 已提交
1561 1562
 * INDEX position, and WRITE to the last (READ - 1 wrapped)
 *
1563
 * When the firmware places a packet in a buffer, it will advance the READ index
Z
Zhu Yi 已提交
1564 1565 1566 1567 1568 1569 1570
 * 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
1571
 *   to replenish the iwl->rxq->rx_free.
C
Christoph Hellwig 已提交
1572
 * + In iwl3945_rx_replenish (scheduled) if 'processed' != 'read' then the
Z
Zhu Yi 已提交
1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
 *   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:
 *
1585
 * iwl3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
C
Christoph Hellwig 已提交
1586
 *                            iwl3945_rx_queue_restock
1587
 * iwl3945_rx_queue_restock() Moves available buffers from rx_free into Rx
Z
Zhu Yi 已提交
1588 1589
 *                            queue, updates firmware pointers, and updates
 *                            the WRITE index.  If insufficient rx_free buffers
C
Christoph Hellwig 已提交
1590
 *                            are available, schedules iwl3945_rx_replenish
Z
Zhu Yi 已提交
1591 1592
 *
 * -- enable interrupts --
1593
 * ISR - iwl3945_rx()         Detach iwl_rx_mem_buffers from pool up to the
Z
Zhu Yi 已提交
1594 1595
 *                            READ INDEX, detaching the SKB from the pool.
 *                            Moves the packet buffer from queue to rx_used.
C
Christoph Hellwig 已提交
1596
 *                            Calls iwl3945_rx_queue_restock to refill any empty
Z
Zhu Yi 已提交
1597 1598 1599 1600 1601 1602
 *                            slots.
 * ...
 *
 */

/**
1603
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
1604
 */
1605
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1606 1607 1608 1609 1610 1611
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

/**
C
Christoph Hellwig 已提交
1612
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
1613
 *
1614
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
1615
 * and we have free pre-allocated buffers, fill the ranks as much
1616
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
1617 1618 1619 1620 1621
 *
 * 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.
 */
1622
static int iwl3945_rx_queue_restock(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1623
{
1624
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1625
	struct list_head *element;
1626
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1627 1628 1629 1630 1631
	unsigned long flags;
	int write, rc;

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
1632
	while ((iwl_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
1633
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
1634
		element = rxq->rx_free.next;
1635
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
Z
Zhu Yi 已提交
1636
		list_del(element);
1637 1638

		/* Point to Rx buffer via next RBD in circular buffer */
1639
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->real_dma_addr);
Z
Zhu Yi 已提交
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650
		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);


1651 1652
	/* 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 已提交
1653 1654 1655 1656 1657
	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);
1658
		rc = iwl_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
1659 1660 1661 1662 1663 1664 1665 1666
		if (rc)
			return rc;
	}

	return 0;
}

/**
C
Christoph Hellwig 已提交
1667
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
1668 1669 1670
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
1671
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
1672
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
1673
 */
1674
static void iwl3945_rx_allocate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1675
{
1676
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1677
	struct list_head *element;
1678
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1679 1680 1681 1682
	unsigned long flags;
	spin_lock_irqsave(&rxq->lock, flags);
	while (!list_empty(&rxq->rx_used)) {
		element = rxq->rx_used.next;
1683
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
1684 1685

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
1686
		rxb->skb =
1687 1688
		    alloc_skb(priv->hw_params.rx_buf_size,
				__GFP_NOWARN | GFP_ATOMIC);
Z
Zhu Yi 已提交
1689 1690
		if (!rxb->skb) {
			if (net_ratelimit())
T
Tomas Winkler 已提交
1691
				IWL_CRIT(priv, ": Can not allocate SKB buffers\n");
Z
Zhu Yi 已提交
1692 1693 1694 1695 1696
			/* 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 已提交
1697 1698 1699 1700 1701 1702 1703 1704 1705

		/* 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 已提交
1706 1707
		priv->alloc_rxb_skb++;
		list_del(element);
1708 1709

		/* Get physical address of RB/SKB */
1710 1711 1712 1713
		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 已提交
1714 1715 1716 1717
		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);
1718 1719 1720 1721 1722
}

/*
 * this should be called while priv->lock is locked
 */
1723
static void __iwl3945_rx_replenish(void *data)
1724
{
1725
	struct iwl_priv *priv = data;
1726 1727 1728 1729 1730 1731 1732 1733

	iwl3945_rx_allocate(priv);
	iwl3945_rx_queue_restock(priv);
}


void iwl3945_rx_replenish(void *data)
{
1734
	struct iwl_priv *priv = data;
1735 1736 1737
	unsigned long flags;

	iwl3945_rx_allocate(priv);
Z
Zhu Yi 已提交
1738 1739

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
1740
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
	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 已提交
1762
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
1763
{
1764 1765
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
1766 1767
		return 60;

1768
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
1769
	 *   add 20 dB to make up for divide by 10 */
1770
	if (sig_ratio >= 100)
1771
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787

	/* 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 已提交
1788
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822
{
	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;
}

/**
1823
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
1824 1825 1826 1827 1828
 *
 * Uses the priv->rx_handlers callback function array to invoke
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
1829
static void iwl3945_rx_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1830
{
1831
	struct iwl_rx_mem_buffer *rxb;
1832
	struct iwl_rx_packet *pkt;
1833
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1834 1835 1836
	u32 r, i;
	int reclaim;
	unsigned long flags;
1837
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
1838
	u32 count = 8;
Z
Zhu Yi 已提交
1839

1840 1841
	/* 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 已提交
1842
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
1843 1844
	i = rxq->read;

1845
	if (iwl_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
1846
		fill_rx = 1;
Z
Zhu Yi 已提交
1847 1848
	/* Rx interrupt, but nothing sent from uCode */
	if (i == r)
1849
		IWL_DEBUG(priv, IWL_DL_RX | IWL_DL_ISR, "r = %d, i = %d\n", r, i);
Z
Zhu Yi 已提交
1850 1851 1852 1853

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

1854
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
1855 1856 1857 1858 1859 1860
		 * then a bug has been introduced in the queue refilling
		 * routines -- catch it here */
		BUG_ON(rxb == NULL);

		rxq->queue[i] = NULL;

1861
		pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->real_dma_addr,
1862
					    priv->hw_params.rx_buf_size,
Z
Zhu Yi 已提交
1863
					    PCI_DMA_FROMDEVICE);
1864
		pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877

		/* 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 已提交
1878
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
1879
		if (priv->rx_handlers[pkt->hdr.cmd]) {
1880
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1881 1882 1883 1884 1885
				"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 */
1886
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1887 1888 1889 1890 1891 1892
				"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) {
1893
			/* Invoke any callbacks, transfer the skb to caller, and
1894
			 * fire off the (possibly) blocking iwl_send_cmd()
Z
Zhu Yi 已提交
1895 1896
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
C
Christoph Hellwig 已提交
1897
				iwl3945_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
1898
			else
1899
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910
		}

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

1911
		pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
1912 1913
				priv->hw_params.rx_buf_size,
				PCI_DMA_FROMDEVICE);
Z
Zhu Yi 已提交
1914 1915 1916 1917
		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;
1918 1919 1920 1921 1922 1923 1924 1925 1926 1927
		/* 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 已提交
1928 1929 1930 1931
	}

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

1935
/* call this function to flush any scheduled tasklet */
1936
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
1937
{
T
Tomas Winkler 已提交
1938
	/* wait to make sure we flush pending tasklet*/
1939 1940 1941 1942
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}

Z
Zhu Yi 已提交
1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
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))

1966
static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1967 1968 1969 1970 1971 1972 1973 1974
{
	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 已提交
1975
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1976
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1977 1978 1979
		return;
	}

1980
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
1981
	if (rc) {
1982
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
1983 1984 1985
		return;
	}

1986
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
1987 1988

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

1994
	IWL_ERR(priv, "Desc       Time       asrtPC  blink2 "
Z
Zhu Yi 已提交
1995 1996 1997 1998
		  "ilink1  nmiPC   Line\n");
	for (i = ERROR_START_OFFSET;
	     i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
	     i += ERROR_ELEM_SIZE) {
1999
		desc = iwl_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
2000
		time =
2001
		    iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
2002
		blink1 =
2003
		    iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
2004
		blink2 =
2005
		    iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
2006
		ilink1 =
2007
		    iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
2008
		ilink2 =
2009
		    iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
2010
		data1 =
2011
		    iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
2012

2013 2014 2015 2016
		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 已提交
2017 2018
	}

2019
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2020 2021 2022

}

2023
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
2024 2025

/**
C
Christoph Hellwig 已提交
2026
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
2027
 *
2028
 * NOTE: Must be called with iwl_grab_nic_access() already obtained!
Z
Zhu Yi 已提交
2029
 */
2030
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053
				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++) {
2054
		ev = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
2055
		ptr += sizeof(u32);
2056
		time = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
2057
		ptr += sizeof(u32);
2058 2059 2060 2061
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
		} else {
2062
			data = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
2063
			ptr += sizeof(u32);
2064
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
Z
Zhu Yi 已提交
2065 2066 2067 2068
		}
	}
}

2069
static void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2070 2071 2072 2073 2074 2075 2076 2077 2078 2079
{
	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 已提交
2080
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
2081
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
2082 2083 2084
		return;
	}

2085
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2086
	if (rc) {
2087
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
2088 2089 2090 2091
		return;
	}

	/* event log header */
2092 2093 2094 2095
	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 已提交
2096 2097 2098 2099 2100

	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
2101
		IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
2102
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2103 2104 2105
		return;
	}

2106
	IWL_ERR(priv, "Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
2107 2108 2109 2110 2111
		  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 已提交
2112
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
2113 2114 2115
				    capacity - next_entry, mode);

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

2118
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2119 2120
}

2121
static void iwl3945_error_recovery(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2122 2123 2124
{
	unsigned long flags;

2125 2126 2127
	memcpy(&priv->staging_rxon, &priv->recovery_rxon,
	       sizeof(priv->staging_rxon));
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
2128
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
2129

C
Christoph Hellwig 已提交
2130
	iwl3945_add_station(priv, priv->bssid, 1, 0);
Z
Zhu Yi 已提交
2131 2132

	spin_lock_irqsave(&priv->lock, flags);
2133
	priv->assoc_id = le16_to_cpu(priv->staging_rxon.assoc_id);
Z
Zhu Yi 已提交
2134 2135 2136 2137
	priv->error_recovering = 0;
	spin_unlock_irqrestore(&priv->lock, flags);
}

2138
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2139 2140 2141 2142
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
S
Samuel Ortiz 已提交
2143
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
2144 2145 2146 2147 2148 2149 2150 2151
	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. */
2152 2153
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
2154 2155 2156 2157

	/* 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. */
2158 2159
	inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
	iwl_write32(priv, CSR_FH_INT_STATUS, inta_fh);
Z
Zhu Yi 已提交
2160

S
Samuel Ortiz 已提交
2161
#ifdef CONFIG_IWLWIFI_DEBUG
2162
	if (priv->debug_level & IWL_DL_ISR) {
2163
		/* just for debug */
2164
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
2165
		IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
Z
Zhu Yi 已提交
2166 2167 2168 2169 2170 2171 2172 2173
			      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 已提交
2174
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
2175
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
2176
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
2177 2178 2179 2180
		inta |= CSR_INT_BIT_FH_TX;

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

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

2186
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
2187 2188 2189 2190 2191 2192 2193 2194

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

S
Samuel Ortiz 已提交
2195
#ifdef CONFIG_IWLWIFI_DEBUG
2196
	if (priv->debug_level & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
2197
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
2198
		if (inta & CSR_INT_BIT_SCD)
2199
			IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
2200
				      "the frame/frames.\n");
Z
Zhu Yi 已提交
2201 2202 2203

		/* Alive notification via Rx interrupt will do the real work */
		if (inta & CSR_INT_BIT_ALIVE)
2204
			IWL_DEBUG_ISR(priv, "Alive interrupt\n");
Z
Zhu Yi 已提交
2205 2206 2207
	}
#endif
	/* Safely ignore these bits for debug checks below */
2208
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
2209 2210 2211

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
2212 2213
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
2214
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
2215 2216 2217 2218 2219
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
2220
		IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
2221
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
2222 2223 2224 2225 2226 2227
		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 已提交
2228 2229 2230 2231 2232 2233 2234 2235

		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 已提交
2236
		iwl3945_rx_handle(priv);
Z
Zhu Yi 已提交
2237 2238 2239 2240
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

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

2243 2244 2245
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
		if (!iwl_grab_nic_access(priv)) {
			iwl_write_direct32(priv, FH39_TCSR_CREDIT
2246
					     (FH39_SRVC_CHNL), 0x0);
2247
			iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2248 2249 2250 2251 2252
		}
		handled |= CSR_INT_BIT_FH_TX;
	}

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

	if (inta & ~CSR_INI_SET_MASK) {
2256
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
Z
Zhu Yi 已提交
2257
			 inta & ~CSR_INI_SET_MASK);
2258
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
2259 2260 2261
	}

	/* Re-enable all interrupts */
2262 2263
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
2264
		iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
2265

S
Samuel Ortiz 已提交
2266
#ifdef CONFIG_IWLWIFI_DEBUG
2267
	if (priv->debug_level & (IWL_DL_ISR)) {
2268 2269 2270
		inta = iwl_read32(priv, CSR_INT);
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
2271
		IWL_DEBUG_ISR(priv, "End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
Z
Zhu Yi 已提交
2272 2273 2274 2275 2276 2277
			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
	}
#endif
	spin_unlock_irqrestore(&priv->lock, flags);
}

2278
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
2279
					 enum ieee80211_band band,
2280
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
2281
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
2282 2283
{
	const struct ieee80211_channel *channels = NULL;
2284
	const struct ieee80211_supported_band *sband;
2285
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
2286 2287 2288 2289
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
2290
	sband = iwl_get_hw_mode(priv, band);
2291
	if (!sband)
Z
Zhu Yi 已提交
2292 2293
		return 0;

2294
	channels = sband->channels;
Z
Zhu Yi 已提交
2295

S
Samuel Ortiz 已提交
2296 2297
	active_dwell = iwl_get_active_dwell_time(priv, band, n_probes);
	passive_dwell = iwl_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
2298

2299 2300 2301
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

2302
	for (i = 0, added = 0; i < sband->n_channels; i++) {
2303 2304 2305
		if (channels[i].flags & IEEE80211_CHAN_DISABLED)
			continue;

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

2308
		ch_info = iwl_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
2309
		if (!is_channel_valid(ch_info)) {
2310
			IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
2311 2312 2313 2314
				       scan_ch->channel);
			continue;
		}

2315 2316 2317 2318 2319
		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 已提交
2320
		if (!is_active || is_channel_passive(ch_info) ||
2321
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
2322
			scan_ch->type = 0;	/* passive */
2323 2324 2325
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
2326
			scan_ch->type = 1;	/* active */
2327
		}
Z
Zhu Yi 已提交
2328

2329 2330 2331 2332 2333 2334
		/* 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)
2335
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
2336 2337 2338 2339
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
2340
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
2341
		}
Z
Zhu Yi 已提交
2342

2343
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
2344 2345 2346 2347
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
2348
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
2349 2350 2351 2352
			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
2353
			 * power level:
2354
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
2355 2356 2357
			 */
		}

2358
		IWL_DEBUG_SCAN(priv, "Scanning %d [%s %d]\n",
Z
Zhu Yi 已提交
2359 2360 2361 2362 2363 2364 2365 2366 2367
			       scan_ch->channel,
			       (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
			       (scan_ch->type & 1) ?
			       active_dwell : passive_dwell);

		scan_ch++;
		added++;
	}

2368
	IWL_DEBUG_SCAN(priv, "total channels to scan %d \n", added);
Z
Zhu Yi 已提交
2369 2370 2371
	return added;
}

2372
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
2373 2374 2375 2376 2377
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
2378 2379 2380 2381
		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;
2382
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
2383
			/*
2384
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
2385
			 */
C
Christoph Hellwig 已提交
2386
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
2387
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
2388 2389 2390 2391 2392 2393 2394 2395 2396 2397
		}
	}
}

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

2398
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2399
{
2400 2401 2402 2403 2404 2405
	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 已提交
2406 2407 2408
}

/**
C
Christoph Hellwig 已提交
2409
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2410 2411
 *     looking at all data.
 */
2412
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2413 2414 2415 2416 2417 2418
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

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

2421
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2422 2423 2424
	if (rc)
		return rc;

2425
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2426
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
2427 2428 2429 2430 2431 2432

	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 */
2433
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2434
		if (val != le32_to_cpu(*image)) {
2435
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2436 2437 2438 2439 2440 2441 2442 2443 2444
				  "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;
		}
	}

2445
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2446 2447

	if (!errcnt)
2448 2449
		IWL_DEBUG_INFO(priv,
			"ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
2450 2451 2452 2453 2454 2455

	return rc;
}


/**
C
Christoph Hellwig 已提交
2456
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2457 2458 2459
 *   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.
 */
2460
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2461 2462 2463 2464 2465 2466
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

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

2469
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2470 2471 2472 2473 2474 2475 2476
	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 */
2477
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2478
			i + IWL39_RTC_INST_LOWER_BOUND);
2479
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2480 2481
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
2482
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492
				  "offset 0x%x, is 0x%x, s/b 0x%x\n",
				  i, val, *image);
#endif
			rc = -EIO;
			errcnt++;
			if (errcnt >= 3)
				break;
		}
	}

2493
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2494 2495 2496 2497 2498 2499

	return rc;
}


/**
C
Christoph Hellwig 已提交
2500
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
2501 2502
 *    and verify its contents
 */
2503
static int iwl3945_verify_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2504 2505 2506 2507 2508 2509 2510 2511
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2512
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2513
	if (rc == 0) {
2514
		IWL_DEBUG_INFO(priv, "Bootstrap uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2515 2516 2517 2518 2519 2520
		return 0;
	}

	/* Try initialize */
	image = (__le32 *)priv->ucode_init.v_addr;
	len = priv->ucode_init.len;
C
Christoph Hellwig 已提交
2521
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2522
	if (rc == 0) {
2523
		IWL_DEBUG_INFO(priv, "Initialize uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2524 2525 2526 2527 2528 2529
		return 0;
	}

	/* Try runtime/protocol */
	image = (__le32 *)priv->ucode_code.v_addr;
	len = priv->ucode_code.len;
C
Christoph Hellwig 已提交
2530
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2531
	if (rc == 0) {
2532
		IWL_DEBUG_INFO(priv, "Runtime uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2533 2534 2535
		return 0;
	}

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

2538 2539 2540
	/* 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 已提交
2541 2542
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2543
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
2544 2545 2546 2547

	return rc;
}

2548
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2549 2550
{
	/* Remove all resets to allow NIC to operate */
2551
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
2552 2553 2554
}

/**
C
Christoph Hellwig 已提交
2555
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
2556 2557 2558
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
2559
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2560
{
2561
	struct iwl_ucode *ucode;
2562
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
2563 2564
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
2565 2566 2567 2568
	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 已提交
2569 2570
	u8 *src;
	size_t len;
2571
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
2572 2573 2574

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
2575 2576 2577 2578
	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) {
2579
			IWL_ERR(priv, "%s firmware file req failed: %d\n",
2580 2581 2582 2583 2584 2585 2586
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
2587 2588 2589
				IWL_ERR(priv, "Loaded firmware %s, "
					"which is deprecated. "
					" Please use API v%u instead.\n",
2590
					  buf, api_max);
2591 2592
			IWL_DEBUG_INFO(priv, "Got firmware '%s' file "
				       "(%zd bytes) from disk\n",
2593 2594 2595
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
2596 2597
	}

2598 2599
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
2600 2601 2602

	/* Make sure that we got at least our header! */
	if (ucode_raw->size < sizeof(*ucode)) {
2603
		IWL_ERR(priv, "File size way too small!\n");
2604
		ret = -EINVAL;
Z
Zhu Yi 已提交
2605 2606 2607 2608 2609 2610
		goto err_release;
	}

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

2611
	priv->ucode_ver = le32_to_cpu(ucode->ver);
2612
	api_ver = IWL_UCODE_API(priv->ucode_ver);
Z
Zhu Yi 已提交
2613 2614 2615 2616 2617 2618
	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);

2619 2620 2621 2622 2623
	/* api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
	 * on the API version read from firware header from here on forward */

	if (api_ver < api_min || api_ver > api_max) {
2624
		IWL_ERR(priv, "Driver unable to support your firmware API. "
2625 2626 2627 2628 2629 2630 2631
			  "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)
2632
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
2633 2634 2635 2636
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
2637 2638 2639 2640 2641 2642
	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));

2643
	IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
2644
		       priv->ucode_ver);
2645 2646 2647 2648 2649 2650 2651 2652 2653 2654
	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 已提交
2655

2656

Z
Zhu Yi 已提交
2657 2658 2659 2660 2661
	/* 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) {

2662 2663
		IWL_DEBUG_INFO(priv, "uCode file size %zd too small\n",
			       ucode_raw->size);
2664
		ret = -EINVAL;
Z
Zhu Yi 已提交
2665 2666 2667 2668
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
2669
	if (inst_size > IWL39_MAX_INST_SIZE) {
2670
		IWL_DEBUG_INFO(priv, "uCode instr len %d too large to fit in\n",
2671 2672
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2673 2674 2675
		goto err_release;
	}

2676
	if (data_size > IWL39_MAX_DATA_SIZE) {
2677
		IWL_DEBUG_INFO(priv, "uCode data len %d too large to fit in\n",
2678 2679
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2680 2681
		goto err_release;
	}
2682
	if (init_size > IWL39_MAX_INST_SIZE) {
2683 2684
		IWL_DEBUG_INFO(priv,
				"uCode init instr len %d too large to fit in\n",
2685 2686
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2687 2688
		goto err_release;
	}
2689
	if (init_data_size > IWL39_MAX_DATA_SIZE) {
2690 2691
		IWL_DEBUG_INFO(priv,
				"uCode init data len %d too large to fit in\n",
2692 2693
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2694 2695
		goto err_release;
	}
2696
	if (boot_size > IWL39_MAX_BSM_SIZE) {
2697 2698
		IWL_DEBUG_INFO(priv,
				"uCode boot instr len %d too large to fit in\n",
2699 2700
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2701 2702 2703 2704 2705 2706 2707 2708 2709
		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;
2710
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
2711 2712

	priv->ucode_data.len = data_size;
2713
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
2714 2715

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

2718 2719 2720
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
2721 2722

	/* Initialization instructions and data */
2723 2724
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
2725
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
2726 2727

		priv->ucode_init_data.len = init_data_size;
2728
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
2729 2730 2731 2732

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

	/* Bootstrap (instructions only, no data) */
2735 2736
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
2737
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
2738

2739 2740 2741
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
2742 2743 2744 2745 2746 2747

	/* 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;
2748 2749
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode instr len %zd\n", len);
Z
Zhu Yi 已提交
2750
	memcpy(priv->ucode_code.v_addr, src, len);
2751
	IWL_DEBUG_INFO(priv, "uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
Z
Zhu Yi 已提交
2752 2753 2754
		priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
2755
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
Z
Zhu Yi 已提交
2756 2757
	src = &ucode->data[inst_size];
	len = priv->ucode_data.len;
2758 2759
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode data len %zd\n", len);
Z
Zhu Yi 已提交
2760 2761 2762 2763 2764 2765 2766
	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;
2767 2768
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init instr len %zd\n", len);
Z
Zhu Yi 已提交
2769 2770 2771 2772 2773 2774 2775
		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;
2776 2777
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init data len %zd\n", len);
Z
Zhu Yi 已提交
2778 2779 2780 2781 2782 2783
		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;
2784 2785
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) boot instr len %zd\n", len);
Z
Zhu Yi 已提交
2786 2787 2788 2789 2790 2791 2792
	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:
2793
	IWL_ERR(priv, "failed to allocate pci memory\n");
2794
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
2795
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
2796 2797 2798 2799 2800

 err_release:
	release_firmware(ucode_raw);

 error:
2801
	return ret;
Z
Zhu Yi 已提交
2802 2803 2804 2805
}


/**
C
Christoph Hellwig 已提交
2806
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
2807 2808 2809 2810 2811 2812 2813
 *
 * 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.
 */
2814
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825
{
	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);
2826
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2827 2828 2829 2830 2831 2832
	if (rc) {
		spin_unlock_irqrestore(&priv->lock, flags);
		return rc;
	}

	/* Tell bootstrap uCode where to find image to load */
2833 2834 2835
	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 已提交
2836 2837
				 priv->ucode_data.len);

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

2843
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2844 2845 2846

	spin_unlock_irqrestore(&priv->lock, flags);

2847
	IWL_DEBUG_INFO(priv, "Runtime uCode pointers are set.\n");
Z
Zhu Yi 已提交
2848 2849 2850 2851 2852

	return rc;
}

/**
C
Christoph Hellwig 已提交
2853
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2854 2855 2856 2857
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
2858
 */
2859
static void iwl3945_init_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2860 2861 2862 2863 2864
{
	/* 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 */
2865
		IWL_DEBUG_INFO(priv, "Initialize Alive failed.\n");
Z
Zhu Yi 已提交
2866 2867 2868 2869 2870 2871
		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 已提交
2872
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2873 2874
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2875
		IWL_DEBUG_INFO(priv, "Bad \"initialize\" uCode load.\n");
Z
Zhu Yi 已提交
2876 2877 2878 2879 2880 2881
		goto restart;
	}

	/* Send pointers to protocol/runtime uCode image ... init code will
	 * load and launch runtime uCode, which will send us another "Alive"
	 * notification. */
2882
	IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
C
Christoph Hellwig 已提交
2883
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
2884 2885
		/* Runtime instruction load won't happen;
		 * take it all the way back down so we can try again */
2886
		IWL_DEBUG_INFO(priv, "Couldn't set up uCode pointers.\n");
Z
Zhu Yi 已提交
2887 2888 2889 2890 2891 2892 2893 2894 2895
		goto restart;
	}
	return;

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


2896 2897 2898 2899
/* temporary */
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw,
				     struct sk_buff *skb);

Z
Zhu Yi 已提交
2900
/**
C
Christoph Hellwig 已提交
2901
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2902
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
2903
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
2904
 */
2905
static void iwl3945_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2906 2907 2908 2909 2910
{
	int rc = 0;
	int thermal_spin = 0;
	u32 rfkill;

2911
	IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
2912 2913 2914 2915

	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 */
2916
		IWL_DEBUG_INFO(priv, "Alive failed.\n");
Z
Zhu Yi 已提交
2917 2918 2919 2920 2921 2922
		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 已提交
2923
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2924 2925
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2926
		IWL_DEBUG_INFO(priv, "Bad runtime uCode load.\n");
Z
Zhu Yi 已提交
2927 2928 2929
		goto restart;
	}

C
Christoph Hellwig 已提交
2930
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
2931

2932
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2933
	if (rc) {
2934
		IWL_WARN(priv, "Can not read RFKILL status from adapter\n");
Z
Zhu Yi 已提交
2935 2936 2937
		return;
	}

2938
	rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
2939
	IWL_DEBUG_INFO(priv, "RFKILL status: 0x%x\n", rfkill);
2940
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2941 2942 2943

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
2944
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
2945
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
2946
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
2947 2948 2949 2950 2951
			thermal_spin++;
			udelay(10);
		}

		if (thermal_spin)
2952
			IWL_DEBUG_INFO(priv, "Thermal calibration took %dus\n",
Z
Zhu Yi 已提交
2953 2954 2955 2956
				       thermal_spin * 10);
	} else
		set_bit(STATUS_RF_KILL_HW, &priv->status);

2957
	/* After the ALIVE response, we can send commands to 3945 uCode */
Z
Zhu Yi 已提交
2958 2959 2960 2961 2962
	set_bit(STATUS_ALIVE, &priv->status);

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

2963
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
2964 2965
		return;

2966
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
2967 2968 2969 2970

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

2971
	iwl_power_update_mode(priv, false);
Z
Zhu Yi 已提交
2972

2973
	if (iwl_is_associated(priv)) {
C
Christoph Hellwig 已提交
2974
		struct iwl3945_rxon_cmd *active_rxon =
2975
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
2976

2977 2978
		memcpy(&priv->staging_rxon, &priv->active_rxon,
		       sizeof(priv->staging_rxon));
Z
Zhu Yi 已提交
2979 2980 2981
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
2982
		iwl_connection_init_rx_config(priv, priv->iw_mode);
Z
Zhu Yi 已提交
2983 2984
	}

2985
	/* Configure Bluetooth device coexistence support */
2986
	iwl_send_bt_config(priv);
Z
Zhu Yi 已提交
2987 2988

	/* Configure the adapter for unassociated operation */
C
Christoph Hellwig 已提交
2989
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
2990 2991 2992

	iwl3945_reg_txpower_periodic(priv);

2993 2994
	iwl3945_led_register(priv);

2995
	IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
2996
	set_bit(STATUS_READY, &priv->status);
2997
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
2998 2999

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

3002 3003 3004 3005 3006 3007 3008 3009
	/* 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 已提交
3010 3011 3012 3013 3014 3015
	return;

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

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

3018
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3019 3020 3021 3022 3023
{
	unsigned long flags;
	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
	struct ieee80211_conf *conf = NULL;

3024
	IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
Z
Zhu Yi 已提交
3025 3026 3027 3028 3029 3030

	conf = ieee80211_get_hw_conf(priv->hw);

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

M
Mohamed Abbas 已提交
3031
	iwl3945_led_unregister(priv);
C
Christoph Hellwig 已提交
3032
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
3033 3034 3035 3036 3037 3038 3039 3040 3041 3042

	/* 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 */
3043
	iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
Z
Zhu Yi 已提交
3044 3045

	/* tell the device to stop sending interrupts */
3046
	spin_lock_irqsave(&priv->lock, flags);
3047
	iwl_disable_interrupts(priv);
3048 3049
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
3050 3051 3052 3053

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

C
Christoph Hellwig 已提交
3054
	/* If we have not previously called iwl3945_init() then
Z
Zhu Yi 已提交
3055
	 * clear all bits but the RF Kill and SUSPEND bits and return */
3056
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
3057 3058 3059 3060
		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 |
3061 3062
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
3063
			       test_bit(STATUS_IN_SUSPEND, &priv->status) <<
3064 3065 3066
					STATUS_IN_SUSPEND |
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
3067 3068 3069 3070 3071 3072 3073 3074 3075
		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 |
3076 3077
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
3078 3079 3080
			test_bit(STATUS_IN_SUSPEND, &priv->status) <<
				STATUS_IN_SUSPEND |
			test_bit(STATUS_FW_ERROR, &priv->status) <<
3081 3082 3083
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
3084

3085
	priv->cfg->ops->lib->apm_ops.reset(priv);
Z
Zhu Yi 已提交
3086
	spin_lock_irqsave(&priv->lock, flags);
3087
	iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
Z
Zhu Yi 已提交
3088 3089
	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
3090 3091
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
3092 3093

	spin_lock_irqsave(&priv->lock, flags);
3094 3095
	if (!iwl_grab_nic_access(priv)) {
		iwl_write_prph(priv, APMG_CLK_DIS_REG,
Z
Zhu Yi 已提交
3096
					 APMG_CLK_VAL_DMA_CLK_RQT);
3097
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3098 3099 3100 3101 3102
	}
	spin_unlock_irqrestore(&priv->lock, flags);

	udelay(5);

3103 3104 3105 3106 3107
	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 已提交
3108
 exit:
3109
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
3110 3111 3112 3113 3114 3115

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
3116
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
3117 3118
}

3119
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3120 3121
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3122
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
3123
	mutex_unlock(&priv->mutex);
3124

C
Christoph Hellwig 已提交
3125
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
3126 3127 3128 3129
}

#define MAX_HW_RESTARTS 5

3130
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3131 3132 3133 3134
{
	int rc, i;

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
3135
		IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
Z
Zhu Yi 已提交
3136 3137 3138 3139
		return -EIO;
	}

	if (test_bit(STATUS_RF_KILL_SW, &priv->status)) {
3140
		IWL_WARN(priv, "Radio disabled by SW RF kill (module "
Z
Zhu Yi 已提交
3141
			    "parameter)\n");
3142 3143 3144
		return -ENODEV;
	}

3145
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
3146
		IWL_ERR(priv, "ucode not available for device bring up\n");
3147 3148 3149
		return -EIO;
	}

3150
	/* If platform's RF_KILL switch is NOT set to KILL */
3151
	if (iwl_read32(priv, CSR_GP_CNTRL) &
3152 3153 3154 3155 3156
				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)) {
3157
			IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
3158 3159
			return -ENODEV;
		}
Z
Zhu Yi 已提交
3160
	}
3161

3162
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
3163

C
Christoph Hellwig 已提交
3164
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
3165
	if (rc) {
3166
		IWL_ERR(priv, "Unable to int nic\n");
Z
Zhu Yi 已提交
3167 3168 3169 3170
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
3171 3172
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
3173 3174 3175
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
3176
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
3177
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
3178 3179

	/* really make sure rfkill handshake bits are cleared */
3180 3181
	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 已提交
3182 3183 3184 3185 3186

	/* 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,
3187
	       priv->ucode_data.len);
Z
Zhu Yi 已提交
3188

3189 3190 3191 3192
	/* 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 已提交
3193 3194
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

C
Christoph Hellwig 已提交
3195
		iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
3196 3197 3198 3199

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

		if (rc) {
3203 3204
			IWL_ERR(priv,
				"Unable to set up bootstrap uCode: %d\n", rc);
Z
Zhu Yi 已提交
3205 3206 3207 3208
			continue;
		}

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

3211
		IWL_DEBUG_INFO(priv, DRV_NAME " is coming up\n");
Z
Zhu Yi 已提交
3212 3213 3214 3215 3216

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
3217
	__iwl3945_down(priv);
3218
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
3219 3220 3221

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
3222
	IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
Z
Zhu Yi 已提交
3223 3224 3225 3226 3227 3228 3229 3230 3231 3232
	return -EIO;
}


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

C
Christoph Hellwig 已提交
3233
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
3234
{
3235 3236
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, init_alive_start.work);
Z
Zhu Yi 已提交
3237 3238 3239 3240 3241

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3242
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
3243 3244 3245
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
3246
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
3247
{
3248 3249
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, alive_start.work);
Z
Zhu Yi 已提交
3250 3251 3252 3253 3254

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3255
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
3256 3257 3258
	mutex_unlock(&priv->mutex);
}

3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277
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 已提交
3278
#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)
C
Christoph Hellwig 已提交
3279
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
3280
{
3281 3282
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
3283
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
3284
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
3285
		.len = sizeof(struct iwl3945_scan_cmd),
Z
Zhu Yi 已提交
3286 3287 3288
		.meta.flags = CMD_SIZE_HUGE,
	};
	int rc = 0;
C
Christoph Hellwig 已提交
3289
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
3290
	struct ieee80211_conf *conf = NULL;
3291
	u8 n_probes = 2;
3292
	enum ieee80211_band band;
3293
	DECLARE_SSID_BUF(ssid);
Z
Zhu Yi 已提交
3294 3295 3296 3297 3298

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

3299
	if (!iwl_is_ready(priv)) {
3300
		IWL_WARN(priv, "request scan called when driver not ready.\n");
Z
Zhu Yi 已提交
3301 3302 3303
		goto done;
	}

T
Tomas Winkler 已提交
3304
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
3305 3306 3307 3308 3309 3310 3311
	 * 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)) {
3312 3313
		IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests  "
				"Ignoring second request.\n");
Z
Zhu Yi 已提交
3314 3315 3316 3317 3318
		rc = -EIO;
		goto done;
	}

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
3319
		IWL_DEBUG_SCAN(priv, "Aborting scan due to device shutdown\n");
Z
Zhu Yi 已提交
3320 3321 3322 3323
		goto done;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
3324 3325
		IWL_DEBUG_HC(priv,
			"Scan request while abort pending. Queuing.\n");
Z
Zhu Yi 已提交
3326 3327 3328
		goto done;
	}

3329
	if (iwl_is_rfkill(priv)) {
3330
		IWL_DEBUG_HC(priv, "Aborting scan due to RF Kill activation\n");
Z
Zhu Yi 已提交
3331 3332 3333 3334
		goto done;
	}

	if (!test_bit(STATUS_READY, &priv->status)) {
3335 3336
		IWL_DEBUG_HC(priv,
			"Scan request while uninitialized. Queuing.\n");
Z
Zhu Yi 已提交
3337 3338 3339 3340
		goto done;
	}

	if (!priv->scan_bands) {
3341
		IWL_DEBUG_HC(priv, "Aborting scan due to no requested bands\n");
Z
Zhu Yi 已提交
3342 3343 3344
		goto done;
	}

W
Winkler, Tomas 已提交
3345 3346
	if (!priv->scan) {
		priv->scan = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
3347
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
W
Winkler, Tomas 已提交
3348
		if (!priv->scan) {
Z
Zhu Yi 已提交
3349 3350 3351 3352
			rc = -ENOMEM;
			goto done;
		}
	}
W
Winkler, Tomas 已提交
3353
	scan = priv->scan;
C
Christoph Hellwig 已提交
3354
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
3355 3356 3357 3358

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

3359
	if (iwl_is_associated(priv)) {
Z
Zhu Yi 已提交
3360 3361 3362 3363 3364 3365
		u16 interval = 0;
		u32 extra;
		u32 suspend_time = 100;
		u32 scan_suspend_time = 100;
		unsigned long flags;

3366
		IWL_DEBUG_INFO(priv, "Scanning while associated...\n");
Z
Zhu Yi 已提交
3367 3368 3369 3370 3371 3372

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

		scan->suspend_time = 0;
3373
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387
		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);
3388
		IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n",
Z
Zhu Yi 已提交
3389 3390 3391 3392 3393
			       scan_suspend_time, interval);
	}

	/* We should add the ability for user to lock to PASSIVE ONLY */
	if (priv->one_direct_scan) {
3394 3395
		IWL_DEBUG_SCAN(priv, "Kicking off one direct scan for '%s'\n",
				print_ssid(ssid, priv->direct_ssid,
3396
				priv->direct_ssid_len));
Z
Zhu Yi 已提交
3397 3398 3399 3400
		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);
3401 3402
		n_probes++;
	} else
3403
		IWL_DEBUG_SCAN(priv, "Kicking off one indirect scan.\n");
Z
Zhu Yi 已提交
3404 3405 3406 3407

	/* 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;
3408
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
3409 3410 3411 3412
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

3413
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
3414 3415 3416
		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;
3417
		band = IEEE80211_BAND_2GHZ;
3418
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
3419 3420
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
		scan->good_CRC_th = IWL_GOOD_CRC_TH;
3421
		band = IEEE80211_BAND_5GHZ;
3422
	} else {
3423
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
3424 3425 3426
		goto done;
	}

S
Samuel Ortiz 已提交
3427 3428 3429 3430 3431
	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 已提交
3432 3433 3434
	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

3435
	if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
Z
Zhu Yi 已提交
3436 3437
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

3438 3439 3440 3441
	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 已提交
3442

3443
	if (scan->channel_count == 0) {
3444
		IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count);
3445 3446 3447
		goto done;
	}

Z
Zhu Yi 已提交
3448
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
3449
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
3450 3451 3452 3453
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
3454
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
3455 3456 3457 3458 3459 3460 3461 3462 3463 3464
	if (rc)
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
3465 3466 3467 3468 3469 3470 3471 3472
	/* 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);

3473
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
3474 3475 3476 3477
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
3478
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
3479
{
3480
	struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
Z
Zhu Yi 已提交
3481 3482 3483 3484 3485

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3486
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
3487
	mutex_unlock(&priv->mutex);
S
Samuel Ortiz 已提交
3488
	iwl_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
3489 3490
}

C
Christoph Hellwig 已提交
3491
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
3492
{
3493
	struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
Z
Zhu Yi 已提交
3494 3495 3496 3497

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

C
Christoph Hellwig 已提交
3498
	iwl3945_down(priv);
Z
Zhu Yi 已提交
3499 3500 3501
	queue_work(priv->workqueue, &priv->up);
}

C
Christoph Hellwig 已提交
3502
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
3503
{
3504 3505
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rx_replenish);
Z
Zhu Yi 已提交
3506 3507 3508 3509 3510

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3511
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
3512 3513 3514
	mutex_unlock(&priv->mutex);
}

3515 3516
#define IWL_DELAY_NEXT_SCAN (HZ*2)

3517
static void iwl3945_post_associate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3518 3519 3520 3521
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

3522
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
3523
		IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
3524 3525 3526 3527
		return;
	}


3528
	IWL_DEBUG_ASSOC(priv, "Associated as %d to: %pM\n",
3529
			priv->assoc_id, priv->active_rxon.bssid_addr);
Z
Zhu Yi 已提交
3530 3531 3532 3533

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

A
Abhijeet Kolekar 已提交
3534
	if (!priv->vif || !priv->is_open)
3535
		return;
A
Abhijeet Kolekar 已提交
3536

3537
	iwl_scan_cancel_timeout(priv, 200);
3538

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

3541
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
3542
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3543

3544
	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
3545
	iwl3945_setup_rxon_timing(priv);
3546
	rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
3547 3548
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
3549
		IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3550 3551
			    "Attempting to continue.\n");

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

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

3556
	IWL_DEBUG_ASSOC(priv, "assoc id %d beacon interval %d\n",
Z
Zhu Yi 已提交
3557 3558 3559
			priv->assoc_id, priv->beacon_int);

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3560
		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3561
	else
3562
		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3563

3564
	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3565
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
3566
			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3567
		else
3568
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3569

3570
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3571
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3572 3573 3574

	}

C
Christoph Hellwig 已提交
3575
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3576 3577

	switch (priv->iw_mode) {
3578
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
3579
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
3580 3581
		break;

3582
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
3583

3584
		priv->assoc_id = 1;
C
Christoph Hellwig 已提交
3585
		iwl3945_add_station(priv, priv->bssid, 0, 0);
Z
Zhu Yi 已提交
3586
		iwl3945_sync_sta(priv, IWL_STA_ID,
3587
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
3588 3589
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
3590 3591
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3592 3593 3594 3595

		break;

	default:
3596
		 IWL_ERR(priv, "%s Should not be called in %d mode\n",
3597
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
3598 3599 3600
		break;
	}

C
Christoph Hellwig 已提交
3601
	iwl3945_activate_qos(priv, 0);
3602

3603 3604
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
3605 3606
}

3607
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed);
3608

Z
Zhu Yi 已提交
3609 3610 3611 3612 3613 3614
/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

3615 3616
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
3617
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3618
{
3619
	struct iwl_priv *priv = hw->priv;
3620
	int ret;
Z
Zhu Yi 已提交
3621

3622
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3623 3624 3625 3626

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

3627
	memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
3628 3629 3630 3631 3632 3633
	/* 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) {
3634
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
3635 3636 3637 3638
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
3639

3640
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
3641 3642

	mutex_unlock(&priv->mutex);
3643

S
Samuel Ortiz 已提交
3644
	iwl_rfkill_set_hw_state(priv);
3645

3646 3647 3648
	if (ret)
		goto out_release_irq;

3649
	IWL_DEBUG_INFO(priv, "Start UP work.\n");
3650 3651 3652 3653

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

3654 3655 3656 3657 3658 3659 3660
	/* 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)) {
3661 3662 3663
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
3664 3665 3666 3667 3668
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

3669 3670 3671 3672
	/* ucode is running and will send rfkill notifications,
	 * no need to poll the killswitch state anymore */
	cancel_delayed_work(&priv->rfkill_poll);

3673
	priv->is_open = 1;
3674
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3675
	return 0;
3676 3677

out_release_irq:
3678
	priv->is_open = 0;
3679
	IWL_DEBUG_MAC80211(priv, "leave - failed\n");
3680
	return ret;
Z
Zhu Yi 已提交
3681 3682
}

C
Christoph Hellwig 已提交
3683
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3684
{
3685
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3686

3687
	IWL_DEBUG_MAC80211(priv, "enter\n");
3688

3689
	if (!priv->is_open) {
3690
		IWL_DEBUG_MAC80211(priv, "leave - skip\n");
3691 3692 3693
		return;
	}

Z
Zhu Yi 已提交
3694
	priv->is_open = 0;
3695

3696
	if (iwl_is_ready_rf(priv)) {
3697 3698 3699
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
3700
		mutex_lock(&priv->mutex);
3701
		iwl_scan_cancel_timeout(priv, 100);
3702 3703 3704
		mutex_unlock(&priv->mutex);
	}

3705 3706 3707
	iwl3945_down(priv);

	flush_workqueue(priv->workqueue);
3708 3709 3710 3711

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

3713
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3714 3715
}

3716
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
3717
{
3718
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3719

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

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

3725
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
3726 3727
		dev_kfree_skb_any(skb);

3728
	IWL_DEBUG_MAC80211(priv, "leave\n");
3729
	return NETDEV_TX_OK;
Z
Zhu Yi 已提交
3730 3731
}

C
Christoph Hellwig 已提交
3732
static int iwl3945_mac_add_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
3733 3734
				 struct ieee80211_if_init_conf *conf)
{
3735
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3736 3737
	unsigned long flags;

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

3740
	if (priv->vif) {
3741
		IWL_DEBUG_MAC80211(priv, "leave - vif != NULL\n");
3742
		return -EOPNOTSUPP;
Z
Zhu Yi 已提交
3743 3744 3745
	}

	spin_lock_irqsave(&priv->lock, flags);
3746
	priv->vif = conf->vif;
3747
	priv->iw_mode = conf->type;
Z
Zhu Yi 已提交
3748 3749 3750 3751

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
3752 3753

	if (conf->mac_addr) {
3754
		IWL_DEBUG_MAC80211(priv, "Set: %pM\n", conf->mac_addr);
3755 3756 3757
		memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
	}

3758
	if (iwl_is_ready(priv))
3759
		iwl3945_set_mode(priv, conf->type);
Z
Zhu Yi 已提交
3760 3761 3762

	mutex_unlock(&priv->mutex);

3763
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3764 3765 3766 3767
	return 0;
}

/**
C
Christoph Hellwig 已提交
3768
 * iwl3945_mac_config - mac80211 config callback
Z
Zhu Yi 已提交
3769 3770 3771 3772 3773
 *
 * 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.
 */
3774
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed)
Z
Zhu Yi 已提交
3775
{
3776
	struct iwl_priv *priv = hw->priv;
3777
	const struct iwl_channel_info *ch_info;
3778
	struct ieee80211_conf *conf = &hw->conf;
Z
Zhu Yi 已提交
3779
	unsigned long flags;
3780
	int ret = 0;
Z
Zhu Yi 已提交
3781 3782

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

3786
	if (!iwl_is_ready(priv)) {
3787
		IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
3788 3789
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
3790 3791
	}

3792
	if (unlikely(!iwl3945_mod_params.disable_hw_scan &&
Z
Zhu Yi 已提交
3793
		     test_bit(STATUS_SCANNING, &priv->status))) {
3794
		IWL_DEBUG_MAC80211(priv, "leave - scanning\n");
3795
		set_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
3796
		mutex_unlock(&priv->mutex);
3797
		return 0;
Z
Zhu Yi 已提交
3798 3799 3800 3801
	}

	spin_lock_irqsave(&priv->lock, flags);

3802 3803
	ch_info = iwl_get_channel_info(priv, conf->channel->band,
				       conf->channel->hw_value);
Z
Zhu Yi 已提交
3804
	if (!is_channel_valid(ch_info)) {
3805 3806 3807 3808
		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 已提交
3809
		spin_unlock_irqrestore(&priv->lock, flags);
3810 3811
		ret = -EINVAL;
		goto out;
Z
Zhu Yi 已提交
3812 3813
	}

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

3816
	iwl_set_flags_for_band(priv, conf->channel->band);
Z
Zhu Yi 已提交
3817 3818 3819 3820

	/* 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 */
3821
	iwl_set_rate(priv);
Z
Zhu Yi 已提交
3822 3823 3824 3825 3826

	spin_unlock_irqrestore(&priv->lock, flags);

#ifdef IEEE80211_CONF_CHANNEL_SWITCH
	if (conf->flags & IEEE80211_CONF_CHANNEL_SWITCH) {
C
Christoph Hellwig 已提交
3827
		iwl3945_hw_channel_switch(priv, conf->channel);
3828
		goto out;
Z
Zhu Yi 已提交
3829 3830 3831
	}
#endif

3832 3833 3834 3835
	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 已提交
3836 3837

	if (!conf->radio_enabled) {
3838
		iwl_radio_kill_sw_disable_radio(priv);
3839
		IWL_DEBUG_MAC80211(priv, "leave - radio disabled\n");
3840
		goto out;
Z
Zhu Yi 已提交
3841 3842
	}

3843
	if (iwl_is_rfkill(priv)) {
3844
		IWL_DEBUG_MAC80211(priv, "leave - RF kill\n");
3845 3846
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
3847 3848
	}

3849
	iwl_set_rate(priv);
Z
Zhu Yi 已提交
3850

3851 3852
	if (memcmp(&priv->active_rxon,
		   &priv->staging_rxon, sizeof(priv->staging_rxon)))
C
Christoph Hellwig 已提交
3853
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3854
	else
3855
		IWL_DEBUG_INFO(priv, "Not re-sending same RXON configuration\n");
Z
Zhu Yi 已提交
3856

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

3859
out:
3860
	clear_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
3861
	mutex_unlock(&priv->mutex);
3862
	return ret;
Z
Zhu Yi 已提交
3863 3864
}

3865
static void iwl3945_config_ap(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3866 3867 3868
{
	int rc = 0;

3869
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
3870 3871 3872
		return;

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

		/* RXON - unassoc (to set timing command) */
3876
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
3877
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3878 3879

		/* RXON Timing */
3880
		memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
3881
		iwl3945_setup_rxon_timing(priv);
3882 3883 3884
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
				      sizeof(priv->rxon_timing),
				      &priv->rxon_timing);
Z
Zhu Yi 已提交
3885
		if (rc)
3886
			IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3887 3888 3889
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
3890
		priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
3891
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3892
			priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3893 3894
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
3895
			priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3896 3897
				~RXON_FLG_SHORT_PREAMBLE_MSK;

3898
		if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3899 3900
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
3901
				priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3902 3903
					RXON_FLG_SHORT_SLOT_MSK;
			else
3904
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3905 3906
					~RXON_FLG_SHORT_SLOT_MSK;

3907
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3908
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3909 3910 3911
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
3912
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
3913
		iwl3945_commit_rxon(priv);
3914
		iwl3945_add_station(priv, iwl_bcast_addr, 0, 0);
3915
	}
C
Christoph Hellwig 已提交
3916
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3917 3918 3919 3920 3921 3922

	/* 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... */
}

3923 3924
static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
3925
					struct ieee80211_if_conf *conf)
Z
Zhu Yi 已提交
3926
{
3927
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3928 3929 3930 3931 3932
	int rc;

	if (conf == NULL)
		return -EIO;

3933
	if (priv->vif != vif) {
3934
		IWL_DEBUG_MAC80211(priv, "leave - priv->vif != vif\n");
3935 3936 3937
		return 0;
	}

3938
	/* handle this temporarily here */
3939
	if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
3940 3941 3942 3943
	    conf->changed & IEEE80211_IFCC_BEACON) {
		struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
		if (!beacon)
			return -ENOMEM;
3944
		mutex_lock(&priv->mutex);
3945
		rc = iwl3945_mac_beacon_update(hw, beacon);
3946
		mutex_unlock(&priv->mutex);
3947 3948 3949 3950
		if (rc)
			return rc;
	}

3951
	if (!iwl_is_alive(priv))
3952 3953
		return -EAGAIN;

Z
Zhu Yi 已提交
3954 3955 3956
	mutex_lock(&priv->mutex);

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

3959 3960 3961
/*
 * very dubious code was here; the probe filtering flag is never set:
 *
Z
Zhu Yi 已提交
3962 3963
	if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
	    !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
3964
 */
Z
Zhu Yi 已提交
3965

3966
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
3967 3968 3969
		if (!conf->bssid) {
			conf->bssid = priv->mac_addr;
			memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
3970
			IWL_DEBUG_MAC80211(priv, "bssid was set to: %pM\n",
J
Johannes Berg 已提交
3971
					   conf->bssid);
Z
Zhu Yi 已提交
3972 3973 3974 3975
		}
		if (priv->ibss_beacon)
			dev_kfree_skb(priv->ibss_beacon);

3976
		priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
Z
Zhu Yi 已提交
3977 3978
	}

3979
	if (iwl_is_rfkill(priv))
3980 3981
		goto done;

Z
Zhu Yi 已提交
3982 3983 3984 3985
	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. */
3986
		if (iwl_scan_cancel_timeout(priv, 100)) {
3987
			IWL_WARN(priv, "Aborted scan still in progress "
Z
Zhu Yi 已提交
3988
				    "after 100ms\n");
3989
			IWL_DEBUG_MAC80211(priv, "leaving:scan abort failed\n");
Z
Zhu Yi 已提交
3990 3991 3992
			mutex_unlock(&priv->mutex);
			return -EAGAIN;
		}
3993
		memcpy(priv->staging_rxon.bssid_addr, conf->bssid, ETH_ALEN);
Z
Zhu Yi 已提交
3994 3995 3996 3997 3998 3999 4000

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

4001
		if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
4002
			iwl3945_config_ap(priv);
Z
Zhu Yi 已提交
4003
		else {
C
Christoph Hellwig 已提交
4004
			rc = iwl3945_commit_rxon(priv);
4005
			if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
C
Christoph Hellwig 已提交
4006
				iwl3945_add_station(priv,
4007
					priv->active_rxon.bssid_addr, 1, 0);
Z
Zhu Yi 已提交
4008 4009 4010
		}

	} else {
4011
		iwl_scan_cancel_timeout(priv, 100);
4012
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
4013
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
4014 4015
	}

4016
 done:
4017
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4018 4019 4020 4021 4022
	mutex_unlock(&priv->mutex);

	return 0;
}

C
Christoph Hellwig 已提交
4023
static void iwl3945_mac_remove_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
4024 4025
				     struct ieee80211_if_init_conf *conf)
{
4026
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
4027

4028
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
4029 4030

	mutex_lock(&priv->mutex);
4031

4032
	if (iwl_is_ready_rf(priv)) {
4033
		iwl_scan_cancel_timeout(priv, 100);
4034
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
4035 4036
		iwl3945_commit_rxon(priv);
	}
4037 4038
	if (priv->vif == conf->vif) {
		priv->vif = NULL;
Z
Zhu Yi 已提交
4039 4040 4041 4042
		memset(priv->bssid, 0, ETH_ALEN);
	}
	mutex_unlock(&priv->mutex);

4043
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4044 4045
}

4046 4047 4048 4049 4050 4051 4052
#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)
{
4053
	struct iwl_priv *priv = hw->priv;
4054

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

	if (changes & BSS_CHANGED_ERP_PREAMBLE) {
4058
		IWL_DEBUG_MAC80211(priv, "ERP_PREAMBLE %d\n",
4059 4060
				   bss_conf->use_short_preamble);
		if (bss_conf->use_short_preamble)
4061
			priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
4062
		else
4063 4064
			priv->staging_rxon.flags &=
				~RXON_FLG_SHORT_PREAMBLE_MSK;
4065 4066 4067
	}

	if (changes & BSS_CHANGED_ERP_CTS_PROT) {
4068 4069
		IWL_DEBUG_MAC80211(priv, "ERP_CTS %d\n",
				   bss_conf->use_cts_prot);
4070
		if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
4071
			priv->staging_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
4072
		else
4073
			priv->staging_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
4074 4075 4076
	}

	if (changes & BSS_CHANGED_ASSOC) {
4077
		IWL_DEBUG_MAC80211(priv, "ASSOC %d\n", bss_conf->assoc);
4078 4079 4080 4081 4082 4083 4084
		/* 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;
4085
			priv->timestamp = bss_conf->timestamp;
4086
			priv->assoc_capability = bss_conf->assoc_capability;
4087
			priv->power_data.dtim_period = bss_conf->dtim_period;
4088 4089 4090 4091 4092 4093 4094
			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;
4095 4096
			IWL_DEBUG_MAC80211(priv,
					"DISASSOC %d\n", bss_conf->assoc);
4097
		}
4098
	} else if (changes && iwl_is_associated(priv) && priv->assoc_id) {
4099 4100
			IWL_DEBUG_MAC80211(priv,
					"Associated Changes %d\n", changes);
4101 4102 4103 4104 4105
			iwl3945_send_rxon_assoc(priv);
	}

}

C
Christoph Hellwig 已提交
4106
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
4107 4108 4109
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
Z
Zhu Yi 已提交
4110
{
4111
	struct iwl_priv *priv = hw->priv;
4112
	const u8 *addr;
4113
	int ret;
Z
Zhu Yi 已提交
4114 4115
	u8 sta_id;

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

4118
	if (iwl3945_mod_params.sw_crypto) {
4119
		IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
Z
Zhu Yi 已提交
4120 4121 4122
		return -EOPNOTSUPP;
	}

4123
	addr = sta ? sta->addr : iwl_bcast_addr;
C
Christoph Hellwig 已提交
4124
	sta_id = iwl3945_hw_find_station(priv, addr);
Z
Zhu Yi 已提交
4125
	if (sta_id == IWL_INVALID_STATION) {
4126
		IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
J
Johannes Berg 已提交
4127
				   addr);
Z
Zhu Yi 已提交
4128 4129 4130 4131 4132
		return -EINVAL;
	}

	mutex_lock(&priv->mutex);

4133
	iwl_scan_cancel_timeout(priv, 100);
4134

Z
Zhu Yi 已提交
4135 4136
	switch (cmd) {
	case  SET_KEY:
4137 4138
		ret = iwl3945_update_sta_key_info(priv, key, sta_id);
		if (!ret) {
4139
			iwl_set_rxon_hwcrypto(priv, 1);
C
Christoph Hellwig 已提交
4140
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
4141
			key->hw_key_idx = sta_id;
4142 4143
			IWL_DEBUG_MAC80211(priv,
				"set_key success, using hwcrypto\n");
Z
Zhu Yi 已提交
4144 4145 4146 4147
			key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
		}
		break;
	case DISABLE_KEY:
4148 4149
		ret = iwl3945_clear_sta_key_info(priv, sta_id);
		if (!ret) {
4150
			iwl_set_rxon_hwcrypto(priv, 0);
C
Christoph Hellwig 已提交
4151
			iwl3945_commit_rxon(priv);
4152
			IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
Z
Zhu Yi 已提交
4153 4154 4155
		}
		break;
	default:
4156
		ret = -EINVAL;
Z
Zhu Yi 已提交
4157 4158
	}

4159
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4160 4161
	mutex_unlock(&priv->mutex);

4162
	return ret;
Z
Zhu Yi 已提交
4163 4164
}

J
Johannes Berg 已提交
4165
static int iwl3945_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
Z
Zhu Yi 已提交
4166 4167
			   const struct ieee80211_tx_queue_params *params)
{
4168
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
4169 4170 4171
	unsigned long flags;
	int q;

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

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

	if (queue >= AC_NUM) {
4180
		IWL_DEBUG_MAC80211(priv, "leave - queue >= AC_NUM %d\n", queue);
Z
Zhu Yi 已提交
4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191
		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 =
4192
			cpu_to_le16((params->txop * 32));
Z
Zhu Yi 已提交
4193 4194 4195 4196 4197 4198 4199

	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);
4200
	if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
4201
		iwl3945_activate_qos(priv, 1);
4202
	else if (priv->assoc_id && iwl_is_associated(priv))
C
Christoph Hellwig 已提交
4203
		iwl3945_activate_qos(priv, 0);
Z
Zhu Yi 已提交
4204 4205 4206

	mutex_unlock(&priv->mutex);

4207
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4208 4209 4210
	return 0;
}

C
Christoph Hellwig 已提交
4211
static int iwl3945_mac_get_tx_stats(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
4212 4213
				struct ieee80211_tx_queue_stats *stats)
{
4214
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
4215
	int i, avail;
4216
	struct iwl_tx_queue *txq;
4217
	struct iwl_queue *q;
Z
Zhu Yi 已提交
4218 4219
	unsigned long flags;

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

4222
	if (!iwl_is_ready_rf(priv)) {
4223
		IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
Z
Zhu Yi 已提交
4224 4225 4226 4227 4228 4229
		return -EIO;
	}

	spin_lock_irqsave(&priv->lock, flags);

	for (i = 0; i < AC_NUM; i++) {
4230
		txq = &priv->txq[i];
Z
Zhu Yi 已提交
4231
		q = &txq->q;
4232
		avail = iwl_queue_space(q);
Z
Zhu Yi 已提交
4233

4234 4235 4236
		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 已提交
4237 4238 4239 4240

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

4241
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4242 4243 4244 4245

	return 0;
}

C
Christoph Hellwig 已提交
4246
static void iwl3945_mac_reset_tsf(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
4247
{
4248
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
4249 4250 4251
	unsigned long flags;

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

4254
	iwl_reset_qos(priv);
4255

Z
Zhu Yi 已提交
4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266
	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;
4267
	priv->timestamp = 0;
4268
	if ((priv->iw_mode == NL80211_IFTYPE_STATION))
Z
Zhu Yi 已提交
4269 4270 4271 4272
		priv->beacon_int = 0;

	spin_unlock_irqrestore(&priv->lock, flags);

4273
	if (!iwl_is_ready_rf(priv)) {
4274
		IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
4275 4276 4277 4278
		mutex_unlock(&priv->mutex);
		return;
	}

4279 4280 4281
	/* we are restarting association process
	 * clear RXON_FILTER_ASSOC_MSK bit
	*/
4282
	if (priv->iw_mode != NL80211_IFTYPE_AP) {
4283
		iwl_scan_cancel_timeout(priv, 100);
4284
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
4285
		iwl3945_commit_rxon(priv);
4286 4287
	}

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

4291
		IWL_DEBUG_MAC80211(priv, "leave - not in IBSS\n");
Z
Zhu Yi 已提交
4292 4293 4294 4295
		mutex_unlock(&priv->mutex);
		return;
	}

4296
	iwl_set_rate(priv);
Z
Zhu Yi 已提交
4297 4298 4299

	mutex_unlock(&priv->mutex);

4300
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4301 4302 4303

}

4304
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
4305
{
4306
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
4307 4308
	unsigned long flags;

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

4311
	if (!iwl_is_ready_rf(priv)) {
4312
		IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
Z
Zhu Yi 已提交
4313 4314 4315
		return -EIO;
	}

4316
	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
4317
		IWL_DEBUG_MAC80211(priv, "leave - not IBSS\n");
Z
Zhu Yi 已提交
4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329
		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;

4330
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
4331 4332
	spin_unlock_irqrestore(&priv->lock, flags);

4333
	iwl_reset_qos(priv);
Z
Zhu Yi 已提交
4334

4335
	iwl3945_post_associate(priv);
Z
Zhu Yi 已提交
4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346


	return 0;
}

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

S
Samuel Ortiz 已提交
4347
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
4348 4349 4350 4351 4352 4353 4354 4355

/*
 * 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.
 */
4356 4357
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
4358
{
4359
	struct iwl_priv *priv = d->driver_data;
4360 4361

	return sprintf(buf, "0x%08X\n", priv->debug_level);
Z
Zhu Yi 已提交
4362
}
4363 4364
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
4365 4366
				 const char *buf, size_t count)
{
4367
	struct iwl_priv *priv = d->driver_data;
4368 4369
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
4370

4371 4372
	ret = strict_strtoul(buf, 0, &val);
	if (ret)
T
Tomas Winkler 已提交
4373
		IWL_INFO(priv, "%s is not in hex or decimal form.\n", buf);
Z
Zhu Yi 已提交
4374
	else
4375
		priv->debug_level = val;
Z
Zhu Yi 已提交
4376 4377 4378 4379

	return strnlen(buf, count);
}

4380 4381
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
4382

S
Samuel Ortiz 已提交
4383
#endif /* CONFIG_IWLWIFI_DEBUG */
Z
Zhu Yi 已提交
4384 4385 4386 4387

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

4390
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
4391 4392
		return -EAGAIN;

C
Christoph Hellwig 已提交
4393
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
4394 4395 4396 4397 4398 4399 4400
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
4401
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
4402
	return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
Z
Zhu Yi 已提交
4403 4404 4405 4406 4407 4408
}

static ssize_t store_tx_power(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
4409
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
4410 4411 4412 4413 4414
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
4415
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
4416
	else
C
Christoph Hellwig 已提交
4417
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
4418 4419 4420 4421 4422 4423 4424 4425 4426

	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)
{
4427
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
4428

4429
	return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
Z
Zhu Yi 已提交
4430 4431 4432 4433 4434 4435
}

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

	mutex_lock(&priv->mutex);
4440
	if (le32_to_cpu(priv->staging_rxon.flags) != flags) {
Z
Zhu Yi 已提交
4441
		/* Cancel any currently running scans... */
4442
		if (iwl_scan_cancel_timeout(priv, 100))
4443
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
4444
		else {
4445
			IWL_DEBUG_INFO(priv, "Committing rxon.flags = 0x%04X\n",
Z
Zhu Yi 已提交
4446
				       flags);
4447
			priv->staging_rxon.flags = cpu_to_le32(flags);
C
Christoph Hellwig 已提交
4448
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460
		}
	}
	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)
{
4461
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
4462 4463

	return sprintf(buf, "0x%04X\n",
4464
		le32_to_cpu(priv->active_rxon.filter_flags));
Z
Zhu Yi 已提交
4465 4466 4467 4468 4469 4470
}

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

	mutex_lock(&priv->mutex);
4475
	if (le32_to_cpu(priv->staging_rxon.filter_flags) != filter_flags) {
Z
Zhu Yi 已提交
4476
		/* Cancel any currently running scans... */
4477
		if (iwl_scan_cancel_timeout(priv, 100))
4478
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
4479
		else {
4480
			IWL_DEBUG_INFO(priv, "Committing rxon.filter_flags = "
Z
Zhu Yi 已提交
4481
				       "0x%04X\n", filter_flags);
4482
			priv->staging_rxon.filter_flags =
Z
Zhu Yi 已提交
4483
				cpu_to_le32(filter_flags);
C
Christoph Hellwig 已提交
4484
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
4485 4486 4487 4488 4489 4490 4491 4492 4493 4494
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

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

4495
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
4496 4497 4498 4499

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
4500
	struct iwl_priv *priv = dev_get_drvdata(d);
4501
	struct iwl_spectrum_notification measure_report;
Z
Zhu Yi 已提交
4502
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
4503
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532
	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)
{
4533
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4534
	struct ieee80211_measurement_params params = {
4535
		.channel = le16_to_cpu(priv->active_rxon.channel),
Z
Zhu Yi 已提交
4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556
		.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);
	}

4557
	IWL_DEBUG_INFO(priv, "Invoking measurement of type %d on "
Z
Zhu Yi 已提交
4558
		       "channel %d (for '%s')\n", type, params.channel, buf);
C
Christoph Hellwig 已提交
4559
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
4560 4561 4562 4563 4564 4565

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
4566
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
4567 4568 4569 4570 4571

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
4572
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583

	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)
{
4584
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4585 4586 4587 4588 4589 4590
	return sprintf(buf, "%d", priv->retry_rate);
}

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

4591

Z
Zhu Yi 已提交
4592 4593 4594 4595
static ssize_t store_power_level(struct device *d,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
4596
	struct iwl_priv *priv = dev_get_drvdata(d);
4597 4598 4599
	int ret;
	unsigned long mode;

Z
Zhu Yi 已提交
4600 4601 4602

	mutex_lock(&priv->mutex);

4603
	if (!iwl_is_ready(priv)) {
4604
		ret = -EAGAIN;
Z
Zhu Yi 已提交
4605 4606 4607
		goto out;
	}

4608 4609 4610
	ret = strict_strtoul(buf, 10, &mode);
	if (ret)
		goto out;
Z
Zhu Yi 已提交
4611

4612 4613 4614 4615
	ret = iwl_power_set_user_mode(priv, mode);
	if (ret) {
		IWL_DEBUG_MAC80211(priv, "failed setting power mode.\n");
		goto out;
Z
Zhu Yi 已提交
4616
	}
4617
	ret = count;
Z
Zhu Yi 已提交
4618 4619 4620

 out:
	mutex_unlock(&priv->mutex);
4621
	return ret;
Z
Zhu Yi 已提交
4622 4623
}

4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654
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 已提交
4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675
#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)
{
4676 4677
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
4678 4679 4680 4681 4682 4683 4684
}

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
4685
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
4686
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
4687
	u32 len = 0, ofs = 0;
4688
	u8 *data = (u8 *)&priv->statistics_39;
Z
Zhu Yi 已提交
4689 4690
	int rc = 0;

4691
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
4692 4693 4694
		return -EAGAIN;

	mutex_lock(&priv->mutex);
4695
	rc = iwl_send_statistics_request(priv, 0);
Z
Zhu Yi 已提交
4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722
	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)
{
4723
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4724

4725
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
4726 4727
		return -EAGAIN;

4728
	return sprintf(buf, "%d\n", iwl3945_mod_params.antenna);
Z
Zhu Yi 已提交
4729 4730 4731 4732 4733 4734
}

static ssize_t store_antenna(struct device *d,
			     struct device_attribute *attr,
			     const char *buf, size_t count)
{
4735
	struct iwl_priv *priv __maybe_unused = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4736 4737 4738 4739 4740 4741
	int ant;

	if (count == 0)
		return 0;

	if (sscanf(buf, "%1i", &ant) != 1) {
4742
		IWL_DEBUG_INFO(priv, "not in hex or decimal form.\n");
Z
Zhu Yi 已提交
4743 4744 4745 4746
		return count;
	}

	if ((ant >= 0) && (ant <= 2)) {
4747
		IWL_DEBUG_INFO(priv, "Setting antenna select to %d.\n", ant);
4748
		iwl3945_mod_params.antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
4749
	} else
4750
		IWL_DEBUG_INFO(priv, "Bad antenna select value %d.\n", ant);
Z
Zhu Yi 已提交
4751 4752 4753 4754 4755 4756 4757 4758 4759 4760


	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)
{
4761
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
4762
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775
		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')
4776
		iwl3945_dump_nic_error_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789

	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')
4790
		iwl3945_dump_nic_event_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
4791 4792 4793 4794 4795 4796 4797 4798

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
4799
 * driver setup and tear down
Z
Zhu Yi 已提交
4800 4801 4802
 *
 *****************************************************************************/

4803
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4804
{
4805
	priv->workqueue = create_singlethread_workqueue(DRV_NAME);
Z
Zhu Yi 已提交
4806 4807 4808

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
4809 4810 4811
	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 已提交
4812
	INIT_WORK(&priv->rf_kill, iwl_bg_rf_kill);
C
Christoph Hellwig 已提交
4813 4814 4815
	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);
4816
	INIT_DELAYED_WORK(&priv->rfkill_poll, iwl3945_rfkill_poll);
S
Samuel Ortiz 已提交
4817 4818 4819 4820
	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 已提交
4821 4822

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
4823 4824

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

4828
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4829
{
C
Christoph Hellwig 已提交
4830
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
4831

4832
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
4833 4834 4835 4836 4837
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
4838
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
4839 4840 4841 4842 4843 4844
	&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,
4845
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
4846 4847 4848 4849 4850 4851 4852 4853
	&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 已提交
4854
#ifdef CONFIG_IWLWIFI_DEBUG
4855 4856
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
4857 4858 4859
	NULL
};

C
Christoph Hellwig 已提交
4860
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
4861
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
4862
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
4863 4864
};

C
Christoph Hellwig 已提交
4865 4866 4867 4868 4869 4870 4871 4872
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,
4873
	.configure_filter = iwl_configure_filter,
C
Christoph Hellwig 已提交
4874 4875 4876 4877
	.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,
4878
	.bss_info_changed = iwl3945_bss_info_changed,
4879
	.hw_scan = iwl_mac_hw_scan
Z
Zhu Yi 已提交
4880 4881
};

4882
static int iwl3945_init_drv(struct iwl_priv *priv)
4883 4884
{
	int ret;
4885
	struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
4886 4887 4888 4889 4890

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

	spin_lock_init(&priv->lock);
4891
	spin_lock_init(&priv->power_data.lock);
4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914
	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;
4915 4916
	/* If power management is turned on, default to CAM mode */
	priv->power_mode = IWL_POWER_MODE_CAM;
4917
	priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
4918

4919 4920 4921 4922 4923 4924 4925
	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);
4926 4927 4928 4929 4930
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

4931 4932 4933 4934 4935 4936
	/* Set up txpower settings in driver for all channels */
	if (iwl3945_txpower_set_from_eeprom(priv)) {
		ret = -EIO;
		goto err_free_channel_map;
	}

4937
	ret = iwlcore_init_geos(priv);
4938 4939 4940 4941
	if (ret) {
		IWL_ERR(priv, "initializing geos failed: %d\n", ret);
		goto err_free_channel_map;
	}
4942 4943 4944 4945 4946 4947 4948 4949
	iwl3945_init_hw_rates(priv, priv->ieee_rates);

	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
	if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&priv->bands[IEEE80211_BAND_5GHZ];
4950 4951 4952 4953

	return 0;

err_free_channel_map:
4954
	iwl_free_channel_map(priv);
4955 4956 4957 4958
err:
	return ret;
}

C
Christoph Hellwig 已提交
4959
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
4960 4961
{
	int err = 0;
4962
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
4963
	struct ieee80211_hw *hw;
4964
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
4965
	struct iwl3945_eeprom *eeprom;
4966
	unsigned long flags;
Z
Zhu Yi 已提交
4967

4968 4969 4970 4971
	/***********************
	 * 1. Allocating HW data
	 * ********************/

Z
Zhu Yi 已提交
4972 4973
	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
4974
	hw = iwl_alloc_all(cfg, &iwl3945_hw_ops);
Z
Zhu Yi 已提交
4975
	if (hw == NULL) {
4976
		printk(KERN_ERR DRV_NAME "Can not allocate network device\n");
Z
Zhu Yi 已提交
4977 4978 4979 4980
		err = -ENOMEM;
		goto out;
	}
	priv = hw->priv;
4981
	SET_IEEE80211_DEV(hw, &pdev->dev);
4982

4983 4984
	if ((iwl3945_mod_params.num_of_queues > IWL39_MAX_NUM_QUEUES) ||
	     (iwl3945_mod_params.num_of_queues < IWL_MIN_NUM_QUEUES)) {
4985 4986 4987
		IWL_ERR(priv,
			"invalid queues_num, should be between %d and %d\n",
			IWL_MIN_NUM_QUEUES, IWL39_MAX_NUM_QUEUES);
4988 4989 4990 4991
		err = -EINVAL;
		goto out;
	}

4992 4993 4994 4995
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
4996
	if (iwl3945_mod_params.disable_hw_scan) {
4997
		IWL_DEBUG_INFO(priv, "Disabling hw_scan\n");
4998 4999 5000
		iwl3945_hw_ops.hw_scan = NULL;
	}

5001

5002
	IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
5003 5004
	priv->cfg = cfg;
	priv->pci_dev = pdev;
5005

S
Samuel Ortiz 已提交
5006
#ifdef CONFIG_IWLWIFI_DEBUG
5007
	priv->debug_level = iwl3945_mod_params.debug;
Z
Zhu Yi 已提交
5008 5009
	atomic_set(&priv->restrict_refcnt, 0);
#endif
5010 5011 5012
	hw->rate_control_algorithm = "iwl-3945-rs";
	hw->sta_data_size = sizeof(struct iwl3945_sta_priv);

5013
	/* Tell mac80211 our characteristics */
5014
	hw->flags = IEEE80211_HW_SIGNAL_DBM |
5015
		    IEEE80211_HW_NOISE_DBM;
Z
Zhu Yi 已提交
5016

5017 5018 5019 5020
	hw->wiphy->interface_modes =
		BIT(NL80211_IFTYPE_STATION) |
		BIT(NL80211_IFTYPE_ADHOC);

5021
	hw->wiphy->custom_regulatory = true;
5022

5023 5024
	hw->wiphy->max_scan_ssids = 1;

5025
	/* 4 EDCA QOS priorities */
Z
Zhu Yi 已提交
5026 5027
	hw->queues = 4;

5028 5029 5030
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

	err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
	if (!err)
		err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
	if (err) {
T
Tomas Winkler 已提交
5042
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
5043 5044 5045 5046 5047 5048 5049
		goto out_pci_disable_device;
	}

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

5051 5052 5053
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
5054 5055 5056 5057 5058 5059
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

5060
	IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
Z
Zhu Yi 已提交
5061
			(unsigned long long) pci_resource_len(pdev, 0));
5062
	IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
Z
Zhu Yi 已提交
5063

5064 5065 5066
	/* 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 已提交
5067

5068 5069
	/* amp init */
	err = priv->cfg->ops->lib->apm_ops.init(priv);
5070
	if (err < 0) {
5071
		IWL_DEBUG_INFO(priv, "Failed to init APMG\n");
5072
		goto out_iounmap;
5073
	}
Z
Zhu Yi 已提交
5074

5075 5076 5077
	/***********************
	 * 4. Read EEPROM
	 * ********************/
5078

5079
	/* Read the EEPROM */
5080
	err = iwl_eeprom_init(priv);
5081
	if (err) {
5082
		IWL_ERR(priv, "Unable to init EEPROM\n");
5083 5084 5085
		goto out_remove_sysfs;
	}
	/* MAC Address location in EEPROM same for 3945/4965 */
5086 5087
	eeprom = (struct iwl3945_eeprom *)priv->eeprom;
	memcpy(priv->mac_addr, eeprom->mac_address, ETH_ALEN);
5088
	IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->mac_addr);
5089
	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
Z
Zhu Yi 已提交
5090

5091 5092 5093
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
5094
	/* Device-specific setup */
5095
	if (iwl3945_hw_set_hw_params(priv)) {
5096
		IWL_ERR(priv, "failed to set hw settings\n");
Z
Zhu Yi 已提交
5097 5098 5099
		goto out_iounmap;
	}

5100 5101 5102 5103
	/***********************
	 * 6. Setup priv
	 * ********************/

5104
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
5105
	if (err) {
5106 5107
		IWL_ERR(priv, "initializing driver failed\n");
		goto out_free_geos;
Z
Zhu Yi 已提交
5108 5109
	}

T
Tomas Winkler 已提交
5110 5111
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
5112 5113 5114 5115 5116 5117 5118

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

	/* Initialize module parameter values here */
	/* Disable radio (SW RF KILL) via parameter when loading driver */
5119
	if (iwl3945_mod_params.disable) {
5120
		set_bit(STATUS_RF_KILL_SW, &priv->status);
5121
		IWL_DEBUG_INFO(priv, "Radio disabled.\n");
5122 5123
	}

5124 5125 5126 5127 5128 5129

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

	spin_lock_irqsave(&priv->lock, flags);
5130
	iwl_disable_interrupts(priv);
5131 5132
	spin_unlock_irqrestore(&priv->lock, flags);

5133 5134
	pci_enable_msi(priv->pci_dev);

A
Abhijeet Kolekar 已提交
5135
	err = request_irq(priv->pci_dev->irq, iwl_isr, IRQF_SHARED,
5136 5137 5138 5139 5140 5141
			  DRV_NAME, priv);
	if (err) {
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

5142
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
5143
	if (err) {
5144
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
5145
		goto out_release_irq;
5146 5147
	}

5148 5149
	iwl_set_rxon_channel(priv,
			     &priv->bands[IEEE80211_BAND_2GHZ].channels[5]);
5150 5151 5152 5153
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);

	/*********************************
5154
	 * 9. Setup and Register mac80211
5155 5156
	 * *******************************/

5157 5158
	err = ieee80211_register_hw(priv->hw);
	if (err) {
5159
		IWL_ERR(priv, "Failed to register network device: %d\n", err);
5160
		goto  out_remove_sysfs;
5161
	}
Z
Zhu Yi 已提交
5162

5163 5164
	priv->hw->conf.beacon_int = 100;
	priv->mac80211_registered = 1;
5165

S
Samuel Ortiz 已提交
5166
	err = iwl_rfkill_init(priv);
5167
	if (err)
5168
		IWL_ERR(priv, "Unable to initialize RFKILL system. "
5169 5170
				  "Ignoring error: %d\n", err);

5171 5172 5173 5174
	/* Start monitoring the killswitch */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   2 * HZ);

Z
Zhu Yi 已提交
5175 5176
	return 0;

5177 5178
 out_remove_sysfs:
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
5179
 out_free_geos:
5180
	iwlcore_free_geos(priv);
Z
Zhu Yi 已提交
5181 5182

 out_release_irq:
5183
	free_irq(priv->pci_dev->irq, priv);
Z
Zhu Yi 已提交
5184 5185
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
5186
	iwl3945_unset_hw_params(priv);
5187 5188
 out_disable_msi:
	pci_disable_msi(priv->pci_dev);
Z
Zhu Yi 已提交
5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201
 out_iounmap:
	pci_iounmap(pdev, priv->hw_base);
 out_pci_release_regions:
	pci_release_regions(pdev);
 out_pci_disable_device:
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);
 out_ieee80211_free_hw:
	ieee80211_free_hw(priv->hw);
 out:
	return err;
}

5202
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
5203
{
5204
	struct iwl_priv *priv = pci_get_drvdata(pdev);
5205
	unsigned long flags;
Z
Zhu Yi 已提交
5206 5207 5208 5209

	if (!priv)
		return;

5210
	IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
Z
Zhu Yi 已提交
5211 5212

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

5214 5215 5216 5217 5218 5219
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
5220

5221 5222 5223 5224
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
5225
	iwl_disable_interrupts(priv);
5226 5227 5228 5229
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

C
Christoph Hellwig 已提交
5230
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
5231

S
Samuel Ortiz 已提交
5232
	iwl_rfkill_unregister(priv);
5233 5234
	cancel_delayed_work(&priv->rfkill_poll);

C
Christoph Hellwig 已提交
5235
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
5236 5237

	if (priv->rxq.bd)
5238
		iwl_rx_queue_free(priv, &priv->rxq);
C
Christoph Hellwig 已提交
5239
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
5240

5241
	iwl3945_unset_hw_params(priv);
C
Christoph Hellwig 已提交
5242
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5243

5244 5245 5246
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
5247
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
5248 5249 5250 5251 5252
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;

5253 5254 5255
	free_irq(pdev->irq, priv);
	pci_disable_msi(pdev);

Z
Zhu Yi 已提交
5256 5257 5258 5259 5260
	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

5261
	iwl_free_channel_map(priv);
5262
	iwlcore_free_geos(priv);
W
Winkler, Tomas 已提交
5263
	kfree(priv->scan);
Z
Zhu Yi 已提交
5264 5265 5266 5267 5268 5269 5270 5271
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}

#ifdef CONFIG_PM

C
Christoph Hellwig 已提交
5272
static int iwl3945_pci_suspend(struct pci_dev *pdev, pm_message_t state)
Z
Zhu Yi 已提交
5273
{
5274
	struct iwl_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
5275

5276 5277 5278 5279 5280
	if (priv->is_open) {
		set_bit(STATUS_IN_SUSPEND, &priv->status);
		iwl3945_mac_stop(priv->hw);
		priv->is_open = 1;
	}
5281 5282
	pci_save_state(pdev);
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
5283 5284 5285 5286 5287
	pci_set_power_state(pdev, PCI_D3hot);

	return 0;
}

C
Christoph Hellwig 已提交
5288
static int iwl3945_pci_resume(struct pci_dev *pdev)
Z
Zhu Yi 已提交
5289
{
5290
	struct iwl_priv *priv = pci_get_drvdata(pdev);
5291
	int ret;
Z
Zhu Yi 已提交
5292 5293

	pci_set_power_state(pdev, PCI_D0);
5294 5295 5296
	ret = pci_enable_device(pdev);
	if (ret)
		return ret;
5297
	pci_restore_state(pdev);
Z
Zhu Yi 已提交
5298

5299 5300
	if (priv->is_open)
		iwl3945_mac_start(priv->hw);
Z
Zhu Yi 已提交
5301

5302
	clear_bit(STATUS_IN_SUSPEND, &priv->status);
Z
Zhu Yi 已提交
5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313
	return 0;
}

#endif /* CONFIG_PM */

/*****************************************************************************
 *
 * driver and module entry point
 *
 *****************************************************************************/

C
Christoph Hellwig 已提交
5314
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
5315
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
5316 5317 5318
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
5319
#ifdef CONFIG_PM
C
Christoph Hellwig 已提交
5320 5321
	.suspend = iwl3945_pci_suspend,
	.resume = iwl3945_pci_resume,
Z
Zhu Yi 已提交
5322 5323 5324
#endif
};

C
Christoph Hellwig 已提交
5325
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
5326 5327 5328 5329 5330
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
5331 5332 5333

	ret = iwl3945_rate_control_register();
	if (ret) {
5334 5335
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
5336 5337 5338
		return ret;
	}

C
Christoph Hellwig 已提交
5339
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
5340
	if (ret) {
5341
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
5342
		goto error_register;
Z
Zhu Yi 已提交
5343 5344 5345
	}

	return ret;
5346 5347 5348 5349

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
5350 5351
}

C
Christoph Hellwig 已提交
5352
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
5353
{
C
Christoph Hellwig 已提交
5354
	pci_unregister_driver(&iwl3945_driver);
5355
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
5356 5357
}

5358
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
5359

5360
module_param_named(antenna, iwl3945_mod_params.antenna, int, 0444);
Z
Zhu Yi 已提交
5361
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
5362
module_param_named(disable, iwl3945_mod_params.disable, int, 0444);
Z
Zhu Yi 已提交
5363
MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
5364 5365 5366
module_param_named(swcrypto, iwl3945_mod_params.sw_crypto, int, 0444);
MODULE_PARM_DESC(swcrypto,
		 "using software crypto (default 1 [software])\n");
5367
module_param_named(debug, iwl3945_mod_params.debug, uint, 0444);
Z
Zhu Yi 已提交
5368
MODULE_PARM_DESC(debug, "debug output mask");
5369
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
5370 5371
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

5372
module_param_named(queues_num, iwl3945_mod_params.num_of_queues, int, 0444);
Z
Zhu Yi 已提交
5373 5374
MODULE_PARM_DESC(queues_num, "number of hw queues.");

5375 5376 5377
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 已提交
5378 5379
module_exit(iwl3945_exit);
module_init(iwl3945_init);