iwl3945-base.c 124.6 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.
 */
A
Abhijeet Kolekar 已提交
152
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, struct ieee80211_sta_ht_cap *ht_info)
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 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
/**
 * 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 */
}

273
static int iwl3945_set_ccmp_dynamic_key_info(struct iwl_priv *priv,
Z
Zhu Yi 已提交
274 275 276 277 278
				   struct ieee80211_key_conf *keyconf,
				   u8 sta_id)
{
	unsigned long flags;
	__le16 key_flags = 0;
279 280 281 282 283 284 285 286 287 288 289
	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 已提交
290 291

	spin_lock_irqsave(&priv->sta_lock, flags);
292 293 294
	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 已提交
295 296
	       keyconf->keylen);

297
	memcpy(priv->stations_39[sta_id].sta.key.key, keyconf->key,
Z
Zhu Yi 已提交
298
	       keyconf->keylen);
299

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

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

310 311 312
	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 已提交
313

314 315 316 317 318
	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 已提交
319 320
	spin_unlock_irqrestore(&priv->sta_lock, flags);

321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
	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 已提交
336 337
}

338
static int iwl3945_clear_sta_key_info(struct iwl_priv *priv, u8 sta_id)
Z
Zhu Yi 已提交
339 340 341 342
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);
343 344
	memset(&priv->stations_39[sta_id].keyinfo, 0, sizeof(struct iwl3945_hw_key));
	memset(&priv->stations_39[sta_id].sta.key, 0,
345
		sizeof(struct iwl4965_keyinfo));
346 347 348
	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 已提交
349 350
	spin_unlock_irqrestore(&priv->sta_lock, flags);

351
	IWL_DEBUG_INFO(priv, "hwcrypto: clear ucode station key info\n");
352 353
	iwl_send_add_sta(priv,
		(struct iwl_addsta_cmd *)&priv->stations_39[sta_id].sta, 0);
Z
Zhu Yi 已提交
354 355 356
	return 0;
}

A
Abhijeet Kolekar 已提交
357
static int iwl3945_set_dynamic_key(struct iwl_priv *priv,
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
			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:
375
		IWL_ERR(priv, "Unknown alg: %s alg = %d\n", __func__, keyconf->alg);
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
		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;
}

403
static void iwl3945_clear_free_frames(struct iwl_priv *priv)
Z
Zhu Yi 已提交
404 405 406
{
	struct list_head *element;

407
	IWL_DEBUG_INFO(priv, "%d frames on pre-allocated heap on clear.\n",
Z
Zhu Yi 已提交
408 409 410 411 412
		       priv->frames_count);

	while (!list_empty(&priv->free_frames)) {
		element = priv->free_frames.next;
		list_del(element);
C
Christoph Hellwig 已提交
413
		kfree(list_entry(element, struct iwl3945_frame, list));
Z
Zhu Yi 已提交
414 415 416 417
		priv->frames_count--;
	}

	if (priv->frames_count) {
418
		IWL_WARN(priv, "%d frames still in use.  Did we lose one?\n",
Z
Zhu Yi 已提交
419 420 421 422 423
			    priv->frames_count);
		priv->frames_count = 0;
	}
}

424
static struct iwl3945_frame *iwl3945_get_free_frame(struct iwl_priv *priv)
Z
Zhu Yi 已提交
425
{
C
Christoph Hellwig 已提交
426
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
427 428 429 430
	struct list_head *element;
	if (list_empty(&priv->free_frames)) {
		frame = kzalloc(sizeof(*frame), GFP_KERNEL);
		if (!frame) {
431
			IWL_ERR(priv, "Could not allocate frame!\n");
Z
Zhu Yi 已提交
432 433 434 435 436 437 438 439 440
			return NULL;
		}

		priv->frames_count++;
		return frame;
	}

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

444
static void iwl3945_free_frame(struct iwl_priv *priv, struct iwl3945_frame *frame)
Z
Zhu Yi 已提交
445 446 447 448 449
{
	memset(frame, 0, sizeof(*frame));
	list_add(&frame->list, &priv->free_frames);
}

450
unsigned int iwl3945_fill_beacon_frame(struct iwl_priv *priv,
Z
Zhu Yi 已提交
451
				struct ieee80211_hdr *hdr,
452
				int left)
Z
Zhu Yi 已提交
453 454
{

455
	if (!iwl_is_associated(priv) || !priv->ibss_beacon ||
456 457
	    ((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
	     (priv->iw_mode != NL80211_IFTYPE_AP)))
Z
Zhu Yi 已提交
458 459 460 461 462 463 464 465 466 467
		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;
}

468
static int iwl3945_send_beacon_cmd(struct iwl_priv *priv)
Z
Zhu Yi 已提交
469
{
C
Christoph Hellwig 已提交
470
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
471 472 473 474
	unsigned int frame_size;
	int rc;
	u8 rate;

C
Christoph Hellwig 已提交
475
	frame = iwl3945_get_free_frame(priv);
Z
Zhu Yi 已提交
476 477

	if (!frame) {
478
		IWL_ERR(priv, "Could not obtain free frame buffer for beacon "
Z
Zhu Yi 已提交
479 480 481 482
			  "command.\n");
		return -ENOMEM;
	}

483
	rate = iwl_rate_get_lowest_plcp(priv);
Z
Zhu Yi 已提交
484

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

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

C
Christoph Hellwig 已提交
490
	iwl3945_free_frame(priv, frame);
Z
Zhu Yi 已提交
491 492 493 494

	return rc;
}

495
static void iwl3945_unset_hw_params(struct iwl_priv *priv)
Z
Zhu Yi 已提交
496
{
497
	if (priv->shared_virt)
Z
Zhu Yi 已提交
498
		pci_free_consistent(priv->pci_dev,
C
Christoph Hellwig 已提交
499
				    sizeof(struct iwl3945_shared),
500 501
				    priv->shared_virt,
				    priv->shared_phys);
Z
Zhu Yi 已提交
502 503 504
}

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

C
Christoph Hellwig 已提交
507
static __le16 iwl3945_adjust_beacon_interval(u16 beacon_val)
Z
Zhu Yi 已提交
508 509 510 511 512 513 514 515 516 517 518 519
{
	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);
}

520
static void iwl3945_setup_rxon_timing(struct iwl_priv *priv)
Z
Zhu Yi 已提交
521 522 523 524 525 526 527 528 529 530
{
	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);
531
	priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
Z
Zhu Yi 已提交
532 533
	priv->rxon_timing.listen_interval = INTEL_CONN_LISTEN_INTERVAL;

534
	tsf = priv->timestamp;
Z
Zhu Yi 已提交
535 536 537 538

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

539
	if (priv->iw_mode == NL80211_IFTYPE_STATION) {
Z
Zhu Yi 已提交
540 541 542 543 544 545 546
		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 已提交
547
			    iwl3945_adjust_beacon_interval(
Z
Zhu Yi 已提交
548 549 550 551 552 553
				le16_to_cpu(priv->rxon_timing.beacon_interval));
		}

		priv->rxon_timing.atim_window = 0;
	} else {
		priv->rxon_timing.beacon_interval =
C
Christoph Hellwig 已提交
554
			iwl3945_adjust_beacon_interval(conf->beacon_int);
Z
Zhu Yi 已提交
555 556 557 558 559 560 561 562 563 564 565
		/* 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));

566 567
	IWL_DEBUG_ASSOC(priv,
		"beacon interval %d beacon timer %d beacon tim %d\n",
Z
Zhu Yi 已提交
568 569 570 571 572
		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));
}

573
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl_priv *priv,
574
				      struct ieee80211_tx_info *info,
575
				      struct iwl_cmd *cmd,
Z
Zhu Yi 已提交
576
				      struct sk_buff *skb_frag,
577
				      int sta_id)
Z
Zhu Yi 已提交
578
{
579
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
580
	struct iwl3945_hw_key *keyinfo =
581
	    &priv->stations_39[sta_id].keyinfo;
Z
Zhu Yi 已提交
582 583 584

	switch (keyinfo->alg) {
	case ALG_CCMP:
585 586
		tx->sec_ctl = TX_CMD_SEC_CCM;
		memcpy(tx->key, keyinfo->key, keyinfo->keylen);
587
		IWL_DEBUG_TX(priv, "tx_cmd with AES hwcrypto\n");
Z
Zhu Yi 已提交
588 589 590 591 592 593
		break;

	case ALG_TKIP:
		break;

	case ALG_WEP:
594
		tx->sec_ctl = TX_CMD_SEC_WEP |
595
		    (info->control.hw_key->hw_key_idx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT;
Z
Zhu Yi 已提交
596 597

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

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

602
		IWL_DEBUG_TX(priv, "Configuring packet for WEP encryption "
603
			     "with key %d\n", info->control.hw_key->hw_key_idx);
Z
Zhu Yi 已提交
604 605 606
		break;

	default:
T
Tomas Winkler 已提交
607
		IWL_ERR(priv, "Unknown encode alg %d\n", keyinfo->alg);
Z
Zhu Yi 已提交
608 609 610 611 612 613 614
		break;
	}
}

/*
 * handle build REPLY_TX command notification.
 */
615
static void iwl3945_build_tx_cmd_basic(struct iwl_priv *priv,
616
				  struct iwl_cmd *cmd,
617
				  struct ieee80211_tx_info *info,
618
				  struct ieee80211_hdr *hdr, u8 std_id)
Z
Zhu Yi 已提交
619
{
620 621
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
	__le32 tx_flags = tx->tx_flags;
622
	__le16 fc = hdr->frame_control;
623
	u8 rc_flags = info->control.rates[0].flags;
Z
Zhu Yi 已提交
624

625
	tx->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
626
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Z
Zhu Yi 已提交
627
		tx_flags |= TX_CMD_FLG_ACK_MSK;
628
		if (ieee80211_is_mgmt(fc))
Z
Zhu Yi 已提交
629
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
630
		if (ieee80211_is_probe_resp(fc) &&
Z
Zhu Yi 已提交
631 632 633 634 635 636 637
		    !(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;
	}

638
	tx->sta_id = std_id;
639
	if (ieee80211_has_morefrags(fc))
Z
Zhu Yi 已提交
640 641
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

642 643
	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
644
		tx->tid_tspec = qc[0] & 0xf;
Z
Zhu Yi 已提交
645
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
646
	} else {
Z
Zhu Yi 已提交
647
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
648
	}
Z
Zhu Yi 已提交
649

650
	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
Z
Zhu Yi 已提交
651 652
		tx_flags |= TX_CMD_FLG_RTS_MSK;
		tx_flags &= ~TX_CMD_FLG_CTS_MSK;
653
	} else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
Z
Zhu Yi 已提交
654 655 656 657 658 659 660 661
		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);
662 663
	if (ieee80211_is_mgmt(fc)) {
		if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
664
			tx->timeout.pm_frame_timeout = cpu_to_le16(3);
Z
Zhu Yi 已提交
665
		else
666
			tx->timeout.pm_frame_timeout = cpu_to_le16(2);
M
Mohamed Abbas 已提交
667
	} else {
668
		tx->timeout.pm_frame_timeout = 0;
669
#ifdef CONFIG_IWLWIFI_LEDS
M
Mohamed Abbas 已提交
670 671 672
		priv->rxtxpackets += le16_to_cpu(cmd->cmd.tx.len);
#endif
	}
Z
Zhu Yi 已提交
673

674 675 676
	tx->driver_txop = 0;
	tx->tx_flags = tx_flags;
	tx->next_frame_len = 0;
Z
Zhu Yi 已提交
677 678 679 680 681
}

/*
 * start REPLY_TX command process
 */
682
static int iwl3945_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
Z
Zhu Yi 已提交
683 684
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
685
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
686
	struct iwl3945_tx_cmd *tx;
687
	struct iwl_tx_queue *txq = NULL;
688
	struct iwl_queue *q = NULL;
689
	struct iwl_cmd *out_cmd = NULL;
