iwl3945-base.c 124.7 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
	memset(&priv->stations_39[sta_id].keyinfo, 0, sizeof(struct iwl_hw_key));
344
	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 =
554 555
			iwl3945_adjust_beacon_interval(
				priv->vif->bss_conf.beacon_int);
Z
Zhu Yi 已提交
556 557 558 559 560 561 562 563 564 565 566
		/* 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));

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

574
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl_priv *priv,
575
				      struct ieee80211_tx_info *info,
576
				      struct iwl_cmd *cmd,
Z
Zhu Yi 已提交
577
				      struct sk_buff *skb_frag,
578
				      int sta_id)
Z
Zhu Yi 已提交
579
{
580
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
581
	struct iwl_hw_key *keyinfo = &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);
R
Reinette Chatre 已提交
693
	u16 len, idx, len_org, hdr_len; /* TODO: len_org is not used */
694 695
	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
	    (!iwl_is_monitor_mode(priv)) && /* 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

R
Reinette Chatre 已提交
795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828

	if (info->control.hw_key)
		iwl3945_build_tx_cmd_hwcrypto(priv, info, out_cmd, skb, sta_id);

	/* TODO need this for burst mode later on */
	iwl3945_build_tx_cmd_basic(priv, out_cmd, info, hdr, sta_id);

	/* set is_hcca to 0; it probably will never be implemented */
	iwl3945_hw_build_tx_cmd_rate(priv, out_cmd, info, hdr, sta_id, 0);

	/* Total # bytes to be transmitted */
	len = (u16)skb->len;
	tx->len = cpu_to_le16(len);


	tx->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
	tx->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;

	if (!ieee80211_has_morefrags(hdr->frame_control)) {
		txq->need_update = 1;
		if (qc)
			priv->stations_39[sta_id].tid[tid].seq_number = seq_number;
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

	IWL_DEBUG_TX(priv, "sequence nr = 0X%x \n",
		     le16_to_cpu(out_cmd->hdr.sequence));
	IWL_DEBUG_TX(priv, "tx_flags = 0X%x \n", le32_to_cpu(tx->tx_flags));
	iwl_print_hex_dump(priv, IWL_DL_TX, tx, sizeof(*tx));
	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx->hdr,
			   ieee80211_hdrlen(fc));

829 830 831 832 833 834 835 836 837
	/*
	 * 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.
	 */
838
	len = sizeof(struct iwl3945_tx_cmd) +
839
			sizeof(struct iwl_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
840 841 842 843 844 845 846 847 848

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

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

849 850
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
R
Reinette Chatre 已提交
851 852 853 854
	txcmd_phys = pci_map_single(priv->pci_dev, &out_cmd->hdr,
				    len, PCI_DMA_TODEVICE);
	/* we do not map meta data ... so we can safely access address to
	 * provide to unmap command*/
855
	pci_unmap_addr_set(&out_cmd->meta, mapping, txcmd_phys);
R
Reinette Chatre 已提交
856
	pci_unmap_len_set(&out_cmd->meta, len, len);
Z
Zhu Yi 已提交
857

858 859
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
860 861
	priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
						   txcmd_phys, len, 1, 0);
Z
Zhu Yi 已提交
862 863


864 865
	/* 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 已提交
866 867 868 869
	len = skb->len - hdr_len;
	if (len) {
		phys_addr = pci_map_single(priv->pci_dev, skb->data + hdr_len,
					   len, PCI_DMA_TODEVICE);
870 871 872
		priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
							   phys_addr, len,
							   0, U32_PAD(len));
Z
Zhu Yi 已提交
873 874 875
	}


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

	if (rc)
		return rc;

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

893
		iwl_stop_queue(priv, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
894 895 896 897 898 899 900 901 902 903
	}

	return 0;

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

904
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
905 906 907 908 909 910 911 912 913 914 915 916 917 918

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

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

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

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

1003
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
1004 1005 1006
	if (rc)
		return rc;

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

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

	palive = &pkt->u.alive_frame;

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

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

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

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

1079
	IWL_DEBUG_RX(priv, "Received REPLY_ADD_STA: 0x%02X\n", pkt->u.status);
Z
Zhu Yi 已提交
1080 1081 1082
	return;
}

C
Christoph Hellwig 已提交
1083
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
1084
{
1085 1086
	struct iwl_priv *priv =
		container_of(work, struct iwl_priv, beacon_update);
Z
Zhu Yi 已提交
1087 1088 1089
	struct sk_buff *beacon;

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

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

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

1116
	IWL_DEBUG_RX(priv, "beacon status %x retries %d iss %d "
Z
Zhu Yi 已提交
1117 1118 1119 1120 1121 1122 1123 1124
		"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

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

1139
	IWL_DEBUG_RF_KILL(priv, "Card state received: HW:%s SW:%s\n",
Z
Zhu Yi 已提交
1140 1141 1142
			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
			  (flags & SW_CARD_DISABLED) ? "Kill" : "On");

1143
	iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
		    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);

1157
	iwl_scan_cancel(priv);
Z
Zhu Yi 已提交
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168

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

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

1196
	iwl_setup_spectrum_handlers(priv);
1197
	iwl_setup_rx_scan_handlers(priv);
C
Christoph Hellwig 已提交
1198
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
1199

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

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

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

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

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

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


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

	return 0;
}

/**
C
Christoph Hellwig 已提交
1333
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
1334 1335 1336
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
1337
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
1338
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
1339
 */
1340
static void iwl3945_rx_allocate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1341
{
1342
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1343
	struct list_head *element;
1344
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1345
	unsigned long flags;
A
Abhijeet Kolekar 已提交
1346 1347 1348 1349 1350 1351 1352 1353 1354

	while (1) {
		spin_lock_irqsave(&rxq->lock, flags);

		if (list_empty(&rxq->rx_used)) {
			spin_unlock_irqrestore(&rxq->lock, flags);
			return;
		}

Z
Zhu Yi 已提交
1355
		element = rxq->rx_used.next;
1356
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
A
Abhijeet Kolekar 已提交
1357 1358
		list_del(element);
		spin_unlock_irqrestore(&rxq->lock, flags);
1359 1360

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
1361
		rxb->skb =
1362
		    alloc_skb(priv->hw_params.rx_buf_size,
A
Abhijeet Kolekar 已提交
1363
				GFP_KERNEL);
Z
Zhu Yi 已提交
1364 1365
		if (!rxb->skb) {
			if (net_ratelimit())
T
Tomas Winkler 已提交
1366
				IWL_CRIT(priv, ": Can not allocate SKB buffers\n");
Z
Zhu Yi 已提交
1367 1368 1369 1370 1371
			/* 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 已提交
1372 1373 1374 1375 1376 1377 1378 1379 1380

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

1381
		/* Get physical address of RB/SKB */
1382 1383 1384 1385
		rxb->real_dma_addr = pci_map_single(priv->pci_dev,
						rxb->skb->data,
						priv->hw_params.rx_buf_size,
						PCI_DMA_FROMDEVICE);
A
Abhijeet Kolekar 已提交
1386 1387

		spin_lock_irqsave(&rxq->lock, flags);
Z
Zhu Yi 已提交
1388
		list_add_tail(&rxb->list, &rxq->rx_free);
A
Abhijeet Kolekar 已提交
1389
		priv->alloc_rxb_skb++;
Z
Zhu Yi 已提交
1390
		rxq->free_count++;
A
Abhijeet Kolekar 已提交
1391
		spin_unlock_irqrestore(&rxq->lock, flags);
Z
Zhu Yi 已提交
1392
	}
1393 1394
}

R
Reinette Chatre 已提交
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
void iwl3945_rx_queue_reset(struct iwl_priv *priv, struct iwl_rx_queue *rxq)
{
	unsigned long flags;
	int i;
	spin_lock_irqsave(&rxq->lock, flags);
	INIT_LIST_HEAD(&rxq->rx_free);
	INIT_LIST_HEAD(&rxq->rx_used);
	/* Fill the rx_used queue with _all_ of the Rx buffers */
	for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
		/* In the reset function, these buffers may have been allocated
		 * to an SKB, so we need to unmap and free potential storage */
		if (rxq->pool[i].skb != NULL) {
			pci_unmap_single(priv->pci_dev,
					 rxq->pool[i].real_dma_addr,
					 priv->hw_params.rx_buf_size,
					 PCI_DMA_FROMDEVICE);
			priv->alloc_rxb_skb--;
			dev_kfree_skb(rxq->pool[i].skb);
			rxq->pool[i].skb = NULL;
		}
		list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
	}

	/* Set us so that we have processed and used all buffers, but have
	 * not restocked the Rx queue with fresh buffers */
	rxq->read = rxq->write = 0;
	rxq->free_count = 0;
	spin_unlock_irqrestore(&rxq->lock, flags);
}

