iwl3945-base.c 236.4 KB
Newer Older
Z
Zhu Yi 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
/******************************************************************************
 *
 * Copyright(c) 2003 - 2007 Intel Corporation. All rights reserved.
 *
 * 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:
 * James P. Ketrenos <ipw2100-admin@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/version.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>
#include <net/mac80211.h>

#include <asm/div64.h>

T
Tomas Winkler 已提交
49
#include "iwl-3945-core.h"
Z
Zhu Yi 已提交
50 51 52
#include "iwl-3945.h"
#include "iwl-helpers.h"

53
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
54
u32 iwl3945_debug_level;
Z
Zhu Yi 已提交
55 56
#endif

C
Christoph Hellwig 已提交
57 58
static int iwl3945_tx_queue_update_write_ptr(struct iwl3945_priv *priv,
				  struct iwl3945_tx_queue *txq);
59

Z
Zhu Yi 已提交
60 61 62 63 64 65 66
/******************************************************************************
 *
 * module boiler plate
 *
 ******************************************************************************/

/* module parameters */
67 68 69
static int iwl3945_param_disable_hw_scan; /* def: 0 = use 3945's h/w scan */
static int iwl3945_param_debug;    /* def: 0 = minimal debug log messages */
static int iwl3945_param_disable;  /* def: 0 = enable radio */
70
static int iwl3945_param_antenna;  /* def: 0 = both antennas (use diversity) */
71 72 73
int iwl3945_param_hwcrypto;        /* def: 0 = use software encryption */
static int iwl3945_param_qos_enable = 1; /* def: 1 = use quality of service */
int iwl3945_param_queues_num = IWL_MAX_NUM_QUEUES; /* def: 8 Tx queues */
Z
Zhu Yi 已提交
74 75 76 77 78 79 80 81 82

/*
 * module name, copyright, version, etc.
 * NOTE: DRV_NAME is defined in iwlwifi.h for use by iwl-debug.h and printk
 */

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

83
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
84 85 86 87 88
#define VD "d"
#else
#define VD
#endif

89
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
90 91 92 93 94
#define VS "s"
#else
#define VS
#endif

95
#define IWLWIFI_VERSION "1.2.26k" VD VS
Z
Zhu Yi 已提交
96 97 98 99 100 101 102 103 104
#define DRV_COPYRIGHT	"Copyright(c) 2003-2007 Intel Corporation"
#define DRV_VERSION     IWLWIFI_VERSION


MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_VERSION(DRV_VERSION);
MODULE_AUTHOR(DRV_COPYRIGHT);
MODULE_LICENSE("GPL");

105
static __le16 *ieee80211_get_qos_ctrl(struct ieee80211_hdr *hdr)
Z
Zhu Yi 已提交
106 107 108 109 110 111 112 113 114
{
	u16 fc = le16_to_cpu(hdr->frame_control);
	int hdr_len = ieee80211_get_hdrlen(fc);

	if ((fc & 0x00cc) == (IEEE80211_STYPE_QOS_DATA | IEEE80211_FTYPE_DATA))
		return (__le16 *) ((u8 *) hdr + hdr_len - QOS_CONTROL_LEN);
	return NULL;
}

115 116
static const struct ieee80211_supported_band *iwl3945_get_band(
		struct iwl3945_priv *priv, enum ieee80211_band band)
Z
Zhu Yi 已提交
117
{
118
	return priv->hw->wiphy->bands[band];
Z
Zhu Yi 已提交
119 120
}

C
Christoph Hellwig 已提交
121
static int iwl3945_is_empty_essid(const char *essid, int essid_len)
Z
Zhu Yi 已提交
122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
{
	/* Single white space is for Linksys APs */
	if (essid_len == 1 && essid[0] == ' ')
		return 1;

	/* Otherwise, if the entire essid is 0, we assume it is hidden */
	while (essid_len) {
		essid_len--;
		if (essid[essid_len] != '\0')
			return 0;
	}

	return 1;
}

C
Christoph Hellwig 已提交
137
static const char *iwl3945_escape_essid(const char *essid, u8 essid_len)
Z
Zhu Yi 已提交
138 139 140 141 142
{
	static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
	const char *s = essid;
	char *d = escaped;

C
Christoph Hellwig 已提交
143
	if (iwl3945_is_empty_essid(essid, essid_len)) {
Z
Zhu Yi 已提交
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
		memcpy(escaped, "<hidden>", sizeof("<hidden>"));
		return escaped;
	}

	essid_len = min(essid_len, (u8) IW_ESSID_MAX_SIZE);
	while (essid_len--) {
		if (*s == '\0') {
			*d++ = '\\';
			*d++ = '0';
			s++;
		} else
			*d++ = *s++;
	}
	*d = '\0';
	return escaped;
}

/*************** DMA-QUEUE-GENERAL-FUNCTIONS  *****
 * DMA services
 *
 * Theory of operation
 *
166 167 168 169 170 171 172 173 174
 * A Tx or Rx queue resides in host DRAM, and is comprised of a circular buffer
 * of buffer descriptors, each of which points to one or more data buffers for
 * the device to read from or fill.  Driver and device exchange status of each
 * queue via "read" and "write" pointers.  Driver keeps minimum of 2 empty
 * entries in each circular buffer, to protect against confusing empty and full
 * queue states.
 *
 * The device reads or writes the data in the queues via the device's several
 * DMA/FIFO channels.  Each queue is mapped to a single DMA channel.
Z
Zhu Yi 已提交
175 176 177 178 179 180
 *
 * For Tx queue, there are low mark and high mark limits. If, after queuing
 * the packet for Tx, free space become < low mark, Tx queue stopped. When
 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
 * Tx queue resumed.
 *
181 182 183
 * The 3945 operates with six queues:  One receive queue, one transmit queue
 * (#4) for sending commands to the device firmware, and four transmit queues
 * (#0-3) for data tx via EDCA.  An additional 2 HCCA queues are unused.
Z
Zhu Yi 已提交
184 185
 ***************************************************/

C
Christoph Hellwig 已提交
186
static int iwl3945_queue_space(const struct iwl3945_queue *q)
Z
Zhu Yi 已提交
187
{
188
	int s = q->read_ptr - q->write_ptr;
Z
Zhu Yi 已提交
189

190
	if (q->read_ptr > q->write_ptr)
Z
Zhu Yi 已提交
191 192 193 194 195 196 197 198 199 200 201
		s -= q->n_bd;

	if (s <= 0)
		s += q->n_window;
	/* keep some reserve to not confuse empty and full situations */
	s -= 2;
	if (s < 0)
		s = 0;
	return s;
}

202 203 204 205 206
/**
 * iwl3945_queue_inc_wrap - increment queue index, wrap back to beginning
 * @index -- current index
 * @n_bd -- total number of entries in queue (must be power of 2)
 */
C
Christoph Hellwig 已提交
207
static inline int iwl3945_queue_inc_wrap(int index, int n_bd)
Z
Zhu Yi 已提交
208 209 210 211
{
	return ++index & (n_bd - 1);
}

212 213 214 215 216
/**
 * iwl3945_queue_dec_wrap - increment queue index, wrap back to end
 * @index -- current index
 * @n_bd -- total number of entries in queue (must be power of 2)
 */
C
Christoph Hellwig 已提交
217
static inline int iwl3945_queue_dec_wrap(int index, int n_bd)
Z
Zhu Yi 已提交
218 219 220 221
{
	return --index & (n_bd - 1);
}

C
Christoph Hellwig 已提交
222
static inline int x2_queue_used(const struct iwl3945_queue *q, int i)
Z
Zhu Yi 已提交
223
{
224 225 226
	return q->write_ptr > q->read_ptr ?
		(i >= q->read_ptr && i < q->write_ptr) :
		!(i < q->read_ptr && i >= q->write_ptr);
Z
Zhu Yi 已提交
227 228
}

C
Christoph Hellwig 已提交
229
static inline u8 get_cmd_index(struct iwl3945_queue *q, u32 index, int is_huge)
Z
Zhu Yi 已提交
230
{
231
	/* This is for scan command, the big buffer at end of command array */
Z
Zhu Yi 已提交
232
	if (is_huge)
233
		return q->n_window;	/* must be power of 2 */
Z
Zhu Yi 已提交
234

235
	/* Otherwise, use normal size buffers */
Z
Zhu Yi 已提交
236 237 238
	return index & (q->n_window - 1);
}

239 240 241
/**
 * iwl3945_queue_init - Initialize queue's high/low-water and read/write indexes
 */
C
Christoph Hellwig 已提交
242
static int iwl3945_queue_init(struct iwl3945_priv *priv, struct iwl3945_queue *q,
Z
Zhu Yi 已提交
243 244 245 246 247 248
			  int count, int slots_num, u32 id)
{
	q->n_bd = count;
	q->n_window = slots_num;
	q->id = id;

C
Christoph Hellwig 已提交
249 250
	/* count must be power-of-two size, otherwise iwl3945_queue_inc_wrap
	 * and iwl3945_queue_dec_wrap are broken. */
Z
Zhu Yi 已提交
251 252 253 254 255 256 257 258 259 260 261 262 263 264
	BUG_ON(!is_power_of_2(count));

	/* slots_num must be power-of-two size, otherwise
	 * get_cmd_index is broken. */
	BUG_ON(!is_power_of_2(slots_num));

	q->low_mark = q->n_window / 4;
	if (q->low_mark < 4)
		q->low_mark = 4;

	q->high_mark = q->n_window / 8;
	if (q->high_mark < 2)
		q->high_mark = 2;

265
	q->write_ptr = q->read_ptr = 0;
Z
Zhu Yi 已提交
266 267 268 269

	return 0;
}

270 271 272
/**
 * iwl3945_tx_queue_alloc - Alloc driver data and TFD CB for one Tx/cmd queue
 */
C
Christoph Hellwig 已提交
273 274
static int iwl3945_tx_queue_alloc(struct iwl3945_priv *priv,
			      struct iwl3945_tx_queue *txq, u32 id)
Z
Zhu Yi 已提交
275 276 277
{
	struct pci_dev *dev = priv->pci_dev;

278 279
	/* Driver private data, only for Tx (not command) queues,
	 * not shared with device. */
Z
Zhu Yi 已提交
280 281 282 283
	if (id != IWL_CMD_QUEUE_NUM) {
		txq->txb = kmalloc(sizeof(txq->txb[0]) *
				   TFD_QUEUE_SIZE_MAX, GFP_KERNEL);
		if (!txq->txb) {
284
			IWL_ERROR("kmalloc for auxiliary BD "
Z
Zhu Yi 已提交
285 286 287 288 289 290
				  "structures failed\n");
			goto error;
		}
	} else
		txq->txb = NULL;

291 292
	/* Circular buffer of transmit frame descriptors (TFDs),
	 * shared with device */
Z
Zhu Yi 已提交
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
	txq->bd = pci_alloc_consistent(dev,
			sizeof(txq->bd[0]) * TFD_QUEUE_SIZE_MAX,
			&txq->q.dma_addr);

	if (!txq->bd) {
		IWL_ERROR("pci_alloc_consistent(%zd) failed\n",
			  sizeof(txq->bd[0]) * TFD_QUEUE_SIZE_MAX);
		goto error;
	}
	txq->q.id = id;

	return 0;

 error:
	if (txq->txb) {
		kfree(txq->txb);
		txq->txb = NULL;
	}

	return -ENOMEM;
}

315 316 317
/**
 * iwl3945_tx_queue_init - Allocate and initialize one tx/cmd queue
 */
C
Christoph Hellwig 已提交
318 319
int iwl3945_tx_queue_init(struct iwl3945_priv *priv,
		      struct iwl3945_tx_queue *txq, int slots_num, u32 txq_id)
Z
Zhu Yi 已提交
320 321 322 323 324
{
	struct pci_dev *dev = priv->pci_dev;
	int len;
	int rc = 0;

325 326 327 328 329 330 331 332
	/*
	 * Alloc buffer array for commands (Tx or other types of commands).
	 * For the command queue (#4), allocate command space + one big
	 * command for scan, since scan command is very huge; the system will
	 * not have two scans at the same time, so only one is needed.
	 * For data Tx queues (all other queues), no super-size command
	 * space is needed.
	 */
C
Christoph Hellwig 已提交
333
	len = sizeof(struct iwl3945_cmd) * slots_num;
Z
Zhu Yi 已提交
334 335 336 337 338 339
	if (txq_id == IWL_CMD_QUEUE_NUM)
		len +=  IWL_MAX_SCAN_SIZE;
	txq->cmd = pci_alloc_consistent(dev, len, &txq->dma_addr_cmd);
	if (!txq->cmd)
		return -ENOMEM;

340
	/* Alloc driver data array and TFD circular buffer */
C
Christoph Hellwig 已提交
341
	rc = iwl3945_tx_queue_alloc(priv, txq, txq_id);
Z
Zhu Yi 已提交
342 343 344 345 346 347 348 349
	if (rc) {
		pci_free_consistent(dev, len, txq->cmd, txq->dma_addr_cmd);

		return -ENOMEM;
	}
	txq->need_update = 0;

	/* TFD_QUEUE_SIZE_MAX must be power-of-two size, otherwise
C
Christoph Hellwig 已提交
350
	 * iwl3945_queue_inc_wrap and iwl3945_queue_dec_wrap are broken. */
Z
Zhu Yi 已提交
351
	BUILD_BUG_ON(TFD_QUEUE_SIZE_MAX & (TFD_QUEUE_SIZE_MAX - 1));
352 353

	/* Initialize queue high/low-water, head/tail indexes */
C
Christoph Hellwig 已提交
354
	iwl3945_queue_init(priv, &txq->q, TFD_QUEUE_SIZE_MAX, slots_num, txq_id);
Z
Zhu Yi 已提交
355

356
	/* Tell device where to find queue, enable DMA channel. */
C
Christoph Hellwig 已提交
357
	iwl3945_hw_tx_queue_init(priv, txq);
Z
Zhu Yi 已提交
358 359 360 361 362

	return 0;
}

/**
C
Christoph Hellwig 已提交
363
 * iwl3945_tx_queue_free - Deallocate DMA queue.
Z
Zhu Yi 已提交
364 365 366
 * @txq: Transmit queue to deallocate.
 *
 * Empty queue by removing and destroying all BD's.
367 368
 * Free all buffers.
 * 0-fill, but do not free "txq" descriptor structure.
Z
Zhu Yi 已提交
369
 */
C
Christoph Hellwig 已提交
370
void iwl3945_tx_queue_free(struct iwl3945_priv *priv, struct iwl3945_tx_queue *txq)
Z
Zhu Yi 已提交
371
{
C
Christoph Hellwig 已提交
372
	struct iwl3945_queue *q = &txq->q;
Z
Zhu Yi 已提交
373 374 375 376 377 378 379
	struct pci_dev *dev = priv->pci_dev;
	int len;

	if (q->n_bd == 0)
		return;

	/* first, empty all BD's */
380
	for (; q->write_ptr != q->read_ptr;
C
Christoph Hellwig 已提交
381 382
	     q->read_ptr = iwl3945_queue_inc_wrap(q->read_ptr, q->n_bd))
		iwl3945_hw_txq_free_tfd(priv, txq);
Z
Zhu Yi 已提交
383

C
Christoph Hellwig 已提交
384
	len = sizeof(struct iwl3945_cmd) * q->n_window;
Z
Zhu Yi 已提交
385 386 387
	if (q->id == IWL_CMD_QUEUE_NUM)
		len += IWL_MAX_SCAN_SIZE;

388
	/* De-alloc array of command/tx buffers */
Z
Zhu Yi 已提交
389 390
	pci_free_consistent(dev, len, txq->cmd, txq->dma_addr_cmd);

391
	/* De-alloc circular buffer of TFDs */
Z
Zhu Yi 已提交
392
	if (txq->q.n_bd)
C
Christoph Hellwig 已提交
393
		pci_free_consistent(dev, sizeof(struct iwl3945_tfd_frame) *
Z
Zhu Yi 已提交
394 395
				    txq->q.n_bd, txq->bd, txq->q.dma_addr);

396
	/* De-alloc array of per-TFD driver data */
Z
Zhu Yi 已提交
397 398 399 400 401
	if (txq->txb) {
		kfree(txq->txb);
		txq->txb = NULL;
	}

402
	/* 0-fill queue descriptor structure */
Z
Zhu Yi 已提交
403 404 405
	memset(txq, 0, sizeof(*txq));
}

C
Christoph Hellwig 已提交
406
const u8 iwl3945_broadcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
Z
Zhu Yi 已提交
407 408

/*************** STATION TABLE MANAGEMENT ****
409
 * mac80211 should be examined to determine if sta_info is duplicating
Z
Zhu Yi 已提交
410 411 412 413
 * the functionality provided here
 */

/**************************************************************/
414
#if 0 /* temporary disable till we add real remove station */
415 416 417 418 419
/**
 * iwl3945_remove_station - Remove driver's knowledge of station.
 *
 * NOTE:  This does not remove station from device's station table.
 */
C
Christoph Hellwig 已提交
420
static u8 iwl3945_remove_station(struct iwl3945_priv *priv, const u8 *addr, int is_ap)
Z
Zhu Yi 已提交
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
{
	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))
		index = priv->hw_setting.bcast_sta_id;
	else
		for (i = IWL_STA_ID; i < priv->hw_setting.max_stations; i++)
			if (priv->stations[i].used &&
			    !compare_ether_addr(priv->stations[i].sta.sta.addr,
						addr)) {
				index = i;
				break;
			}

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

	if (priv->stations[index].used) {
		priv->stations[index].used = 0;
		priv->num_stations--;
	}

	BUG_ON(priv->num_stations < 0);

out:
	spin_unlock_irqrestore(&priv->sta_lock, flags);
	return 0;
}
455
#endif
456 457 458 459 460 461

/**
 * iwl3945_clear_stations_table - Clear the driver's station table
 *
 * NOTE:  This does not clear or otherwise alter the device's station table.
 */
C
Christoph Hellwig 已提交
462
static void iwl3945_clear_stations_table(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
463 464 465 466 467 468 469 470 471 472 473
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);

	priv->num_stations = 0;
	memset(priv->stations, 0, sizeof(priv->stations));

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

474 475 476
/**
 * iwl3945_add_station - Add station to station tables in driver and device
 */
C
Christoph Hellwig 已提交
477
u8 iwl3945_add_station(struct iwl3945_priv *priv, const u8 *addr, int is_ap, u8 flags)
Z
Zhu Yi 已提交
478 479 480
{
	int i;
	int index = IWL_INVALID_STATION;
C
Christoph Hellwig 已提交
481
	struct iwl3945_station_entry *station;
Z
Zhu Yi 已提交
482
	unsigned long flags_spin;
483
	DECLARE_MAC_BUF(mac);
484
	u8 rate;
Z
Zhu Yi 已提交
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503

	spin_lock_irqsave(&priv->sta_lock, flags_spin);
	if (is_ap)
		index = IWL_AP_ID;
	else if (is_broadcast_ether_addr(addr))
		index = priv->hw_setting.bcast_sta_id;
	else
		for (i = IWL_STA_ID; i < priv->hw_setting.max_stations; i++) {
			if (!compare_ether_addr(priv->stations[i].sta.sta.addr,
						addr)) {
				index = i;
				break;
			}

			if (!priv->stations[i].used &&
			    index == IWL_INVALID_STATION)
				index = i;
		}

504
	/* These two conditions has the same outcome but keep them separate
Z
Zhu Yi 已提交
505 506 507 508 509 510 511 512 513 514 515 516
	  since they have different meaning */
	if (unlikely(index == IWL_INVALID_STATION)) {
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return index;
	}

	if (priv->stations[index].used &&
	   !compare_ether_addr(priv->stations[index].sta.sta.addr, addr)) {
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return index;
	}

517
	IWL_DEBUG_ASSOC("Add STA ID %d: %s\n", index, print_mac(mac, addr));
Z
Zhu Yi 已提交
518 519 520 521
	station = &priv->stations[index];
	station->used = 1;
	priv->num_stations++;

522
	/* Set up the REPLY_ADD_STA command to send to device */
C
Christoph Hellwig 已提交
523
	memset(&station->sta, 0, sizeof(struct iwl3945_addsta_cmd));
Z
Zhu Yi 已提交
524 525 526 527 528
	memcpy(station->sta.sta.addr, addr, ETH_ALEN);
	station->sta.mode = 0;
	station->sta.sta.sta_id = index;
	station->sta.station_flags = 0;

529
	if (priv->band == IEEE80211_BAND_5GHZ)
530 531 532
		rate = IWL_RATE_6M_PLCP;
	else
		rate =	IWL_RATE_1M_PLCP;
533 534 535

	/* Turn on both antennas for the station... */
	station->sta.rate_n_flags =
C
Christoph Hellwig 已提交
536
			iwl3945_hw_set_rate_n_flags(rate, RATE_MCS_ANT_AB_MSK);
537 538 539
	station->current_rate.rate_n_flags =
			le16_to_cpu(station->sta.rate_n_flags);

Z
Zhu Yi 已提交
540
	spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
541 542

	/* Add station to device's station table */
C
Christoph Hellwig 已提交
543
	iwl3945_send_add_station(priv, &station->sta, flags);
Z
Zhu Yi 已提交
544 545 546 547 548 549
	return index;

}

/*************** DRIVER STATUS FUNCTIONS   *****/

C
Christoph Hellwig 已提交
550
static inline int iwl3945_is_ready(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
551 552 553 554 555 556 557 558
{
	/* The adapter is 'ready' if READY and GEO_CONFIGURED bits are
	 * set but EXIT_PENDING is not */
	return test_bit(STATUS_READY, &priv->status) &&
	       test_bit(STATUS_GEO_CONFIGURED, &priv->status) &&
	       !test_bit(STATUS_EXIT_PENDING, &priv->status);
}

C
Christoph Hellwig 已提交
559
static inline int iwl3945_is_alive(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
560 561 562 563
{
	return test_bit(STATUS_ALIVE, &priv->status);
}

C
Christoph Hellwig 已提交
564
static inline int iwl3945_is_init(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
565 566 567 568
{
	return test_bit(STATUS_INIT, &priv->status);
}

C
Christoph Hellwig 已提交
569
static inline int iwl3945_is_rfkill(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
570 571 572 573 574
{
	return test_bit(STATUS_RF_KILL_HW, &priv->status) ||
	       test_bit(STATUS_RF_KILL_SW, &priv->status);
}

C
Christoph Hellwig 已提交
575
static inline int iwl3945_is_ready_rf(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
576 577
{

C
Christoph Hellwig 已提交
578
	if (iwl3945_is_rfkill(priv))
Z
Zhu Yi 已提交
579 580
		return 0;

C
Christoph Hellwig 已提交
581
	return iwl3945_is_ready(priv);
Z
Zhu Yi 已提交
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
}

/*************** HOST COMMAND QUEUE FUNCTIONS   *****/

#define IWL_CMD(x) case x : return #x

static const char *get_cmd_string(u8 cmd)
{
	switch (cmd) {
		IWL_CMD(REPLY_ALIVE);
		IWL_CMD(REPLY_ERROR);
		IWL_CMD(REPLY_RXON);
		IWL_CMD(REPLY_RXON_ASSOC);
		IWL_CMD(REPLY_QOS_PARAM);
		IWL_CMD(REPLY_RXON_TIMING);
		IWL_CMD(REPLY_ADD_STA);
		IWL_CMD(REPLY_REMOVE_STA);
		IWL_CMD(REPLY_REMOVE_ALL_STA);
		IWL_CMD(REPLY_3945_RX);
		IWL_CMD(REPLY_TX);
		IWL_CMD(REPLY_RATE_SCALE);
		IWL_CMD(REPLY_LEDS_CMD);
		IWL_CMD(REPLY_TX_LINK_QUALITY_CMD);
		IWL_CMD(RADAR_NOTIFICATION);
		IWL_CMD(REPLY_QUIET_CMD);
		IWL_CMD(REPLY_CHANNEL_SWITCH);
		IWL_CMD(CHANNEL_SWITCH_NOTIFICATION);
		IWL_CMD(REPLY_SPECTRUM_MEASUREMENT_CMD);
		IWL_CMD(SPECTRUM_MEASURE_NOTIFICATION);
		IWL_CMD(POWER_TABLE_CMD);
		IWL_CMD(PM_SLEEP_NOTIFICATION);
		IWL_CMD(PM_DEBUG_STATISTIC_NOTIFIC);
		IWL_CMD(REPLY_SCAN_CMD);
		IWL_CMD(REPLY_SCAN_ABORT_CMD);
		IWL_CMD(SCAN_START_NOTIFICATION);
		IWL_CMD(SCAN_RESULTS_NOTIFICATION);
		IWL_CMD(SCAN_COMPLETE_NOTIFICATION);
		IWL_CMD(BEACON_NOTIFICATION);
		IWL_CMD(REPLY_TX_BEACON);
		IWL_CMD(WHO_IS_AWAKE_NOTIFICATION);
		IWL_CMD(QUIET_NOTIFICATION);
		IWL_CMD(REPLY_TX_PWR_TABLE_CMD);
		IWL_CMD(MEASURE_ABORT_NOTIFICATION);
		IWL_CMD(REPLY_BT_CONFIG);
		IWL_CMD(REPLY_STATISTICS_CMD);
		IWL_CMD(STATISTICS_NOTIFICATION);
		IWL_CMD(REPLY_CARD_STATE_CMD);
		IWL_CMD(CARD_STATE_NOTIFICATION);
		IWL_CMD(MISSED_BEACONS_NOTIFICATION);
	default:
		return "UNKNOWN";

	}
}

#define HOST_COMPLETE_TIMEOUT (HZ / 2)

/**
C
Christoph Hellwig 已提交
640
 * iwl3945_enqueue_hcmd - enqueue a uCode command
Z
Zhu Yi 已提交
641 642 643 644 645 646 647
 * @priv: device private data point
 * @cmd: a point to the ucode command structure
 *
 * The function returns < 0 values to indicate the operation is
 * failed. On success, it turns the index (> 0) of command in the
 * command queue.
 */
C
Christoph Hellwig 已提交
648
static int iwl3945_enqueue_hcmd(struct iwl3945_priv *priv, struct iwl3945_host_cmd *cmd)
Z
Zhu Yi 已提交
649
{
C
Christoph Hellwig 已提交
650 651 652
	struct iwl3945_tx_queue *txq = &priv->txq[IWL_CMD_QUEUE_NUM];
	struct iwl3945_queue *q = &txq->q;
	struct iwl3945_tfd_frame *tfd;
Z
Zhu Yi 已提交
653
	u32 *control_flags;
C
Christoph Hellwig 已提交
654
	struct iwl3945_cmd *out_cmd;
Z
Zhu Yi 已提交
655 656 657 658 659 660 661 662 663 664 665 666 667 668
	u32 idx;
	u16 fix_size = (u16)(cmd->len + sizeof(out_cmd->hdr));
	dma_addr_t phys_addr;
	int pad;
	u16 count;
	int ret;
	unsigned long flags;

	/* If any of the command structures end up being larger than
	 * the TFD_MAX_PAYLOAD_SIZE, and it sent as a 'small' command then
	 * we will need to increase the size of the TFD entries */
	BUG_ON((fix_size > TFD_MAX_PAYLOAD_SIZE) &&
	       !(cmd->meta.flags & CMD_SIZE_HUGE));

669 670 671 672 673 674

	if (iwl3945_is_rfkill(priv)) {
		IWL_DEBUG_INFO("Not sending command - RF KILL");
		return -EIO;
	}

C
Christoph Hellwig 已提交
675
	if (iwl3945_queue_space(q) < ((cmd->meta.flags & CMD_ASYNC) ? 2 : 1)) {
Z
Zhu Yi 已提交
676 677 678 679 680 681
		IWL_ERROR("No space for Tx\n");
		return -ENOSPC;
	}

	spin_lock_irqsave(&priv->hcmd_lock, flags);

682
	tfd = &txq->bd[q->write_ptr];
Z
Zhu Yi 已提交
683 684 685 686
	memset(tfd, 0, sizeof(*tfd));

	control_flags = (u32 *) tfd;

687
	idx = get_cmd_index(q, q->write_ptr, cmd->meta.flags & CMD_SIZE_HUGE);
Z
Zhu Yi 已提交
688 689 690 691 692 693 694 695 696 697 698
	out_cmd = &txq->cmd[idx];

	out_cmd->hdr.cmd = cmd->id;
	memcpy(&out_cmd->meta, &cmd->meta, sizeof(cmd->meta));
	memcpy(&out_cmd->cmd.payload, cmd->data, cmd->len);

	/* At this point, the out_cmd now has all of the incoming cmd
	 * information */

	out_cmd->hdr.flags = 0;
	out_cmd->hdr.sequence = cpu_to_le16(QUEUE_TO_SEQ(IWL_CMD_QUEUE_NUM) |
699
			INDEX_TO_SEQ(q->write_ptr));
Z
Zhu Yi 已提交
700 701 702 703
	if (out_cmd->meta.flags & CMD_SIZE_HUGE)
		out_cmd->hdr.sequence |= cpu_to_le16(SEQ_HUGE_FRAME);

	phys_addr = txq->dma_addr_cmd + sizeof(txq->cmd[0]) * idx +
C
Christoph Hellwig 已提交
704 705
			offsetof(struct iwl3945_cmd, hdr);
	iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, phys_addr, fix_size);
Z
Zhu Yi 已提交
706 707 708 709 710 711 712 713 714

	pad = U32_PAD(cmd->len);
	count = TFD_CTL_COUNT_GET(*control_flags);
	*control_flags = TFD_CTL_COUNT_SET(count) | TFD_CTL_PAD_SET(pad);

	IWL_DEBUG_HC("Sending command %s (#%x), seq: 0x%04X, "
		     "%d bytes at %d[%d]:%d\n",
		     get_cmd_string(out_cmd->hdr.cmd),
		     out_cmd->hdr.cmd, le16_to_cpu(out_cmd->hdr.sequence),
715
		     fix_size, q->write_ptr, idx, IWL_CMD_QUEUE_NUM);
Z
Zhu Yi 已提交
716 717

	txq->need_update = 1;
718 719

	/* Increment and update queue's write index */
C
Christoph Hellwig 已提交
720 721
	q->write_ptr = iwl3945_queue_inc_wrap(q->write_ptr, q->n_bd);
	ret = iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
722 723 724 725 726

	spin_unlock_irqrestore(&priv->hcmd_lock, flags);
	return ret ? ret : idx;
}

C
Christoph Hellwig 已提交
727
static int iwl3945_send_cmd_async(struct iwl3945_priv *priv, struct iwl3945_host_cmd *cmd)
Z
Zhu Yi 已提交
728 729 730 731 732 733 734 735 736 737 738 739 740 741
{
	int ret;

	BUG_ON(!(cmd->meta.flags & CMD_ASYNC));

	/* An asynchronous command can not expect an SKB to be set. */
	BUG_ON(cmd->meta.flags & CMD_WANT_SKB);

	/* An asynchronous command MUST have a callback. */
	BUG_ON(!cmd->meta.u.callback);

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

C
Christoph Hellwig 已提交
742
	ret = iwl3945_enqueue_hcmd(priv, cmd);
Z
Zhu Yi 已提交
743
	if (ret < 0) {
C
Christoph Hellwig 已提交
744
		IWL_ERROR("Error sending %s: iwl3945_enqueue_hcmd failed: %d\n",
Z
Zhu Yi 已提交
745 746 747 748 749 750
			  get_cmd_string(cmd->id), ret);
		return ret;
	}
	return 0;
}

C
Christoph Hellwig 已提交
751
static int iwl3945_send_cmd_sync(struct iwl3945_priv *priv, struct iwl3945_host_cmd *cmd)
Z
Zhu Yi 已提交
752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
{
	int cmd_idx;
	int ret;
	static atomic_t entry = ATOMIC_INIT(0); /* reentrance protection */

	BUG_ON(cmd->meta.flags & CMD_ASYNC);

	 /* A synchronous command can not have a callback set. */
	BUG_ON(cmd->meta.u.callback != NULL);

	if (atomic_xchg(&entry, 1)) {
		IWL_ERROR("Error sending %s: Already sending a host command\n",
			  get_cmd_string(cmd->id));
		return -EBUSY;
	}

	set_bit(STATUS_HCMD_ACTIVE, &priv->status);

	if (cmd->meta.flags & CMD_WANT_SKB)
		cmd->meta.source = &cmd->meta;

C
Christoph Hellwig 已提交
773
	cmd_idx = iwl3945_enqueue_hcmd(priv, cmd);
Z
Zhu Yi 已提交
774 775
	if (cmd_idx < 0) {
		ret = cmd_idx;
C
Christoph Hellwig 已提交
776
		IWL_ERROR("Error sending %s: iwl3945_enqueue_hcmd failed: %d\n",
Z
Zhu Yi 已提交
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 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
			  get_cmd_string(cmd->id), ret);
		goto out;
	}

	ret = wait_event_interruptible_timeout(priv->wait_command_queue,
			!test_bit(STATUS_HCMD_ACTIVE, &priv->status),
			HOST_COMPLETE_TIMEOUT);
	if (!ret) {
		if (test_bit(STATUS_HCMD_ACTIVE, &priv->status)) {
			IWL_ERROR("Error sending %s: time out after %dms.\n",
				  get_cmd_string(cmd->id),
				  jiffies_to_msecs(HOST_COMPLETE_TIMEOUT));

			clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
			ret = -ETIMEDOUT;
			goto cancel;
		}
	}

	if (test_bit(STATUS_RF_KILL_HW, &priv->status)) {
		IWL_DEBUG_INFO("Command %s aborted: RF KILL Switch\n",
			       get_cmd_string(cmd->id));
		ret = -ECANCELED;
		goto fail;
	}
	if (test_bit(STATUS_FW_ERROR, &priv->status)) {
		IWL_DEBUG_INFO("Command %s failed: FW Error\n",
			       get_cmd_string(cmd->id));
		ret = -EIO;
		goto fail;
	}
	if ((cmd->meta.flags & CMD_WANT_SKB) && !cmd->meta.u.skb) {
		IWL_ERROR("Error: Response NULL in '%s'\n",
			  get_cmd_string(cmd->id));
		ret = -EIO;
		goto out;
	}

	ret = 0;
	goto out;

cancel:
	if (cmd->meta.flags & CMD_WANT_SKB) {
C
Christoph Hellwig 已提交
820
		struct iwl3945_cmd *qcmd;
Z
Zhu Yi 已提交
821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838

		/* Cancel the CMD_WANT_SKB flag for the cmd in the
		 * TX cmd queue. Otherwise in case the cmd comes
		 * in later, it will possibly set an invalid
		 * address (cmd->meta.source). */
		qcmd = &priv->txq[IWL_CMD_QUEUE_NUM].cmd[cmd_idx];
		qcmd->meta.flags &= ~CMD_WANT_SKB;
	}
fail:
	if (cmd->meta.u.skb) {
		dev_kfree_skb_any(cmd->meta.u.skb);
		cmd->meta.u.skb = NULL;
	}
out:
	atomic_set(&entry, 0);
	return ret;
}

C
Christoph Hellwig 已提交
839
int iwl3945_send_cmd(struct iwl3945_priv *priv, struct iwl3945_host_cmd *cmd)
Z
Zhu Yi 已提交
840 841
{
	if (cmd->meta.flags & CMD_ASYNC)
C
Christoph Hellwig 已提交
842
		return iwl3945_send_cmd_async(priv, cmd);
Z
Zhu Yi 已提交
843

C
Christoph Hellwig 已提交
844
	return iwl3945_send_cmd_sync(priv, cmd);
Z
Zhu Yi 已提交
845 846
}

C
Christoph Hellwig 已提交
847
int iwl3945_send_cmd_pdu(struct iwl3945_priv *priv, u8 id, u16 len, const void *data)
Z
Zhu Yi 已提交
848
{
C
Christoph Hellwig 已提交
849
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
850 851 852 853 854
		.id = id,
		.len = len,
		.data = data,
	};

C
Christoph Hellwig 已提交
855
	return iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
856 857
}

C
Christoph Hellwig 已提交
858
static int __must_check iwl3945_send_cmd_u32(struct iwl3945_priv *priv, u8 id, u32 val)
Z
Zhu Yi 已提交
859
{
C
Christoph Hellwig 已提交
860
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
861 862 863 864 865
		.id = id,
		.len = sizeof(val),
		.data = &val,
	};

C
Christoph Hellwig 已提交
866
	return iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
867 868
}

C
Christoph Hellwig 已提交
869
int iwl3945_send_statistics_request(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
870
{
C
Christoph Hellwig 已提交
871
	return iwl3945_send_cmd_u32(priv, REPLY_STATISTICS_CMD, 0);
Z
Zhu Yi 已提交
872 873 874
}

/**
C
Christoph Hellwig 已提交
875
 * iwl3945_set_rxon_channel - Set the phymode and channel values in staging RXON
876 877
 * @band: 2.4 or 5 GHz band
 * @channel: Any channel valid for the requested band
Z
Zhu Yi 已提交
878

879
 * In addition to setting the staging RXON, priv->band is also set.
Z
Zhu Yi 已提交
880 881
 *
 * NOTE:  Does not commit to the hardware; it sets appropriate bit fields
882
 * in the staging RXON flag structure based on the band
Z
Zhu Yi 已提交
883
 */
884 885 886
static int iwl3945_set_rxon_channel(struct iwl3945_priv *priv,
				    enum ieee80211_band band,
				    u16 channel)
Z
Zhu Yi 已提交
887
{
888
	if (!iwl3945_get_channel_info(priv, band, channel)) {
Z
Zhu Yi 已提交
889
		IWL_DEBUG_INFO("Could not set channel to %d [%d]\n",
890
			       channel, band);
Z
Zhu Yi 已提交
891 892 893 894
		return -EINVAL;
	}

	if ((le16_to_cpu(priv->staging_rxon.channel) == channel) &&
895
	    (priv->band == band))
Z
Zhu Yi 已提交
896 897 898
		return 0;

	priv->staging_rxon.channel = cpu_to_le16(channel);
899
	if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
900 901 902 903
		priv->staging_rxon.flags &= ~RXON_FLG_BAND_24G_MSK;
	else
		priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;

904
	priv->band = band;
Z
Zhu Yi 已提交
905

906
	IWL_DEBUG_INFO("Staging channel set to %d [%d]\n", channel, band);
Z
Zhu Yi 已提交
907 908 909 910 911

	return 0;
}

/**
C
Christoph Hellwig 已提交
912
 * iwl3945_check_rxon_cmd - validate RXON structure is valid
Z
Zhu Yi 已提交
913 914 915 916 917
 *
 * NOTE:  This is really only useful during development and can eventually
 * be #ifdef'd out once the driver is stable and folks aren't actively
 * making changes
 */
C
Christoph Hellwig 已提交
918
static int iwl3945_check_rxon_cmd(struct iwl3945_rxon_cmd *rxon)
Z
Zhu Yi 已提交
919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983
{
	int error = 0;
	int counter = 1;

	if (rxon->flags & RXON_FLG_BAND_24G_MSK) {
		error |= le32_to_cpu(rxon->flags &
				(RXON_FLG_TGJ_NARROW_BAND_MSK |
				 RXON_FLG_RADAR_DETECT_MSK));
		if (error)
			IWL_WARNING("check 24G fields %d | %d\n",
				    counter++, error);
	} else {
		error |= (rxon->flags & RXON_FLG_SHORT_SLOT_MSK) ?
				0 : le32_to_cpu(RXON_FLG_SHORT_SLOT_MSK);
		if (error)
			IWL_WARNING("check 52 fields %d | %d\n",
				    counter++, error);
		error |= le32_to_cpu(rxon->flags & RXON_FLG_CCK_MSK);
		if (error)
			IWL_WARNING("check 52 CCK %d | %d\n",
				    counter++, error);
	}
	error |= (rxon->node_addr[0] | rxon->bssid_addr[0]) & 0x1;
	if (error)
		IWL_WARNING("check mac addr %d | %d\n", counter++, error);

	/* make sure basic rates 6Mbps and 1Mbps are supported */
	error |= (((rxon->ofdm_basic_rates & IWL_RATE_6M_MASK) == 0) &&
		  ((rxon->cck_basic_rates & IWL_RATE_1M_MASK) == 0));
	if (error)
		IWL_WARNING("check basic rate %d | %d\n", counter++, error);

	error |= (le16_to_cpu(rxon->assoc_id) > 2007);
	if (error)
		IWL_WARNING("check assoc id %d | %d\n", counter++, error);

	error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK))
			== (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK));
	if (error)
		IWL_WARNING("check CCK and short slot %d | %d\n",
			    counter++, error);

	error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK))
			== (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK));
	if (error)
		IWL_WARNING("check CCK & auto detect %d | %d\n",
			    counter++, error);

	error |= ((rxon->flags & (RXON_FLG_AUTO_DETECT_MSK |
			RXON_FLG_TGG_PROTECT_MSK)) == RXON_FLG_TGG_PROTECT_MSK);
	if (error)
		IWL_WARNING("check TGG and auto detect %d | %d\n",
			    counter++, error);

	if ((rxon->flags & RXON_FLG_DIS_DIV_MSK))
		error |= ((rxon->flags & (RXON_FLG_ANT_B_MSK |
				RXON_FLG_ANT_A_MSK)) == 0);
	if (error)
		IWL_WARNING("check antenna %d %d\n", counter++, error);

	if (error)
		IWL_WARNING("Tuning to channel %d\n",
			    le16_to_cpu(rxon->channel));

	if (error) {
C
Christoph Hellwig 已提交
984
		IWL_ERROR("Not a valid iwl3945_rxon_assoc_cmd field values\n");
Z
Zhu Yi 已提交
985 986 987 988 989 990
		return -1;
	}
	return 0;
}