Z
Zhu Yi 已提交
690 691
	dma_addr_t phys_addr;
	dma_addr_t txcmd_phys;
692
	int txq_id = skb_get_queue_mapping(skb);
693 694 695
	u16 len, idx, len_org, hdr_len;
	u8 id;
	u8 unicast;
Z
Zhu Yi 已提交
696
	u8 sta_id;
697
	u8 tid = 0;
Z
Zhu Yi 已提交
698
	u16 seq_number = 0;
699
	__le16 fc;
Z
Zhu Yi 已提交
700
	u8 wait_write_ptr = 0;
701
	u8 *qc = NULL;
Z
Zhu Yi 已提交
702 703 704 705
	unsigned long flags;
	int rc;

	spin_lock_irqsave(&priv->lock, flags);
706
	if (iwl_is_rfkill(priv)) {
707
		IWL_DEBUG_DROP(priv, "Dropping - RF KILL\n");
Z
Zhu Yi 已提交
708 709 710
		goto drop_unlock;
	}

711
	if ((ieee80211_get_tx_rate(priv->hw, info)->hw_value & 0xFF) == IWL_INVALID_RATE) {
712
		IWL_ERR(priv, "ERROR: No TX rate available.\n");
Z
Zhu Yi 已提交
713 714 715 716 717 718
		goto drop_unlock;
	}

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

719
	fc = hdr->frame_control;
Z
Zhu Yi 已提交
720

S
Samuel Ortiz 已提交
721
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
722
	if (ieee80211_is_auth(fc))
723
		IWL_DEBUG_TX(priv, "Sending AUTH frame\n");
724
	else if (ieee80211_is_assoc_req(fc))
725
		IWL_DEBUG_TX(priv, "Sending ASSOC frame\n");
726
	else if (ieee80211_is_reassoc_req(fc))
727
		IWL_DEBUG_TX(priv, "Sending REASSOC frame\n");
Z
Zhu Yi 已提交
728 729
#endif

730
	/* drop all data frame if we are not associated */
731
	if (ieee80211_is_data(fc) &&
732
	    (priv->iw_mode != NL80211_IFTYPE_MONITOR) && /* packet injection */
733
	    (!iwl_is_associated(priv) ||
734
	     ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id))) {
735
		IWL_DEBUG_DROP(priv, "Dropping - !iwl_is_associated\n");
Z
Zhu Yi 已提交
736 737 738 739 740
		goto drop_unlock;
	}

	spin_unlock_irqrestore(&priv->lock, flags);

741
	hdr_len = ieee80211_hdrlen(fc);
742 743

	/* Find (or create) index into station table for destination station */
744
	sta_id = iwl_get_sta_id(priv, hdr);
Z
Zhu Yi 已提交
745
	if (sta_id == IWL_INVALID_STATION) {
746
		IWL_DEBUG_DROP(priv, "Dropping - INVALID STATION: %pM\n",
J
Johannes Berg 已提交
747
			       hdr->addr1);
Z
Zhu Yi 已提交
748 749 750
		goto drop;
	}

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

753 754
	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
755
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
756
		seq_number = priv->stations_39[sta_id].tid[tid].seq_number &
Z
Zhu Yi 已提交
757 758 759
				IEEE80211_SCTL_SEQ;
		hdr->seq_ctrl = cpu_to_le16(seq_number) |
			(hdr->seq_ctrl &
760
				cpu_to_le16(IEEE80211_SCTL_FRAG));
Z
Zhu Yi 已提交
761 762
		seq_number += 0x10;
	}
763 764

	/* Descriptor for chosen Tx queue */
765
	txq = &priv->txq[txq_id];
Z
Zhu Yi 已提交
766 767 768 769
	q = &txq->q;

	spin_lock_irqsave(&priv->lock, flags);

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

772
	/* Set up driver data for this TFD */
W
Winkler, Tomas 已提交
773
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl_tx_info));
774
	txq->txb[q->write_ptr].skb[0] = skb;
775 776

	/* Init first empty entry in queue's array of Tx/cmd buffers */
777
	out_cmd = txq->cmd[idx];
778
	tx = (struct iwl3945_tx_cmd *)out_cmd->cmd.payload;
Z
Zhu Yi 已提交
779
	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
780
	memset(tx, 0, sizeof(*tx));
781 782 783 784 785 786 787

	/*
	 * 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 已提交
788 789
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
790
				INDEX_TO_SEQ(q->write_ptr)));
791 792

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

795 796 797 798 799 800 801 802 803
	/*
	 * 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.
	 */
804
	len = sizeof(struct iwl3945_tx_cmd) +
805
			sizeof(struct iwl_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
806 807 808 809 810 811 812 813 814

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

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

815 816
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
817 818 819 820 821 822 823 824
	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 已提交
825

826 827
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
828 829
	priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
						   txcmd_phys, len, 1, 0);
Z
Zhu Yi 已提交
830

831
	if (info->control.hw_key)
832
		iwl3945_build_tx_cmd_hwcrypto(priv, info, out_cmd, skb, sta_id);
Z
Zhu Yi 已提交
833

834 835
	/* 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 已提交
836 837 838 839
	len = skb->len - hdr_len;
	if (len) {
		phys_addr = pci_map_single(priv->pci_dev, skb->data + hdr_len,
					   len, PCI_DMA_TODEVICE);
840 841 842
		priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
							   phys_addr, len,
							   0, U32_PAD(len));
Z
Zhu Yi 已提交
843 844
	}

845
	/* Total # bytes to be transmitted */
Z
Zhu Yi 已提交
846
	len = (u16)skb->len;
847
	tx->len = cpu_to_le16(len);
Z
Zhu Yi 已提交
848 849

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

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

855 856
	tx->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
	tx->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;
Z
Zhu Yi 已提交
857

858
	if (!ieee80211_has_morefrags(hdr->frame_control)) {
Z
Zhu Yi 已提交
859
		txq->need_update = 1;
860
		if (qc)
861
			priv->stations_39[sta_id].tid[tid].seq_number = seq_number;
Z
Zhu Yi 已提交
862 863 864 865 866
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

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

869
	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx->hdr,
870
			   ieee80211_hdrlen(fc));
Z
Zhu Yi 已提交
871

872
	/* Tell device the write index *just past* this latest filled TFD */
T
Tomas Winkler 已提交
873
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
874
	rc = iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
875 876 877 878 879
	spin_unlock_irqrestore(&priv->lock, flags);

	if (rc)
		return rc;

880
	if ((iwl_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
881 882 883 884
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
885
			iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
886 887 888
			spin_unlock_irqrestore(&priv->lock, flags);
		}

889
		iwl_stop_queue(priv, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
890 891 892 893 894 895 896 897 898 899
	}

	return 0;

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

900
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
901 902 903 904 905 906 907 908 909 910 911 912 913 914

#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 已提交
915
static u32 iwl3945_usecs_to_beacons(u32 usec, u32 beacon_interval)
Z
Zhu Yi 已提交
916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933
{
	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 已提交
934
static __le32 iwl3945_add_beacon_time(u32 base, u32 addon, u32 beacon_interval)
Z
Zhu Yi 已提交
935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952
{
	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);
}

953
static int iwl3945_get_measurement(struct iwl_priv *priv,
Z
Zhu Yi 已提交
954 955 956
			       struct ieee80211_measurement_params *params,
			       u8 type)
{
957
	struct iwl_spectrum_cmd spectrum;
958
	struct iwl_rx_packet *res;
959
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
960 961 962 963 964 965 966 967 968
		.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);

969
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
970
		add_time =
C
Christoph Hellwig 已提交
971
		    iwl3945_usecs_to_beacons(
Z
Zhu Yi 已提交
972 973 974 975 976 977 978 979 980 981 982 983
			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));

984
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
985
		spectrum.start_time =