1425 1426
void iwl3945_rx_replenish(void *data)
{
1427
	struct iwl_priv *priv = data;
1428 1429 1430
	unsigned long flags;

	iwl3945_rx_allocate(priv);
Z
Zhu Yi 已提交
1431 1432

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
1433
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1434 1435 1436
	spin_unlock_irqrestore(&priv->lock, flags);
}

R
Reinette Chatre 已提交
1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463
/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
 * This free routine walks the list of POOL entries and if SKB is set to
 * non NULL it is unmapped and freed
 */
static void iwl3945_rx_queue_free(struct iwl_priv *priv, struct iwl_rx_queue *rxq)
{
	int i;
	for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
		if (rxq->pool[i].skb != NULL) {
			pci_unmap_single(priv->pci_dev,
					 rxq->pool[i].real_dma_addr,
					 priv->hw_params.rx_buf_size,
					 PCI_DMA_FROMDEVICE);
			dev_kfree_skb(rxq->pool[i].skb);
		}
	}

	pci_free_consistent(priv->pci_dev, 4 * RX_QUEUE_SIZE, rxq->bd,
			    rxq->dma_addr);
	pci_free_consistent(priv->pci_dev, sizeof(struct iwl_rb_status),
			    rxq->rb_stts, rxq->rb_stts_dma);
	rxq->bd = NULL;
	rxq->rb_stts  = NULL;
}


Z
Zhu Yi 已提交
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481
/* 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 已提交
1482
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
1483
{
1484 1485
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
1486 1487
		return 60;

1488
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
1489
	 *   add 20 dB to make up for divide by 10 */
1490
	if (sig_ratio >= 100)
1491
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507

	/* 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 已提交
1508
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
{
	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;
}

/**
1543
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
1544 1545 1546 1547 1548
 *
 * Uses the priv->rx_handlers callback function array to invoke
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
1549
static void iwl3945_rx_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1550
{
1551
	struct iwl_rx_mem_buffer *rxb;
1552
	struct iwl_rx_packet *pkt;
1553
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1554 1555 1556
	u32 r, i;
	int reclaim;
	unsigned long flags;
1557
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
1558
	u32 count = 8;
Z
Zhu Yi 已提交
1559

1560 1561
	/* 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 已提交
1562
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
1563 1564
	i = rxq->read;

1565
	if (iwl_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
1566
		fill_rx = 1;
Z
Zhu Yi 已提交
1567 1568
	/* Rx interrupt, but nothing sent from uCode */
	if (i == r)
1569
		IWL_DEBUG(priv, IWL_DL_RX | IWL_DL_ISR, "r = %d, i = %d\n", r, i);
Z
Zhu Yi 已提交
1570 1571 1572 1573

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

1574
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
1575 1576 1577 1578 1579 1580
		 * then a bug has been introduced in the queue refilling
		 * routines -- catch it here */
		BUG_ON(rxb == NULL);

		rxq->queue[i] = NULL;

R
Reinette Chatre 已提交
1581 1582 1583
		pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
				priv->hw_params.rx_buf_size,
				PCI_DMA_FROMDEVICE);
1584
		pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597

		/* 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 已提交
1598
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
1599
		if (priv->rx_handlers[pkt->hdr.cmd]) {
1600
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1601 1602 1603
				"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);
1604
			priv->isr_stats.rx_handlers[pkt->hdr.cmd]++;
Z
Zhu Yi 已提交
1605 1606
		} else {
			/* No handling needed */
1607
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1608 1609 1610 1611 1612 1613
				"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) {
1614
			/* Invoke any callbacks, transfer the skb to caller, and
1615
			 * fire off the (possibly) blocking iwl_send_cmd()
Z
Zhu Yi 已提交
1616 1617
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
1618
				iwl_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
1619
			else
1620
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
		}

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

		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;
1636 1637 1638 1639 1640 1641
		/* 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;
A
Abhijeet Kolekar 已提交
1642
				iwl3945_rx_queue_restock(priv);
1643 1644 1645
				count = 0;
			}
		}
Z
Zhu Yi 已提交
1646 1647 1648 1649
	}

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

1653
/* call this function to flush any scheduled tasklet */
1654
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
1655
{
T
Tomas Winkler 已提交
1656
	/* wait to make sure we flush pending tasklet*/
1657 1658 1659 1660
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}

Z
Zhu Yi 已提交
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683
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))

1684
static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1685 1686 1687 1688 1689 1690 1691
{
	u32 i;
	u32 desc, time, count, base, data1;
	u32 blink1, blink2, ilink1, ilink2;

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

C
Christoph Hellwig 已提交
1692
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1693
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1694 1695 1696 1697
		return;
	}


1698
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
1699 1700

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

1706
	IWL_ERR(priv, "Desc       Time       asrtPC  blink2 "
Z
Zhu Yi 已提交
1707 1708 1709 1710
		  "ilink1  nmiPC   Line\n");
	for (i = ERROR_START_OFFSET;
	     i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
	     i += ERROR_ELEM_SIZE) {
1711
		desc = iwl_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
1712
		time =
1713
		    iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
1714
		blink1 =
1715
		    iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
1716
		blink2 =
1717
		    iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
1718
		ilink1 =
1719
		    iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
1720
		ilink2 =
1721
		    iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
1722
		data1 =
1723
		    iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
1724

1725 1726 1727 1728
		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 已提交
1729 1730 1731 1732
	}

}

1733
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
1734 1735

/**
C
Christoph Hellwig 已提交
1736
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
1737 1738
 *
 */
1739
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
				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++) {
1763
		ev = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1764
		ptr += sizeof(u32);
1765
		time = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1766
		ptr += sizeof(u32);
1767 1768 1769 1770
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
		} else {
1771
			data = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1772
			ptr += sizeof(u32);
1773
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
Z
Zhu Yi 已提交
1774 1775 1776 1777
		}
	}
}

1778
static void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1779 1780 1781 1782 1783 1784 1785 1786 1787
{
	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 已提交
1788
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1789
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1790 1791 1792 1793
		return;
	}

	/* event log header */
1794 1795 1796 1797
	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 已提交
1798 1799 1800 1801 1802

	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
1803
		IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
Z
Zhu Yi 已提交
1804 1805 1806
		return;
	}

1807
	IWL_ERR(priv, "Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
1808 1809 1810 1811 1812
		  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 已提交
1813
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
1814 1815 1816
				    capacity - next_entry, mode);

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

}

1821
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1822 1823 1824 1825
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
S
Samuel Ortiz 已提交
1826
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1827 1828 1829 1830 1831 1832 1833 1834
	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. */
1835 1836
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
1837 1838 1839 1840

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

S
Samuel Ortiz 已提交
1844
#ifdef CONFIG_IWLWIFI_DEBUG
1845
	if (priv->debug_level & IWL_DL_ISR) {
1846
		/* just for debug */
1847
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
1848
		IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
Z
Zhu Yi 已提交
1849 1850 1851 1852 1853 1854 1855 1856
			      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 已提交
1857
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
1858
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
1859
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
1860 1861 1862 1863
		inta |= CSR_INT_BIT_FH_TX;

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

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

1869
		priv->isr_stats.hw++;
1870
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1871 1872 1873 1874 1875 1876 1877 1878

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

S
Samuel Ortiz 已提交
1879
#ifdef CONFIG_IWLWIFI_DEBUG
1880
	if (priv->debug_level & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
1881
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
1882
		if (inta & CSR_INT_BIT_SCD) {
1883
			IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
1884
				      "the frame/frames.\n");
1885 1886
			priv->isr_stats.sch++;
		}
Z
Zhu Yi 已提交
1887 1888

		/* Alive notification via Rx interrupt will do the real work */
1889
		if (inta & CSR_INT_BIT_ALIVE) {
1890
			IWL_DEBUG_ISR(priv, "Alive interrupt\n");
1891 1892
			priv->isr_stats.alive++;
		}
Z
Zhu Yi 已提交
1893 1894 1895
	}
#endif
	/* Safely ignore these bits for debug checks below */
1896
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
1897 1898 1899

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
1900 1901
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
1902 1903
		priv->isr_stats.sw++;
		priv->isr_stats.sw_err = inta;
1904
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1905 1906 1907 1908 1909
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
1910
		IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
1911
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
1912 1913 1914 1915 1916 1917
		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 已提交
1918

1919
		priv->isr_stats.wakeup++;
Z
Zhu Yi 已提交
1920 1921 1922 1923 1924 1925 1926
		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 已提交
1927
		iwl3945_rx_handle(priv);
1928
		priv->isr_stats.rx++;
