iwl3945-base.c 146.1 KB
Newer Older
Z
Zhu Yi 已提交
1 2
/******************************************************************************
 *
3
 * Copyright(c) 2003 - 2009 Intel Corporation. All rights reserved.
Z
Zhu Yi 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * Portions of this file are derived from the ipw3945 project, as well
 * as portions of the ieee80211 subsystem header files.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 * Contact Information:
25
 *  Intel Linux Wireless <ilw@linux.intel.com>
Z
Zhu Yi 已提交
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/

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

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

#include <asm/div64.h>

49 50
#define DRV_NAME	"iwl3945"

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

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

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

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

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

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


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

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

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

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

	spin_lock_irqsave(&priv->sta_lock, flags);

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

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

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

	BUG_ON(priv->num_stations < 0);

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

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

	spin_lock_irqsave(&priv->sta_lock, flags);

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

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

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

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

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

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

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

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

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

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

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

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

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

}

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

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

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

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

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

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

	return rc;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

		return 0;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

	return 0;
}

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

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

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

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

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

485
	memcpy(priv->stations_39[sta_id].sta.key.key, keyconf->key,
Z
Zhu Yi 已提交
486
	       keyconf->keylen);
487 488 489 490 491 492 493 494 495 496 497

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

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

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

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

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

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

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

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

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

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

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

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

A
Abhijeet Kolekar 已提交
545
static int iwl3945_set_dynamic_key(struct iwl_priv *priv,
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
			struct ieee80211_key_conf *keyconf, u8 sta_id)
{
	int ret = 0;

	keyconf->hw_key_idx = HW_KEY_DYNAMIC;

	switch (keyconf->alg) {
	case ALG_CCMP:
		ret = iwl3945_set_ccmp_dynamic_key_info(priv, keyconf, sta_id);
		break;
	case ALG_TKIP:
		ret = iwl3945_set_tkip_dynamic_key_info(priv, keyconf, sta_id);
		break;
	case ALG_WEP:
		ret = iwl3945_set_wep_dynamic_key_info(priv, keyconf, sta_id);
		break;
	default:
		IWL_ERR(priv,"Unknown alg: %s alg = %d\n", __func__, keyconf->alg);
		ret = -EINVAL;
	}

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

	return ret;
}

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

	return ret;
}

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

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

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

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

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

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

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

		priv->frames_count++;
		return frame;
	}

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

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

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

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

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

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

	return priv->ibss_beacon->len;
}

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

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

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

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

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

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

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

	return rc;
}

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

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

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

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

	return cpu_to_le16(new_val);
}

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

	conf = ieee80211_get_hw_conf(priv->hw);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return 0;
}

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

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

	case ALG_TKIP:
		break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	switch (priv->iw_mode) {

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

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

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

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

		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

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

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

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

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

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

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

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

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

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

	spin_unlock_irqrestore(&priv->lock, flags);

1023
	hdr_len = ieee80211_hdrlen(fc);
1024 1025

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

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

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

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

	spin_lock_irqsave(&priv->lock, flags);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1151
	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx->hdr,
1152
			   ieee80211_hdrlen(fc));
Z
Zhu Yi 已提交
1153

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

	if (rc)
		return rc;

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

1171
		ieee80211_stop_queue(priv->hw, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
	}

	return 0;

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

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

#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 已提交
1197
static u32 iwl3945_usecs_to_beacons(u32 usec, u32 beacon_interval)
Z
Zhu Yi 已提交
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
{
	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 已提交
1216
static __le32 iwl3945_add_beacon_time(u32 base, u32 addon, u32 beacon_interval)
Z
Zhu Yi 已提交
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
{
	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);
}

1235
static int iwl3945_get_measurement(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1236 1237 1238
			       struct ieee80211_measurement_params *params,
			       u8 type)
{
1239
	struct iwl_spectrum_cmd spectrum;
1240
	struct iwl_rx_packet *res;
1241
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
1242 1243 1244 1245 1246 1247 1248 1249 1250
		.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);

1251
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
1252
		add_time =
C
Christoph Hellwig 已提交
1253
		    iwl3945_usecs_to_beacons(
Z
Zhu Yi 已提交
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
			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));

1266
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
1267
		spectrum.start_time =
C
Christoph Hellwig 已提交
1268
		    iwl3945_add_beacon_time(priv->last_beacon_time,
Z
Zhu Yi 已提交
1269 1270 1271 1272 1273 1274 1275 1276
				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;
1277
	if (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK)
Z
Zhu Yi 已提交
1278 1279 1280
		spectrum.flags |= RXON_FLG_BAND_24G_MSK |
		    RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK;

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

1285
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1286
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
1287
		IWL_ERR(priv, "Bad return from REPLY_RX_ON_ASSOC command\n");
Z
Zhu Yi 已提交
1288 1289 1290 1291 1292 1293 1294
		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) {
1295
			IWL_DEBUG_INFO(priv, "Replaced existing measurement: %d\n",
1296
						res->u.spectrum.id);
Z
Zhu Yi 已提交
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
			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

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

	palive = &pkt->u.alive_frame;

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

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

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

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

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

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

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

	if (!beacon) {
1371
		IWL_ERR(priv, "update beacon failed\n");
Z
Zhu Yi 已提交
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
		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 已提交
1383
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
1384 1385
}

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

1394
	IWL_DEBUG_RX(priv, "beacon status %x retries %d iss %d "
Z
Zhu Yi 已提交
1395 1396 1397 1398 1399 1400 1401 1402
		"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

1403
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
1404 1405 1406 1407 1408 1409
	    (!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 */
1410
static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
1411
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1412
{
1413
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
1414 1415 1416
	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
	unsigned long status = priv->status;

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

1421
	iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434
		    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);

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

	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 已提交
1447
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
1448 1449 1450 1451 1452 1453 1454
 *
 * 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.
 */