C
Christoph Hellwig 已提交
986
		    iwl3945_add_beacon_time(priv->last_beacon_time,
Z
Zhu Yi 已提交
987 988 989 990 991 992 993 994
				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;
995
	if (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK)
Z
Zhu Yi 已提交
996 997 998
		spectrum.flags |= RXON_FLG_BAND_24G_MSK |
		    RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK;

999
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
1000 1001 1002
	if (rc)
		return rc;

1003
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1004
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
1005
		IWL_ERR(priv, "Bad return from REPLY_RX_ON_ASSOC command\n");
Z
Zhu Yi 已提交
1006 1007 1008 1009 1010 1011 1012
		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) {
1013
			IWL_DEBUG_INFO(priv, "Replaced existing measurement: %d\n",
1014
						res->u.spectrum.id);
Z
Zhu Yi 已提交
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
			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

1032
static void iwl3945_rx_reply_alive(struct iwl_priv *priv,
1033
			       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1034
{
1035 1036
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl_alive_resp *palive;
Z
Zhu Yi 已提交
1037 1038 1039 1040
	struct delayed_work *pwork;

	palive = &pkt->u.alive_frame;

1041
	IWL_DEBUG_INFO(priv, "Alive ucode status 0x%08X revision "
Z
Zhu Yi 已提交
1042 1043 1044 1045 1046
		       "0x%01X 0x%01X\n",
		       palive->is_valid, palive->ver_type,
		       palive->ver_subtype);

	if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
1047
		IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
1048 1049
		memcpy(&priv->card_alive_init, &pkt->u.alive_frame,
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
1050 1051
		pwork = &priv->init_alive_start;
	} else {
1052
		IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
1053
		memcpy(&priv->card_alive, &pkt->u.alive_frame,
1054
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
1055
		pwork = &priv->alive_start;
C
Christoph Hellwig 已提交
1056
		iwl3945_disable_events(priv);
Z
Zhu Yi 已提交
1057 1058 1059 1060 1061 1062 1063 1064
	}

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

1068
static void iwl3945_rx_reply_add_sta(struct iwl_priv *priv,
1069
				 struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1070
{
1071
#ifdef CONFIG_IWLWIFI_DEBUG
1072
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
1073
#endif
Z
Zhu Yi 已提交
1074

1075
	IWL_DEBUG_RX(priv, "Received REPLY_ADD_STA: 0x%02X\n", pkt->u.status);
Z
Zhu Yi 已提交
1076 1077 1078
	return;
}

C
Christoph Hellwig 已提交
1079
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
1080
{
1081 1082
	struct iwl_priv *priv =
		container_of(work, struct iwl_priv, beacon_update);
Z
Zhu Yi 已提交
1083 1084 1085
	struct sk_buff *beacon;

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

	if (!beacon) {
1089
		IWL_ERR(priv, "update beacon failed\n");
Z
Zhu Yi 已提交
1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
		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 已提交
1101
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
1102 1103
}

1104
static void iwl3945_rx_beacon_notif(struct iwl_priv *priv,
1105
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1106
{
S
Samuel Ortiz 已提交
1107
#ifdef CONFIG_IWLWIFI_DEBUG
1108
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
C
Christoph Hellwig 已提交
1109
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
1110 1111
	u8 rate = beacon->beacon_notify_hdr.rate;

1112
	IWL_DEBUG_RX(priv, "beacon status %x retries %d iss %d "
Z
Zhu Yi 已提交
1113 1114 1115 1116 1117 1118 1119 1120
		"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

1121
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
1122 1123 1124 1125 1126 1127
	    (!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 */
1128
static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
1129
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
1130
{
1131
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
1132 1133 1134
	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
	unsigned long status = priv->status;

1135
	IWL_DEBUG_RF_KILL(priv, "Card state received: HW:%s SW:%s\n",
Z
Zhu Yi 已提交
1136 1137 1138
			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
			  (flags & SW_CARD_DISABLED) ? "Kill" : "On");

1139
	iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
		    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);

1153
	iwl_scan_cancel(priv);
Z
Zhu Yi 已提交
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164

	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 已提交
1165
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
1166 1167 1168 1169 1170 1171 1172
 *
 * 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.
 */
1173
static void iwl3945_setup_rx_handlers(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1174
{
C
Christoph Hellwig 已提交
1175 1176
	priv->rx_handlers[REPLY_ALIVE] = iwl3945_rx_reply_alive;
	priv->rx_handlers[REPLY_ADD_STA] = iwl3945_rx_reply_add_sta;
1177
	priv->rx_handlers[REPLY_ERROR] = iwl_rx_reply_error;
1178
	priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl_rx_csa;
A
Abhijeet Kolekar 已提交
1179
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
1180
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
A
Abhijeet Kolekar 已提交
1181
	    iwl_rx_pm_debug_statistics_notif;
C
Christoph Hellwig 已提交
1182
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
1183

1184 1185 1186 1187
	/*
	 * 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 已提交
1188
	 */
C
Christoph Hellwig 已提交
1189 1190
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
1191

1192
	iwl_setup_spectrum_handlers(priv);
1193
	iwl_setup_rx_scan_handlers(priv);
C
Christoph Hellwig 已提交
1194
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
1195

1196
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
1197
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
}

/************************** 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.
 *
1222
 * During initialization, the host sets up the READ queue position to the first
Z
Zhu Yi 已提交
1223 1224
 * INDEX position, and WRITE to the last (READ - 1 wrapped)
 *
1225
 * When the firmware places a packet in a buffer, it will advance the READ index
Z
Zhu Yi 已提交
1226 1227 1228 1229 1230 1231 1232
 * 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
1233
 *   to replenish the iwl->rxq->rx_free.
C
Christoph Hellwig 已提交
1234
 * + In iwl3945_rx_replenish (scheduled) if 'processed' != 'read' then the
Z
Zhu Yi 已提交
1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
 *   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:
 *
1247
 * iwl3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
C
Christoph Hellwig 已提交
1248
 *                            iwl3945_rx_queue_restock
1249
 * iwl3945_rx_queue_restock() Moves available buffers from rx_free into Rx
Z
Zhu Yi 已提交
1250 1251
 *                            queue, updates firmware pointers, and updates
 *                            the WRITE index.  If insufficient rx_free buffers
C
Christoph Hellwig 已提交
1252
 *                            are available, schedules iwl3945_rx_replenish
Z
Zhu Yi 已提交
1253 1254
 *
 * -- enable interrupts --
1255
 * ISR - iwl3945_rx()         Detach iwl_rx_mem_buffers from pool up to the
Z
Zhu Yi 已提交
1256 1257
 *                            READ INDEX, detaching the SKB from the pool.
 *                            Moves the packet buffer from queue to rx_used.
C
Christoph Hellwig 已提交
1258
 *                            Calls iwl3945_rx_queue_restock to refill any empty
Z
Zhu Yi 已提交
1259 1260 1261 1262 1263 1264
 *                            slots.
 * ...
 *
 */

/**
1265
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
1266
 */
1267
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1268 1269 1270 1271 1272 1273
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

/**
C
Christoph Hellwig 已提交
1274
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
1275
 *
1276
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
1277
 * and we have free pre-allocated buffers, fill the ranks as much
1278
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
1279 1280 1281 1282 1283
 *
 * 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.
 */
1284
static int iwl3945_rx_queue_restock(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1285
{
1286
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1287
	struct list_head *element;
1288
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1289 1290 1291 1292 1293
	unsigned long flags;
	int write, rc;

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
1294
	while ((iwl_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
1295
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
1296
		element = rxq->rx_free.next;
1297
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
Z
Zhu Yi 已提交
1298
		list_del(element);
1299 1300

		/* Point to Rx buffer via next RBD in circular buffer */
1301
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->real_dma_addr);
Z
Zhu Yi 已提交
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
		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);


1313 1314
	/* 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 已提交
1315 1316 1317 1318 1319
	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);
1320
		rc = iwl_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
1321 1322 1323 1324 1325 1326 1327 1328
		if (rc)
			return rc;
	}

	return 0;
}

/**
C
Christoph Hellwig 已提交
1329
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
1330 1331 1332
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
1333
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
1334
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
1335
 */
1336
static void iwl3945_rx_allocate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1337
{
1338
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1339
	struct list_head *element;
1340
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1341 1342 1343 1344
	unsigned long flags;
	spin_lock_irqsave(&rxq->lock, flags);
	while (!list_empty(&rxq->rx_used)) {
		element = rxq->rx_used.next;
1345
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
1346 1347

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
1348
		rxb->skb =
1349 1350
		    alloc_skb(priv->hw_params.rx_buf_size,
				__GFP_NOWARN | GFP_ATOMIC);
Z
Zhu Yi 已提交
1351 1352
		if (!rxb->skb) {
			if (net_ratelimit())
T
Tomas Winkler 已提交
1353
				IWL_CRIT(priv, ": Can not allocate SKB buffers\n");
Z
Zhu Yi 已提交
1354 1355 1356 1357 1358
			/* 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 已提交
1359 1360 1361 1362 1363 1364 1365 1366 1367

		/* 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 已提交
1368 1369
		priv->alloc_rxb_skb++;
		list_del(element);
1370 1371

		/* Get physical address of RB/SKB */
1372 1373 1374 1375
		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 已提交
1376 1377 1378 1379
		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);
1380 1381 1382 1383 1384
}

/*
 * this should be called while priv->lock is locked
 */
1385
static void __iwl3945_rx_replenish(void *data)
1386
{
1387
	struct iwl_priv *priv = data;
1388 1389 1390 1391 1392 1393 1394 1395

	iwl3945_rx_allocate(priv);
	iwl3945_rx_queue_restock(priv);
}


void iwl3945_rx_replenish(void *data)
{
1396
	struct iwl_priv *priv = data;
1397 1398 1399
	unsigned long flags;

	iwl3945_rx_allocate(priv);
Z
Zhu Yi 已提交
1400 1401

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
1402
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
	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 已提交
1424
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
1425
{
1426 1427
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
1428 1429
		return 60;

1430
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
1431
	 *   add 20 dB to make up for divide by 10 */
1432
	if (sig_ratio >= 100)
1433
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449

	/* 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 已提交
1450
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
{
	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;
}

/**
1485
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
1486 1487 1488 1489 1490
 *
 * Uses the priv->rx_handlers callback function array to invoke
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
1491
static void iwl3945_rx_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1492
{
1493
	struct iwl_rx_mem_buffer *rxb;
1494
	struct iwl_rx_packet *pkt;
1495
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1496 1497 1498
	u32 r, i;
	int reclaim;
	unsigned long flags;
1499
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
1500
	u32 count = 8;
Z
Zhu Yi 已提交
1501

1502 1503
	/* 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 已提交
1504
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
1505 1506
	i = rxq->read;

1507
	if (iwl_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
1508
		fill_rx = 1;
Z
Zhu Yi 已提交
1509 1510
	/* Rx interrupt, but nothing sent from uCode */
	if (i == r)
1511
		IWL_DEBUG(priv, IWL_DL_RX | IWL_DL_ISR, "r = %d, i = %d\n", r, i);
Z
Zhu Yi 已提交
1512 1513 1514 1515

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

1516
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
1517 1518 1519 1520 1521 1522
		 * then a bug has been introduced in the queue refilling
		 * routines -- catch it here */
		BUG_ON(rxb == NULL);

		rxq->queue[i] = NULL;

1523
		pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->real_dma_addr,
1524
					    priv->hw_params.rx_buf_size,
Z
Zhu Yi 已提交
1525
					    PCI_DMA_FROMDEVICE);
1526
		pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539

		/* 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 已提交
1540
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
1541
		if (priv->rx_handlers[pkt->hdr.cmd]) {
1542
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1543 1544 1545 1546 1547
				"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 */
1548
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1549 1550 1551 1552 1553 1554
				"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) {
1555
			/* Invoke any callbacks, transfer the skb to caller, and
1556
			 * fire off the (possibly) blocking iwl_send_cmd()
Z
Zhu Yi 已提交
1557 1558
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
1559
				iwl_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
1560
			else
1561
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572
		}

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

1573
		pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
1574 1575
				priv->hw_params.rx_buf_size,
				PCI_DMA_FROMDEVICE);
Z
Zhu Yi 已提交
1576 1577 1578 1579
		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;
1580 1581 1582 1583 1584 1585 1586 1587 1588 1589
		/* 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 已提交
1590 1591 1592 1593
	}

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

1597
/* call this function to flush any scheduled tasklet */
1598
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
1599
{
T
Tomas Winkler 已提交
1600
	/* wait to make sure we flush pending tasklet*/
1601 1602 1603 1604
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}

Z
Zhu Yi 已提交
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627
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))

1628
static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1629 1630 1631 1632 1633 1634 1635 1636
{
	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 已提交
1637
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1638
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1639 1640 1641
		return;
	}

1642
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
1643
	if (rc) {
1644
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
1645 1646 1647
		return;
	}

1648
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
1649 1650

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

1656
	IWL_ERR(priv, "Desc       Time       asrtPC  blink2 "
Z
Zhu Yi 已提交
1657 1658 1659 1660
		  "ilink1  nmiPC   Line\n");
	for (i = ERROR_START_OFFSET;
	     i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
	     i += ERROR_ELEM_SIZE) {
1661
		desc = iwl_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
1662
		time =
1663
		    iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
1664
		blink1 =
1665
		    iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
1666
		blink2 =
1667
		    iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
1668
		ilink1 =
1669
		    iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
1670
		ilink2 =
1671
		    iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
1672
		data1 =
1673
		    iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
1674

1675 1676 1677 1678
		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 已提交
1679 1680
	}

1681
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
1682 1683 1684

}

1685
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
1686 1687

/**
C
Christoph Hellwig 已提交
1688
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
1689
 *
1690
 * NOTE: Must be called with iwl_grab_nic_access() already obtained!
Z
Zhu Yi 已提交
1691
 */
1692
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
				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++) {
1716
		ev = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1717
		ptr += sizeof(u32);
1718
		time = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1719
		ptr += sizeof(u32);
1720 1721 1722 1723
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
		} else {
1724
			data = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1725
			ptr += sizeof(u32);
1726
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
Z
Zhu Yi 已提交
1727 1728 1729 1730
		}
	}
}

1731
static void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1732 1733 1734 1735 1736 1737 1738 1739 1740 1741
{
	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 已提交
1742
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1743
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1744 1745 1746
		return;
	}

1747
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
1748
	if (rc) {
1749
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
1750 1751 1752 1753
		return;
	}

	/* event log header */
1754 1755 1756 1757
	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 已提交
1758 1759 1760 1761 1762

	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
1763
		IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
1764
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
1765 1766 1767
		return;
	}

1768
	IWL_ERR(priv, "Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
1769 1770 1771 1772 1773
		  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 已提交
1774
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
1775 1776 1777
				    capacity - next_entry, mode);

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

1780
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
1781 1782
}

1783
static void iwl3945_error_recovery(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1784 1785 1786
{
	unsigned long flags;

1787 1788 1789
	memcpy(&priv->staging_rxon, &priv->recovery_rxon,
	       sizeof(priv->staging_rxon));
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
1790
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
1791

1792
	priv->cfg->ops->smgmt->add_station(priv, priv->bssid, 1, 0, NULL);
Z
Zhu Yi 已提交
1793 1794

	spin_lock_irqsave(&priv->lock, flags);
1795
	priv->assoc_id = le16_to_cpu(priv->staging_rxon.assoc_id);
Z
Zhu Yi 已提交
1796 1797 1798 1799
	priv->error_recovering = 0;
	spin_unlock_irqrestore(&priv->lock, flags);
}

1800
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1801 1802 1803 1804
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
S
Samuel Ortiz 已提交
1805
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1806 1807 1808 1809 1810 1811 1812 1813
	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. */
1814 1815
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
1816 1817 1818 1819

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

S
Samuel Ortiz 已提交
1823
#ifdef CONFIG_IWLWIFI_DEBUG
1824
	if (priv->debug_level & IWL_DL_ISR) {
1825
		/* just for debug */
1826
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
1827
		IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
Z
Zhu Yi 已提交
1828 1829 1830 1831 1832 1833 1834 1835
			      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 已提交
1836
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
1837
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
1838
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
1839 1840 1841 1842
		inta |= CSR_INT_BIT_FH_TX;

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

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

1848
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1849 1850 1851 1852 1853 1854 1855 1856

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

S
Samuel Ortiz 已提交
1857
#ifdef CONFIG_IWLWIFI_DEBUG
1858
	if (priv->debug_level & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
1859
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
1860
		if (inta & CSR_INT_BIT_SCD)
1861
			IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
1862
				      "the frame/frames.\n");
Z
Zhu Yi 已提交
1863 1864 1865

		/* Alive notification via Rx interrupt will do the real work */
		if (inta & CSR_INT_BIT_ALIVE)
1866
			IWL_DEBUG_ISR(priv, "Alive interrupt\n");
Z
Zhu Yi 已提交
1867 1868 1869
	}
#endif
	/* Safely ignore these bits for debug checks below */
1870
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
1871 1872 1873

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
1874 1875
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
1876
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1877 1878 1879 1880 1881
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
1882
		IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
1883
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
1884 1885 1886 1887 1888 1889
		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 已提交
1890 1891 1892 1893 1894 1895 1896 1897

		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 已提交
1898
		iwl3945_rx_handle(priv);
Z
Zhu Yi 已提交
1899 1900 1901 1902
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

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

1905 1906 1907
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
		if (!iwl_grab_nic_access(priv)) {
			iwl_write_direct32(priv, FH39_TCSR_CREDIT
1908
					     (FH39_SRVC_CHNL), 0x0);
1909
			iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
1910 1911 1912 1913 1914
		}
		handled |= CSR_INT_BIT_FH_TX;
	}

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

	if (inta & ~CSR_INI_SET_MASK) {
1918
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
Z
Zhu Yi 已提交
1919
			 inta & ~CSR_INI_SET_MASK);
1920
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
1921 1922 1923
	}

	/* Re-enable all interrupts */
1924 1925
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
1926
		iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
1927

S
Samuel Ortiz 已提交
1928
#ifdef CONFIG_IWLWIFI_DEBUG
1929
	if (priv->debug_level & (IWL_DL_ISR)) {
1930 1931 1932
		inta = iwl_read32(priv, CSR_INT);
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
1933
		IWL_DEBUG_ISR(priv, "End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
Z
Zhu Yi 已提交
1934 1935 1936 1937 1938 1939
			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
	}
#endif
	spin_unlock_irqrestore(&priv->lock, flags);
}

1940
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
1941
					 enum ieee80211_band band,
1942
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
1943
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
1944 1945
{
	const struct ieee80211_channel *channels = NULL;
1946
	const struct ieee80211_supported_band *sband;
1947
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
1948 1949 1950 1951
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
1952
	sband = iwl_get_hw_mode(priv, band);
1953
	if (!sband)
Z
Zhu Yi 已提交
1954 1955
		return 0;

1956
	channels = sband->channels;
Z
Zhu Yi 已提交
1957

S
Samuel Ortiz 已提交
1958 1959
	active_dwell = iwl_get_active_dwell_time(priv, band, n_probes);
	passive_dwell = iwl_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
1960

1961 1962 1963
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

1964
	for (i = 0, added = 0; i < sband->n_channels; i++) {
1965 1966 1967
		if (channels[i].flags & IEEE80211_CHAN_DISABLED)
			continue;

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

1970
		ch_info = iwl_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
1971
		if (!is_channel_valid(ch_info)) {
1972
			IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
1973 1974 1975 1976
				       scan_ch->channel);
			continue;
		}

1977 1978 1979 1980 1981
		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 已提交
1982
		if (!is_active || is_channel_passive(ch_info) ||
1983
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
1984
			scan_ch->type = 0;	/* passive */
1985 1986 1987
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
1988
			scan_ch->type = 1;	/* active */
1989
		}
Z
Zhu Yi 已提交
1990

1991 1992 1993 1994 1995 1996
		/* 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)
1997
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
1998 1999 2000 2001
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
2002
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
2003
		}
Z
Zhu Yi 已提交
2004

2005
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
2006 2007 2008 2009
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
2010
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
2011 2012 2013 2014
			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
2015
			 * power level:
2016
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
2017 2018 2019
			 */
		}

2020
		IWL_DEBUG_SCAN(priv, "Scanning %d [%s %d]\n",
Z
Zhu Yi 已提交
2021 2022 2023 2024 2025 2026 2027 2028 2029
			       scan_ch->channel,
			       (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
			       (scan_ch->type & 1) ?
			       active_dwell : passive_dwell);

		scan_ch++;
		added++;
	}

2030
	IWL_DEBUG_SCAN(priv, "total channels to scan %d \n", added);
Z
Zhu Yi 已提交
2031 2032 2033
	return added;
}

2034
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
2035 2036 2037 2038 2039
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
2040 2041 2042 2043
		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;
2044
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
2045
			/*
2046
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
2047
			 */
C
Christoph Hellwig 已提交
2048
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
2049
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
2050 2051 2052 2053 2054 2055 2056 2057 2058 2059
		}
	}
}

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

2060
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2061
{
2062 2063 2064 2065 2066 2067
	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 已提交
2068 2069 2070
}

/**
C
Christoph Hellwig 已提交
2071
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2072 2073
 *     looking at all data.
 */
2074
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2075 2076 2077 2078 2079 2080
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

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

2083
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2084 2085 2086
	if (rc)
		return rc;

2087
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2088
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
2089 2090 2091 2092 2093 2094

	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 */
2095
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2096
		if (val != le32_to_cpu(*image)) {
2097
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2098 2099 2100 2101 2102 2103 2104 2105 2106
				  "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;
		}
	}

2107
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2108 2109

	if (!errcnt)
2110 2111
		IWL_DEBUG_INFO(priv,
			"ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
2112 2113 2114 2115 2116 2117

	return rc;
}


/**
C
Christoph Hellwig 已提交
2118
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2119 2120 2121
 *   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.
 */
2122
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2123 2124 2125 2126 2127 2128
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

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

2131
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2132 2133 2134 2135 2136 2137 2138
	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 */
2139
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2140
			i + IWL39_RTC_INST_LOWER_BOUND);