Z
Zhu Yi 已提交
1929 1930 1931 1932
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

	if (inta & CSR_INT_BIT_FH_TX) {
1933
		IWL_DEBUG_ISR(priv, "Tx interrupt\n");
1934
		priv->isr_stats.tx++;
Z
Zhu Yi 已提交
1935

1936
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
M
Mohamed Abbas 已提交
1937 1938
		iwl_write_direct32(priv, FH39_TCSR_CREDIT
					(FH39_SRVC_CHNL), 0x0);
Z
Zhu Yi 已提交
1939 1940 1941
		handled |= CSR_INT_BIT_FH_TX;
	}

1942
	if (inta & ~handled) {
1943
		IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
1944 1945
		priv->isr_stats.unhandled++;
	}
Z
Zhu Yi 已提交
1946 1947

	if (inta & ~CSR_INI_SET_MASK) {
1948
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
Z
Zhu Yi 已提交
1949
			 inta & ~CSR_INI_SET_MASK);
1950
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
1951 1952 1953
	}

	/* Re-enable all interrupts */
1954 1955
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
1956
		iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
1957

S
Samuel Ortiz 已提交
1958
#ifdef CONFIG_IWLWIFI_DEBUG
1959
	if (priv->debug_level & (IWL_DL_ISR)) {
1960 1961 1962
		inta = iwl_read32(priv, CSR_INT);
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
1963
		IWL_DEBUG_ISR(priv, "End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
Z
Zhu Yi 已提交
1964 1965 1966 1967 1968 1969
			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
	}
#endif
	spin_unlock_irqrestore(&priv->lock, flags);
}

1970
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
1971
					 enum ieee80211_band band,
1972
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
1973
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
1974 1975
{
	const struct ieee80211_channel *channels = NULL;
1976
	const struct ieee80211_supported_band *sband;
1977
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
1978 1979 1980 1981
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
1982
	sband = iwl_get_hw_mode(priv, band);
1983
	if (!sband)
Z
Zhu Yi 已提交
1984 1985
		return 0;

1986
	channels = sband->channels;
Z
Zhu Yi 已提交
1987

S
Samuel Ortiz 已提交
1988 1989
	active_dwell = iwl_get_active_dwell_time(priv, band, n_probes);
	passive_dwell = iwl_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
1990

1991 1992 1993
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

1994
	for (i = 0, added = 0; i < sband->n_channels; i++) {
1995 1996 1997
		if (channels[i].flags & IEEE80211_CHAN_DISABLED)
			continue;

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

2000
		ch_info = iwl_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
2001
		if (!is_channel_valid(ch_info)) {
2002
			IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
2003 2004 2005 2006
				       scan_ch->channel);
			continue;
		}

2007 2008 2009 2010 2011
		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 已提交
2012
		if (!is_active || is_channel_passive(ch_info) ||
2013
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
2014
			scan_ch->type = 0;	/* passive */
2015 2016 2017
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
2018
			scan_ch->type = 1;	/* active */
2019
		}
Z
Zhu Yi 已提交
2020

2021 2022 2023 2024 2025 2026
		/* 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)
2027
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
2028 2029 2030 2031
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
2032
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
2033
		}
Z
Zhu Yi 已提交
2034

2035
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
2036 2037 2038 2039
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
2040
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
2041 2042 2043 2044
			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
2045
			 * power level:
2046
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
2047 2048 2049
			 */
		}

2050
		IWL_DEBUG_SCAN(priv, "Scanning %d [%s %d]\n",
Z
Zhu Yi 已提交
2051 2052 2053 2054 2055 2056 2057 2058 2059
			       scan_ch->channel,
			       (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
			       (scan_ch->type & 1) ?
			       active_dwell : passive_dwell);

		scan_ch++;
		added++;
	}

2060
	IWL_DEBUG_SCAN(priv, "total channels to scan %d \n", added);
Z
Zhu Yi 已提交
2061 2062 2063
	return added;
}

2064
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
2065 2066 2067 2068 2069
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
2070 2071 2072 2073
		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;
2074
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
2075
			/*
2076
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
2077
			 */
C
Christoph Hellwig 已提交
2078
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
2079
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
		}
	}
}

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

2090
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2091
{
2092 2093 2094 2095 2096 2097
	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 已提交
2098 2099 2100
}

/**
C
Christoph Hellwig 已提交
2101
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2102 2103
 *     looking at all data.
 */
2104
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2105 2106 2107 2108 2109 2110
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

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

2113
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2114
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
2115 2116 2117 2118 2119 2120

	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 */
2121
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2122
		if (val != le32_to_cpu(*image)) {
2123
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134
				  "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;
		}
	}


	if (!errcnt)
2135 2136
		IWL_DEBUG_INFO(priv,
			"ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
2137 2138 2139 2140 2141 2142

	return rc;
}


/**
C
Christoph Hellwig 已提交
2143
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2144 2145 2146
 *   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.
 */
2147
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2148 2149 2150 2151 2152 2153
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

2154
	IWL_DEBUG_INFO(priv, "ucode inst image size is %u\n", len);
Z
Zhu Yi 已提交
2155 2156 2157 2158 2159

	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 */
2160
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2161
			i + IWL39_RTC_INST_LOWER_BOUND);
2162
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2163 2164
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
2165
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180
				  "offset 0x%x, is 0x%x, s/b 0x%x\n",
				  i, val, *image);
#endif
			rc = -EIO;
			errcnt++;
			if (errcnt >= 3)
				break;
		}
	}

	return rc;
}


/**
C
Christoph Hellwig 已提交
2181
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
2182 2183
 *    and verify its contents
 */
2184
static int iwl3945_verify_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2185 2186 2187 2188 2189 2190 2191 2192
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2193
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2194
	if (rc == 0) {
2195
		IWL_DEBUG_INFO(priv, "Bootstrap uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2196 2197 2198 2199 2200 2201
		return 0;
	}

	/* Try initialize */
	image = (__le32 *)priv->ucode_init.v_addr;
	len = priv->ucode_init.len;
C
Christoph Hellwig 已提交
2202
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2203
	if (rc == 0) {
2204
		IWL_DEBUG_INFO(priv, "Initialize uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2205 2206 2207 2208 2209 2210
		return 0;
	}

	/* Try runtime/protocol */
	image = (__le32 *)priv->ucode_code.v_addr;
	len = priv->ucode_code.len;
C
Christoph Hellwig 已提交
2211
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2212
	if (rc == 0) {
2213
		IWL_DEBUG_INFO(priv, "Runtime uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2214 2215 2216
		return 0;
	}

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

2219 2220 2221
	/* 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 已提交
2222 2223
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2224
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
2225 2226 2227 2228

	return rc;
}

2229
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2230 2231
{
	/* Remove all resets to allow NIC to operate */
2232
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
2233 2234 2235
}

/**
C
Christoph Hellwig 已提交
2236
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
2237 2238 2239
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
2240
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2241
{
2242
	struct iwl_ucode *ucode;
2243
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
2244 2245
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
2246 2247 2248 2249
	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 已提交
2250 2251
	u8 *src;
	size_t len;
2252
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
2253 2254 2255

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
2256 2257 2258 2259
	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) {
2260
			IWL_ERR(priv, "%s firmware file req failed: %d\n",
2261 2262 2263 2264 2265 2266 2267
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
2268 2269 2270
				IWL_ERR(priv, "Loaded firmware %s, "
					"which is deprecated. "
					" Please use API v%u instead.\n",
2271
					  buf, api_max);
2272 2273
			IWL_DEBUG_INFO(priv, "Got firmware '%s' file "
				       "(%zd bytes) from disk\n",
2274 2275 2276
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
2277 2278
	}

2279 2280
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
2281 2282 2283

	/* Make sure that we got at least our header! */
	if (ucode_raw->size < sizeof(*ucode)) {
2284
		IWL_ERR(priv, "File size way too small!\n");
2285
		ret = -EINVAL;
Z
Zhu Yi 已提交
2286 2287 2288 2289 2290 2291
		goto err_release;
	}

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

2292
	priv->ucode_ver = le32_to_cpu(ucode->ver);
2293
	api_ver = IWL_UCODE_API(priv->ucode_ver);
Z
Zhu Yi 已提交
2294 2295 2296 2297 2298 2299
	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);

2300 2301
	/* api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
2302
	 * on the API version read from firmware header from here on forward */
2303 2304

	if (api_ver < api_min || api_ver > api_max) {
2305
		IWL_ERR(priv, "Driver unable to support your firmware API. "
2306 2307 2308 2309 2310 2311 2312
			  "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)
2313
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
2314 2315 2316 2317
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
2318 2319 2320 2321 2322 2323
	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));

2324
	IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
2325
		       priv->ucode_ver);
2326 2327 2328 2329 2330 2331 2332 2333 2334 2335
	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 已提交
2336

2337