1455
static void iwl3945_setup_rx_handlers(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1456
{
C
Christoph Hellwig 已提交
1457 1458
	priv->rx_handlers[REPLY_ALIVE] = iwl3945_rx_reply_alive;
	priv->rx_handlers[REPLY_ADD_STA] = iwl3945_rx_reply_add_sta;
1459
	priv->rx_handlers[REPLY_ERROR] = iwl_rx_reply_error;
1460
	priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl_rx_csa;
A
Abhijeet Kolekar 已提交
1461
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
1462
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
A
Abhijeet Kolekar 已提交
1463
	    iwl_rx_pm_debug_statistics_notif;
C
Christoph Hellwig 已提交
1464
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
1465

1466 1467 1468 1469
	/*
	 * 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 已提交
1470
	 */
C
Christoph Hellwig 已提交
1471 1472
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
1473

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

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

/************************** 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.
 *
1504
 * During initialization, the host sets up the READ queue position to the first
Z
Zhu Yi 已提交
1505 1506
 * INDEX position, and WRITE to the last (READ - 1 wrapped)
 *
1507
 * When the firmware places a packet in a buffer, it will advance the READ index
Z
Zhu Yi 已提交
1508 1509 1510 1511 1512 1513 1514
 * 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
1515
 *   to replenish the iwl->rxq->rx_free.
C
Christoph Hellwig 已提交
1516
 * + In iwl3945_rx_replenish (scheduled) if 'processed' != 'read' then the
Z
Zhu Yi 已提交
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
 *   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:
 *
1529
 * iwl3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
C
Christoph Hellwig 已提交
1530
 *                            iwl3945_rx_queue_restock
1531
 * iwl3945_rx_queue_restock() Moves available buffers from rx_free into Rx
Z
Zhu Yi 已提交
1532 1533
 *                            queue, updates firmware pointers, and updates
 *                            the WRITE index.  If insufficient rx_free buffers
C
Christoph Hellwig 已提交
1534
 *                            are available, schedules iwl3945_rx_replenish
Z
Zhu Yi 已提交
1535 1536
 *
 * -- enable interrupts --
1537
 * ISR - iwl3945_rx()         Detach iwl_rx_mem_buffers from pool up to the
Z
Zhu Yi 已提交
1538 1539
 *                            READ INDEX, detaching the SKB from the pool.
 *                            Moves the packet buffer from queue to rx_used.
C
Christoph Hellwig 已提交
1540
 *                            Calls iwl3945_rx_queue_restock to refill any empty
Z
Zhu Yi 已提交
1541 1542 1543 1544 1545 1546
 *                            slots.
 * ...
 *
 */

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

/**
C
Christoph Hellwig 已提交
1556
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
1557
 *
1558
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
1559
 * and we have free pre-allocated buffers, fill the ranks as much
1560
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
1561 1562 1563 1564 1565
 *
 * 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.
 */
1566
static int iwl3945_rx_queue_restock(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1567
{
1568
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1569
	struct list_head *element;
1570
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1571 1572 1573 1574 1575
	unsigned long flags;
	int write, rc;

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

		/* Point to Rx buffer via next RBD in circular buffer */
1583
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->real_dma_addr);
Z
Zhu Yi 已提交
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594
		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);


1595 1596
	/* 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 已提交
1597 1598 1599 1600 1601
	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);
1602
		rc = iwl_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
1603 1604 1605 1606 1607 1608 1609 1610
		if (rc)
			return rc;
	}

	return 0;
}

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

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
1630
		rxb->skb =
1631 1632
		    alloc_skb(priv->hw_params.rx_buf_size,
				__GFP_NOWARN | GFP_ATOMIC);
Z
Zhu Yi 已提交
1633 1634
		if (!rxb->skb) {
			if (net_ratelimit())
T
Tomas Winkler 已提交
1635
				IWL_CRIT(priv, ": Can not allocate SKB buffers\n");
Z
Zhu Yi 已提交
1636 1637 1638 1639 1640
			/* 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 已提交
1641 1642 1643 1644 1645 1646 1647 1648 1649

		/* 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 已提交
1650 1651
		priv->alloc_rxb_skb++;
		list_del(element);
1652 1653

		/* Get physical address of RB/SKB */
1654 1655 1656 1657
		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 已提交
1658 1659 1660 1661
		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);
1662 1663 1664 1665 1666
}

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

	iwl3945_rx_allocate(priv);
	iwl3945_rx_queue_restock(priv);
}


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

	iwl3945_rx_allocate(priv);
Z
Zhu Yi 已提交
1682 1683

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
1684
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705
	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 已提交
1706
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
1707
{
1708 1709
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
1710 1711
		return 60;

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

	/* 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 已提交
1732
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766
{
	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;
}

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

1784 1785
	/* 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 已提交
1786
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
1787 1788
	i = rxq->read;

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

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

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

		rxq->queue[i] = NULL;

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

		/* 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 已提交
1822
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
1823
		if (priv->rx_handlers[pkt->hdr.cmd]) {
1824
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1825 1826 1827 1828 1829
				"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 */
1830
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1831 1832 1833 1834 1835 1836
				"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) {
1837
			/* Invoke any callbacks, transfer the skb to caller, and
1838
			 * fire off the (possibly) blocking iwl_send_cmd()
Z
Zhu Yi 已提交
1839 1840
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
1841
				iwl_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
1842
			else
1843
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854
		}

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

1855
		pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
1856 1857
				priv->hw_params.rx_buf_size,
				PCI_DMA_FROMDEVICE);
Z
Zhu Yi 已提交
1858 1859 1860 1861
		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;
1862 1863 1864 1865 1866 1867 1868 1869 1870 1871
		/* 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 已提交
1872 1873 1874 1875
	}

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

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

Z
Zhu Yi 已提交
1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909
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))

1910
static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1911 1912 1913 1914 1915 1916 1917 1918
{
	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 已提交
1919
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1920
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1921 1922 1923
		return;
	}

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

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

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

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

1957 1958 1959 1960
		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 已提交
1961 1962
	}

1963
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
1964 1965 1966

}

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

/**
C
Christoph Hellwig 已提交
1970
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
1971
 *
1972
 * NOTE: Must be called with iwl_grab_nic_access() already obtained!
Z
Zhu Yi 已提交
1973
 */
1974
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
				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++) {
1998
		ev = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1999
		ptr += sizeof(u32);
2000
		time = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
2001
		ptr += sizeof(u32);
2002 2003 2004 2005
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
		} else {
2006
			data = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
2007
			ptr += sizeof(u32);
2008
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
Z
Zhu Yi 已提交
2009 2010 2011 2012
		}
	}
}