2141
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2142 2143
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
2144
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2145 2146 2147 2148 2149 2150 2151 2152 2153 2154
				  "offset 0x%x, is 0x%x, s/b 0x%x\n",
				  i, val, *image);
#endif
			rc = -EIO;
			errcnt++;
			if (errcnt >= 3)
				break;
		}
	}

2155
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2156 2157 2158 2159 2160 2161

	return rc;
}


/**
C
Christoph Hellwig 已提交
2162
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
2163 2164
 *    and verify its contents
 */
2165
static int iwl3945_verify_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2166 2167 2168 2169 2170 2171 2172 2173
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2174
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2175
	if (rc == 0) {
2176
		IWL_DEBUG_INFO(priv, "Bootstrap uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2177 2178 2179 2180 2181 2182
		return 0;
	}

	/* Try initialize */
	image = (__le32 *)priv->ucode_init.v_addr;
	len = priv->ucode_init.len;
C
Christoph Hellwig 已提交
2183
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2184
	if (rc == 0) {
2185
		IWL_DEBUG_INFO(priv, "Initialize uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2186 2187 2188 2189 2190 2191
		return 0;
	}

	/* Try runtime/protocol */
	image = (__le32 *)priv->ucode_code.v_addr;
	len = priv->ucode_code.len;
C
Christoph Hellwig 已提交
2192
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2193
	if (rc == 0) {
2194
		IWL_DEBUG_INFO(priv, "Runtime uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2195 2196 2197
		return 0;
	}

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

2200 2201 2202
	/* 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 已提交
2203 2204
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2205
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
2206 2207 2208 2209

	return rc;
}

2210
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2211 2212
{
	/* Remove all resets to allow NIC to operate */
2213
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
2214 2215 2216
}

/**
C
Christoph Hellwig 已提交
2217
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
2218 2219 2220
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
2221
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2222
{
2223
	struct iwl_ucode *ucode;
2224
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
2225 2226
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
2227 2228 2229 2230
	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 已提交
2231 2232
	u8 *src;
	size_t len;
2233
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
2234 2235 2236

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
2237 2238 2239 2240
	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) {
2241
			IWL_ERR(priv, "%s firmware file req failed: %d\n",
2242 2243 2244 2245 2246 2247 2248
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
2249 2250 2251
				IWL_ERR(priv, "Loaded firmware %s, "
					"which is deprecated. "
					" Please use API v%u instead.\n",
2252
					  buf, api_max);
2253 2254
			IWL_DEBUG_INFO(priv, "Got firmware '%s' file "
				       "(%zd bytes) from disk\n",
2255 2256 2257
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
2258 2259
	}

2260 2261
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
2262 2263 2264

	/* Make sure that we got at least our header! */
	if (ucode_raw->size < sizeof(*ucode)) {
2265
		IWL_ERR(priv, "File size way too small!\n");
2266
		ret = -EINVAL;
Z
Zhu Yi 已提交
2267 2268 2269 2270 2271 2272
		goto err_release;
	}

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

2273
	priv->ucode_ver = le32_to_cpu(ucode->ver);
2274
	api_ver = IWL_UCODE_API(priv->ucode_ver);
Z
Zhu Yi 已提交
2275 2276 2277 2278 2279 2280
	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);

2281 2282
	/* api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
2283
	 * on the API version read from firmware header from here on forward */
2284 2285

	if (api_ver < api_min || api_ver > api_max) {
2286
		IWL_ERR(priv, "Driver unable to support your firmware API. "
2287 2288 2289 2290 2291 2292 2293
			  "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)
2294
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
2295 2296 2297 2298
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
2299 2300 2301 2302 2303 2304
	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));

2305
	IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
2306
		       priv->ucode_ver);
2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
	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 已提交
2317

2318

Z
Zhu Yi 已提交
2319 2320 2321 2322 2323
	/* 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) {

2324 2325
		IWL_DEBUG_INFO(priv, "uCode file size %zd too small\n",
			       ucode_raw->size);
2326
		ret = -EINVAL;
Z
Zhu Yi 已提交
2327 2328 2329 2330
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
2331
	if (inst_size > IWL39_MAX_INST_SIZE) {
2332
		IWL_DEBUG_INFO(priv, "uCode instr len %d too large to fit in\n",
2333 2334
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2335 2336 2337
		goto err_release;
	}

2338
	if (data_size > IWL39_MAX_DATA_SIZE) {
2339
		IWL_DEBUG_INFO(priv, "uCode data len %d too large to fit in\n",
2340 2341
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2342 2343
		goto err_release;
	}
2344
	if (init_size > IWL39_MAX_INST_SIZE) {
2345 2346
		IWL_DEBUG_INFO(priv,
				"uCode init instr len %d too large to fit in\n",
2347 2348
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2349 2350
		goto err_release;
	}
2351
	if (init_data_size > IWL39_MAX_DATA_SIZE) {
2352 2353
		IWL_DEBUG_INFO(priv,
				"uCode init data len %d too large to fit in\n",
2354 2355
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2356 2357
		goto err_release;
	}
2358
	if (boot_size > IWL39_MAX_BSM_SIZE) {
2359 2360
		IWL_DEBUG_INFO(priv,
				"uCode boot instr len %d too large to fit in\n",
2361 2362
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2363 2364 2365 2366 2367 2368 2369 2370 2371
		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;
2372
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
2373 2374

	priv->ucode_data.len = data_size;
2375
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
2376 2377

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

2380 2381 2382
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
2383 2384

	/* Initialization instructions and data */
2385 2386
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
2387
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
2388 2389

		priv->ucode_init_data.len = init_data_size;
2390
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
2391 2392 2393 2394

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

	/* Bootstrap (instructions only, no data) */
2397 2398
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
2399
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
2400