Z
Zhu Yi 已提交
2338 2339 2340 2341 2342
	/* 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) {

2343 2344
		IWL_DEBUG_INFO(priv, "uCode file size %zd too small\n",
			       ucode_raw->size);
2345
		ret = -EINVAL;
Z
Zhu Yi 已提交
2346 2347 2348 2349
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
2350
	if (inst_size > IWL39_MAX_INST_SIZE) {
2351
		IWL_DEBUG_INFO(priv, "uCode instr len %d too large to fit in\n",
2352 2353
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2354 2355 2356
		goto err_release;
	}

2357
	if (data_size > IWL39_MAX_DATA_SIZE) {
2358
		IWL_DEBUG_INFO(priv, "uCode data len %d too large to fit in\n",
2359 2360
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2361 2362
		goto err_release;
	}
2363
	if (init_size > IWL39_MAX_INST_SIZE) {
2364 2365
		IWL_DEBUG_INFO(priv,
				"uCode init instr len %d too large to fit in\n",
2366 2367
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2368 2369
		goto err_release;
	}
2370
	if (init_data_size > IWL39_MAX_DATA_SIZE) {
2371 2372
		IWL_DEBUG_INFO(priv,
				"uCode init data len %d too large to fit in\n",
2373 2374
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2375 2376
		goto err_release;
	}
2377
	if (boot_size > IWL39_MAX_BSM_SIZE) {
2378 2379
		IWL_DEBUG_INFO(priv,
				"uCode boot instr len %d too large to fit in\n",
2380 2381
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2382 2383 2384 2385 2386 2387 2388 2389 2390
		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;
2391
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
2392 2393

	priv->ucode_data.len = data_size;
2394
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
2395 2396

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

2399 2400 2401
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
2402 2403

	/* Initialization instructions and data */
2404 2405
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
2406
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
2407 2408

		priv->ucode_init_data.len = init_data_size;
2409
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
2410 2411 2412 2413

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

	/* Bootstrap (instructions only, no data) */
2416 2417
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
2418
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
2419

2420 2421 2422
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
2423 2424 2425 2426 2427 2428

	/* 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;
2429 2430
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode instr len %zd\n", len);
Z
Zhu Yi 已提交
2431
	memcpy(priv->ucode_code.v_addr, src, len);
2432
	IWL_DEBUG_INFO(priv, "uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
Z
Zhu Yi 已提交
2433 2434 2435
		priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
2436
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
Z
Zhu Yi 已提交
2437 2438
	src = &ucode->data[inst_size];
	len = priv->ucode_data.len;
2439 2440
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode data len %zd\n", len);
Z
Zhu Yi 已提交
2441 2442 2443 2444 2445 2446 2447
	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;
2448 2449
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init instr len %zd\n", len);
Z
Zhu Yi 已提交
2450 2451 2452 2453 2454 2455 2456
		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;
2457 2458
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init data len %zd\n", len);
Z
Zhu Yi 已提交
2459 2460 2461 2462 2463 2464
		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;
2465 2466
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) boot instr len %zd\n", len);
Z
Zhu Yi 已提交
2467 2468 2469 2470 2471 2472 2473
	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:
2474
	IWL_ERR(priv, "failed to allocate pci memory\n");
2475
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
2476
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
2477 2478 2479 2480 2481

 err_release:
	release_firmware(ucode_raw);

 error:
2482
	return ret;
Z
Zhu Yi 已提交
2483 2484 2485 2486
}


/**
C
Christoph Hellwig 已提交
2487
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
2488 2489 2490 2491 2492 2493 2494
 *
 * 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.
 */
2495
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2496 2497 2498 2499 2500 2501 2502 2503 2504
{
	dma_addr_t pinst;
	dma_addr_t pdata;

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

	/* Tell bootstrap uCode where to find image to load */
2505 2506 2507
	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 已提交
2508 2509
				 priv->ucode_data.len);

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

2515
	IWL_DEBUG_INFO(priv, "Runtime uCode pointers are set.\n");
Z
Zhu Yi 已提交
2516

M
Mohamed Abbas 已提交
2517
	return 0;
Z
Zhu Yi 已提交
2518 2519 2520
}

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

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

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

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

2573
	IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
2574 2575 2576 2577

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

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

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

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

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

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

2615
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
2616 2617
		return;

2618
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
2619 2620 2621 2622

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

2623
	iwl_power_update_mode(priv, false);
Z
Zhu Yi 已提交
2624

2625
	if (iwl_is_associated(priv)) {
C
Christoph Hellwig 已提交
2626
		struct iwl3945_rxon_cmd *active_rxon =
2627
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
2628

2629 2630
		memcpy(&priv->staging_rxon, &priv->active_rxon,
		       sizeof(priv->staging_rxon));
Z
Zhu Yi 已提交
2631 2632 2633
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
2634
		iwl_connection_init_rx_config(priv, priv->iw_mode);
Z
Zhu Yi 已提交
2635 2636
	}

2637
	/* Configure Bluetooth device coexistence support */
2638
	iwl_send_bt_config(priv);
Z
Zhu Yi 已提交
2639 2640

	/* Configure the adapter for unassociated operation */
A
Abhijeet Kolekar 已提交
2641
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
2642 2643 2644

	iwl3945_reg_txpower_periodic(priv);

2645 2646
	iwl3945_led_register(priv);

2647
	IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
2648
	set_bit(STATUS_READY, &priv->status);
2649
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
2650

2651 2652 2653 2654 2655
	/* 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)
2656
			iwl_mac_beacon_update(priv->hw, beacon);
2657 2658
	}

A
Abhijeet Kolekar 已提交
2659
	if (test_and_clear_bit(STATUS_MODE_PENDING, &priv->status))
2660
		iwl_set_mode(priv, priv->iw_mode);
A
Abhijeet Kolekar 已提交
2661

Z
Zhu Yi 已提交
2662 2663 2664 2665 2666 2667
	return;

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

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

2670
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2671 2672 2673 2674 2675
{
	unsigned long flags;
	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
	struct ieee80211_conf *conf = NULL;

2676
	IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
Z
Zhu Yi 已提交
2677 2678 2679 2680 2681 2682

	conf = ieee80211_get_hw_conf(priv->hw);

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

M
Mohamed Abbas 已提交
2683
	iwl3945_led_unregister(priv);
2684
	priv->cfg->ops->smgmt->clear_station_table(priv);
Z
Zhu Yi 已提交
2685 2686 2687 2688 2689 2690 2691 2692 2693 2694

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

	/* tell the device to stop sending interrupts */
2698
	spin_lock_irqsave(&priv->lock, flags);
2699
	iwl_disable_interrupts(priv);
2700 2701
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
2702 2703 2704 2705

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

C
Christoph Hellwig 已提交
2706
	/* If we have not previously called iwl3945_init() then
2707
	 * clear all bits but the RF Kill bits and return */
2708
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
2709 2710 2711 2712
		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 |
2713 2714
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
2715 2716
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2717 2718 2719
		goto exit;
	}

2720 2721
	/* ...otherwise clear out all the status bits but the RF Kill
	 * bits and continue taking the NIC down. */
Z
Zhu Yi 已提交
2722 2723 2724 2725
	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 |
2726 2727
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
2728
			test_bit(STATUS_FW_ERROR, &priv->status) <<
2729 2730 2731
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2732

2733
	priv->cfg->ops->lib->apm_ops.reset(priv);
Z
Zhu Yi 已提交
2734
	spin_lock_irqsave(&priv->lock, flags);
2735
	iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
Z
Zhu Yi 已提交
2736 2737
	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
2738 2739
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
2740

M
Mohamed Abbas 已提交
2741 2742
	iwl_write_prph(priv, APMG_CLK_DIS_REG,
				APMG_CLK_VAL_DMA_CLK_RQT);
Z
Zhu Yi 已提交
2743 2744 2745

	udelay(5);

2746
	if (exit_pending)
2747 2748 2749 2750
		priv->cfg->ops->lib->apm_ops.stop(priv);
	else
		priv->cfg->ops->lib->apm_ops.reset(priv);

Z
Zhu Yi 已提交
2751
 exit:
2752
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
2753 2754 2755 2756 2757 2758

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
2759
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
2760 2761
}

2762
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2763 2764
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2765
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
2766
	mutex_unlock(&priv->mutex);
2767

C
Christoph Hellwig 已提交
2768
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
2769 2770 2771 2772
}

#define MAX_HW_RESTARTS 5

2773
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2774 2775 2776 2777
{
	int rc, i;

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
2778
		IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
Z
Zhu Yi 已提交
2779 2780 2781 2782
		return -EIO;
	}

	if (test_bit(STATUS_RF_KILL_SW, &priv->status)) {
2783
		IWL_WARN(priv, "Radio disabled by SW RF kill (module "
Z
Zhu Yi 已提交
2784
			    "parameter)\n");
2785 2786 2787
		return -ENODEV;
	}