2013
static void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2014 2015 2016 2017 2018 2019 2020 2021 2022 2023
{
	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 已提交
2024
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
2025
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
2026 2027 2028
		return;
	}

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

	/* event log header */
2036 2037 2038 2039
	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 已提交
2040 2041 2042 2043 2044

	size = num_wraps ? capacity : next_entry;

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

2050
	IWL_ERR(priv, "Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
2051 2052 2053 2054 2055
		  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 已提交
2056
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
2057 2058 2059
				    capacity - next_entry, mode);

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

2062
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2063 2064
}

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

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

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

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

2082
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2083 2084 2085 2086
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
S
Samuel Ortiz 已提交
2087
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
2088 2089 2090 2091 2092 2093 2094 2095
	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. */
2096 2097
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
2098 2099 2100 2101

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

S
Samuel Ortiz 已提交
2105
#ifdef CONFIG_IWLWIFI_DEBUG
2106
	if (priv->debug_level & IWL_DL_ISR) {
2107
		/* just for debug */
2108
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
2109
		IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
Z
Zhu Yi 已提交
2110 2111 2112 2113 2114 2115 2116 2117
			      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 已提交
2118
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
2119
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
2120
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
2121 2122 2123 2124
		inta |= CSR_INT_BIT_FH_TX;

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

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

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

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

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

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

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

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
2164
		IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
2165
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
2166 2167 2168 2169 2170 2171
		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 已提交
2172 2173 2174 2175 2176 2177 2178 2179

		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 已提交
2180
		iwl3945_rx_handle(priv);
Z
Zhu Yi 已提交
2181 2182 2183 2184
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

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

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

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

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

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

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

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

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

2238
	channels = sband->channels;
Z
Zhu Yi 已提交
2239

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

2243 2244 2245
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

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

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

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

2259 2260 2261 2262 2263
		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 已提交
2264
		if (!is_active || is_channel_passive(ch_info) ||
2265
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
2266
			scan_ch->type = 0;	/* passive */
2267 2268 2269
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
2270
			scan_ch->type = 1;	/* active */
2271
		}
Z
Zhu Yi 已提交
2272

2273 2274 2275 2276 2277 2278
		/* 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)
2279
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
2280 2281 2282 2283
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
2284
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
2285
		}
Z
Zhu Yi 已提交
2286

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

		/*scan_pwr_info->tpc.tx_gain; */
2292
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
2293 2294 2295 2296
			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
2297
			 * power level:
2298
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
2299 2300 2301
			 */
		}

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

		scan_ch++;
		added++;
	}

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

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

	for (i = 0; i < IWL_RATE_COUNT; i++) {
2322 2323 2324 2325
		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;
2326
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
2327
			/*
2328
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
2329
			 */
C
Christoph Hellwig 已提交
2330
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
2331
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
2332 2333 2334 2335 2336 2337 2338 2339 2340 2341
		}
	}
}

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

2342
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2343
{
2344 2345 2346 2347 2348 2349
	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 已提交
2350 2351 2352
}

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

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

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

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

	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 */
2377
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2378
		if (val != le32_to_cpu(*image)) {
2379
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2380 2381 2382 2383 2384 2385 2386 2387 2388
				  "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;
		}
	}

2389
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2390 2391

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

	return rc;
}


/**
C
Christoph Hellwig 已提交
2400
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2401 2402 2403
 *   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.
 */
2404
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2405 2406 2407 2408 2409 2410
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

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

2413
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2414 2415 2416 2417 2418 2419 2420
	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 */
2421
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2422
			i + IWL39_RTC_INST_LOWER_BOUND);
2423
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2424 2425
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
2426
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
				  "offset 0x%x, is 0x%x, s/b 0x%x\n",
				  i, val, *image);
#endif
			rc = -EIO;
			errcnt++;
			if (errcnt >= 3)
				break;
		}
	}

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

	return rc;
}


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

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

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

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

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