2401 2402 2403
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
2404 2405 2406 2407 2408 2409

	/* 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;
2410 2411
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode instr len %zd\n", len);
Z
Zhu Yi 已提交
2412
	memcpy(priv->ucode_code.v_addr, src, len);
2413
	IWL_DEBUG_INFO(priv, "uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
Z
Zhu Yi 已提交
2414 2415 2416
		priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
2417
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
Z
Zhu Yi 已提交
2418 2419
	src = &ucode->data[inst_size];
	len = priv->ucode_data.len;
2420 2421
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode data len %zd\n", len);
Z
Zhu Yi 已提交
2422 2423 2424 2425 2426 2427 2428
	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;
2429 2430
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init instr len %zd\n", len);
Z
Zhu Yi 已提交
2431 2432 2433 2434 2435 2436 2437
		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;
2438 2439
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init data len %zd\n", len);
Z
Zhu Yi 已提交
2440 2441 2442 2443 2444 2445
		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;
2446 2447
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) boot instr len %zd\n", len);
Z
Zhu Yi 已提交
2448 2449 2450 2451 2452 2453 2454
	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:
2455
	IWL_ERR(priv, "failed to allocate pci memory\n");
2456
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
2457
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
2458 2459 2460 2461 2462

 err_release:
	release_firmware(ucode_raw);

 error:
2463
	return ret;
Z
Zhu Yi 已提交
2464 2465 2466 2467
}


/**
C
Christoph Hellwig 已提交
2468
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
2469 2470 2471 2472 2473 2474 2475
 *
 * 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.
 */
2476
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487
{
	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);
2488
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2489 2490 2491 2492 2493 2494
	if (rc) {
		spin_unlock_irqrestore(&priv->lock, flags);
		return rc;
	}

	/* Tell bootstrap uCode where to find image to load */
2495 2496 2497
	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 已提交
2498 2499
				 priv->ucode_data.len);

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

2505
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2506 2507 2508

	spin_unlock_irqrestore(&priv->lock, flags);

2509
	IWL_DEBUG_INFO(priv, "Runtime uCode pointers are set.\n");
Z
Zhu Yi 已提交
2510 2511 2512 2513 2514

	return rc;
}

/**
C
Christoph Hellwig 已提交
2515
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2516 2517 2518 2519
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
2520
 */
2521
static void iwl3945_init_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2522 2523 2524 2525 2526
{
	/* 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 */
2527
		IWL_DEBUG_INFO(priv, "Initialize Alive failed.\n");
Z
Zhu Yi 已提交
2528 2529 2530 2531 2532 2533
		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 已提交
2534
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2535 2536
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2537
		IWL_DEBUG_INFO(priv, "Bad \"initialize\" uCode load.\n");
Z
Zhu Yi 已提交
2538 2539 2540 2541 2542 2543
		goto restart;
	}

	/* Send pointers to protocol/runtime uCode image ... init code will
	 * load and launch runtime uCode, which will send us another "Alive"
	 * notification. */
2544
	IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
C
Christoph Hellwig 已提交
2545
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
2546 2547
		/* Runtime instruction load won't happen;
		 * take it all the way back down so we can try again */
2548
		IWL_DEBUG_INFO(priv, "Couldn't set up uCode pointers.\n");
Z
Zhu Yi 已提交
2549 2550 2551 2552 2553 2554 2555 2556 2557
		goto restart;
	}
	return;

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

/**
C
Christoph Hellwig 已提交
2558
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2559
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
2560
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
2561
 */
2562
static void iwl3945_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2563 2564 2565 2566 2567
{
	int rc = 0;
	int thermal_spin = 0;
	u32 rfkill;

2568
	IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
2569 2570 2571 2572

	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 */
2573
		IWL_DEBUG_INFO(priv, "Alive failed.\n");
Z
Zhu Yi 已提交
2574 2575 2576 2577 2578 2579
		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 已提交
2580
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2581 2582
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2583
		IWL_DEBUG_INFO(priv, "Bad runtime uCode load.\n");
Z
Zhu Yi 已提交
2584 2585 2586
		goto restart;
	}

2587
	priv->cfg->ops->smgmt->clear_station_table(priv);
Z
Zhu Yi 已提交
2588

2589
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2590
	if (rc) {
2591
		IWL_WARN(priv, "Can not read RFKILL status from adapter\n");
Z
Zhu Yi 已提交
2592 2593 2594
		return;
	}

2595
	rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
2596
	IWL_DEBUG_INFO(priv, "RFKILL status: 0x%x\n", rfkill);
2597
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2598 2599 2600

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
2601
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
2602
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
2603
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
2604 2605 2606 2607 2608
			thermal_spin++;
			udelay(10);
		}

		if (thermal_spin)
2609
			IWL_DEBUG_INFO(priv, "Thermal calibration took %dus\n",
Z
Zhu Yi 已提交
2610 2611 2612 2613
				       thermal_spin * 10);
	} else
		set_bit(STATUS_RF_KILL_HW, &priv->status);

2614
	/* After the ALIVE response, we can send commands to 3945 uCode */
Z
Zhu Yi 已提交
2615 2616 2617 2618 2619
	set_bit(STATUS_ALIVE, &priv->status);

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

2620
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
2621 2622
		return;

2623
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
2624 2625 2626 2627

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

2628
	iwl_power_update_mode(priv, false);
Z
Zhu Yi 已提交
2629

2630
	if (iwl_is_associated(priv)) {
C
Christoph Hellwig 已提交
2631
		struct iwl3945_rxon_cmd *active_rxon =
2632
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
2633

2634 2635
		memcpy(&priv->staging_rxon, &priv->active_rxon,
		       sizeof(priv->staging_rxon));
Z
Zhu Yi 已提交
2636 2637 2638
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
2639
		iwl_connection_init_rx_config(priv, priv->iw_mode);
Z
Zhu Yi 已提交
2640 2641
	}

2642
	/* Configure Bluetooth device coexistence support */
2643
	iwl_send_bt_config(priv);
Z
Zhu Yi 已提交
2644 2645

	/* Configure the adapter for unassociated operation */
A
Abhijeet Kolekar 已提交
2646
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
2647 2648 2649

	iwl3945_reg_txpower_periodic(priv);

2650 2651
	iwl3945_led_register(priv);

2652
	IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
2653
	set_bit(STATUS_READY, &priv->status);
2654
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
2655 2656

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

2659 2660 2661 2662 2663
	/* 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)
2664
			iwl_mac_beacon_update(priv->hw, beacon);
2665 2666
	}

A
Abhijeet Kolekar 已提交
2667
	if (test_and_clear_bit(STATUS_MODE_PENDING, &priv->status))
2668
		iwl_set_mode(priv, priv->iw_mode);
A
Abhijeet Kolekar 已提交
2669

Z
Zhu Yi 已提交
2670 2671 2672 2673 2674 2675
	return;

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

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

2678
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2679 2680 2681 2682 2683
{
	unsigned long flags;
	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
	struct ieee80211_conf *conf = NULL;

2684
	IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
Z
Zhu Yi 已提交
2685 2686 2687 2688 2689 2690

	conf = ieee80211_get_hw_conf(priv->hw);

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

M
Mohamed Abbas 已提交
2691
	iwl3945_led_unregister(priv);
2692
	priv->cfg->ops->smgmt->clear_station_table(priv);
Z
Zhu Yi 已提交
2693 2694 2695 2696 2697 2698 2699 2700 2701 2702

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

	/* tell the device to stop sending interrupts */
2706
	spin_lock_irqsave(&priv->lock, flags);
2707
	iwl_disable_interrupts(priv);
2708 2709
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
2710 2711 2712 2713

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

C
Christoph Hellwig 已提交
2714
	/* If we have not previously called iwl3945_init() then
2715
	 * clear all bits but the RF Kill bits and return */
2716
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
2717 2718 2719 2720
		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 |
2721 2722
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
2723 2724
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2725 2726 2727
		goto exit;
	}

2728 2729
	/* ...otherwise clear out all the status bits but the RF Kill
	 * bits and continue taking the NIC down. */
Z
Zhu Yi 已提交
2730 2731 2732 2733
	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 |
2734 2735
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
2736
			test_bit(STATUS_FW_ERROR, &priv->status) <<
2737 2738 2739
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2740

2741
	priv->cfg->ops->lib->apm_ops.reset(priv);
Z
Zhu Yi 已提交
2742
	spin_lock_irqsave(&priv->lock, flags);
2743
	iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
Z
Zhu Yi 已提交
2744 2745
	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
2746 2747
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
2748 2749

	spin_lock_irqsave(&priv->lock, flags);
2750 2751
	if (!iwl_grab_nic_access(priv)) {
		iwl_write_prph(priv, APMG_CLK_DIS_REG,
Z
Zhu Yi 已提交
2752
					 APMG_CLK_VAL_DMA_CLK_RQT);
2753
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2754 2755 2756 2757 2758
	}
	spin_unlock_irqrestore(&priv->lock, flags);

	udelay(5);

2759
	if (exit_pending)
2760 2761 2762 2763
		priv->cfg->ops->lib->apm_ops.stop(priv);
	else
		priv->cfg->ops->lib->apm_ops.reset(priv);

Z
Zhu Yi 已提交
2764
 exit:
2765
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
2766 2767 2768 2769 2770 2771

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
2772
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
2773 2774
}

2775
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2776 2777
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2778
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
2779
	mutex_unlock(&priv->mutex);
2780

C
Christoph Hellwig 已提交
2781
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
2782 2783 2784 2785
}

#define MAX_HW_RESTARTS 5

2786
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2787 2788 2789 2790
{
	int rc, i;

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
2791
		IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
Z
Zhu Yi 已提交
2792 2793 2794 2795
		return -EIO;
	}

	if (test_bit(STATUS_RF_KILL_SW, &priv->status)) {
2796
		IWL_WARN(priv, "Radio disabled by SW RF kill (module "
Z
Zhu Yi 已提交
2797
			    "parameter)\n");
2798 2799 2800
		return -ENODEV;
	}

2801
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
2802
		IWL_ERR(priv, "ucode not available for device bring up\n");
2803 2804 2805
		return -EIO;
	}

2806
	/* If platform's RF_KILL switch is NOT set to KILL */
2807
	if (iwl_read32(priv, CSR_GP_CNTRL) &
2808 2809 2810 2811
				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);
2812 2813
		IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
		return -ENODEV;
Z
Zhu Yi 已提交
2814
	}
2815

2816
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
2817