2788
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
2789
		IWL_ERR(priv, "ucode not available for device bring up\n");
2790 2791 2792
		return -EIO;
	}

2793
	/* If platform's RF_KILL switch is NOT set to KILL */
2794
	if (iwl_read32(priv, CSR_GP_CNTRL) &
2795 2796 2797 2798
				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);
2799 2800
		IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
		return -ENODEV;
Z
Zhu Yi 已提交
2801
	}
2802

2803
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
2804

C
Christoph Hellwig 已提交
2805
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
2806
	if (rc) {
2807
		IWL_ERR(priv, "Unable to int nic\n");
Z
Zhu Yi 已提交
2808 2809 2810 2811
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
2812 2813
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
2814 2815 2816
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
2817
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2818
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
2819 2820

	/* really make sure rfkill handshake bits are cleared */
2821 2822
	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 已提交
2823 2824 2825 2826 2827

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

2830 2831 2832 2833
	/* 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 已提交
2834 2835
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

2836
		priv->cfg->ops->smgmt->clear_station_table(priv);
Z
Zhu Yi 已提交
2837 2838 2839 2840

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

		if (rc) {
2844 2845
			IWL_ERR(priv,
				"Unable to set up bootstrap uCode: %d\n", rc);
Z
Zhu Yi 已提交
2846 2847 2848 2849
			continue;
		}

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

2852
		IWL_DEBUG_INFO(priv, DRV_NAME " is coming up\n");
Z
Zhu Yi 已提交
2853 2854 2855 2856 2857

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
2858
	__iwl3945_down(priv);
2859
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
2860 2861 2862

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
2863
	IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
Z
Zhu Yi 已提交
2864 2865 2866 2867 2868 2869 2870 2871 2872 2873
	return -EIO;
}


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

C
Christoph Hellwig 已提交
2874
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2875
{
2876 2877
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, init_alive_start.work);
Z
Zhu Yi 已提交
2878 2879 2880 2881 2882

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2883
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
2884 2885 2886
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
2887
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2888
{
2889 2890
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, 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_alive_start(priv);
Z
Zhu Yi 已提交
2897 2898 2899
	mutex_unlock(&priv->mutex);
}

2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918
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 已提交
2919
#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)
C
Christoph Hellwig 已提交
2920
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
2921
{
2922 2923
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
2924
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
2925
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
2926
		.len = sizeof(struct iwl3945_scan_cmd),
Z
Zhu Yi 已提交
2927 2928 2929
		.meta.flags = CMD_SIZE_HUGE,
	};
	int rc = 0;
C
Christoph Hellwig 已提交
2930
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
2931
	struct ieee80211_conf *conf = NULL;
J
Johannes Berg 已提交
2932
	u8 n_probes = 0;
2933
	enum ieee80211_band band;
J
Johannes Berg 已提交
2934
	bool is_active = false;
Z
Zhu Yi 已提交
2935 2936 2937 2938 2939

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

2940
	if (!iwl_is_ready(priv)) {
2941
		IWL_WARN(priv, "request scan called when driver not ready.\n");
Z
Zhu Yi 已提交
2942 2943 2944
		goto done;
	}

T
Tomas Winkler 已提交
2945
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
2946 2947 2948 2949 2950 2951 2952
	 * 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)) {
2953 2954
		IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests  "
				"Ignoring second request.\n");
Z
Zhu Yi 已提交
2955 2956 2957 2958 2959
		rc = -EIO;
		goto done;
	}

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
2960
		IWL_DEBUG_SCAN(priv, "Aborting scan due to device shutdown\n");
Z
Zhu Yi 已提交
2961 2962 2963 2964
		goto done;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
2965 2966
		IWL_DEBUG_HC(priv,
			"Scan request while abort pending. Queuing.\n");
Z
Zhu Yi 已提交
2967 2968 2969
		goto done;
	}

2970
	if (iwl_is_rfkill(priv)) {
2971
		IWL_DEBUG_HC(priv, "Aborting scan due to RF Kill activation\n");
Z
Zhu Yi 已提交
2972 2973 2974 2975
		goto done;
	}

	if (!test_bit(STATUS_READY, &priv->status)) {
2976 2977
		IWL_DEBUG_HC(priv,
			"Scan request while uninitialized. Queuing.\n");
Z
Zhu Yi 已提交
2978 2979 2980 2981
		goto done;
	}

	if (!priv->scan_bands) {
2982
		IWL_DEBUG_HC(priv, "Aborting scan due to no requested bands\n");
Z
Zhu Yi 已提交
2983 2984 2985
		goto done;
	}

W
Winkler, Tomas 已提交
2986 2987
	if (!priv->scan) {
		priv->scan = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
2988
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
W
Winkler, Tomas 已提交
2989
		if (!priv->scan) {
Z
Zhu Yi 已提交
2990 2991 2992 2993
			rc = -ENOMEM;
			goto done;
		}
	}
W
Winkler, Tomas 已提交
2994
	scan = priv->scan;
C
Christoph Hellwig 已提交
2995
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
2996 2997 2998 2999

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

3000
	if (iwl_is_associated(priv)) {
Z
Zhu Yi 已提交
3001 3002 3003 3004 3005 3006
		u16 interval = 0;
		u32 extra;
		u32 suspend_time = 100;
		u32 scan_suspend_time = 100;
		unsigned long flags;

3007
		IWL_DEBUG_INFO(priv, "Scanning while associated...\n");
Z
Zhu Yi 已提交
3008 3009 3010 3011 3012 3013

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

		scan->suspend_time = 0;
3014
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028
		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);
3029
		IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n",
Z
Zhu Yi 已提交
3030 3031 3032
			       scan_suspend_time, interval);
	}

J
Johannes Berg 已提交
3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049
	if (priv->scan_request->n_ssids) {
		int i, p = 0;
		IWL_DEBUG_SCAN(priv, "Kicking off active scan\n");
		for (i = 0; i < priv->scan_request->n_ssids; i++) {
			/* always does wildcard anyway */
			if (!priv->scan_request->ssids[i].ssid_len)
				continue;
			scan->direct_scan[p].id = WLAN_EID_SSID;
			scan->direct_scan[p].len =
				priv->scan_request->ssids[i].ssid_len;
			memcpy(scan->direct_scan[p].ssid,
			       priv->scan_request->ssids[i].ssid,
			       priv->scan_request->ssids[i].ssid_len);
			n_probes++;
			p++;
		}
		is_active = true;
3050
	} else
J
Johannes Berg 已提交
3051
		IWL_DEBUG_SCAN(priv, "Kicking off passive scan.\n");
Z
Zhu Yi 已提交
3052 3053 3054 3055

	/* 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;
3056
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
3057 3058 3059 3060
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

3061
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
3062 3063 3064
		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;
3065
		band = IEEE80211_BAND_2GHZ;
3066
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
3067
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
3068 3069 3070 3071 3072 3073
		/*
		 * If active scaning is requested but a certain channel
		 * is marked passive, we can do active scanning if we
		 * detect transmissions.
		 */
		scan->good_CRC_th = is_active ? IWL_GOOD_CRC_TH : 0;
3074
		band = IEEE80211_BAND_5GHZ;
3075
	} else {
3076
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
3077 3078 3079
		goto done;
	}

S
Samuel Ortiz 已提交
3080
	scan->tx_cmd.len = cpu_to_le16(
J
Johannes Berg 已提交
3081 3082 3083 3084 3085
			iwl_fill_probe_req(priv,
				(struct ieee80211_mgmt *)scan->data,
				priv->scan_request->ie,
				priv->scan_request->ie_len,
				IWL_MAX_SCAN_SIZE - sizeof(*scan)));
S
Samuel Ortiz 已提交
3086

Z
Zhu Yi 已提交
3087 3088 3089
	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

3090
	if (iwl_is_monitor_mode(priv))
Z
Zhu Yi 已提交
3091 3092
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

3093
	scan->channel_count =
J
Johannes Berg 已提交
3094
		iwl3945_get_channels_for_scan(priv, band, is_active, n_probes,
3095
			(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;

J
Johannes Berg 已提交
3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162
	if (test_and_clear_bit(STATUS_FW_ERROR, &priv->status)) {
		mutex_lock(&priv->mutex);
		priv->vif = NULL;
		priv->is_open = 0;
		mutex_unlock(&priv->mutex);
		iwl3945_down(priv);
		ieee80211_restart_hw(priv->hw);
	} else {
		iwl3945_down(priv);
		queue_work(priv->workqueue, &priv->up);
	}
Z
Zhu Yi 已提交
3163 3164
}

C
Christoph Hellwig 已提交
3165
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
3166
{
3167 3168
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rx_replenish);
Z
Zhu Yi 已提交
3169 3170 3171 3172 3173

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3174
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
3175 3176 3177
	mutex_unlock(&priv->mutex);
}