2482 2483 2484
	/* 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 已提交
2485 2486
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2487
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
2488 2489 2490 2491

	return rc;
}

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

/**
C
Christoph Hellwig 已提交
2499
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
2500 2501 2502
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
2503
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2504
{
2505
	struct iwl_ucode *ucode;
2506
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
2507 2508
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
2509 2510 2511 2512
	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 已提交
2513 2514
	u8 *src;
	size_t len;
2515
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
2516 2517 2518

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

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

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

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

2555
	priv->ucode_ver = le32_to_cpu(ucode->ver);
2556
	api_ver = IWL_UCODE_API(priv->ucode_ver);
Z
Zhu Yi 已提交
2557 2558 2559 2560 2561 2562
	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);

2563 2564 2565 2566 2567
	/* 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) {
2568
		IWL_ERR(priv, "Driver unable to support your firmware API. "
2569 2570 2571 2572 2573 2574 2575
			  "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)
2576
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
2577 2578 2579 2580
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
2581 2582 2583 2584 2585 2586
	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));

2587
	IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
2588
		       priv->ucode_ver);
2589 2590 2591 2592 2593 2594 2595 2596 2597 2598
	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 已提交
2599

2600

Z
Zhu Yi 已提交
2601 2602 2603 2604 2605
	/* 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) {

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

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

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

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

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

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

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

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

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

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

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

	/* 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;
2692 2693
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode instr len %zd\n", len);
Z
Zhu Yi 已提交
2694
	memcpy(priv->ucode_code.v_addr, src, len);
2695
	IWL_DEBUG_INFO(priv, "uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
Z
Zhu Yi 已提交
2696 2697 2698
		priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
2699
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
Z
Zhu Yi 已提交
2700 2701
	src = &ucode->data[inst_size];
	len = priv->ucode_data.len;
2702 2703
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode data len %zd\n", len);
Z
Zhu Yi 已提交
2704 2705 2706 2707 2708 2709 2710
	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;
2711 2712
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init instr len %zd\n", len);
Z
Zhu Yi 已提交
2713 2714 2715 2716 2717 2718 2719
		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;
2720 2721
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init data len %zd\n", len);
Z
Zhu Yi 已提交
2722 2723 2724 2725 2726 2727
		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;
2728 2729
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) boot instr len %zd\n", len);
Z
Zhu Yi 已提交
2730 2731 2732 2733 2734 2735 2736
	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:
2737
	IWL_ERR(priv, "failed to allocate pci memory\n");
2738
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
2739
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
2740 2741 2742 2743 2744

 err_release:
	release_firmware(ucode_raw);

 error:
2745
	return ret;
Z
Zhu Yi 已提交
2746 2747 2748 2749
}


/**
C
Christoph Hellwig 已提交
2750
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
2751 2752 2753 2754 2755 2756 2757
 *
 * 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.
 */
2758
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769
{
	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);
2770
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2771 2772 2773 2774 2775 2776
	if (rc) {
		spin_unlock_irqrestore(&priv->lock, flags);
		return rc;
	}

	/* Tell bootstrap uCode where to find image to load */
2777 2778 2779
	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 已提交
2780 2781
				 priv->ucode_data.len);

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

2787
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2788 2789 2790

	spin_unlock_irqrestore(&priv->lock, flags);

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

	return rc;
}

/**
C
Christoph Hellwig 已提交
2797
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2798 2799 2800 2801
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
2802
 */
2803
static void iwl3945_init_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2804 2805 2806 2807 2808
{
	/* 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 */
2809
		IWL_DEBUG_INFO(priv, "Initialize Alive failed.\n");
Z
Zhu Yi 已提交
2810 2811 2812 2813 2814 2815
		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 已提交
2816
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2817 2818
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2819
		IWL_DEBUG_INFO(priv, "Bad \"initialize\" uCode load.\n");
Z
Zhu Yi 已提交
2820 2821 2822 2823 2824 2825
		goto restart;
	}

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

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


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

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

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

	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 */
2860
		IWL_DEBUG_INFO(priv, "Alive failed.\n");
Z
Zhu Yi 已提交
2861 2862 2863 2864 2865 2866
		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 已提交
2867
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2868 2869
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2870
		IWL_DEBUG_INFO(priv, "Bad runtime uCode load.\n");
Z
Zhu Yi 已提交
2871 2872 2873
		goto restart;
	}

C
Christoph Hellwig 已提交
2874
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
2875

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

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

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

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

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

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

2907
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
2908 2909
		return;

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

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

2915
	iwl_power_update_mode(priv, false);
Z
Zhu Yi 已提交
2916

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

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

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

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

	iwl3945_reg_txpower_periodic(priv);

2937 2938
	iwl3945_led_register(priv);

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

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

2946 2947 2948 2949 2950 2951 2952 2953
	/* 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 已提交
2954 2955 2956 2957 2958 2959
	return;

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

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

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

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

	conf = ieee80211_get_hw_conf(priv->hw);

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

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

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

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

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

C
Christoph Hellwig 已提交
2998
	/* If we have not previously called iwl3945_init() then
Z
Zhu Yi 已提交
2999
	 * clear all bits but the RF Kill and SUSPEND bits and return */
3000
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
3001 3002 3003 3004
		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 |
3005 3006
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
3007
			       test_bit(STATUS_IN_SUSPEND, &priv->status) <<
3008 3009 3010
					STATUS_IN_SUSPEND |
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
3011 3012 3013 3014 3015 3016 3017 3018 3019
		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 |
3020 3021
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
3022 3023 3024
			test_bit(STATUS_IN_SUSPEND, &priv->status) <<
				STATUS_IN_SUSPEND |
			test_bit(STATUS_FW_ERROR, &priv->status) <<
3025 3026 3027
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
3028

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

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

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

	udelay(5);

3047 3048 3049 3050 3051
	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 已提交
3052
 exit:
3053
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
3054 3055 3056 3057 3058 3059

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

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

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

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

#define MAX_HW_RESTARTS 5

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

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

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

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

3094
	/* If platform's RF_KILL switch is NOT set to KILL */
3095
	if (iwl_read32(priv, CSR_GP_CNTRL) &
3096 3097 3098 3099 3100
				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)) {
3101
			IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
3102 3103
			return -ENODEV;
		}
Z
Zhu Yi 已提交
3104
	}
3105

3106
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
3107

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

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

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

	/* really make sure rfkill handshake bits are cleared */
3124 3125
	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 已提交
3126 3127 3128 3129 3130

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