C
Christoph Hellwig 已提交
2818
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
2819
	if (rc) {
2820
		IWL_ERR(priv, "Unable to int nic\n");
Z
Zhu Yi 已提交
2821 2822 2823 2824
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
2825 2826
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
2827 2828 2829
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
2830
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2831
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
2832 2833

	/* really make sure rfkill handshake bits are cleared */
2834 2835
	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 已提交
2836 2837 2838 2839 2840

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

2843 2844 2845 2846
	/* 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 已提交
2847 2848
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

2849
		priv->cfg->ops->smgmt->clear_station_table(priv);
Z
Zhu Yi 已提交
2850 2851 2852 2853

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

		if (rc) {
2857 2858
			IWL_ERR(priv,
				"Unable to set up bootstrap uCode: %d\n", rc);
Z
Zhu Yi 已提交
2859 2860 2861 2862
			continue;
		}

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

2865
		IWL_DEBUG_INFO(priv, DRV_NAME " is coming up\n");
Z
Zhu Yi 已提交
2866 2867 2868 2869 2870

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
2871
	__iwl3945_down(priv);
2872
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
2873 2874 2875

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
2876
	IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
Z
Zhu Yi 已提交
2877 2878 2879 2880 2881 2882 2883 2884 2885 2886
	return -EIO;
}


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

C
Christoph Hellwig 已提交
2887
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2888
{
2889 2890
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, init_alive_start.work);
Z
Zhu Yi 已提交
2891 2892 2893 2894 2895

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2896
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
2897 2898 2899
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
2900
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2901
{
2902 2903
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, alive_start.work);
Z
Zhu Yi 已提交
2904 2905 2906 2907 2908

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2909
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
2910 2911 2912
	mutex_unlock(&priv->mutex);
}

2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931
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 已提交
2932
#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)
C
Christoph Hellwig 已提交
2933
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
2934
{
2935 2936
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
2937
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
2938
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
2939
		.len = sizeof(struct iwl3945_scan_cmd),
Z
Zhu Yi 已提交
2940 2941 2942
		.meta.flags = CMD_SIZE_HUGE,
	};
	int rc = 0;
C
Christoph Hellwig 已提交
2943
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
2944
	struct ieee80211_conf *conf = NULL;
2945
	u8 n_probes = 2;
2946
	enum ieee80211_band band;
2947
	DECLARE_SSID_BUF(ssid);
Z
Zhu Yi 已提交
2948 2949 2950 2951 2952

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

2953
	if (!iwl_is_ready(priv)) {
2954
		IWL_WARN(priv, "request scan called when driver not ready.\n");
Z
Zhu Yi 已提交
2955 2956 2957
		goto done;
	}

T
Tomas Winkler 已提交
2958
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
2959 2960 2961 2962 2963 2964 2965
	 * 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)) {
2966 2967
		IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests  "
				"Ignoring second request.\n");
Z
Zhu Yi 已提交
2968 2969 2970 2971 2972
		rc = -EIO;
		goto done;
	}

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
2973
		IWL_DEBUG_SCAN(priv, "Aborting scan due to device shutdown\n");
Z
Zhu Yi 已提交
2974 2975 2976 2977
		goto done;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
2978 2979
		IWL_DEBUG_HC(priv,
			"Scan request while abort pending. Queuing.\n");
Z
Zhu Yi 已提交
2980 2981 2982
		goto done;
	}

2983
	if (iwl_is_rfkill(priv)) {
2984
		IWL_DEBUG_HC(priv, "Aborting scan due to RF Kill activation\n");
Z
Zhu Yi 已提交
2985 2986 2987 2988
		goto done;
	}

	if (!test_bit(STATUS_READY, &priv->status)) {
2989 2990
		IWL_DEBUG_HC(priv,
			"Scan request while uninitialized. Queuing.\n");
Z
Zhu Yi 已提交
2991 2992 2993 2994
		goto done;
	}

	if (!priv->scan_bands) {
2995
		IWL_DEBUG_HC(priv, "Aborting scan due to no requested bands\n");
Z
Zhu Yi 已提交
2996 2997 2998
		goto done;
	}

W
Winkler, Tomas 已提交
2999 3000
	if (!priv->scan) {
		priv->scan = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
3001
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
W
Winkler, Tomas 已提交
3002
		if (!priv->scan) {
Z
Zhu Yi 已提交
3003 3004 3005 3006
			rc = -ENOMEM;
			goto done;
		}
	}
W
Winkler, Tomas 已提交
3007
	scan = priv->scan;
C
Christoph Hellwig 已提交
3008
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
3009 3010 3011 3012

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

3013
	if (iwl_is_associated(priv)) {
Z
Zhu Yi 已提交
3014 3015 3016 3017 3018 3019
		u16 interval = 0;
		u32 extra;
		u32 suspend_time = 100;
		u32 scan_suspend_time = 100;
		unsigned long flags;

3020
		IWL_DEBUG_INFO(priv, "Scanning while associated...\n");
Z
Zhu Yi 已提交
3021 3022 3023 3024 3025 3026

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

		scan->suspend_time = 0;
3027
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041
		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);
3042
		IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n",
Z
Zhu Yi 已提交
3043 3044 3045 3046 3047
			       scan_suspend_time, interval);
	}

	/* We should add the ability for user to lock to PASSIVE ONLY */
	if (priv->one_direct_scan) {
3048 3049
		IWL_DEBUG_SCAN(priv, "Kicking off one direct scan for '%s'\n",
				print_ssid(ssid, priv->direct_ssid,
3050
				priv->direct_ssid_len));
Z
Zhu Yi 已提交
3051 3052 3053 3054
		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);
3055 3056
		n_probes++;
	} else
3057
		IWL_DEBUG_SCAN(priv, "Kicking off one indirect scan.\n");
Z
Zhu Yi 已提交
3058 3059 3060 3061

	/* 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;
3062
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
3063 3064 3065 3066
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

3067
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
3068 3069 3070
		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;
3071
		band = IEEE80211_BAND_2GHZ;
3072
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
3073 3074
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
		scan->good_CRC_th = IWL_GOOD_CRC_TH;
3075
		band = IEEE80211_BAND_5GHZ;
3076
	} else {
3077
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
3078 3079 3080
		goto done;
	}

S
Samuel Ortiz 已提交
3081 3082 3083 3084 3085
	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 已提交
3086 3087 3088
	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

3089
	if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
Z
Zhu Yi 已提交
3090 3091
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

3092 3093 3094 3095
	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 已提交
3096

3097
	if (scan->channel_count == 0) {
3098
		IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count);
3099 3100 3101
		goto done;
	}

Z
Zhu Yi 已提交
3102
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
3103
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
3104 3105 3106 3107
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
3108
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
3109 3110 3111 3112 3113 3114 3115 3116 3117 3118
	if (rc)
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
3119 3120 3121 3122 3123 3124 3125 3126
	/* 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);

3127
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
3128 3129 3130 3131
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
3132
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
3133
{
3134
	struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
Z
Zhu Yi 已提交
3135 3136 3137 3138 3139

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3140
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
3141
	mutex_unlock(&priv->mutex);
S
Samuel Ortiz 已提交
3142
	iwl_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
3143 3144
}

C
Christoph Hellwig 已提交
3145
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
3146
{
3147
	struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
Z
Zhu Yi 已提交
3148 3149 3150 3151

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

C
Christoph Hellwig 已提交
3152
	iwl3945_down(priv);
Z
Zhu Yi 已提交
3153 3154 3155
	queue_work(priv->workqueue, &priv->up);
}

C
Christoph Hellwig 已提交
3156
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
3157
{
3158 3159
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rx_replenish);
Z
Zhu Yi 已提交
3160 3161 3162 3163 3164

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3165
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
3166 3167 3168
	mutex_unlock(&priv->mutex);
}

3169 3170
#define IWL_DELAY_NEXT_SCAN (HZ*2)

3171
void iwl3945_post_associate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3172 3173 3174 3175
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

3176
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
3177
		IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
3178 3179 3180 3181
		return;
	}


3182
	IWL_DEBUG_ASSOC(priv, "Associated as %d to: %pM\n",
3183
			priv->assoc_id, priv->active_rxon.bssid_addr);
Z
Zhu Yi 已提交
3184 3185 3186 3187

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

A
Abhijeet Kolekar 已提交
3188
	if (!priv->vif || !priv->is_open)
3189
		return;
A
Abhijeet Kolekar 已提交
3190

3191
	iwl_scan_cancel_timeout(priv, 200);
3192

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

3195
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3196
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3197

3198
	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
3199
	iwl3945_setup_rxon_timing(priv);
3200
	rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
3201 3202
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
3203
		IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3204 3205
			    "Attempting to continue.\n");

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

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

3210
	IWL_DEBUG_ASSOC(priv, "assoc id %d beacon interval %d\n",
Z
Zhu Yi 已提交
3211 3212 3213
			priv->assoc_id, priv->beacon_int);

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3214
		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3215
	else
3216
		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3217

3218
	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3219
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
3220
			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3221
		else
3222
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3223

3224
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3225
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3226 3227 3228

	}

A
Abhijeet Kolekar 已提交
3229
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3230 3231

	switch (priv->iw_mode) {
3232
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
3233
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
3234 3235
		break;

3236
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
3237

3238
		priv->assoc_id = 1;
3239
		priv->cfg->ops->smgmt->add_station(priv, priv->bssid, 0, 0, NULL);
Z
Zhu Yi 已提交
3240
		iwl3945_sync_sta(priv, IWL_STA_ID,
3241
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
3242 3243
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
3244 3245
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3246 3247 3248 3249

		break;

	default:
3250
		 IWL_ERR(priv, "%s Should not be called in %d mode\n",
3251
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
3252 3253 3254
		break;
	}

3255
	iwl_activate_qos(priv, 0);
3256

3257 3258
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
3259 3260
}

Z
Zhu Yi 已提交
3261 3262 3263 3264 3265 3266
/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

3267 3268
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
3269
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3270
{
3271
	struct iwl_priv *priv = hw->priv;
3272
	int ret;
Z
Zhu Yi 已提交
3273

3274
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3275 3276 3277 3278

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

3279
	memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
3280 3281 3282 3283 3284 3285
	/* 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) {
3286
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
3287 3288 3289 3290
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
3291

3292
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
3293 3294

	mutex_unlock(&priv->mutex);
3295

S
Samuel Ortiz 已提交
3296
	iwl_rfkill_set_hw_state(priv);
3297

3298 3299 3300
	if (ret)
		goto out_release_irq;

3301
	IWL_DEBUG_INFO(priv, "Start UP work.\n");
3302

3303 3304 3305 3306 3307 3308 3309
	/* 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)) {
3310 3311 3312
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
3313 3314 3315 3316 3317
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

3318 3319 3320 3321
	/* ucode is running and will send rfkill notifications,
	 * no need to poll the killswitch state anymore */
	cancel_delayed_work(&priv->rfkill_poll);

3322
	priv->is_open = 1;
3323
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3324
	return 0;
3325 3326

out_release_irq:
3327
	priv->is_open = 0;
3328
	IWL_DEBUG_MAC80211(priv, "leave - failed\n");
3329
	return ret;
Z
Zhu Yi 已提交
3330 3331
}

C
Christoph Hellwig 已提交
3332
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3333
{
3334
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3335

3336
	IWL_DEBUG_MAC80211(priv, "enter\n");
3337

3338
	if (!priv->is_open) {
3339
		IWL_DEBUG_MAC80211(priv, "leave - skip\n");
3340 3341 3342
		return;
	}

Z
Zhu Yi 已提交
3343
	priv->is_open = 0;
3344

3345
	if (iwl_is_ready_rf(priv)) {
3346 3347 3348
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
3349
		mutex_lock(&priv->mutex);
3350
		iwl_scan_cancel_timeout(priv, 100);
3351 3352 3353
		mutex_unlock(&priv->mutex);
	}

3354 3355 3356
	iwl3945_down(priv);

	flush_workqueue(priv->workqueue);
3357 3358 3359 3360

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

3362
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3363 3364
}

3365
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
3366
{
3367
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3368

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

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

3374
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
3375 3376
		dev_kfree_skb_any(skb);

3377
	IWL_DEBUG_MAC80211(priv, "leave\n");
3378
	return NETDEV_TX_OK;
Z
Zhu Yi 已提交
3379 3380
}

A
Abhijeet Kolekar 已提交
3381
void iwl3945_config_ap(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3382 3383 3384
{
	int rc = 0;

3385
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
3386 3387 3388
		return;

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

		/* RXON - unassoc (to set timing command) */
3392
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3393
		iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3394 3395

		/* RXON Timing */
3396
		memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
3397
		iwl3945_setup_rxon_timing(priv);
3398 3399 3400
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
				      sizeof(priv->rxon_timing),
				      &priv->rxon_timing);
Z
Zhu Yi 已提交
3401
		if (rc)
3402
			IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3403 3404 3405
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
3406
		priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
3407
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3408
			priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3409 3410
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
3411
			priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3412 3413
				~RXON_FLG_SHORT_PREAMBLE_MSK;

3414
		if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3415 3416
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
3417
				priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3418 3419
					RXON_FLG_SHORT_SLOT_MSK;
			else
3420
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3421 3422
					~RXON_FLG_SHORT_SLOT_MSK;

3423
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3424
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3425 3426 3427
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
3428
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3429
		iwlcore_commit_rxon(priv);
3430
		priv->cfg->ops->smgmt->add_station(priv, iwl_bcast_addr, 0, 0, NULL);
3431
	}
C
Christoph Hellwig 已提交
3432
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3433 3434 3435 3436 3437 3438

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