/**
991
 * iwl3945_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
992
 * @priv: staging_rxon is compared to active_rxon
Z
Zhu Yi 已提交
993
 *
994 995 996
 * If the RXON structure is changing enough to require a new tune,
 * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
 * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
Z
Zhu Yi 已提交
997
 */
C
Christoph Hellwig 已提交
998
static int iwl3945_full_rxon_required(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
{

	/* These items are only settable from the full RXON command */
	if (!(priv->active_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) ||
	    compare_ether_addr(priv->staging_rxon.bssid_addr,
			       priv->active_rxon.bssid_addr) ||
	    compare_ether_addr(priv->staging_rxon.node_addr,
			       priv->active_rxon.node_addr) ||
	    compare_ether_addr(priv->staging_rxon.wlap_bssid_addr,
			       priv->active_rxon.wlap_bssid_addr) ||
	    (priv->staging_rxon.dev_type != priv->active_rxon.dev_type) ||
	    (priv->staging_rxon.channel != priv->active_rxon.channel) ||
	    (priv->staging_rxon.air_propagation !=
	     priv->active_rxon.air_propagation) ||
	    (priv->staging_rxon.assoc_id != priv->active_rxon.assoc_id))
		return 1;

	/* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
	 * be updated with the RXON_ASSOC command -- however only some
	 * flag transitions are allowed using RXON_ASSOC */

	/* Check if we are not switching bands */
	if ((priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) !=
	    (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK))
		return 1;

	/* Check if we are switching association toggle */
	if ((priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) !=
		(priv->active_rxon.filter_flags & RXON_FILTER_ASSOC_MSK))
		return 1;

	return 0;
}

C
Christoph Hellwig 已提交
1033
static int iwl3945_send_rxon_assoc(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1034 1035
{
	int rc = 0;
C
Christoph Hellwig 已提交
1036 1037 1038
	struct iwl3945_rx_packet *res = NULL;
	struct iwl3945_rxon_assoc_cmd rxon_assoc;
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
1039 1040 1041 1042 1043
		.id = REPLY_RXON_ASSOC,
		.len = sizeof(rxon_assoc),
		.meta.flags = CMD_WANT_SKB,
		.data = &rxon_assoc,
	};
C
Christoph Hellwig 已提交
1044 1045
	const struct iwl3945_rxon_cmd *rxon1 = &priv->staging_rxon;
	const struct iwl3945_rxon_cmd *rxon2 = &priv->active_rxon;
Z
Zhu Yi 已提交
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060

	if ((rxon1->flags == rxon2->flags) &&
	    (rxon1->filter_flags == rxon2->filter_flags) &&
	    (rxon1->cck_basic_rates == rxon2->cck_basic_rates) &&
	    (rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) {
		IWL_DEBUG_INFO("Using current RXON_ASSOC.  Not resending.\n");
		return 0;
	}

	rxon_assoc.flags = priv->staging_rxon.flags;
	rxon_assoc.filter_flags = priv->staging_rxon.filter_flags;
	rxon_assoc.ofdm_basic_rates = priv->staging_rxon.ofdm_basic_rates;
	rxon_assoc.cck_basic_rates = priv->staging_rxon.cck_basic_rates;
	rxon_assoc.reserved = 0;

C
Christoph Hellwig 已提交
1061
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
1062 1063 1064
	if (rc)
		return rc;

C
Christoph Hellwig 已提交
1065
	res = (struct iwl3945_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
		IWL_ERROR("Bad return from REPLY_RXON_ASSOC command\n");
		rc = -EIO;
	}

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

	return rc;
}

/**
C
Christoph Hellwig 已提交
1078
 * iwl3945_commit_rxon - commit staging_rxon to hardware
Z
Zhu Yi 已提交
1079
 *
1080
 * The RXON command in staging_rxon is committed to the hardware and
Z
Zhu Yi 已提交
1081 1082 1083 1084
 * the active_rxon structure is updated with the new data.  This
 * function correctly transitions out of the RXON_ASSOC_MSK state if
 * a HW tune is required based on the RXON structure changes.
 */
C
Christoph Hellwig 已提交
1085
static int iwl3945_commit_rxon(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1086 1087
{
	/* cast away the const for active_rxon in this function */
C
Christoph Hellwig 已提交
1088
	struct iwl3945_rxon_cmd *active_rxon = (void *)&priv->active_rxon;
Z
Zhu Yi 已提交
1089
	int rc = 0;
1090
	DECLARE_MAC_BUF(mac);
Z
Zhu Yi 已提交
1091

C
Christoph Hellwig 已提交
1092
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
		return -1;

	/* always get timestamp with Rx frame */
	priv->staging_rxon.flags |= RXON_FLG_TSF2HOST_MSK;

	/* select antenna */
	priv->staging_rxon.flags &=
	    ~(RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_SEL_MSK);
	priv->staging_rxon.flags |= iwl3945_get_antenna_flags(priv);

C
Christoph Hellwig 已提交
1103
	rc = iwl3945_check_rxon_cmd(&priv->staging_rxon);
Z
Zhu Yi 已提交
1104 1105 1106 1107 1108 1109
	if (rc) {
		IWL_ERROR("Invalid RXON configuration.  Not committing.\n");
		return -EINVAL;
	}

	/* If we don't need to send a full RXON, we can use
C
Christoph Hellwig 已提交
1110
	 * iwl3945_rxon_assoc_cmd which is used to reconfigure filter
Z
Zhu Yi 已提交
1111
	 * and other flags for the current radio configuration. */
C
Christoph Hellwig 已提交
1112 1113
	if (!iwl3945_full_rxon_required(priv)) {
		rc = iwl3945_send_rxon_assoc(priv);
Z
Zhu Yi 已提交
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
		if (rc) {
			IWL_ERROR("Error setting RXON_ASSOC "
				  "configuration (%d).\n", rc);
			return rc;
		}

		memcpy(active_rxon, &priv->staging_rxon, sizeof(*active_rxon));

		return 0;
	}

	/* If we are currently associated and the new config requires
	 * an RXON_ASSOC and the new config wants the associated mask enabled,
	 * we must clear the associated from the active configuration
	 * before we apply the new config */
C
Christoph Hellwig 已提交
1129
	if (iwl3945_is_associated(priv) &&
Z
Zhu Yi 已提交
1130 1131 1132 1133
	    (priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK)) {
		IWL_DEBUG_INFO("Toggling associated bit on current RXON\n");
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;

C
Christoph Hellwig 已提交
1134 1135
		rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON,
				      sizeof(struct iwl3945_rxon_cmd),
Z
Zhu Yi 已提交
1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
				      &priv->active_rxon);

		/* If the mask clearing failed then we set
		 * active_rxon back to what it was previously */
		if (rc) {
			active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
			IWL_ERROR("Error clearing ASSOC_MSK on current "
				  "configuration (%d).\n", rc);
			return rc;
		}
	}

	IWL_DEBUG_INFO("Sending RXON\n"
		       "* with%s RXON_FILTER_ASSOC_MSK\n"
		       "* channel = %d\n"
1151
		       "* bssid = %s\n",
Z
Zhu Yi 已提交
1152 1153 1154
		       ((priv->staging_rxon.filter_flags &
			 RXON_FILTER_ASSOC_MSK) ? "" : "out"),
		       le16_to_cpu(priv->staging_rxon.channel),
1155
		       print_mac(mac, priv->staging_rxon.bssid_addr));
Z
Zhu Yi 已提交
1156 1157

	/* Apply the new configuration */
C
Christoph Hellwig 已提交
1158 1159
	rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON,
			      sizeof(struct iwl3945_rxon_cmd), &priv->staging_rxon);
Z
Zhu Yi 已提交
1160 1161 1162 1163 1164 1165 1166
	if (rc) {
		IWL_ERROR("Error setting new configuration (%d).\n", rc);
		return rc;
	}

	memcpy(active_rxon, &priv->staging_rxon, sizeof(*active_rxon));

C
Christoph Hellwig 已提交
1167
	iwl3945_clear_stations_table(priv);
1168

Z
Zhu Yi 已提交
1169 1170
	/* If we issue a new RXON command which required a tune then we must
	 * send a new TXPOWER command or we won't be able to Tx any frames */
C
Christoph Hellwig 已提交
1171
	rc = iwl3945_hw_reg_send_txpower(priv);
Z
Zhu Yi 已提交
1172 1173 1174 1175 1176 1177
	if (rc) {
		IWL_ERROR("Error setting Tx power (%d).\n", rc);
		return rc;
	}

	/* Add the broadcast address so we can send broadcast frames */
C
Christoph Hellwig 已提交
1178
	if (iwl3945_add_station(priv, iwl3945_broadcast_addr, 0, 0) ==
Z
Zhu Yi 已提交
1179 1180 1181 1182 1183 1184 1185
	    IWL_INVALID_STATION) {
		IWL_ERROR("Error adding BROADCAST address for transmit.\n");
		return -EIO;
	}

	/* If we have set the ASSOC_MSK and we are in BSS mode then
	 * add the IWL_AP_ID to the station rate table */
C
Christoph Hellwig 已提交
1186
	if (iwl3945_is_associated(priv) &&
Z
Zhu Yi 已提交
1187
	    (priv->iw_mode == IEEE80211_IF_TYPE_STA))
C
Christoph Hellwig 已提交
1188
		if (iwl3945_add_station(priv, priv->active_rxon.bssid_addr, 1, 0)
Z
Zhu Yi 已提交
1189 1190 1191 1192 1193
		    == IWL_INVALID_STATION) {
			IWL_ERROR("Error adding AP address for transmit.\n");
			return -EIO;
		}

1194
	/* Init the hardware's rate fallback order based on the band */
Z
Zhu Yi 已提交
1195 1196 1197 1198 1199 1200 1201 1202 1203
	rc = iwl3945_init_hw_rate_table(priv);
	if (rc) {
		IWL_ERROR("Error setting HW rate table: %02X\n", rc);
		return -EIO;
	}

	return 0;
}

C
Christoph Hellwig 已提交
1204
static int iwl3945_send_bt_config(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1205
{
C
Christoph Hellwig 已提交
1206
	struct iwl3945_bt_cmd bt_cmd = {
Z
Zhu Yi 已提交
1207 1208 1209 1210 1211 1212 1213
		.flags = 3,
		.lead_time = 0xAA,
		.max_kill = 1,
		.kill_ack_mask = 0,
		.kill_cts_mask = 0,
	};

C
Christoph Hellwig 已提交
1214 1215
	return iwl3945_send_cmd_pdu(priv, REPLY_BT_CONFIG,
				sizeof(struct iwl3945_bt_cmd), &bt_cmd);
Z
Zhu Yi 已提交
1216 1217
}

C
Christoph Hellwig 已提交
1218
static int iwl3945_send_scan_abort(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1219 1220
{
	int rc = 0;
C
Christoph Hellwig 已提交
1221 1222
	struct iwl3945_rx_packet *res;
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
		.id = REPLY_SCAN_ABORT_CMD,
		.meta.flags = CMD_WANT_SKB,
	};

	/* If there isn't a scan actively going on in the hardware
	 * then we are in between scan bands and not actually
	 * actively scanning, so don't send the abort command */
	if (!test_bit(STATUS_SCAN_HW, &priv->status)) {
		clear_bit(STATUS_SCAN_ABORTING, &priv->status);
		return 0;
	}

C
Christoph Hellwig 已提交
1235
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
1236 1237 1238 1239 1240
	if (rc) {
		clear_bit(STATUS_SCAN_ABORTING, &priv->status);
		return rc;
	}

C
Christoph Hellwig 已提交
1241
	res = (struct iwl3945_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
	if (res->u.status != CAN_ABORT_STATUS) {
		/* The scan abort will return 1 for success or
		 * 2 for "failure".  A failure condition can be
		 * due to simply not being in an active scan which
		 * can occur if we send the scan abort before we
		 * the microcode has notified us that a scan is
		 * completed. */
		IWL_DEBUG_INFO("SCAN_ABORT returned %d.\n", res->u.status);
		clear_bit(STATUS_SCAN_ABORTING, &priv->status);
		clear_bit(STATUS_SCAN_HW, &priv->status);
	}

	dev_kfree_skb_any(cmd.meta.u.skb);

	return rc;
}

C
Christoph Hellwig 已提交
1259 1260
static int iwl3945_card_state_sync_callback(struct iwl3945_priv *priv,
					struct iwl3945_cmd *cmd,
Z
Zhu Yi 已提交
1261 1262 1263 1264 1265 1266 1267 1268
					struct sk_buff *skb)
{
	return 1;
}

/*
 * CARD_STATE_CMD
 *
1269
 * Use: Sets the device's internal card state to enable, disable, or halt
Z
Zhu Yi 已提交
1270 1271 1272 1273 1274 1275
 *
 * When in the 'enable' state the card operates as normal.
 * When in the 'disable' state, the card enters into a low power mode.
 * When in the 'halt' state, the card is shut down and must be fully
 * restarted to come back on.
 */
C
Christoph Hellwig 已提交
1276
static int iwl3945_send_card_state(struct iwl3945_priv *priv, u32 flags, u8 meta_flag)
Z
Zhu Yi 已提交
1277
{
C
Christoph Hellwig 已提交
1278
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
1279 1280 1281 1282 1283 1284 1285
		.id = REPLY_CARD_STATE_CMD,
		.len = sizeof(u32),
		.data = &flags,
		.meta.flags = meta_flag,
	};

	if (meta_flag & CMD_ASYNC)
C
Christoph Hellwig 已提交
1286
		cmd.meta.u.callback = iwl3945_card_state_sync_callback;
Z
Zhu Yi 已提交
1287

C
Christoph Hellwig 已提交
1288
	return iwl3945_send_cmd(priv, &cmd);
Z
Zhu Yi 已提交
1289 1290
}

C
Christoph Hellwig 已提交
1291 1292
static int iwl3945_add_sta_sync_callback(struct iwl3945_priv *priv,
				     struct iwl3945_cmd *cmd, struct sk_buff *skb)
Z
Zhu Yi 已提交
1293
{
C
Christoph Hellwig 已提交
1294
	struct iwl3945_rx_packet *res = NULL;
Z
Zhu Yi 已提交
1295 1296 1297 1298 1299 1300

	if (!skb) {
		IWL_ERROR("Error: Response NULL in REPLY_ADD_STA.\n");
		return 1;
	}

C
Christoph Hellwig 已提交
1301
	res = (struct iwl3945_rx_packet *)skb->data;
Z
Zhu Yi 已提交
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
		IWL_ERROR("Bad return from REPLY_ADD_STA (0x%08X)\n",
			  res->hdr.flags);
		return 1;
	}

	switch (res->u.add_sta.status) {
	case ADD_STA_SUCCESS_MSK:
		break;
	default:
		break;
	}

	/* We didn't cache the SKB; let the caller free it */
	return 1;
}

C
Christoph Hellwig 已提交
1319 1320
int iwl3945_send_add_station(struct iwl3945_priv *priv,
			 struct iwl3945_addsta_cmd *sta, u8 flags)
Z
Zhu Yi 已提交
1321
{
C
Christoph Hellwig 已提交
1322
	struct iwl3945_rx_packet *res = NULL;
Z
Zhu Yi 已提交
1323
	int rc = 0;
C
Christoph Hellwig 已提交
1324
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
1325
		.id = REPLY_ADD_STA,
C
Christoph Hellwig 已提交
1326
		.len = sizeof(struct iwl3945_addsta_cmd),
Z
Zhu Yi 已提交
1327 1328 1329 1330 1331
		.meta.flags = flags,
		.data = sta,
	};

	if (flags & CMD_ASYNC)
C
Christoph Hellwig 已提交
1332
		cmd.meta.u.callback = iwl3945_add_sta_sync_callback;
Z
Zhu Yi 已提交
1333 1334 1335
	else
		cmd.meta.flags |= CMD_WANT_SKB;

C
Christoph Hellwig 已提交
1336
	rc = iwl3945_send_cmd(priv, &cmd);
Z
Zhu Yi 已提交
1337 1338 1339 1340

	if (rc || (flags & CMD_ASYNC))
		return rc;

C
Christoph Hellwig 已提交
1341
	res = (struct iwl3945_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
		IWL_ERROR("Bad return from REPLY_ADD_STA (0x%08X)\n",
			  res->hdr.flags);
		rc = -EIO;
	}

	if (rc == 0) {
		switch (res->u.add_sta.status) {
		case ADD_STA_SUCCESS_MSK:
			IWL_DEBUG_INFO("REPLY_ADD_STA PASSED\n");
			break;
		default:
			rc = -EIO;
			IWL_WARNING("REPLY_ADD_STA failed\n");
			break;
		}
	}

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

	return rc;
}

C
Christoph Hellwig 已提交
1366
static int iwl3945_update_sta_key_info(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
				   struct ieee80211_key_conf *keyconf,
				   u8 sta_id)
{
	unsigned long flags;
	__le16 key_flags = 0;

	switch (keyconf->alg) {
	case ALG_CCMP:
		key_flags |= STA_KEY_FLG_CCMP;
		key_flags |= cpu_to_le16(
				keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
		key_flags &= ~STA_KEY_FLG_INVALID;
		break;
	case ALG_TKIP:
	case ALG_WEP:
	default:
		return -EINVAL;
	}
	spin_lock_irqsave(&priv->sta_lock, flags);
	priv->stations[sta_id].keyinfo.alg = keyconf->alg;
	priv->stations[sta_id].keyinfo.keylen = keyconf->keylen;
	memcpy(priv->stations[sta_id].keyinfo.key, keyconf->key,
	       keyconf->keylen);

	memcpy(priv->stations[sta_id].sta.key.key, keyconf->key,
	       keyconf->keylen);
	priv->stations[sta_id].sta.key.key_flags = key_flags;
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;

	spin_unlock_irqrestore(&priv->sta_lock, flags);

	IWL_DEBUG_INFO("hwcrypto: modify ucode station key info\n");
C
Christoph Hellwig 已提交
1400
	iwl3945_send_add_station(priv, &priv->stations[sta_id].sta, 0);
Z
Zhu Yi 已提交
1401 1402 1403
	return 0;
}

C
Christoph Hellwig 已提交
1404
static int iwl3945_clear_sta_key_info(struct iwl3945_priv *priv, u8 sta_id)
Z
Zhu Yi 已提交
1405 1406 1407 1408
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);
C
Christoph Hellwig 已提交
1409 1410
	memset(&priv->stations[sta_id].keyinfo, 0, sizeof(struct iwl3945_hw_key));
	memset(&priv->stations[sta_id].sta.key, 0, sizeof(struct iwl3945_keyinfo));
Z
Zhu Yi 已提交
1411 1412 1413 1414 1415 1416
	priv->stations[sta_id].sta.key.key_flags = STA_KEY_FLG_NO_ENC;
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
	spin_unlock_irqrestore(&priv->sta_lock, flags);

	IWL_DEBUG_INFO("hwcrypto: clear ucode station key info\n");
C
Christoph Hellwig 已提交
1417
	iwl3945_send_add_station(priv, &priv->stations[sta_id].sta, 0);
Z
Zhu Yi 已提交
1418 1419 1420
	return 0;
}