3178 3179
#define IWL_DELAY_NEXT_SCAN (HZ*2)

3180
void iwl3945_post_associate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3181 3182 3183 3184
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

3185
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
3186
		IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
3187 3188 3189 3190
		return;
	}


3191
	IWL_DEBUG_ASSOC(priv, "Associated as %d to: %pM\n",
3192
			priv->assoc_id, priv->active_rxon.bssid_addr);
Z
Zhu Yi 已提交
3193 3194 3195 3196

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

A
Abhijeet Kolekar 已提交
3197
	if (!priv->vif || !priv->is_open)
3198
		return;
A
Abhijeet Kolekar 已提交
3199

3200
	iwl_scan_cancel_timeout(priv, 200);
3201

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

3204
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3205
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3206

3207
	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
3208
	iwl3945_setup_rxon_timing(priv);
3209
	rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
3210 3211
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
3212
		IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3213 3214
			    "Attempting to continue.\n");

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

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

3219
	IWL_DEBUG_ASSOC(priv, "assoc id %d beacon interval %d\n",
Z
Zhu Yi 已提交
3220 3221 3222
			priv->assoc_id, priv->beacon_int);

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3223
		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3224
	else
3225
		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3226

3227
	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3228
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
3229
			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3230
		else
3231
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3232

3233
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3234
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3235 3236 3237

	}

A
Abhijeet Kolekar 已提交
3238
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3239 3240

	switch (priv->iw_mode) {
3241
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
3242
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
3243 3244
		break;

3245
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
3246

3247
		priv->assoc_id = 1;
3248
		priv->cfg->ops->smgmt->add_station(priv, priv->bssid, 0, 0, NULL);
Z
Zhu Yi 已提交
3249
		iwl3945_sync_sta(priv, IWL_STA_ID,
3250
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
3251 3252
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
3253 3254
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3255 3256 3257 3258

		break;

	default:
3259
		 IWL_ERR(priv, "%s Should not be called in %d mode\n",
3260
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
3261 3262 3263
		break;
	}

3264
	iwl_activate_qos(priv, 0);
3265

3266 3267
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
3268 3269
}

Z
Zhu Yi 已提交
3270 3271 3272 3273 3274 3275
/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

3276 3277
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
3278
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3279
{
3280
	struct iwl_priv *priv = hw->priv;
3281
	int ret;
Z
Zhu Yi 已提交
3282

3283
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3284 3285 3286 3287

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

3288
	memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
3289 3290 3291 3292 3293 3294
	/* 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) {
3295
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
3296 3297 3298 3299
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
3300

3301
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
3302 3303

	mutex_unlock(&priv->mutex);
3304

S
Samuel Ortiz 已提交
3305
	iwl_rfkill_set_hw_state(priv);
3306

3307 3308 3309
	if (ret)
		goto out_release_irq;

3310
	IWL_DEBUG_INFO(priv, "Start UP work.\n");
3311

3312 3313 3314 3315 3316 3317 3318
	/* 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)) {
3319 3320 3321
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
3322 3323 3324 3325 3326
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

3327 3328 3329 3330
	/* ucode is running and will send rfkill notifications,
	 * no need to poll the killswitch state anymore */
	cancel_delayed_work(&priv->rfkill_poll);

3331
	priv->is_open = 1;
3332
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3333
	return 0;
3334 3335

out_release_irq:
3336
	priv->is_open = 0;
3337
	IWL_DEBUG_MAC80211(priv, "leave - failed\n");
3338
	return ret;
Z
Zhu Yi 已提交
3339 3340
}

C
Christoph Hellwig 已提交
3341
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3342
{
3343
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3344

3345
	IWL_DEBUG_MAC80211(priv, "enter\n");
3346

3347
	if (!priv->is_open) {
3348
		IWL_DEBUG_MAC80211(priv, "leave - skip\n");
3349 3350 3351
		return;
	}

Z
Zhu Yi 已提交
3352
	priv->is_open = 0;
3353

3354
	if (iwl_is_ready_rf(priv)) {
3355 3356 3357
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
3358
		mutex_lock(&priv->mutex);
3359
		iwl_scan_cancel_timeout(priv, 100);
3360 3361 3362
		mutex_unlock(&priv->mutex);
	}

3363 3364 3365
	iwl3945_down(priv);

	flush_workqueue(priv->workqueue);
3366 3367 3368 3369

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

3371
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3372 3373
}

3374
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
3375
{
3376
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3377

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

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

3383
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
3384 3385
		dev_kfree_skb_any(skb);

3386
	IWL_DEBUG_MAC80211(priv, "leave\n");
3387
	return NETDEV_TX_OK;
Z
Zhu Yi 已提交
3388 3389
}

A
Abhijeet Kolekar 已提交
3390
void iwl3945_config_ap(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3391 3392 3393
{
	int rc = 0;

3394
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
3395 3396 3397
		return;

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

		/* RXON - unassoc (to set timing command) */
3401
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3402
		iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3403 3404

		/* RXON Timing */
3405
		memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
3406
		iwl3945_setup_rxon_timing(priv);
3407 3408 3409
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
				      sizeof(priv->rxon_timing),
				      &priv->rxon_timing);
Z
Zhu Yi 已提交
3410
		if (rc)
3411
			IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3412 3413 3414
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
3415
		priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
3416
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3417
			priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3418 3419
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
3420
			priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3421 3422
				~RXON_FLG_SHORT_PREAMBLE_MSK;

3423
		if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3424 3425
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
3426
				priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3427 3428
					RXON_FLG_SHORT_SLOT_MSK;
			else
3429
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3430 3431
					~RXON_FLG_SHORT_SLOT_MSK;

3432
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3433
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3434 3435 3436
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
3437
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3438
		iwlcore_commit_rxon(priv);
3439
		priv->cfg->ops->smgmt->add_station(priv, iwl_bcast_addr, 0, 0, NULL);
3440
	}
C
Christoph Hellwig 已提交
3441
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3442 3443 3444 3445 3446 3447

	/* 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 已提交
3448
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3449 3450 3451
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
Z
Zhu Yi 已提交
3452
{
3453
	struct iwl_priv *priv = hw->priv;
3454
	const u8 *addr;
3455 3456 3457
	int ret = 0;
	u8 sta_id = IWL_INVALID_STATION;
	u8 static_key;
Z
Zhu Yi 已提交
3458

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

3461
	if (iwl3945_mod_params.sw_crypto) {
3462
		IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
Z
Zhu Yi 已提交
3463 3464 3465
		return -EOPNOTSUPP;
	}

3466
	addr = sta ? sta->addr : iwl_bcast_addr;
3467 3468 3469
	static_key = !iwl_is_associated(priv);

	if (!static_key) {
3470
		sta_id = priv->cfg->ops->smgmt->find_station(priv, addr);
3471
		if (sta_id == IWL_INVALID_STATION) {
3472
			IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
3473 3474 3475
					    addr);
			return -EINVAL;
		}
Z
Zhu Yi 已提交
3476 3477 3478
	}

	mutex_lock(&priv->mutex);
3479
	iwl_scan_cancel_timeout(priv, 100);
3480
	mutex_unlock(&priv->mutex);
3481

Z
Zhu Yi 已提交
3482
	switch (cmd) {
3483 3484 3485 3486 3487 3488
	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 已提交
3489 3490
		break;
	case DISABLE_KEY:
3491 3492 3493 3494 3495
		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 已提交
3496 3497
		break;
	default:
3498
		ret = -EINVAL;
Z
Zhu Yi 已提交
3499 3500
	}

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

3503
	return ret;
Z
Zhu Yi 已提交
3504 3505 3506 3507 3508 3509 3510 3511
}

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

S
Samuel Ortiz 已提交
3512
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
3513 3514 3515 3516 3517 3518 3519 3520

/*
 * 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.
 */
3521 3522
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
3523
{
3524
	struct iwl_priv *priv = dev_get_drvdata(d);
3525 3526

	return sprintf(buf, "0x%08X\n", priv->debug_level);
Z
Zhu Yi 已提交
3527
}
3528 3529
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
3530 3531
				 const char *buf, size_t count)
{
3532
	struct iwl_priv *priv = dev_get_drvdata(d);
3533 3534
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
3535

3536 3537
	ret = strict_strtoul(buf, 0, &val);
	if (ret)
T
Tomas Winkler 已提交
3538
		IWL_INFO(priv, "%s is not in hex or decimal form.\n", buf);
Z
Zhu Yi 已提交
3539
	else
3540
		priv->debug_level = val;
Z
Zhu Yi 已提交
3541 3542 3543 3544

	return strnlen(buf, count);
}

3545 3546
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
3547