C
Christoph Hellwig 已提交
3439
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3440 3441 3442
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
Z
Zhu Yi 已提交
3443
{
3444
	struct iwl_priv *priv = hw->priv;
3445
	const u8 *addr;
3446 3447 3448
	int ret = 0;
	u8 sta_id = IWL_INVALID_STATION;
	u8 static_key;
Z
Zhu Yi 已提交
3449

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

3452
	if (iwl3945_mod_params.sw_crypto) {
3453
		IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
Z
Zhu Yi 已提交
3454 3455 3456
		return -EOPNOTSUPP;
	}

3457
	addr = sta ? sta->addr : iwl_bcast_addr;
3458 3459 3460
	static_key = !iwl_is_associated(priv);

	if (!static_key) {
3461
		sta_id = priv->cfg->ops->smgmt->find_station(priv, addr);
3462
		if (sta_id == IWL_INVALID_STATION) {
3463
			IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
3464 3465 3466
					    addr);
			return -EINVAL;
		}
Z
Zhu Yi 已提交
3467 3468 3469
	}

	mutex_lock(&priv->mutex);
3470
	iwl_scan_cancel_timeout(priv, 100);
3471
	mutex_unlock(&priv->mutex);
3472

Z
Zhu Yi 已提交
3473
	switch (cmd) {
3474 3475 3476 3477 3478 3479
	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 已提交
3480 3481
		break;
	case DISABLE_KEY:
3482 3483 3484 3485 3486
		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 已提交
3487 3488
		break;
	default:
3489
		ret = -EINVAL;
Z
Zhu Yi 已提交
3490 3491
	}

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

3494
	return ret;
Z
Zhu Yi 已提交
3495 3496 3497 3498 3499 3500 3501 3502
}

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

S
Samuel Ortiz 已提交
3503
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
3504 3505 3506 3507 3508 3509 3510 3511

/*
 * 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.
 */
3512 3513
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
3514
{
3515
	struct iwl_priv *priv = d->driver_data;
3516 3517

	return sprintf(buf, "0x%08X\n", priv->debug_level);
Z
Zhu Yi 已提交
3518
}
3519 3520
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
3521 3522
				 const char *buf, size_t count)
{
3523
	struct iwl_priv *priv = d->driver_data;
3524 3525
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
3526

3527 3528
	ret = strict_strtoul(buf, 0, &val);
	if (ret)
T
Tomas Winkler 已提交
3529
		IWL_INFO(priv, "%s is not in hex or decimal form.\n", buf);
Z
Zhu Yi 已提交
3530
	else
3531
		priv->debug_level = val;
Z
Zhu Yi 已提交
3532 3533 3534 3535

	return strnlen(buf, count);
}

3536 3537
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
3538

S
Samuel Ortiz 已提交
3539
#endif /* CONFIG_IWLWIFI_DEBUG */
Z
Zhu Yi 已提交
3540 3541 3542 3543

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

3546
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3547 3548
		return -EAGAIN;

C
Christoph Hellwig 已提交
3549
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
3550 3551 3552 3553 3554 3555 3556
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
3557
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
3558
	return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
Z
Zhu Yi 已提交
3559 3560 3561 3562 3563 3564
}

static ssize_t store_tx_power(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
3565
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
3566 3567 3568 3569 3570
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
3571
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
3572
	else
C
Christoph Hellwig 已提交
3573
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
3574 3575 3576 3577 3578 3579 3580 3581 3582

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

3585
	return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
Z
Zhu Yi 已提交
3586 3587 3588 3589 3590 3591
}

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

	mutex_lock(&priv->mutex);
3596
	if (le32_to_cpu(priv->staging_rxon.flags) != flags) {
Z
Zhu Yi 已提交
3597
		/* Cancel any currently running scans... */
3598
		if (iwl_scan_cancel_timeout(priv, 100))
3599
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
3600
		else {
3601
			IWL_DEBUG_INFO(priv, "Committing rxon.flags = 0x%04X\n",
Z
Zhu Yi 已提交
3602
				       flags);
3603
			priv->staging_rxon.flags = cpu_to_le32(flags);
A
Abhijeet Kolekar 已提交
3604
			iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616
		}
	}
	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)
{
3617
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
3618 3619

	return sprintf(buf, "0x%04X\n",
3620
		le32_to_cpu(priv->active_rxon.filter_flags));
Z
Zhu Yi 已提交
3621 3622 3623 3624 3625 3626
}

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

	mutex_lock(&priv->mutex);
3631
	if (le32_to_cpu(priv->staging_rxon.filter_flags) != filter_flags) {
Z
Zhu Yi 已提交
3632
		/* Cancel any currently running scans... */
3633
		if (iwl_scan_cancel_timeout(priv, 100))
3634
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
3635
		else {
3636
			IWL_DEBUG_INFO(priv, "Committing rxon.filter_flags = "
Z
Zhu Yi 已提交
3637
				       "0x%04X\n", filter_flags);
3638
			priv->staging_rxon.filter_flags =
Z
Zhu Yi 已提交
3639
				cpu_to_le32(filter_flags);
A
Abhijeet Kolekar 已提交
3640
			iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3641 3642 3643 3644 3645 3646 3647 3648 3649 3650
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

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

3651
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3652 3653 3654 3655

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
3656
	struct iwl_priv *priv = dev_get_drvdata(d);
3657
	struct iwl_spectrum_notification measure_report;
Z
Zhu Yi 已提交
3658
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
3659
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688
	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)
{
3689
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3690
	struct ieee80211_measurement_params params = {
3691
		.channel = le16_to_cpu(priv->active_rxon.channel),
Z
Zhu Yi 已提交
3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712
		.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);
	}

3713
	IWL_DEBUG_INFO(priv, "Invoking measurement of type %d on "
Z
Zhu Yi 已提交
3714
		       "channel %d (for '%s')\n", type, params.channel, buf);
C
Christoph Hellwig 已提交
3715
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
3716 3717 3718 3719 3720 3721

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
3722
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
3723 3724 3725 3726 3727

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
3728
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739

	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)
{
3740
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3741 3742 3743 3744 3745 3746
	return sprintf(buf, "%d", priv->retry_rate);
}

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

3747

Z
Zhu Yi 已提交
3748 3749 3750 3751
static ssize_t store_power_level(struct device *d,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
3752
	struct iwl_priv *priv = dev_get_drvdata(d);
3753 3754 3755
	int ret;
	unsigned long mode;

Z
Zhu Yi 已提交
3756 3757 3758

	mutex_lock(&priv->mutex);

3759 3760 3761
	ret = strict_strtoul(buf, 10, &mode);
	if (ret)
		goto out;
Z
Zhu Yi 已提交
3762

3763 3764 3765 3766
	ret = iwl_power_set_user_mode(priv, mode);
	if (ret) {
		IWL_DEBUG_MAC80211(priv, "failed setting power mode.\n");
		goto out;
Z
Zhu Yi 已提交
3767
	}
3768
	ret = count;
Z
Zhu Yi 已提交
3769 3770 3771

 out:
	mutex_unlock(&priv->mutex);
3772
	return ret;
Z
Zhu Yi 已提交
3773 3774
}

3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805
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 已提交
3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826
#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)
{
3827 3828
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
3829 3830 3831 3832 3833 3834 3835
}

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
3836
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
3837
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
3838
	u32 len = 0, ofs = 0;
3839
	u8 *data = (u8 *)&priv->statistics_39;
Z
Zhu Yi 已提交
3840 3841
	int rc = 0;

3842
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3843 3844 3845
		return -EAGAIN;

	mutex_lock(&priv->mutex);
3846
	rc = iwl_send_statistics_request(priv, 0);
Z
Zhu Yi 已提交
3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873
	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)
{
3874
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3875

3876
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3877 3878
		return -EAGAIN;

3879
	return sprintf(buf, "%d\n", iwl3945_mod_params.antenna);
Z
Zhu Yi 已提交
3880 3881 3882 3883 3884 3885
}

static ssize_t store_antenna(struct device *d,
			     struct device_attribute *attr,
			     const char *buf, size_t count)
{
3886
	struct iwl_priv *priv __maybe_unused = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3887 3888 3889 3890 3891 3892
	int ant;

	if (count == 0)
		return 0;

	if (sscanf(buf, "%1i", &ant) != 1) {
3893
		IWL_DEBUG_INFO(priv, "not in hex or decimal form.\n");
Z
Zhu Yi 已提交
3894 3895 3896 3897
		return count;
	}

	if ((ant >= 0) && (ant <= 2)) {
3898
		IWL_DEBUG_INFO(priv, "Setting antenna select to %d.\n", ant);
3899
		iwl3945_mod_params.antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
3900
	} else
3901
		IWL_DEBUG_INFO(priv, "Bad antenna select value %d.\n", ant);
Z
Zhu Yi 已提交
3902 3903 3904 3905 3906 3907 3908 3909 3910 3911


	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)
{
3912
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
3913
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926
		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')
3927
		iwl3945_dump_nic_error_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940

	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')
3941
		iwl3945_dump_nic_event_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
3942 3943 3944 3945 3946 3947 3948 3949

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
3950
 * driver setup and tear down
Z
Zhu Yi 已提交
3951 3952 3953
 *
 *****************************************************************************/

3954
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3955
{
3956
	priv->workqueue = create_singlethread_workqueue(DRV_NAME);
Z
Zhu Yi 已提交
3957 3958 3959

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
3960 3961 3962
	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 已提交
3963
	INIT_WORK(&priv->rf_kill, iwl_bg_rf_kill);
C
Christoph Hellwig 已提交
3964 3965 3966
	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);
3967
	INIT_DELAYED_WORK(&priv->rfkill_poll, iwl3945_rfkill_poll);
S
Samuel Ortiz 已提交
3968 3969 3970 3971
	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 已提交
3972 3973

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
3974 3975

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

3979
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3980
{
C
Christoph Hellwig 已提交
3981
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
3982

3983
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
3984 3985 3986 3987 3988
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
3989
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
3990 3991 3992 3993 3994 3995
	&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,
3996
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3997 3998 3999 4000 4001 4002 4003 4004
	&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 已提交
4005
#ifdef CONFIG_IWLWIFI_DEBUG
4006 4007
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
4008 4009 4010
	NULL
};

C
Christoph Hellwig 已提交
4011
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
4012
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
4013
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
4014 4015
};

C
Christoph Hellwig 已提交
4016 4017 4018 4019
static struct ieee80211_ops iwl3945_hw_ops = {
	.tx = iwl3945_mac_tx,
	.start = iwl3945_mac_start,
	.stop = iwl3945_mac_stop,
4020
	.add_interface = iwl_mac_add_interface,
4021
	.remove_interface = iwl_mac_remove_interface,
4022
	.config = iwl_mac_config,
4023
	.config_interface = iwl_mac_config_interface,
4024
	.configure_filter = iwl_configure_filter,
C
Christoph Hellwig 已提交
4025
	.set_key = iwl3945_mac_set_key,
4026
	.get_tx_stats = iwl_mac_get_tx_stats,
A
Abhijeet Kolekar 已提交
4027
	.conf_tx = iwl_mac_conf_tx,
4028
	.reset_tsf = iwl_mac_reset_tsf,
4029
	.bss_info_changed = iwl_bss_info_changed,
4030
	.hw_scan = iwl_mac_hw_scan
Z
Zhu Yi 已提交
4031 4032
};

4033
static int iwl3945_init_drv(struct iwl_priv *priv)
4034 4035
{
	int ret;
4036
	struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
4037 4038 4039 4040 4041

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

	spin_lock_init(&priv->lock);
4042
	spin_lock_init(&priv->power_data.lock);
4043 4044 4045 4046 4047 4048 4049 4050
	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 */
4051
	priv->cfg->ops->smgmt->clear_station_table(priv);
4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065

	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;
4066 4067
	/* If power management is turned on, default to CAM mode */
	priv->power_mode = IWL_POWER_MODE_CAM;
4068
	priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
4069

4070 4071 4072 4073 4074 4075 4076
	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);
4077 4078 4079 4080 4081
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