3133 3134 3135 3136
	/* 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 已提交
3137 3138
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

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

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

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

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

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

		return 0;
	}

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

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


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

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

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

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

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

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

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

3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221
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 已提交
3222
#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)
C
Christoph Hellwig 已提交
3223
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
3224
{
3225 3226
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
3227
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
3228
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
3229
		.len = sizeof(struct iwl3945_scan_cmd),
Z
Zhu Yi 已提交
3230 3231 3232
		.meta.flags = CMD_SIZE_HUGE,
	};
	int rc = 0;
C
Christoph Hellwig 已提交
3233
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
3234
	struct ieee80211_conf *conf = NULL;
3235
	u8 n_probes = 2;
3236
	enum ieee80211_band band;
3237
	DECLARE_SSID_BUF(ssid);
Z
Zhu Yi 已提交
3238 3239 3240 3241 3242

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

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

T
Tomas Winkler 已提交
3248
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
3249 3250 3251 3252 3253 3254 3255
	 * 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)) {
3256 3257
		IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests  "
				"Ignoring second request.\n");
Z
Zhu Yi 已提交
3258 3259 3260 3261 3262
		rc = -EIO;
		goto done;
	}

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

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

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

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

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

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

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

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

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

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

		scan->suspend_time = 0;
3317
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331
		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);
3332
		IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n",
Z
Zhu Yi 已提交
3333 3334 3335 3336 3337
			       scan_suspend_time, interval);
	}

	/* We should add the ability for user to lock to PASSIVE ONLY */
	if (priv->one_direct_scan) {
3338 3339
		IWL_DEBUG_SCAN(priv, "Kicking off one direct scan for '%s'\n",
				print_ssid(ssid, priv->direct_ssid,
3340
				priv->direct_ssid_len));
Z
Zhu Yi 已提交
3341 3342 3343 3344
		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);
3345 3346
		n_probes++;
	} else
3347
		IWL_DEBUG_SCAN(priv, "Kicking off one indirect scan.\n");
Z
Zhu Yi 已提交
3348 3349 3350 3351

	/* 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;
3352
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
3353 3354 3355 3356
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

3357
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
3358 3359 3360
		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;
3361
		band = IEEE80211_BAND_2GHZ;
3362
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
3363 3364
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
		scan->good_CRC_th = IWL_GOOD_CRC_TH;
3365
		band = IEEE80211_BAND_5GHZ;
3366
	} else {
3367
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
3368 3369 3370
		goto done;
	}

S
Samuel Ortiz 已提交
3371 3372 3373 3374 3375
	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 已提交
3376 3377 3378
	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

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

3382 3383 3384 3385
	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 已提交
3386

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

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

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

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

	mutex_unlock(&priv->mutex);
	return;

 done:
3409 3410 3411 3412 3413 3414 3415 3416
	/* 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);

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

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

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

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

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

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

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

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

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

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

3459 3460
#define IWL_DELAY_NEXT_SCAN (HZ*2)

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

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


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

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

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

3481
	iwl_scan_cancel_timeout(priv, 200);
3482

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

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

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

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

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

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

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

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

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

	}

C
Christoph Hellwig 已提交
3519
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3520 3521

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

3526
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
3527

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

		break;

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

3545
	iwl_activate_qos(priv, 0);
3546

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

3551
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed);
3552

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

3559 3560
#define UCODE_READY_TIMEOUT	(2 * HZ)

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

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

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

3571
	memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
3572 3573 3574 3575 3576 3577
	/* 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) {
3578
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
3579 3580 3581 3582
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
3583

3584
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
3585 3586

	mutex_unlock(&priv->mutex);
3587

S
Samuel Ortiz 已提交
3588
	iwl_rfkill_set_hw_state(priv);
3589

3590 3591 3592
	if (ret)
		goto out_release_irq;

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

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

3598 3599 3600 3601 3602 3603 3604
	/* 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)) {
3605 3606 3607
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
3608 3609 3610 3611 3612
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

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

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

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

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

3631
	IWL_DEBUG_MAC80211(priv, "enter\n");
3632

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

Z
Zhu Yi 已提交
3638
	priv->is_open = 0;
3639

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

3649 3650 3651
	iwl3945_down(priv);

	flush_workqueue(priv->workqueue);
3652 3653 3654 3655

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

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

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

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

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

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

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

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

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

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

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

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
3696 3697

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

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

	mutex_unlock(&priv->mutex);

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

/**
C
Christoph Hellwig 已提交
3712
 * iwl3945_mac_config - mac80211 config callback
Z
Zhu Yi 已提交
3713 3714 3715 3716 3717
 *
 * 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.
 */
3718
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed)
Z
Zhu Yi 已提交
3719
{
3720
	struct iwl_priv *priv = hw->priv;
3721
	const struct iwl_channel_info *ch_info;
3722
	struct ieee80211_conf *conf = &hw->conf;
Z
Zhu Yi 已提交
3723
	unsigned long flags;
3724
	int ret = 0;
Z
Zhu Yi 已提交
3725 3726

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

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

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

	spin_lock_irqsave(&priv->lock, flags);

3746 3747
	ch_info = iwl_get_channel_info(priv, conf->channel->band,
				       conf->channel->hw_value);
Z
Zhu Yi 已提交
3748
	if (!is_channel_valid(ch_info)) {
3749 3750 3751 3752
		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 已提交
3753
		spin_unlock_irqrestore(&priv->lock, flags);
3754 3755
		ret = -EINVAL;
		goto out;
Z
Zhu Yi 已提交
3756 3757
	}

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

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

	/* 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 */
3765
	iwl_set_rate(priv);
Z
Zhu Yi 已提交
3766 3767 3768 3769 3770

	spin_unlock_irqrestore(&priv->lock, flags);

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

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

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

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

3797
	iwl_set_rate(priv);
Z
Zhu Yi 已提交
3798

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

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

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

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

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

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

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

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

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

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

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

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

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

	if (conf == NULL)
		return -EIO;

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

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

3899
	if (!iwl_is_alive(priv))
3900 3901
		return -EAGAIN;

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

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

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

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

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

3927
	if (iwl_is_rfkill(priv))
3928 3929
		goto done;

Z
Zhu Yi 已提交
3930 3931 3932 3933
	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. */
3934
		if (iwl_scan_cancel_timeout(priv, 100)) {
3935
			IWL_WARN(priv, "Aborted scan still in progress "
Z
Zhu Yi 已提交
3936
				    "after 100ms\n");
3937
			IWL_DEBUG_MAC80211(priv, "leaving:scan abort failed\n");
Z
Zhu Yi 已提交
3938 3939 3940
			mutex_unlock(&priv->mutex);
			return -EAGAIN;
		}
3941
		memcpy(priv->staging_rxon.bssid_addr, conf->bssid, ETH_ALEN);
Z
Zhu Yi 已提交
3942 3943 3944 3945 3946 3947 3948

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

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

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

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

	return 0;
}

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

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

	mutex_lock(&priv->mutex);