S
Samuel Ortiz 已提交
3548
#endif /* CONFIG_IWLWIFI_DEBUG */
Z
Zhu Yi 已提交
3549 3550 3551 3552

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

3555
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3556 3557
		return -EAGAIN;

C
Christoph Hellwig 已提交
3558
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
3559 3560 3561 3562 3563 3564 3565
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
3566
	struct iwl_priv *priv = dev_get_drvdata(d);
3567
	return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
Z
Zhu Yi 已提交
3568 3569 3570 3571 3572 3573
}

static ssize_t store_tx_power(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
3574
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3575 3576 3577 3578 3579
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
3580
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
3581
	else
C
Christoph Hellwig 已提交
3582
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
3583 3584 3585 3586 3587 3588 3589 3590 3591

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

3594
	return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
Z
Zhu Yi 已提交
3595 3596 3597 3598 3599 3600
}

static ssize_t store_flags(struct device *d,
			   struct device_attribute *attr,
			   const char *buf, size_t count)
{
3601
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3602 3603 3604
	u32 flags = simple_strtoul(buf, NULL, 0);

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

	return sprintf(buf, "0x%04X\n",
3629
		le32_to_cpu(priv->active_rxon.filter_flags));
Z
Zhu Yi 已提交
3630 3631 3632 3633 3634 3635
}

static ssize_t store_filter_flags(struct device *d,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
{
3636
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3637 3638 3639
	u32 filter_flags = simple_strtoul(buf, NULL, 0);

	mutex_lock(&priv->mutex);
3640
	if (le32_to_cpu(priv->staging_rxon.filter_flags) != filter_flags) {
Z
Zhu Yi 已提交
3641
		/* Cancel any currently running scans... */
3642
		if (iwl_scan_cancel_timeout(priv, 100))
3643
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
3644
		else {
3645
			IWL_DEBUG_INFO(priv, "Committing rxon.filter_flags = "
Z
Zhu Yi 已提交
3646
				       "0x%04X\n", filter_flags);
3647
			priv->staging_rxon.filter_flags =
Z
Zhu Yi 已提交
3648
				cpu_to_le32(filter_flags);
A
Abhijeet Kolekar 已提交
3649
			iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3650 3651 3652 3653 3654 3655 3656 3657 3658 3659
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

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

3660
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3661 3662 3663 3664

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

3722
	IWL_DEBUG_INFO(priv, "Invoking measurement of type %d on "
Z
Zhu Yi 已提交
3723
		       "channel %d (for '%s')\n", type, params.channel, buf);
C
Christoph Hellwig 已提交
3724
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
3725 3726 3727 3728 3729 3730

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
3731
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
3732 3733 3734 3735 3736

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
3737
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748

	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)
{
3749
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3750 3751 3752 3753 3754 3755
	return sprintf(buf, "%d", priv->retry_rate);
}

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

3756

Z
Zhu Yi 已提交
3757 3758 3759 3760
static ssize_t store_power_level(struct device *d,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
3761
	struct iwl_priv *priv = dev_get_drvdata(d);
3762 3763 3764
	int ret;
	unsigned long mode;

Z
Zhu Yi 已提交
3765 3766 3767

	mutex_lock(&priv->mutex);

3768 3769 3770
	ret = strict_strtoul(buf, 10, &mode);
	if (ret)
		goto out;
Z
Zhu Yi 已提交
3771

3772 3773 3774 3775
	ret = iwl_power_set_user_mode(priv, mode);
	if (ret) {
		IWL_DEBUG_MAC80211(priv, "failed setting power mode.\n");
		goto out;
Z
Zhu Yi 已提交
3776
	}
3777
	ret = count;
Z
Zhu Yi 已提交
3778 3779 3780

 out:
	mutex_unlock(&priv->mutex);
3781
	return ret;
Z
Zhu Yi 已提交
3782 3783
}

3784 3785 3786 3787 3788 3789 3790 3791
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 level = priv->power_data.power_mode;
	char *p = buf;

J
Johannes Berg 已提交
3792 3793
	p += sprintf(p, "INDEX:%d\t", level);
	p += sprintf(p, "USER:%d\n", mode);
3794 3795 3796 3797 3798 3799
	return p - buf + 1;
}

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

Z
Zhu Yi 已提交
3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820
#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)
{
3821 3822
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
3823 3824 3825 3826 3827 3828 3829
}

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
3830
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
3831
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
3832
	u32 len = 0, ofs = 0;
3833
	u8 *data = (u8 *)&priv->statistics_39;
Z
Zhu Yi 已提交
3834 3835
	int rc = 0;

3836
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3837 3838 3839
		return -EAGAIN;

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

3870
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3871 3872
		return -EAGAIN;

3873
	return sprintf(buf, "%d\n", iwl3945_mod_params.antenna);
Z
Zhu Yi 已提交
3874 3875 3876 3877 3878 3879
}

static ssize_t store_antenna(struct device *d,
			     struct device_attribute *attr,
			     const char *buf, size_t count)
{
3880
	struct iwl_priv *priv __maybe_unused = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3881 3882 3883 3884 3885 3886
	int ant;

	if (count == 0)
		return 0;

	if (sscanf(buf, "%1i", &ant) != 1) {
3887
		IWL_DEBUG_INFO(priv, "not in hex or decimal form.\n");
Z
Zhu Yi 已提交
3888 3889 3890 3891
		return count;
	}

	if ((ant >= 0) && (ant <= 2)) {
3892
		IWL_DEBUG_INFO(priv, "Setting antenna select to %d.\n", ant);
3893
		iwl3945_mod_params.antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
3894
	} else
3895
		IWL_DEBUG_INFO(priv, "Bad antenna select value %d.\n", ant);
Z
Zhu Yi 已提交
3896 3897 3898 3899 3900 3901 3902 3903 3904 3905


	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)
{
3906
	struct iwl_priv *priv = dev_get_drvdata(d);
3907
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3908 3909 3910 3911 3912 3913 3914 3915 3916 3917
		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)
{
3918
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3919 3920 3921
	char *p = (char *)buf;

	if (p[0] == '1')
3922
		iwl3945_dump_nic_error_log(priv);
Z
Zhu Yi 已提交
3923 3924 3925 3926 3927 3928 3929 3930 3931 3932

	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)
{
3933
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3934 3935 3936
	char *p = (char *)buf;

	if (p[0] == '1')
3937
		iwl3945_dump_nic_event_log(priv);
Z
Zhu Yi 已提交
3938 3939 3940 3941 3942 3943 3944 3945

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
3946
 * driver setup and tear down
Z
Zhu Yi 已提交
3947 3948 3949
 *
 *****************************************************************************/

3950
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3951
{
3952
	priv->workqueue = create_singlethread_workqueue(DRV_NAME);
Z
Zhu Yi 已提交
3953 3954 3955

	init_waitqueue_head(&priv->wait_command_queue);

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

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
3970 3971

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

3975
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3976
{
C
Christoph Hellwig 已提交
3977
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
3978

3979
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
3980 3981 3982 3983 3984
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

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

C
Christoph Hellwig 已提交
4007
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
4008
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
4009
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
4010 4011
};

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

4028
static int iwl3945_init_drv(struct iwl_priv *priv)
4029 4030
{
	int ret;
4031
	struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044

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

	spin_lock_init(&priv->lock);
	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 */
4045
	priv->cfg->ops->smgmt->clear_station_table(priv);
4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059

	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;
4060 4061
	/* If power management is turned on, default to CAM mode */
	priv->power_mode = IWL_POWER_MODE_CAM;
4062
	priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
4063

4064 4065 4066 4067 4068 4069 4070
	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);
4071 4072 4073 4074 4075
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

4076 4077 4078 4079 4080 4081
	/* Set up txpower settings in driver for all channels */
	if (iwl3945_txpower_set_from_eeprom(priv)) {
		ret = -EIO;
		goto err_free_channel_map;
	}

4082
	ret = iwlcore_init_geos(priv);
4083 4084 4085 4086
	if (ret) {
		IWL_ERR(priv, "initializing geos failed: %d\n", ret);
		goto err_free_channel_map;
	}
4087 4088
	iwl3945_init_hw_rates(priv, priv->ieee_rates);

4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106
	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 已提交
4107 4108
		    IEEE80211_HW_NOISE_DBM |
		    IEEE80211_HW_SPECTRUM_MGMT;
4109 4110 4111 4112 4113 4114 4115

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

	hw->wiphy->custom_regulatory = true;

J
Johannes Berg 已提交
4116 4117 4118
	hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX_3945;
	/* we create the 802.11 header and a zero-length SSID element */
	hw->wiphy->max_scan_ie_len = IWL_MAX_PROBE_REQUEST - 24 - 2;
4119

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

4123 4124 4125
	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
4126

4127 4128 4129
	if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&priv->bands[IEEE80211_BAND_5GHZ];
4130

4131 4132 4133 4134 4135 4136
	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;
4137

4138
	return 0;
4139 4140
}

C
Christoph Hellwig 已提交
4141
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
4142 4143
{
	int err = 0;
4144
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
4145
	struct ieee80211_hw *hw;
4146
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
4147
	struct iwl3945_eeprom *eeprom;
4148
	unsigned long flags;
Z
Zhu Yi 已提交
4149

4150 4151 4152 4153
	/***********************
	 * 1. Allocating HW data
	 * ********************/

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

4165 4166
	if ((iwl3945_mod_params.num_of_queues > IWL39_MAX_NUM_QUEUES) ||
	     (iwl3945_mod_params.num_of_queues < IWL_MIN_NUM_QUEUES)) {
4167 4168 4169
		IWL_ERR(priv,
			"invalid queues_num, should be between %d and %d\n",
			IWL_MIN_NUM_QUEUES, IWL39_MAX_NUM_QUEUES);
4170
		err = -EINVAL;
4171
		goto out_ieee80211_free_hw;
4172 4173
	}

4174 4175 4176 4177
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
4178
	if (iwl3945_mod_params.disable_hw_scan) {
4179
		IWL_DEBUG_INFO(priv, "Disabling hw_scan\n");
4180 4181 4182
		iwl3945_hw_ops.hw_scan = NULL;
	}

4183

4184
	IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
4185 4186
	priv->cfg = cfg;
	priv->pci_dev = pdev;
4187

S
Samuel Ortiz 已提交
4188
#ifdef CONFIG_IWLWIFI_DEBUG
4189
	priv->debug_level = iwl3945_mod_params.debug;
Z
Zhu Yi 已提交
4190 4191 4192
	atomic_set(&priv->restrict_refcnt, 0);
#endif

4193 4194 4195
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
4196 4197 4198 4199 4200 4201 4202
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

4203
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
4204
	if (!err)
4205
		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
4206
	if (err) {
T
Tomas Winkler 已提交
4207
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
4208 4209 4210 4211 4212 4213 4214
		goto out_pci_disable_device;
	}

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

4216 4217 4218
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
4219 4220 4221 4222 4223 4224
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

4225
	IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
Z
Zhu Yi 已提交
4226
			(unsigned long long) pci_resource_len(pdev, 0));
4227
	IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
Z
Zhu Yi 已提交
4228

4229 4230 4231
	/* 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 已提交
4232

M
Mohamed Abbas 已提交
4233 4234 4235 4236 4237
	/* this spin lock will be used in apm_ops.init and EEPROM access
	 * we should init now
	 */
	spin_lock_init(&priv->reg_lock);

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

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

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

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

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

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

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

	/***********************
4284
	 * 7. Setup Services
4285 4286 4287
	 * ********************/

	spin_lock_irqsave(&priv->lock, flags);
4288
	iwl_disable_interrupts(priv);
4289 4290
	spin_unlock_irqrestore(&priv->lock, flags);

4291 4292
	pci_enable_msi(priv->pci_dev);

M
Mohamed Abbas 已提交
4293 4294
	err = request_irq(priv->pci_dev->irq, priv->cfg->ops->lib->isr,
			  IRQF_SHARED, DRV_NAME, priv);
4295 4296 4297 4298 4299
	if (err) {
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

4300
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
4301
	if (err) {
4302
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
4303
		goto out_release_irq;
4304 4305
	}

4306 4307
	iwl_set_rxon_channel(priv,
			     &priv->bands[IEEE80211_BAND_2GHZ].channels[5]);
4308 4309 4310 4311
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);

	/*********************************
4312
	 * 8. Setup and Register mac80211
4313 4314
	 * *******************************/

4315
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
4316

4317 4318 4319
	err = iwl3945_setup_mac(priv);
	if (err)
		goto  out_remove_sysfs;
4320

A
Abhijeet Kolekar 已提交
4321 4322 4323 4324
	err = iwl_dbgfs_register(priv, DRV_NAME);
	if (err)
		IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);

S
Samuel Ortiz 已提交
4325
	err = iwl_rfkill_init(priv);
4326
	if (err)
4327
		IWL_ERR(priv, "Unable to initialize RFKILL system. "
4328
				  "Ignoring error: %d\n", err);
4329 4330
	else
		iwl_rfkill_set_hw_state(priv);
4331

4332 4333 4334 4335
	/* Start monitoring the killswitch */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   2 * HZ);