4082 4083 4084 4085 4086 4087
	/* Set up txpower settings in driver for all channels */
	if (iwl3945_txpower_set_from_eeprom(priv)) {
		ret = -EIO;
		goto err_free_channel_map;
	}

4088
	ret = iwlcore_init_geos(priv);
4089 4090 4091 4092
	if (ret) {
		IWL_ERR(priv, "initializing geos failed: %d\n", ret);
		goto err_free_channel_map;
	}
4093 4094
	iwl3945_init_hw_rates(priv, priv->ieee_rates);

4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112
	return 0;

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

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

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

	/* Tell mac80211 our characteristics */
	hw->flags = IEEE80211_HW_SIGNAL_DBM |
M
Mohamed Abbas 已提交
4113 4114
		    IEEE80211_HW_NOISE_DBM |
		    IEEE80211_HW_SPECTRUM_MGMT;
4115 4116 4117 4118 4119 4120 4121

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

	hw->wiphy->custom_regulatory = true;

4122 4123
	hw->wiphy->max_scan_ssids = 1; /* WILL FIX */

4124 4125 4126 4127 4128
	/* Default value; 4 EDCA QOS priorities */
	hw->queues = 4;

	hw->conf.beacon_int = 100;

4129 4130 4131
	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
4132

4133 4134 4135
	if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&priv->bands[IEEE80211_BAND_5GHZ];
4136

4137 4138 4139 4140 4141 4142
	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;
4143

4144
	return 0;
4145 4146
}

C
Christoph Hellwig 已提交
4147
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
4148 4149
{
	int err = 0;
4150
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
4151
	struct ieee80211_hw *hw;
4152
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
4153
	struct iwl3945_eeprom *eeprom;
4154
	unsigned long flags;
Z
Zhu Yi 已提交
4155

4156 4157 4158 4159
	/***********************
	 * 1. Allocating HW data
	 * ********************/

Z
Zhu Yi 已提交
4160 4161
	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
4162
	hw = iwl_alloc_all(cfg, &iwl3945_hw_ops);
Z
Zhu Yi 已提交
4163
	if (hw == NULL) {
4164
		printk(KERN_ERR DRV_NAME "Can not allocate network device\n");
Z
Zhu Yi 已提交
4165 4166 4167 4168
		err = -ENOMEM;
		goto out;
	}
	priv = hw->priv;
4169
	SET_IEEE80211_DEV(hw, &pdev->dev);
4170

4171 4172
	if ((iwl3945_mod_params.num_of_queues > IWL39_MAX_NUM_QUEUES) ||
	     (iwl3945_mod_params.num_of_queues < IWL_MIN_NUM_QUEUES)) {
4173 4174 4175
		IWL_ERR(priv,
			"invalid queues_num, should be between %d and %d\n",
			IWL_MIN_NUM_QUEUES, IWL39_MAX_NUM_QUEUES);
4176
		err = -EINVAL;
4177
		goto out_ieee80211_free_hw;
4178 4179
	}

4180 4181 4182 4183
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
4184
	if (iwl3945_mod_params.disable_hw_scan) {
4185
		IWL_DEBUG_INFO(priv, "Disabling hw_scan\n");
4186 4187 4188
		iwl3945_hw_ops.hw_scan = NULL;
	}

4189

4190
	IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
4191 4192
	priv->cfg = cfg;
	priv->pci_dev = pdev;
4193

S
Samuel Ortiz 已提交
4194
#ifdef CONFIG_IWLWIFI_DEBUG
4195
	priv->debug_level = iwl3945_mod_params.debug;
Z
Zhu Yi 已提交
4196 4197 4198
	atomic_set(&priv->restrict_refcnt, 0);
#endif

4199 4200 4201
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
4202 4203 4204 4205 4206 4207 4208
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

4209
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
4210
	if (!err)
4211
		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
4212
	if (err) {
T
Tomas Winkler 已提交
4213
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
4214 4215 4216 4217 4218 4219 4220
		goto out_pci_disable_device;
	}

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

4222 4223 4224
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
4225 4226 4227 4228 4229 4230
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

4231
	IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
Z
Zhu Yi 已提交
4232
			(unsigned long long) pci_resource_len(pdev, 0));
4233
	IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
Z
Zhu Yi 已提交
4234

4235 4236 4237
	/* 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 已提交
4238

4239 4240
	/* amp init */
	err = priv->cfg->ops->lib->apm_ops.init(priv);
4241
	if (err < 0) {
4242
		IWL_DEBUG_INFO(priv, "Failed to init the card\n");
4243
		goto out_iounmap;
4244
	}
Z
Zhu Yi 已提交
4245

4246 4247 4248
	/***********************
	 * 4. Read EEPROM
	 * ********************/
4249

4250
	/* Read the EEPROM */
4251
	err = iwl_eeprom_init(priv);
4252
	if (err) {
4253
		IWL_ERR(priv, "Unable to init EEPROM\n");
4254
		goto out_iounmap;
4255 4256
	}
	/* MAC Address location in EEPROM same for 3945/4965 */
4257 4258
	eeprom = (struct iwl3945_eeprom *)priv->eeprom;
	memcpy(priv->mac_addr, eeprom->mac_address, ETH_ALEN);
4259
	IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->mac_addr);
4260
	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
Z
Zhu Yi 已提交
4261

4262 4263 4264
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
4265
	/* Device-specific setup */
4266
	if (iwl3945_hw_set_hw_params(priv)) {
4267
		IWL_ERR(priv, "failed to set hw settings\n");
4268
		goto out_eeprom_free;
Z
Zhu Yi 已提交
4269 4270
	}

4271 4272 4273 4274
	/***********************
	 * 6. Setup priv
	 * ********************/

4275
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
4276
	if (err) {
4277
		IWL_ERR(priv, "initializing driver failed\n");
4278
		goto out_unset_hw_params;
Z
Zhu Yi 已提交
4279 4280
	}

T
Tomas Winkler 已提交
4281 4282
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
4283 4284 4285 4286 4287 4288 4289

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

	/* Initialize module parameter values here */
	/* Disable radio (SW RF KILL) via parameter when loading driver */
4290
	if (iwl3945_mod_params.disable) {
4291
		set_bit(STATUS_RF_KILL_SW, &priv->status);
4292
		IWL_DEBUG_INFO(priv, "Radio disabled.\n");
4293 4294
	}

4295 4296 4297 4298 4299 4300

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

	spin_lock_irqsave(&priv->lock, flags);
4301
	iwl_disable_interrupts(priv);
4302 4303
	spin_unlock_irqrestore(&priv->lock, flags);

4304 4305
	pci_enable_msi(priv->pci_dev);

A
Abhijeet Kolekar 已提交
4306
	err = request_irq(priv->pci_dev->irq, iwl_isr, IRQF_SHARED,
4307 4308 4309 4310 4311 4312
			  DRV_NAME, priv);
	if (err) {
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

4313
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
4314
	if (err) {
4315
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
4316
		goto out_release_irq;
4317 4318
	}

4319 4320
	iwl_set_rxon_channel(priv,
			     &priv->bands[IEEE80211_BAND_2GHZ].channels[5]);
4321 4322 4323 4324
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);

	/*********************************
4325
	 * 9. Setup and Register mac80211
4326 4327
	 * *******************************/

4328
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
4329

4330 4331 4332
	err = iwl3945_setup_mac(priv);
	if (err)
		goto  out_remove_sysfs;
4333

S
Samuel Ortiz 已提交
4334
	err = iwl_rfkill_init(priv);
4335
	if (err)
4336
		IWL_ERR(priv, "Unable to initialize RFKILL system. "
4337
				  "Ignoring error: %d\n", err);
4338 4339
	else
		iwl_rfkill_set_hw_state(priv);
4340

4341 4342 4343 4344
	/* Start monitoring the killswitch */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   2 * HZ);

Z
Zhu Yi 已提交
4345 4346
	return 0;

4347
 out_remove_sysfs:
4348 4349
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
4350
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
4351
 out_release_irq:
4352 4353 4354
	free_irq(priv->pci_dev->irq, priv);
 out_disable_msi:
	pci_disable_msi(priv->pci_dev);
4355 4356 4357 4358 4359 4360
	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 已提交
4361 4362 4363 4364 4365 4366
 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);
4367
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
4368 4369 4370 4371 4372 4373
 out_ieee80211_free_hw:
	ieee80211_free_hw(priv->hw);
 out:
	return err;
}

4374
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
4375
{
4376
	struct iwl_priv *priv = pci_get_drvdata(pdev);
4377
	unsigned long flags;
Z
Zhu Yi 已提交
4378 4379 4380 4381

	if (!priv)
		return;

4382
	IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
Z
Zhu Yi 已提交
4383 4384

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

4386 4387 4388 4389 4390 4391
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
4392

4393 4394 4395 4396
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
4397
	iwl_disable_interrupts(priv);
4398 4399 4400 4401
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

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

S
Samuel Ortiz 已提交
4404
	iwl_rfkill_unregister(priv);
4405 4406
	cancel_delayed_work(&priv->rfkill_poll);

C
Christoph Hellwig 已提交
4407
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
4408 4409

	if (priv->rxq.bd)
4410
		iwl_rx_queue_free(priv, &priv->rxq);
C
Christoph Hellwig 已提交
4411
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
4412

4413
	iwl3945_unset_hw_params(priv);
4414
	priv->cfg->ops->smgmt->clear_station_table(priv);
Z
Zhu Yi 已提交
4415

4416 4417 4418
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
4419
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
4420 4421 4422 4423 4424
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;

4425 4426 4427
	free_irq(pdev->irq, priv);
	pci_disable_msi(pdev);

Z
Zhu Yi 已提交
4428 4429 4430 4431 4432
	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

4433
	iwl_free_channel_map(priv);
4434
	iwlcore_free_geos(priv);
W
Winkler, Tomas 已提交
4435
	kfree(priv->scan);
Z
Zhu Yi 已提交
4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}


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

C
Christoph Hellwig 已提交
4449
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
4450
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
4451 4452 4453
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
4454
#ifdef CONFIG_PM
4455 4456
	.suspend = iwl_pci_suspend,
	.resume = iwl_pci_resume,
Z
Zhu Yi 已提交
4457 4458 4459
#endif
};

C
Christoph Hellwig 已提交
4460
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
4461 4462 4463 4464 4465
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
4466 4467 4468

	ret = iwl3945_rate_control_register();
	if (ret) {
4469 4470
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
4471 4472 4473
		return ret;
	}

C
Christoph Hellwig 已提交
4474
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
4475
	if (ret) {
4476
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
4477
		goto error_register;
Z
Zhu Yi 已提交
4478 4479 4480
	}

	return ret;
4481 4482 4483 4484

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
4485 4486
}

C
Christoph Hellwig 已提交
4487
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
4488
{
C
Christoph Hellwig 已提交
4489
	pci_unregister_driver(&iwl3945_driver);
4490
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
4491 4492
}

4493
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
4494

4495
module_param_named(antenna, iwl3945_mod_params.antenna, int, 0444);
Z
Zhu Yi 已提交
4496
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
4497
module_param_named(disable, iwl3945_mod_params.disable, int, 0444);
Z
Zhu Yi 已提交
4498
MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
4499 4500 4501
module_param_named(swcrypto, iwl3945_mod_params.sw_crypto, int, 0444);
MODULE_PARM_DESC(swcrypto,
		 "using software crypto (default 1 [software])\n");
4502
module_param_named(debug, iwl3945_mod_params.debug, uint, 0444);
Z
Zhu Yi 已提交
4503
MODULE_PARM_DESC(debug, "debug output mask");
4504
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
4505 4506
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

4507
module_param_named(queues_num, iwl3945_mod_params.num_of_queues, int, 0444);
Z
Zhu Yi 已提交
4508 4509
MODULE_PARM_DESC(queues_num, "number of hw queues.");

4510 4511 4512
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 已提交
4513 4514
module_exit(iwl3945_exit);
module_init(iwl3945_init);