3979

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

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

3994 3995 3996 3997 3998 3999 4000
#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)
{
4001
	struct iwl_priv *priv = hw->priv;
4002

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

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

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

	if (changes & BSS_CHANGED_ASSOC) {
4025
		IWL_DEBUG_MAC80211(priv, "ASSOC %d\n", bss_conf->assoc);
4026 4027 4028 4029 4030 4031 4032
		/* 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;
4033
			priv->timestamp = bss_conf->timestamp;
4034
			priv->assoc_capability = bss_conf->assoc_capability;
4035
			priv->power_data.dtim_period = bss_conf->dtim_period;
4036 4037 4038 4039 4040 4041 4042
			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;
4043 4044
			IWL_DEBUG_MAC80211(priv,
					"DISASSOC %d\n", bss_conf->assoc);
4045
		}
4046
	} else if (changes && iwl_is_associated(priv) && priv->assoc_id) {
4047 4048
			IWL_DEBUG_MAC80211(priv,
					"Associated Changes %d\n", changes);
4049 4050 4051 4052 4053
			iwl3945_send_rxon_assoc(priv);
	}

}

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

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

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

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

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

	mutex_lock(&priv->mutex);
4085
	iwl_scan_cancel_timeout(priv, 100);
4086
	mutex_unlock(&priv->mutex);
4087

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

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

4109
	return ret;
Z
Zhu Yi 已提交
4110 4111
}

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

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

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

	if (queue >= AC_NUM) {
4127
		IWL_DEBUG_MAC80211(priv, "leave - queue >= AC_NUM %d\n", queue);
Z
Zhu Yi 已提交
4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138
		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 =
4139
			cpu_to_le16((params->txop * 32));
Z
Zhu Yi 已提交
4140 4141 4142 4143 4144 4145 4146

	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);
4147
	if (priv->iw_mode == NL80211_IFTYPE_AP)
4148
		iwl_activate_qos(priv, 1);
4149
	else if (priv->assoc_id && iwl_is_associated(priv))
4150
		iwl_activate_qos(priv, 0);
Z
Zhu Yi 已提交
4151 4152 4153

	mutex_unlock(&priv->mutex);

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

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

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

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

	spin_lock_irqsave(&priv->lock, flags);

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

4181 4182 4183
		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 已提交
4184 4185 4186 4187

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

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

	return 0;
}

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

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

4201
	iwl_reset_qos(priv);
4202

Z
Zhu Yi 已提交
4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213
	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;
4214
	priv->timestamp = 0;
4215
	if ((priv->iw_mode == NL80211_IFTYPE_STATION))
Z
Zhu Yi 已提交
4216 4217 4218 4219
		priv->beacon_int = 0;

	spin_unlock_irqrestore(&priv->lock, flags);

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

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

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

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

4243
	iwl_set_rate(priv);
Z
Zhu Yi 已提交
4244 4245 4246

	mutex_unlock(&priv->mutex);

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

}

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

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

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

4264
	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
4265
		IWL_DEBUG_MAC80211(priv, "leave - not IBSS\n");
Z
Zhu Yi 已提交
4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276
		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;
4277 4278
	timestamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
	priv->timestamp = le64_to_cpu(timestamp);
Z
Zhu Yi 已提交
4279

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

4283
	iwl_reset_qos(priv);
Z
Zhu Yi 已提交
4284

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


	return 0;
}

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

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

/*
 * 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.
 */
4306 4307
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
4308
{
4309
	struct iwl_priv *priv = d->driver_data;
4310 4311

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

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

	return strnlen(buf, count);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return count;
}

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

4445
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
4446 4447 4448 4449

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
4450
	struct iwl_priv *priv = dev_get_drvdata(d);
4451
	struct iwl_spectrum_notification measure_report;
Z
Zhu Yi 已提交
4452
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
4453
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482
	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)
{
4483
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4484
	struct ieee80211_measurement_params params = {
4485
		.channel = le16_to_cpu(priv->active_rxon.channel),
Z
Zhu Yi 已提交
4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506
		.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);
	}

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

	return count;
}

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

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

	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)
{
4534
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4535 4536 4537 4538 4539 4540
	return sprintf(buf, "%d", priv->retry_rate);
}

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

4541

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

Z
Zhu Yi 已提交
4550 4551 4552

	mutex_lock(&priv->mutex);

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

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

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

4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599
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 已提交
4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620
#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)
{
4621 4622
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
4623 4624 4625 4626 4627 4628 4629
}

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

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

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

	mutex_lock(&priv->mutex);
4640
	rc = iwl_send_statistics_request(priv, 0);
Z
Zhu Yi 已提交
4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667
	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)
{
4668
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
4669

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

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

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

	if (count == 0)
		return 0;

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

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


	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)
{
4706
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
4707
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720
		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')
4721
		iwl3945_dump_nic_error_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734

	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')
4735
		iwl3945_dump_nic_event_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
4736 4737 4738 4739 4740 4741 4742 4743

	return strnlen(buf, count);
}

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

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

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

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
4754 4755 4756
	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 已提交