Z
Zhu Yi 已提交
4336 4337
	return 0;

4338
 out_remove_sysfs:
4339 4340
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
4341
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
4342
 out_release_irq:
4343 4344 4345
	free_irq(priv->pci_dev->irq, priv);
 out_disable_msi:
	pci_disable_msi(priv->pci_dev);
4346 4347 4348 4349 4350 4351
	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 已提交
4352 4353 4354 4355 4356 4357
 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);
4358
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
4359 4360 4361 4362 4363 4364
 out_ieee80211_free_hw:
	ieee80211_free_hw(priv->hw);
 out:
	return err;
}

4365
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
4366
{
4367
	struct iwl_priv *priv = pci_get_drvdata(pdev);
4368
	unsigned long flags;
Z
Zhu Yi 已提交
4369 4370 4371 4372

	if (!priv)
		return;

4373
	IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
Z
Zhu Yi 已提交
4374

A
Abhijeet Kolekar 已提交
4375 4376
	iwl_dbgfs_unregister(priv);

Z
Zhu Yi 已提交
4377
	set_bit(STATUS_EXIT_PENDING, &priv->status);
4378

4379 4380 4381 4382 4383 4384
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
4385

4386 4387 4388 4389
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
4390
	iwl_disable_interrupts(priv);
4391 4392 4393 4394
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

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

S
Samuel Ortiz 已提交
4397
	iwl_rfkill_unregister(priv);
4398
	cancel_delayed_work_sync(&priv->rfkill_poll);
4399

C
Christoph Hellwig 已提交
4400
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
4401 4402

	if (priv->rxq.bd)
R
Reinette Chatre 已提交
4403
		iwl3945_rx_queue_free(priv, &priv->rxq);
C
Christoph Hellwig 已提交
4404
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
4405

4406
	iwl3945_unset_hw_params(priv);
4407
	priv->cfg->ops->smgmt->clear_station_table(priv);
Z
Zhu Yi 已提交
4408

4409 4410 4411
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
4412
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
4413 4414 4415 4416 4417
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;

4418 4419 4420
	free_irq(pdev->irq, priv);
	pci_disable_msi(pdev);

Z
Zhu Yi 已提交
4421 4422 4423 4424 4425
	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

4426
	iwl_free_channel_map(priv);
4427
	iwlcore_free_geos(priv);
W
Winkler, Tomas 已提交
4428
	kfree(priv->scan);
Z
Zhu Yi 已提交
4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}


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

C
Christoph Hellwig 已提交
4442
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
4443
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
4444 4445 4446
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
4447
#ifdef CONFIG_PM
4448 4449
	.suspend = iwl_pci_suspend,
	.resume = iwl_pci_resume,
Z
Zhu Yi 已提交
4450 4451 4452
#endif
};

C
Christoph Hellwig 已提交
4453
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
4454 4455 4456 4457 4458
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
4459 4460 4461

	ret = iwl3945_rate_control_register();
	if (ret) {
4462 4463
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
4464 4465 4466
		return ret;
	}

C
Christoph Hellwig 已提交
4467
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
4468
	if (ret) {
4469
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
4470
		goto error_register;
Z
Zhu Yi 已提交
4471 4472 4473
	}

	return ret;
4474 4475 4476 4477

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
4478 4479
}

C
Christoph Hellwig 已提交
4480
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
4481
{
C
Christoph Hellwig 已提交
4482
	pci_unregister_driver(&iwl3945_driver);
4483
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
4484 4485
}

4486
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
4487

4488
module_param_named(antenna, iwl3945_mod_params.antenna, int, 0444);
Z
Zhu Yi 已提交
4489
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
4490 4491 4492
module_param_named(swcrypto, iwl3945_mod_params.sw_crypto, int, 0444);
MODULE_PARM_DESC(swcrypto,
		 "using software crypto (default 1 [software])\n");
4493
module_param_named(debug, iwl3945_mod_params.debug, uint, 0444);
Z
Zhu Yi 已提交
4494
MODULE_PARM_DESC(debug, "debug output mask");
4495
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
4496 4497
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

4498
module_param_named(queues_num, iwl3945_mod_params.num_of_queues, int, 0444);
Z
Zhu Yi 已提交
4499 4500
MODULE_PARM_DESC(queues_num, "number of hw queues.");

4501 4502 4503
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 已提交
4504 4505
module_exit(iwl3945_exit);
module_init(iwl3945_init);