C
Christoph Hellwig 已提交
1421
static void iwl3945_clear_free_frames(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1422 1423 1424 1425 1426 1427 1428 1429 1430
{
	struct list_head *element;

	IWL_DEBUG_INFO("%d frames on pre-allocated heap on clear.\n",
		       priv->frames_count);

	while (!list_empty(&priv->free_frames)) {
		element = priv->free_frames.next;
		list_del(element);
C
Christoph Hellwig 已提交
1431
		kfree(list_entry(element, struct iwl3945_frame, list));
Z
Zhu Yi 已提交
1432 1433 1434 1435 1436 1437 1438 1439 1440 1441
		priv->frames_count--;
	}

	if (priv->frames_count) {
		IWL_WARNING("%d frames still in use.  Did we lose one?\n",
			    priv->frames_count);
		priv->frames_count = 0;
	}
}

C
Christoph Hellwig 已提交
1442
static struct iwl3945_frame *iwl3945_get_free_frame(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1443
{
C
Christoph Hellwig 已提交
1444
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458
	struct list_head *element;
	if (list_empty(&priv->free_frames)) {
		frame = kzalloc(sizeof(*frame), GFP_KERNEL);
		if (!frame) {
			IWL_ERROR("Could not allocate frame!\n");
			return NULL;
		}

		priv->frames_count++;
		return frame;
	}

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

C
Christoph Hellwig 已提交
1462
static void iwl3945_free_frame(struct iwl3945_priv *priv, struct iwl3945_frame *frame)
Z
Zhu Yi 已提交
1463 1464 1465 1466 1467
{
	memset(frame, 0, sizeof(*frame));
	list_add(&frame->list, &priv->free_frames);
}

C
Christoph Hellwig 已提交
1468
unsigned int iwl3945_fill_beacon_frame(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
1469 1470 1471 1472
				struct ieee80211_hdr *hdr,
				const u8 *dest, int left)
{

C
Christoph Hellwig 已提交
1473
	if (!iwl3945_is_associated(priv) || !priv->ibss_beacon ||
Z
Zhu Yi 已提交
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
	    ((priv->iw_mode != IEEE80211_IF_TYPE_IBSS) &&
	     (priv->iw_mode != IEEE80211_IF_TYPE_AP)))
		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;
}

C
Christoph Hellwig 已提交
1486
static u8 iwl3945_rate_get_lowest_plcp(int rate_mask)
Z
Zhu Yi 已提交
1487 1488 1489 1490
{
	u8 i;

	for (i = IWL_RATE_1M_INDEX; i != IWL_RATE_INVALID;
C
Christoph Hellwig 已提交
1491
	     i = iwl3945_rates[i].next_ieee) {
Z
Zhu Yi 已提交
1492
		if (rate_mask & (1 << i))
C
Christoph Hellwig 已提交
1493
			return iwl3945_rates[i].plcp;
Z
Zhu Yi 已提交
1494 1495 1496 1497 1498
	}

	return IWL_RATE_INVALID;
}

C
Christoph Hellwig 已提交
1499
static int iwl3945_send_beacon_cmd(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1500
{
C
Christoph Hellwig 已提交
1501
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
1502 1503 1504 1505
	unsigned int frame_size;
	int rc;
	u8 rate;

C
Christoph Hellwig 已提交
1506
	frame = iwl3945_get_free_frame(priv);
Z
Zhu Yi 已提交
1507 1508 1509 1510 1511 1512 1513 1514

	if (!frame) {
		IWL_ERROR("Could not obtain free frame buffer for beacon "
			  "command.\n");
		return -ENOMEM;
	}

	if (!(priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)) {
C
Christoph Hellwig 已提交
1515
		rate = iwl3945_rate_get_lowest_plcp(priv->active_rate_basic &
Z
Zhu Yi 已提交
1516 1517 1518 1519
						0xFF0);
		if (rate == IWL_INVALID_RATE)
			rate = IWL_RATE_6M_PLCP;
	} else {
C
Christoph Hellwig 已提交
1520
		rate = iwl3945_rate_get_lowest_plcp(priv->active_rate_basic & 0xF);
Z
Zhu Yi 已提交
1521 1522 1523 1524
		if (rate == IWL_INVALID_RATE)
			rate = IWL_RATE_1M_PLCP;
	}

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

C
Christoph Hellwig 已提交
1527
	rc = iwl3945_send_cmd_pdu(priv, REPLY_TX_BEACON, frame_size,
Z
Zhu Yi 已提交
1528 1529
			      &frame->u.cmd[0]);

C
Christoph Hellwig 已提交
1530
	iwl3945_free_frame(priv, frame);
Z
Zhu Yi 已提交
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540

	return rc;
}

/******************************************************************************
 *
 * EEPROM related functions
 *
 ******************************************************************************/

C
Christoph Hellwig 已提交
1541
static void get_eeprom_mac(struct iwl3945_priv *priv, u8 *mac)
Z
Zhu Yi 已提交
1542 1543 1544 1545
{
	memcpy(mac, priv->eeprom.mac_address, 6);
}

1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559
/*
 * Clear the OWNER_MSK, to establish driver (instead of uCode running on
 * embedded controller) as EEPROM reader; each read is a series of pulses
 * to/from the EEPROM chip, not a single event, so even reads could conflict
 * if they weren't arbitrated by some ownership mechanism.  Here, the driver
 * simply claims ownership, which should be safe when this function is called
 * (i.e. before loading uCode!).
 */
static inline int iwl3945_eeprom_acquire_semaphore(struct iwl3945_priv *priv)
{
	_iwl3945_clear_bit(priv, CSR_EEPROM_GP, CSR_EEPROM_GP_IF_OWNER_MSK);
	return 0;
}

Z
Zhu Yi 已提交
1560
/**
C
Christoph Hellwig 已提交
1561
 * iwl3945_eeprom_init - read EEPROM contents
Z
Zhu Yi 已提交
1562
 *
1563
 * Load the EEPROM contents from adapter into priv->eeprom
Z
Zhu Yi 已提交
1564 1565 1566
 *
 * NOTE:  This routine uses the non-debug IO access functions.
 */
C
Christoph Hellwig 已提交
1567
int iwl3945_eeprom_init(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1568
{
1569
	u16 *e = (u16 *)&priv->eeprom;
C
Christoph Hellwig 已提交
1570
	u32 gp = iwl3945_read32(priv, CSR_EEPROM_GP);
Z
Zhu Yi 已提交
1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587
	u32 r;
	int sz = sizeof(priv->eeprom);
	int rc;
	int i;
	u16 addr;

	/* The EEPROM structure has several padding buffers within it
	 * and when adding new EEPROM maps is subject to programmer errors
	 * which may be very difficult to identify without explicitly
	 * checking the resulting size of the eeprom map. */
	BUILD_BUG_ON(sizeof(priv->eeprom) != IWL_EEPROM_IMAGE_SIZE);

	if ((gp & CSR_EEPROM_GP_VALID_MSK) == CSR_EEPROM_GP_BAD_SIGNATURE) {
		IWL_ERROR("EEPROM not found, EEPROM_GP=0x%08x", gp);
		return -ENOENT;
	}

1588
	/* Make sure driver (instead of uCode) is allowed to read EEPROM */
C
Christoph Hellwig 已提交
1589
	rc = iwl3945_eeprom_acquire_semaphore(priv);
Z
Zhu Yi 已提交
1590
	if (rc < 0) {
1591
		IWL_ERROR("Failed to acquire EEPROM semaphore.\n");
Z
Zhu Yi 已提交
1592 1593 1594 1595 1596
		return -ENOENT;
	}

	/* eeprom is an array of 16bit values */
	for (addr = 0; addr < sz; addr += sizeof(u16)) {
C
Christoph Hellwig 已提交
1597 1598
		_iwl3945_write32(priv, CSR_EEPROM_REG, addr << 1);
		_iwl3945_clear_bit(priv, CSR_EEPROM_REG, CSR_EEPROM_REG_BIT_CMD);
Z
Zhu Yi 已提交
1599 1600 1601

		for (i = 0; i < IWL_EEPROM_ACCESS_TIMEOUT;
					i += IWL_EEPROM_ACCESS_DELAY) {
C
Christoph Hellwig 已提交
1602
			r = _iwl3945_read_direct32(priv, CSR_EEPROM_REG);
Z
Zhu Yi 已提交
1603 1604 1605 1606 1607 1608 1609 1610 1611
			if (r & CSR_EEPROM_REG_READ_VALID_MSK)
				break;
			udelay(IWL_EEPROM_ACCESS_DELAY);
		}

		if (!(r & CSR_EEPROM_REG_READ_VALID_MSK)) {
			IWL_ERROR("Time out reading EEPROM[%d]", addr);
			return -ETIMEDOUT;
		}
1612
		e[addr / 2] = le16_to_cpu((__force __le16)(r >> 16));
Z
Zhu Yi 已提交
1613 1614 1615 1616 1617
	}

	return 0;
}

C
Christoph Hellwig 已提交
1618
static void iwl3945_unset_hw_setting(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1619 1620 1621
{
	if (priv->hw_setting.shared_virt)
		pci_free_consistent(priv->pci_dev,
C
Christoph Hellwig 已提交
1622
				    sizeof(struct iwl3945_shared),
Z
Zhu Yi 已提交
1623 1624 1625 1626 1627
				    priv->hw_setting.shared_virt,
				    priv->hw_setting.shared_phys);
}

/**
C
Christoph Hellwig 已提交
1628
 * iwl3945_supported_rate_to_ie - fill in the supported rate in IE field
Z
Zhu Yi 已提交
1629 1630 1631
 *
 * return : set the bit for each supported rate insert in ie
 */
C
Christoph Hellwig 已提交
1632
static u16 iwl3945_supported_rate_to_ie(u8 *ie, u16 supported_rate,
1633
				    u16 basic_rate, int *left)
Z
Zhu Yi 已提交
1634 1635 1636
{
	u16 ret_rates = 0, bit;
	int i;
1637 1638
	u8 *cnt = ie;
	u8 *rates = ie + 1;
Z
Zhu Yi 已提交
1639 1640 1641 1642

	for (bit = 1, i = 0; i < IWL_RATE_COUNT; i++, bit <<= 1) {
		if (bit & supported_rate) {
			ret_rates |= bit;
C
Christoph Hellwig 已提交
1643
			rates[*cnt] = iwl3945_rates[i].ieee |
1644 1645 1646 1647 1648
				((bit & basic_rate) ? 0x80 : 0x00);
			(*cnt)++;
			(*left)--;
			if ((*left <= 0) ||
			    (*cnt >= IWL_SUPPORTED_RATES_IE_LEN))
Z
Zhu Yi 已提交
1649 1650 1651 1652 1653 1654 1655 1656
				break;
		}
	}

	return ret_rates;
}

/**
C
Christoph Hellwig 已提交
1657
 * iwl3945_fill_probe_req - fill in all required fields and IE for probe request
Z
Zhu Yi 已提交
1658
 */
C
Christoph Hellwig 已提交
1659
static u16 iwl3945_fill_probe_req(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
1660 1661 1662 1663 1664
			      struct ieee80211_mgmt *frame,
			      int left, int is_direct)
{
	int len = 0;
	u8 *pos = NULL;
1665
	u16 active_rates, ret_rates, cck_rates;
Z
Zhu Yi 已提交
1666 1667 1668 1669 1670 1671 1672 1673 1674

	/* Make sure there is enough space for the probe request,
	 * two mandatory IEs and the data */
	left -= 24;
	if (left < 0)
		return 0;
	len += 24;

	frame->frame_control = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ);
C
Christoph Hellwig 已提交
1675
	memcpy(frame->da, iwl3945_broadcast_addr, ETH_ALEN);
Z
Zhu Yi 已提交
1676
	memcpy(frame->sa, priv->mac_addr, ETH_ALEN);
C
Christoph Hellwig 已提交
1677
	memcpy(frame->bssid, iwl3945_broadcast_addr, ETH_ALEN);
Z
Zhu Yi 已提交
1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709
	frame->seq_ctrl = 0;

	/* fill in our indirect SSID IE */
	/* ...next IE... */

	left -= 2;
	if (left < 0)
		return 0;
	len += 2;
	pos = &(frame->u.probe_req.variable[0]);
	*pos++ = WLAN_EID_SSID;
	*pos++ = 0;

	/* fill in our direct SSID IE... */
	if (is_direct) {
		/* ...next IE... */
		left -= 2 + priv->essid_len;
		if (left < 0)
			return 0;
		/* ... fill it in... */
		*pos++ = WLAN_EID_SSID;
		*pos++ = priv->essid_len;
		memcpy(pos, priv->essid, priv->essid_len);
		pos += priv->essid_len;
		len += 2 + priv->essid_len;
	}

	/* fill in supported rate */
	/* ...next IE... */
	left -= 2;
	if (left < 0)
		return 0;
1710

Z
Zhu Yi 已提交
1711 1712 1713
	/* ... fill it in... */
	*pos++ = WLAN_EID_SUPP_RATES;
	*pos = 0;
1714 1715 1716

	priv->active_rate = priv->rates_mask;
	active_rates = priv->active_rate;
Z
Zhu Yi 已提交
1717 1718
	priv->active_rate_basic = priv->rates_mask & IWL_BASIC_RATES_MASK;

1719
	cck_rates = IWL_CCK_RATES_MASK & active_rates;
C
Christoph Hellwig 已提交
1720
	ret_rates = iwl3945_supported_rate_to_ie(pos, cck_rates,
1721 1722 1723
			priv->active_rate_basic, &left);
	active_rates &= ~ret_rates;

C
Christoph Hellwig 已提交
1724
	ret_rates = iwl3945_supported_rate_to_ie(pos, active_rates,
1725 1726 1727
				 priv->active_rate_basic, &left);
	active_rates &= ~ret_rates;

Z
Zhu Yi 已提交
1728 1729
	len += 2 + *pos;
	pos += (*pos) + 1;
1730
	if (active_rates == 0)
Z
Zhu Yi 已提交
1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
		goto fill_end;

	/* fill in supported extended rate */
	/* ...next IE... */
	left -= 2;
	if (left < 0)
		return 0;
	/* ... fill it in... */
	*pos++ = WLAN_EID_EXT_SUPP_RATES;
	*pos = 0;
C
Christoph Hellwig 已提交
1741
	iwl3945_supported_rate_to_ie(pos, active_rates,
1742
				 priv->active_rate_basic, &left);
Z
Zhu Yi 已提交
1743 1744 1745 1746 1747 1748 1749 1750 1751 1752
	if (*pos > 0)
		len += 2 + *pos;

 fill_end:
	return (u16)len;
}

/*
 * QoS  support
*/
C
Christoph Hellwig 已提交
1753 1754
static int iwl3945_send_qos_params_command(struct iwl3945_priv *priv,
				       struct iwl3945_qosparam_cmd *qos)
Z
Zhu Yi 已提交
1755 1756
{

C
Christoph Hellwig 已提交
1757 1758
	return iwl3945_send_cmd_pdu(priv, REPLY_QOS_PARAM,
				sizeof(struct iwl3945_qosparam_cmd), qos);
Z
Zhu Yi 已提交
1759 1760
}

C
Christoph Hellwig 已提交
1761
static void iwl3945_reset_qos(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847
{
	u16 cw_min = 15;
	u16 cw_max = 1023;
	u8 aifs = 2;
	u8 is_legacy = 0;
	unsigned long flags;
	int i;

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

	if (priv->iw_mode == IEEE80211_IF_TYPE_IBSS) {
		if (priv->qos_data.qos_enable)
			priv->qos_data.qos_active = 1;
		if (!(priv->active_rate & 0xfff0)) {
			cw_min = 31;
			is_legacy = 1;
		}
	} else if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
		if (priv->qos_data.qos_enable)
			priv->qos_data.qos_active = 1;
	} else if (!(priv->staging_rxon.flags & RXON_FLG_SHORT_SLOT_MSK)) {
		cw_min = 31;
		is_legacy = 1;
	}

	if (priv->qos_data.qos_active)
		aifs = 3;

	priv->qos_data.def_qos_parm.ac[0].cw_min = cpu_to_le16(cw_min);
	priv->qos_data.def_qos_parm.ac[0].cw_max = cpu_to_le16(cw_max);
	priv->qos_data.def_qos_parm.ac[0].aifsn = aifs;
	priv->qos_data.def_qos_parm.ac[0].edca_txop = 0;
	priv->qos_data.def_qos_parm.ac[0].reserved1 = 0;

	if (priv->qos_data.qos_active) {
		i = 1;
		priv->qos_data.def_qos_parm.ac[i].cw_min = cpu_to_le16(cw_min);
		priv->qos_data.def_qos_parm.ac[i].cw_max = cpu_to_le16(cw_max);
		priv->qos_data.def_qos_parm.ac[i].aifsn = 7;
		priv->qos_data.def_qos_parm.ac[i].edca_txop = 0;
		priv->qos_data.def_qos_parm.ac[i].reserved1 = 0;

		i = 2;
		priv->qos_data.def_qos_parm.ac[i].cw_min =
			cpu_to_le16((cw_min + 1) / 2 - 1);
		priv->qos_data.def_qos_parm.ac[i].cw_max =
			cpu_to_le16(cw_max);
		priv->qos_data.def_qos_parm.ac[i].aifsn = 2;
		if (is_legacy)
			priv->qos_data.def_qos_parm.ac[i].edca_txop =
				cpu_to_le16(6016);
		else
			priv->qos_data.def_qos_parm.ac[i].edca_txop =
				cpu_to_le16(3008);
		priv->qos_data.def_qos_parm.ac[i].reserved1 = 0;

		i = 3;
		priv->qos_data.def_qos_parm.ac[i].cw_min =
			cpu_to_le16((cw_min + 1) / 4 - 1);
		priv->qos_data.def_qos_parm.ac[i].cw_max =
			cpu_to_le16((cw_max + 1) / 2 - 1);
		priv->qos_data.def_qos_parm.ac[i].aifsn = 2;
		priv->qos_data.def_qos_parm.ac[i].reserved1 = 0;
		if (is_legacy)
			priv->qos_data.def_qos_parm.ac[i].edca_txop =
				cpu_to_le16(3264);
		else
			priv->qos_data.def_qos_parm.ac[i].edca_txop =
				cpu_to_le16(1504);
	} else {
		for (i = 1; i < 4; i++) {
			priv->qos_data.def_qos_parm.ac[i].cw_min =
				cpu_to_le16(cw_min);
			priv->qos_data.def_qos_parm.ac[i].cw_max =
				cpu_to_le16(cw_max);
			priv->qos_data.def_qos_parm.ac[i].aifsn = aifs;
			priv->qos_data.def_qos_parm.ac[i].edca_txop = 0;
			priv->qos_data.def_qos_parm.ac[i].reserved1 = 0;
		}
	}
	IWL_DEBUG_QOS("set QoS to default \n");

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

C
Christoph Hellwig 已提交
1848
static void iwl3945_activate_qos(struct iwl3945_priv *priv, u8 force)
Z
Zhu Yi 已提交
1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871
{
	unsigned long flags;

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

	if (!priv->qos_data.qos_enable)
		return;

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

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

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

	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
1872
	if (force || iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
1873 1874 1875
		IWL_DEBUG_QOS("send QoS cmd with Qos active %d \n",
			      priv->qos_data.qos_active);

C
Christoph Hellwig 已提交
1876
		iwl3945_send_qos_params_command(priv,
Z
Zhu Yi 已提交
1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
				&(priv->qos_data.def_qos_parm));
	}
}

/*
 * Power management (not Tx power!) functions
 */
#define MSEC_TO_USEC 1024

#define NOSLP __constant_cpu_to_le32(0)
#define SLP IWL_POWER_DRIVER_ALLOW_SLEEP_MSK
#define SLP_TIMEOUT(T) __constant_cpu_to_le32((T) * MSEC_TO_USEC)
#define SLP_VEC(X0, X1, X2, X3, X4) {__constant_cpu_to_le32(X0), \
				     __constant_cpu_to_le32(X1), \
				     __constant_cpu_to_le32(X2), \
				     __constant_cpu_to_le32(X3), \
				     __constant_cpu_to_le32(X4)}


/* default power management (not Tx power) table values */
/* for tim  0-10 */
C
Christoph Hellwig 已提交
1898
static struct iwl3945_power_vec_entry range_0[IWL_POWER_AC] = {
Z
Zhu Yi 已提交
1899 1900 1901 1902 1903 1904 1905 1906 1907
	{{NOSLP, SLP_TIMEOUT(0), SLP_TIMEOUT(0), SLP_VEC(0, 0, 0, 0, 0)}, 0},
	{{SLP, SLP_TIMEOUT(200), SLP_TIMEOUT(500), SLP_VEC(1, 2, 3, 4, 4)}, 0},
	{{SLP, SLP_TIMEOUT(200), SLP_TIMEOUT(300), SLP_VEC(2, 4, 6, 7, 7)}, 0},
	{{SLP, SLP_TIMEOUT(50), SLP_TIMEOUT(100), SLP_VEC(2, 6, 9, 9, 10)}, 0},
	{{SLP, SLP_TIMEOUT(50), SLP_TIMEOUT(25), SLP_VEC(2, 7, 9, 9, 10)}, 1},
	{{SLP, SLP_TIMEOUT(25), SLP_TIMEOUT(25), SLP_VEC(4, 7, 10, 10, 10)}, 1}
};

/* for tim > 10 */
C
Christoph Hellwig 已提交
1908
static struct iwl3945_power_vec_entry range_1[IWL_POWER_AC] = {
Z
Zhu Yi 已提交
1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920
	{{NOSLP, SLP_TIMEOUT(0), SLP_TIMEOUT(0), SLP_VEC(0, 0, 0, 0, 0)}, 0},
	{{SLP, SLP_TIMEOUT(200), SLP_TIMEOUT(500),
		 SLP_VEC(1, 2, 3, 4, 0xFF)}, 0},
	{{SLP, SLP_TIMEOUT(200), SLP_TIMEOUT(300),
		 SLP_VEC(2, 4, 6, 7, 0xFF)}, 0},
	{{SLP, SLP_TIMEOUT(50), SLP_TIMEOUT(100),
		 SLP_VEC(2, 6, 9, 9, 0xFF)}, 0},
	{{SLP, SLP_TIMEOUT(50), SLP_TIMEOUT(25), SLP_VEC(2, 7, 9, 9, 0xFF)}, 0},
	{{SLP, SLP_TIMEOUT(25), SLP_TIMEOUT(25),
		 SLP_VEC(4, 7, 10, 10, 0xFF)}, 0}
};

C
Christoph Hellwig 已提交
1921
int iwl3945_power_init_handle(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1922 1923
{
	int rc = 0, i;
C
Christoph Hellwig 已提交
1924 1925
	struct iwl3945_power_mgr *pow_data;
	int size = sizeof(struct iwl3945_power_vec_entry) * IWL_POWER_AC;
Z
Zhu Yi 已提交
1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943
	u16 pci_pm;

	IWL_DEBUG_POWER("Initialize power \n");

	pow_data = &(priv->power_data);

	memset(pow_data, 0, sizeof(*pow_data));

	pow_data->active_index = IWL_POWER_RANGE_0;
	pow_data->dtim_val = 0xffff;

	memcpy(&pow_data->pwr_range_0[0], &range_0[0], size);
	memcpy(&pow_data->pwr_range_1[0], &range_1[0], size);

	rc = pci_read_config_word(priv->pci_dev, PCI_LINK_CTRL, &pci_pm);
	if (rc != 0)
		return 0;
	else {
C
Christoph Hellwig 已提交
1944
		struct iwl3945_powertable_cmd *cmd;
Z
Zhu Yi 已提交
1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959

		IWL_DEBUG_POWER("adjust power command flags\n");

		for (i = 0; i < IWL_POWER_AC; i++) {
			cmd = &pow_data->pwr_range_0[i].cmd;

			if (pci_pm & 0x1)
				cmd->flags &= ~IWL_POWER_PCI_PM_MSK;
			else
				cmd->flags |= IWL_POWER_PCI_PM_MSK;
		}
	}
	return rc;
}

C
Christoph Hellwig 已提交
1960 1961
static int iwl3945_update_power_cmd(struct iwl3945_priv *priv,
				struct iwl3945_powertable_cmd *cmd, u32 mode)
Z
Zhu Yi 已提交
1962 1963 1964 1965
{
	int rc = 0, i;
	u8 skip;
	u32 max_sleep = 0;
C
Christoph Hellwig 已提交
1966
	struct iwl3945_power_vec_entry *range;
Z
Zhu Yi 已提交
1967
	u8 period = 0;
C
Christoph Hellwig 已提交
1968
	struct iwl3945_power_mgr *pow_data;
Z
Zhu Yi 已提交
1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980

	if (mode > IWL_POWER_INDEX_5) {
		IWL_DEBUG_POWER("Error invalid power mode \n");
		return -1;
	}
	pow_data = &(priv->power_data);

	if (pow_data->active_index == IWL_POWER_RANGE_0)
		range = &pow_data->pwr_range_0[0];
	else
		range = &pow_data->pwr_range_1[1];

C
Christoph Hellwig 已提交
1981
	memcpy(cmd, &range[mode].cmd, sizeof(struct iwl3945_powertable_cmd));
Z
Zhu Yi 已提交
1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023

#ifdef IWL_MAC80211_DISABLE
	if (priv->assoc_network != NULL) {
		unsigned long flags;

		period = priv->assoc_network->tim.tim_period;
	}
#endif	/*IWL_MAC80211_DISABLE */
	skip = range[mode].no_dtim;

	if (period == 0) {
		period = 1;
		skip = 0;
	}

	if (skip == 0) {
		max_sleep = period;
		cmd->flags &= ~IWL_POWER_SLEEP_OVER_DTIM_MSK;
	} else {
		__le32 slp_itrvl = cmd->sleep_interval[IWL_POWER_VEC_SIZE - 1];
		max_sleep = (le32_to_cpu(slp_itrvl) / period) * period;
		cmd->flags |= IWL_POWER_SLEEP_OVER_DTIM_MSK;
	}

	for (i = 0; i < IWL_POWER_VEC_SIZE; i++) {
		if (le32_to_cpu(cmd->sleep_interval[i]) > max_sleep)
			cmd->sleep_interval[i] = cpu_to_le32(max_sleep);
	}

	IWL_DEBUG_POWER("Flags value = 0x%08X\n", cmd->flags);
	IWL_DEBUG_POWER("Tx timeout = %u\n", le32_to_cpu(cmd->tx_data_timeout));
	IWL_DEBUG_POWER("Rx timeout = %u\n", le32_to_cpu(cmd->rx_data_timeout));
	IWL_DEBUG_POWER("Sleep interval vector = { %d , %d , %d , %d , %d }\n",
			le32_to_cpu(cmd->sleep_interval[0]),
			le32_to_cpu(cmd->sleep_interval[1]),
			le32_to_cpu(cmd->sleep_interval[2]),
			le32_to_cpu(cmd->sleep_interval[3]),
			le32_to_cpu(cmd->sleep_interval[4]));

	return rc;
}

C
Christoph Hellwig 已提交
2024
static int iwl3945_send_power_mode(struct iwl3945_priv *priv, u32 mode)
Z
Zhu Yi 已提交
2025
{
2026
	u32 uninitialized_var(final_mode);
Z
Zhu Yi 已提交
2027
	int rc;
C
Christoph Hellwig 已提交
2028
	struct iwl3945_powertable_cmd cmd;
Z
Zhu Yi 已提交
2029 2030

	/* If on battery, set to 3,
2031
	 * if plugged into AC power, set to CAM ("continuously aware mode"),
Z
Zhu Yi 已提交
2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044
	 * else user level */
	switch (mode) {
	case IWL_POWER_BATTERY:
		final_mode = IWL_POWER_INDEX_3;
		break;
	case IWL_POWER_AC:
		final_mode = IWL_POWER_MODE_CAM;
		break;
	default:
		final_mode = mode;
		break;
	}

C
Christoph Hellwig 已提交
2045
	iwl3945_update_power_cmd(priv, &cmd, final_mode);
Z
Zhu Yi 已提交
2046

C
Christoph Hellwig 已提交
2047
	rc = iwl3945_send_cmd_pdu(priv, POWER_TABLE_CMD, sizeof(cmd), &cmd);
Z
Zhu Yi 已提交
2048 2049 2050 2051 2052 2053 2054 2055 2056

	if (final_mode == IWL_POWER_MODE_CAM)
		clear_bit(STATUS_POWER_PMI, &priv->status);
	else
		set_bit(STATUS_POWER_PMI, &priv->status);

	return rc;
}

C
Christoph Hellwig 已提交
2057
int iwl3945_is_network_packet(struct iwl3945_priv *priv, struct ieee80211_hdr *header)
Z
Zhu Yi 已提交
2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
{
	/* Filter incoming packets to determine if they are targeted toward
	 * this network, discarding packets coming from ourselves */
	switch (priv->iw_mode) {
	case IEEE80211_IF_TYPE_IBSS: /* Header: Dest. | Source    | BSSID */
		/* packets from our adapter are dropped (echo) */
		if (!compare_ether_addr(header->addr2, priv->mac_addr))
			return 0;
		/* {broad,multi}cast packets to our IBSS go through */
		if (is_multicast_ether_addr(header->addr1))
			return !compare_ether_addr(header->addr3, priv->bssid);
		/* packets to our adapter go through */
		return !compare_ether_addr(header->addr1, priv->mac_addr);
	case IEEE80211_IF_TYPE_STA: /* Header: Dest. | AP{BSSID} | Source */
		/* packets from our adapter are dropped (echo) */
		if (!compare_ether_addr(header->addr3, priv->mac_addr))
			return 0;
		/* {broad,multi}cast packets to our BSS go through */
		if (is_multicast_ether_addr(header->addr1))
			return !compare_ether_addr(header->addr2, priv->bssid);
		/* packets to our adapter go through */
		return !compare_ether_addr(header->addr1, priv->mac_addr);
	}

	return 1;
}

#define TX_STATUS_ENTRY(x) case TX_STATUS_FAIL_ ## x: return #x

C
Christoph Hellwig 已提交
2087
static const char *iwl3945_get_tx_fail_reason(u32 status)
Z
Zhu Yi 已提交
2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113
{
	switch (status & TX_STATUS_MSK) {
	case TX_STATUS_SUCCESS:
		return "SUCCESS";
		TX_STATUS_ENTRY(SHORT_LIMIT);
		TX_STATUS_ENTRY(LONG_LIMIT);
		TX_STATUS_ENTRY(FIFO_UNDERRUN);
		TX_STATUS_ENTRY(MGMNT_ABORT);
		TX_STATUS_ENTRY(NEXT_FRAG);
		TX_STATUS_ENTRY(LIFE_EXPIRE);
		TX_STATUS_ENTRY(DEST_PS);
		TX_STATUS_ENTRY(ABORTED);
		TX_STATUS_ENTRY(BT_RETRY);
		TX_STATUS_ENTRY(STA_INVALID);
		TX_STATUS_ENTRY(FRAG_DROPPED);
		TX_STATUS_ENTRY(TID_DISABLE);
		TX_STATUS_ENTRY(FRAME_FLUSHED);
		TX_STATUS_ENTRY(INSUFFICIENT_CF_POLL);
		TX_STATUS_ENTRY(TX_LOCKED);
		TX_STATUS_ENTRY(NO_BEACON_ON_RADAR);
	}

	return "UNKNOWN";
}

/**
C
Christoph Hellwig 已提交
2114
 * iwl3945_scan_cancel - Cancel any currently executing HW scan
Z
Zhu Yi 已提交
2115 2116 2117
 *
 * NOTE: priv->mutex is not required before calling this function
 */
C
Christoph Hellwig 已提交
2118
static int iwl3945_scan_cancel(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
{
	if (!test_bit(STATUS_SCAN_HW, &priv->status)) {
		clear_bit(STATUS_SCANNING, &priv->status);
		return 0;
	}

	if (test_bit(STATUS_SCANNING, &priv->status)) {
		if (!test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
			IWL_DEBUG_SCAN("Queuing scan abort.\n");
			set_bit(STATUS_SCAN_ABORTING, &priv->status);
			queue_work(priv->workqueue, &priv->abort_scan);

		} else
			IWL_DEBUG_SCAN("Scan abort already in progress.\n");

		return test_bit(STATUS_SCANNING, &priv->status);
	}

	return 0;
}

/**
C
Christoph Hellwig 已提交
2141
 * iwl3945_scan_cancel_timeout - Cancel any currently executing HW scan
Z
Zhu Yi 已提交
2142 2143 2144 2145
 * @ms: amount of time to wait (in milliseconds) for scan to abort
 *
 * NOTE: priv->mutex must be held before calling this function
 */
C
Christoph Hellwig 已提交
2146
static int iwl3945_scan_cancel_timeout(struct iwl3945_priv *priv, unsigned long ms)
Z
Zhu Yi 已提交
2147 2148 2149 2150
{
	unsigned long now = jiffies;
	int ret;

C
Christoph Hellwig 已提交
2151
	ret = iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164
	if (ret && ms) {
		mutex_unlock(&priv->mutex);
		while (!time_after(jiffies, now + msecs_to_jiffies(ms)) &&
				test_bit(STATUS_SCANNING, &priv->status))
			msleep(1);
		mutex_lock(&priv->mutex);

		return test_bit(STATUS_SCANNING, &priv->status);
	}

	return ret;
}

C
Christoph Hellwig 已提交
2165
static void iwl3945_sequence_reset(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175
{
	/* Reset ieee stats */

	/* We don't reset the net_device_stats (ieee->stats) on
	 * re-association */

	priv->last_seq_num = -1;
	priv->last_frag_num = -1;
	priv->last_packet_time = 0;

C
Christoph Hellwig 已提交
2176
	iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
2177 2178 2179 2180 2181
}

#define MAX_UCODE_BEACON_INTERVAL	1024
#define INTEL_CONN_LISTEN_INTERVAL	__constant_cpu_to_le16(0xA)

C
Christoph Hellwig 已提交
2182
static __le16 iwl3945_adjust_beacon_interval(u16 beacon_val)
Z
Zhu Yi 已提交
2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194
{
	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);
}

C
Christoph Hellwig 已提交
2195
static void iwl3945_setup_rxon_timing(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224
{
	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);
	priv->rxon_timing.timestamp.dw[1] = cpu_to_le32(priv->timestamp1);
	priv->rxon_timing.timestamp.dw[0] = cpu_to_le32(priv->timestamp0);

	priv->rxon_timing.listen_interval = INTEL_CONN_LISTEN_INTERVAL;

	tsf = priv->timestamp1;
	tsf = ((tsf << 32) | priv->timestamp0);

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

	if (priv->iw_mode == IEEE80211_IF_TYPE_STA) {
		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 已提交
2225
			    iwl3945_adjust_beacon_interval(
Z
Zhu Yi 已提交
2226 2227 2228 2229 2230 2231
				le16_to_cpu(priv->rxon_timing.beacon_interval));
		}

		priv->rxon_timing.atim_window = 0;
	} else {
		priv->rxon_timing.beacon_interval =
C
Christoph Hellwig 已提交
2232
			iwl3945_adjust_beacon_interval(conf->beacon_int);
Z
Zhu Yi 已提交
2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250
		/* 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));

	IWL_DEBUG_ASSOC
	    ("beacon interval %d beacon timer %d beacon tim %d\n",
		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));
}

C
Christoph Hellwig 已提交
2251
static int iwl3945_scan_initiate(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2252 2253 2254 2255 2256 2257
{
	if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
		IWL_ERROR("APs don't scan.\n");
		return 0;
	}

C
Christoph Hellwig 已提交
2258
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284
		IWL_DEBUG_SCAN("Aborting scan due to not ready.\n");
		return -EIO;
	}

	if (test_bit(STATUS_SCANNING, &priv->status)) {
		IWL_DEBUG_SCAN("Scan already in progress.\n");
		return -EAGAIN;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
		IWL_DEBUG_SCAN("Scan request while abort pending.  "
			       "Queuing.\n");
		return -EAGAIN;
	}

	IWL_DEBUG_INFO("Starting scan...\n");
	priv->scan_bands = 2;
	set_bit(STATUS_SCANNING, &priv->status);
	priv->scan_start = jiffies;
	priv->scan_pass_start = priv->scan_start;

	queue_work(priv->workqueue, &priv->request_scan);

	return 0;
}

C
Christoph Hellwig 已提交
2285
static int iwl3945_set_rxon_hwcrypto(struct iwl3945_priv *priv, int hw_decrypt)
Z
Zhu Yi 已提交
2286
{
C
Christoph Hellwig 已提交
2287
	struct iwl3945_rxon_cmd *rxon = &priv->staging_rxon;
Z
Zhu Yi 已提交
2288 2289 2290 2291 2292 2293 2294 2295 2296

	if (hw_decrypt)
		rxon->filter_flags &= ~RXON_FILTER_DIS_DECRYPT_MSK;
	else
		rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK;

	return 0;
}

2297 2298
static void iwl3945_set_flags_for_phymode(struct iwl3945_priv *priv,
					  enum ieee80211_band band)
Z
Zhu Yi 已提交
2299
{
2300
	if (band == IEEE80211_BAND_5GHZ) {
Z
Zhu Yi 已提交
2301 2302 2303 2304 2305
		priv->staging_rxon.flags &=
		    ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
		      | RXON_FLG_CCK_MSK);
		priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
	} else {
C
Christoph Hellwig 已提交
2306
		/* Copied from iwl3945_bg_post_associate() */
Z
Zhu Yi 已提交
2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
		else
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;

		if (priv->iw_mode == IEEE80211_IF_TYPE_IBSS)
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;

		priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;
		priv->staging_rxon.flags |= RXON_FLG_AUTO_DETECT_MSK;
		priv->staging_rxon.flags &= ~RXON_FLG_CCK_MSK;
	}
}

/*
2322
 * initialize rxon structure with default values from eeprom
Z
Zhu Yi 已提交
2323
 */
C
Christoph Hellwig 已提交
2324
static void iwl3945_connection_init_rx_config(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2325
{
C
Christoph Hellwig 已提交
2326
	const struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362

	memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));

	switch (priv->iw_mode) {
	case IEEE80211_IF_TYPE_AP:
		priv->staging_rxon.dev_type = RXON_DEV_TYPE_AP;
		break;

	case IEEE80211_IF_TYPE_STA:
		priv->staging_rxon.dev_type = RXON_DEV_TYPE_ESS;
		priv->staging_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
		break;

	case IEEE80211_IF_TYPE_IBSS:
		priv->staging_rxon.dev_type = RXON_DEV_TYPE_IBSS;
		priv->staging_rxon.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
		priv->staging_rxon.filter_flags = RXON_FILTER_BCON_AWARE_MSK |
						  RXON_FILTER_ACCEPT_GRP_MSK;
		break;

	case IEEE80211_IF_TYPE_MNTR:
		priv->staging_rxon.dev_type = RXON_DEV_TYPE_SNIFFER;
		priv->staging_rxon.filter_flags = RXON_FILTER_PROMISC_MSK |
		    RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_ACCEPT_GRP_MSK;
		break;
	}

#if 0
	/* TODO:  Figure out when short_preamble would be set and cache from
	 * that */
	if (!hw_to_local(priv->hw)->short_preamble)
		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
	else
		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
#endif

2363
	ch_info = iwl3945_get_channel_info(priv, priv->band,
Z
Zhu Yi 已提交
2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378
				       le16_to_cpu(priv->staging_rxon.channel));

	if (!ch_info)
		ch_info = &priv->channel_info[0];

	/*
	 * in some case A channels are all non IBSS
	 * in this case force B/G channel
	 */
	if ((priv->iw_mode == IEEE80211_IF_TYPE_IBSS) &&
	    !(is_channel_ibss(ch_info)))
		ch_info = &priv->channel_info[0];

	priv->staging_rxon.channel = cpu_to_le16(ch_info->channel);
	if (is_channel_a_band(ch_info))
2379
		priv->band = IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
2380
	else
2381
		priv->band = IEEE80211_BAND_2GHZ;
Z
Zhu Yi 已提交
2382

2383
	iwl3945_set_flags_for_phymode(priv, priv->band);
Z
Zhu Yi 已提交
2384 2385 2386 2387 2388 2389 2390

	priv->staging_rxon.ofdm_basic_rates =
	    (IWL_OFDM_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
	priv->staging_rxon.cck_basic_rates =
	    (IWL_CCK_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
}

C
Christoph Hellwig 已提交
2391
static int iwl3945_set_mode(struct iwl3945_priv *priv, int mode)
Z
Zhu Yi 已提交
2392 2393
{
	if (mode == IEEE80211_IF_TYPE_IBSS) {
C
Christoph Hellwig 已提交
2394
		const struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
2395

C
Christoph Hellwig 已提交
2396
		ch_info = iwl3945_get_channel_info(priv,
2397
			priv->band,
Z
Zhu Yi 已提交
2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408
			le16_to_cpu(priv->staging_rxon.channel));

		if (!ch_info || !is_channel_ibss(ch_info)) {
			IWL_ERROR("channel %d not IBSS channel\n",
				  le16_to_cpu(priv->staging_rxon.channel));
			return -EINVAL;
		}
	}

	priv->iw_mode = mode;

C
Christoph Hellwig 已提交
2409
	iwl3945_connection_init_rx_config(priv);
Z
Zhu Yi 已提交
2410 2411
	memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);

C
Christoph Hellwig 已提交
2412
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
2413

2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424
	/* dont commit rxon if rf-kill is on*/
	if (!iwl3945_is_ready_rf(priv))
		return -EAGAIN;

	cancel_delayed_work(&priv->scan_check);
	if (iwl3945_scan_cancel_timeout(priv, 100)) {
		IWL_WARNING("Aborted scan still in progress after 100ms\n");
		IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
		return -EAGAIN;
	}

C
Christoph Hellwig 已提交
2425
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
2426 2427 2428 2429

	return 0;
}

C
Christoph Hellwig 已提交
2430
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
2431
				      struct ieee80211_tx_control *ctl,
C
Christoph Hellwig 已提交
2432
				      struct iwl3945_cmd *cmd,
Z
Zhu Yi 已提交
2433 2434 2435
				      struct sk_buff *skb_frag,
				      int last_frag)
{
C
Christoph Hellwig 已提交
2436
	struct iwl3945_hw_key *keyinfo = &priv->stations[ctl->key_idx].keyinfo;
Z
Zhu Yi 已提交
2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478

	switch (keyinfo->alg) {
	case ALG_CCMP:
		cmd->cmd.tx.sec_ctl = TX_CMD_SEC_CCM;
		memcpy(cmd->cmd.tx.key, keyinfo->key, keyinfo->keylen);
		IWL_DEBUG_TX("tx_cmd with aes hwcrypto\n");
		break;

	case ALG_TKIP:
#if 0
		cmd->cmd.tx.sec_ctl = TX_CMD_SEC_TKIP;

		if (last_frag)
			memcpy(cmd->cmd.tx.tkip_mic.byte, skb_frag->tail - 8,
			       8);
		else
			memset(cmd->cmd.tx.tkip_mic.byte, 0, 8);
#endif
		break;

	case ALG_WEP:
		cmd->cmd.tx.sec_ctl = TX_CMD_SEC_WEP |
		    (ctl->key_idx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT;

		if (keyinfo->keylen == 13)
			cmd->cmd.tx.sec_ctl |= TX_CMD_SEC_KEY128;

		memcpy(&cmd->cmd.tx.key[3], keyinfo->key, keyinfo->keylen);

		IWL_DEBUG_TX("Configuring packet for WEP encryption "
			     "with key %d\n", ctl->key_idx);
		break;

	default:
		printk(KERN_ERR "Unknown encode alg %d\n", keyinfo->alg);
		break;
	}
}

/*
 * handle build REPLY_TX command notification.
 */
C
Christoph Hellwig 已提交
2479 2480
static void iwl3945_build_tx_cmd_basic(struct iwl3945_priv *priv,
				  struct iwl3945_cmd *cmd,
Z
Zhu Yi 已提交
2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527
				  struct ieee80211_tx_control *ctrl,
				  struct ieee80211_hdr *hdr,
				  int is_unicast, u8 std_id)
{
	__le16 *qc;
	u16 fc = le16_to_cpu(hdr->frame_control);
	__le32 tx_flags = cmd->cmd.tx.tx_flags;

	cmd->cmd.tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
	if (!(ctrl->flags & IEEE80211_TXCTL_NO_ACK)) {
		tx_flags |= TX_CMD_FLG_ACK_MSK;
		if ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT)
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
		if (ieee80211_is_probe_response(fc) &&
		    !(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;
	}

	cmd->cmd.tx.sta_id = std_id;
	if (ieee80211_get_morefrag(hdr))
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

	qc = ieee80211_get_qos_ctrl(hdr);
	if (qc) {
		cmd->cmd.tx.tid_tspec = (u8) (le16_to_cpu(*qc) & 0xf);
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
	} else
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;

	if (ctrl->flags & IEEE80211_TXCTL_USE_RTS_CTS) {
		tx_flags |= TX_CMD_FLG_RTS_MSK;
		tx_flags &= ~TX_CMD_FLG_CTS_MSK;
	} else if (ctrl->flags & IEEE80211_TXCTL_USE_CTS_PROTECT) {
		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);
	if ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT) {
		if ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_ASSOC_REQ ||
		    (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_REASSOC_REQ)
2528
			cmd->cmd.tx.timeout.pm_frame_timeout = cpu_to_le16(3);
Z
Zhu Yi 已提交
2529
		else
2530
			cmd->cmd.tx.timeout.pm_frame_timeout = cpu_to_le16(2);
Z
Zhu Yi 已提交
2531 2532 2533 2534 2535 2536 2537 2538
	} else
		cmd->cmd.tx.timeout.pm_frame_timeout = 0;

	cmd->cmd.tx.driver_txop = 0;
	cmd->cmd.tx.tx_flags = tx_flags;
	cmd->cmd.tx.next_frame_len = 0;
}

2539 2540 2541
/**
 * iwl3945_get_sta_id - Find station's index within station table
 */
C
Christoph Hellwig 已提交
2542
static int iwl3945_get_sta_id(struct iwl3945_priv *priv, struct ieee80211_hdr *hdr)
Z
Zhu Yi 已提交
2543 2544 2545 2546
{
	int sta_id;
	u16 fc = le16_to_cpu(hdr->frame_control);

2547
	/* If this frame is broadcast or management, use broadcast station id */
Z
Zhu Yi 已提交
2548 2549 2550 2551 2552 2553
	if (((fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA) ||
	    is_multicast_ether_addr(hdr->addr1))
		return priv->hw_setting.bcast_sta_id;

	switch (priv->iw_mode) {

2554 2555
	/* If we are a client station in a BSS network, use the special
	 * AP station entry (that's the only station we communicate with) */
Z
Zhu Yi 已提交
2556 2557 2558 2559 2560
	case IEEE80211_IF_TYPE_STA:
		return IWL_AP_ID;

	/* If we are an AP, then find the station, or use BCAST */
	case IEEE80211_IF_TYPE_AP:
C
Christoph Hellwig 已提交
2561
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
2562 2563 2564 2565
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;
		return priv->hw_setting.bcast_sta_id;

2566 2567
	/* If this frame is going out to an IBSS network, find the station,
	 * or create a new station table entry */
2568 2569 2570
	case IEEE80211_IF_TYPE_IBSS: {
		DECLARE_MAC_BUF(mac);

2571
		/* Create new station table entry */
C
Christoph Hellwig 已提交
2572
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
2573 2574 2575
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

C
Christoph Hellwig 已提交
2576
		sta_id = iwl3945_add_station(priv, hdr->addr1, 0, CMD_ASYNC);
Z
Zhu Yi 已提交
2577 2578 2579 2580

		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

2581
		IWL_DEBUG_DROP("Station %s not in station map. "
Z
Zhu Yi 已提交
2582
			       "Defaulting to broadcast...\n",
2583
			       print_mac(mac, hdr->addr1));
C
Christoph Hellwig 已提交
2584
		iwl3945_print_hex_dump(IWL_DL_DROP, (u8 *) hdr, sizeof(*hdr));
Z
Zhu Yi 已提交
2585
		return priv->hw_setting.bcast_sta_id;
2586
	}
Z
Zhu Yi 已提交
2587
	default:
2588
		IWL_WARNING("Unknown mode of operation: %d", priv->iw_mode);
Z
Zhu Yi 已提交
2589 2590 2591 2592 2593 2594 2595
		return priv->hw_setting.bcast_sta_id;
	}
}

/*
 * start REPLY_TX command process
 */
C
Christoph Hellwig 已提交
2596
static int iwl3945_tx_skb(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
2597 2598 2599
		      struct sk_buff *skb, struct ieee80211_tx_control *ctl)
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
C
Christoph Hellwig 已提交
2600
	struct iwl3945_tfd_frame *tfd;
Z
Zhu Yi 已提交
2601 2602
	u32 *control_flags;
	int txq_id = ctl->queue;
C
Christoph Hellwig 已提交
2603 2604
	struct iwl3945_tx_queue *txq = NULL;
	struct iwl3945_queue *q = NULL;
Z
Zhu Yi 已提交
2605 2606
	dma_addr_t phys_addr;
	dma_addr_t txcmd_phys;
C
Christoph Hellwig 已提交
2607
	struct iwl3945_cmd *out_cmd = NULL;
Z
Zhu Yi 已提交
2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618
	u16 len, idx, len_org;
	u8 id, hdr_len, unicast;
	u8 sta_id;
	u16 seq_number = 0;
	u16 fc;
	__le16 *qc;
	u8 wait_write_ptr = 0;
	unsigned long flags;
	int rc;

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
2619
	if (iwl3945_is_rfkill(priv)) {
Z
Zhu Yi 已提交
2620 2621 2622 2623
		IWL_DEBUG_DROP("Dropping - RF KILL\n");
		goto drop_unlock;
	}

2624 2625
	if (!priv->vif) {
		IWL_DEBUG_DROP("Dropping - !priv->vif\n");
Z
Zhu Yi 已提交
2626 2627 2628
		goto drop_unlock;
	}

2629
	if ((ctl->tx_rate->hw_value & 0xFF) == IWL_INVALID_RATE) {
Z
Zhu Yi 已提交
2630 2631 2632 2633 2634 2635 2636 2637 2638
		IWL_ERROR("ERROR: No TX rate available.\n");
		goto drop_unlock;
	}

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

	fc = le16_to_cpu(hdr->frame_control);

2639
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
2640 2641 2642 2643 2644 2645 2646 2647
	if (ieee80211_is_auth(fc))
		IWL_DEBUG_TX("Sending AUTH frame\n");
	else if (ieee80211_is_assoc_request(fc))
		IWL_DEBUG_TX("Sending ASSOC frame\n");
	else if (ieee80211_is_reassoc_request(fc))
		IWL_DEBUG_TX("Sending REASSOC frame\n");
#endif

2648
	/* drop all data frame if we are not associated */
2649 2650
	if ((!iwl3945_is_associated(priv) ||
	     ((priv->iw_mode == IEEE80211_IF_TYPE_STA) && !priv->assoc_id)) &&
Z
Zhu Yi 已提交
2651
	    ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA)) {
C
Christoph Hellwig 已提交
2652
		IWL_DEBUG_DROP("Dropping - !iwl3945_is_associated\n");
Z
Zhu Yi 已提交
2653 2654 2655 2656 2657 2658
		goto drop_unlock;
	}

	spin_unlock_irqrestore(&priv->lock, flags);

	hdr_len = ieee80211_get_hdrlen(fc);
2659 2660

	/* Find (or create) index into station table for destination station */
C
Christoph Hellwig 已提交
2661
	sta_id = iwl3945_get_sta_id(priv, hdr);
Z
Zhu Yi 已提交
2662
	if (sta_id == IWL_INVALID_STATION) {
2663 2664 2665 2666
		DECLARE_MAC_BUF(mac);

		IWL_DEBUG_DROP("Dropping - INVALID STATION: %s\n",
			       print_mac(mac, hdr->addr1));
Z
Zhu Yi 已提交
2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681
		goto drop;
	}

	IWL_DEBUG_RATE("station Id %d\n", sta_id);

	qc = ieee80211_get_qos_ctrl(hdr);
	if (qc) {
		u8 tid = (u8)(le16_to_cpu(*qc) & 0xf);
		seq_number = priv->stations[sta_id].tid[tid].seq_number &
				IEEE80211_SCTL_SEQ;
		hdr->seq_ctrl = cpu_to_le16(seq_number) |
			(hdr->seq_ctrl &
				__constant_cpu_to_le16(IEEE80211_SCTL_FRAG));
		seq_number += 0x10;
	}
2682 2683

	/* Descriptor for chosen Tx queue */
Z
Zhu Yi 已提交
2684 2685 2686 2687 2688
	txq = &priv->txq[txq_id];
	q = &txq->q;

	spin_lock_irqsave(&priv->lock, flags);

2689
	/* Set up first empty TFD within this queue's circular TFD buffer */
2690
	tfd = &txq->bd[q->write_ptr];
Z
Zhu Yi 已提交
2691 2692
	memset(tfd, 0, sizeof(*tfd));
	control_flags = (u32 *) tfd;
2693
	idx = get_cmd_index(q, q->write_ptr, 0);
Z
Zhu Yi 已提交
2694

2695
	/* Set up driver data for this TFD */
C
Christoph Hellwig 已提交
2696
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl3945_tx_info));
2697 2698
	txq->txb[q->write_ptr].skb[0] = skb;
	memcpy(&(txq->txb[q->write_ptr].status.control),
Z
Zhu Yi 已提交
2699
	       ctl, sizeof(struct ieee80211_tx_control));
2700 2701

	/* Init first empty entry in queue's array of Tx/cmd buffers */
Z
Zhu Yi 已提交
2702 2703 2704
	out_cmd = &txq->cmd[idx];
	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
	memset(&out_cmd->cmd.tx, 0, sizeof(out_cmd->cmd.tx));
2705 2706 2707 2708 2709 2710 2711

	/*
	 * 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 已提交
2712 2713
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
2714
				INDEX_TO_SEQ(q->write_ptr)));
2715 2716

	/* Copy MAC header from skb into command buffer */
Z
Zhu Yi 已提交
2717 2718
	memcpy(out_cmd->cmd.tx.hdr, hdr, hdr_len);

2719 2720 2721 2722 2723 2724 2725 2726 2727
	/*
	 * 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.
	 */
Z
Zhu Yi 已提交
2728
	len = priv->hw_setting.tx_cmd_len +
C
Christoph Hellwig 已提交
2729
		sizeof(struct iwl3945_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
2730 2731 2732 2733 2734 2735 2736 2737 2738

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

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

2739 2740
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
C
Christoph Hellwig 已提交
2741 2742
	txcmd_phys = txq->dma_addr_cmd + sizeof(struct iwl3945_cmd) * idx +
		     offsetof(struct iwl3945_cmd, hdr);
Z
Zhu Yi 已提交
2743

2744 2745
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
C
Christoph Hellwig 已提交
2746
	iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, txcmd_phys, len);
Z
Zhu Yi 已提交
2747 2748

	if (!(ctl->flags & IEEE80211_TXCTL_DO_NOT_ENCRYPT))
C
Christoph Hellwig 已提交
2749
		iwl3945_build_tx_cmd_hwcrypto(priv, ctl, out_cmd, skb, 0);
Z
Zhu Yi 已提交
2750

2751 2752
	/* 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 已提交
2753 2754 2755 2756
	len = skb->len - hdr_len;
	if (len) {
		phys_addr = pci_map_single(priv->pci_dev, skb->data + hdr_len,
					   len, PCI_DMA_TODEVICE);
C
Christoph Hellwig 已提交
2757
		iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, phys_addr, len);
Z
Zhu Yi 已提交
2758 2759 2760
	}

	if (!len)
2761
		/* If there is no payload, then we use only one Tx buffer */
Z
Zhu Yi 已提交
2762 2763
		*control_flags = TFD_CTL_COUNT_SET(1);
	else
2764 2765
		/* Else use 2 buffers.
		 * Tell 3945 about any padding after MAC header */
Z
Zhu Yi 已提交
2766 2767 2768
		*control_flags = TFD_CTL_COUNT_SET(2) |
			TFD_CTL_PAD_SET(U32_PAD(len));

2769
	/* Total # bytes to be transmitted */
Z
Zhu Yi 已提交
2770 2771 2772 2773
	len = (u16)skb->len;
	out_cmd->cmd.tx.len = cpu_to_le16(len);

	/* TODO need this for burst mode later on */
C
Christoph Hellwig 已提交
2774
	iwl3945_build_tx_cmd_basic(priv, out_cmd, ctl, hdr, unicast, sta_id);
Z
Zhu Yi 已提交
2775 2776

	/* set is_hcca to 0; it probably will never be implemented */
C
Christoph Hellwig 已提交
2777
	iwl3945_hw_build_tx_cmd_rate(priv, out_cmd, ctl, hdr, sta_id, 0);
Z
Zhu Yi 已提交
2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792

	out_cmd->cmd.tx.tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
	out_cmd->cmd.tx.tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;

	if (!ieee80211_get_morefrag(hdr)) {
		txq->need_update = 1;
		if (qc) {
			u8 tid = (u8)(le16_to_cpu(*qc) & 0xf);
			priv->stations[sta_id].tid[tid].seq_number = seq_number;
		}
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

C
Christoph Hellwig 已提交
2793
	iwl3945_print_hex_dump(IWL_DL_TX, out_cmd->cmd.payload,
Z
Zhu Yi 已提交
2794 2795
			   sizeof(out_cmd->cmd.tx));

C
Christoph Hellwig 已提交
2796
	iwl3945_print_hex_dump(IWL_DL_TX, (u8 *)out_cmd->cmd.tx.hdr,
Z
Zhu Yi 已提交
2797 2798
			   ieee80211_get_hdrlen(fc));

2799
	/* Tell device the write index *just past* this latest filled TFD */
C
Christoph Hellwig 已提交
2800 2801
	q->write_ptr = iwl3945_queue_inc_wrap(q->write_ptr, q->n_bd);
	rc = iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
2802 2803 2804 2805 2806
	spin_unlock_irqrestore(&priv->lock, flags);

	if (rc)
		return rc;

C
Christoph Hellwig 已提交
2807
	if ((iwl3945_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
2808 2809 2810 2811
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
C
Christoph Hellwig 已提交
2812
			iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826
			spin_unlock_irqrestore(&priv->lock, flags);
		}

		ieee80211_stop_queue(priv->hw, ctl->queue);
	}

	return 0;

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

C
Christoph Hellwig 已提交
2827
static void iwl3945_set_rate(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2828
{
2829
	const struct ieee80211_supported_band *sband = NULL;
Z
Zhu Yi 已提交
2830 2831 2832
	struct ieee80211_rate *rate;
	int i;

2833 2834
	sband = iwl3945_get_band(priv, priv->band);
	if (!sband) {
2835 2836 2837
		IWL_ERROR("Failed to set rate: unable to get hw mode\n");
		return;
	}
Z
Zhu Yi 已提交
2838 2839 2840 2841

	priv->active_rate = 0;
	priv->active_rate_basic = 0;

2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852
	IWL_DEBUG_RATE("Setting rates for %s GHz\n",
		       sband->band == IEEE80211_BAND_2GHZ ? "2.4" : "5");

	for (i = 0; i < sband->n_bitrates; i++) {
		rate = &sband->bitrates[i];
		if ((rate->hw_value < IWL_RATE_COUNT) &&
		    !(rate->flags & IEEE80211_CHAN_DISABLED)) {
			IWL_DEBUG_RATE("Adding rate index %d (plcp %d)\n",
				       rate->hw_value, iwl3945_rates[rate->hw_value].plcp);
			priv->active_rate |= (1 << rate->hw_value);
		}
Z
Zhu Yi 已提交
2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880
	}

	IWL_DEBUG_RATE("Set active_rate = %0x, active_rate_basic = %0x\n",
		       priv->active_rate, priv->active_rate_basic);

	/*
	 * If a basic rate is configured, then use it (adding IWL_RATE_1M_MASK)
	 * otherwise set it to the default of all CCK rates and 6, 12, 24 for
	 * OFDM
	 */
	if (priv->active_rate_basic & IWL_CCK_BASIC_RATES_MASK)
		priv->staging_rxon.cck_basic_rates =
		    ((priv->active_rate_basic &
		      IWL_CCK_RATES_MASK) >> IWL_FIRST_CCK_RATE) & 0xF;
	else
		priv->staging_rxon.cck_basic_rates =
		    (IWL_CCK_BASIC_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;

	if (priv->active_rate_basic & IWL_OFDM_BASIC_RATES_MASK)
		priv->staging_rxon.ofdm_basic_rates =
		    ((priv->active_rate_basic &
		      (IWL_OFDM_BASIC_RATES_MASK | IWL_RATE_6M_MASK)) >>
		      IWL_FIRST_OFDM_RATE) & 0xFF;
	else
		priv->staging_rxon.ofdm_basic_rates =
		   (IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
}

C
Christoph Hellwig 已提交
2881
static void iwl3945_radio_kill_sw(struct iwl3945_priv *priv, int disable_radio)
Z
Zhu Yi 已提交
2882 2883 2884 2885 2886 2887 2888 2889 2890 2891
{
	unsigned long flags;

	if (!!disable_radio == test_bit(STATUS_RF_KILL_SW, &priv->status))
		return;

	IWL_DEBUG_RF_KILL("Manual SW RF KILL set to: RADIO %s\n",
			  disable_radio ? "OFF" : "ON");

	if (disable_radio) {
C
Christoph Hellwig 已提交
2892
		iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
2893 2894 2895
		/* FIXME: This is a workaround for AP */
		if (priv->iw_mode != IEEE80211_IF_TYPE_AP) {
			spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
2896
			iwl3945_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
2897 2898
				    CSR_UCODE_SW_BIT_RFKILL);
			spin_unlock_irqrestore(&priv->lock, flags);
C
Christoph Hellwig 已提交
2899
			iwl3945_send_card_state(priv, CARD_STATE_CMD_DISABLE, 0);
Z
Zhu Yi 已提交
2900 2901 2902 2903 2904 2905
			set_bit(STATUS_RF_KILL_SW, &priv->status);
		}
		return;
	}

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
2906
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
Z
Zhu Yi 已提交
2907 2908 2909 2910 2911 2912 2913 2914

	clear_bit(STATUS_RF_KILL_SW, &priv->status);
	spin_unlock_irqrestore(&priv->lock, flags);

	/* wake up ucode */
	msleep(10);

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
2915 2916 2917
	iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
	if (!iwl3945_grab_nic_access(priv))
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929
	spin_unlock_irqrestore(&priv->lock, flags);

	if (test_bit(STATUS_RF_KILL_HW, &priv->status)) {
		IWL_DEBUG_RF_KILL("Can not turn radio back on - "
				  "disabled by HW switch\n");
		return;
	}

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

C
Christoph Hellwig 已提交
2930
void iwl3945_set_decrypted_flag(struct iwl3945_priv *priv, struct sk_buff *skb,
Z
Zhu Yi 已提交
2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963
			    u32 decrypt_res, struct ieee80211_rx_status *stats)
{
	u16 fc =
	    le16_to_cpu(((struct ieee80211_hdr *)skb->data)->frame_control);

	if (priv->active_rxon.filter_flags & RXON_FILTER_DIS_DECRYPT_MSK)
		return;

	if (!(fc & IEEE80211_FCTL_PROTECTED))
		return;

	IWL_DEBUG_RX("decrypt_res:0x%x\n", decrypt_res);
	switch (decrypt_res & RX_RES_STATUS_SEC_TYPE_MSK) {
	case RX_RES_STATUS_SEC_TYPE_TKIP:
		if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
		    RX_RES_STATUS_BAD_ICV_MIC)
			stats->flag |= RX_FLAG_MMIC_ERROR;
	case RX_RES_STATUS_SEC_TYPE_WEP:
	case RX_RES_STATUS_SEC_TYPE_CCMP:
		if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
		    RX_RES_STATUS_DECRYPT_OK) {
			IWL_DEBUG_RX("hw decrypt successfully!!!\n");
			stats->flag |= RX_FLAG_DECRYPTED;
		}
		break;

	default:
		break;
	}
}

#define IWL_PACKET_RETRY_TIME HZ

C
Christoph Hellwig 已提交
2964
int iwl3945_is_duplicate_packet(struct iwl3945_priv *priv, struct ieee80211_hdr *header)
Z
Zhu Yi 已提交
2965 2966 2967 2968 2969 2970 2971 2972 2973 2974
{
	u16 sc = le16_to_cpu(header->seq_ctrl);
	u16 seq = (sc & IEEE80211_SCTL_SEQ) >> 4;
	u16 frag = sc & IEEE80211_SCTL_FRAG;
	u16 *last_seq, *last_frag;
	unsigned long *last_time;

	switch (priv->iw_mode) {
	case IEEE80211_IF_TYPE_IBSS:{
		struct list_head *p;
C
Christoph Hellwig 已提交
2975
		struct iwl3945_ibss_seq *entry = NULL;
Z
Zhu Yi 已提交
2976 2977 2978 2979
		u8 *mac = header->addr2;
		int index = mac[5] & (IWL_IBSS_MAC_HASH_SIZE - 1);

		__list_for_each(p, &priv->ibss_mac_hash[index]) {
C
Christoph Hellwig 已提交
2980
			entry = list_entry(p, struct iwl3945_ibss_seq, list);
Z
Zhu Yi 已提交
2981 2982 2983 2984 2985 2986
			if (!compare_ether_addr(entry->mac, mac))
				break;
		}
		if (p == &priv->ibss_mac_hash[index]) {
			entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
			if (!entry) {
2987
				IWL_ERROR("Cannot malloc new mac entry\n");
Z
Zhu Yi 已提交
2988 2989 2990 2991 2992 2993
				return 0;
			}
			memcpy(entry->mac, mac, ETH_ALEN);
			entry->seq_num = seq;
			entry->frag_num = frag;
			entry->packet_time = jiffies;
2994
			list_add(&entry->list, &priv->ibss_mac_hash[index]);
Z
Zhu Yi 已提交
2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027
			return 0;
		}
		last_seq = &entry->seq_num;
		last_frag = &entry->frag_num;
		last_time = &entry->packet_time;
		break;
	}
	case IEEE80211_IF_TYPE_STA:
		last_seq = &priv->last_seq_num;
		last_frag = &priv->last_frag_num;
		last_time = &priv->last_packet_time;
		break;
	default:
		return 0;
	}
	if ((*last_seq == seq) &&
	    time_after(*last_time + IWL_PACKET_RETRY_TIME, jiffies)) {
		if (*last_frag == frag)
			goto drop;
		if (*last_frag + 1 != frag)
			/* out-of-order fragment */
			goto drop;
	} else
		*last_seq = seq;

	*last_frag = frag;
	*last_time = jiffies;
	return 0;

 drop:
	return 1;
}

3028
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042

#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 已提交
3043
static u32 iwl3945_usecs_to_beacons(u32 usec, u32 beacon_interval)
Z
Zhu Yi 已提交
3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061
{
	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 已提交
3062
static __le32 iwl3945_add_beacon_time(u32 base, u32 addon, u32 beacon_interval)
Z
Zhu Yi 已提交
3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080
{
	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);
}

C
Christoph Hellwig 已提交
3081
static int iwl3945_get_measurement(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
3082 3083 3084
			       struct ieee80211_measurement_params *params,
			       u8 type)
{
C
Christoph Hellwig 已提交
3085 3086 3087
	struct iwl3945_spectrum_cmd spectrum;
	struct iwl3945_rx_packet *res;
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
3088 3089 3090 3091 3092 3093 3094 3095 3096
		.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);

C
Christoph Hellwig 已提交
3097
	if (iwl3945_is_associated(priv))
Z
Zhu Yi 已提交
3098
		add_time =
C
Christoph Hellwig 已提交
3099
		    iwl3945_usecs_to_beacons(
Z
Zhu Yi 已提交
3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111
			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));

C
Christoph Hellwig 已提交
3112
	if (iwl3945_is_associated(priv))
Z
Zhu Yi 已提交
3113
		spectrum.start_time =
C
Christoph Hellwig 已提交
3114
		    iwl3945_add_beacon_time(priv->last_beacon_time,
Z
Zhu Yi 已提交
3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126
				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;
	if (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK)
		spectrum.flags |= RXON_FLG_BAND_24G_MSK |
		    RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK;

C
Christoph Hellwig 已提交
3127
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
3128 3129 3130
	if (rc)
		return rc;

C
Christoph Hellwig 已提交
3131
	res = (struct iwl3945_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
3132 3133 3134 3135 3136 3137 3138 3139 3140
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
		IWL_ERROR("Bad return from REPLY_RX_ON_ASSOC command\n");
		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) {
3141 3142
			IWL_DEBUG_INFO("Replaced existing measurement: %d\n",
						res->u.spectrum.id);
Z
Zhu Yi 已提交
3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159
			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

C
Christoph Hellwig 已提交
3160 3161
static void iwl3945_txstatus_to_ieee(struct iwl3945_priv *priv,
				 struct iwl3945_tx_info *tx_sta)
Z
Zhu Yi 已提交
3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179
{

	tx_sta->status.ack_signal = 0;
	tx_sta->status.excessive_retries = 0;
	tx_sta->status.queue_length = 0;
	tx_sta->status.queue_number = 0;

	if (in_interrupt())
		ieee80211_tx_status_irqsafe(priv->hw,
					    tx_sta->skb[0], &(tx_sta->status));
	else
		ieee80211_tx_status(priv->hw,
				    tx_sta->skb[0], &(tx_sta->status));

	tx_sta->skb[0] = NULL;
}

/**
3180
 * iwl3945_tx_queue_reclaim - Reclaim Tx queue entries already Tx'd
Z
Zhu Yi 已提交
3181
 *
3182 3183 3184
 * When FW advances 'R' index, all entries between old and new 'R' index
 * need to be reclaimed. As result, some free space forms. If there is
 * enough free space (> low mark), wake the stack that feeds us.
Z
Zhu Yi 已提交
3185
 */
C
Christoph Hellwig 已提交
3186
static int iwl3945_tx_queue_reclaim(struct iwl3945_priv *priv, int txq_id, int index)
Z
Zhu Yi 已提交
3187
{
C
Christoph Hellwig 已提交
3188 3189
	struct iwl3945_tx_queue *txq = &priv->txq[txq_id];
	struct iwl3945_queue *q = &txq->q;
Z
Zhu Yi 已提交
3190 3191 3192 3193 3194
	int nfreed = 0;

	if ((index >= q->n_bd) || (x2_queue_used(q, index) == 0)) {
		IWL_ERROR("Read index for DMA queue txq id (%d), index %d, "
			  "is out of range [0-%d] %d %d.\n", txq_id,
3195
			  index, q->n_bd, q->write_ptr, q->read_ptr);
Z
Zhu Yi 已提交
3196 3197 3198
		return 0;
	}

C
Christoph Hellwig 已提交
3199
	for (index = iwl3945_queue_inc_wrap(index, q->n_bd);
3200
		q->read_ptr != index;
C
Christoph Hellwig 已提交
3201
		q->read_ptr = iwl3945_queue_inc_wrap(q->read_ptr, q->n_bd)) {
Z
Zhu Yi 已提交
3202
		if (txq_id != IWL_CMD_QUEUE_NUM) {
C
Christoph Hellwig 已提交
3203
			iwl3945_txstatus_to_ieee(priv,
3204
					&(txq->txb[txq->q.read_ptr]));
C
Christoph Hellwig 已提交
3205
			iwl3945_hw_txq_free_tfd(priv, txq);
Z
Zhu Yi 已提交
3206 3207
		} else if (nfreed > 1) {
			IWL_ERROR("HCMD skipped: index (%d) %d %d\n", index,
3208
					q->write_ptr, q->read_ptr);
Z
Zhu Yi 已提交
3209 3210 3211 3212 3213
			queue_work(priv->workqueue, &priv->restart);
		}
		nfreed++;
	}

C
Christoph Hellwig 已提交
3214
	if (iwl3945_queue_space(q) > q->low_mark && (txq_id >= 0) &&
Z
Zhu Yi 已提交
3215 3216 3217 3218 3219 3220 3221 3222
			(txq_id != IWL_CMD_QUEUE_NUM) &&
			priv->mac80211_registered)
		ieee80211_wake_queue(priv->hw, txq_id);


	return nfreed;
}

C
Christoph Hellwig 已提交
3223
static int iwl3945_is_tx_success(u32 status)
Z
Zhu Yi 已提交
3224 3225 3226 3227 3228 3229 3230 3231 3232
{
	return (status & 0xFF) == 0x1;
}

/******************************************************************************
 *
 * Generic RX handler implementations
 *
 ******************************************************************************/
3233 3234 3235
/**
 * iwl3945_rx_reply_tx - Handle Tx response
 */
C
Christoph Hellwig 已提交
3236 3237
static void iwl3945_rx_reply_tx(struct iwl3945_priv *priv,
			    struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3238
{
C
Christoph Hellwig 已提交
3239
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
3240 3241 3242
	u16 sequence = le16_to_cpu(pkt->hdr.sequence);
	int txq_id = SEQ_TO_QUEUE(sequence);
	int index = SEQ_TO_INDEX(sequence);
C
Christoph Hellwig 已提交
3243
	struct iwl3945_tx_queue *txq = &priv->txq[txq_id];
Z
Zhu Yi 已提交
3244
	struct ieee80211_tx_status *tx_status;
C
Christoph Hellwig 已提交
3245
	struct iwl3945_tx_resp *tx_resp = (void *)&pkt->u.raw[0];
Z
Zhu Yi 已提交
3246 3247 3248 3249 3250
	u32  status = le32_to_cpu(tx_resp->status);

	if ((index >= txq->q.n_bd) || (x2_queue_used(&txq->q, index) == 0)) {
		IWL_ERROR("Read index for DMA queue txq_id (%d) index %d "
			  "is out of range [0-%d] %d %d\n", txq_id,
3251 3252
			  index, txq->q.n_bd, txq->q.write_ptr,
			  txq->q.read_ptr);
Z
Zhu Yi 已提交
3253 3254 3255
		return;
	}

3256
	tx_status = &(txq->txb[txq->q.read_ptr].status);
Z
Zhu Yi 已提交
3257 3258 3259 3260 3261 3262 3263

	tx_status->retry_count = tx_resp->failure_frame;
	tx_status->queue_number = status;
	tx_status->queue_length = tx_resp->bt_kill_count;
	tx_status->queue_length |= tx_resp->failure_rts;

	tx_status->flags =
C
Christoph Hellwig 已提交
3264
	    iwl3945_is_tx_success(status) ? IEEE80211_TX_STATUS_ACK : 0;
Z
Zhu Yi 已提交
3265 3266

	IWL_DEBUG_TX("Tx queue %d Status %s (0x%08x) plcp rate %d retries %d\n",
C
Christoph Hellwig 已提交
3267
			txq_id, iwl3945_get_tx_fail_reason(status), status,
Z
Zhu Yi 已提交
3268 3269 3270 3271
			tx_resp->rate, tx_resp->failure_frame);

	IWL_DEBUG_TX_REPLY("Tx queue reclaim %d\n", index);
	if (index != -1)
C
Christoph Hellwig 已提交
3272
		iwl3945_tx_queue_reclaim(priv, txq_id, index);
Z
Zhu Yi 已提交
3273 3274 3275 3276 3277 3278

	if (iwl_check_bits(status, TX_ABORT_REQUIRED_MSK))
		IWL_ERROR("TODO:  Implement Tx ABORT REQUIRED!!!\n");
}


C
Christoph Hellwig 已提交
3279 3280
static void iwl3945_rx_reply_alive(struct iwl3945_priv *priv,
			       struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3281
{
C
Christoph Hellwig 已提交
3282 3283
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_alive_resp *palive;
Z
Zhu Yi 已提交
3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296
	struct delayed_work *pwork;

	palive = &pkt->u.alive_frame;

	IWL_DEBUG_INFO("Alive ucode status 0x%08X revision "
		       "0x%01X 0x%01X\n",
		       palive->is_valid, palive->ver_type,
		       palive->ver_subtype);

	if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
		IWL_DEBUG_INFO("Initialization Alive received.\n");
		memcpy(&priv->card_alive_init,
		       &pkt->u.alive_frame,
C
Christoph Hellwig 已提交
3297
		       sizeof(struct iwl3945_init_alive_resp));
Z
Zhu Yi 已提交
3298 3299 3300 3301
		pwork = &priv->init_alive_start;
	} else {
		IWL_DEBUG_INFO("Runtime Alive received.\n");
		memcpy(&priv->card_alive, &pkt->u.alive_frame,
C
Christoph Hellwig 已提交
3302
		       sizeof(struct iwl3945_alive_resp));
Z
Zhu Yi 已提交
3303
		pwork = &priv->alive_start;
C
Christoph Hellwig 已提交
3304
		iwl3945_disable_events(priv);
Z
Zhu Yi 已提交
3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315
	}

	/* 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
		IWL_WARNING("uCode did not respond OK.\n");
}

C
Christoph Hellwig 已提交
3316 3317
static void iwl3945_rx_reply_add_sta(struct iwl3945_priv *priv,
				 struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3318
{
C
Christoph Hellwig 已提交
3319
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
3320 3321 3322 3323 3324

	IWL_DEBUG_RX("Received REPLY_ADD_STA: 0x%02X\n", pkt->u.status);
	return;
}

C
Christoph Hellwig 已提交
3325 3326
static void iwl3945_rx_reply_error(struct iwl3945_priv *priv,
			       struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3327
{
C
Christoph Hellwig 已提交
3328
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340

	IWL_ERROR("Error Reply type 0x%08X cmd %s (0x%02X) "
		"seq 0x%04X ser 0x%08X\n",
		le32_to_cpu(pkt->u.err_resp.error_type),
		get_cmd_string(pkt->u.err_resp.cmd_id),
		pkt->u.err_resp.cmd_id,
		le16_to_cpu(pkt->u.err_resp.bad_cmd_seq_num),
		le32_to_cpu(pkt->u.err_resp.error_info));
}

#define TX_STATUS_ENTRY(x) case TX_STATUS_FAIL_ ## x: return #x

C
Christoph Hellwig 已提交
3341
static void iwl3945_rx_csa(struct iwl3945_priv *priv, struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3342
{
C
Christoph Hellwig 已提交
3343 3344 3345
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_rxon_cmd *rxon = (void *)&priv->active_rxon;
	struct iwl3945_csa_notification *csa = &(pkt->u.csa_notif);
Z
Zhu Yi 已提交
3346 3347 3348 3349 3350 3351
	IWL_DEBUG_11H("CSA notif: channel %d, status %d\n",
		      le16_to_cpu(csa->channel), le32_to_cpu(csa->status));
	rxon->channel = csa->channel;
	priv->staging_rxon.channel = csa->channel;
}

C
Christoph Hellwig 已提交
3352 3353
static void iwl3945_rx_spectrum_measure_notif(struct iwl3945_priv *priv,
					  struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3354
{
3355
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
C
Christoph Hellwig 已提交
3356 3357
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_spectrum_notification *report = &(pkt->u.spectrum_notif);
Z
Zhu Yi 已提交
3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369

	if (!report->state) {
		IWL_DEBUG(IWL_DL_11H | IWL_DL_INFO,
			  "Spectrum Measure Notification: Start\n");
		return;
	}

	memcpy(&priv->measure_report, report, sizeof(*report));
	priv->measurement_status |= MEASUREMENT_READY;
#endif
}

C
Christoph Hellwig 已提交
3370 3371
static void iwl3945_rx_pm_sleep_notif(struct iwl3945_priv *priv,
				  struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3372
{
3373
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
3374 3375
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_sleep_notification *sleep = &(pkt->u.sleep_notif);
Z
Zhu Yi 已提交
3376 3377 3378 3379 3380
	IWL_DEBUG_RX("sleep mode: %d, src: %d\n",
		     sleep->pm_sleep_mode, sleep->pm_wakeup_src);
#endif
}

C
Christoph Hellwig 已提交
3381 3382
static void iwl3945_rx_pm_debug_statistics_notif(struct iwl3945_priv *priv,
					     struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3383
{
C
Christoph Hellwig 已提交
3384
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
3385 3386 3387
	IWL_DEBUG_RADIO("Dumping %d bytes of unhandled "
			"notification for %s:\n",
			le32_to_cpu(pkt->len), get_cmd_string(pkt->hdr.cmd));
C
Christoph Hellwig 已提交
3388
	iwl3945_print_hex_dump(IWL_DL_RADIO, pkt->u.raw, le32_to_cpu(pkt->len));
Z
Zhu Yi 已提交
3389 3390
}

C
Christoph Hellwig 已提交
3391
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
3392
{
C
Christoph Hellwig 已提交
3393 3394
	struct iwl3945_priv *priv =
		container_of(work, struct iwl3945_priv, beacon_update);
Z
Zhu Yi 已提交
3395 3396 3397
	struct sk_buff *beacon;

	/* Pull updated AP beacon from mac80211. will fail if not in AP mode */
3398
	beacon = ieee80211_beacon_get(priv->hw, priv->vif, NULL);
Z
Zhu Yi 已提交
3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412

	if (!beacon) {
		IWL_ERROR("update beacon failed\n");
		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 已提交
3413
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3414 3415
}

C
Christoph Hellwig 已提交
3416 3417
static void iwl3945_rx_beacon_notif(struct iwl3945_priv *priv,
				struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3418
{
3419
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
3420 3421
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438
	u8 rate = beacon->beacon_notify_hdr.rate;

	IWL_DEBUG_RX("beacon status %x retries %d iss %d "
		"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

	if ((priv->iw_mode == IEEE80211_IF_TYPE_AP) &&
	    (!test_bit(STATUS_EXIT_PENDING, &priv->status)))
		queue_work(priv->workqueue, &priv->beacon_update);
}

/* Service response to REPLY_SCAN_CMD (0x80) */
C
Christoph Hellwig 已提交
3439 3440
static void iwl3945_rx_reply_scan(struct iwl3945_priv *priv,
			      struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3441
{
3442
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
3443 3444 3445
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_scanreq_notification *notif =
	    (struct iwl3945_scanreq_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
3446 3447 3448 3449 3450 3451

	IWL_DEBUG_RX("Scan request status = 0x%x\n", notif->status);
#endif
}

/* Service SCAN_START_NOTIFICATION (0x82) */
C
Christoph Hellwig 已提交
3452 3453
static void iwl3945_rx_scan_start_notif(struct iwl3945_priv *priv,
				    struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3454
{
C
Christoph Hellwig 已提交
3455 3456 3457
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_scanstart_notification *notif =
	    (struct iwl3945_scanstart_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468
	priv->scan_start_tsf = le32_to_cpu(notif->tsf_low);
	IWL_DEBUG_SCAN("Scan start: "
		       "%d [802.11%s] "
		       "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n",
		       notif->channel,
		       notif->band ? "bg" : "a",
		       notif->tsf_high,
		       notif->tsf_low, notif->status, notif->beacon_timer);
}

/* Service SCAN_RESULTS_NOTIFICATION (0x83) */
C
Christoph Hellwig 已提交
3469 3470
static void iwl3945_rx_scan_results_notif(struct iwl3945_priv *priv,
				      struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3471
{
C
Christoph Hellwig 已提交
3472 3473 3474
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_scanresults_notification *notif =
	    (struct iwl3945_scanresults_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489

	IWL_DEBUG_SCAN("Scan ch.res: "
		       "%d [802.11%s] "
		       "(TSF: 0x%08X:%08X) - %d "
		       "elapsed=%lu usec (%dms since last)\n",
		       notif->channel,
		       notif->band ? "bg" : "a",
		       le32_to_cpu(notif->tsf_high),
		       le32_to_cpu(notif->tsf_low),
		       le32_to_cpu(notif->statistics[0]),
		       le32_to_cpu(notif->tsf_low) - priv->scan_start_tsf,
		       jiffies_to_msecs(elapsed_jiffies
					(priv->last_scan_jiffies, jiffies)));

	priv->last_scan_jiffies = jiffies;
3490
	priv->next_scan_jiffies = 0;
Z
Zhu Yi 已提交
3491 3492 3493
}

/* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
C
Christoph Hellwig 已提交
3494 3495
static void iwl3945_rx_scan_complete_notif(struct iwl3945_priv *priv,
				       struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3496
{
C
Christoph Hellwig 已提交
3497 3498
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
Z
Zhu Yi 已提交
3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532

	IWL_DEBUG_SCAN("Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
		       scan_notif->scanned_channels,
		       scan_notif->tsf_low,
		       scan_notif->tsf_high, scan_notif->status);

	/* The HW is no longer scanning */
	clear_bit(STATUS_SCAN_HW, &priv->status);

	/* The scan completion notification came in, so kill that timer... */
	cancel_delayed_work(&priv->scan_check);

	IWL_DEBUG_INFO("Scan pass on %sGHz took %dms\n",
		       (priv->scan_bands == 2) ? "2.4" : "5.2",
		       jiffies_to_msecs(elapsed_jiffies
					(priv->scan_pass_start, jiffies)));

	/* Remove this scanned band from the list
	 * of pending bands to scan */
	priv->scan_bands--;

	/* If a request to abort was given, or the scan did not succeed
	 * then we reset the scan state machine and terminate,
	 * re-queuing another scan if one has been requested */
	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
		IWL_DEBUG_INFO("Aborted scan completed.\n");
		clear_bit(STATUS_SCAN_ABORTING, &priv->status);
	} else {
		/* If there are more bands on this scan pass reschedule */
		if (priv->scan_bands > 0)
			goto reschedule;
	}

	priv->last_scan_jiffies = jiffies;
3533
	priv->next_scan_jiffies = 0;
Z
Zhu Yi 已提交
3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551
	IWL_DEBUG_INFO("Setting scan to off\n");

	clear_bit(STATUS_SCANNING, &priv->status);

	IWL_DEBUG_INFO("Scan took %dms\n",
		jiffies_to_msecs(elapsed_jiffies(priv->scan_start, jiffies)));

	queue_work(priv->workqueue, &priv->scan_completed);

	return;

reschedule:
	priv->scan_pass_start = jiffies;
	queue_work(priv->workqueue, &priv->request_scan);
}

/* Handle notification from uCode that card's power state is changing
 * due to software, hardware, or critical temperature RFKILL */
C
Christoph Hellwig 已提交
3552 3553
static void iwl3945_rx_card_state_notif(struct iwl3945_priv *priv,
				    struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3554
{
C
Christoph Hellwig 已提交
3555
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
3556 3557 3558 3559 3560 3561 3562
	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
	unsigned long status = priv->status;

	IWL_DEBUG_RF_KILL("Card state received: HW:%s SW:%s\n",
			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
			  (flags & SW_CARD_DISABLED) ? "Kill" : "On");

C
Christoph Hellwig 已提交
3563
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576
		    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);

C
Christoph Hellwig 已提交
3577
	iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588

	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 已提交
3589
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
3590 3591 3592 3593 3594 3595 3596
 *
 * 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.
 */
C
Christoph Hellwig 已提交
3597
static void iwl3945_setup_rx_handlers(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3598
{
C
Christoph Hellwig 已提交
3599 3600 3601 3602
	priv->rx_handlers[REPLY_ALIVE] = iwl3945_rx_reply_alive;
	priv->rx_handlers[REPLY_ADD_STA] = iwl3945_rx_reply_add_sta;
	priv->rx_handlers[REPLY_ERROR] = iwl3945_rx_reply_error;
	priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl3945_rx_csa;
Z
Zhu Yi 已提交
3603
	priv->rx_handlers[SPECTRUM_MEASURE_NOTIFICATION] =
C
Christoph Hellwig 已提交
3604 3605
	    iwl3945_rx_spectrum_measure_notif;
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl3945_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
3606
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
C
Christoph Hellwig 已提交
3607 3608
	    iwl3945_rx_pm_debug_statistics_notif;
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
3609

3610 3611 3612 3613
	/*
	 * 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 已提交
3614
	 */
C
Christoph Hellwig 已提交
3615 3616
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
3617

C
Christoph Hellwig 已提交
3618 3619
	priv->rx_handlers[REPLY_SCAN_CMD] = iwl3945_rx_reply_scan;
	priv->rx_handlers[SCAN_START_NOTIFICATION] = iwl3945_rx_scan_start_notif;
Z
Zhu Yi 已提交
3620
	priv->rx_handlers[SCAN_RESULTS_NOTIFICATION] =
C
Christoph Hellwig 已提交
3621
	    iwl3945_rx_scan_results_notif;
Z
Zhu Yi 已提交
3622
	priv->rx_handlers[SCAN_COMPLETE_NOTIFICATION] =
C
Christoph Hellwig 已提交
3623 3624 3625
	    iwl3945_rx_scan_complete_notif;
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
	priv->rx_handlers[REPLY_TX] = iwl3945_rx_reply_tx;
Z
Zhu Yi 已提交
3626

3627
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
3628
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
3629 3630 3631
}

/**
C
Christoph Hellwig 已提交
3632
 * iwl3945_tx_cmd_complete - Pull unused buffers off the queue and reclaim them
Z
Zhu Yi 已提交
3633 3634 3635 3636 3637 3638
 * @rxb: Rx buffer to reclaim
 *
 * If an Rx buffer has an async callback associated with it the callback
 * will be executed.  The attached skb (if present) will only be freed
 * if the callback returns 1
 */
C
Christoph Hellwig 已提交
3639 3640
static void iwl3945_tx_cmd_complete(struct iwl3945_priv *priv,
				struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3641
{
C
Christoph Hellwig 已提交
3642
	struct iwl3945_rx_packet *pkt = (struct iwl3945_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
3643 3644 3645 3646 3647
	u16 sequence = le16_to_cpu(pkt->hdr.sequence);
	int txq_id = SEQ_TO_QUEUE(sequence);
	int index = SEQ_TO_INDEX(sequence);
	int huge = sequence & SEQ_HUGE_FRAME;
	int cmd_index;
C
Christoph Hellwig 已提交
3648
	struct iwl3945_cmd *cmd;
Z
Zhu Yi 已提交
3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668

	/* If a Tx command is being handled and it isn't in the actual
	 * command queue then there a command routing bug has been introduced
	 * in the queue management code. */
	if (txq_id != IWL_CMD_QUEUE_NUM)
		IWL_ERROR("Error wrong command queue %d command id 0x%X\n",
			  txq_id, pkt->hdr.cmd);
	BUG_ON(txq_id != IWL_CMD_QUEUE_NUM);

	cmd_index = get_cmd_index(&priv->txq[IWL_CMD_QUEUE_NUM].q, index, huge);
	cmd = &priv->txq[IWL_CMD_QUEUE_NUM].cmd[cmd_index];

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

C
Christoph Hellwig 已提交
3669
	iwl3945_tx_queue_reclaim(priv, txq_id, index);
Z
Zhu Yi 已提交
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 3698

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

/************************** RX-FUNCTIONS ****************************/
/*
 * Rx theory of operation
 *
 * The host allocates 32 DMA target addresses and passes the host address
 * to the firmware at register IWL_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
 * 0 to 31
 *
 * Rx Queue Indexes
 * The host/firmware share two index registers for managing the Rx buffers.
 *
 * The READ index maps to the first position that the firmware may be writing
 * to -- the driver can read up to (but not including) this position and get
 * good data.
 * The READ index is managed by the firmware once the card is enabled.
 *
 * The WRITE index maps to the last position the driver has read from -- the
 * position preceding WRITE is the last slot the firmware can place a packet.
 *
 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
 * WRITE = READ.
 *
3699
 * During initialization, the host sets up the READ queue position to the first
Z
Zhu Yi 已提交
3700 3701
 * INDEX position, and WRITE to the last (READ - 1 wrapped)
 *
3702
 * When the firmware places a packet in a buffer, it will advance the READ index
Z
Zhu Yi 已提交
3703 3704 3705 3706 3707 3708 3709
 * 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
3710
 *   to replenish the iwl->rxq->rx_free.
C
Christoph Hellwig 已提交
3711
 * + In iwl3945_rx_replenish (scheduled) if 'processed' != 'read' then the
Z
Zhu Yi 已提交
3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723
 *   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:
 *
3724 3725
 * iwl3945_rx_queue_alloc()   Allocates rx_free
 * iwl3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
C
Christoph Hellwig 已提交
3726
 *                            iwl3945_rx_queue_restock
3727
 * iwl3945_rx_queue_restock() Moves available buffers from rx_free into Rx
Z
Zhu Yi 已提交
3728 3729
 *                            queue, updates firmware pointers, and updates
 *                            the WRITE index.  If insufficient rx_free buffers
C
Christoph Hellwig 已提交
3730
 *                            are available, schedules iwl3945_rx_replenish
Z
Zhu Yi 已提交
3731 3732
 *
 * -- enable interrupts --
3733
 * ISR - iwl3945_rx()         Detach iwl3945_rx_mem_buffers from pool up to the
Z
Zhu Yi 已提交
3734 3735
 *                            READ INDEX, detaching the SKB from the pool.
 *                            Moves the packet buffer from queue to rx_used.
C
Christoph Hellwig 已提交
3736
 *                            Calls iwl3945_rx_queue_restock to refill any empty
Z
Zhu Yi 已提交
3737 3738 3739 3740 3741 3742
 *                            slots.
 * ...
 *
 */

/**
C
Christoph Hellwig 已提交
3743
 * iwl3945_rx_queue_space - Return number of free slots available in queue.
Z
Zhu Yi 已提交
3744
 */
C
Christoph Hellwig 已提交
3745
static int iwl3945_rx_queue_space(const struct iwl3945_rx_queue *q)
Z
Zhu Yi 已提交
3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757
{
	int s = q->read - q->write;
	if (s <= 0)
		s += RX_QUEUE_SIZE;
	/* keep some buffer to not confuse full and empty queue */
	s -= 2;
	if (s < 0)
		s = 0;
	return s;
}

/**
C
Christoph Hellwig 已提交
3758
 * iwl3945_rx_queue_update_write_ptr - Update the write pointer for the RX queue
Z
Zhu Yi 已提交
3759
 */
C
Christoph Hellwig 已提交
3760
int iwl3945_rx_queue_update_write_ptr(struct iwl3945_priv *priv, struct iwl3945_rx_queue *q)
Z
Zhu Yi 已提交
3761 3762 3763 3764 3765 3766 3767 3768 3769 3770
{
	u32 reg = 0;
	int rc = 0;
	unsigned long flags;

	spin_lock_irqsave(&q->lock, flags);

	if (q->need_update == 0)
		goto exit_unlock;

3771
	/* If power-saving is in use, make sure device is awake */
Z
Zhu Yi 已提交
3772
	if (test_bit(STATUS_POWER_PMI, &priv->status)) {
C
Christoph Hellwig 已提交
3773
		reg = iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
Z
Zhu Yi 已提交
3774 3775

		if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
C
Christoph Hellwig 已提交
3776
			iwl3945_set_bit(priv, CSR_GP_CNTRL,
Z
Zhu Yi 已提交
3777 3778 3779 3780
				    CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
			goto exit_unlock;
		}

C
Christoph Hellwig 已提交
3781
		rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
3782 3783 3784
		if (rc)
			goto exit_unlock;

3785
		/* Device expects a multiple of 8 */
C
Christoph Hellwig 已提交
3786
		iwl3945_write_direct32(priv, FH_RSCSR_CHNL0_WPTR,
Z
Zhu Yi 已提交
3787
				     q->write & ~0x7);
C
Christoph Hellwig 已提交
3788
		iwl3945_release_nic_access(priv);
3789 3790

	/* Else device is assumed to be awake */
Z
Zhu Yi 已提交
3791
	} else
3792
		/* Device expects a multiple of 8 */
C
Christoph Hellwig 已提交
3793
		iwl3945_write32(priv, FH_RSCSR_CHNL0_WPTR, q->write & ~0x7);
Z
Zhu Yi 已提交
3794 3795 3796 3797 3798 3799 3800 3801 3802 3803


	q->need_update = 0;

 exit_unlock:
	spin_unlock_irqrestore(&q->lock, flags);
	return rc;
}

/**
3804
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
3805
 */
C
Christoph Hellwig 已提交
3806
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
3807 3808 3809 3810 3811 3812
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

/**
C
Christoph Hellwig 已提交
3813
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
3814
 *
3815
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
3816
 * and we have free pre-allocated buffers, fill the ranks as much
3817
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
3818 3819 3820 3821 3822
 *
 * 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.
 */
C
Christoph Hellwig 已提交
3823
static int iwl3945_rx_queue_restock(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3824
{
C
Christoph Hellwig 已提交
3825
	struct iwl3945_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3826
	struct list_head *element;
C
Christoph Hellwig 已提交
3827
	struct iwl3945_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
3828 3829 3830 3831 3832
	unsigned long flags;
	int write, rc;

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
C
Christoph Hellwig 已提交
3833
	while ((iwl3945_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
3834
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
3835
		element = rxq->rx_free.next;
C
Christoph Hellwig 已提交
3836
		rxb = list_entry(element, struct iwl3945_rx_mem_buffer, list);
Z
Zhu Yi 已提交
3837
		list_del(element);
3838 3839

		/* Point to Rx buffer via next RBD in circular buffer */
C
Christoph Hellwig 已提交
3840
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->dma_addr);
Z
Zhu Yi 已提交
3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851
		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);


3852 3853
	/* 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 已提交
3854 3855 3856 3857 3858
	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);
C
Christoph Hellwig 已提交
3859
		rc = iwl3945_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
3860 3861 3862 3863 3864 3865 3866 3867
		if (rc)
			return rc;
	}

	return 0;
}

/**
C
Christoph Hellwig 已提交
3868
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
3869 3870 3871
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
3872
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
3873
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
3874
 */
3875
static void iwl3945_rx_allocate(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3876
{
C
Christoph Hellwig 已提交
3877
	struct iwl3945_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3878
	struct list_head *element;
C
Christoph Hellwig 已提交
3879
	struct iwl3945_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
3880 3881 3882 3883
	unsigned long flags;
	spin_lock_irqsave(&rxq->lock, flags);
	while (!list_empty(&rxq->rx_used)) {
		element = rxq->rx_used.next;
C
Christoph Hellwig 已提交
3884
		rxb = list_entry(element, struct iwl3945_rx_mem_buffer, list);
3885 3886

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897
		rxb->skb =
		    alloc_skb(IWL_RX_BUF_SIZE, __GFP_NOWARN | GFP_ATOMIC);
		if (!rxb->skb) {
			if (net_ratelimit())
				printk(KERN_CRIT DRV_NAME
				       ": Can not allocate SKB buffers\n");
			/* 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 已提交
3898 3899 3900 3901 3902 3903 3904 3905 3906

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

Z
Zhu Yi 已提交
3907 3908
		priv->alloc_rxb_skb++;
		list_del(element);
3909 3910

		/* Get physical address of RB/SKB */
Z
Zhu Yi 已提交
3911 3912 3913 3914 3915 3916 3917
		rxb->dma_addr =
		    pci_map_single(priv->pci_dev, rxb->skb->data,
				   IWL_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);
3918 3919 3920 3921 3922
}

/*
 * this should be called while priv->lock is locked
 */
3923
static void __iwl3945_rx_replenish(void *data)
3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937
{
	struct iwl3945_priv *priv = data;

	iwl3945_rx_allocate(priv);
	iwl3945_rx_queue_restock(priv);
}


void iwl3945_rx_replenish(void *data)
{
	struct iwl3945_priv *priv = data;
	unsigned long flags;

	iwl3945_rx_allocate(priv);
Z
Zhu Yi 已提交
3938 3939

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
3940
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
3941 3942 3943 3944
	spin_unlock_irqrestore(&priv->lock, flags);
}

/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
3945
 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
Z
Zhu Yi 已提交
3946 3947 3948
 * This free routine walks the list of POOL entries and if SKB is set to
 * non NULL it is unmapped and freed
 */
C
Christoph Hellwig 已提交
3949
static void iwl3945_rx_queue_free(struct iwl3945_priv *priv, struct iwl3945_rx_queue *rxq)
Z
Zhu Yi 已提交
3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965
{
	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].dma_addr,
					 IWL_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);
	rxq->bd = NULL;
}

C
Christoph Hellwig 已提交
3966
int iwl3945_rx_queue_alloc(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3967
{
C
Christoph Hellwig 已提交
3968
	struct iwl3945_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3969 3970 3971 3972 3973 3974
	struct pci_dev *dev = priv->pci_dev;
	int i;

	spin_lock_init(&rxq->lock);
	INIT_LIST_HEAD(&rxq->rx_free);
	INIT_LIST_HEAD(&rxq->rx_used);
3975 3976

	/* Alloc the circular buffer of Read Buffer Descriptors (RBDs) */
Z
Zhu Yi 已提交
3977 3978 3979
	rxq->bd = pci_alloc_consistent(dev, 4 * RX_QUEUE_SIZE, &rxq->dma_addr);
	if (!rxq->bd)
		return -ENOMEM;
3980

Z
Zhu Yi 已提交
3981 3982 3983
	/* Fill the rx_used queue with _all_ of the Rx buffers */
	for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
		list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3984

Z
Zhu Yi 已提交
3985 3986 3987 3988 3989 3990 3991 3992
	/* 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;
	rxq->need_update = 0;
	return 0;
}

C
Christoph Hellwig 已提交
3993
void iwl3945_rx_queue_reset(struct iwl3945_priv *priv, struct iwl3945_rx_queue *rxq)
Z
Zhu Yi 已提交
3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039
{
	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].dma_addr,
					 IWL_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);
}

/* 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 已提交
4040
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
4041
{
4042 4043
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
4044 4045
		return 60;

4046
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
4047
	 *   add 20 dB to make up for divide by 10 */
4048
	if (sig_ratio >= 100)
Z
Zhu Yi 已提交
4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065
		return (20 + (int)ratio2dB[sig_ratio/10]);

	/* 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 已提交
4066
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100
{
	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;
}

/**
4101
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
4102 4103 4104 4105 4106
 *
 * Uses the priv->rx_handlers callback function array to invoke
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
C
Christoph Hellwig 已提交
4107
static void iwl3945_rx_handle(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4108
{
C
Christoph Hellwig 已提交
4109 4110 4111
	struct iwl3945_rx_mem_buffer *rxb;
	struct iwl3945_rx_packet *pkt;
	struct iwl3945_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
4112 4113 4114
	u32 r, i;
	int reclaim;
	unsigned long flags;
4115
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
4116
	u32 count = 8;
Z
Zhu Yi 已提交
4117

4118 4119
	/* uCode's read index (stored in shared DRAM) indicates the last Rx
	 * buffer that the driver may process (last buffer filled by ucode). */
C
Christoph Hellwig 已提交
4120
	r = iwl3945_hw_get_rx_read(priv);
Z
Zhu Yi 已提交
4121 4122
	i = rxq->read;

4123 4124
	if (iwl3945_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
		fill_rx = 1;
Z
Zhu Yi 已提交
4125 4126 4127 4128 4129 4130 4131
	/* Rx interrupt, but nothing sent from uCode */
	if (i == r)
		IWL_DEBUG(IWL_DL_RX | IWL_DL_ISR, "r = %d, i = %d\n", r, i);

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

4132
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
4133 4134 4135 4136 4137 4138 4139 4140 4141
		 * then a bug has been introduced in the queue refilling
		 * routines -- catch it here */
		BUG_ON(rxb == NULL);

		rxq->queue[i] = NULL;

		pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
					    IWL_RX_BUF_SIZE,
					    PCI_DMA_FROMDEVICE);
C
Christoph Hellwig 已提交
4142
		pkt = (struct iwl3945_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155

		/* 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 已提交
4156
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170
		if (priv->rx_handlers[pkt->hdr.cmd]) {
			IWL_DEBUG(IWL_DL_HOST_COMMAND | IWL_DL_RX | IWL_DL_ISR,
				"r = %d, i = %d, %s, 0x%02x\n", r, i,
				get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
			priv->rx_handlers[pkt->hdr.cmd] (priv, rxb);
		} else {
			/* No handling needed */
			IWL_DEBUG(IWL_DL_HOST_COMMAND | IWL_DL_RX | IWL_DL_ISR,
				"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) {
4171 4172
			/* Invoke any callbacks, transfer the skb to caller, and
			 * fire off the (possibly) blocking iwl3945_send_cmd()
Z
Zhu Yi 已提交
4173 4174
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
C
Christoph Hellwig 已提交
4175
				iwl3945_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194
			else
				IWL_WARNING("Claim null rxb?\n");
		}

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

		pci_unmap_single(priv->pci_dev, rxb->dma_addr,
				 IWL_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
		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;
4195 4196 4197 4198 4199 4200 4201 4202 4203 4204
		/* If there are a lot of unused frames,
		 * restock the Rx queue so ucode won't assert. */
		if (fill_rx) {
			count++;
			if (count >= 8) {
				priv->rxq.read = i;
				__iwl3945_rx_replenish(priv);
				count = 0;
			}
		}
Z
Zhu Yi 已提交
4205 4206 4207 4208
	}

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

4212 4213 4214
/**
 * iwl3945_tx_queue_update_write_ptr - Send new write index to hardware
 */
C
Christoph Hellwig 已提交
4215 4216
static int iwl3945_tx_queue_update_write_ptr(struct iwl3945_priv *priv,
				  struct iwl3945_tx_queue *txq)
Z
Zhu Yi 已提交
4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229
{
	u32 reg = 0;
	int rc = 0;
	int txq_id = txq->q.id;

	if (txq->need_update == 0)
		return rc;

	/* if we're trying to save power */
	if (test_bit(STATUS_POWER_PMI, &priv->status)) {
		/* wake up nic if it's powered down ...
		 * uCode will wake up, and interrupt us again, so next
		 * time we'll skip this part. */
C
Christoph Hellwig 已提交
4230
		reg = iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
Z
Zhu Yi 已提交
4231 4232 4233

		if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
			IWL_DEBUG_INFO("Requesting wakeup, GP1 = 0x%x\n", reg);
C
Christoph Hellwig 已提交
4234
			iwl3945_set_bit(priv, CSR_GP_CNTRL,
Z
Zhu Yi 已提交
4235 4236 4237 4238 4239
				    CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
			return rc;
		}

		/* restore this queue's parameters in nic hardware. */
C
Christoph Hellwig 已提交
4240
		rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
4241 4242
		if (rc)
			return rc;
C
Christoph Hellwig 已提交
4243
		iwl3945_write_direct32(priv, HBUS_TARG_WRPTR,
4244
				     txq->q.write_ptr | (txq_id << 8));
C
Christoph Hellwig 已提交
4245
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4246 4247 4248 4249

	/* else not in power-save mode, uCode will never sleep when we're
	 * trying to tx (during RFKILL, we're not trying to tx). */
	} else
C
Christoph Hellwig 已提交
4250
		iwl3945_write32(priv, HBUS_TARG_WRPTR,
4251
			    txq->q.write_ptr | (txq_id << 8));
Z
Zhu Yi 已提交
4252 4253 4254 4255 4256 4257

	txq->need_update = 0;

	return rc;
}

4258
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
4259
static void iwl3945_print_rx_config_cmd(struct iwl3945_rxon_cmd *rxon)
Z
Zhu Yi 已提交
4260
{
4261 4262
	DECLARE_MAC_BUF(mac);

Z
Zhu Yi 已提交
4263
	IWL_DEBUG_RADIO("RX CONFIG:\n");
C
Christoph Hellwig 已提交
4264
	iwl3945_print_hex_dump(IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
Z
Zhu Yi 已提交
4265 4266 4267 4268 4269 4270 4271 4272
	IWL_DEBUG_RADIO("u16 channel: 0x%x\n", le16_to_cpu(rxon->channel));
	IWL_DEBUG_RADIO("u32 flags: 0x%08X\n", le32_to_cpu(rxon->flags));
	IWL_DEBUG_RADIO("u32 filter_flags: 0x%08x\n",
			le32_to_cpu(rxon->filter_flags));
	IWL_DEBUG_RADIO("u8 dev_type: 0x%x\n", rxon->dev_type);
	IWL_DEBUG_RADIO("u8 ofdm_basic_rates: 0x%02x\n",
			rxon->ofdm_basic_rates);
	IWL_DEBUG_RADIO("u8 cck_basic_rates: 0x%02x\n", rxon->cck_basic_rates);
4273 4274 4275 4276
	IWL_DEBUG_RADIO("u8[6] node_addr: %s\n",
			print_mac(mac, rxon->node_addr));
	IWL_DEBUG_RADIO("u8[6] bssid_addr: %s\n",
			print_mac(mac, rxon->bssid_addr));
Z
Zhu Yi 已提交
4277 4278 4279 4280
	IWL_DEBUG_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
}
#endif

C
Christoph Hellwig 已提交
4281
static void iwl3945_enable_interrupts(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4282 4283 4284
{
	IWL_DEBUG_ISR("Enabling interrupts\n");
	set_bit(STATUS_INT_ENABLED, &priv->status);
C
Christoph Hellwig 已提交
4285
	iwl3945_write32(priv, CSR_INT_MASK, CSR_INI_SET_MASK);
Z
Zhu Yi 已提交
4286 4287
}

C
Christoph Hellwig 已提交
4288
static inline void iwl3945_disable_interrupts(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4289 4290 4291 4292
{
	clear_bit(STATUS_INT_ENABLED, &priv->status);

	/* disable interrupts from uCode/NIC to host */
C
Christoph Hellwig 已提交
4293
	iwl3945_write32(priv, CSR_INT_MASK, 0x00000000);
Z
Zhu Yi 已提交
4294 4295 4296

	/* acknowledge/clear/reset any interrupts still pending
	 * from uCode or flow handler (Rx/Tx DMA) */
C
Christoph Hellwig 已提交
4297 4298
	iwl3945_write32(priv, CSR_INT, 0xffffffff);
	iwl3945_write32(priv, CSR_FH_INT_STATUS, 0xffffffff);
Z
Zhu Yi 已提交
4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324
	IWL_DEBUG_ISR("Disabled interrupts\n");
}

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))

C
Christoph Hellwig 已提交
4325
static void iwl3945_dump_nic_error_log(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4326 4327 4328 4329 4330 4331 4332 4333
{
	u32 i;
	u32 desc, time, count, base, data1;
	u32 blink1, blink2, ilink1, ilink2;
	int rc;

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

C
Christoph Hellwig 已提交
4334
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
Z
Zhu Yi 已提交
4335 4336 4337 4338
		IWL_ERROR("Not valid error log pointer 0x%08X\n", base);
		return;
	}

C
Christoph Hellwig 已提交
4339
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
4340 4341 4342 4343 4344
	if (rc) {
		IWL_WARNING("Can not read from adapter at this time.\n");
		return;
	}

C
Christoph Hellwig 已提交
4345
	count = iwl3945_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
4346 4347 4348

	if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
		IWL_ERROR("Start IWL Error Log Dump:\n");
4349
		IWL_ERROR("Status: 0x%08lX, count: %d\n", priv->status, count);
Z
Zhu Yi 已提交
4350 4351 4352 4353 4354 4355 4356
	}

	IWL_ERROR("Desc       Time       asrtPC  blink2 "
		  "ilink1  nmiPC   Line\n");
	for (i = ERROR_START_OFFSET;
	     i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
	     i += ERROR_ELEM_SIZE) {
C
Christoph Hellwig 已提交
4357
		desc = iwl3945_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
4358
		time =
C
Christoph Hellwig 已提交
4359
		    iwl3945_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
4360
		blink1 =
C
Christoph Hellwig 已提交
4361
		    iwl3945_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
4362
		blink2 =
C
Christoph Hellwig 已提交
4363
		    iwl3945_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
4364
		ilink1 =
C
Christoph Hellwig 已提交
4365
		    iwl3945_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
4366
		ilink2 =
C
Christoph Hellwig 已提交
4367
		    iwl3945_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
4368
		data1 =
C
Christoph Hellwig 已提交
4369
		    iwl3945_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
4370 4371 4372 4373 4374 4375 4376

		IWL_ERROR
		    ("%-13s (#%d) %010u 0x%05X 0x%05X 0x%05X 0x%05X %u\n\n",
		     desc_lookup(desc), desc, time, blink1, blink2,
		     ilink1, ilink2, data1);
	}

C
Christoph Hellwig 已提交
4377
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4378 4379 4380

}

4381
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
4382 4383

/**
C
Christoph Hellwig 已提交
4384
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
4385
 *
C
Christoph Hellwig 已提交
4386
 * NOTE: Must be called with iwl3945_grab_nic_access() already obtained!
Z
Zhu Yi 已提交
4387
 */
C
Christoph Hellwig 已提交
4388
static void iwl3945_print_event_log(struct iwl3945_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411
				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++) {
C
Christoph Hellwig 已提交
4412
		ev = iwl3945_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
4413
		ptr += sizeof(u32);
C
Christoph Hellwig 已提交
4414
		time = iwl3945_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
4415 4416 4417 4418
		ptr += sizeof(u32);
		if (mode == 0)
			IWL_ERROR("0x%08x\t%04u\n", time, ev); /* data, ev */
		else {
C
Christoph Hellwig 已提交
4419
			data = iwl3945_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
4420 4421 4422 4423 4424 4425
			ptr += sizeof(u32);
			IWL_ERROR("%010u\t0x%08x\t%04u\n", time, data, ev);
		}
	}
}

C
Christoph Hellwig 已提交
4426
static void iwl3945_dump_nic_event_log(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4427 4428 4429 4430 4431 4432 4433 4434 4435 4436
{
	int rc;
	u32 base;       /* SRAM byte address of event log header */
	u32 capacity;   /* event log capacity in # entries */
	u32 mode;       /* 0 - no timestamp, 1 - timestamp recorded */
	u32 num_wraps;  /* # times uCode wrapped to top of log */
	u32 next_entry; /* index of next entry to be written by uCode */
	u32 size;       /* # entries that we'll print */

	base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
C
Christoph Hellwig 已提交
4437
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
Z
Zhu Yi 已提交
4438 4439 4440 4441
		IWL_ERROR("Invalid event log pointer 0x%08X\n", base);
		return;
	}

C
Christoph Hellwig 已提交
4442
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
4443 4444 4445 4446 4447 4448
	if (rc) {
		IWL_WARNING("Can not read from adapter at this time.\n");
		return;
	}

	/* event log header */
C
Christoph Hellwig 已提交
4449 4450 4451 4452
	capacity = iwl3945_read_targ_mem(priv, base);
	mode = iwl3945_read_targ_mem(priv, base + (1 * sizeof(u32)));
	num_wraps = iwl3945_read_targ_mem(priv, base + (2 * sizeof(u32)));
	next_entry = iwl3945_read_targ_mem(priv, base + (3 * sizeof(u32)));
Z
Zhu Yi 已提交
4453 4454 4455 4456 4457

	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
4458
		IWL_ERROR("Start IWL Event Log Dump: nothing in log\n");
C
Christoph Hellwig 已提交
4459
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4460 4461 4462
		return;
	}

4463
	IWL_ERROR("Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
4464 4465 4466 4467 4468
		  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 已提交
4469
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
4470 4471 4472
				    capacity - next_entry, mode);

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

C
Christoph Hellwig 已提交
4475
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4476 4477 4478
}

/**
C
Christoph Hellwig 已提交
4479
 * iwl3945_irq_handle_error - called for HW or SW error interrupt from card
Z
Zhu Yi 已提交
4480
 */
C
Christoph Hellwig 已提交
4481
static void iwl3945_irq_handle_error(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4482
{
C
Christoph Hellwig 已提交
4483
	/* Set the FW error flag -- cleared on iwl3945_down */
Z
Zhu Yi 已提交
4484 4485 4486 4487 4488
	set_bit(STATUS_FW_ERROR, &priv->status);

	/* Cancel currently queued command. */
	clear_bit(STATUS_HCMD_ACTIVE, &priv->status);

4489
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
4490 4491 4492 4493
	if (iwl3945_debug_level & IWL_DL_FW_ERRORS) {
		iwl3945_dump_nic_error_log(priv);
		iwl3945_dump_nic_event_log(priv);
		iwl3945_print_rx_config_cmd(&priv->staging_rxon);
Z
Zhu Yi 已提交
4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506
	}
#endif

	wake_up_interruptible(&priv->wait_command_queue);

	/* Keep the restart process from trying to send host
	 * commands by clearing the INIT status bit */
	clear_bit(STATUS_READY, &priv->status);

	if (!test_bit(STATUS_EXIT_PENDING, &priv->status)) {
		IWL_DEBUG(IWL_DL_INFO | IWL_DL_FW_ERRORS,
			  "Restarting adapter due to uCode error.\n");

C
Christoph Hellwig 已提交
4507
		if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
4508 4509 4510 4511 4512 4513 4514 4515
			memcpy(&priv->recovery_rxon, &priv->active_rxon,
			       sizeof(priv->recovery_rxon));
			priv->error_recovering = 1;
		}
		queue_work(priv->workqueue, &priv->restart);
	}
}

C
Christoph Hellwig 已提交
4516
static void iwl3945_error_recovery(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4517 4518 4519 4520 4521 4522
{
	unsigned long flags;

	memcpy(&priv->staging_rxon, &priv->recovery_rxon,
	       sizeof(priv->staging_rxon));
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
4523
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
4524

C
Christoph Hellwig 已提交
4525
	iwl3945_add_station(priv, priv->bssid, 1, 0);
Z
Zhu Yi 已提交
4526 4527 4528 4529 4530 4531 4532

	spin_lock_irqsave(&priv->lock, flags);
	priv->assoc_id = le16_to_cpu(priv->staging_rxon.assoc_id);
	priv->error_recovering = 0;
	spin_unlock_irqrestore(&priv->lock, flags);
}

C
Christoph Hellwig 已提交
4533
static void iwl3945_irq_tasklet(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4534 4535 4536 4537
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
4538
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
4539 4540 4541 4542 4543 4544 4545 4546
	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. */
C
Christoph Hellwig 已提交
4547 4548
	inta = iwl3945_read32(priv, CSR_INT);
	iwl3945_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
4549 4550 4551 4552

	/* 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. */
C
Christoph Hellwig 已提交
4553 4554
	inta_fh = iwl3945_read32(priv, CSR_FH_INT_STATUS);
	iwl3945_write32(priv, CSR_FH_INT_STATUS, inta_fh);
Z
Zhu Yi 已提交
4555

4556
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
4557
	if (iwl3945_debug_level & IWL_DL_ISR) {
4558 4559
		/* just for debug */
		inta_mask = iwl3945_read32(priv, CSR_INT_MASK);
Z
Zhu Yi 已提交
4560 4561 4562 4563 4564 4565 4566 4567 4568
		IWL_DEBUG_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
			      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 已提交
4569
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
4570
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
4571
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
4572 4573 4574 4575 4576 4577 4578
		inta |= CSR_INT_BIT_FH_TX;

	/* Now service all interrupt bits discovered above. */
	if (inta & CSR_INT_BIT_HW_ERR) {
		IWL_ERROR("Microcode HW error detected.  Restarting.\n");

		/* Tell the device to stop sending interrupts */
C
Christoph Hellwig 已提交
4579
		iwl3945_disable_interrupts(priv);
Z
Zhu Yi 已提交
4580

C
Christoph Hellwig 已提交
4581
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
4582 4583 4584 4585 4586 4587 4588 4589

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

4590
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
4591
	if (iwl3945_debug_level & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
4592
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
4593 4594 4595
		if (inta & CSR_INT_BIT_SCD)
			IWL_DEBUG_ISR("Scheduler finished to transmit "
				      "the frame/frames.\n");
Z
Zhu Yi 已提交
4596 4597 4598 4599 4600 4601 4602

		/* Alive notification via Rx interrupt will do the real work */
		if (inta & CSR_INT_BIT_ALIVE)
			IWL_DEBUG_ISR("Alive interrupt\n");
	}
#endif
	/* Safely ignore these bits for debug checks below */
4603
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
4604 4605 4606 4607

	/* HW RF KILL switch toggled (4965 only) */
	if (inta & CSR_INT_BIT_RF_KILL) {
		int hw_rf_kill = 0;
C
Christoph Hellwig 已提交
4608
		if (!(iwl3945_read32(priv, CSR_GP_CNTRL) &
Z
Zhu Yi 已提交
4609 4610 4611 4612 4613 4614 4615 4616 4617 4618
				CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
			hw_rf_kill = 1;

		IWL_DEBUG(IWL_DL_INFO | IWL_DL_RF_KILL | IWL_DL_ISR,
				"RF_KILL bit toggled to %s.\n",
				hw_rf_kill ? "disable radio":"enable radio");

		/* Queue restart only if RF_KILL switch was set to "kill"
		 *   when we loaded driver, and is now set to "enable".
		 * After we're Alive, RF_KILL gets handled by
4619
		 *   iwl3945_rx_card_state_notif() */
4620 4621
		if (!hw_rf_kill && !test_bit(STATUS_ALIVE, &priv->status)) {
			clear_bit(STATUS_RF_KILL_HW, &priv->status);
Z
Zhu Yi 已提交
4622
			queue_work(priv->workqueue, &priv->restart);
4623
		}
Z
Zhu Yi 已提交
4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637

		handled |= CSR_INT_BIT_RF_KILL;
	}

	/* Chip got too hot and stopped itself (4965 only) */
	if (inta & CSR_INT_BIT_CT_KILL) {
		IWL_ERROR("Microcode CT kill error detected.\n");
		handled |= CSR_INT_BIT_CT_KILL;
	}

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
		IWL_ERROR("Microcode SW error detected.  Restarting 0x%X.\n",
			  inta);
C
Christoph Hellwig 已提交
4638
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
4639 4640 4641 4642 4643 4644
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
		IWL_DEBUG_ISR("Wakeup interrupt\n");
C
Christoph Hellwig 已提交
4645 4646 4647 4648 4649 4650 4651
		iwl3945_rx_queue_update_write_ptr(priv, &priv->rxq);
		iwl3945_tx_queue_update_write_ptr(priv, &priv->txq[0]);
		iwl3945_tx_queue_update_write_ptr(priv, &priv->txq[1]);
		iwl3945_tx_queue_update_write_ptr(priv, &priv->txq[2]);
		iwl3945_tx_queue_update_write_ptr(priv, &priv->txq[3]);
		iwl3945_tx_queue_update_write_ptr(priv, &priv->txq[4]);
		iwl3945_tx_queue_update_write_ptr(priv, &priv->txq[5]);
Z
Zhu Yi 已提交
4652 4653 4654 4655 4656 4657 4658 4659

		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 已提交
4660
		iwl3945_rx_handle(priv);
Z
Zhu Yi 已提交
4661 4662 4663 4664 4665 4666
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

	if (inta & CSR_INT_BIT_FH_TX) {
		IWL_DEBUG_ISR("Tx interrupt\n");

C
Christoph Hellwig 已提交
4667 4668 4669
		iwl3945_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
		if (!iwl3945_grab_nic_access(priv)) {
			iwl3945_write_direct32(priv,
Z
Zhu Yi 已提交
4670 4671
					     FH_TCSR_CREDIT
					     (ALM_FH_SRVC_CHNL), 0x0);
C
Christoph Hellwig 已提交
4672
			iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686
		}
		handled |= CSR_INT_BIT_FH_TX;
	}

	if (inta & ~handled)
		IWL_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);

	if (inta & ~CSR_INI_SET_MASK) {
		IWL_WARNING("Disabled INTA bits 0x%08x were pending\n",
			 inta & ~CSR_INI_SET_MASK);
		IWL_WARNING("   with FH_INT = 0x%08x\n", inta_fh);
	}

	/* Re-enable all interrupts */
C
Christoph Hellwig 已提交
4687
	iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
4688

4689
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
4690 4691 4692 4693
	if (iwl3945_debug_level & (IWL_DL_ISR)) {
		inta = iwl3945_read32(priv, CSR_INT);
		inta_mask = iwl3945_read32(priv, CSR_INT_MASK);
		inta_fh = iwl3945_read32(priv, CSR_FH_INT_STATUS);
Z
Zhu Yi 已提交
4694 4695 4696 4697 4698 4699 4700
		IWL_DEBUG_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
	}
#endif
	spin_unlock_irqrestore(&priv->lock, flags);
}

C
Christoph Hellwig 已提交
4701
static irqreturn_t iwl3945_isr(int irq, void *data)
Z
Zhu Yi 已提交
4702
{
C
Christoph Hellwig 已提交
4703
	struct iwl3945_priv *priv = data;
Z
Zhu Yi 已提交
4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714
	u32 inta, inta_mask;
	u32 inta_fh;
	if (!priv)
		return IRQ_NONE;

	spin_lock(&priv->lock);

	/* Disable (but don't clear!) interrupts here to avoid
	 *    back-to-back ISRs and sporadic interrupts from our NIC.
	 * If we have something to service, the tasklet will re-enable ints.
	 * If we *don't* have something, we'll re-enable before leaving here. */
C
Christoph Hellwig 已提交
4715 4716
	inta_mask = iwl3945_read32(priv, CSR_INT_MASK);  /* just for debug */
	iwl3945_write32(priv, CSR_INT_MASK, 0x00000000);
Z
Zhu Yi 已提交
4717 4718

	/* Discover which interrupts are active/pending */
C
Christoph Hellwig 已提交
4719 4720
	inta = iwl3945_read32(priv, CSR_INT);
	inta_fh = iwl3945_read32(priv, CSR_FH_INT_STATUS);
Z
Zhu Yi 已提交
4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732

	/* Ignore interrupt if there's nothing in NIC to service.
	 * This may be due to IRQ shared with another device,
	 * or due to sporadic interrupts thrown from our NIC. */
	if (!inta && !inta_fh) {
		IWL_DEBUG_ISR("Ignore interrupt, inta == 0, inta_fh == 0\n");
		goto none;
	}

	if ((inta == 0xFFFFFFFF) || ((inta & 0xFFFFFFF0) == 0xa5a5a5a0)) {
		/* Hardware disappeared */
		IWL_WARNING("HARDWARE GONE?? INTA == 0x%080x\n", inta);
4733
		goto unplugged;
Z
Zhu Yi 已提交
4734 4735 4736 4737 4738
	}

	IWL_DEBUG_ISR("ISR inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
		      inta, inta_mask, inta_fh);

4739 4740
	inta &= ~CSR_INT_BIT_SCD;

C
Christoph Hellwig 已提交
4741
	/* iwl3945_irq_tasklet() will service interrupts and re-enable them */
4742 4743
	if (likely(inta || inta_fh))
		tasklet_schedule(&priv->irq_tasklet);
4744
unplugged:
Z
Zhu Yi 已提交
4745 4746 4747 4748 4749 4750
	spin_unlock(&priv->lock);

	return IRQ_HANDLED;

 none:
	/* re-enable interrupts here since we don't have anything to service. */
C
Christoph Hellwig 已提交
4751
	iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
4752 4753 4754 4755 4756 4757
	spin_unlock(&priv->lock);
	return IRQ_NONE;
}

/************************** EEPROM BANDS ****************************
 *
C
Christoph Hellwig 已提交
4758
 * The iwl3945_eeprom_band definitions below provide the mapping from the
Z
Zhu Yi 已提交
4759 4760 4761
 * EEPROM contents to the specific channel number supported for each
 * band.
 *
C
Christoph Hellwig 已提交
4762
 * For example, iwl3945_priv->eeprom.band_3_channels[4] from the band_3
Z
Zhu Yi 已提交
4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787
 * definition below maps to physical channel 42 in the 5.2GHz spectrum.
 * The specific geography and calibration information for that channel
 * is contained in the eeprom map itself.
 *
 * During init, we copy the eeprom information and channel map
 * information into priv->channel_info_24/52 and priv->channel_map_24/52
 *
 * channel_map_24/52 provides the index in the channel_info array for a
 * given channel.  We have to have two separate maps as there is channel
 * overlap with the 2.4GHz and 5.2GHz spectrum as seen in band_1 and
 * band_2
 *
 * A value of 0xff stored in the channel_map indicates that the channel
 * is not supported by the hardware at all.
 *
 * A value of 0xfe in the channel_map indicates that the channel is not
 * valid for Tx with the current hardware.  This means that
 * while the system can tune and receive on a given channel, it may not
 * be able to associate or transmit any frames on that
 * channel.  There is no corresponding channel information for that
 * entry.
 *
 *********************************************************************/

/* 2.4 GHz */
C
Christoph Hellwig 已提交
4788
static const u8 iwl3945_eeprom_band_1[14] = {
Z
Zhu Yi 已提交
4789 4790 4791 4792
	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
};

/* 5.2 GHz bands */
4793
static const u8 iwl3945_eeprom_band_2[] = {	/* 4915-5080MHz */
Z
Zhu Yi 已提交
4794 4795 4796
	183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16
};

4797
static const u8 iwl3945_eeprom_band_3[] = {	/* 5170-5320MHz */
Z
Zhu Yi 已提交
4798 4799 4800
	34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
};

C
Christoph Hellwig 已提交
4801
static const u8 iwl3945_eeprom_band_4[] = {	/* 5500-5700MHz */
Z
Zhu Yi 已提交
4802 4803 4804
	100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
};

C
Christoph Hellwig 已提交
4805
static const u8 iwl3945_eeprom_band_5[] = {	/* 5725-5825MHz */
Z
Zhu Yi 已提交
4806 4807 4808
	145, 149, 153, 157, 161, 165
};

C
Christoph Hellwig 已提交
4809
static void iwl3945_init_band_reference(const struct iwl3945_priv *priv, int band,
Z
Zhu Yi 已提交
4810
				    int *eeprom_ch_count,
C
Christoph Hellwig 已提交
4811
				    const struct iwl3945_eeprom_channel
Z
Zhu Yi 已提交
4812 4813 4814 4815 4816
				    **eeprom_ch_info,
				    const u8 **eeprom_ch_index)
{
	switch (band) {
	case 1:		/* 2.4GHz band */
C
Christoph Hellwig 已提交
4817
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_1);
Z
Zhu Yi 已提交
4818
		*eeprom_ch_info = priv->eeprom.band_1_channels;
C
Christoph Hellwig 已提交
4819
		*eeprom_ch_index = iwl3945_eeprom_band_1;
Z
Zhu Yi 已提交
4820
		break;
4821
	case 2:		/* 4.9GHz band */
C
Christoph Hellwig 已提交
4822
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_2);
Z
Zhu Yi 已提交
4823
		*eeprom_ch_info = priv->eeprom.band_2_channels;
C
Christoph Hellwig 已提交
4824
		*eeprom_ch_index = iwl3945_eeprom_band_2;
Z
Zhu Yi 已提交
4825 4826
		break;
	case 3:		/* 5.2GHz band */
C
Christoph Hellwig 已提交
4827
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_3);
Z
Zhu Yi 已提交
4828
		*eeprom_ch_info = priv->eeprom.band_3_channels;
C
Christoph Hellwig 已提交
4829
		*eeprom_ch_index = iwl3945_eeprom_band_3;
Z
Zhu Yi 已提交
4830
		break;
4831
	case 4:		/* 5.5GHz band */
C
Christoph Hellwig 已提交
4832
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_4);
Z
Zhu Yi 已提交
4833
		*eeprom_ch_info = priv->eeprom.band_4_channels;
C
Christoph Hellwig 已提交
4834
		*eeprom_ch_index = iwl3945_eeprom_band_4;
Z
Zhu Yi 已提交
4835
		break;
4836
	case 5:		/* 5.7GHz band */
C
Christoph Hellwig 已提交
4837
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_5);
Z
Zhu Yi 已提交
4838
		*eeprom_ch_info = priv->eeprom.band_5_channels;
C
Christoph Hellwig 已提交
4839
		*eeprom_ch_index = iwl3945_eeprom_band_5;
Z
Zhu Yi 已提交
4840 4841 4842 4843 4844 4845 4846
		break;
	default:
		BUG();
		return;
	}
}

4847 4848 4849 4850 4851
/**
 * iwl3945_get_channel_info - Find driver's private channel info
 *
 * Based on band and channel number.
 */
C
Christoph Hellwig 已提交
4852
const struct iwl3945_channel_info *iwl3945_get_channel_info(const struct iwl3945_priv *priv,
4853
						    enum ieee80211_band band, u16 channel)
Z
Zhu Yi 已提交
4854 4855 4856
{
	int i;

4857 4858
	switch (band) {
	case IEEE80211_BAND_5GHZ:
Z
Zhu Yi 已提交
4859 4860 4861 4862 4863 4864
		for (i = 14; i < priv->channel_count; i++) {
			if (priv->channel_info[i].channel == channel)
				return &priv->channel_info[i];
		}
		break;

4865
	case IEEE80211_BAND_2GHZ:
Z
Zhu Yi 已提交
4866 4867 4868
		if (channel >= 1 && channel <= 14)
			return &priv->channel_info[channel - 1];
		break;
4869 4870
	case IEEE80211_NUM_BANDS:
		WARN_ON(1);
Z
Zhu Yi 已提交
4871 4872 4873 4874 4875 4876 4877 4878
	}

	return NULL;
}

#define CHECK_AND_PRINT(x) ((eeprom_ch_info[ch].flags & EEPROM_CHANNEL_##x) \
			    ? # x " " : "")

4879 4880 4881
/**
 * iwl3945_init_channel_map - Set up driver's info for all possible channels
 */
C
Christoph Hellwig 已提交
4882
static int iwl3945_init_channel_map(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4883 4884 4885
{
	int eeprom_ch_count = 0;
	const u8 *eeprom_ch_index = NULL;
C
Christoph Hellwig 已提交
4886
	const struct iwl3945_eeprom_channel *eeprom_ch_info = NULL;
Z
Zhu Yi 已提交
4887
	int band, ch;
C
Christoph Hellwig 已提交
4888
	struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903

	if (priv->channel_count) {
		IWL_DEBUG_INFO("Channel map already initialized.\n");
		return 0;
	}

	if (priv->eeprom.version < 0x2f) {
		IWL_WARNING("Unsupported EEPROM version: 0x%04X\n",
			    priv->eeprom.version);
		return -EINVAL;
	}

	IWL_DEBUG_INFO("Initializing regulatory info from EEPROM\n");

	priv->channel_count =
C
Christoph Hellwig 已提交
4904 4905 4906 4907 4908
	    ARRAY_SIZE(iwl3945_eeprom_band_1) +
	    ARRAY_SIZE(iwl3945_eeprom_band_2) +
	    ARRAY_SIZE(iwl3945_eeprom_band_3) +
	    ARRAY_SIZE(iwl3945_eeprom_band_4) +
	    ARRAY_SIZE(iwl3945_eeprom_band_5);
Z
Zhu Yi 已提交
4909 4910 4911

	IWL_DEBUG_INFO("Parsing data for %d channels.\n", priv->channel_count);

C
Christoph Hellwig 已提交
4912
	priv->channel_info = kzalloc(sizeof(struct iwl3945_channel_info) *
Z
Zhu Yi 已提交
4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926
				     priv->channel_count, GFP_KERNEL);
	if (!priv->channel_info) {
		IWL_ERROR("Could not allocate channel_info\n");
		priv->channel_count = 0;
		return -ENOMEM;
	}

	ch_info = priv->channel_info;

	/* Loop through the 5 EEPROM bands adding them in order to the
	 * channel map we maintain (that contains additional information than
	 * what just in the EEPROM) */
	for (band = 1; band <= 5; band++) {

C
Christoph Hellwig 已提交
4927
		iwl3945_init_band_reference(priv, band, &eeprom_ch_count,
Z
Zhu Yi 已提交
4928 4929 4930 4931 4932
					&eeprom_ch_info, &eeprom_ch_index);

		/* Loop through each band adding each of the channels */
		for (ch = 0; ch < eeprom_ch_count; ch++) {
			ch_info->channel = eeprom_ch_index[ch];
4933 4934
			ch_info->band = (band == 1) ? IEEE80211_BAND_2GHZ :
			    IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960

			/* permanently store EEPROM's channel regulatory flags
			 *   and max power in channel info database. */
			ch_info->eeprom = eeprom_ch_info[ch];

			/* Copy the run-time flags so they are there even on
			 * invalid channels */
			ch_info->flags = eeprom_ch_info[ch].flags;

			if (!(is_channel_valid(ch_info))) {
				IWL_DEBUG_INFO("Ch. %d Flags %x [%sGHz] - "
					       "No traffic\n",
					       ch_info->channel,
					       ch_info->flags,
					       is_channel_a_band(ch_info) ?
					       "5.2" : "2.4");
				ch_info++;
				continue;
			}

			/* Initialize regulatory-based run-time data */
			ch_info->max_power_avg = ch_info->curr_txpow =
			    eeprom_ch_info[ch].max_power_avg;
			ch_info->scan_power = eeprom_ch_info[ch].max_power_avg;
			ch_info->min_power = 0;

4961
			IWL_DEBUG_INFO("Ch. %d [%sGHz] %s%s%s%s%s%s%s(0x%02x"
Z
Zhu Yi 已提交
4962 4963 4964 4965
				       " %ddBm): Ad-Hoc %ssupported\n",
				       ch_info->channel,
				       is_channel_a_band(ch_info) ?
				       "5.2" : "2.4",
4966
				       CHECK_AND_PRINT(VALID),
Z
Zhu Yi 已提交
4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991
				       CHECK_AND_PRINT(IBSS),
				       CHECK_AND_PRINT(ACTIVE),
				       CHECK_AND_PRINT(RADAR),
				       CHECK_AND_PRINT(WIDE),
				       CHECK_AND_PRINT(NARROW),
				       CHECK_AND_PRINT(DFS),
				       eeprom_ch_info[ch].flags,
				       eeprom_ch_info[ch].max_power_avg,
				       ((eeprom_ch_info[ch].
					 flags & EEPROM_CHANNEL_IBSS)
					&& !(eeprom_ch_info[ch].
					     flags & EEPROM_CHANNEL_RADAR))
				       ? "" : "not ");

			/* Set the user_txpower_limit to the highest power
			 * supported by any channel */
			if (eeprom_ch_info[ch].max_power_avg >
			    priv->user_txpower_limit)
				priv->user_txpower_limit =
				    eeprom_ch_info[ch].max_power_avg;

			ch_info++;
		}
	}

4992
	/* Set up txpower settings in driver for all channels */
Z
Zhu Yi 已提交
4993 4994 4995 4996 4997 4998
	if (iwl3945_txpower_set_from_eeprom(priv))
		return -EIO;

	return 0;
}

4999 5000 5001 5002 5003 5004 5005 5006 5007
/*
 * iwl3945_free_channel_map - undo allocations in iwl3945_init_channel_map
 */
static void iwl3945_free_channel_map(struct iwl3945_priv *priv)
{
	kfree(priv->channel_info);
	priv->channel_count = 0;
}

Z
Zhu Yi 已提交
5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030
/* For active scan, listen ACTIVE_DWELL_TIME (msec) on each channel after
 * sending probe req.  This should be set long enough to hear probe responses
 * from more than one AP.  */
#define IWL_ACTIVE_DWELL_TIME_24    (20)	/* all times in msec */
#define IWL_ACTIVE_DWELL_TIME_52    (10)

/* For faster active scanning, scan will move to the next channel if fewer than
 * PLCP_QUIET_THRESH packets are heard on this channel within
 * ACTIVE_QUIET_TIME after sending probe request.  This shortens the dwell
 * time if it's a quiet channel (nothing responded to our probe, and there's
 * no other traffic).
 * Disable "quiet" feature by setting PLCP_QUIET_THRESH to 0. */
#define IWL_PLCP_QUIET_THRESH       __constant_cpu_to_le16(1)	/* packets */
#define IWL_ACTIVE_QUIET_TIME       __constant_cpu_to_le16(5)	/* msec */

/* For passive scan, listen PASSIVE_DWELL_TIME (msec) on each channel.
 * Must be set longer than active dwell time.
 * For the most reliable scan, set > AP beacon interval (typically 100msec). */
#define IWL_PASSIVE_DWELL_TIME_24   (20)	/* all times in msec */
#define IWL_PASSIVE_DWELL_TIME_52   (10)
#define IWL_PASSIVE_DWELL_BASE      (100)
#define IWL_CHANNEL_TUNE_TIME       5

5031 5032
static inline u16 iwl3945_get_active_dwell_time(struct iwl3945_priv *priv,
						enum ieee80211_band band)
Z
Zhu Yi 已提交
5033
{
5034
	if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
5035 5036 5037 5038 5039
		return IWL_ACTIVE_DWELL_TIME_52;
	else
		return IWL_ACTIVE_DWELL_TIME_24;
}

5040 5041
static u16 iwl3945_get_passive_dwell_time(struct iwl3945_priv *priv,
					  enum ieee80211_band band)
Z
Zhu Yi 已提交
5042
{
5043 5044
	u16 active = iwl3945_get_active_dwell_time(priv, band);
	u16 passive = (band == IEEE80211_BAND_2GHZ) ?
Z
Zhu Yi 已提交
5045 5046 5047
	    IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_24 :
	    IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_52;

C
Christoph Hellwig 已提交
5048
	if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063
		/* If we're associated, we clamp the maximum passive
		 * dwell time to be 98% of the beacon interval (minus
		 * 2 * channel tune time) */
		passive = priv->beacon_int;
		if ((passive > IWL_PASSIVE_DWELL_BASE) || !passive)
			passive = IWL_PASSIVE_DWELL_BASE;
		passive = (passive * 98) / 100 - IWL_CHANNEL_TUNE_TIME * 2;
	}

	if (passive <= active)
		passive = active + 1;

	return passive;
}

5064 5065
static int iwl3945_get_channels_for_scan(struct iwl3945_priv *priv,
					 enum ieee80211_band band,
Z
Zhu Yi 已提交
5066
				     u8 is_active, u8 direct_mask,
C
Christoph Hellwig 已提交
5067
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
5068 5069
{
	const struct ieee80211_channel *channels = NULL;
5070
	const struct ieee80211_supported_band *sband;
C
Christoph Hellwig 已提交
5071
	const struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
5072 5073 5074 5075
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

5076 5077
	sband = iwl3945_get_band(priv, band);
	if (!sband)
Z
Zhu Yi 已提交
5078 5079
		return 0;

5080
	channels = sband->channels;
Z
Zhu Yi 已提交
5081

5082 5083
	active_dwell = iwl3945_get_active_dwell_time(priv, band);
	passive_dwell = iwl3945_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
5084

5085 5086
	for (i = 0, added = 0; i < sband->n_channels; i++) {
		if (channels[i].hw_value ==
Z
Zhu Yi 已提交
5087
		    le16_to_cpu(priv->active_rxon.channel)) {
C
Christoph Hellwig 已提交
5088
			if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
5089 5090 5091 5092 5093 5094 5095 5096
				IWL_DEBUG_SCAN
				    ("Skipping current channel %d\n",
				     le16_to_cpu(priv->active_rxon.channel));
				continue;
			}
		} else if (priv->only_active_channel)
			continue;

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

5099
		ch_info = iwl3945_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
5100 5101 5102 5103 5104 5105 5106
		if (!is_channel_valid(ch_info)) {
			IWL_DEBUG_SCAN("Channel %d is INVALID for this SKU.\n",
				       scan_ch->channel);
			continue;
		}

		if (!is_active || is_channel_passive(ch_info) ||
5107
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN))
Z
Zhu Yi 已提交
5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120
			scan_ch->type = 0;	/* passive */
		else
			scan_ch->type = 1;	/* active */

		if (scan_ch->type & 1)
			scan_ch->type |= (direct_mask << 1);

		if (is_channel_narrow(ch_info))
			scan_ch->type |= (1 << 7);

		scan_ch->active_dwell = cpu_to_le16(active_dwell);
		scan_ch->passive_dwell = cpu_to_le16(passive_dwell);

5121
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
5122 5123 5124 5125
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
5126
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
5127 5128 5129 5130
			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
5131
			 * power level:
5132
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149
			 */
		}

		IWL_DEBUG_SCAN("Scanning %d [%s %d]\n",
			       scan_ch->channel,
			       (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
			       (scan_ch->type & 1) ?
			       active_dwell : passive_dwell);

		scan_ch++;
		added++;
	}

	IWL_DEBUG_SCAN("total channels to scan %d \n", added);
	return added;
}

C
Christoph Hellwig 已提交
5150
static void iwl3945_init_hw_rates(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
5151 5152 5153 5154 5155
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
5156 5157 5158 5159 5160
		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;
		if ((i > IWL_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
5161
			/*
5162
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
5163
			 */
C
Christoph Hellwig 已提交
5164
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
5165
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
5166 5167 5168 5169 5170
		}
	}
}

/**
C
Christoph Hellwig 已提交
5171
 * iwl3945_init_geos - Initialize mac80211's geo/channel info based from eeprom
Z
Zhu Yi 已提交
5172
 */
C
Christoph Hellwig 已提交
5173
static int iwl3945_init_geos(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5174
{
C
Christoph Hellwig 已提交
5175
	struct iwl3945_channel_info *ch;
5176
	struct ieee80211_supported_band *sband;
Z
Zhu Yi 已提交
5177 5178 5179 5180 5181
	struct ieee80211_channel *channels;
	struct ieee80211_channel *geo_ch;
	struct ieee80211_rate *rates;
	int i = 0;

5182 5183
	if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
	    priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
Z
Zhu Yi 已提交
5184 5185 5186 5187 5188 5189 5190
		IWL_DEBUG_INFO("Geography modes already initialized.\n");
		set_bit(STATUS_GEO_CONFIGURED, &priv->status);
		return 0;
	}

	channels = kzalloc(sizeof(struct ieee80211_channel) *
			   priv->channel_count, GFP_KERNEL);
5191
	if (!channels)
Z
Zhu Yi 已提交
5192 5193
		return -ENOMEM;

5194
	rates = kzalloc((sizeof(struct ieee80211_rate) * (IWL_RATE_COUNT + 1)),
Z
Zhu Yi 已提交
5195 5196 5197 5198 5199 5200 5201
			GFP_KERNEL);
	if (!rates) {
		kfree(channels);
		return -ENOMEM;
	}

	/* 5.2GHz channels start after the 2.4GHz channels */
5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212
	sband = &priv->bands[IEEE80211_BAND_5GHZ];
	sband->channels = &channels[ARRAY_SIZE(iwl3945_eeprom_band_1)];
	/* just OFDM */
	sband->bitrates = &rates[IWL_FIRST_OFDM_RATE];
	sband->n_bitrates = IWL_RATE_COUNT - IWL_FIRST_OFDM_RATE;

	sband = &priv->bands[IEEE80211_BAND_2GHZ];
	sband->channels = channels;
	/* OFDM & CCK */
	sband->bitrates = rates;
	sband->n_bitrates = IWL_RATE_COUNT;
Z
Zhu Yi 已提交
5213 5214 5215 5216

	priv->ieee_channels = channels;
	priv->ieee_rates = rates;

C
Christoph Hellwig 已提交
5217
	iwl3945_init_hw_rates(priv, rates);
Z
Zhu Yi 已提交
5218

5219
	for (i = 0;  i < priv->channel_count; i++) {
Z
Zhu Yi 已提交
5220 5221
		ch = &priv->channel_info[i];

5222 5223
		/* FIXME: might be removed if scan is OK*/
		if (!is_channel_valid(ch))
Z
Zhu Yi 已提交
5224 5225 5226
			continue;

		if (is_channel_a_band(ch))
5227
			sband =  &priv->bands[IEEE80211_BAND_5GHZ];
5228
		else
5229
			sband =  &priv->bands[IEEE80211_BAND_2GHZ];
Z
Zhu Yi 已提交
5230

5231 5232 5233
		geo_ch = &sband->channels[sband->n_channels++];

		geo_ch->center_freq = ieee80211_channel_to_frequency(ch->channel);
5234 5235
		geo_ch->max_power = ch->max_power_avg;
		geo_ch->max_antenna_gain = 0xff;
5236
		geo_ch->hw_value = ch->channel;
Z
Zhu Yi 已提交
5237 5238

		if (is_channel_valid(ch)) {
5239 5240
			if (!(ch->flags & EEPROM_CHANNEL_IBSS))
				geo_ch->flags |= IEEE80211_CHAN_NO_IBSS;
Z
Zhu Yi 已提交
5241

5242 5243
			if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
				geo_ch->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
Z
Zhu Yi 已提交
5244 5245

			if (ch->flags & EEPROM_CHANNEL_RADAR)
5246
				geo_ch->flags |= IEEE80211_CHAN_RADAR;
Z
Zhu Yi 已提交
5247 5248 5249 5250

			if (ch->max_power_avg > priv->max_channel_txpower_limit)
				priv->max_channel_txpower_limit =
				    ch->max_power_avg;
5251
		} else {
5252
			geo_ch->flags |= IEEE80211_CHAN_DISABLED;
5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263
		}

		/* Save flags for reg domain usage */
		geo_ch->orig_flags = geo_ch->flags;

		IWL_DEBUG_INFO("Channel %d Freq=%d[%sGHz] %s flag=0%X\n",
				ch->channel, geo_ch->center_freq,
				is_channel_a_band(ch) ?  "5.2" : "2.4",
				geo_ch->flags & IEEE80211_CHAN_DISABLED ?
				"restricted" : "valid",
				 geo_ch->flags);
Z
Zhu Yi 已提交
5264 5265
	}

T
Tomas Winkler 已提交
5266 5267
	if ((priv->bands[IEEE80211_BAND_5GHZ].n_channels == 0) &&
	     priv->cfg->sku & IWL_SKU_A) {
Z
Zhu Yi 已提交
5268 5269 5270 5271
		printk(KERN_INFO DRV_NAME
		       ": Incorrectly detected BG card as ABG.  Please send "
		       "your PCI ID 0x%04X:0x%04X to maintainer.\n",
		       priv->pci_dev->device, priv->pci_dev->subsystem_device);
T
Tomas Winkler 已提交
5272
		 priv->cfg->sku &= ~IWL_SKU_A;
Z
Zhu Yi 已提交
5273 5274 5275 5276
	}

	printk(KERN_INFO DRV_NAME
	       ": Tunable channels: %d 802.11bg, %d 802.11a channels\n",
5277 5278
	       priv->bands[IEEE80211_BAND_2GHZ].n_channels,
	       priv->bands[IEEE80211_BAND_5GHZ].n_channels);
Z
Zhu Yi 已提交
5279

5280 5281
	priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->bands[IEEE80211_BAND_2GHZ];
	priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &priv->bands[IEEE80211_BAND_5GHZ];
Z
Zhu Yi 已提交
5282 5283 5284 5285 5286 5287

	set_bit(STATUS_GEO_CONFIGURED, &priv->status);

	return 0;
}

5288 5289 5290 5291 5292 5293 5294 5295 5296 5297
/*
 * iwl3945_free_geos - undo allocations in iwl3945_init_geos
 */
static void iwl3945_free_geos(struct iwl3945_priv *priv)
{
	kfree(priv->ieee_channels);
	kfree(priv->ieee_rates);
	clear_bit(STATUS_GEO_CONFIGURED, &priv->status);
}

Z
Zhu Yi 已提交
5298 5299 5300 5301 5302 5303
/******************************************************************************
 *
 * uCode download functions
 *
 ******************************************************************************/

C
Christoph Hellwig 已提交
5304
static void iwl3945_dealloc_ucode_pci(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5305
{
5306 5307 5308 5309 5310 5311
	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 已提交
5312 5313 5314
}

/**
C
Christoph Hellwig 已提交
5315
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
5316 5317
 *     looking at all data.
 */
C
Christoph Hellwig 已提交
5318
static int iwl3945_verify_inst_full(struct iwl3945_priv *priv, __le32 * image, u32 len)
Z
Zhu Yi 已提交
5319 5320 5321 5322 5323 5324 5325 5326
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

	IWL_DEBUG_INFO("ucode inst image size is %u\n", len);

C
Christoph Hellwig 已提交
5327
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5328 5329 5330
	if (rc)
		return rc;

C
Christoph Hellwig 已提交
5331
	iwl3945_write_direct32(priv, HBUS_TARG_MEM_RADDR, RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
5332 5333 5334 5335 5336 5337

	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 */
C
Christoph Hellwig 已提交
5338
		val = _iwl3945_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349
		if (val != le32_to_cpu(*image)) {
			IWL_ERROR("uCode INST section is invalid at "
				  "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;
		}
	}

C
Christoph Hellwig 已提交
5350
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5351 5352

	if (!errcnt)
5353
		IWL_DEBUG_INFO("ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
5354 5355 5356 5357 5358 5359

	return rc;
}


/**
C
Christoph Hellwig 已提交
5360
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
5361 5362 5363
 *   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.
 */
C
Christoph Hellwig 已提交
5364
static int iwl3945_verify_inst_sparse(struct iwl3945_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
5365 5366 5367 5368 5369 5370 5371 5372
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

	IWL_DEBUG_INFO("ucode inst image size is %u\n", len);

C
Christoph Hellwig 已提交
5373
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5374 5375 5376 5377 5378 5379 5380
	if (rc)
		return rc;

	for (i = 0; i < len; i += 100, image += 100/sizeof(u32)) {
		/* read data comes through single port, auto-incr addr */
		/* NOTE: Use the debugless read so we don't flood kernel log
		 * if IWL_DL_IO is set */
C
Christoph Hellwig 已提交
5381
		iwl3945_write_direct32(priv, HBUS_TARG_MEM_RADDR,
Z
Zhu Yi 已提交
5382
			i + RTC_INST_LOWER_BOUND);
C
Christoph Hellwig 已提交
5383
		val = _iwl3945_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
			IWL_ERROR("uCode INST section is invalid at "
				  "offset 0x%x, is 0x%x, s/b 0x%x\n",
				  i, val, *image);
#endif
			rc = -EIO;
			errcnt++;
			if (errcnt >= 3)
				break;
		}
	}

C
Christoph Hellwig 已提交
5397
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5398 5399 5400 5401 5402 5403

	return rc;
}


/**
C
Christoph Hellwig 已提交
5404
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
5405 5406
 *    and verify its contents
 */
C
Christoph Hellwig 已提交
5407
static int iwl3945_verify_ucode(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5408 5409 5410 5411 5412 5413 5414 5415
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
5416
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
5417 5418 5419 5420 5421 5422 5423 5424
	if (rc == 0) {
		IWL_DEBUG_INFO("Bootstrap uCode is good in inst SRAM\n");
		return 0;
	}

	/* Try initialize */
	image = (__le32 *)priv->ucode_init.v_addr;
	len = priv->ucode_init.len;
C
Christoph Hellwig 已提交
5425
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
5426 5427 5428 5429 5430 5431 5432 5433
	if (rc == 0) {
		IWL_DEBUG_INFO("Initialize uCode is good in inst SRAM\n");
		return 0;
	}

	/* Try runtime/protocol */
	image = (__le32 *)priv->ucode_code.v_addr;
	len = priv->ucode_code.len;
C
Christoph Hellwig 已提交
5434
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
5435 5436 5437 5438 5439 5440 5441
	if (rc == 0) {
		IWL_DEBUG_INFO("Runtime uCode is good in inst SRAM\n");
		return 0;
	}

	IWL_ERROR("NO VALID UCODE IMAGE IN INSTRUCTION SRAM!!\n");

5442 5443 5444
	/* 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 已提交
5445 5446
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
5447
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
5448 5449 5450 5451 5452 5453

	return rc;
}


/* check contents of special bootstrap uCode SRAM */
C
Christoph Hellwig 已提交
5454
static int iwl3945_verify_bsm(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5455 5456 5457 5458 5459 5460 5461 5462 5463
{
	__le32 *image = priv->ucode_boot.v_addr;
	u32 len = priv->ucode_boot.len;
	u32 reg;
	u32 val;

	IWL_DEBUG_INFO("Begin verify bsm\n");

	/* verify BSM SRAM contents */
C
Christoph Hellwig 已提交
5464
	val = iwl3945_read_prph(priv, BSM_WR_DWCOUNT_REG);
Z
Zhu Yi 已提交
5465 5466 5467
	for (reg = BSM_SRAM_LOWER_BOUND;
	     reg < BSM_SRAM_LOWER_BOUND + len;
	     reg += sizeof(u32), image ++) {
C
Christoph Hellwig 已提交
5468
		val = iwl3945_read_prph(priv, reg);
Z
Zhu Yi 已提交
5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484
		if (val != le32_to_cpu(*image)) {
			IWL_ERROR("BSM uCode verification failed at "
				  "addr 0x%08X+%u (of %u), is 0x%x, s/b 0x%x\n",
				  BSM_SRAM_LOWER_BOUND,
				  reg - BSM_SRAM_LOWER_BOUND, len,
				  val, le32_to_cpu(*image));
			return -EIO;
		}
	}

	IWL_DEBUG_INFO("BSM bootstrap uCode image OK\n");

	return 0;
}

/**
C
Christoph Hellwig 已提交
5485
 * iwl3945_load_bsm - Load bootstrap instructions
Z
Zhu Yi 已提交
5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515
 *
 * BSM operation:
 *
 * The Bootstrap State Machine (BSM) stores a short bootstrap uCode program
 * in special SRAM that does not power down during RFKILL.  When powering back
 * up after power-saving sleeps (or during initial uCode load), the BSM loads
 * the bootstrap program into the on-board processor, and starts it.
 *
 * The bootstrap program loads (via DMA) instructions and data for a new
 * program from host DRAM locations indicated by the host driver in the
 * BSM_DRAM_* registers.  Once the new program is loaded, it starts
 * automatically.
 *
 * When initializing the NIC, the host driver points the BSM to the
 * "initialize" uCode image.  This uCode sets up some internal data, then
 * notifies host via "initialize alive" that it is complete.
 *
 * The host then replaces the BSM_DRAM_* pointer values to point to the
 * normal runtime uCode instructions and a backup uCode data cache buffer
 * (filled initially with starting data values for the on-board processor),
 * then triggers the "initialize" uCode to load and launch the runtime uCode,
 * which begins normal operation.
 *
 * When doing a power-save shutdown, runtime uCode saves data SRAM into
 * the backup data cache in DRAM before SRAM is powered down.
 *
 * When powering back up, the BSM loads the bootstrap program.  This reloads
 * the runtime uCode instructions and the backup data cache into SRAM,
 * and re-launches the runtime uCode from where it left off.
 */
C
Christoph Hellwig 已提交
5516
static int iwl3945_load_bsm(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535
{
	__le32 *image = priv->ucode_boot.v_addr;
	u32 len = priv->ucode_boot.len;
	dma_addr_t pinst;
	dma_addr_t pdata;
	u32 inst_len;
	u32 data_len;
	int rc;
	int i;
	u32 done;
	u32 reg_offset;

	IWL_DEBUG_INFO("Begin load bsm\n");

	/* make sure bootstrap program is no larger than BSM's SRAM size */
	if (len > IWL_MAX_BSM_SIZE)
		return -EINVAL;

	/* Tell bootstrap uCode where to find the "Initialize" uCode
5536
	 *   in host DRAM ... host DRAM physical address bits 31:0 for 3945.
C
Christoph Hellwig 已提交
5537
	 * NOTE:  iwl3945_initialize_alive_start() will replace these values,
Z
Zhu Yi 已提交
5538 5539 5540 5541 5542 5543 5544
	 *        after the "initialize" uCode has run, to point to
	 *        runtime/protocol instructions and backup data cache. */
	pinst = priv->ucode_init.p_addr;
	pdata = priv->ucode_init_data.p_addr;
	inst_len = priv->ucode_init.len;
	data_len = priv->ucode_init_data.len;

C
Christoph Hellwig 已提交
5545
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5546 5547 5548
	if (rc)
		return rc;

C
Christoph Hellwig 已提交
5549 5550 5551 5552
	iwl3945_write_prph(priv, BSM_DRAM_INST_PTR_REG, pinst);
	iwl3945_write_prph(priv, BSM_DRAM_DATA_PTR_REG, pdata);
	iwl3945_write_prph(priv, BSM_DRAM_INST_BYTECOUNT_REG, inst_len);
	iwl3945_write_prph(priv, BSM_DRAM_DATA_BYTECOUNT_REG, data_len);
Z
Zhu Yi 已提交
5553 5554 5555 5556 5557

	/* Fill BSM memory with bootstrap instructions */
	for (reg_offset = BSM_SRAM_LOWER_BOUND;
	     reg_offset < BSM_SRAM_LOWER_BOUND + len;
	     reg_offset += sizeof(u32), image++)
C
Christoph Hellwig 已提交
5558
		_iwl3945_write_prph(priv, reg_offset,
Z
Zhu Yi 已提交
5559 5560
					  le32_to_cpu(*image));

C
Christoph Hellwig 已提交
5561
	rc = iwl3945_verify_bsm(priv);
Z
Zhu Yi 已提交
5562
	if (rc) {
C
Christoph Hellwig 已提交
5563
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5564 5565 5566 5567
		return rc;
	}

	/* Tell BSM to copy from BSM SRAM into instruction SRAM, when asked */
C
Christoph Hellwig 已提交
5568 5569
	iwl3945_write_prph(priv, BSM_WR_MEM_SRC_REG, 0x0);
	iwl3945_write_prph(priv, BSM_WR_MEM_DST_REG,
Z
Zhu Yi 已提交
5570
				 RTC_INST_LOWER_BOUND);
C
Christoph Hellwig 已提交
5571
	iwl3945_write_prph(priv, BSM_WR_DWCOUNT_REG, len / sizeof(u32));
Z
Zhu Yi 已提交
5572 5573 5574

	/* Load bootstrap code into instruction SRAM now,
	 *   to prepare to load "initialize" uCode */
C
Christoph Hellwig 已提交
5575
	iwl3945_write_prph(priv, BSM_WR_CTRL_REG,
Z
Zhu Yi 已提交
5576 5577 5578 5579
		BSM_WR_CTRL_REG_BIT_START);

	/* Wait for load of bootstrap uCode to finish */
	for (i = 0; i < 100; i++) {
C
Christoph Hellwig 已提交
5580
		done = iwl3945_read_prph(priv, BSM_WR_CTRL_REG);
Z
Zhu Yi 已提交
5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593
		if (!(done & BSM_WR_CTRL_REG_BIT_START))
			break;
		udelay(10);
	}
	if (i < 100)
		IWL_DEBUG_INFO("BSM write complete, poll %d iterations\n", i);
	else {
		IWL_ERROR("BSM write did not complete!\n");
		return -EIO;
	}

	/* Enable future boot loads whenever power management unit triggers it
	 *   (e.g. when powering back up after power-save shutdown) */
C
Christoph Hellwig 已提交
5594
	iwl3945_write_prph(priv, BSM_WR_CTRL_REG,
Z
Zhu Yi 已提交
5595 5596
		BSM_WR_CTRL_REG_BIT_START_EN);

C
Christoph Hellwig 已提交
5597
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5598 5599 5600 5601

	return 0;
}

C
Christoph Hellwig 已提交
5602
static void iwl3945_nic_start(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5603 5604
{
	/* Remove all resets to allow NIC to operate */
C
Christoph Hellwig 已提交
5605
	iwl3945_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
5606 5607 5608
}

/**
C
Christoph Hellwig 已提交
5609
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
5610 5611 5612
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
C
Christoph Hellwig 已提交
5613
static int iwl3945_read_ucode(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5614
{
C
Christoph Hellwig 已提交
5615
	struct iwl3945_ucode *ucode;
5616
	int ret = 0;
Z
Zhu Yi 已提交
5617 5618
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
5619
	const char *name = priv->cfg->fw_name;
Z
Zhu Yi 已提交
5620 5621 5622 5623 5624 5625
	u8 *src;
	size_t len;
	u32 ver, inst_size, data_size, init_size, init_data_size, boot_size;

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
5626 5627 5628 5629
	ret = request_firmware(&ucode_raw, name, &priv->pci_dev->dev);
	if (ret < 0) {
		IWL_ERROR("%s firmware file req failed: Reason %d\n",
				name, ret);
Z
Zhu Yi 已提交
5630 5631 5632 5633 5634 5635 5636 5637 5638
		goto error;
	}

	IWL_DEBUG_INFO("Got firmware '%s' file (%zd bytes) from disk\n",
		       name, ucode_raw->size);

	/* Make sure that we got at least our header! */
	if (ucode_raw->size < sizeof(*ucode)) {
		IWL_ERROR("File size way too small!\n");
5639
		ret = -EINVAL;
Z
Zhu Yi 已提交
5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653
		goto err_release;
	}

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

	ver = le32_to_cpu(ucode->ver);
	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);

	IWL_DEBUG_INFO("f/w package hdr ucode version = 0x%x\n", ver);
5654 5655 5656 5657 5658
	IWL_DEBUG_INFO("f/w package hdr runtime inst size = %u\n", inst_size);
	IWL_DEBUG_INFO("f/w package hdr runtime data size = %u\n", data_size);
	IWL_DEBUG_INFO("f/w package hdr init inst size = %u\n", init_size);
	IWL_DEBUG_INFO("f/w package hdr init data size = %u\n", init_data_size);
	IWL_DEBUG_INFO("f/w package hdr boot inst size = %u\n", boot_size);
Z
Zhu Yi 已提交
5659 5660 5661 5662 5663 5664 5665 5666

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

		IWL_DEBUG_INFO("uCode file size %d too small\n",
			       (int)ucode_raw->size);
5667
		ret = -EINVAL;
Z
Zhu Yi 已提交
5668 5669 5670 5671 5672
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
	if (inst_size > IWL_MAX_INST_SIZE) {
5673 5674 5675
		IWL_DEBUG_INFO("uCode instr len %d too large to fit in\n",
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
5676 5677 5678 5679
		goto err_release;
	}

	if (data_size > IWL_MAX_DATA_SIZE) {
5680 5681 5682
		IWL_DEBUG_INFO("uCode data len %d too large to fit in\n",
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
5683 5684 5685
		goto err_release;
	}
	if (init_size > IWL_MAX_INST_SIZE) {
5686 5687 5688
		IWL_DEBUG_INFO("uCode init instr len %d too large to fit in\n",
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
5689 5690 5691
		goto err_release;
	}
	if (init_data_size > IWL_MAX_DATA_SIZE) {
5692 5693 5694
		IWL_DEBUG_INFO("uCode init data len %d too large to fit in\n",
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
5695 5696 5697
		goto err_release;
	}
	if (boot_size > IWL_MAX_BSM_SIZE) {
5698 5699 5700
		IWL_DEBUG_INFO("uCode boot instr len %d too large to fit in\n",
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
5701 5702 5703 5704 5705 5706 5707 5708 5709
		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;
5710
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
5711 5712

	priv->ucode_data.len = data_size;
5713
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
5714 5715

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

5718 5719 5720
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
5721 5722

	/* Initialization instructions and data */
5723 5724
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
5725
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
5726 5727

		priv->ucode_init_data.len = init_data_size;
5728
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
5729 5730 5731 5732

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

	/* Bootstrap (instructions only, no data) */
5735 5736
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
5737
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
5738

5739 5740 5741
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
5742 5743 5744 5745 5746 5747

	/* 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;
5748
	IWL_DEBUG_INFO("Copying (but not loading) uCode instr len %Zd\n", len);
Z
Zhu Yi 已提交
5749 5750 5751 5752 5753
	memcpy(priv->ucode_code.v_addr, src, len);
	IWL_DEBUG_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
		priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
5754
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
Z
Zhu Yi 已提交
5755 5756
	src = &ucode->data[inst_size];
	len = priv->ucode_data.len;
5757
	IWL_DEBUG_INFO("Copying (but not loading) uCode data len %Zd\n", len);
Z
Zhu Yi 已提交
5758 5759 5760 5761 5762 5763 5764
	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;
5765 5766
		IWL_DEBUG_INFO("Copying (but not loading) init instr len %Zd\n",
			       len);
Z
Zhu Yi 已提交
5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791
		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;
		IWL_DEBUG_INFO("Copying (but not loading) init data len %d\n",
			       (int)len);
		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;
	IWL_DEBUG_INFO("Copying (but not loading) boot instr len %d\n",
		       (int)len);
	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:
	IWL_ERROR("failed to allocate pci memory\n");
5792
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
5793
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
5794 5795 5796 5797 5798

 err_release:
	release_firmware(ucode_raw);

 error:
5799
	return ret;
Z
Zhu Yi 已提交
5800 5801 5802 5803
}


/**
C
Christoph Hellwig 已提交
5804
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
5805 5806 5807 5808 5809 5810 5811
 *
 * 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.
 */
C
Christoph Hellwig 已提交
5812
static int iwl3945_set_ucode_ptrs(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823
{
	dma_addr_t pinst;
	dma_addr_t pdata;
	int rc = 0;
	unsigned long flags;

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

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
5824
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5825 5826 5827 5828 5829 5830
	if (rc) {
		spin_unlock_irqrestore(&priv->lock, flags);
		return rc;
	}

	/* Tell bootstrap uCode where to find image to load */
C
Christoph Hellwig 已提交
5831 5832 5833
	iwl3945_write_prph(priv, BSM_DRAM_INST_PTR_REG, pinst);
	iwl3945_write_prph(priv, BSM_DRAM_DATA_PTR_REG, pdata);
	iwl3945_write_prph(priv, BSM_DRAM_DATA_BYTECOUNT_REG,
Z
Zhu Yi 已提交
5834 5835 5836 5837
				 priv->ucode_data.len);

	/* Inst bytecount must be last to set up, bit 31 signals uCode
	 *   that all new ptr/size info is in place */
C
Christoph Hellwig 已提交
5838
	iwl3945_write_prph(priv, BSM_DRAM_INST_BYTECOUNT_REG,
Z
Zhu Yi 已提交
5839 5840
				 priv->ucode_code.len | BSM_DRAM_INST_LOAD);

C
Christoph Hellwig 已提交
5841
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5842 5843 5844 5845 5846 5847 5848 5849 5850

	spin_unlock_irqrestore(&priv->lock, flags);

	IWL_DEBUG_INFO("Runtime uCode pointers are set.\n");

	return rc;
}

/**
C
Christoph Hellwig 已提交
5851
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
5852 5853 5854 5855
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
5856
 */
C
Christoph Hellwig 已提交
5857
static void iwl3945_init_alive_start(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869
{
	/* 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 */
		IWL_DEBUG_INFO("Initialize Alive failed.\n");
		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 已提交
5870
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
5871 5872 5873 5874 5875 5876 5877 5878 5879 5880
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
		IWL_DEBUG_INFO("Bad \"initialize\" uCode load.\n");
		goto restart;
	}

	/* Send pointers to protocol/runtime uCode image ... init code will
	 * load and launch runtime uCode, which will send us another "Alive"
	 * notification. */
	IWL_DEBUG_INFO("Initialization Alive received.\n");
C
Christoph Hellwig 已提交
5881
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894
		/* Runtime instruction load won't happen;
		 * take it all the way back down so we can try again */
		IWL_DEBUG_INFO("Couldn't set up uCode pointers.\n");
		goto restart;
	}
	return;

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


/**
C
Christoph Hellwig 已提交
5895
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
5896
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
5897
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
5898
 */
C
Christoph Hellwig 已提交
5899
static void iwl3945_alive_start(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916
{
	int rc = 0;
	int thermal_spin = 0;
	u32 rfkill;

	IWL_DEBUG_INFO("Runtime Alive received.\n");

	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 */
		IWL_DEBUG_INFO("Alive failed.\n");
		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 已提交
5917
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
5918 5919 5920 5921 5922 5923
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
		IWL_DEBUG_INFO("Bad runtime uCode load.\n");
		goto restart;
	}

C
Christoph Hellwig 已提交
5924
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5925

C
Christoph Hellwig 已提交
5926
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5927 5928 5929 5930 5931
	if (rc) {
		IWL_WARNING("Can not read rfkill status from adapter\n");
		return;
	}

C
Christoph Hellwig 已提交
5932
	rfkill = iwl3945_read_prph(priv, APMG_RFKILL_REG);
Z
Zhu Yi 已提交
5933
	IWL_DEBUG_INFO("RFKILL status: 0x%x\n", rfkill);
C
Christoph Hellwig 已提交
5934
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5935 5936 5937 5938 5939

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
		/* if rfkill is not on, then wait for thermal
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
5940
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
5941 5942 5943 5944 5945 5946 5947 5948 5949 5950
			thermal_spin++;
			udelay(10);
		}

		if (thermal_spin)
			IWL_DEBUG_INFO("Thermal calibration took %dus\n",
				       thermal_spin * 10);
	} else
		set_bit(STATUS_RF_KILL_HW, &priv->status);

5951
	/* After the ALIVE response, we can send commands to 3945 uCode */
Z
Zhu Yi 已提交
5952 5953 5954 5955 5956
	set_bit(STATUS_ALIVE, &priv->status);

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

C
Christoph Hellwig 已提交
5957
	if (iwl3945_is_rfkill(priv))
Z
Zhu Yi 已提交
5958 5959
		return;

5960
	ieee80211_start_queues(priv->hw);
Z
Zhu Yi 已提交
5961 5962 5963 5964

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

C
Christoph Hellwig 已提交
5965
	iwl3945_send_power_mode(priv, IWL_POWER_LEVEL(priv->power_mode));
Z
Zhu Yi 已提交
5966

C
Christoph Hellwig 已提交
5967 5968 5969
	if (iwl3945_is_associated(priv)) {
		struct iwl3945_rxon_cmd *active_rxon =
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
5970 5971 5972 5973 5974 5975

		memcpy(&priv->staging_rxon, &priv->active_rxon,
		       sizeof(priv->staging_rxon));
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
C
Christoph Hellwig 已提交
5976
		iwl3945_connection_init_rx_config(priv);
Z
Zhu Yi 已提交
5977 5978 5979
		memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
	}

5980
	/* Configure Bluetooth device coexistence support */
C
Christoph Hellwig 已提交
5981
	iwl3945_send_bt_config(priv);
Z
Zhu Yi 已提交
5982 5983

	/* Configure the adapter for unassociated operation */
C
Christoph Hellwig 已提交
5984
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5985 5986 5987 5988 5989 5990 5991 5992

	/* At this point, the NIC is initialized and operational */
	priv->notif_missed_beacons = 0;
	set_bit(STATUS_READY, &priv->status);

	iwl3945_reg_txpower_periodic(priv);

	IWL_DEBUG_INFO("ALIVE processing complete.\n");
5993
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
5994 5995

	if (priv->error_recovering)
C
Christoph Hellwig 已提交
5996
		iwl3945_error_recovery(priv);
Z
Zhu Yi 已提交
5997 5998 5999 6000 6001 6002 6003

	return;

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

C
Christoph Hellwig 已提交
6004
static void iwl3945_cancel_deferred_work(struct iwl3945_priv *priv);
Z
Zhu Yi 已提交
6005

C
Christoph Hellwig 已提交
6006
static void __iwl3945_down(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018
{
	unsigned long flags;
	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
	struct ieee80211_conf *conf = NULL;

	IWL_DEBUG_INFO(DRV_NAME " is going down\n");

	conf = ieee80211_get_hw_conf(priv->hw);

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

C
Christoph Hellwig 已提交
6019
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
6020 6021 6022 6023 6024 6025 6026 6027 6028 6029

	/* 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 */
C
Christoph Hellwig 已提交
6030
	iwl3945_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
Z
Zhu Yi 已提交
6031 6032

	/* tell the device to stop sending interrupts */
C
Christoph Hellwig 已提交
6033
	iwl3945_disable_interrupts(priv);
Z
Zhu Yi 已提交
6034 6035 6036 6037

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

C
Christoph Hellwig 已提交
6038
	/* If we have not previously called iwl3945_init() then
Z
Zhu Yi 已提交
6039
	 * clear all bits but the RF Kill and SUSPEND bits and return */
C
Christoph Hellwig 已提交
6040
	if (!iwl3945_is_init(priv)) {
Z
Zhu Yi 已提交
6041 6042 6043 6044
		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 |
6045 6046
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057
			       test_bit(STATUS_IN_SUSPEND, &priv->status) <<
					STATUS_IN_SUSPEND;
		goto exit;
	}

	/* ...otherwise clear out all the status bits but the RF Kill and
	 * SUSPEND bits and continue taking the NIC down. */
	priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
				STATUS_RF_KILL_HW |
			test_bit(STATUS_RF_KILL_SW, &priv->status) <<
				STATUS_RF_KILL_SW |
6058 6059
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
6060 6061 6062 6063 6064 6065
			test_bit(STATUS_IN_SUSPEND, &priv->status) <<
				STATUS_IN_SUSPEND |
			test_bit(STATUS_FW_ERROR, &priv->status) <<
				STATUS_FW_ERROR;

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
6066
	iwl3945_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
Z
Zhu Yi 已提交
6067 6068
	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
6069 6070
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
6071 6072

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
6073 6074
	if (!iwl3945_grab_nic_access(priv)) {
		iwl3945_write_prph(priv, APMG_CLK_DIS_REG,
Z
Zhu Yi 已提交
6075
					 APMG_CLK_VAL_DMA_CLK_RQT);
C
Christoph Hellwig 已提交
6076
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
6077 6078 6079 6080 6081
	}
	spin_unlock_irqrestore(&priv->lock, flags);

	udelay(5);

C
Christoph Hellwig 已提交
6082 6083 6084
	iwl3945_hw_nic_stop_master(priv);
	iwl3945_set_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_SW_RESET);
	iwl3945_hw_nic_reset(priv);
Z
Zhu Yi 已提交
6085 6086

 exit:
C
Christoph Hellwig 已提交
6087
	memset(&priv->card_alive, 0, sizeof(struct iwl3945_alive_resp));
Z
Zhu Yi 已提交
6088 6089 6090 6091 6092 6093

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
6094
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
6095 6096
}

C
Christoph Hellwig 已提交
6097
static void iwl3945_down(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
6098 6099
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
6100
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
6101
	mutex_unlock(&priv->mutex);
6102

C
Christoph Hellwig 已提交
6103
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
6104 6105 6106 6107
}

#define MAX_HW_RESTARTS 5

C
Christoph Hellwig 已提交
6108
static int __iwl3945_up(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119
{
	int rc, i;

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
		IWL_WARNING("Exit pending; will not bring the NIC up\n");
		return -EIO;
	}

	if (test_bit(STATUS_RF_KILL_SW, &priv->status)) {
		IWL_WARNING("Radio disabled by SW RF kill (module "
			    "parameter)\n");
6120 6121 6122
		return -ENODEV;
	}

6123 6124 6125 6126 6127
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
		IWL_ERROR("ucode not available for device bringup\n");
		return -EIO;
	}

6128 6129 6130 6131 6132 6133 6134 6135 6136 6137
	/* If platform's RF_KILL switch is NOT set to KILL */
	if (iwl3945_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_IN_SUSPEND, &priv->status)) {
			IWL_WARNING("Radio disabled by HW RF Kill switch\n");
			return -ENODEV;
		}
Z
Zhu Yi 已提交
6138 6139
	}

C
Christoph Hellwig 已提交
6140
	iwl3945_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
6141

C
Christoph Hellwig 已提交
6142
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
6143 6144 6145 6146 6147 6148
	if (rc) {
		IWL_ERROR("Unable to int nic\n");
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
C
Christoph Hellwig 已提交
6149 6150
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
6151 6152 6153
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
C
Christoph Hellwig 已提交
6154 6155
	iwl3945_write32(priv, CSR_INT, 0xFFFFFFFF);
	iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
6156 6157

	/* really make sure rfkill handshake bits are cleared */
C
Christoph Hellwig 已提交
6158 6159
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
Z
Zhu Yi 已提交
6160 6161 6162 6163 6164

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

6167 6168 6169 6170
	/* 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 已提交
6171 6172
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

C
Christoph Hellwig 已提交
6173
		iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
6174 6175 6176 6177

		/* load bootstrap state machine,
		 * load bootstrap program into processor's memory,
		 * prepare to load the "initialize" uCode */
C
Christoph Hellwig 已提交
6178
		rc = iwl3945_load_bsm(priv);
Z
Zhu Yi 已提交
6179 6180 6181 6182 6183 6184 6185

		if (rc) {
			IWL_ERROR("Unable to set up bootstrap uCode: %d\n", rc);
			continue;
		}

		/* start card; "initialize" will load runtime ucode */
C
Christoph Hellwig 已提交
6186
		iwl3945_nic_start(priv);
Z
Zhu Yi 已提交
6187 6188 6189 6190 6191 6192 6193

		IWL_DEBUG_INFO(DRV_NAME " is coming up\n");

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
6194
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
	IWL_ERROR("Unable to initialize device after %d attempts.\n", i);
	return -EIO;
}


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

C
Christoph Hellwig 已提交
6209
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
6210
{
C
Christoph Hellwig 已提交
6211 6212
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, init_alive_start.work);
Z
Zhu Yi 已提交
6213 6214 6215 6216 6217

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
6218
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
6219 6220 6221
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
6222
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
6223
{
C
Christoph Hellwig 已提交
6224 6225
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, alive_start.work);
Z
Zhu Yi 已提交
6226 6227 6228 6229 6230

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
6231
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
6232 6233 6234
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
6235
static void iwl3945_bg_rf_kill(struct work_struct *work)
Z
Zhu Yi 已提交
6236
{
C
Christoph Hellwig 已提交
6237
	struct iwl3945_priv *priv = container_of(work, struct iwl3945_priv, rf_kill);
Z
Zhu Yi 已提交
6238 6239 6240 6241 6242 6243 6244 6245

	wake_up_interruptible(&priv->wait_command_queue);

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

	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
6246
	if (!iwl3945_is_rfkill(priv)) {
Z
Zhu Yi 已提交
6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266
		IWL_DEBUG(IWL_DL_INFO | IWL_DL_RF_KILL,
			  "HW and/or SW RF Kill no longer active, restarting "
			  "device\n");
		if (!test_bit(STATUS_EXIT_PENDING, &priv->status))
			queue_work(priv->workqueue, &priv->restart);
	} else {

		if (!test_bit(STATUS_RF_KILL_HW, &priv->status))
			IWL_DEBUG_RF_KILL("Can not turn radio back on - "
					  "disabled by SW switch\n");
		else
			IWL_WARNING("Radio Frequency Kill Switch is On:\n"
				    "Kill switch must be turned off for "
				    "wireless networking to work.\n");
	}
	mutex_unlock(&priv->mutex);
}

#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)

C
Christoph Hellwig 已提交
6267
static void iwl3945_bg_scan_check(struct work_struct *data)
Z
Zhu Yi 已提交
6268
{
C
Christoph Hellwig 已提交
6269 6270
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, scan_check.work);
Z
Zhu Yi 已提交
6271 6272 6273 6274 6275 6276 6277 6278 6279 6280

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

	mutex_lock(&priv->mutex);
	if (test_bit(STATUS_SCANNING, &priv->status) ||
	    test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
		IWL_DEBUG(IWL_DL_INFO | IWL_DL_SCAN,
			  "Scan completion watchdog resetting adapter (%dms)\n",
			  jiffies_to_msecs(IWL_SCAN_CHECK_WATCHDOG));
6281

Z
Zhu Yi 已提交
6282
		if (!test_bit(STATUS_EXIT_PENDING, &priv->status))
C
Christoph Hellwig 已提交
6283
			iwl3945_send_scan_abort(priv);
Z
Zhu Yi 已提交
6284 6285 6286 6287
	}
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
6288
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
6289
{
C
Christoph Hellwig 已提交
6290 6291 6292
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, request_scan);
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
6293
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
6294
		.len = sizeof(struct iwl3945_scan_cmd),
Z
Zhu Yi 已提交
6295 6296 6297
		.meta.flags = CMD_SIZE_HUGE,
	};
	int rc = 0;
C
Christoph Hellwig 已提交
6298
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
6299 6300
	struct ieee80211_conf *conf = NULL;
	u8 direct_mask;
6301
	enum ieee80211_band band;
Z
Zhu Yi 已提交
6302 6303 6304 6305 6306

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
6307
	if (!iwl3945_is_ready(priv)) {
Z
Zhu Yi 已提交
6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335
		IWL_WARNING("request scan called when driver not ready.\n");
		goto done;
	}

	/* Make sure the scan wasn't cancelled before this queued work
	 * 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)) {
		IWL_DEBUG_INFO("Multiple concurrent scan requests in parallel. "
			       "Ignoring second request.\n");
		rc = -EIO;
		goto done;
	}

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
		IWL_DEBUG_SCAN("Aborting scan due to device shutdown\n");
		goto done;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
		IWL_DEBUG_HC("Scan request while abort pending.  Queuing.\n");
		goto done;
	}

C
Christoph Hellwig 已提交
6336
	if (iwl3945_is_rfkill(priv)) {
Z
Zhu Yi 已提交
6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351
		IWL_DEBUG_HC("Aborting scan due to RF Kill activation\n");
		goto done;
	}

	if (!test_bit(STATUS_READY, &priv->status)) {
		IWL_DEBUG_HC("Scan request while uninitialized.  Queuing.\n");
		goto done;
	}

	if (!priv->scan_bands) {
		IWL_DEBUG_HC("Aborting scan due to no requested bands\n");
		goto done;
	}

	if (!priv->scan) {
C
Christoph Hellwig 已提交
6352
		priv->scan = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
6353 6354 6355 6356 6357 6358 6359
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
		if (!priv->scan) {
			rc = -ENOMEM;
			goto done;
		}
	}
	scan = priv->scan;
C
Christoph Hellwig 已提交
6360
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
6361 6362 6363 6364

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

C
Christoph Hellwig 已提交
6365
	if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377 6378
		u16 interval = 0;
		u32 extra;
		u32 suspend_time = 100;
		u32 scan_suspend_time = 100;
		unsigned long flags;

		IWL_DEBUG_INFO("Scanning while associated...\n");

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

		scan->suspend_time = 0;
6379
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 6401
		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);
		IWL_DEBUG_SCAN("suspend_time 0x%X beacon interval %d\n",
			       scan_suspend_time, interval);
	}

	/* We should add the ability for user to lock to PASSIVE ONLY */
	if (priv->one_direct_scan) {
		IWL_DEBUG_SCAN
		    ("Kicking off one direct scan for '%s'\n",
C
Christoph Hellwig 已提交
6402
		     iwl3945_escape_essid(priv->direct_ssid,
Z
Zhu Yi 已提交
6403 6404 6405 6406 6407 6408
				      priv->direct_ssid_len));
		scan->direct_scan[0].id = WLAN_EID_SSID;
		scan->direct_scan[0].len = priv->direct_ssid_len;
		memcpy(scan->direct_scan[0].ssid,
		       priv->direct_ssid, priv->direct_ssid_len);
		direct_mask = 1;
C
Christoph Hellwig 已提交
6409
	} else if (!iwl3945_is_associated(priv) && priv->essid_len) {
Z
Zhu Yi 已提交
6410 6411 6412 6413 6414 6415 6416 6417 6418 6419
		scan->direct_scan[0].id = WLAN_EID_SSID;
		scan->direct_scan[0].len = priv->essid_len;
		memcpy(scan->direct_scan[0].ssid, priv->essid, priv->essid_len);
		direct_mask = 1;
	} else
		direct_mask = 0;

	/* 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.len = cpu_to_le16(
C
Christoph Hellwig 已提交
6420
		iwl3945_fill_probe_req(priv, (struct ieee80211_mgmt *)scan->data,
6421
			IWL_MAX_SCAN_SIZE - sizeof(*scan), 0));
Z
Zhu Yi 已提交
6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432
	scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
	scan->tx_cmd.sta_id = priv->hw_setting.bcast_sta_id;
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

	switch (priv->scan_bands) {
	case 2:
		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;
6433
		band = IEEE80211_BAND_2GHZ;
Z
Zhu Yi 已提交
6434 6435 6436 6437 6438
		break;

	case 1:
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
		scan->good_CRC_th = IWL_GOOD_CRC_TH;
6439
		band = IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455
		break;

	default:
		IWL_WARNING("Invalid scan band count\n");
		goto done;
	}

	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

	if (priv->iw_mode == IEEE80211_IF_TYPE_MNTR)
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

	if (direct_mask)
		IWL_DEBUG_SCAN
		    ("Initiating direct scan for %s.\n",
C
Christoph Hellwig 已提交
6456
		     iwl3945_escape_essid(priv->essid, priv->essid_len));
Z
Zhu Yi 已提交
6457 6458 6459 6460
	else
		IWL_DEBUG_SCAN("Initiating indirect scan.\n");

	scan->channel_count =
C
Christoph Hellwig 已提交
6461
		iwl3945_get_channels_for_scan(
6462
			priv, band, 1, /* active */
Z
Zhu Yi 已提交
6463 6464 6465 6466
			direct_mask,
			(void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);

	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
6467
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
6468 6469 6470 6471
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
C
Christoph Hellwig 已提交
6472
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
6473 6474 6475 6476 6477 6478 6479 6480 6481 6482
	if (rc)
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
6483
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
6484 6485 6486 6487
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
6488
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
6489
{
C
Christoph Hellwig 已提交
6490
	struct iwl3945_priv *priv = container_of(data, struct iwl3945_priv, up);
Z
Zhu Yi 已提交
6491 6492 6493 6494 6495

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
6496
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
6497 6498 6499
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
6500
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
6501
{
C
Christoph Hellwig 已提交
6502
	struct iwl3945_priv *priv = container_of(data, struct iwl3945_priv, restart);
Z
Zhu Yi 已提交
6503 6504 6505 6506

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

C
Christoph Hellwig 已提交
6507
	iwl3945_down(priv);
Z
Zhu Yi 已提交
6508 6509 6510
	queue_work(priv->workqueue, &priv->up);
}

C
Christoph Hellwig 已提交
6511
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
6512
{
C
Christoph Hellwig 已提交
6513 6514
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, rx_replenish);
Z
Zhu Yi 已提交
6515 6516 6517 6518 6519

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
6520
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
6521 6522 6523
	mutex_unlock(&priv->mutex);
}

6524 6525
#define IWL_DELAY_NEXT_SCAN (HZ*2)

C
Christoph Hellwig 已提交
6526
static void iwl3945_bg_post_associate(struct work_struct *data)
Z
Zhu Yi 已提交
6527
{
C
Christoph Hellwig 已提交
6528
	struct iwl3945_priv *priv = container_of(data, struct iwl3945_priv,
Z
Zhu Yi 已提交
6529 6530 6531 6532
					     post_associate.work);

	int rc = 0;
	struct ieee80211_conf *conf = NULL;
6533
	DECLARE_MAC_BUF(mac);
Z
Zhu Yi 已提交
6534 6535 6536 6537 6538 6539 6540

	if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
		IWL_ERROR("%s Should not be called in AP mode\n", __FUNCTION__);
		return;
	}


6541 6542 6543
	IWL_DEBUG_ASSOC("Associated as %d to: %s\n",
			priv->assoc_id,
			print_mac(mac, priv->active_rxon.bssid_addr));
Z
Zhu Yi 已提交
6544 6545 6546 6547 6548 6549

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

	mutex_lock(&priv->mutex);

6550
	if (!priv->vif || !priv->is_open) {
6551 6552 6553
		mutex_unlock(&priv->mutex);
		return;
	}
C
Christoph Hellwig 已提交
6554
	iwl3945_scan_cancel_timeout(priv, 200);
6555

Z
Zhu Yi 已提交
6556 6557 6558
	conf = ieee80211_get_hw_conf(priv->hw);

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

C
Christoph Hellwig 已提交
6561 6562 6563
	memset(&priv->rxon_timing, 0, sizeof(struct iwl3945_rxon_time_cmd));
	iwl3945_setup_rxon_timing(priv);
	rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
		IWL_WARNING("REPLY_RXON_TIMING failed - "
			    "Attempting to continue.\n");

	priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;

	priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);

	IWL_DEBUG_ASSOC("assoc id %d beacon interval %d\n",
			priv->assoc_id, priv->beacon_int);

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
	else
		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;

	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
		else
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;

		if (priv->iw_mode == IEEE80211_IF_TYPE_IBSS)
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;

	}

C
Christoph Hellwig 已提交
6592
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6593 6594 6595

	switch (priv->iw_mode) {
	case IEEE80211_IF_TYPE_STA:
C
Christoph Hellwig 已提交
6596
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
6597 6598 6599 6600 6601
		break;

	case IEEE80211_IF_TYPE_IBSS:

		/* clear out the station table */
C
Christoph Hellwig 已提交
6602
		iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
6603

C
Christoph Hellwig 已提交
6604 6605
		iwl3945_add_station(priv, iwl3945_broadcast_addr, 0, 0);
		iwl3945_add_station(priv, priv->bssid, 0, 0);
Z
Zhu Yi 已提交
6606
		iwl3945_sync_sta(priv, IWL_STA_ID,
6607
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
6608 6609
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
6610 6611
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
6612 6613 6614 6615 6616

		break;

	default:
		 IWL_ERROR("%s Should not be called in %d mode\n",
6617
			   __FUNCTION__, priv->iw_mode);
Z
Zhu Yi 已提交
6618 6619 6620
		break;
	}

C
Christoph Hellwig 已提交
6621
	iwl3945_sequence_reset(priv);
Z
Zhu Yi 已提交
6622

C
Christoph Hellwig 已提交
6623
	iwl3945_activate_qos(priv, 0);
6624

6625 6626
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
Z
Zhu Yi 已提交
6627 6628 6629
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
6630
static void iwl3945_bg_abort_scan(struct work_struct *work)
Z
Zhu Yi 已提交
6631
{
C
Christoph Hellwig 已提交
6632
	struct iwl3945_priv *priv = container_of(work, struct iwl3945_priv, abort_scan);
Z
Zhu Yi 已提交
6633

C
Christoph Hellwig 已提交
6634
	if (!iwl3945_is_ready(priv))
Z
Zhu Yi 已提交
6635 6636 6637 6638 6639
		return;

	mutex_lock(&priv->mutex);

	set_bit(STATUS_SCAN_ABORTING, &priv->status);
C
Christoph Hellwig 已提交
6640
	iwl3945_send_scan_abort(priv);
Z
Zhu Yi 已提交
6641 6642 6643 6644

	mutex_unlock(&priv->mutex);
}

6645 6646
static int iwl3945_mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf);

C
Christoph Hellwig 已提交
6647
static void iwl3945_bg_scan_completed(struct work_struct *work)
Z
Zhu Yi 已提交
6648
{
C
Christoph Hellwig 已提交
6649 6650
	struct iwl3945_priv *priv =
	    container_of(work, struct iwl3945_priv, scan_completed);
Z
Zhu Yi 已提交
6651 6652 6653 6654 6655 6656

	IWL_DEBUG(IWL_DL_INFO | IWL_DL_SCAN, "SCAN complete scan\n");

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

6657 6658
	if (test_bit(STATUS_CONF_PENDING, &priv->status))
		iwl3945_mac_config(priv->hw, ieee80211_get_hw_conf(priv->hw));
6659

Z
Zhu Yi 已提交
6660 6661 6662 6663 6664
	ieee80211_scan_completed(priv->hw);

	/* Since setting the TXPOWER may have been deferred while
	 * performing the scan, fire one off */
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
6665
	iwl3945_hw_reg_send_txpower(priv);
Z
Zhu Yi 已提交
6666 6667 6668 6669 6670 6671 6672 6673 6674
	mutex_unlock(&priv->mutex);
}

/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

6675 6676
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
6677
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
6678
{
C
Christoph Hellwig 已提交
6679
	struct iwl3945_priv *priv = hw->priv;
6680
	int ret;
Z
Zhu Yi 已提交
6681 6682 6683

	IWL_DEBUG_MAC80211("enter\n");

6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697
	if (pci_enable_device(priv->pci_dev)) {
		IWL_ERROR("Fail to pci_enable_device\n");
		return -ENODEV;
	}
	pci_restore_state(priv->pci_dev);
	pci_enable_msi(priv->pci_dev);

	ret = request_irq(priv->pci_dev->irq, iwl3945_isr, IRQF_SHARED,
			  DRV_NAME, priv);
	if (ret) {
		IWL_ERROR("Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

Z
Zhu Yi 已提交
6698 6699 6700
	/* we should be verifying the device is ready to be opened */
	mutex_lock(&priv->mutex);

6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712
	memset(&priv->staging_rxon, 0, sizeof(struct iwl3945_rxon_cmd));
	/* 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) {
			IWL_ERROR("Could not read microcode: %d\n", ret);
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
6713

6714
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
6715 6716

	mutex_unlock(&priv->mutex);
6717

6718 6719 6720 6721 6722 6723 6724 6725
	if (ret)
		goto out_release_irq;

	IWL_DEBUG_INFO("Start UP work.\n");

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

6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739
	/* 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)) {
			IWL_ERROR("Wait for START_ALIVE timeout after %dms.\n",
				  jiffies_to_msecs(UCODE_READY_TIMEOUT));
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

6740
	priv->is_open = 1;
Z
Zhu Yi 已提交
6741 6742
	IWL_DEBUG_MAC80211("leave\n");
	return 0;
6743 6744 6745 6746 6747

out_release_irq:
	free_irq(priv->pci_dev->irq, priv);
out_disable_msi:
	pci_disable_msi(priv->pci_dev);
6748 6749 6750
	pci_disable_device(priv->pci_dev);
	priv->is_open = 0;
	IWL_DEBUG_MAC80211("leave - failed\n");
6751
	return ret;
Z
Zhu Yi 已提交
6752 6753
}

C
Christoph Hellwig 已提交
6754
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
6755
{
C
Christoph Hellwig 已提交
6756
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6757 6758

	IWL_DEBUG_MAC80211("enter\n");
6759

6760 6761 6762 6763 6764
	if (!priv->is_open) {
		IWL_DEBUG_MAC80211("leave - skip\n");
		return;
	}

Z
Zhu Yi 已提交
6765
	priv->is_open = 0;
6766 6767

	if (iwl3945_is_ready_rf(priv)) {
6768 6769 6770
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
6771 6772 6773
		mutex_lock(&priv->mutex);
		iwl3945_scan_cancel_timeout(priv, 100);
		cancel_delayed_work(&priv->post_associate);
6774 6775 6776
		mutex_unlock(&priv->mutex);
	}

6777 6778 6779 6780 6781 6782 6783
	iwl3945_down(priv);

	flush_workqueue(priv->workqueue);
	free_irq(priv->pci_dev->irq, priv);
	pci_disable_msi(priv->pci_dev);
	pci_save_state(priv->pci_dev);
	pci_disable_device(priv->pci_dev);
6784

Z
Zhu Yi 已提交
6785 6786 6787
	IWL_DEBUG_MAC80211("leave\n");
}

C
Christoph Hellwig 已提交
6788
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb,
Z
Zhu Yi 已提交
6789 6790
		      struct ieee80211_tx_control *ctl)
{
C
Christoph Hellwig 已提交
6791
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6792 6793 6794 6795 6796 6797 6798 6799 6800

	IWL_DEBUG_MAC80211("enter\n");

	if (priv->iw_mode == IEEE80211_IF_TYPE_MNTR) {
		IWL_DEBUG_MAC80211("leave - monitor\n");
		return -1;
	}

	IWL_DEBUG_TX("dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
6801
		     ctl->tx_rate->bitrate);
Z
Zhu Yi 已提交
6802

C
Christoph Hellwig 已提交
6803
	if (iwl3945_tx_skb(priv, skb, ctl))
Z
Zhu Yi 已提交
6804 6805 6806 6807 6808 6809
		dev_kfree_skb_any(skb);

	IWL_DEBUG_MAC80211("leave\n");
	return 0;
}

C
Christoph Hellwig 已提交
6810
static int iwl3945_mac_add_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
6811 6812
				 struct ieee80211_if_init_conf *conf)
{
C
Christoph Hellwig 已提交
6813
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6814
	unsigned long flags;
6815
	DECLARE_MAC_BUF(mac);
Z
Zhu Yi 已提交
6816

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

6819 6820
	if (priv->vif) {
		IWL_DEBUG_MAC80211("leave - vif != NULL\n");
6821
		return -EOPNOTSUPP;
Z
Zhu Yi 已提交
6822 6823 6824
	}

	spin_lock_irqsave(&priv->lock, flags);
6825
	priv->vif = conf->vif;
Z
Zhu Yi 已提交
6826 6827 6828 6829

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
6830 6831 6832 6833 6834 6835

	if (conf->mac_addr) {
		IWL_DEBUG_MAC80211("Set: %s\n", print_mac(mac, conf->mac_addr));
		memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
	}

6836 6837
	if (iwl3945_is_ready(priv))
		iwl3945_set_mode(priv, conf->type);
Z
Zhu Yi 已提交
6838 6839 6840

	mutex_unlock(&priv->mutex);

6841
	IWL_DEBUG_MAC80211("leave\n");
Z
Zhu Yi 已提交
6842 6843 6844 6845
	return 0;
}

/**
C
Christoph Hellwig 已提交
6846
 * iwl3945_mac_config - mac80211 config callback
Z
Zhu Yi 已提交
6847 6848 6849 6850 6851
 *
 * We ignore conf->flags & IEEE80211_CONF_SHORT_SLOT_TIME since it seems to
 * be set inappropriately and the driver currently sets the hardware up to
 * use it whenever needed.
 */
C
Christoph Hellwig 已提交
6852
static int iwl3945_mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf)
Z
Zhu Yi 已提交
6853
{
C
Christoph Hellwig 已提交
6854 6855
	struct iwl3945_priv *priv = hw->priv;
	const struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
6856
	unsigned long flags;
6857
	int ret = 0;
Z
Zhu Yi 已提交
6858 6859

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

Z
Zhu Yi 已提交
6862 6863
	priv->add_radiotap = !!(conf->flags & IEEE80211_CONF_RADIOTAP);

C
Christoph Hellwig 已提交
6864
	if (!iwl3945_is_ready(priv)) {
Z
Zhu Yi 已提交
6865
		IWL_DEBUG_MAC80211("leave - not ready\n");
6866 6867
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
6868 6869
	}

C
Christoph Hellwig 已提交
6870
	if (unlikely(!iwl3945_param_disable_hw_scan &&
Z
Zhu Yi 已提交
6871
		     test_bit(STATUS_SCANNING, &priv->status))) {
6872 6873
		IWL_DEBUG_MAC80211("leave - scanning\n");
		set_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
6874
		mutex_unlock(&priv->mutex);
6875
		return 0;
Z
Zhu Yi 已提交
6876 6877 6878 6879
	}

	spin_lock_irqsave(&priv->lock, flags);

6880 6881
	ch_info = iwl3945_get_channel_info(priv, conf->channel->band,
					   conf->channel->hw_value);
Z
Zhu Yi 已提交
6882 6883
	if (!is_channel_valid(ch_info)) {
		IWL_DEBUG_SCAN("Channel %d [%d] is INVALID for this SKU.\n",
6884
			       conf->channel->hw_value, conf->channel->band);
Z
Zhu Yi 已提交
6885 6886
		IWL_DEBUG_MAC80211("leave - invalid channel\n");
		spin_unlock_irqrestore(&priv->lock, flags);
6887 6888
		ret = -EINVAL;
		goto out;
Z
Zhu Yi 已提交
6889 6890
	}

6891
	iwl3945_set_rxon_channel(priv, conf->channel->band, conf->channel->hw_value);
Z
Zhu Yi 已提交
6892

6893
	iwl3945_set_flags_for_phymode(priv, conf->channel->band);
Z
Zhu Yi 已提交
6894 6895 6896 6897

	/* The list of supported rates and rate mask can be different
	 * for each phymode; since the phymode may have changed, reset
	 * the rate mask to what mac80211 lists */
C
Christoph Hellwig 已提交
6898
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6899 6900 6901 6902 6903

	spin_unlock_irqrestore(&priv->lock, flags);

#ifdef IEEE80211_CONF_CHANNEL_SWITCH
	if (conf->flags & IEEE80211_CONF_CHANNEL_SWITCH) {
C
Christoph Hellwig 已提交
6904
		iwl3945_hw_channel_switch(priv, conf->channel);
6905
		goto out;
Z
Zhu Yi 已提交
6906 6907 6908
	}
#endif

C
Christoph Hellwig 已提交
6909
	iwl3945_radio_kill_sw(priv, !conf->radio_enabled);
Z
Zhu Yi 已提交
6910 6911 6912

	if (!conf->radio_enabled) {
		IWL_DEBUG_MAC80211("leave - radio disabled\n");
6913
		goto out;
Z
Zhu Yi 已提交
6914 6915
	}

C
Christoph Hellwig 已提交
6916
	if (iwl3945_is_rfkill(priv)) {
Z
Zhu Yi 已提交
6917
		IWL_DEBUG_MAC80211("leave - RF kill\n");
6918 6919
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
6920 6921
	}

C
Christoph Hellwig 已提交
6922
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6923 6924 6925

	if (memcmp(&priv->active_rxon,
		   &priv->staging_rxon, sizeof(priv->staging_rxon)))
C
Christoph Hellwig 已提交
6926
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6927 6928 6929 6930 6931
	else
		IWL_DEBUG_INFO("No re-sending same RXON configuration.\n");

	IWL_DEBUG_MAC80211("leave\n");

6932
out:
6933
	clear_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
6934
	mutex_unlock(&priv->mutex);
6935
	return ret;
Z
Zhu Yi 已提交
6936 6937
}

C
Christoph Hellwig 已提交
6938
static void iwl3945_config_ap(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
6939 6940 6941
{
	int rc = 0;

6942
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
6943 6944 6945 6946 6947 6948 6949
		return;

	/* The following should be done only at AP bring up */
	if ((priv->active_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) == 0) {

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

		/* RXON Timing */
C
Christoph Hellwig 已提交
6953 6954 6955
		memset(&priv->rxon_timing, 0, sizeof(struct iwl3945_rxon_time_cmd));
		iwl3945_setup_rxon_timing(priv);
		rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984
				sizeof(priv->rxon_timing), &priv->rxon_timing);
		if (rc)
			IWL_WARNING("REPLY_RXON_TIMING failed - "
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
		priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
			priv->staging_rxon.flags |=
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
			priv->staging_rxon.flags &=
				~RXON_FLG_SHORT_PREAMBLE_MSK;

		if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
				priv->staging_rxon.flags |=
					RXON_FLG_SHORT_SLOT_MSK;
			else
				priv->staging_rxon.flags &=
					~RXON_FLG_SHORT_SLOT_MSK;

			if (priv->iw_mode == IEEE80211_IF_TYPE_IBSS)
				priv->staging_rxon.flags &=
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6985 6986
		iwl3945_commit_rxon(priv);
		iwl3945_add_station(priv, iwl3945_broadcast_addr, 0, 0);
6987
	}
C
Christoph Hellwig 已提交
6988
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
6989 6990 6991 6992 6993 6994

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

6995 6996
static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
Z
Zhu Yi 已提交
6997 6998
				    struct ieee80211_if_conf *conf)
{
C
Christoph Hellwig 已提交
6999
	struct iwl3945_priv *priv = hw->priv;
7000
	DECLARE_MAC_BUF(mac);
Z
Zhu Yi 已提交
7001 7002 7003 7004 7005 7006
	unsigned long flags;
	int rc;

	if (conf == NULL)
		return -EIO;

7007 7008 7009 7010 7011 7012
	if (priv->vif != vif) {
		IWL_DEBUG_MAC80211("leave - priv->vif != vif\n");
		mutex_unlock(&priv->mutex);
		return 0;
	}

7013 7014
	/* XXX: this MUST use conf->mac_addr */

Z
Zhu Yi 已提交
7015 7016 7017 7018 7019 7020 7021
	if ((priv->iw_mode == IEEE80211_IF_TYPE_AP) &&
	    (!conf->beacon || !conf->ssid_len)) {
		IWL_DEBUG_MAC80211
		    ("Leaving in AP mode because HostAPD is not ready.\n");
		return 0;
	}

7022 7023 7024
	if (!iwl3945_is_alive(priv))
		return -EAGAIN;

Z
Zhu Yi 已提交
7025 7026 7027
	mutex_lock(&priv->mutex);

	if (conf->bssid)
7028 7029
		IWL_DEBUG_MAC80211("bssid: %s\n",
				   print_mac(mac, conf->bssid));
Z
Zhu Yi 已提交
7030

7031 7032 7033
/*
 * very dubious code was here; the probe filtering flag is never set:
 *
Z
Zhu Yi 已提交
7034 7035
	if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
	    !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
7036
 */
Z
Zhu Yi 已提交
7037 7038 7039 7040 7041

	if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
		if (!conf->bssid) {
			conf->bssid = priv->mac_addr;
			memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
7042 7043
			IWL_DEBUG_MAC80211("bssid was set to: %s\n",
					   print_mac(mac, conf->bssid));
Z
Zhu Yi 已提交
7044 7045 7046 7047 7048 7049 7050
		}
		if (priv->ibss_beacon)
			dev_kfree_skb(priv->ibss_beacon);

		priv->ibss_beacon = conf->beacon;
	}

7051 7052 7053
	if (iwl3945_is_rfkill(priv))
		goto done;

Z
Zhu Yi 已提交
7054 7055 7056 7057
	if (conf->bssid && !is_zero_ether_addr(conf->bssid) &&
	    !is_multicast_ether_addr(conf->bssid)) {
		/* If there is currently a HW scan going on in the background
		 * then we need to cancel it else the RXON below will fail. */
C
Christoph Hellwig 已提交
7058
		if (iwl3945_scan_cancel_timeout(priv, 100)) {
Z
Zhu Yi 已提交
7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073
			IWL_WARNING("Aborted scan still in progress "
				    "after 100ms\n");
			IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
			mutex_unlock(&priv->mutex);
			return -EAGAIN;
		}
		memcpy(priv->staging_rxon.bssid_addr, conf->bssid, ETH_ALEN);

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

		if (priv->iw_mode == IEEE80211_IF_TYPE_AP)
C
Christoph Hellwig 已提交
7074
			iwl3945_config_ap(priv);
Z
Zhu Yi 已提交
7075
		else {
C
Christoph Hellwig 已提交
7076
			rc = iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7077
			if ((priv->iw_mode == IEEE80211_IF_TYPE_STA) && rc)
C
Christoph Hellwig 已提交
7078
				iwl3945_add_station(priv,
7079
					priv->active_rxon.bssid_addr, 1, 0);
Z
Zhu Yi 已提交
7080 7081 7082
		}

	} else {
C
Christoph Hellwig 已提交
7083
		iwl3945_scan_cancel_timeout(priv, 100);
Z
Zhu Yi 已提交
7084
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
7085
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7086 7087
	}

7088
 done:
Z
Zhu Yi 已提交
7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103
	spin_lock_irqsave(&priv->lock, flags);
	if (!conf->ssid_len)
		memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
	else
		memcpy(priv->essid, conf->ssid, conf->ssid_len);

	priv->essid_len = conf->ssid_len;
	spin_unlock_irqrestore(&priv->lock, flags);

	IWL_DEBUG_MAC80211("leave\n");
	mutex_unlock(&priv->mutex);

	return 0;
}

C
Christoph Hellwig 已提交
7104
static void iwl3945_configure_filter(struct ieee80211_hw *hw,
7105 7106 7107 7108 7109 7110
				 unsigned int changed_flags,
				 unsigned int *total_flags,
				 int mc_count, struct dev_addr_list *mc_list)
{
	/*
	 * XXX: dummy
C
Christoph Hellwig 已提交
7111
	 * see also iwl3945_connection_init_rx_config
7112 7113 7114 7115
	 */
	*total_flags = 0;
}

C
Christoph Hellwig 已提交
7116
static void iwl3945_mac_remove_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
7117 7118
				     struct ieee80211_if_init_conf *conf)
{
C
Christoph Hellwig 已提交
7119
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7120 7121 7122 7123

	IWL_DEBUG_MAC80211("enter\n");

	mutex_lock(&priv->mutex);
7124

7125 7126 7127 7128 7129 7130
	if (iwl3945_is_ready_rf(priv)) {
		iwl3945_scan_cancel_timeout(priv, 100);
		cancel_delayed_work(&priv->post_associate);
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
		iwl3945_commit_rxon(priv);
	}
7131 7132
	if (priv->vif == conf->vif) {
		priv->vif = NULL;
Z
Zhu Yi 已提交
7133 7134 7135 7136 7137 7138 7139 7140 7141
		memset(priv->bssid, 0, ETH_ALEN);
		memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
		priv->essid_len = 0;
	}
	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");
}

C
Christoph Hellwig 已提交
7142
static int iwl3945_mac_hw_scan(struct ieee80211_hw *hw, u8 *ssid, size_t len)
Z
Zhu Yi 已提交
7143 7144 7145
{
	int rc = 0;
	unsigned long flags;
C
Christoph Hellwig 已提交
7146
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7147 7148 7149

	IWL_DEBUG_MAC80211("enter\n");

7150
	mutex_lock(&priv->mutex);
Z
Zhu Yi 已提交
7151 7152
	spin_lock_irqsave(&priv->lock, flags);

C
Christoph Hellwig 已提交
7153
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164
		rc = -EIO;
		IWL_DEBUG_MAC80211("leave - not ready or exit pending\n");
		goto out_unlock;
	}

	if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {	/* APs don't scan */
		rc = -EIO;
		IWL_ERROR("ERROR: APs don't scan\n");
		goto out_unlock;
	}

7165 7166 7167 7168 7169 7170
	/* we don't schedule scan within next_scan_jiffies period */
	if (priv->next_scan_jiffies &&
			time_after(priv->next_scan_jiffies, jiffies)) {
		rc = -EAGAIN;
		goto out_unlock;
	}
Z
Zhu Yi 已提交
7171
	/* if we just finished scan ask for delay */
7172 7173
	if (priv->last_scan_jiffies && time_after(priv->last_scan_jiffies +
				IWL_DELAY_NEXT_SCAN, jiffies)) {
Z
Zhu Yi 已提交
7174 7175 7176 7177
		rc = -EAGAIN;
		goto out_unlock;
	}
	if (len) {
7178
		IWL_DEBUG_SCAN("direct scan for %s [%d]\n ",
C
Christoph Hellwig 已提交
7179
			       iwl3945_escape_essid(ssid, len), (int)len);
Z
Zhu Yi 已提交
7180 7181 7182 7183 7184

		priv->one_direct_scan = 1;
		priv->direct_ssid_len = (u8)
		    min((u8) len, (u8) IW_ESSID_MAX_SIZE);
		memcpy(priv->direct_ssid, ssid, priv->direct_ssid_len);
7185 7186
	} else
		priv->one_direct_scan = 0;
Z
Zhu Yi 已提交
7187

C
Christoph Hellwig 已提交
7188
	rc = iwl3945_scan_initiate(priv);
Z
Zhu Yi 已提交
7189 7190 7191 7192 7193

	IWL_DEBUG_MAC80211("leave\n");

out_unlock:
	spin_unlock_irqrestore(&priv->lock, flags);
7194
	mutex_unlock(&priv->mutex);
Z
Zhu Yi 已提交
7195 7196 7197 7198

	return rc;
}

C
Christoph Hellwig 已提交
7199
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
Z
Zhu Yi 已提交
7200 7201 7202
			   const u8 *local_addr, const u8 *addr,
			   struct ieee80211_key_conf *key)
{
C
Christoph Hellwig 已提交
7203
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7204 7205 7206 7207 7208
	int rc = 0;
	u8 sta_id;

	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7209
	if (!iwl3945_param_hwcrypto) {
Z
Zhu Yi 已提交
7210 7211 7212 7213 7214 7215 7216 7217
		IWL_DEBUG_MAC80211("leave - hwcrypto disabled\n");
		return -EOPNOTSUPP;
	}

	if (is_zero_ether_addr(addr))
		/* only support pairwise keys */
		return -EOPNOTSUPP;

C
Christoph Hellwig 已提交
7218
	sta_id = iwl3945_hw_find_station(priv, addr);
Z
Zhu Yi 已提交
7219
	if (sta_id == IWL_INVALID_STATION) {
7220 7221 7222 7223
		DECLARE_MAC_BUF(mac);

		IWL_DEBUG_MAC80211("leave - %s not in station map.\n",
				   print_mac(mac, addr));
Z
Zhu Yi 已提交
7224 7225 7226 7227 7228
		return -EINVAL;
	}

	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
7229
	iwl3945_scan_cancel_timeout(priv, 100);
7230

Z
Zhu Yi 已提交
7231 7232
	switch (cmd) {
	case  SET_KEY:
C
Christoph Hellwig 已提交
7233
		rc = iwl3945_update_sta_key_info(priv, key, sta_id);
Z
Zhu Yi 已提交
7234
		if (!rc) {
C
Christoph Hellwig 已提交
7235 7236
			iwl3945_set_rxon_hwcrypto(priv, 1);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7237 7238 7239 7240 7241 7242
			key->hw_key_idx = sta_id;
			IWL_DEBUG_MAC80211("set_key success, using hwcrypto\n");
			key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
		}
		break;
	case DISABLE_KEY:
C
Christoph Hellwig 已提交
7243
		rc = iwl3945_clear_sta_key_info(priv, sta_id);
Z
Zhu Yi 已提交
7244
		if (!rc) {
C
Christoph Hellwig 已提交
7245 7246
			iwl3945_set_rxon_hwcrypto(priv, 0);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259
			IWL_DEBUG_MAC80211("disable hwcrypto key\n");
		}
		break;
	default:
		rc = -EINVAL;
	}

	IWL_DEBUG_MAC80211("leave\n");
	mutex_unlock(&priv->mutex);

	return rc;
}

C
Christoph Hellwig 已提交
7260
static int iwl3945_mac_conf_tx(struct ieee80211_hw *hw, int queue,
Z
Zhu Yi 已提交
7261 7262
			   const struct ieee80211_tx_queue_params *params)
{
C
Christoph Hellwig 已提交
7263
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7264 7265 7266 7267 7268
	unsigned long flags;
	int q;

	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7269
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
7270 7271 7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		return -EIO;
	}

	if (queue >= AC_NUM) {
		IWL_DEBUG_MAC80211("leave - queue >= AC_NUM %d\n", queue);
		return 0;
	}

	if (!priv->qos_data.qos_enable) {
		priv->qos_data.qos_active = 0;
		IWL_DEBUG_MAC80211("leave - qos not enabled\n");
		return 0;
	}
	q = AC_NUM - 1 - queue;

	spin_lock_irqsave(&priv->lock, flags);

	priv->qos_data.def_qos_parm.ac[q].cw_min = cpu_to_le16(params->cw_min);
	priv->qos_data.def_qos_parm.ac[q].cw_max = cpu_to_le16(params->cw_max);
	priv->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
	priv->qos_data.def_qos_parm.ac[q].edca_txop =
7292
			cpu_to_le16((params->txop * 32));
Z
Zhu Yi 已提交
7293 7294 7295 7296 7297 7298 7299 7300

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

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
	if (priv->iw_mode == IEEE80211_IF_TYPE_AP)
C
Christoph Hellwig 已提交
7301 7302 7303
		iwl3945_activate_qos(priv, 1);
	else if (priv->assoc_id && iwl3945_is_associated(priv))
		iwl3945_activate_qos(priv, 0);
Z
Zhu Yi 已提交
7304 7305 7306 7307 7308 7309 7310

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");
	return 0;
}

C
Christoph Hellwig 已提交
7311
static int iwl3945_mac_get_tx_stats(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
7312 7313
				struct ieee80211_tx_queue_stats *stats)
{
C
Christoph Hellwig 已提交
7314
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7315
	int i, avail;
C
Christoph Hellwig 已提交
7316 7317
	struct iwl3945_tx_queue *txq;
	struct iwl3945_queue *q;
Z
Zhu Yi 已提交
7318 7319 7320 7321
	unsigned long flags;

	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7322
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
7323 7324 7325 7326 7327 7328 7329 7330 7331
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		return -EIO;
	}

	spin_lock_irqsave(&priv->lock, flags);

	for (i = 0; i < AC_NUM; i++) {
		txq = &priv->txq[i];
		q = &txq->q;
C
Christoph Hellwig 已提交
7332
		avail = iwl3945_queue_space(q);
Z
Zhu Yi 已提交
7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345

		stats->data[i].len = q->n_window - avail;
		stats->data[i].limit = q->n_window - q->high_mark;
		stats->data[i].count = q->n_window;

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

	IWL_DEBUG_MAC80211("leave\n");

	return 0;
}

C
Christoph Hellwig 已提交
7346
static int iwl3945_mac_get_stats(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
7347 7348 7349 7350 7351 7352 7353 7354
			     struct ieee80211_low_level_stats *stats)
{
	IWL_DEBUG_MAC80211("enter\n");
	IWL_DEBUG_MAC80211("leave\n");

	return 0;
}

C
Christoph Hellwig 已提交
7355
static u64 iwl3945_mac_get_tsf(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
7356 7357 7358 7359 7360 7361 7362
{
	IWL_DEBUG_MAC80211("enter\n");
	IWL_DEBUG_MAC80211("leave\n");

	return 0;
}

C
Christoph Hellwig 已提交
7363
static void iwl3945_mac_reset_tsf(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
7364
{
C
Christoph Hellwig 已提交
7365
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7366 7367 7368 7369 7370
	unsigned long flags;

	mutex_lock(&priv->mutex);
	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7371
	iwl3945_reset_qos(priv);
7372

Z
Zhu Yi 已提交
7373 7374 7375 7376 7377 7378 7379 7380 7381 7382 7383 7384 7385 7386 7387 7388 7389 7390 7391 7392 7393
	cancel_delayed_work(&priv->post_associate);

	spin_lock_irqsave(&priv->lock, flags);
	priv->assoc_id = 0;
	priv->assoc_capability = 0;
	priv->call_post_assoc_from_beacon = 0;

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

	priv->ibss_beacon = NULL;

	priv->beacon_int = priv->hw->conf.beacon_int;
	priv->timestamp1 = 0;
	priv->timestamp0 = 0;
	if ((priv->iw_mode == IEEE80211_IF_TYPE_STA))
		priv->beacon_int = 0;

	spin_unlock_irqrestore(&priv->lock, flags);

7394 7395 7396 7397 7398 7399
	if (!iwl3945_is_ready_rf(priv)) {
		IWL_DEBUG_MAC80211("leave - not ready\n");
		mutex_unlock(&priv->mutex);
		return;
	}

7400 7401 7402 7403
	/* we are restarting association process
	 * clear RXON_FILTER_ASSOC_MSK bit
	*/
	if (priv->iw_mode != IEEE80211_IF_TYPE_AP) {
C
Christoph Hellwig 已提交
7404
		iwl3945_scan_cancel_timeout(priv, 100);
7405
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
7406
		iwl3945_commit_rxon(priv);
7407 7408
	}

Z
Zhu Yi 已提交
7409 7410
	/* Per mac80211.h: This is only used in IBSS mode... */
	if (priv->iw_mode != IEEE80211_IF_TYPE_IBSS) {
7411

Z
Zhu Yi 已提交
7412 7413 7414 7415 7416 7417 7418
		IWL_DEBUG_MAC80211("leave - not in IBSS\n");
		mutex_unlock(&priv->mutex);
		return;
	}

	priv->only_active_channel = 0;

C
Christoph Hellwig 已提交
7419
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
7420 7421 7422 7423 7424 7425 7426

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");

}

C
Christoph Hellwig 已提交
7427
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb,
Z
Zhu Yi 已提交
7428 7429
				 struct ieee80211_tx_control *control)
{
C
Christoph Hellwig 已提交
7430
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7431 7432 7433 7434 7435
	unsigned long flags;

	mutex_lock(&priv->mutex);
	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7436
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		mutex_unlock(&priv->mutex);
		return -EIO;
	}

	if (priv->iw_mode != IEEE80211_IF_TYPE_IBSS) {
		IWL_DEBUG_MAC80211("leave - not IBSS\n");
		mutex_unlock(&priv->mutex);
		return -EIO;
	}

	spin_lock_irqsave(&priv->lock, flags);

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

	priv->ibss_beacon = skb;

	priv->assoc_id = 0;

	IWL_DEBUG_MAC80211("leave\n");
	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
7460
	iwl3945_reset_qos(priv);
Z
Zhu Yi 已提交
7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474

	queue_work(priv->workqueue, &priv->post_associate.work);

	mutex_unlock(&priv->mutex);

	return 0;
}

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

7475
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486

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

static ssize_t show_debug_level(struct device_driver *d, char *buf)
{
C
Christoph Hellwig 已提交
7487
	return sprintf(buf, "0x%08X\n", iwl3945_debug_level);
Z
Zhu Yi 已提交
7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499
}
static ssize_t store_debug_level(struct device_driver *d,
				 const char *buf, size_t count)
{
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 0);
	if (p == buf)
		printk(KERN_INFO DRV_NAME
		       ": %s is not in hex or decimal form.\n", buf);
	else
C
Christoph Hellwig 已提交
7500
		iwl3945_debug_level = val;
Z
Zhu Yi 已提交
7501 7502 7503 7504 7505 7506 7507

	return strnlen(buf, count);
}

static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
		   show_debug_level, store_debug_level);

7508
#endif /* CONFIG_IWL3945_DEBUG */
Z
Zhu Yi 已提交
7509 7510 7511 7512 7513 7514 7515 7516 7517 7518

static ssize_t show_rf_kill(struct device *d,
			    struct device_attribute *attr, char *buf)
{
	/*
	 * 0 - RF kill not enabled
	 * 1 - SW based RF kill active (sysfs)
	 * 2 - HW based RF kill active
	 * 3 - Both HW and SW based RF kill active
	 */
C
Christoph Hellwig 已提交
7519
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7520 7521 7522 7523 7524 7525 7526 7527 7528 7529
	int val = (test_bit(STATUS_RF_KILL_SW, &priv->status) ? 0x1 : 0x0) |
		  (test_bit(STATUS_RF_KILL_HW, &priv->status) ? 0x2 : 0x0);

	return sprintf(buf, "%i\n", val);
}

static ssize_t store_rf_kill(struct device *d,
			     struct device_attribute *attr,
			     const char *buf, size_t count)
{
C
Christoph Hellwig 已提交
7530
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7531 7532

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
7533
	iwl3945_radio_kill_sw(priv, buf[0] == '1');
Z
Zhu Yi 已提交
7534 7535 7536 7537 7538 7539 7540 7541 7542 7543
	mutex_unlock(&priv->mutex);

	return count;
}

static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);

static ssize_t show_temperature(struct device *d,
				struct device_attribute *attr, char *buf)
{
C
Christoph Hellwig 已提交
7544
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7545

C
Christoph Hellwig 已提交
7546
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7547 7548
		return -EAGAIN;

C
Christoph Hellwig 已提交
7549
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
7550 7551 7552 7553 7554 7555 7556 7557
}

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

static ssize_t show_rs_window(struct device *d,
			      struct device_attribute *attr,
			      char *buf)
{
C
Christoph Hellwig 已提交
7558 7559
	struct iwl3945_priv *priv = d->driver_data;
	return iwl3945_fill_rs_info(priv->hw, buf, IWL_AP_ID);
Z
Zhu Yi 已提交
7560 7561 7562 7563 7564 7565
}
static DEVICE_ATTR(rs_window, S_IRUGO, show_rs_window, NULL);

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
C
Christoph Hellwig 已提交
7566
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7567 7568 7569 7570 7571 7572 7573
	return sprintf(buf, "%d\n", priv->user_txpower_limit);
}

static ssize_t store_tx_power(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
C
Christoph Hellwig 已提交
7574
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7575 7576 7577 7578 7579 7580 7581 7582
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
		printk(KERN_INFO DRV_NAME
		       ": %s is not in decimal form.\n", buf);
	else
C
Christoph Hellwig 已提交
7583
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
7584 7585 7586 7587 7588 7589 7590 7591 7592

	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)
{
C
Christoph Hellwig 已提交
7593
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7594 7595 7596 7597 7598 7599 7600 7601

	return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
}

static ssize_t store_flags(struct device *d,
			   struct device_attribute *attr,
			   const char *buf, size_t count)
{
C
Christoph Hellwig 已提交
7602
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7603 7604 7605 7606 7607
	u32 flags = simple_strtoul(buf, NULL, 0);

	mutex_lock(&priv->mutex);
	if (le32_to_cpu(priv->staging_rxon.flags) != flags) {
		/* Cancel any currently running scans... */
C
Christoph Hellwig 已提交
7608
		if (iwl3945_scan_cancel_timeout(priv, 100))
Z
Zhu Yi 已提交
7609 7610 7611 7612 7613
			IWL_WARNING("Could not cancel scan.\n");
		else {
			IWL_DEBUG_INFO("Committing rxon.flags = 0x%04X\n",
				       flags);
			priv->staging_rxon.flags = cpu_to_le32(flags);
C
Christoph Hellwig 已提交
7614
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626
		}
	}
	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)
{
C
Christoph Hellwig 已提交
7627
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7628 7629 7630 7631 7632 7633 7634 7635 7636

	return sprintf(buf, "0x%04X\n",
		le32_to_cpu(priv->active_rxon.filter_flags));
}

static ssize_t store_filter_flags(struct device *d,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
{
C
Christoph Hellwig 已提交
7637
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7638 7639 7640 7641 7642
	u32 filter_flags = simple_strtoul(buf, NULL, 0);

	mutex_lock(&priv->mutex);
	if (le32_to_cpu(priv->staging_rxon.filter_flags) != filter_flags) {
		/* Cancel any currently running scans... */
C
Christoph Hellwig 已提交
7643
		if (iwl3945_scan_cancel_timeout(priv, 100))
Z
Zhu Yi 已提交
7644 7645 7646 7647 7648 7649
			IWL_WARNING("Could not cancel scan.\n");
		else {
			IWL_DEBUG_INFO("Committing rxon.filter_flags = "
				       "0x%04X\n", filter_flags);
			priv->staging_rxon.filter_flags =
				cpu_to_le32(filter_flags);
C
Christoph Hellwig 已提交
7650
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7651 7652 7653 7654 7655 7656 7657 7658 7659 7660
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

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

7661
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
7662 7663 7664 7665

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
C
Christoph Hellwig 已提交
7666 7667
	struct iwl3945_priv *priv = dev_get_drvdata(d);
	struct iwl3945_spectrum_notification measure_report;
Z
Zhu Yi 已提交
7668 7669 7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696 7697 7698
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
	u8 *data = (u8 *) & measure_report;
	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)
{
C
Christoph Hellwig 已提交
7699
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7700 7701 7702 7703 7704 7705 7706 7707 7708 7709 7710 7711 7712 7713 7714 7715 7716 7717 7718 7719 7720 7721 7722 7723 7724
	struct ieee80211_measurement_params params = {
		.channel = le16_to_cpu(priv->active_rxon.channel),
		.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);
	}

	IWL_DEBUG_INFO("Invoking measurement of type %d on "
		       "channel %d (for '%s')\n", type, params.channel, buf);
C
Christoph Hellwig 已提交
7725
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
7726 7727 7728 7729 7730 7731

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
7732
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
7733 7734 7735 7736 7737

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
C
Christoph Hellwig 已提交
7738
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7739 7740 7741 7742 7743 7744 7745 7746 7747 7748 7749

	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)
{
C
Christoph Hellwig 已提交
7750
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7751 7752 7753 7754 7755 7756 7757 7758 7759 7760
	return sprintf(buf, "%d", priv->retry_rate);
}

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

static ssize_t store_power_level(struct device *d,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
C
Christoph Hellwig 已提交
7761
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7762 7763 7764 7765 7766 7767
	int rc;
	int mode;

	mode = simple_strtoul(buf, NULL, 0);
	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
7768
	if (!iwl3945_is_ready(priv)) {
Z
Zhu Yi 已提交
7769 7770 7771 7772 7773 7774 7775 7776 7777 7778
		rc = -EAGAIN;
		goto out;
	}

	if ((mode < 1) || (mode > IWL_POWER_LIMIT) || (mode == IWL_POWER_AC))
		mode = IWL_POWER_AC;
	else
		mode |= IWL_POWER_ENABLED;

	if (mode != priv->power_mode) {
C
Christoph Hellwig 已提交
7779
		rc = iwl3945_send_power_mode(priv, IWL_POWER_LEVEL(mode));
Z
Zhu Yi 已提交
7780 7781 7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792 7793 7794 7795 7796 7797 7798 7799 7800 7801 7802 7803 7804 7805 7806 7807 7808 7809 7810 7811 7812 7813 7814
		if (rc) {
			IWL_DEBUG_MAC80211("failed setting power mode.\n");
			goto out;
		}
		priv->power_mode = mode;
	}

	rc = count;

 out:
	mutex_unlock(&priv->mutex);
	return rc;
}

#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_power_level(struct device *d,
				struct device_attribute *attr, char *buf)
{
C
Christoph Hellwig 已提交
7815
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7816 7817 7818 7819 7820 7821 7822 7823 7824 7825 7826 7827 7828 7829 7830 7831 7832 7833 7834 7835 7836 7837 7838 7839 7840 7841 7842 7843 7844 7845 7846 7847 7848 7849
	int level = IWL_POWER_LEVEL(priv->power_mode);
	char *p = buf;

	p += sprintf(p, "%d ", level);
	switch (level) {
	case IWL_POWER_MODE_CAM:
	case IWL_POWER_AC:
		p += sprintf(p, "(AC)");
		break;
	case IWL_POWER_BATTERY:
		p += sprintf(p, "(BATTERY)");
		break;
	default:
		p += sprintf(p,
			     "(Timeout %dms, Period %dms)",
			     timeout_duration[level - 1] / 1000,
			     period_duration[level - 1] / 1000);
	}

	if (!(priv->power_mode & IWL_POWER_ENABLED))
		p += sprintf(p, " OFF\n");
	else
		p += sprintf(p, " \n");

	return (p - buf + 1);

}

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

static ssize_t show_channels(struct device *d,
			     struct device_attribute *attr, char *buf)
{
7850 7851
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
7852 7853 7854 7855 7856 7857 7858
}

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
C
Christoph Hellwig 已提交
7859 7860
	struct iwl3945_priv *priv = dev_get_drvdata(d);
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
7861 7862 7863 7864
	u32 len = 0, ofs = 0;
	u8 *data = (u8 *) & priv->statistics;
	int rc = 0;

C
Christoph Hellwig 已提交
7865
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7866 7867 7868
		return -EAGAIN;

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
7869
	rc = iwl3945_send_statistics_request(priv);
Z
Zhu Yi 已提交
7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896
	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)
{
C
Christoph Hellwig 已提交
7897
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7898

C
Christoph Hellwig 已提交
7899
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7900 7901 7902 7903 7904 7905 7906 7907 7908 7909
		return -EAGAIN;

	return sprintf(buf, "%d\n", priv->antenna);
}

static ssize_t store_antenna(struct device *d,
			     struct device_attribute *attr,
			     const char *buf, size_t count)
{
	int ant;
C
Christoph Hellwig 已提交
7910
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921

	if (count == 0)
		return 0;

	if (sscanf(buf, "%1i", &ant) != 1) {
		IWL_DEBUG_INFO("not in hex or decimal form.\n");
		return count;
	}

	if ((ant >= 0) && (ant <= 2)) {
		IWL_DEBUG_INFO("Setting antenna select to %d.\n", ant);
C
Christoph Hellwig 已提交
7922
		priv->antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
7923 7924 7925 7926 7927 7928 7929 7930 7931 7932 7933 7934
	} else
		IWL_DEBUG_INFO("Bad antenna select value %d.\n", ant);


	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)
{
C
Christoph Hellwig 已提交
7935 7936
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7937 7938 7939 7940 7941 7942 7943 7944 7945 7946 7947 7948 7949
		return -EAGAIN;
	return sprintf(buf, "0x%08x\n", (int)priv->status);
}

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

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

	if (p[0] == '1')
C
Christoph Hellwig 已提交
7950
		iwl3945_dump_nic_error_log((struct iwl3945_priv *)d->driver_data);
Z
Zhu Yi 已提交
7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963

	return strnlen(buf, count);
}

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

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

	if (p[0] == '1')
C
Christoph Hellwig 已提交
7964
		iwl3945_dump_nic_event_log((struct iwl3945_priv *)d->driver_data);
Z
Zhu Yi 已提交
7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
 * driver setup and teardown
 *
 *****************************************************************************/

C
Christoph Hellwig 已提交
7977
static void iwl3945_setup_deferred_work(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
7978 7979 7980 7981 7982
{
	priv->workqueue = create_workqueue(DRV_NAME);

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
7983 7984 7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996
	INIT_WORK(&priv->up, iwl3945_bg_up);
	INIT_WORK(&priv->restart, iwl3945_bg_restart);
	INIT_WORK(&priv->rx_replenish, iwl3945_bg_rx_replenish);
	INIT_WORK(&priv->scan_completed, iwl3945_bg_scan_completed);
	INIT_WORK(&priv->request_scan, iwl3945_bg_request_scan);
	INIT_WORK(&priv->abort_scan, iwl3945_bg_abort_scan);
	INIT_WORK(&priv->rf_kill, iwl3945_bg_rf_kill);
	INIT_WORK(&priv->beacon_update, iwl3945_bg_beacon_update);
	INIT_DELAYED_WORK(&priv->post_associate, iwl3945_bg_post_associate);
	INIT_DELAYED_WORK(&priv->init_alive_start, iwl3945_bg_init_alive_start);
	INIT_DELAYED_WORK(&priv->alive_start, iwl3945_bg_alive_start);
	INIT_DELAYED_WORK(&priv->scan_check, iwl3945_bg_scan_check);

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
7997 7998

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

C
Christoph Hellwig 已提交
8002
static void iwl3945_cancel_deferred_work(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
8003
{
C
Christoph Hellwig 已提交
8004
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
8005

8006
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
8007 8008 8009 8010 8011 8012
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_delayed_work(&priv->post_associate);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
8013
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
8014 8015 8016 8017 8018 8019
	&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,
8020
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034
	&dev_attr_measurement.attr,
#endif
	&dev_attr_power_level.attr,
	&dev_attr_retry_rate.attr,
	&dev_attr_rf_kill.attr,
	&dev_attr_rs_window.attr,
	&dev_attr_statistics.attr,
	&dev_attr_status.attr,
	&dev_attr_temperature.attr,
	&dev_attr_tx_power.attr,

	NULL
};

C
Christoph Hellwig 已提交
8035
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
8036
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
8037
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
8038 8039
};

C
Christoph Hellwig 已提交
8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050 8051 8052 8053 8054 8055 8056
static struct ieee80211_ops iwl3945_hw_ops = {
	.tx = iwl3945_mac_tx,
	.start = iwl3945_mac_start,
	.stop = iwl3945_mac_stop,
	.add_interface = iwl3945_mac_add_interface,
	.remove_interface = iwl3945_mac_remove_interface,
	.config = iwl3945_mac_config,
	.config_interface = iwl3945_mac_config_interface,
	.configure_filter = iwl3945_configure_filter,
	.set_key = iwl3945_mac_set_key,
	.get_stats = iwl3945_mac_get_stats,
	.get_tx_stats = iwl3945_mac_get_tx_stats,
	.conf_tx = iwl3945_mac_conf_tx,
	.get_tsf = iwl3945_mac_get_tsf,
	.reset_tsf = iwl3945_mac_reset_tsf,
	.beacon_update = iwl3945_mac_beacon_update,
	.hw_scan = iwl3945_mac_hw_scan
Z
Zhu Yi 已提交
8057 8058
};

C
Christoph Hellwig 已提交
8059
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
8060 8061
{
	int err = 0;
C
Christoph Hellwig 已提交
8062
	struct iwl3945_priv *priv;
Z
Zhu Yi 已提交
8063
	struct ieee80211_hw *hw;
T
Tomas Winkler 已提交
8064
	struct iwl_3945_cfg *cfg = (struct iwl_3945_cfg *)(ent->driver_data);
Z
Zhu Yi 已提交
8065
	int i;
8066
	DECLARE_MAC_BUF(mac);
Z
Zhu Yi 已提交
8067

8068 8069
	/* Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan. */
C
Christoph Hellwig 已提交
8070
	if (iwl3945_param_disable_hw_scan) {
Z
Zhu Yi 已提交
8071
		IWL_DEBUG_INFO("Disabling hw_scan\n");
C
Christoph Hellwig 已提交
8072
		iwl3945_hw_ops.hw_scan = NULL;
Z
Zhu Yi 已提交
8073 8074
	}

C
Christoph Hellwig 已提交
8075 8076
	if ((iwl3945_param_queues_num > IWL_MAX_NUM_QUEUES) ||
	    (iwl3945_param_queues_num < IWL_MIN_NUM_QUEUES)) {
Z
Zhu Yi 已提交
8077 8078 8079 8080 8081 8082 8083 8084
		IWL_ERROR("invalid queues_num, should be between %d and %d\n",
			  IWL_MIN_NUM_QUEUES, IWL_MAX_NUM_QUEUES);
		err = -EINVAL;
		goto out;
	}

	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
C
Christoph Hellwig 已提交
8085
	hw = ieee80211_alloc_hw(sizeof(struct iwl3945_priv), &iwl3945_hw_ops);
Z
Zhu Yi 已提交
8086 8087 8088 8089 8090 8091 8092
	if (hw == NULL) {
		IWL_ERROR("Can not allocate network device\n");
		err = -ENOMEM;
		goto out;
	}
	SET_IEEE80211_DEV(hw, &pdev->dev);

8093 8094
	hw->rate_control_algorithm = "iwl-3945-rs";

Z
Zhu Yi 已提交
8095 8096 8097 8098 8099
	IWL_DEBUG_INFO("*** LOAD DRIVER ***\n");
	priv = hw->priv;
	priv->hw = hw;

	priv->pci_dev = pdev;
T
Tomas Winkler 已提交
8100
	priv->cfg = cfg;
8101 8102

	/* Select antenna (may be helpful if only one antenna is connected) */
C
Christoph Hellwig 已提交
8103
	priv->antenna = (enum iwl3945_antenna)iwl3945_param_antenna;
8104
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
8105
	iwl3945_debug_level = iwl3945_param_debug;
Z
Zhu Yi 已提交
8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123
	atomic_set(&priv->restrict_refcnt, 0);
#endif
	priv->retry_rate = 1;

	priv->ibss_beacon = NULL;

	/* Tell mac80211 and its clients (e.g. Wireless Extensions)
	 *   the range of signal quality values that we'll provide.
	 * Negative values for level/noise indicate that we'll provide dBm.
	 * For WE, at least, non-0 values here *enable* display of values
	 *   in app (iwconfig). */
	hw->max_rssi = -20;	/* signal level, negative indicates dBm */
	hw->max_noise = -20;	/* noise level, negative indicates dBm */
	hw->max_signal = 100;	/* link quality indication (%) */

	/* Tell mac80211 our Tx characteristics */
	hw->flags = IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE;

8124
	/* 4 EDCA QOS priorities */
Z
Zhu Yi 已提交
8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144
	hw->queues = 4;

	spin_lock_init(&priv->lock);
	spin_lock_init(&priv->power_data.lock);
	spin_lock_init(&priv->sta_lock);
	spin_lock_init(&priv->hcmd_lock);

	for (i = 0; i < IWL_IBSS_MAC_HASH_SIZE; i++)
		INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);

	INIT_LIST_HEAD(&priv->free_frames);

	mutex_init(&priv->mutex);
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

8145
	/* Clear the driver's (not device's) station table */
C
Christoph Hellwig 已提交
8146
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
8147 8148 8149 8150

	priv->data_retry_limit = -1;
	priv->ieee_channels = NULL;
	priv->ieee_rates = NULL;
8151
	priv->band = IEEE80211_BAND_2GHZ;
Z
Zhu Yi 已提交
8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164

	err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
	if (!err)
		err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
	if (err) {
		printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
		goto out_pci_disable_device;
	}

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

Z
Zhu Yi 已提交
8166 8167 8168
	/* 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);
8169

Z
Zhu Yi 已提交
8170 8171 8172 8173 8174 8175 8176 8177 8178 8179 8180 8181
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

	IWL_DEBUG_INFO("pci_resource_len = 0x%08llx\n",
			(unsigned long long) pci_resource_len(pdev, 0));
	IWL_DEBUG_INFO("pci_resource_base = %p\n", priv->hw_base);

	/* Initialize module parameter values here */

8182
	/* Disable radio (SW RF KILL) via parameter when loading driver */
C
Christoph Hellwig 已提交
8183
	if (iwl3945_param_disable) {
Z
Zhu Yi 已提交
8184 8185 8186 8187 8188 8189 8190
		set_bit(STATUS_RF_KILL_SW, &priv->status);
		IWL_DEBUG_INFO("Radio disabled.\n");
	}

	priv->iw_mode = IEEE80211_IF_TYPE_STA;

	printk(KERN_INFO DRV_NAME
T
Tomas Winkler 已提交
8191
		": Detected Intel Wireless WiFi Link %s\n", priv->cfg->name);
Z
Zhu Yi 已提交
8192 8193

	/* Device-specific setup */
C
Christoph Hellwig 已提交
8194
	if (iwl3945_hw_set_hw_setting(priv)) {
Z
Zhu Yi 已提交
8195 8196 8197 8198
		IWL_ERROR("failed to set hw settings\n");
		goto out_iounmap;
	}

C
Christoph Hellwig 已提交
8199
	if (iwl3945_param_qos_enable)
Z
Zhu Yi 已提交
8200 8201
		priv->qos_data.qos_enable = 1;

C
Christoph Hellwig 已提交
8202
	iwl3945_reset_qos(priv);
Z
Zhu Yi 已提交
8203 8204 8205 8206

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

8207
	iwl3945_set_rxon_channel(priv, IEEE80211_BAND_2GHZ, 6);
C
Christoph Hellwig 已提交
8208 8209
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);
Z
Zhu Yi 已提交
8210 8211 8212 8213 8214 8215

	priv->rates_mask = IWL_RATES_MASK;
	/* If power management is turned on, default to AC mode */
	priv->power_mode = IWL_POWER_AC;
	priv->user_txpower_limit = IWL_DEFAULT_TX_POWER;

C
Christoph Hellwig 已提交
8216
	iwl3945_disable_interrupts(priv);
8217

C
Christoph Hellwig 已提交
8218
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
8219 8220 8221 8222 8223
	if (err) {
		IWL_ERROR("failed to create sysfs device attributes\n");
		goto out_release_irq;
	}

8224 8225 8226 8227 8228 8229 8230 8231 8232 8233 8234 8235 8236 8237
	/* nic init */
	iwl3945_set_bit(priv, CSR_GIO_CHICKEN_BITS,
                    CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);

        iwl3945_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
        err = iwl3945_poll_bit(priv, CSR_GP_CNTRL,
                          CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY,
                          CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
        if (err < 0) {
                IWL_DEBUG_INFO("Failed to init the card\n");
		goto out_remove_sysfs;
        }
	/* Read the EEPROM */
	err = iwl3945_eeprom_init(priv);
Z
Zhu Yi 已提交
8238
	if (err) {
8239 8240
		IWL_ERROR("Unable to init EEPROM\n");
		goto out_remove_sysfs;
Z
Zhu Yi 已提交
8241
	}
8242 8243 8244 8245
	/* MAC Address location in EEPROM same for 3945/4965 */
	get_eeprom_mac(priv, priv->mac_addr);
	IWL_DEBUG_INFO("MAC address: %s\n", print_mac(mac, priv->mac_addr));
	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
Z
Zhu Yi 已提交
8246

8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258
	err = iwl3945_init_channel_map(priv);
	if (err) {
		IWL_ERROR("initializing regulatory failed: %d\n", err);
		goto out_remove_sysfs;
	}

	err = iwl3945_init_geos(priv);
	if (err) {
		IWL_ERROR("initializing geos failed: %d\n", err);
		goto out_free_channel_map;
	}

8259 8260 8261 8262
	iwl3945_rate_control_register(priv->hw);
	err = ieee80211_register_hw(priv->hw);
	if (err) {
		IWL_ERROR("Failed to register network device (error %d)\n", err);
8263
		goto out_free_geos;
8264
	}
Z
Zhu Yi 已提交
8265

8266 8267 8268 8269
	priv->hw->conf.beacon_int = 100;
	priv->mac80211_registered = 1;
	pci_save_state(pdev);
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
8270 8271 8272

	return 0;

8273 8274 8275 8276
 out_free_geos:
	iwl3945_free_geos(priv);
 out_free_channel_map:
	iwl3945_free_channel_map(priv);
8277
 out_remove_sysfs:
C
Christoph Hellwig 已提交
8278
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
8279 8280 8281 8282

 out_release_irq:
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
C
Christoph Hellwig 已提交
8283
	iwl3945_unset_hw_setting(priv);
Z
Zhu Yi 已提交
8284 8285 8286 8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297

 out_iounmap:
	pci_iounmap(pdev, priv->hw_base);
 out_pci_release_regions:
	pci_release_regions(pdev);
 out_pci_disable_device:
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);
 out_ieee80211_free_hw:
	ieee80211_free_hw(priv->hw);
 out:
	return err;
}

C
Christoph Hellwig 已提交
8298
static void iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
8299
{
C
Christoph Hellwig 已提交
8300
	struct iwl3945_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
8301 8302 8303 8304 8305 8306 8307 8308 8309
	struct list_head *p, *q;
	int i;

	if (!priv)
		return;

	IWL_DEBUG_INFO("*** UNLOAD DRIVER ***\n");

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

C
Christoph Hellwig 已提交
8311
	iwl3945_down(priv);
Z
Zhu Yi 已提交
8312 8313 8314 8315 8316

	/* Free MAC hash list for ADHOC */
	for (i = 0; i < IWL_IBSS_MAC_HASH_SIZE; i++) {
		list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
			list_del(p);
C
Christoph Hellwig 已提交
8317
			kfree(list_entry(p, struct iwl3945_ibss_seq, list));
Z
Zhu Yi 已提交
8318 8319 8320
		}
	}

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

C
Christoph Hellwig 已提交
8323
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
8324 8325

	if (priv->rxq.bd)
C
Christoph Hellwig 已提交
8326 8327
		iwl3945_rx_queue_free(priv, &priv->rxq);
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
8328

C
Christoph Hellwig 已提交
8329 8330
	iwl3945_unset_hw_setting(priv);
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
8331 8332 8333

	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
C
Christoph Hellwig 已提交
8334
		iwl3945_rate_control_unregister(priv->hw);
Z
Zhu Yi 已提交
8335 8336
	}

8337 8338 8339
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
8340
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
8341 8342 8343 8344 8345 8346 8347 8348 8349 8350
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;

	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

8351 8352
	iwl3945_free_channel_map(priv);
	iwl3945_free_geos(priv);
Z
Zhu Yi 已提交
8353 8354 8355 8356 8357 8358 8359 8360 8361

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

	ieee80211_free_hw(priv->hw);
}

#ifdef CONFIG_PM

C
Christoph Hellwig 已提交
8362
static int iwl3945_pci_suspend(struct pci_dev *pdev, pm_message_t state)
Z
Zhu Yi 已提交
8363
{
C
Christoph Hellwig 已提交
8364
	struct iwl3945_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
8365

8366 8367 8368 8369 8370
	if (priv->is_open) {
		set_bit(STATUS_IN_SUSPEND, &priv->status);
		iwl3945_mac_stop(priv->hw);
		priv->is_open = 1;
	}
Z
Zhu Yi 已提交
8371 8372 8373 8374 8375 8376

	pci_set_power_state(pdev, PCI_D3hot);

	return 0;
}

C
Christoph Hellwig 已提交
8377
static int iwl3945_pci_resume(struct pci_dev *pdev)
Z
Zhu Yi 已提交
8378
{
C
Christoph Hellwig 已提交
8379
	struct iwl3945_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
8380 8381 8382

	pci_set_power_state(pdev, PCI_D0);

8383 8384
	if (priv->is_open)
		iwl3945_mac_start(priv->hw);
Z
Zhu Yi 已提交
8385

8386
	clear_bit(STATUS_IN_SUSPEND, &priv->status);
Z
Zhu Yi 已提交
8387 8388 8389 8390 8391 8392 8393 8394 8395 8396 8397
	return 0;
}

#endif /* CONFIG_PM */

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

C
Christoph Hellwig 已提交
8398
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
8399
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
8400 8401 8402
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
8403
#ifdef CONFIG_PM
C
Christoph Hellwig 已提交
8404 8405
	.suspend = iwl3945_pci_suspend,
	.resume = iwl3945_pci_resume,
Z
Zhu Yi 已提交
8406 8407 8408
#endif
};

C
Christoph Hellwig 已提交
8409
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
8410 8411 8412 8413 8414
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
C
Christoph Hellwig 已提交
8415
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
8416 8417 8418 8419
	if (ret) {
		IWL_ERROR("Unable to initialize PCI module\n");
		return ret;
	}
8420
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
8421
	ret = driver_create_file(&iwl3945_driver.driver, &driver_attr_debug_level);
Z
Zhu Yi 已提交
8422 8423
	if (ret) {
		IWL_ERROR("Unable to create driver sysfs file\n");
C
Christoph Hellwig 已提交
8424
		pci_unregister_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
8425 8426 8427 8428 8429 8430 8431
		return ret;
	}
#endif

	return ret;
}

C
Christoph Hellwig 已提交
8432
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
8433
{
8434
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
8435
	driver_remove_file(&iwl3945_driver.driver, &driver_attr_debug_level);
Z
Zhu Yi 已提交
8436
#endif
C
Christoph Hellwig 已提交
8437
	pci_unregister_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
8438 8439
}

C
Christoph Hellwig 已提交
8440
module_param_named(antenna, iwl3945_param_antenna, int, 0444);
Z
Zhu Yi 已提交
8441
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
C
Christoph Hellwig 已提交
8442
module_param_named(disable, iwl3945_param_disable, int, 0444);
Z
Zhu Yi 已提交
8443
MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
C
Christoph Hellwig 已提交
8444
module_param_named(hwcrypto, iwl3945_param_hwcrypto, int, 0444);
Z
Zhu Yi 已提交
8445 8446
MODULE_PARM_DESC(hwcrypto,
		 "using hardware crypto engine (default 0 [software])\n");
C
Christoph Hellwig 已提交
8447
module_param_named(debug, iwl3945_param_debug, int, 0444);
Z
Zhu Yi 已提交
8448
MODULE_PARM_DESC(debug, "debug output mask");
C
Christoph Hellwig 已提交
8449
module_param_named(disable_hw_scan, iwl3945_param_disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
8450 8451
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

C
Christoph Hellwig 已提交
8452
module_param_named(queues_num, iwl3945_param_queues_num, int, 0444);
Z
Zhu Yi 已提交
8453 8454 8455
MODULE_PARM_DESC(queues_num, "number of hw queues.");

/* QoS */
C
Christoph Hellwig 已提交
8456
module_param_named(qos_enable, iwl3945_param_qos_enable, int, 0444);
Z
Zhu Yi 已提交
8457 8458
MODULE_PARM_DESC(qos_enable, "enable all QoS functionality");

C
Christoph Hellwig 已提交
8459 8460
module_exit(iwl3945_exit);
module_init(iwl3945_init);