4757
	INIT_WORK(&priv->rf_kill, iwl_bg_rf_kill);
C
Christoph Hellwig 已提交
4758 4759 4760
	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);
4761
	INIT_DELAYED_WORK(&priv->rfkill_poll, iwl3945_rfkill_poll);
S
Samuel Ortiz 已提交
4762 4763 4764 4765
	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 已提交
4766 4767

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
4768 4769

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

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

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

C
Christoph Hellwig 已提交
4783
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
4784 4785 4786 4787 4788 4789
	&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,
4790
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
4791 4792 4793 4794 4795 4796 4797 4798
	&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 已提交
4799
#ifdef CONFIG_IWLWIFI_DEBUG
4800 4801
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
4802 4803 4804
	NULL
};

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

C
Christoph Hellwig 已提交
4810 4811 4812 4813 4814 4815 4816 4817
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,
4818
	.configure_filter = iwl_configure_filter,
C
Christoph Hellwig 已提交
4819 4820 4821 4822
	.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,
4823
	.bss_info_changed = iwl3945_bss_info_changed,
4824
	.hw_scan = iwl_mac_hw_scan
Z
Zhu Yi 已提交
4825 4826
};

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

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

	spin_lock_init(&priv->lock);
4836
	spin_lock_init(&priv->power_data.lock);
4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859
	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;
4860 4861
	/* If power management is turned on, default to CAM mode */
	priv->power_mode = IWL_POWER_MODE_CAM;
4862
	priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
4863

4864 4865 4866 4867 4868 4869 4870
	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);
4871 4872 4873 4874 4875
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

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

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

4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919
	return 0;

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

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

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

	/* Tell mac80211 our characteristics */
	hw->flags = IEEE80211_HW_SIGNAL_DBM |
		    IEEE80211_HW_NOISE_DBM;

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

	hw->wiphy->custom_regulatory = true;

	/* Default value; 4 EDCA QOS priorities */
	hw->queues = 4;

	hw->conf.beacon_int = 100;

4920 4921 4922
	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
4923

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

4928 4929 4930 4931 4932 4933
	ret = ieee80211_register_hw(priv->hw);
	if (ret) {
		IWL_ERR(priv, "Failed to register hw (error %d)\n", ret);
		return ret;
	}
	priv->mac80211_registered = 1;
4934

4935
	return 0;
4936 4937
}

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

4947 4948 4949 4950
	/***********************
	 * 1. Allocating HW data
	 * ********************/

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

4962 4963
	if ((iwl3945_mod_params.num_of_queues > IWL39_MAX_NUM_QUEUES) ||
	     (iwl3945_mod_params.num_of_queues < IWL_MIN_NUM_QUEUES)) {
4964 4965 4966
		IWL_ERR(priv,
			"invalid queues_num, should be between %d and %d\n",
			IWL_MIN_NUM_QUEUES, IWL39_MAX_NUM_QUEUES);
4967
		err = -EINVAL;
4968
		goto out_ieee80211_free_hw;
4969 4970
	}

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

4980

4981
	IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
4982 4983
	priv->cfg = cfg;
	priv->pci_dev = pdev;
4984

S
Samuel Ortiz 已提交
4985
#ifdef CONFIG_IWLWIFI_DEBUG
4986
	priv->debug_level = iwl3945_mod_params.debug;
Z
Zhu Yi 已提交
4987 4988 4989
	atomic_set(&priv->restrict_refcnt, 0);
#endif

4990 4991 4992
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003
	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 已提交
5004
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
5005 5006 5007 5008 5009 5010 5011
		goto out_pci_disable_device;
	}

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

5013 5014 5015
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
5016 5017 5018 5019 5020 5021
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

5022
	IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
Z
Zhu Yi 已提交
5023
			(unsigned long long) pci_resource_len(pdev, 0));
5024
	IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
Z
Zhu Yi 已提交
5025

5026 5027 5028
	/* 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 已提交
5029

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

5037 5038 5039
	/***********************
	 * 4. Read EEPROM
	 * ********************/
5040

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

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

5062 5063 5064 5065
	/***********************
	 * 6. Setup priv
	 * ********************/

5066
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
5067
	if (err) {
5068
		IWL_ERR(priv, "initializing driver failed\n");
5069
		goto out_unset_hw_params;
Z
Zhu Yi 已提交
5070 5071
	}

T
Tomas Winkler 已提交
5072 5073
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
5074 5075 5076 5077 5078 5079 5080

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

	/* Initialize module parameter values here */
	/* Disable radio (SW RF KILL) via parameter when loading driver */
5081
	if (iwl3945_mod_params.disable) {
5082
		set_bit(STATUS_RF_KILL_SW, &priv->status);
5083
		IWL_DEBUG_INFO(priv, "Radio disabled.\n");
5084 5085
	}

5086 5087 5088 5089 5090 5091

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

	spin_lock_irqsave(&priv->lock, flags);
5092
	iwl_disable_interrupts(priv);
5093 5094
	spin_unlock_irqrestore(&priv->lock, flags);

5095 5096
	pci_enable_msi(priv->pci_dev);

A
Abhijeet Kolekar 已提交
5097
	err = request_irq(priv->pci_dev->irq, iwl_isr, IRQF_SHARED,
5098 5099 5100 5101 5102 5103
			  DRV_NAME, priv);
	if (err) {
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

5104
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
5105
	if (err) {
5106
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
5107
		goto out_release_irq;
5108 5109
	}

5110 5111
	iwl_set_rxon_channel(priv,
			     &priv->bands[IEEE80211_BAND_2GHZ].channels[5]);
5112 5113 5114 5115
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);

	/*********************************
5116
	 * 9. Setup and Register mac80211
5117 5118
	 * *******************************/

5119
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
5120

5121 5122 5123
	err = iwl3945_setup_mac(priv);
	if (err)
		goto  out_remove_sysfs;
5124

S
Samuel Ortiz 已提交
5125
	err = iwl_rfkill_init(priv);
5126
	if (err)
5127
		IWL_ERR(priv, "Unable to initialize RFKILL system. "
5128
				  "Ignoring error: %d\n", err);
5129 5130
	else
		iwl_rfkill_set_hw_state(priv);
5131

5132 5133 5134 5135
	/* Start monitoring the killswitch */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   2 * HZ);

Z
Zhu Yi 已提交
5136 5137
	return 0;

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

5165
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
5166
{
5167
	struct iwl_priv *priv = pci_get_drvdata(pdev);
5168
	unsigned long flags;
Z
Zhu Yi 已提交
5169 5170 5171 5172

	if (!priv)
		return;

5173
	IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
Z
Zhu Yi 已提交
5174 5175

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

5177 5178 5179 5180 5181 5182
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
5183

5184 5185 5186 5187
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
5188
	iwl_disable_interrupts(priv);
5189 5190 5191 5192
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

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

S
Samuel Ortiz 已提交
5195
	iwl_rfkill_unregister(priv);
5196 5197
	cancel_delayed_work(&priv->rfkill_poll);

C
Christoph Hellwig 已提交
5198
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
5199 5200

	if (priv->rxq.bd)
5201
		iwl_rx_queue_free(priv, &priv->rxq);
C
Christoph Hellwig 已提交
5202
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
5203

5204
	iwl3945_unset_hw_params(priv);
C
Christoph Hellwig 已提交
5205
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5206

5207 5208 5209
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
5210
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
5211 5212 5213 5214 5215
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;

5216 5217 5218
	free_irq(pdev->irq, priv);
	pci_disable_msi(pdev);

Z
Zhu Yi 已提交
5219 5220 5221 5222 5223
	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

5224
	iwl_free_channel_map(priv);
5225
	iwlcore_free_geos(priv);
W
Winkler, Tomas 已提交
5226
	kfree(priv->scan);
Z
Zhu Yi 已提交
5227 5228 5229 5230 5231 5232 5233 5234
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}

#ifdef CONFIG_PM

C
Christoph Hellwig 已提交
5235
static int iwl3945_pci_suspend(struct pci_dev *pdev, pm_message_t state)
Z
Zhu Yi 已提交
5236
{
5237
	struct iwl_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
5238

5239 5240 5241 5242 5243
	if (priv->is_open) {
		set_bit(STATUS_IN_SUSPEND, &priv->status);
		iwl3945_mac_stop(priv->hw);
		priv->is_open = 1;
	}
5244 5245
	pci_save_state(pdev);
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
5246 5247 5248 5249 5250
	pci_set_power_state(pdev, PCI_D3hot);

	return 0;
}

C
Christoph Hellwig 已提交
5251
static int iwl3945_pci_resume(struct pci_dev *pdev)
Z
Zhu Yi 已提交
5252
{
5253
	struct iwl_priv *priv = pci_get_drvdata(pdev);
5254
	int ret;
Z
Zhu Yi 已提交
5255 5256

	pci_set_power_state(pdev, PCI_D0);
5257 5258 5259
	ret = pci_enable_device(pdev);
	if (ret)
		return ret;
5260
	pci_restore_state(pdev);
Z
Zhu Yi 已提交
5261

5262 5263
	if (priv->is_open)
		iwl3945_mac_start(priv->hw);
Z
Zhu Yi 已提交
5264

5265
	clear_bit(STATUS_IN_SUSPEND, &priv->status);
Z
Zhu Yi 已提交
5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276
	return 0;
}

#endif /* CONFIG_PM */

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

C
Christoph Hellwig 已提交
5277
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
5278
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
5279 5280 5281
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
5282
#ifdef CONFIG_PM
C
Christoph Hellwig 已提交
5283 5284
	.suspend = iwl3945_pci_suspend,
	.resume = iwl3945_pci_resume,
Z
Zhu Yi 已提交
5285 5286 5287
#endif
};

C
Christoph Hellwig 已提交
5288
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
5289 5290 5291 5292 5293
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
5294 5295 5296

	ret = iwl3945_rate_control_register();
	if (ret) {
5297 5298
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
5299 5300 5301
		return ret;
	}

C
Christoph Hellwig 已提交
5302
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
5303
	if (ret) {
5304
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
5305
		goto error_register;
Z
Zhu Yi 已提交
5306 5307 5308
	}

	return ret;
5309 5310 5311 5312

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
5313 5314
}

C
Christoph Hellwig 已提交
5315
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
5316
{
C
Christoph Hellwig 已提交
5317
	pci_unregister_driver(&iwl3945_driver);
5318
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
5319 5320
}

5321
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
5322

5323
module_param_named(antenna, iwl3945_mod_params.antenna, int, 0444);
Z
Zhu Yi 已提交
5324
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
5325
module_param_named(disable, iwl3945_mod_params.disable, int, 0444);
Z
Zhu Yi 已提交
5326
MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
5327 5328 5329
module_param_named(swcrypto, iwl3945_mod_params.sw_crypto, int, 0444);
MODULE_PARM_DESC(swcrypto,
		 "using software crypto (default 1 [software])\n");
5330
module_param_named(debug, iwl3945_mod_params.debug, uint, 0444);
Z
Zhu Yi 已提交
5331
MODULE_PARM_DESC(debug, "debug output mask");
5332
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
5333 5334
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

5335
module_param_named(queues_num, iwl3945_mod_params.num_of_queues, int, 0444);
Z
Zhu Yi 已提交
5336 5337
MODULE_PARM_DESC(queues_num, "number of hw queues.");

5338 5339 5340
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 已提交
5341 5342
module_exit(iwl3945_exit);
module_init(iwl3945_init);