iwl3945-base.c 234.1 KB
Newer Older
Z
Zhu Yi 已提交
1 2
/******************************************************************************
 *
R
Reinette Chatre 已提交
3
 * Copyright(c) 2003 - 2008 Intel Corporation. All rights reserved.
Z
Zhu Yi 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
 *
 * 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/init.h>
#include <linux/pci.h>
#include <linux/dma-mapping.h>
#include <linux/delay.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/wireless.h>
#include <linux/firmware.h>
#include <linux/etherdevice.h>
#include <linux/if_arp.h>

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

#include <asm/div64.h>

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
int iwl3945_param_hwcrypto;        /* def: 0 = use software encryption */
static int iwl3945_param_qos_enable = 1; /* def: 1 = use quality of service */
73
int iwl3945_param_queues_num = IWL39_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
R
Reinette Chatre 已提交
96
#define DRV_COPYRIGHT	"Copyright(c) 2003-2008 Intel Corporation"
Z
Zhu Yi 已提交
97 98 99 100 101 102 103 104
#define DRV_VERSION     IWLWIFI_VERSION


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

105 106
static const struct ieee80211_supported_band *iwl3945_get_band(
		struct iwl3945_priv *priv, enum ieee80211_band band)
Z
Zhu Yi 已提交
107
{
108
	return priv->hw->wiphy->bands[band];
Z
Zhu Yi 已提交
109 110 111 112 113 114 115
}

/*************** DMA-QUEUE-GENERAL-FUNCTIONS  *****
 * DMA services
 *
 * Theory of operation
 *
116 117 118 119 120 121 122 123 124
 * 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 已提交
125 126 127 128 129 130
 *
 * 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.
 *
131 132 133
 * 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 已提交
134 135
 ***************************************************/

T
Tomas Winkler 已提交
136
int iwl3945_queue_space(const struct iwl3945_queue *q)
Z
Zhu Yi 已提交
137
{
138
	int s = q->read_ptr - q->write_ptr;
Z
Zhu Yi 已提交
139

140
	if (q->read_ptr > q->write_ptr)
Z
Zhu Yi 已提交
141 142 143 144 145 146 147 148 149 150 151
		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;
}

T
Tomas Winkler 已提交
152
int iwl3945_x2_queue_used(const struct iwl3945_queue *q, int i)
Z
Zhu Yi 已提交
153
{
154 155 156
	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 已提交
157 158
}

T
Tomas Winkler 已提交
159

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

166
	/* Otherwise, use normal size buffers */
Z
Zhu Yi 已提交
167 168 169
	return index & (q->n_window - 1);
}

170 171 172
/**
 * iwl3945_queue_init - Initialize queue's high/low-water and read/write indexes
 */
C
Christoph Hellwig 已提交
173
static int iwl3945_queue_init(struct iwl3945_priv *priv, struct iwl3945_queue *q,
Z
Zhu Yi 已提交
174 175 176 177 178 179
			  int count, int slots_num, u32 id)
{
	q->n_bd = count;
	q->n_window = slots_num;
	q->id = id;

T
Tomas Winkler 已提交
180 181
	/* count must be power-of-two size, otherwise iwl_queue_inc_wrap
	 * and iwl_queue_dec_wrap are broken. */
Z
Zhu Yi 已提交
182 183 184 185 186 187 188 189 190 191 192 193 194 195
	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;

196
	q->write_ptr = q->read_ptr = 0;
Z
Zhu Yi 已提交
197 198 199 200

	return 0;
}

201 202 203
/**
 * iwl3945_tx_queue_alloc - Alloc driver data and TFD CB for one Tx/cmd queue
 */
C
Christoph Hellwig 已提交
204 205
static int iwl3945_tx_queue_alloc(struct iwl3945_priv *priv,
			      struct iwl3945_tx_queue *txq, u32 id)
Z
Zhu Yi 已提交
206 207 208
{
	struct pci_dev *dev = priv->pci_dev;

209 210
	/* Driver private data, only for Tx (not command) queues,
	 * not shared with device. */
Z
Zhu Yi 已提交
211 212 213 214
	if (id != IWL_CMD_QUEUE_NUM) {
		txq->txb = kmalloc(sizeof(txq->txb[0]) *
				   TFD_QUEUE_SIZE_MAX, GFP_KERNEL);
		if (!txq->txb) {
215
			IWL_ERROR("kmalloc for auxiliary BD "
Z
Zhu Yi 已提交
216 217 218 219 220 221
				  "structures failed\n");
			goto error;
		}
	} else
		txq->txb = NULL;

222 223
	/* Circular buffer of transmit frame descriptors (TFDs),
	 * shared with device */
Z
Zhu Yi 已提交
224 225 226 227 228 229 230 231 232 233 234 235 236 237
	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:
238 239
	kfree(txq->txb);
	txq->txb = NULL;
Z
Zhu Yi 已提交
240 241 242 243

	return -ENOMEM;
}

244 245 246
/**
 * iwl3945_tx_queue_init - Allocate and initialize one tx/cmd queue
 */
C
Christoph Hellwig 已提交
247 248
int iwl3945_tx_queue_init(struct iwl3945_priv *priv,
		      struct iwl3945_tx_queue *txq, int slots_num, u32 txq_id)
Z
Zhu Yi 已提交
249 250 251 252 253
{
	struct pci_dev *dev = priv->pci_dev;
	int len;
	int rc = 0;

254 255 256 257 258 259 260 261
	/*
	 * 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 已提交
262
	len = sizeof(struct iwl3945_cmd) * slots_num;
Z
Zhu Yi 已提交
263 264 265 266 267 268
	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;

269
	/* Alloc driver data array and TFD circular buffer */
C
Christoph Hellwig 已提交
270
	rc = iwl3945_tx_queue_alloc(priv, txq, txq_id);
Z
Zhu Yi 已提交
271 272 273 274 275 276 277 278
	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
T
Tomas Winkler 已提交
279
	 * iwl_queue_inc_wrap and iwl_queue_dec_wrap are broken. */
Z
Zhu Yi 已提交
280
	BUILD_BUG_ON(TFD_QUEUE_SIZE_MAX & (TFD_QUEUE_SIZE_MAX - 1));
281 282

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

285
	/* Tell device where to find queue, enable DMA channel. */
C
Christoph Hellwig 已提交
286
	iwl3945_hw_tx_queue_init(priv, txq);
Z
Zhu Yi 已提交
287 288 289 290 291

	return 0;
}

/**
C
Christoph Hellwig 已提交
292
 * iwl3945_tx_queue_free - Deallocate DMA queue.
Z
Zhu Yi 已提交
293 294 295
 * @txq: Transmit queue to deallocate.
 *
 * Empty queue by removing and destroying all BD's.
296 297
 * Free all buffers.
 * 0-fill, but do not free "txq" descriptor structure.
Z
Zhu Yi 已提交
298
 */
C
Christoph Hellwig 已提交
299
void iwl3945_tx_queue_free(struct iwl3945_priv *priv, struct iwl3945_tx_queue *txq)
Z
Zhu Yi 已提交
300
{
C
Christoph Hellwig 已提交
301
	struct iwl3945_queue *q = &txq->q;
Z
Zhu Yi 已提交
302 303 304 305 306 307 308
	struct pci_dev *dev = priv->pci_dev;
	int len;

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

	/* first, empty all BD's */
309
	for (; q->write_ptr != q->read_ptr;
T
Tomas Winkler 已提交
310
	     q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd))
C
Christoph Hellwig 已提交
311
		iwl3945_hw_txq_free_tfd(priv, txq);
Z
Zhu Yi 已提交
312

C
Christoph Hellwig 已提交
313
	len = sizeof(struct iwl3945_cmd) * q->n_window;
Z
Zhu Yi 已提交
314 315 316
	if (q->id == IWL_CMD_QUEUE_NUM)
		len += IWL_MAX_SCAN_SIZE;

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

320
	/* De-alloc circular buffer of TFDs */
Z
Zhu Yi 已提交
321
	if (txq->q.n_bd)
C
Christoph Hellwig 已提交
322
		pci_free_consistent(dev, sizeof(struct iwl3945_tfd_frame) *
Z
Zhu Yi 已提交
323 324
				    txq->q.n_bd, txq->bd, txq->q.dma_addr);

325
	/* De-alloc array of per-TFD driver data */
326 327
	kfree(txq->txb);
	txq->txb = NULL;
Z
Zhu Yi 已提交
328

329
	/* 0-fill queue descriptor structure */
Z
Zhu Yi 已提交
330 331 332
	memset(txq, 0, sizeof(*txq));
}

C
Christoph Hellwig 已提交
333
const u8 iwl3945_broadcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
Z
Zhu Yi 已提交
334 335

/*************** STATION TABLE MANAGEMENT ****
336
 * mac80211 should be examined to determine if sta_info is duplicating
Z
Zhu Yi 已提交
337 338 339 340
 * the functionality provided here
 */

/**************************************************************/
341
#if 0 /* temporary disable till we add real remove station */
342 343 344 345 346
/**
 * iwl3945_remove_station - Remove driver's knowledge of station.
 *
 * NOTE:  This does not remove station from device's station table.
 */
C
Christoph Hellwig 已提交
347
static u8 iwl3945_remove_station(struct iwl3945_priv *priv, const u8 *addr, int is_ap)
Z
Zhu Yi 已提交
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
{
	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;
}
382
#endif
383 384 385 386 387 388

/**
 * 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 已提交
389
static void iwl3945_clear_stations_table(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
390 391 392 393 394 395 396 397 398 399 400
{
	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);
}

401 402 403
/**
 * iwl3945_add_station - Add station to station tables in driver and device
 */
C
Christoph Hellwig 已提交
404
u8 iwl3945_add_station(struct iwl3945_priv *priv, const u8 *addr, int is_ap, u8 flags)
Z
Zhu Yi 已提交
405 406 407
{
	int i;
	int index = IWL_INVALID_STATION;
C
Christoph Hellwig 已提交
408
	struct iwl3945_station_entry *station;
Z
Zhu Yi 已提交
409
	unsigned long flags_spin;
410
	u8 rate;
Z
Zhu Yi 已提交
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429

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

430
	/* These two conditions has the same outcome but keep them separate
Z
Zhu Yi 已提交
431 432 433 434 435 436 437 438 439 440 441 442
	  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;
	}

J
Johannes Berg 已提交
443
	IWL_DEBUG_ASSOC("Add STA ID %d: %pM\n", index, addr);
Z
Zhu Yi 已提交
444 445 446 447
	station = &priv->stations[index];
	station->used = 1;
	priv->num_stations++;

448
	/* Set up the REPLY_ADD_STA command to send to device */
C
Christoph Hellwig 已提交
449
	memset(&station->sta, 0, sizeof(struct iwl3945_addsta_cmd));
Z
Zhu Yi 已提交
450 451 452 453 454
	memcpy(station->sta.sta.addr, addr, ETH_ALEN);
	station->sta.mode = 0;
	station->sta.sta.sta_id = index;
	station->sta.station_flags = 0;

455
	if (priv->band == IEEE80211_BAND_5GHZ)
456 457 458
		rate = IWL_RATE_6M_PLCP;
	else
		rate =	IWL_RATE_1M_PLCP;
459 460 461

	/* Turn on both antennas for the station... */
	station->sta.rate_n_flags =
C
Christoph Hellwig 已提交
462
			iwl3945_hw_set_rate_n_flags(rate, RATE_MCS_ANT_AB_MSK);
463 464 465
	station->current_rate.rate_n_flags =
			le16_to_cpu(station->sta.rate_n_flags);

Z
Zhu Yi 已提交
466
	spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
467 468

	/* Add station to device's station table */
C
Christoph Hellwig 已提交
469
	iwl3945_send_add_station(priv, &station->sta, flags);
Z
Zhu Yi 已提交
470 471 472 473 474 475
	return index;

}

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

C
Christoph Hellwig 已提交
476
static inline int iwl3945_is_ready(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
477 478 479 480 481 482 483 484
{
	/* 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 已提交
485
static inline int iwl3945_is_alive(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
486 487 488 489
{
	return test_bit(STATUS_ALIVE, &priv->status);
}

C
Christoph Hellwig 已提交
490
static inline int iwl3945_is_init(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
491 492 493 494
{
	return test_bit(STATUS_INIT, &priv->status);
}

495 496 497 498 499 500 501 502 503 504
static inline int iwl3945_is_rfkill_sw(struct iwl3945_priv *priv)
{
	return test_bit(STATUS_RF_KILL_SW, &priv->status);
}

static inline int iwl3945_is_rfkill_hw(struct iwl3945_priv *priv)
{
	return test_bit(STATUS_RF_KILL_HW, &priv->status);
}

C
Christoph Hellwig 已提交
505
static inline int iwl3945_is_rfkill(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
506
{
507 508
	return iwl3945_is_rfkill_hw(priv) ||
		iwl3945_is_rfkill_sw(priv);
Z
Zhu Yi 已提交
509 510
}

C
Christoph Hellwig 已提交
511
static inline int iwl3945_is_ready_rf(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
512 513
{

C
Christoph Hellwig 已提交
514
	if (iwl3945_is_rfkill(priv))
Z
Zhu Yi 已提交
515 516
		return 0;

C
Christoph Hellwig 已提交
517
	return iwl3945_is_ready(priv);
Z
Zhu Yi 已提交
518 519 520 521
}

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

522
#define IWL_CMD(x) case x: return #x
Z
Zhu Yi 已提交
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575

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 已提交
576
 * iwl3945_enqueue_hcmd - enqueue a uCode command
Z
Zhu Yi 已提交
577 578 579 580 581 582 583
 * @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 已提交
584
static int iwl3945_enqueue_hcmd(struct iwl3945_priv *priv, struct iwl3945_host_cmd *cmd)
Z
Zhu Yi 已提交
585
{
C
Christoph Hellwig 已提交
586 587 588
	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 已提交
589
	u32 *control_flags;
C
Christoph Hellwig 已提交
590
	struct iwl3945_cmd *out_cmd;
Z
Zhu Yi 已提交
591 592 593 594 595 596 597 598 599 600 601 602 603 604
	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));

605 606 607 608 609 610

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

C
Christoph Hellwig 已提交
611
	if (iwl3945_queue_space(q) < ((cmd->meta.flags & CMD_ASYNC) ? 2 : 1)) {
Z
Zhu Yi 已提交
612 613 614 615 616 617
		IWL_ERROR("No space for Tx\n");
		return -ENOSPC;
	}

	spin_lock_irqsave(&priv->hcmd_lock, flags);

618
	tfd = &txq->bd[q->write_ptr];
Z
Zhu Yi 已提交
619 620 621 622
	memset(tfd, 0, sizeof(*tfd));

	control_flags = (u32 *) tfd;

623
	idx = get_cmd_index(q, q->write_ptr, cmd->meta.flags & CMD_SIZE_HUGE);
Z
Zhu Yi 已提交
624 625 626 627 628 629 630 631 632 633 634
	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) |
635
			INDEX_TO_SEQ(q->write_ptr));
Z
Zhu Yi 已提交
636 637 638 639
	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 已提交
640 641
			offsetof(struct iwl3945_cmd, hdr);
	iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, phys_addr, fix_size);
Z
Zhu Yi 已提交
642 643 644 645 646 647 648 649 650

	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),
651
		     fix_size, q->write_ptr, idx, IWL_CMD_QUEUE_NUM);
Z
Zhu Yi 已提交
652 653

	txq->need_update = 1;
654 655

	/* Increment and update queue's write index */
T
Tomas Winkler 已提交
656
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
C
Christoph Hellwig 已提交
657
	ret = iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
658 659 660 661 662

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

C
Christoph Hellwig 已提交
663
static int iwl3945_send_cmd_async(struct iwl3945_priv *priv, struct iwl3945_host_cmd *cmd)
Z
Zhu Yi 已提交
664 665 666 667 668 669 670 671 672 673 674 675 676 677
{
	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 已提交
678
	ret = iwl3945_enqueue_hcmd(priv, cmd);
Z
Zhu Yi 已提交
679
	if (ret < 0) {
C
Christoph Hellwig 已提交
680
		IWL_ERROR("Error sending %s: iwl3945_enqueue_hcmd failed: %d\n",
Z
Zhu Yi 已提交
681 682 683 684 685 686
			  get_cmd_string(cmd->id), ret);
		return ret;
	}
	return 0;
}

C
Christoph Hellwig 已提交
687
static int iwl3945_send_cmd_sync(struct iwl3945_priv *priv, struct iwl3945_host_cmd *cmd)
Z
Zhu Yi 已提交
688 689 690 691 692 693 694 695 696
{
	int cmd_idx;
	int ret;

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

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

697
	if (test_and_set_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status)) {
Z
Zhu Yi 已提交
698 699
		IWL_ERROR("Error sending %s: Already sending a host command\n",
			  get_cmd_string(cmd->id));
700 701
		ret = -EBUSY;
		goto out;
Z
Zhu Yi 已提交
702 703 704 705 706 707 708
	}

	set_bit(STATUS_HCMD_ACTIVE, &priv->status);

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

C
Christoph Hellwig 已提交
709
	cmd_idx = iwl3945_enqueue_hcmd(priv, cmd);
Z
Zhu Yi 已提交
710 711
	if (cmd_idx < 0) {
		ret = cmd_idx;
C
Christoph Hellwig 已提交
712
		IWL_ERROR("Error sending %s: iwl3945_enqueue_hcmd failed: %d\n",
Z
Zhu Yi 已提交
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
			  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 已提交
756
		struct iwl3945_cmd *qcmd;
Z
Zhu Yi 已提交
757 758 759 760 761 762 763 764 765 766 767 768 769 770

		/* 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:
771
	clear_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status);
Z
Zhu Yi 已提交
772 773 774
	return ret;
}

C
Christoph Hellwig 已提交
775
int iwl3945_send_cmd(struct iwl3945_priv *priv, struct iwl3945_host_cmd *cmd)
Z
Zhu Yi 已提交
776 777
{
	if (cmd->meta.flags & CMD_ASYNC)
C
Christoph Hellwig 已提交
778
		return iwl3945_send_cmd_async(priv, cmd);
Z
Zhu Yi 已提交
779

C
Christoph Hellwig 已提交
780
	return iwl3945_send_cmd_sync(priv, cmd);
Z
Zhu Yi 已提交
781 782
}

C
Christoph Hellwig 已提交
783
int iwl3945_send_cmd_pdu(struct iwl3945_priv *priv, u8 id, u16 len, const void *data)
Z
Zhu Yi 已提交
784
{
C
Christoph Hellwig 已提交
785
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
786 787 788 789 790
		.id = id,
		.len = len,
		.data = data,
	};

C
Christoph Hellwig 已提交
791
	return iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
792 793
}

C
Christoph Hellwig 已提交
794
static int __must_check iwl3945_send_cmd_u32(struct iwl3945_priv *priv, u8 id, u32 val)
Z
Zhu Yi 已提交
795
{
C
Christoph Hellwig 已提交
796
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
797 798 799 800 801
		.id = id,
		.len = sizeof(val),
		.data = &val,
	};

C
Christoph Hellwig 已提交
802
	return iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
803 804
}

C
Christoph Hellwig 已提交
805
int iwl3945_send_statistics_request(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
806
{
C
Christoph Hellwig 已提交
807
	return iwl3945_send_cmd_u32(priv, REPLY_STATISTICS_CMD, 0);
Z
Zhu Yi 已提交
808 809 810
}

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

815
 * In addition to setting the staging RXON, priv->band is also set.
Z
Zhu Yi 已提交
816 817
 *
 * NOTE:  Does not commit to the hardware; it sets appropriate bit fields
818
 * in the staging RXON flag structure based on the band
Z
Zhu Yi 已提交
819
 */
820 821 822
static int iwl3945_set_rxon_channel(struct iwl3945_priv *priv,
				    enum ieee80211_band band,
				    u16 channel)
Z
Zhu Yi 已提交
823
{
824
	if (!iwl3945_get_channel_info(priv, band, channel)) {
Z
Zhu Yi 已提交
825
		IWL_DEBUG_INFO("Could not set channel to %d [%d]\n",
826
			       channel, band);
Z
Zhu Yi 已提交
827 828 829 830
		return -EINVAL;
	}

	if ((le16_to_cpu(priv->staging_rxon.channel) == channel) &&
831
	    (priv->band == band))
Z
Zhu Yi 已提交
832 833 834
		return 0;

	priv->staging_rxon.channel = cpu_to_le16(channel);
835
	if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
836 837 838 839
		priv->staging_rxon.flags &= ~RXON_FLG_BAND_24G_MSK;
	else
		priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;

840
	priv->band = band;
Z
Zhu Yi 已提交
841

842
	IWL_DEBUG_INFO("Staging channel set to %d [%d]\n", channel, band);
Z
Zhu Yi 已提交
843 844 845 846 847

	return 0;
}

/**
C
Christoph Hellwig 已提交
848
 * iwl3945_check_rxon_cmd - validate RXON structure is valid
Z
Zhu Yi 已提交
849 850 851 852 853
 *
 * 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 已提交
854
static int iwl3945_check_rxon_cmd(struct iwl3945_rxon_cmd *rxon)
Z
Zhu Yi 已提交
855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
{
	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 已提交
920
		IWL_ERROR("Not a valid iwl3945_rxon_assoc_cmd field values\n");
Z
Zhu Yi 已提交
921 922 923 924 925 926
		return -1;
	}
	return 0;
}

/**
927
 * iwl3945_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
928
 * @priv: staging_rxon is compared to active_rxon
Z
Zhu Yi 已提交
929
 *
930 931 932
 * 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 已提交
933
 */
C
Christoph Hellwig 已提交
934
static int iwl3945_full_rxon_required(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
935 936 937
{

	/* These items are only settable from the full RXON command */
938
	if (!(iwl3945_is_associated(priv)) ||
Z
Zhu Yi 已提交
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
	    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 已提交
969
static int iwl3945_send_rxon_assoc(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
970 971
{
	int rc = 0;
C
Christoph Hellwig 已提交
972 973 974
	struct iwl3945_rx_packet *res = NULL;
	struct iwl3945_rxon_assoc_cmd rxon_assoc;
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
975 976 977 978 979
		.id = REPLY_RXON_ASSOC,
		.len = sizeof(rxon_assoc),
		.meta.flags = CMD_WANT_SKB,
		.data = &rxon_assoc,
	};
C
Christoph Hellwig 已提交
980 981
	const struct iwl3945_rxon_cmd *rxon1 = &priv->staging_rxon;
	const struct iwl3945_rxon_cmd *rxon2 = &priv->active_rxon;
Z
Zhu Yi 已提交
982 983 984 985 986 987 988 989 990 991 992 993 994 995 996

	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 已提交
997
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
998 999 1000
	if (rc)
		return rc;

C
Christoph Hellwig 已提交
1001
	res = (struct iwl3945_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
	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 已提交
1014
 * iwl3945_commit_rxon - commit staging_rxon to hardware
Z
Zhu Yi 已提交
1015
 *
1016
 * The RXON command in staging_rxon is committed to the hardware and
Z
Zhu Yi 已提交
1017 1018 1019 1020
 * 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 已提交
1021
static int iwl3945_commit_rxon(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1022 1023
{
	/* cast away the const for active_rxon in this function */
C
Christoph Hellwig 已提交
1024
	struct iwl3945_rxon_cmd *active_rxon = (void *)&priv->active_rxon;
Z
Zhu Yi 已提交
1025 1026
	int rc = 0;

C
Christoph Hellwig 已提交
1027
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
		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 已提交
1038
	rc = iwl3945_check_rxon_cmd(&priv->staging_rxon);
Z
Zhu Yi 已提交
1039 1040 1041 1042 1043 1044
	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 已提交
1045
	 * iwl3945_rxon_assoc_cmd which is used to reconfigure filter
Z
Zhu Yi 已提交
1046
	 * and other flags for the current radio configuration. */
C
Christoph Hellwig 已提交
1047 1048
	if (!iwl3945_full_rxon_required(priv)) {
		rc = iwl3945_send_rxon_assoc(priv);
Z
Zhu Yi 已提交
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
		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 已提交
1064
	if (iwl3945_is_associated(priv) &&
Z
Zhu Yi 已提交
1065 1066 1067 1068
	    (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 已提交
1069 1070
		rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON,
				      sizeof(struct iwl3945_rxon_cmd),
Z
Zhu Yi 已提交
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
				      &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"
J
Johannes Berg 已提交
1086
		       "* bssid = %pM\n",
Z
Zhu Yi 已提交
1087 1088 1089
		       ((priv->staging_rxon.filter_flags &
			 RXON_FILTER_ASSOC_MSK) ? "" : "out"),
		       le16_to_cpu(priv->staging_rxon.channel),
J
Johannes Berg 已提交
1090
		       priv->staging_rxon.bssid_addr);
Z
Zhu Yi 已提交
1091 1092

	/* Apply the new configuration */
C
Christoph Hellwig 已提交
1093 1094
	rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON,
			      sizeof(struct iwl3945_rxon_cmd), &priv->staging_rxon);
Z
Zhu Yi 已提交
1095 1096 1097 1098 1099 1100 1101
	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 已提交
1102
	iwl3945_clear_stations_table(priv);
1103

Z
Zhu Yi 已提交
1104 1105
	/* 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 已提交
1106
	rc = iwl3945_hw_reg_send_txpower(priv);
Z
Zhu Yi 已提交
1107 1108 1109 1110 1111 1112
	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 已提交
1113
	if (iwl3945_add_station(priv, iwl3945_broadcast_addr, 0, 0) ==
Z
Zhu Yi 已提交
1114 1115 1116 1117 1118 1119 1120
	    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 已提交
1121
	if (iwl3945_is_associated(priv) &&
1122
	    (priv->iw_mode == NL80211_IFTYPE_STATION))
C
Christoph Hellwig 已提交
1123
		if (iwl3945_add_station(priv, priv->active_rxon.bssid_addr, 1, 0)
Z
Zhu Yi 已提交
1124 1125 1126 1127 1128
		    == IWL_INVALID_STATION) {
			IWL_ERROR("Error adding AP address for transmit.\n");
			return -EIO;
		}

1129
	/* Init the hardware's rate fallback order based on the band */
Z
Zhu Yi 已提交
1130 1131 1132 1133 1134 1135 1136 1137 1138
	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 已提交
1139
static int iwl3945_send_bt_config(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1140
{
C
Christoph Hellwig 已提交
1141
	struct iwl3945_bt_cmd bt_cmd = {
Z
Zhu Yi 已提交
1142 1143 1144 1145 1146 1147 1148
		.flags = 3,
		.lead_time = 0xAA,
		.max_kill = 1,
		.kill_ack_mask = 0,
		.kill_cts_mask = 0,
	};

C
Christoph Hellwig 已提交
1149 1150
	return iwl3945_send_cmd_pdu(priv, REPLY_BT_CONFIG,
				sizeof(struct iwl3945_bt_cmd), &bt_cmd);
Z
Zhu Yi 已提交
1151 1152
}

C
Christoph Hellwig 已提交
1153
static int iwl3945_send_scan_abort(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1154 1155
{
	int rc = 0;
C
Christoph Hellwig 已提交
1156 1157
	struct iwl3945_rx_packet *res;
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
		.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 已提交
1170
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
1171 1172 1173 1174 1175
	if (rc) {
		clear_bit(STATUS_SCAN_ABORTING, &priv->status);
		return rc;
	}

C
Christoph Hellwig 已提交
1176
	res = (struct iwl3945_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
	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 已提交
1194 1195
static int iwl3945_card_state_sync_callback(struct iwl3945_priv *priv,
					struct iwl3945_cmd *cmd,
Z
Zhu Yi 已提交
1196 1197 1198 1199 1200 1201 1202 1203
					struct sk_buff *skb)
{
	return 1;
}

/*
 * CARD_STATE_CMD
 *
1204
 * Use: Sets the device's internal card state to enable, disable, or halt
Z
Zhu Yi 已提交
1205 1206 1207 1208 1209 1210
 *
 * 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 已提交
1211
static int iwl3945_send_card_state(struct iwl3945_priv *priv, u32 flags, u8 meta_flag)
Z
Zhu Yi 已提交
1212
{
C
Christoph Hellwig 已提交
1213
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
1214 1215 1216 1217 1218 1219 1220
		.id = REPLY_CARD_STATE_CMD,
		.len = sizeof(u32),
		.data = &flags,
		.meta.flags = meta_flag,
	};

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

C
Christoph Hellwig 已提交
1223
	return iwl3945_send_cmd(priv, &cmd);
Z
Zhu Yi 已提交
1224 1225
}

C
Christoph Hellwig 已提交
1226 1227
static int iwl3945_add_sta_sync_callback(struct iwl3945_priv *priv,
				     struct iwl3945_cmd *cmd, struct sk_buff *skb)
Z
Zhu Yi 已提交
1228
{
C
Christoph Hellwig 已提交
1229
	struct iwl3945_rx_packet *res = NULL;
Z
Zhu Yi 已提交
1230 1231 1232 1233 1234 1235

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

C
Christoph Hellwig 已提交
1236
	res = (struct iwl3945_rx_packet *)skb->data;
Z
Zhu Yi 已提交
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
	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 已提交
1254 1255
int iwl3945_send_add_station(struct iwl3945_priv *priv,
			 struct iwl3945_addsta_cmd *sta, u8 flags)
Z
Zhu Yi 已提交
1256
{
C
Christoph Hellwig 已提交
1257
	struct iwl3945_rx_packet *res = NULL;
Z
Zhu Yi 已提交
1258
	int rc = 0;
C
Christoph Hellwig 已提交
1259
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
1260
		.id = REPLY_ADD_STA,
C
Christoph Hellwig 已提交
1261
		.len = sizeof(struct iwl3945_addsta_cmd),
Z
Zhu Yi 已提交
1262 1263 1264 1265 1266
		.meta.flags = flags,
		.data = sta,
	};

	if (flags & CMD_ASYNC)
C
Christoph Hellwig 已提交
1267
		cmd.meta.u.callback = iwl3945_add_sta_sync_callback;
Z
Zhu Yi 已提交
1268 1269 1270
	else
		cmd.meta.flags |= CMD_WANT_SKB;

C
Christoph Hellwig 已提交
1271
	rc = iwl3945_send_cmd(priv, &cmd);
Z
Zhu Yi 已提交
1272 1273 1274 1275

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

C
Christoph Hellwig 已提交
1276
	res = (struct iwl3945_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
	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 已提交
1301
static int iwl3945_update_sta_key_info(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
				   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 已提交
1335
	iwl3945_send_add_station(priv, &priv->stations[sta_id].sta, 0);
Z
Zhu Yi 已提交
1336 1337 1338
	return 0;
}

C
Christoph Hellwig 已提交
1339
static int iwl3945_clear_sta_key_info(struct iwl3945_priv *priv, u8 sta_id)
Z
Zhu Yi 已提交
1340 1341 1342 1343
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);
C
Christoph Hellwig 已提交
1344 1345
	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 已提交
1346 1347 1348 1349 1350 1351
	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 已提交
1352
	iwl3945_send_add_station(priv, &priv->stations[sta_id].sta, 0);
Z
Zhu Yi 已提交
1353 1354 1355
	return 0;
}

C
Christoph Hellwig 已提交
1356
static void iwl3945_clear_free_frames(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1357 1358 1359 1360 1361 1362 1363 1364 1365
{
	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 已提交
1366
		kfree(list_entry(element, struct iwl3945_frame, list));
Z
Zhu Yi 已提交
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376
		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 已提交
1377
static struct iwl3945_frame *iwl3945_get_free_frame(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1378
{
C
Christoph Hellwig 已提交
1379
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393
	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 已提交
1394
	return list_entry(element, struct iwl3945_frame, list);
Z
Zhu Yi 已提交
1395 1396
}

C
Christoph Hellwig 已提交
1397
static void iwl3945_free_frame(struct iwl3945_priv *priv, struct iwl3945_frame *frame)
Z
Zhu Yi 已提交
1398 1399 1400 1401 1402
{
	memset(frame, 0, sizeof(*frame));
	list_add(&frame->list, &priv->free_frames);
}

C
Christoph Hellwig 已提交
1403
unsigned int iwl3945_fill_beacon_frame(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
1404 1405 1406 1407
				struct ieee80211_hdr *hdr,
				const u8 *dest, int left)
{

C
Christoph Hellwig 已提交
1408
	if (!iwl3945_is_associated(priv) || !priv->ibss_beacon ||
1409 1410
	    ((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
	     (priv->iw_mode != NL80211_IFTYPE_AP)))
Z
Zhu Yi 已提交
1411 1412 1413 1414 1415 1416 1417 1418 1419 1420
		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;
}

1421
static u8 iwl3945_rate_get_lowest_plcp(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1422 1423
{
	u8 i;
1424 1425 1426 1427
	int rate_mask;

	/* Set rate mask*/
	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
1428
		rate_mask = priv->active_rate_basic & IWL_CCK_RATES_MASK;
1429
	else
1430
		rate_mask = priv->active_rate_basic & IWL_OFDM_RATES_MASK;
Z
Zhu Yi 已提交
1431 1432

	for (i = IWL_RATE_1M_INDEX; i != IWL_RATE_INVALID;
C
Christoph Hellwig 已提交
1433
	     i = iwl3945_rates[i].next_ieee) {
Z
Zhu Yi 已提交
1434
		if (rate_mask & (1 << i))
C
Christoph Hellwig 已提交
1435
			return iwl3945_rates[i].plcp;
Z
Zhu Yi 已提交
1436 1437
	}

1438 1439 1440 1441 1442
	/* No valid rate was found. Assign the lowest one */
	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
		return IWL_RATE_1M_PLCP;
	else
		return IWL_RATE_6M_PLCP;
Z
Zhu Yi 已提交
1443 1444
}

C
Christoph Hellwig 已提交
1445
static int iwl3945_send_beacon_cmd(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1446
{
C
Christoph Hellwig 已提交
1447
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
1448 1449 1450 1451
	unsigned int frame_size;
	int rc;
	u8 rate;

C
Christoph Hellwig 已提交
1452
	frame = iwl3945_get_free_frame(priv);
Z
Zhu Yi 已提交
1453 1454 1455 1456 1457 1458 1459

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

1460
	rate = iwl3945_rate_get_lowest_plcp(priv);
Z
Zhu Yi 已提交
1461

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

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

C
Christoph Hellwig 已提交
1467
	iwl3945_free_frame(priv, frame);
Z
Zhu Yi 已提交
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477

	return rc;
}

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

C
Christoph Hellwig 已提交
1478
static void get_eeprom_mac(struct iwl3945_priv *priv, u8 *mac)
Z
Zhu Yi 已提交
1479 1480 1481 1482
{
	memcpy(mac, priv->eeprom.mac_address, 6);
}

1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
/*
 * 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 已提交
1497
/**
C
Christoph Hellwig 已提交
1498
 * iwl3945_eeprom_init - read EEPROM contents
Z
Zhu Yi 已提交
1499
 *
1500
 * Load the EEPROM contents from adapter into priv->eeprom
Z
Zhu Yi 已提交
1501 1502 1503
 *
 * NOTE:  This routine uses the non-debug IO access functions.
 */
C
Christoph Hellwig 已提交
1504
int iwl3945_eeprom_init(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1505
{
1506
	u16 *e = (u16 *)&priv->eeprom;
C
Christoph Hellwig 已提交
1507
	u32 gp = iwl3945_read32(priv, CSR_EEPROM_GP);
Z
Zhu Yi 已提交
1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
	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) {
J
Jiri Slaby 已提交
1521
		IWL_ERROR("EEPROM not found, EEPROM_GP=0x%08x\n", gp);
Z
Zhu Yi 已提交
1522 1523 1524
		return -ENOENT;
	}

1525
	/* Make sure driver (instead of uCode) is allowed to read EEPROM */
C
Christoph Hellwig 已提交
1526
	rc = iwl3945_eeprom_acquire_semaphore(priv);
Z
Zhu Yi 已提交
1527
	if (rc < 0) {
1528
		IWL_ERROR("Failed to acquire EEPROM semaphore.\n");
Z
Zhu Yi 已提交
1529 1530 1531 1532 1533
		return -ENOENT;
	}

	/* eeprom is an array of 16bit values */
	for (addr = 0; addr < sz; addr += sizeof(u16)) {
C
Christoph Hellwig 已提交
1534 1535
		_iwl3945_write32(priv, CSR_EEPROM_REG, addr << 1);
		_iwl3945_clear_bit(priv, CSR_EEPROM_REG, CSR_EEPROM_REG_BIT_CMD);
Z
Zhu Yi 已提交
1536 1537 1538

		for (i = 0; i < IWL_EEPROM_ACCESS_TIMEOUT;
					i += IWL_EEPROM_ACCESS_DELAY) {
C
Christoph Hellwig 已提交
1539
			r = _iwl3945_read_direct32(priv, CSR_EEPROM_REG);
Z
Zhu Yi 已提交
1540 1541 1542 1543 1544 1545
			if (r & CSR_EEPROM_REG_READ_VALID_MSK)
				break;
			udelay(IWL_EEPROM_ACCESS_DELAY);
		}

		if (!(r & CSR_EEPROM_REG_READ_VALID_MSK)) {
J
Jiri Slaby 已提交
1546
			IWL_ERROR("Time out reading EEPROM[%d]\n", addr);
Z
Zhu Yi 已提交
1547 1548
			return -ETIMEDOUT;
		}
1549
		e[addr / 2] = le16_to_cpu((__force __le16)(r >> 16));
Z
Zhu Yi 已提交
1550 1551 1552 1553 1554
	}

	return 0;
}

C
Christoph Hellwig 已提交
1555
static void iwl3945_unset_hw_setting(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1556 1557 1558
{
	if (priv->hw_setting.shared_virt)
		pci_free_consistent(priv->pci_dev,
C
Christoph Hellwig 已提交
1559
				    sizeof(struct iwl3945_shared),
Z
Zhu Yi 已提交
1560 1561 1562 1563 1564
				    priv->hw_setting.shared_virt,
				    priv->hw_setting.shared_phys);
}

/**
C
Christoph Hellwig 已提交
1565
 * iwl3945_supported_rate_to_ie - fill in the supported rate in IE field
Z
Zhu Yi 已提交
1566 1567 1568
 *
 * return : set the bit for each supported rate insert in ie
 */
C
Christoph Hellwig 已提交
1569
static u16 iwl3945_supported_rate_to_ie(u8 *ie, u16 supported_rate,
1570
				    u16 basic_rate, int *left)
Z
Zhu Yi 已提交
1571 1572 1573
{
	u16 ret_rates = 0, bit;
	int i;
1574 1575
	u8 *cnt = ie;
	u8 *rates = ie + 1;
Z
Zhu Yi 已提交
1576 1577 1578 1579

	for (bit = 1, i = 0; i < IWL_RATE_COUNT; i++, bit <<= 1) {
		if (bit & supported_rate) {
			ret_rates |= bit;
C
Christoph Hellwig 已提交
1580
			rates[*cnt] = iwl3945_rates[i].ieee |
1581 1582 1583 1584 1585
				((bit & basic_rate) ? 0x80 : 0x00);
			(*cnt)++;
			(*left)--;
			if ((*left <= 0) ||
			    (*cnt >= IWL_SUPPORTED_RATES_IE_LEN))
Z
Zhu Yi 已提交
1586 1587 1588 1589 1590 1591 1592 1593
				break;
		}
	}

	return ret_rates;
}

/**
C
Christoph Hellwig 已提交
1594
 * iwl3945_fill_probe_req - fill in all required fields and IE for probe request
Z
Zhu Yi 已提交
1595
 */
C
Christoph Hellwig 已提交
1596
static u16 iwl3945_fill_probe_req(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
1597
			      struct ieee80211_mgmt *frame,
J
Johannes Berg 已提交
1598
			      int left)
Z
Zhu Yi 已提交
1599 1600 1601
{
	int len = 0;
	u8 *pos = NULL;
1602
	u16 active_rates, ret_rates, cck_rates;
Z
Zhu Yi 已提交
1603 1604 1605 1606 1607 1608 1609 1610 1611

	/* 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 已提交
1612
	memcpy(frame->da, iwl3945_broadcast_addr, ETH_ALEN);
Z
Zhu Yi 已提交
1613
	memcpy(frame->sa, priv->mac_addr, ETH_ALEN);
C
Christoph Hellwig 已提交
1614
	memcpy(frame->bssid, iwl3945_broadcast_addr, ETH_ALEN);
Z
Zhu Yi 已提交
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632
	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 supported rate */
	/* ...next IE... */
	left -= 2;
	if (left < 0)
		return 0;
1633

Z
Zhu Yi 已提交
1634 1635 1636
	/* ... fill it in... */
	*pos++ = WLAN_EID_SUPP_RATES;
	*pos = 0;
1637 1638 1639

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

1642
	cck_rates = IWL_CCK_RATES_MASK & active_rates;
C
Christoph Hellwig 已提交
1643
	ret_rates = iwl3945_supported_rate_to_ie(pos, cck_rates,
1644 1645 1646
			priv->active_rate_basic, &left);
	active_rates &= ~ret_rates;

C
Christoph Hellwig 已提交
1647
	ret_rates = iwl3945_supported_rate_to_ie(pos, active_rates,
1648 1649 1650
				 priv->active_rate_basic, &left);
	active_rates &= ~ret_rates;

Z
Zhu Yi 已提交
1651 1652
	len += 2 + *pos;
	pos += (*pos) + 1;
1653
	if (active_rates == 0)
Z
Zhu Yi 已提交
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663
		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 已提交
1664
	iwl3945_supported_rate_to_ie(pos, active_rates,
1665
				 priv->active_rate_basic, &left);
Z
Zhu Yi 已提交
1666 1667 1668 1669 1670 1671 1672 1673 1674 1675
	if (*pos > 0)
		len += 2 + *pos;

 fill_end:
	return (u16)len;
}

/*
 * QoS  support
*/
C
Christoph Hellwig 已提交
1676 1677
static int iwl3945_send_qos_params_command(struct iwl3945_priv *priv,
				       struct iwl3945_qosparam_cmd *qos)
Z
Zhu Yi 已提交
1678 1679
{

C
Christoph Hellwig 已提交
1680 1681
	return iwl3945_send_cmd_pdu(priv, REPLY_QOS_PARAM,
				sizeof(struct iwl3945_qosparam_cmd), qos);
Z
Zhu Yi 已提交
1682 1683
}

C
Christoph Hellwig 已提交
1684
static void iwl3945_reset_qos(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695
{
	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;

1696
	if (priv->iw_mode == NL80211_IFTYPE_ADHOC) {
Z
Zhu Yi 已提交
1697 1698 1699 1700 1701 1702
		if (priv->qos_data.qos_enable)
			priv->qos_data.qos_active = 1;
		if (!(priv->active_rate & 0xfff0)) {
			cw_min = 31;
			is_legacy = 1;
		}
1703
	} else if (priv->iw_mode == NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770
		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 已提交
1771
static void iwl3945_activate_qos(struct iwl3945_priv *priv, u8 force)
Z
Zhu Yi 已提交
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
{
	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 已提交
1795
	if (force || iwl3945_is_associated(priv)) {
T
Tomas Winkler 已提交
1796
		IWL_DEBUG_QOS("send QoS cmd with QoS active %d \n",
Z
Zhu Yi 已提交
1797 1798
			      priv->qos_data.qos_active);

C
Christoph Hellwig 已提交
1799
		iwl3945_send_qos_params_command(priv,
Z
Zhu Yi 已提交
1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819
				&(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 */
T
Tomas Winkler 已提交
1820
/* for TIM  0-10 */
C
Christoph Hellwig 已提交
1821
static struct iwl3945_power_vec_entry range_0[IWL_POWER_AC] = {
Z
Zhu Yi 已提交
1822 1823 1824 1825 1826 1827 1828 1829
	{{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}
};

T
Tomas Winkler 已提交
1830
/* for TIM > 10 */
C
Christoph Hellwig 已提交
1831
static struct iwl3945_power_vec_entry range_1[IWL_POWER_AC] = {
Z
Zhu Yi 已提交
1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843
	{{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 已提交
1844
int iwl3945_power_init_handle(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1845 1846
{
	int rc = 0, i;
C
Christoph Hellwig 已提交
1847 1848
	struct iwl3945_power_mgr *pow_data;
	int size = sizeof(struct iwl3945_power_vec_entry) * IWL_POWER_AC;
Z
Zhu Yi 已提交
1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866
	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 已提交
1867
		struct iwl3945_powertable_cmd *cmd;
Z
Zhu Yi 已提交
1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882

		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 已提交
1883 1884
static int iwl3945_update_power_cmd(struct iwl3945_priv *priv,
				struct iwl3945_powertable_cmd *cmd, u32 mode)
Z
Zhu Yi 已提交
1885 1886 1887 1888
{
	int rc = 0, i;
	u8 skip;
	u32 max_sleep = 0;
C
Christoph Hellwig 已提交
1889
	struct iwl3945_power_vec_entry *range;
Z
Zhu Yi 已提交
1890
	u8 period = 0;
C
Christoph Hellwig 已提交
1891
	struct iwl3945_power_mgr *pow_data;
Z
Zhu Yi 已提交
1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903

	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 已提交
1904
	memcpy(cmd, &range[mode].cmd, sizeof(struct iwl3945_powertable_cmd));
Z
Zhu Yi 已提交
1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946

#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 已提交
1947
static int iwl3945_send_power_mode(struct iwl3945_priv *priv, u32 mode)
Z
Zhu Yi 已提交
1948
{
1949
	u32 uninitialized_var(final_mode);
Z
Zhu Yi 已提交
1950
	int rc;
C
Christoph Hellwig 已提交
1951
	struct iwl3945_powertable_cmd cmd;
Z
Zhu Yi 已提交
1952 1953

	/* If on battery, set to 3,
1954
	 * if plugged into AC power, set to CAM ("continuously aware mode"),
Z
Zhu Yi 已提交
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967
	 * 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 已提交
1968
	iwl3945_update_power_cmd(priv, &cmd, final_mode);
Z
Zhu Yi 已提交
1969

C
Christoph Hellwig 已提交
1970
	rc = iwl3945_send_cmd_pdu(priv, POWER_TABLE_CMD, sizeof(cmd), &cmd);
Z
Zhu Yi 已提交
1971 1972 1973 1974 1975 1976 1977 1978 1979 1980

	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 已提交
1981
 * iwl3945_scan_cancel - Cancel any currently executing HW scan
Z
Zhu Yi 已提交
1982 1983 1984
 *
 * NOTE: priv->mutex is not required before calling this function
 */
C
Christoph Hellwig 已提交
1985
static int iwl3945_scan_cancel(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007
{
	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 已提交
2008
 * iwl3945_scan_cancel_timeout - Cancel any currently executing HW scan
Z
Zhu Yi 已提交
2009 2010 2011 2012
 * @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 已提交
2013
static int iwl3945_scan_cancel_timeout(struct iwl3945_priv *priv, unsigned long ms)
Z
Zhu Yi 已提交
2014 2015 2016 2017
{
	unsigned long now = jiffies;
	int ret;

C
Christoph Hellwig 已提交
2018
	ret = iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034
	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;
}

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

C
Christoph Hellwig 已提交
2035
static __le16 iwl3945_adjust_beacon_interval(u16 beacon_val)
Z
Zhu Yi 已提交
2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047
{
	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 已提交
2048
static void iwl3945_setup_rxon_timing(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069
{
	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);

2070
	if (priv->iw_mode == NL80211_IFTYPE_STATION) {
Z
Zhu Yi 已提交
2071 2072 2073 2074 2075 2076 2077
		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 已提交
2078
			    iwl3945_adjust_beacon_interval(
Z
Zhu Yi 已提交
2079 2080 2081 2082 2083 2084
				le16_to_cpu(priv->rxon_timing.beacon_interval));
		}

		priv->rxon_timing.atim_window = 0;
	} else {
		priv->rxon_timing.beacon_interval =
C
Christoph Hellwig 已提交
2085
			iwl3945_adjust_beacon_interval(conf->beacon_int);
Z
Zhu Yi 已提交
2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
		/* 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 已提交
2104
static int iwl3945_scan_initiate(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2105
{
2106
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
2107 2108 2109 2110
		IWL_ERROR("APs don't scan.\n");
		return 0;
	}

C
Christoph Hellwig 已提交
2111
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127
		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");
2128 2129 2130 2131
	if (priv->cfg->sku & IWL_SKU_G)
		priv->scan_bands |= BIT(IEEE80211_BAND_2GHZ);
	if (priv->cfg->sku & IWL_SKU_A)
		priv->scan_bands |= BIT(IEEE80211_BAND_5GHZ);
Z
Zhu Yi 已提交
2132 2133 2134 2135 2136 2137 2138 2139 2140
	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 已提交
2141
static int iwl3945_set_rxon_hwcrypto(struct iwl3945_priv *priv, int hw_decrypt)
Z
Zhu Yi 已提交
2142
{
C
Christoph Hellwig 已提交
2143
	struct iwl3945_rxon_cmd *rxon = &priv->staging_rxon;
Z
Zhu Yi 已提交
2144 2145 2146 2147 2148 2149 2150 2151 2152

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

	return 0;
}

2153 2154
static void iwl3945_set_flags_for_phymode(struct iwl3945_priv *priv,
					  enum ieee80211_band band)
Z
Zhu Yi 已提交
2155
{
2156
	if (band == IEEE80211_BAND_5GHZ) {
Z
Zhu Yi 已提交
2157 2158 2159 2160 2161
		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 已提交
2162
		/* Copied from iwl3945_bg_post_associate() */
Z
Zhu Yi 已提交
2163 2164 2165 2166 2167
		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;

2168
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
Z
Zhu Yi 已提交
2169 2170 2171 2172 2173 2174 2175 2176 2177
			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;
	}
}

/*
2178
 * initialize rxon structure with default values from eeprom
Z
Zhu Yi 已提交
2179
 */
2180 2181
static void iwl3945_connection_init_rx_config(struct iwl3945_priv *priv,
					      int mode)
Z
Zhu Yi 已提交
2182
{
C
Christoph Hellwig 已提交
2183
	const struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
2184 2185 2186

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

2187
	switch (mode) {
2188
	case NL80211_IFTYPE_AP:
Z
Zhu Yi 已提交
2189 2190 2191
		priv->staging_rxon.dev_type = RXON_DEV_TYPE_AP;
		break;

2192
	case NL80211_IFTYPE_STATION:
Z
Zhu Yi 已提交
2193 2194 2195 2196
		priv->staging_rxon.dev_type = RXON_DEV_TYPE_ESS;
		priv->staging_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
		break;

2197
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
2198 2199 2200 2201 2202 2203
		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;

2204
	case NL80211_IFTYPE_MONITOR:
Z
Zhu Yi 已提交
2205 2206 2207 2208
		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;
2209
	default:
2210
		IWL_ERROR("Unsupported interface type %d\n", mode);
2211
		break;
Z
Zhu Yi 已提交
2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222
	}

#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

2223
	ch_info = iwl3945_get_channel_info(priv, priv->band,
2224
				       le16_to_cpu(priv->active_rxon.channel));
Z
Zhu Yi 已提交
2225 2226 2227 2228 2229 2230 2231 2232

	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
	 */
2233
	if ((mode == NL80211_IFTYPE_ADHOC) && !(is_channel_ibss(ch_info)))
Z
Zhu Yi 已提交
2234 2235 2236 2237
		ch_info = &priv->channel_info[0];

	priv->staging_rxon.channel = cpu_to_le16(ch_info->channel);
	if (is_channel_a_band(ch_info))
2238
		priv->band = IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
2239
	else
2240
		priv->band = IEEE80211_BAND_2GHZ;
Z
Zhu Yi 已提交
2241

2242
	iwl3945_set_flags_for_phymode(priv, priv->band);
Z
Zhu Yi 已提交
2243 2244 2245 2246 2247 2248 2249

	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 已提交
2250
static int iwl3945_set_mode(struct iwl3945_priv *priv, int mode)
Z
Zhu Yi 已提交
2251
{
2252
	if (mode == NL80211_IFTYPE_ADHOC) {
C
Christoph Hellwig 已提交
2253
		const struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
2254

C
Christoph Hellwig 已提交
2255
		ch_info = iwl3945_get_channel_info(priv,
2256
			priv->band,
Z
Zhu Yi 已提交
2257 2258 2259 2260 2261 2262 2263 2264 2265
			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;
		}
	}

2266
	iwl3945_connection_init_rx_config(priv, mode);
Z
Zhu Yi 已提交
2267 2268
	memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);

C
Christoph Hellwig 已提交
2269
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
2270

T
Tomas Winkler 已提交
2271
	/* don't commit rxon if rf-kill is on*/
2272 2273 2274 2275 2276 2277 2278 2279 2280 2281
	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 已提交
2282
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
2283 2284 2285 2286

	return 0;
}

C
Christoph Hellwig 已提交
2287
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl3945_priv *priv,
2288
				      struct ieee80211_tx_info *info,
C
Christoph Hellwig 已提交
2289
				      struct iwl3945_cmd *cmd,
Z
Zhu Yi 已提交
2290 2291 2292
				      struct sk_buff *skb_frag,
				      int last_frag)
{
2293
	struct iwl3945_hw_key *keyinfo =
2294
	    &priv->stations[info->control.hw_key->hw_key_idx].keyinfo;
Z
Zhu Yi 已提交
2295 2296 2297 2298 2299

	switch (keyinfo->alg) {
	case ALG_CCMP:
		cmd->cmd.tx.sec_ctl = TX_CMD_SEC_CCM;
		memcpy(cmd->cmd.tx.key, keyinfo->key, keyinfo->keylen);
T
Tomas Winkler 已提交
2300
		IWL_DEBUG_TX("tx_cmd with AES hwcrypto\n");
Z
Zhu Yi 已提交
2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
		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 |
2317
		    (info->control.hw_key->hw_key_idx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT;
Z
Zhu Yi 已提交
2318 2319 2320 2321 2322 2323 2324

		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 "
2325
			     "with key %d\n", info->control.hw_key->hw_key_idx);
Z
Zhu Yi 已提交
2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
		break;

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

/*
 * handle build REPLY_TX command notification.
 */
C
Christoph Hellwig 已提交
2337 2338
static void iwl3945_build_tx_cmd_basic(struct iwl3945_priv *priv,
				  struct iwl3945_cmd *cmd,
2339
				  struct ieee80211_tx_info *info,
Z
Zhu Yi 已提交
2340 2341 2342
				  struct ieee80211_hdr *hdr,
				  int is_unicast, u8 std_id)
{
2343
	__le16 fc = hdr->frame_control;
Z
Zhu Yi 已提交
2344
	__le32 tx_flags = cmd->cmd.tx.tx_flags;
2345
	u8 rc_flags = info->control.rates[0].flags;
Z
Zhu Yi 已提交
2346 2347

	cmd->cmd.tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
2348
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Z
Zhu Yi 已提交
2349
		tx_flags |= TX_CMD_FLG_ACK_MSK;
2350
		if (ieee80211_is_mgmt(fc))
Z
Zhu Yi 已提交
2351
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
2352
		if (ieee80211_is_probe_resp(fc) &&
Z
Zhu Yi 已提交
2353 2354 2355 2356 2357 2358 2359 2360
		    !(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;
2361
	if (ieee80211_has_morefrags(fc))
Z
Zhu Yi 已提交
2362 2363
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

2364 2365
	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
2366
		cmd->cmd.tx.tid_tspec = qc[0] & 0xf;
Z
Zhu Yi 已提交
2367
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
2368
	} else {
Z
Zhu Yi 已提交
2369
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
2370
	}
Z
Zhu Yi 已提交
2371

2372
	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
Z
Zhu Yi 已提交
2373 2374
		tx_flags |= TX_CMD_FLG_RTS_MSK;
		tx_flags &= ~TX_CMD_FLG_CTS_MSK;
2375
	} else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
Z
Zhu Yi 已提交
2376 2377 2378 2379 2380 2381 2382 2383
		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);
2384 2385
	if (ieee80211_is_mgmt(fc)) {
		if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
2386
			cmd->cmd.tx.timeout.pm_frame_timeout = cpu_to_le16(3);
Z
Zhu Yi 已提交
2387
		else
2388
			cmd->cmd.tx.timeout.pm_frame_timeout = cpu_to_le16(2);
M
Mohamed Abbas 已提交
2389
	} else {
Z
Zhu Yi 已提交
2390
		cmd->cmd.tx.timeout.pm_frame_timeout = 0;
M
Mohamed Abbas 已提交
2391 2392 2393 2394
#ifdef CONFIG_IWL3945_LEDS
		priv->rxtxpackets += le16_to_cpu(cmd->cmd.tx.len);
#endif
	}
Z
Zhu Yi 已提交
2395 2396 2397 2398 2399 2400

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

2401 2402 2403
/**
 * iwl3945_get_sta_id - Find station's index within station table
 */
C
Christoph Hellwig 已提交
2404
static int iwl3945_get_sta_id(struct iwl3945_priv *priv, struct ieee80211_hdr *hdr)
Z
Zhu Yi 已提交
2405 2406 2407 2408
{
	int sta_id;
	u16 fc = le16_to_cpu(hdr->frame_control);

2409
	/* If this frame is broadcast or management, use broadcast station id */
Z
Zhu Yi 已提交
2410 2411 2412 2413 2414 2415
	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) {

2416 2417
	/* If we are a client station in a BSS network, use the special
	 * AP station entry (that's the only station we communicate with) */
2418
	case NL80211_IFTYPE_STATION:
Z
Zhu Yi 已提交
2419 2420 2421
		return IWL_AP_ID;

	/* If we are an AP, then find the station, or use BCAST */
2422
	case NL80211_IFTYPE_AP:
C
Christoph Hellwig 已提交
2423
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
2424 2425 2426 2427
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;
		return priv->hw_setting.bcast_sta_id;

2428 2429
	/* If this frame is going out to an IBSS network, find the station,
	 * or create a new station table entry */
2430
	case NL80211_IFTYPE_ADHOC: {
2431
		/* Create new station table entry */
C
Christoph Hellwig 已提交
2432
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
2433 2434 2435
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

C
Christoph Hellwig 已提交
2436
		sta_id = iwl3945_add_station(priv, hdr->addr1, 0, CMD_ASYNC);
Z
Zhu Yi 已提交
2437 2438 2439 2440

		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

J
Johannes Berg 已提交
2441
		IWL_DEBUG_DROP("Station %pM not in station map. "
Z
Zhu Yi 已提交
2442
			       "Defaulting to broadcast...\n",
J
Johannes Berg 已提交
2443
			       hdr->addr1);
C
Christoph Hellwig 已提交
2444
		iwl3945_print_hex_dump(IWL_DL_DROP, (u8 *) hdr, sizeof(*hdr));
Z
Zhu Yi 已提交
2445
		return priv->hw_setting.bcast_sta_id;
2446
	}
2447 2448
	/* If we are in monitor mode, use BCAST. This is required for
	 * packet injection. */
2449
	case NL80211_IFTYPE_MONITOR:
2450 2451
		return priv->hw_setting.bcast_sta_id;

Z
Zhu Yi 已提交
2452
	default:
J
Jiri Slaby 已提交
2453
		IWL_WARNING("Unknown mode of operation: %d\n", priv->iw_mode);
Z
Zhu Yi 已提交
2454 2455 2456 2457 2458 2459 2460
		return priv->hw_setting.bcast_sta_id;
	}
}

/*
 * start REPLY_TX command process
 */
2461
static int iwl3945_tx_skb(struct iwl3945_priv *priv, struct sk_buff *skb)
Z
Zhu Yi 已提交
2462 2463
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2464
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
C
Christoph Hellwig 已提交
2465
	struct iwl3945_tfd_frame *tfd;
Z
Zhu Yi 已提交
2466
	u32 *control_flags;
2467
	int txq_id = skb_get_queue_mapping(skb);
C
Christoph Hellwig 已提交
2468 2469
	struct iwl3945_tx_queue *txq = NULL;
	struct iwl3945_queue *q = NULL;
Z
Zhu Yi 已提交
2470 2471
	dma_addr_t phys_addr;
	dma_addr_t txcmd_phys;
C
Christoph Hellwig 已提交
2472
	struct iwl3945_cmd *out_cmd = NULL;
2473 2474 2475
	u16 len, idx, len_org, hdr_len;
	u8 id;
	u8 unicast;
Z
Zhu Yi 已提交
2476
	u8 sta_id;
2477
	u8 tid = 0;
Z
Zhu Yi 已提交
2478
	u16 seq_number = 0;
2479
	__le16 fc;
Z
Zhu Yi 已提交
2480
	u8 wait_write_ptr = 0;
2481
	u8 *qc = NULL;
Z
Zhu Yi 已提交
2482 2483 2484 2485
	unsigned long flags;
	int rc;

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
2486
	if (iwl3945_is_rfkill(priv)) {
Z
Zhu Yi 已提交
2487 2488 2489 2490
		IWL_DEBUG_DROP("Dropping - RF KILL\n");
		goto drop_unlock;
	}

2491
	if ((ieee80211_get_tx_rate(priv->hw, info)->hw_value & 0xFF) == IWL_INVALID_RATE) {
Z
Zhu Yi 已提交
2492 2493 2494 2495 2496 2497 2498
		IWL_ERROR("ERROR: No TX rate available.\n");
		goto drop_unlock;
	}

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

2499
	fc = hdr->frame_control;
Z
Zhu Yi 已提交
2500

2501
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
2502 2503
	if (ieee80211_is_auth(fc))
		IWL_DEBUG_TX("Sending AUTH frame\n");
2504
	else if (ieee80211_is_assoc_req(fc))
Z
Zhu Yi 已提交
2505
		IWL_DEBUG_TX("Sending ASSOC frame\n");
2506
	else if (ieee80211_is_reassoc_req(fc))
Z
Zhu Yi 已提交
2507 2508 2509
		IWL_DEBUG_TX("Sending REASSOC frame\n");
#endif

2510
	/* drop all data frame if we are not associated */
2511
	if (ieee80211_is_data(fc) &&
2512
	    (priv->iw_mode != NL80211_IFTYPE_MONITOR) && /* packet injection */
2513
	    (!iwl3945_is_associated(priv) ||
2514
	     ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id))) {
C
Christoph Hellwig 已提交
2515
		IWL_DEBUG_DROP("Dropping - !iwl3945_is_associated\n");
Z
Zhu Yi 已提交
2516 2517 2518 2519 2520
		goto drop_unlock;
	}

	spin_unlock_irqrestore(&priv->lock, flags);

2521
	hdr_len = ieee80211_hdrlen(fc);
2522 2523

	/* Find (or create) index into station table for destination station */
C
Christoph Hellwig 已提交
2524
	sta_id = iwl3945_get_sta_id(priv, hdr);
Z
Zhu Yi 已提交
2525
	if (sta_id == IWL_INVALID_STATION) {
J
Johannes Berg 已提交
2526 2527
		IWL_DEBUG_DROP("Dropping - INVALID STATION: %pM\n",
			       hdr->addr1);
Z
Zhu Yi 已提交
2528 2529 2530 2531 2532
		goto drop;
	}

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

2533 2534
	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
2535
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
Z
Zhu Yi 已提交
2536 2537 2538 2539 2540 2541 2542
		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;
	}
2543 2544

	/* Descriptor for chosen Tx queue */
Z
Zhu Yi 已提交
2545 2546 2547 2548 2549
	txq = &priv->txq[txq_id];
	q = &txq->q;

	spin_lock_irqsave(&priv->lock, flags);

2550
	/* Set up first empty TFD within this queue's circular TFD buffer */
2551
	tfd = &txq->bd[q->write_ptr];
Z
Zhu Yi 已提交
2552 2553
	memset(tfd, 0, sizeof(*tfd));
	control_flags = (u32 *) tfd;
2554
	idx = get_cmd_index(q, q->write_ptr, 0);
Z
Zhu Yi 已提交
2555

2556
	/* Set up driver data for this TFD */
C
Christoph Hellwig 已提交
2557
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl3945_tx_info));
2558
	txq->txb[q->write_ptr].skb[0] = skb;
2559 2560

	/* Init first empty entry in queue's array of Tx/cmd buffers */
Z
Zhu Yi 已提交
2561 2562 2563
	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));
2564 2565 2566 2567 2568 2569 2570

	/*
	 * 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 已提交
2571 2572
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
2573
				INDEX_TO_SEQ(q->write_ptr)));
2574 2575

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

2578 2579 2580 2581 2582 2583 2584 2585 2586
	/*
	 * 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 已提交
2587
	len = priv->hw_setting.tx_cmd_len +
C
Christoph Hellwig 已提交
2588
		sizeof(struct iwl3945_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
2589 2590 2591 2592 2593 2594 2595 2596 2597

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

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

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

2603 2604
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
C
Christoph Hellwig 已提交
2605
	iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, txcmd_phys, len);
Z
Zhu Yi 已提交
2606

2607
	if (info->control.hw_key)
2608
		iwl3945_build_tx_cmd_hwcrypto(priv, info, out_cmd, skb, 0);
Z
Zhu Yi 已提交
2609

2610 2611
	/* 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 已提交
2612 2613 2614 2615
	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 已提交
2616
		iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, phys_addr, len);
Z
Zhu Yi 已提交
2617 2618 2619
	}

	if (!len)
2620
		/* If there is no payload, then we use only one Tx buffer */
Z
Zhu Yi 已提交
2621 2622
		*control_flags = TFD_CTL_COUNT_SET(1);
	else
2623 2624
		/* Else use 2 buffers.
		 * Tell 3945 about any padding after MAC header */
Z
Zhu Yi 已提交
2625 2626 2627
		*control_flags = TFD_CTL_COUNT_SET(2) |
			TFD_CTL_PAD_SET(U32_PAD(len));

2628
	/* Total # bytes to be transmitted */
Z
Zhu Yi 已提交
2629 2630 2631 2632
	len = (u16)skb->len;
	out_cmd->cmd.tx.len = cpu_to_le16(len);

	/* TODO need this for burst mode later on */
2633
	iwl3945_build_tx_cmd_basic(priv, out_cmd, info, hdr, unicast, sta_id);
Z
Zhu Yi 已提交
2634 2635

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

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

2641
	if (!ieee80211_has_morefrags(hdr->frame_control)) {
Z
Zhu Yi 已提交
2642
		txq->need_update = 1;
2643
		if (qc)
Z
Zhu Yi 已提交
2644 2645 2646 2647 2648 2649
			priv->stations[sta_id].tid[tid].seq_number = seq_number;
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

C
Christoph Hellwig 已提交
2650
	iwl3945_print_hex_dump(IWL_DL_TX, out_cmd->cmd.payload,
Z
Zhu Yi 已提交
2651 2652
			   sizeof(out_cmd->cmd.tx));

C
Christoph Hellwig 已提交
2653
	iwl3945_print_hex_dump(IWL_DL_TX, (u8 *)out_cmd->cmd.tx.hdr,
2654
			   ieee80211_hdrlen(fc));
Z
Zhu Yi 已提交
2655

2656
	/* Tell device the write index *just past* this latest filled TFD */
T
Tomas Winkler 已提交
2657
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
C
Christoph Hellwig 已提交
2658
	rc = iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
2659 2660 2661 2662 2663
	spin_unlock_irqrestore(&priv->lock, flags);

	if (rc)
		return rc;

C
Christoph Hellwig 已提交
2664
	if ((iwl3945_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
2665 2666 2667 2668
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
C
Christoph Hellwig 已提交
2669
			iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
2670 2671 2672
			spin_unlock_irqrestore(&priv->lock, flags);
		}

2673
		ieee80211_stop_queue(priv->hw, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
2674 2675 2676 2677 2678 2679 2680 2681 2682 2683
	}

	return 0;

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

C
Christoph Hellwig 已提交
2684
static void iwl3945_set_rate(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2685
{
2686
	const struct ieee80211_supported_band *sband = NULL;
Z
Zhu Yi 已提交
2687 2688 2689
	struct ieee80211_rate *rate;
	int i;

2690 2691
	sband = iwl3945_get_band(priv, priv->band);
	if (!sband) {
2692 2693 2694
		IWL_ERROR("Failed to set rate: unable to get hw mode\n");
		return;
	}
Z
Zhu Yi 已提交
2695 2696 2697 2698

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

2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709
	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 已提交
2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737
	}

	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 已提交
2738
static void iwl3945_radio_kill_sw(struct iwl3945_priv *priv, int disable_radio)
Z
Zhu Yi 已提交
2739 2740 2741 2742 2743 2744 2745 2746 2747 2748
{
	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 已提交
2749
		iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
2750
		/* FIXME: This is a workaround for AP */
2751
		if (priv->iw_mode != NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
2752
			spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
2753
			iwl3945_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
2754 2755
				    CSR_UCODE_SW_BIT_RFKILL);
			spin_unlock_irqrestore(&priv->lock, flags);
C
Christoph Hellwig 已提交
2756
			iwl3945_send_card_state(priv, CARD_STATE_CMD_DISABLE, 0);
Z
Zhu Yi 已提交
2757 2758 2759 2760 2761 2762
			set_bit(STATUS_RF_KILL_SW, &priv->status);
		}
		return;
	}

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
2763
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
Z
Zhu Yi 已提交
2764 2765 2766 2767 2768 2769 2770 2771

	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 已提交
2772 2773 2774
	iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
	if (!iwl3945_grab_nic_access(priv))
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
2775 2776 2777 2778 2779 2780 2781 2782
	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;
	}

2783 2784
	if (priv->is_open)
		queue_work(priv->workqueue, &priv->restart);
Z
Zhu Yi 已提交
2785 2786 2787
	return;
}

C
Christoph Hellwig 已提交
2788
void iwl3945_set_decrypted_flag(struct iwl3945_priv *priv, struct sk_buff *skb,
Z
Zhu Yi 已提交
2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819
			    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;
	}
}

2820
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834

#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 已提交
2835
static u32 iwl3945_usecs_to_beacons(u32 usec, u32 beacon_interval)
Z
Zhu Yi 已提交
2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853
{
	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 已提交
2854
static __le32 iwl3945_add_beacon_time(u32 base, u32 addon, u32 beacon_interval)
Z
Zhu Yi 已提交
2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872
{
	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 已提交
2873
static int iwl3945_get_measurement(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
2874 2875 2876
			       struct ieee80211_measurement_params *params,
			       u8 type)
{
C
Christoph Hellwig 已提交
2877 2878 2879
	struct iwl3945_spectrum_cmd spectrum;
	struct iwl3945_rx_packet *res;
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
2880 2881 2882 2883 2884 2885 2886 2887 2888
		.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 已提交
2889
	if (iwl3945_is_associated(priv))
Z
Zhu Yi 已提交
2890
		add_time =
C
Christoph Hellwig 已提交
2891
		    iwl3945_usecs_to_beacons(
Z
Zhu Yi 已提交
2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903
			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 已提交
2904
	if (iwl3945_is_associated(priv))
Z
Zhu Yi 已提交
2905
		spectrum.start_time =
C
Christoph Hellwig 已提交
2906
		    iwl3945_add_beacon_time(priv->last_beacon_time,
Z
Zhu Yi 已提交
2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918
				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 已提交
2919
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
2920 2921 2922
	if (rc)
		return rc;

C
Christoph Hellwig 已提交
2923
	res = (struct iwl3945_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
2924 2925 2926 2927 2928 2929 2930 2931 2932
	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) {
2933 2934
			IWL_DEBUG_INFO("Replaced existing measurement: %d\n",
						res->u.spectrum.id);
Z
Zhu Yi 已提交
2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951
			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 已提交
2952 2953
static void iwl3945_rx_reply_alive(struct iwl3945_priv *priv,
			       struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2954
{
C
Christoph Hellwig 已提交
2955 2956
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_alive_resp *palive;
Z
Zhu Yi 已提交
2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969
	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 已提交
2970
		       sizeof(struct iwl3945_init_alive_resp));
Z
Zhu Yi 已提交
2971 2972 2973 2974
		pwork = &priv->init_alive_start;
	} else {
		IWL_DEBUG_INFO("Runtime Alive received.\n");
		memcpy(&priv->card_alive, &pkt->u.alive_frame,
C
Christoph Hellwig 已提交
2975
		       sizeof(struct iwl3945_alive_resp));
Z
Zhu Yi 已提交
2976
		pwork = &priv->alive_start;
C
Christoph Hellwig 已提交
2977
		iwl3945_disable_events(priv);
Z
Zhu Yi 已提交
2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988
	}

	/* 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 已提交
2989 2990
static void iwl3945_rx_reply_add_sta(struct iwl3945_priv *priv,
				 struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2991
{
C
Christoph Hellwig 已提交
2992
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
2993 2994 2995 2996 2997

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

C
Christoph Hellwig 已提交
2998 2999
static void iwl3945_rx_reply_error(struct iwl3945_priv *priv,
			       struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3000
{
C
Christoph Hellwig 已提交
3001
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013

	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 已提交
3014
static void iwl3945_rx_csa(struct iwl3945_priv *priv, struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3015
{
C
Christoph Hellwig 已提交
3016 3017 3018
	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 已提交
3019 3020 3021 3022 3023 3024
	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 已提交
3025 3026
static void iwl3945_rx_spectrum_measure_notif(struct iwl3945_priv *priv,
					  struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3027
{
3028
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
C
Christoph Hellwig 已提交
3029 3030
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_spectrum_notification *report = &(pkt->u.spectrum_notif);
Z
Zhu Yi 已提交
3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042

	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 已提交
3043 3044
static void iwl3945_rx_pm_sleep_notif(struct iwl3945_priv *priv,
				  struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3045
{
3046
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
3047 3048
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_sleep_notification *sleep = &(pkt->u.sleep_notif);
Z
Zhu Yi 已提交
3049 3050 3051 3052 3053
	IWL_DEBUG_RX("sleep mode: %d, src: %d\n",
		     sleep->pm_sleep_mode, sleep->pm_wakeup_src);
#endif
}

C
Christoph Hellwig 已提交
3054 3055
static void iwl3945_rx_pm_debug_statistics_notif(struct iwl3945_priv *priv,
					     struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3056
{
C
Christoph Hellwig 已提交
3057
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
3058 3059 3060
	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 已提交
3061
	iwl3945_print_hex_dump(IWL_DL_RADIO, pkt->u.raw, le32_to_cpu(pkt->len));
Z
Zhu Yi 已提交
3062 3063
}

C
Christoph Hellwig 已提交
3064
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
3065
{
C
Christoph Hellwig 已提交
3066 3067
	struct iwl3945_priv *priv =
		container_of(work, struct iwl3945_priv, beacon_update);
Z
Zhu Yi 已提交
3068 3069 3070
	struct sk_buff *beacon;

	/* Pull updated AP beacon from mac80211. will fail if not in AP mode */
3071
	beacon = ieee80211_beacon_get(priv->hw, priv->vif);
Z
Zhu Yi 已提交
3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085

	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 已提交
3086
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3087 3088
}

C
Christoph Hellwig 已提交
3089 3090
static void iwl3945_rx_beacon_notif(struct iwl3945_priv *priv,
				struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3091
{
3092
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
3093 3094
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105
	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

3106
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
3107 3108 3109 3110 3111
	    (!test_bit(STATUS_EXIT_PENDING, &priv->status)))
		queue_work(priv->workqueue, &priv->beacon_update);
}

/* Service response to REPLY_SCAN_CMD (0x80) */
C
Christoph Hellwig 已提交
3112 3113
static void iwl3945_rx_reply_scan(struct iwl3945_priv *priv,
			      struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3114
{
3115
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
3116 3117 3118
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_scanreq_notification *notif =
	    (struct iwl3945_scanreq_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
3119 3120 3121 3122 3123 3124

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

/* Service SCAN_START_NOTIFICATION (0x82) */
C
Christoph Hellwig 已提交
3125 3126
static void iwl3945_rx_scan_start_notif(struct iwl3945_priv *priv,
				    struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3127
{
C
Christoph Hellwig 已提交
3128 3129 3130
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_scanstart_notification *notif =
	    (struct iwl3945_scanstart_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141
	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 已提交
3142 3143
static void iwl3945_rx_scan_results_notif(struct iwl3945_priv *priv,
				      struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3144
{
C
Christoph Hellwig 已提交
3145 3146 3147
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_scanresults_notification *notif =
	    (struct iwl3945_scanresults_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162

	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;
3163
	priv->next_scan_jiffies = 0;
Z
Zhu Yi 已提交
3164 3165 3166
}

/* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
C
Christoph Hellwig 已提交
3167 3168
static void iwl3945_rx_scan_complete_notif(struct iwl3945_priv *priv,
				       struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3169
{
C
Christoph Hellwig 已提交
3170 3171
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
Z
Zhu Yi 已提交
3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184

	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",
3185 3186
		       (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) ?
							"2.4" : "5.2",
Z
Zhu Yi 已提交
3187 3188 3189
		       jiffies_to_msecs(elapsed_jiffies
					(priv->scan_pass_start, jiffies)));

3190 3191 3192 3193 3194 3195 3196
	/* Remove this scanned band from the list of pending
	 * bands to scan, band G precedes A in order of scanning
	 * as seen in iwl3945_bg_request_scan */
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ))
		priv->scan_bands &= ~BIT(IEEE80211_BAND_2GHZ);
	else if (priv->scan_bands &  BIT(IEEE80211_BAND_5GHZ))
		priv->scan_bands &= ~BIT(IEEE80211_BAND_5GHZ);
Z
Zhu Yi 已提交
3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210

	/* 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;
3211
	priv->next_scan_jiffies = 0;
Z
Zhu Yi 已提交
3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229
	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 已提交
3230 3231
static void iwl3945_rx_card_state_notif(struct iwl3945_priv *priv,
				    struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3232
{
C
Christoph Hellwig 已提交
3233
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
3234 3235 3236 3237 3238 3239 3240
	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 已提交
3241
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254
		    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 已提交
3255
	iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266

	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 已提交
3267
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
3268 3269 3270 3271 3272 3273 3274
 *
 * 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 已提交
3275
static void iwl3945_setup_rx_handlers(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3276
{
C
Christoph Hellwig 已提交
3277 3278 3279 3280
	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 已提交
3281
	priv->rx_handlers[SPECTRUM_MEASURE_NOTIFICATION] =
C
Christoph Hellwig 已提交
3282 3283
	    iwl3945_rx_spectrum_measure_notif;
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl3945_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
3284
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
C
Christoph Hellwig 已提交
3285 3286
	    iwl3945_rx_pm_debug_statistics_notif;
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
3287

3288 3289 3290 3291
	/*
	 * 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 已提交
3292
	 */
C
Christoph Hellwig 已提交
3293 3294
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
3295

C
Christoph Hellwig 已提交
3296 3297
	priv->rx_handlers[REPLY_SCAN_CMD] = iwl3945_rx_reply_scan;
	priv->rx_handlers[SCAN_START_NOTIFICATION] = iwl3945_rx_scan_start_notif;
Z
Zhu Yi 已提交
3298
	priv->rx_handlers[SCAN_RESULTS_NOTIFICATION] =
C
Christoph Hellwig 已提交
3299
	    iwl3945_rx_scan_results_notif;
Z
Zhu Yi 已提交
3300
	priv->rx_handlers[SCAN_COMPLETE_NOTIFICATION] =
C
Christoph Hellwig 已提交
3301 3302
	    iwl3945_rx_scan_complete_notif;
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
3303

3304
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
3305
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
3306 3307
}

3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339
/**
 * iwl3945_cmd_queue_reclaim - Reclaim CMD queue entries
 * When FW advances 'R' index, all entries between old and new 'R' index
 * need to be reclaimed.
 */
static void iwl3945_cmd_queue_reclaim(struct iwl3945_priv *priv,
				      int txq_id, int index)
{
	struct iwl3945_tx_queue *txq = &priv->txq[txq_id];
	struct iwl3945_queue *q = &txq->q;
	int nfreed = 0;

	if ((index >= q->n_bd) || (iwl3945_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,
			  index, q->n_bd, q->write_ptr, q->read_ptr);
		return;
	}

	for (index = iwl_queue_inc_wrap(index, q->n_bd); q->read_ptr != index;
		q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd)) {
		if (nfreed > 1) {
			IWL_ERROR("HCMD skipped: index (%d) %d %d\n", index,
					q->write_ptr, q->read_ptr);
			queue_work(priv->workqueue, &priv->restart);
			break;
		}
		nfreed++;
	}
}


Z
Zhu Yi 已提交
3340
/**
C
Christoph Hellwig 已提交
3341
 * iwl3945_tx_cmd_complete - Pull unused buffers off the queue and reclaim them
Z
Zhu Yi 已提交
3342 3343 3344 3345 3346 3347
 * @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 已提交
3348 3349
static void iwl3945_tx_cmd_complete(struct iwl3945_priv *priv,
				struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3350
{
C
Christoph Hellwig 已提交
3351
	struct iwl3945_rx_packet *pkt = (struct iwl3945_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
3352 3353 3354 3355 3356
	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 已提交
3357
	struct iwl3945_cmd *cmd;
Z
Zhu Yi 已提交
3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371

	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;

3372
	iwl3945_cmd_queue_reclaim(priv, txq_id, index);
Z
Zhu Yi 已提交
3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401

	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.
 *
3402
 * During initialization, the host sets up the READ queue position to the first
Z
Zhu Yi 已提交
3403 3404
 * INDEX position, and WRITE to the last (READ - 1 wrapped)
 *
3405
 * When the firmware places a packet in a buffer, it will advance the READ index
Z
Zhu Yi 已提交
3406 3407 3408 3409 3410 3411 3412
 * 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
3413
 *   to replenish the iwl->rxq->rx_free.
C
Christoph Hellwig 已提交
3414
 * + In iwl3945_rx_replenish (scheduled) if 'processed' != 'read' then the
Z
Zhu Yi 已提交
3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426
 *   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:
 *
3427 3428
 * iwl3945_rx_queue_alloc()   Allocates rx_free
 * iwl3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
C
Christoph Hellwig 已提交
3429
 *                            iwl3945_rx_queue_restock
3430
 * iwl3945_rx_queue_restock() Moves available buffers from rx_free into Rx
Z
Zhu Yi 已提交
3431 3432
 *                            queue, updates firmware pointers, and updates
 *                            the WRITE index.  If insufficient rx_free buffers
C
Christoph Hellwig 已提交
3433
 *                            are available, schedules iwl3945_rx_replenish
Z
Zhu Yi 已提交
3434 3435
 *
 * -- enable interrupts --
3436
 * ISR - iwl3945_rx()         Detach iwl3945_rx_mem_buffers from pool up to the
Z
Zhu Yi 已提交
3437 3438
 *                            READ INDEX, detaching the SKB from the pool.
 *                            Moves the packet buffer from queue to rx_used.
C
Christoph Hellwig 已提交
3439
 *                            Calls iwl3945_rx_queue_restock to refill any empty
Z
Zhu Yi 已提交
3440 3441 3442 3443 3444 3445
 *                            slots.
 * ...
 *
 */

/**
C
Christoph Hellwig 已提交
3446
 * iwl3945_rx_queue_space - Return number of free slots available in queue.
Z
Zhu Yi 已提交
3447
 */
C
Christoph Hellwig 已提交
3448
static int iwl3945_rx_queue_space(const struct iwl3945_rx_queue *q)
Z
Zhu Yi 已提交
3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460
{
	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 已提交
3461
 * iwl3945_rx_queue_update_write_ptr - Update the write pointer for the RX queue
Z
Zhu Yi 已提交
3462
 */
C
Christoph Hellwig 已提交
3463
int iwl3945_rx_queue_update_write_ptr(struct iwl3945_priv *priv, struct iwl3945_rx_queue *q)
Z
Zhu Yi 已提交
3464 3465 3466 3467 3468 3469 3470 3471 3472 3473
{
	u32 reg = 0;
	int rc = 0;
	unsigned long flags;

	spin_lock_irqsave(&q->lock, flags);

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

3474
	/* If power-saving is in use, make sure device is awake */
Z
Zhu Yi 已提交
3475
	if (test_bit(STATUS_POWER_PMI, &priv->status)) {
C
Christoph Hellwig 已提交
3476
		reg = iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
Z
Zhu Yi 已提交
3477 3478

		if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
C
Christoph Hellwig 已提交
3479
			iwl3945_set_bit(priv, CSR_GP_CNTRL,
Z
Zhu Yi 已提交
3480 3481 3482 3483
				    CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
			goto exit_unlock;
		}

C
Christoph Hellwig 已提交
3484
		rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
3485 3486 3487
		if (rc)
			goto exit_unlock;

3488
		/* Device expects a multiple of 8 */
C
Christoph Hellwig 已提交
3489
		iwl3945_write_direct32(priv, FH_RSCSR_CHNL0_WPTR,
Z
Zhu Yi 已提交
3490
				     q->write & ~0x7);
C
Christoph Hellwig 已提交
3491
		iwl3945_release_nic_access(priv);
3492 3493

	/* Else device is assumed to be awake */
Z
Zhu Yi 已提交
3494
	} else
3495
		/* Device expects a multiple of 8 */
C
Christoph Hellwig 已提交
3496
		iwl3945_write32(priv, FH_RSCSR_CHNL0_WPTR, q->write & ~0x7);
Z
Zhu Yi 已提交
3497 3498 3499 3500 3501 3502 3503 3504 3505 3506


	q->need_update = 0;

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

/**
3507
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
3508
 */
C
Christoph Hellwig 已提交
3509
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
3510 3511 3512 3513 3514 3515
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

/**
C
Christoph Hellwig 已提交
3516
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
3517
 *
3518
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
3519
 * and we have free pre-allocated buffers, fill the ranks as much
3520
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
3521 3522 3523 3524 3525
 *
 * 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 已提交
3526
static int iwl3945_rx_queue_restock(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3527
{
C
Christoph Hellwig 已提交
3528
	struct iwl3945_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3529
	struct list_head *element;
C
Christoph Hellwig 已提交
3530
	struct iwl3945_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
3531 3532 3533 3534 3535
	unsigned long flags;
	int write, rc;

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
C
Christoph Hellwig 已提交
3536
	while ((iwl3945_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
3537
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
3538
		element = rxq->rx_free.next;
C
Christoph Hellwig 已提交
3539
		rxb = list_entry(element, struct iwl3945_rx_mem_buffer, list);
Z
Zhu Yi 已提交
3540
		list_del(element);
3541 3542

		/* Point to Rx buffer via next RBD in circular buffer */
C
Christoph Hellwig 已提交
3543
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->dma_addr);
Z
Zhu Yi 已提交
3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554
		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);


3555 3556
	/* 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 已提交
3557 3558 3559 3560 3561
	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 已提交
3562
		rc = iwl3945_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
3563 3564 3565 3566 3567 3568 3569 3570
		if (rc)
			return rc;
	}

	return 0;
}

/**
C
Christoph Hellwig 已提交
3571
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
3572 3573 3574
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
3575
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
3576
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
3577
 */
3578
static void iwl3945_rx_allocate(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3579
{
C
Christoph Hellwig 已提交
3580
	struct iwl3945_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3581
	struct list_head *element;
C
Christoph Hellwig 已提交
3582
	struct iwl3945_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
3583 3584 3585 3586
	unsigned long flags;
	spin_lock_irqsave(&rxq->lock, flags);
	while (!list_empty(&rxq->rx_used)) {
		element = rxq->rx_used.next;
C
Christoph Hellwig 已提交
3587
		rxb = list_entry(element, struct iwl3945_rx_mem_buffer, list);
3588 3589

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600
		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 已提交
3601 3602 3603 3604 3605 3606 3607 3608 3609

		/* 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 已提交
3610 3611
		priv->alloc_rxb_skb++;
		list_del(element);
3612 3613

		/* Get physical address of RB/SKB */
Z
Zhu Yi 已提交
3614 3615 3616 3617 3618 3619 3620
		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);
3621 3622 3623 3624 3625
}

/*
 * this should be called while priv->lock is locked
 */
3626
static void __iwl3945_rx_replenish(void *data)
3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640
{
	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 已提交
3641 3642

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
3643
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
3644 3645 3646 3647
	spin_unlock_irqrestore(&priv->lock, flags);
}

/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
3648
 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
Z
Zhu Yi 已提交
3649 3650 3651
 * 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 已提交
3652
static void iwl3945_rx_queue_free(struct iwl3945_priv *priv, struct iwl3945_rx_queue *rxq)
Z
Zhu Yi 已提交
3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668
{
	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 已提交
3669
int iwl3945_rx_queue_alloc(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3670
{
C
Christoph Hellwig 已提交
3671
	struct iwl3945_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3672 3673 3674 3675 3676 3677
	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);
3678 3679

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

Z
Zhu Yi 已提交
3684 3685 3686
	/* 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);
3687

Z
Zhu Yi 已提交
3688 3689 3690 3691 3692 3693 3694 3695
	/* 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 已提交
3696
void iwl3945_rx_queue_reset(struct iwl3945_priv *priv, struct iwl3945_rx_queue *rxq)
Z
Zhu Yi 已提交
3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742
{
	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 已提交
3743
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
3744
{
3745 3746
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
3747 3748
		return 60;

3749
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
3750
	 *   add 20 dB to make up for divide by 10 */
3751
	if (sig_ratio >= 100)
3752
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768

	/* 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 已提交
3769
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803
{
	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;
}

/**
3804
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
3805 3806 3807 3808 3809
 *
 * 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 已提交
3810
static void iwl3945_rx_handle(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3811
{
C
Christoph Hellwig 已提交
3812 3813 3814
	struct iwl3945_rx_mem_buffer *rxb;
	struct iwl3945_rx_packet *pkt;
	struct iwl3945_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3815 3816 3817
	u32 r, i;
	int reclaim;
	unsigned long flags;
3818
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
3819
	u32 count = 8;
Z
Zhu Yi 已提交
3820

3821 3822
	/* 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 已提交
3823
	r = iwl3945_hw_get_rx_read(priv);
Z
Zhu Yi 已提交
3824 3825
	i = rxq->read;

3826 3827
	if (iwl3945_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
		fill_rx = 1;
Z
Zhu Yi 已提交
3828 3829 3830 3831 3832 3833 3834
	/* 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];

3835
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
3836 3837 3838 3839 3840 3841 3842 3843 3844
		 * 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 已提交
3845
		pkt = (struct iwl3945_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858

		/* 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 已提交
3859
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873
		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) {
3874 3875
			/* Invoke any callbacks, transfer the skb to caller, and
			 * fire off the (possibly) blocking iwl3945_send_cmd()
Z
Zhu Yi 已提交
3876 3877
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
C
Christoph Hellwig 已提交
3878
				iwl3945_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897
			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;
3898 3899 3900 3901 3902 3903 3904 3905 3906 3907
		/* 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 已提交
3908 3909 3910 3911
	}

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

3915 3916 3917
/**
 * iwl3945_tx_queue_update_write_ptr - Send new write index to hardware
 */
C
Christoph Hellwig 已提交
3918 3919
static int iwl3945_tx_queue_update_write_ptr(struct iwl3945_priv *priv,
				  struct iwl3945_tx_queue *txq)
Z
Zhu Yi 已提交
3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932
{
	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 已提交
3933
		reg = iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
Z
Zhu Yi 已提交
3934 3935 3936

		if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
			IWL_DEBUG_INFO("Requesting wakeup, GP1 = 0x%x\n", reg);
C
Christoph Hellwig 已提交
3937
			iwl3945_set_bit(priv, CSR_GP_CNTRL,
Z
Zhu Yi 已提交
3938 3939 3940 3941 3942
				    CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
			return rc;
		}

		/* restore this queue's parameters in nic hardware. */
C
Christoph Hellwig 已提交
3943
		rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
3944 3945
		if (rc)
			return rc;
C
Christoph Hellwig 已提交
3946
		iwl3945_write_direct32(priv, HBUS_TARG_WRPTR,
3947
				     txq->q.write_ptr | (txq_id << 8));
C
Christoph Hellwig 已提交
3948
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
3949 3950 3951 3952

	/* 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 已提交
3953
		iwl3945_write32(priv, HBUS_TARG_WRPTR,
3954
			    txq->q.write_ptr | (txq_id << 8));
Z
Zhu Yi 已提交
3955 3956 3957 3958 3959 3960

	txq->need_update = 0;

	return rc;
}

3961
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
3962
static void iwl3945_print_rx_config_cmd(struct iwl3945_rxon_cmd *rxon)
Z
Zhu Yi 已提交
3963 3964
{
	IWL_DEBUG_RADIO("RX CONFIG:\n");
C
Christoph Hellwig 已提交
3965
	iwl3945_print_hex_dump(IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
Z
Zhu Yi 已提交
3966 3967 3968 3969 3970 3971 3972 3973
	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);
J
Johannes Berg 已提交
3974 3975
	IWL_DEBUG_RADIO("u8[6] node_addr: %pM\n", rxon->node_addr);
	IWL_DEBUG_RADIO("u8[6] bssid_addr: %pM\n", rxon->bssid_addr);
Z
Zhu Yi 已提交
3976 3977 3978 3979
	IWL_DEBUG_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
}
#endif

C
Christoph Hellwig 已提交
3980
static void iwl3945_enable_interrupts(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3981 3982 3983
{
	IWL_DEBUG_ISR("Enabling interrupts\n");
	set_bit(STATUS_INT_ENABLED, &priv->status);
C
Christoph Hellwig 已提交
3984
	iwl3945_write32(priv, CSR_INT_MASK, CSR_INI_SET_MASK);
Z
Zhu Yi 已提交
3985 3986
}

3987 3988 3989 3990

/* call this function to flush any scheduled tasklet */
static inline void iwl_synchronize_irq(struct iwl3945_priv *priv)
{
T
Tomas Winkler 已提交
3991
	/* wait to make sure we flush pending tasklet*/
3992 3993 3994 3995 3996
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}


C
Christoph Hellwig 已提交
3997
static inline void iwl3945_disable_interrupts(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3998 3999 4000 4001
{
	clear_bit(STATUS_INT_ENABLED, &priv->status);

	/* disable interrupts from uCode/NIC to host */
C
Christoph Hellwig 已提交
4002
	iwl3945_write32(priv, CSR_INT_MASK, 0x00000000);
Z
Zhu Yi 已提交
4003 4004 4005

	/* acknowledge/clear/reset any interrupts still pending
	 * from uCode or flow handler (Rx/Tx DMA) */
C
Christoph Hellwig 已提交
4006 4007
	iwl3945_write32(priv, CSR_INT, 0xffffffff);
	iwl3945_write32(priv, CSR_FH_INT_STATUS, 0xffffffff);
Z
Zhu Yi 已提交
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
	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 已提交
4034
static void iwl3945_dump_nic_error_log(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4035 4036 4037 4038 4039 4040 4041 4042
{
	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 已提交
4043
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
Z
Zhu Yi 已提交
4044 4045 4046 4047
		IWL_ERROR("Not valid error log pointer 0x%08X\n", base);
		return;
	}

C
Christoph Hellwig 已提交
4048
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
4049 4050 4051 4052 4053
	if (rc) {
		IWL_WARNING("Can not read from adapter at this time.\n");
		return;
	}

C
Christoph Hellwig 已提交
4054
	count = iwl3945_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
4055 4056 4057

	if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
		IWL_ERROR("Start IWL Error Log Dump:\n");
4058
		IWL_ERROR("Status: 0x%08lX, count: %d\n", priv->status, count);
Z
Zhu Yi 已提交
4059 4060 4061 4062 4063 4064 4065
	}

	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 已提交
4066
		desc = iwl3945_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
4067
		time =
C
Christoph Hellwig 已提交
4068
		    iwl3945_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
4069
		blink1 =
C
Christoph Hellwig 已提交
4070
		    iwl3945_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
4071
		blink2 =
C
Christoph Hellwig 已提交
4072
		    iwl3945_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
4073
		ilink1 =
C
Christoph Hellwig 已提交
4074
		    iwl3945_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
4075
		ilink2 =
C
Christoph Hellwig 已提交
4076
		    iwl3945_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
4077
		data1 =
C
Christoph Hellwig 已提交
4078
		    iwl3945_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
4079 4080 4081 4082 4083 4084 4085

		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 已提交
4086
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4087 4088 4089

}

4090
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
4091 4092

/**
C
Christoph Hellwig 已提交
4093
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
4094
 *
C
Christoph Hellwig 已提交
4095
 * NOTE: Must be called with iwl3945_grab_nic_access() already obtained!
Z
Zhu Yi 已提交
4096
 */
C
Christoph Hellwig 已提交
4097
static void iwl3945_print_event_log(struct iwl3945_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120
				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 已提交
4121
		ev = iwl3945_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
4122
		ptr += sizeof(u32);
C
Christoph Hellwig 已提交
4123
		time = iwl3945_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
4124 4125 4126 4127
		ptr += sizeof(u32);
		if (mode == 0)
			IWL_ERROR("0x%08x\t%04u\n", time, ev); /* data, ev */
		else {
C
Christoph Hellwig 已提交
4128
			data = iwl3945_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
4129 4130 4131 4132 4133 4134
			ptr += sizeof(u32);
			IWL_ERROR("%010u\t0x%08x\t%04u\n", time, data, ev);
		}
	}
}

C
Christoph Hellwig 已提交
4135
static void iwl3945_dump_nic_event_log(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4136 4137 4138 4139 4140 4141 4142 4143 4144 4145
{
	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 已提交
4146
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
Z
Zhu Yi 已提交
4147 4148 4149 4150
		IWL_ERROR("Invalid event log pointer 0x%08X\n", base);
		return;
	}

C
Christoph Hellwig 已提交
4151
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
4152 4153 4154 4155 4156 4157
	if (rc) {
		IWL_WARNING("Can not read from adapter at this time.\n");
		return;
	}

	/* event log header */
C
Christoph Hellwig 已提交
4158 4159 4160 4161
	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 已提交
4162 4163 4164 4165 4166

	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
4167
		IWL_ERROR("Start IWL Event Log Dump: nothing in log\n");
C
Christoph Hellwig 已提交
4168
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4169 4170 4171
		return;
	}

4172
	IWL_ERROR("Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
4173 4174 4175 4176 4177
		  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 已提交
4178
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
4179 4180 4181
				    capacity - next_entry, mode);

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

C
Christoph Hellwig 已提交
4184
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4185 4186 4187
}

/**
C
Christoph Hellwig 已提交
4188
 * iwl3945_irq_handle_error - called for HW or SW error interrupt from card
Z
Zhu Yi 已提交
4189
 */
C
Christoph Hellwig 已提交
4190
static void iwl3945_irq_handle_error(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4191
{
C
Christoph Hellwig 已提交
4192
	/* Set the FW error flag -- cleared on iwl3945_down */
Z
Zhu Yi 已提交
4193 4194 4195 4196 4197
	set_bit(STATUS_FW_ERROR, &priv->status);

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

4198
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
4199 4200 4201 4202
	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 已提交
4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215
	}
#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 已提交
4216
		if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
4217 4218 4219 4220 4221 4222 4223 4224
			memcpy(&priv->recovery_rxon, &priv->active_rxon,
			       sizeof(priv->recovery_rxon));
			priv->error_recovering = 1;
		}
		queue_work(priv->workqueue, &priv->restart);
	}
}

C
Christoph Hellwig 已提交
4225
static void iwl3945_error_recovery(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4226 4227 4228 4229 4230 4231
{
	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 已提交
4232
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
4233

C
Christoph Hellwig 已提交
4234
	iwl3945_add_station(priv, priv->bssid, 1, 0);
Z
Zhu Yi 已提交
4235 4236 4237 4238 4239 4240 4241

	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 已提交
4242
static void iwl3945_irq_tasklet(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4243 4244 4245 4246
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
4247
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
4248 4249 4250 4251 4252 4253 4254 4255
	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 已提交
4256 4257
	inta = iwl3945_read32(priv, CSR_INT);
	iwl3945_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
4258 4259 4260 4261

	/* 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 已提交
4262 4263
	inta_fh = iwl3945_read32(priv, CSR_FH_INT_STATUS);
	iwl3945_write32(priv, CSR_FH_INT_STATUS, inta_fh);
Z
Zhu Yi 已提交
4264

4265
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
4266
	if (iwl3945_debug_level & IWL_DL_ISR) {
4267 4268
		/* just for debug */
		inta_mask = iwl3945_read32(priv, CSR_INT_MASK);
Z
Zhu Yi 已提交
4269 4270 4271 4272 4273 4274 4275 4276 4277
		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 已提交
4278
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
4279
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
4280
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
4281 4282 4283 4284 4285 4286 4287
		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 已提交
4288
		iwl3945_disable_interrupts(priv);
Z
Zhu Yi 已提交
4289

C
Christoph Hellwig 已提交
4290
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
4291 4292 4293 4294 4295 4296 4297 4298

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

4299
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
4300
	if (iwl3945_debug_level & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
4301
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
4302 4303 4304
		if (inta & CSR_INT_BIT_SCD)
			IWL_DEBUG_ISR("Scheduler finished to transmit "
				      "the frame/frames.\n");
Z
Zhu Yi 已提交
4305 4306 4307 4308 4309 4310 4311

		/* 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 */
4312
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
4313 4314 4315 4316 4317

	/* 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 已提交
4318
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
4319 4320 4321 4322 4323 4324
		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 已提交
4325 4326 4327 4328 4329 4330 4331
		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 已提交
4332 4333 4334 4335 4336 4337 4338 4339

		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 已提交
4340
		iwl3945_rx_handle(priv);
Z
Zhu Yi 已提交
4341 4342 4343 4344 4345 4346
		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 已提交
4347 4348 4349
		iwl3945_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
		if (!iwl3945_grab_nic_access(priv)) {
			iwl3945_write_direct32(priv,
Z
Zhu Yi 已提交
4350 4351
					     FH_TCSR_CREDIT
					     (ALM_FH_SRVC_CHNL), 0x0);
C
Christoph Hellwig 已提交
4352
			iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366
		}
		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 */
4367 4368 4369
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
		iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
4370

4371
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
4372 4373 4374 4375
	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 已提交
4376 4377 4378 4379 4380 4381 4382
		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 已提交
4383
static irqreturn_t iwl3945_isr(int irq, void *data)
Z
Zhu Yi 已提交
4384
{
C
Christoph Hellwig 已提交
4385
	struct iwl3945_priv *priv = data;
Z
Zhu Yi 已提交
4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396
	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 已提交
4397 4398
	inta_mask = iwl3945_read32(priv, CSR_INT_MASK);  /* just for debug */
	iwl3945_write32(priv, CSR_INT_MASK, 0x00000000);
Z
Zhu Yi 已提交
4399 4400

	/* Discover which interrupts are active/pending */
C
Christoph Hellwig 已提交
4401 4402
	inta = iwl3945_read32(priv, CSR_INT);
	inta_fh = iwl3945_read32(priv, CSR_FH_INT_STATUS);
Z
Zhu Yi 已提交
4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413

	/* 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 */
Z
Zhu Yi 已提交
4414
		IWL_WARNING("HARDWARE GONE?? INTA == 0x%08x\n", inta);
4415
		goto unplugged;
Z
Zhu Yi 已提交
4416 4417 4418 4419 4420
	}

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

4421 4422
	inta &= ~CSR_INT_BIT_SCD;

C
Christoph Hellwig 已提交
4423
	/* iwl3945_irq_tasklet() will service interrupts and re-enable them */
4424 4425
	if (likely(inta || inta_fh))
		tasklet_schedule(&priv->irq_tasklet);
4426
unplugged:
Z
Zhu Yi 已提交
4427 4428 4429 4430 4431 4432
	spin_unlock(&priv->lock);

	return IRQ_HANDLED;

 none:
	/* re-enable interrupts here since we don't have anything to service. */
4433 4434 4435
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
		iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
4436 4437 4438 4439 4440 4441
	spin_unlock(&priv->lock);
	return IRQ_NONE;
}

/************************** EEPROM BANDS ****************************
 *
C
Christoph Hellwig 已提交
4442
 * The iwl3945_eeprom_band definitions below provide the mapping from the
Z
Zhu Yi 已提交
4443 4444 4445
 * EEPROM contents to the specific channel number supported for each
 * band.
 *
C
Christoph Hellwig 已提交
4446
 * For example, iwl3945_priv->eeprom.band_3_channels[4] from the band_3
Z
Zhu Yi 已提交
4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471
 * 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 已提交
4472
static const u8 iwl3945_eeprom_band_1[14] = {
Z
Zhu Yi 已提交
4473 4474 4475 4476
	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
};

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

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

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

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

C
Christoph Hellwig 已提交
4493
static void iwl3945_init_band_reference(const struct iwl3945_priv *priv, int band,
Z
Zhu Yi 已提交
4494
				    int *eeprom_ch_count,
C
Christoph Hellwig 已提交
4495
				    const struct iwl3945_eeprom_channel
Z
Zhu Yi 已提交
4496 4497 4498 4499 4500
				    **eeprom_ch_info,
				    const u8 **eeprom_ch_index)
{
	switch (band) {
	case 1:		/* 2.4GHz band */
C
Christoph Hellwig 已提交
4501
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_1);
Z
Zhu Yi 已提交
4502
		*eeprom_ch_info = priv->eeprom.band_1_channels;
C
Christoph Hellwig 已提交
4503
		*eeprom_ch_index = iwl3945_eeprom_band_1;
Z
Zhu Yi 已提交
4504
		break;
4505
	case 2:		/* 4.9GHz band */
C
Christoph Hellwig 已提交
4506
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_2);
Z
Zhu Yi 已提交
4507
		*eeprom_ch_info = priv->eeprom.band_2_channels;
C
Christoph Hellwig 已提交
4508
		*eeprom_ch_index = iwl3945_eeprom_band_2;
Z
Zhu Yi 已提交
4509 4510
		break;
	case 3:		/* 5.2GHz band */
C
Christoph Hellwig 已提交
4511
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_3);
Z
Zhu Yi 已提交
4512
		*eeprom_ch_info = priv->eeprom.band_3_channels;
C
Christoph Hellwig 已提交
4513
		*eeprom_ch_index = iwl3945_eeprom_band_3;
Z
Zhu Yi 已提交
4514
		break;
4515
	case 4:		/* 5.5GHz band */
C
Christoph Hellwig 已提交
4516
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_4);
Z
Zhu Yi 已提交
4517
		*eeprom_ch_info = priv->eeprom.band_4_channels;
C
Christoph Hellwig 已提交
4518
		*eeprom_ch_index = iwl3945_eeprom_band_4;
Z
Zhu Yi 已提交
4519
		break;
4520
	case 5:		/* 5.7GHz band */
C
Christoph Hellwig 已提交
4521
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_5);
Z
Zhu Yi 已提交
4522
		*eeprom_ch_info = priv->eeprom.band_5_channels;
C
Christoph Hellwig 已提交
4523
		*eeprom_ch_index = iwl3945_eeprom_band_5;
Z
Zhu Yi 已提交
4524 4525 4526 4527 4528 4529 4530
		break;
	default:
		BUG();
		return;
	}
}

4531 4532 4533 4534 4535
/**
 * iwl3945_get_channel_info - Find driver's private channel info
 *
 * Based on band and channel number.
 */
C
Christoph Hellwig 已提交
4536
const struct iwl3945_channel_info *iwl3945_get_channel_info(const struct iwl3945_priv *priv,
4537
						    enum ieee80211_band band, u16 channel)
Z
Zhu Yi 已提交
4538 4539 4540
{
	int i;

4541 4542
	switch (band) {
	case IEEE80211_BAND_5GHZ:
Z
Zhu Yi 已提交
4543 4544 4545 4546 4547 4548
		for (i = 14; i < priv->channel_count; i++) {
			if (priv->channel_info[i].channel == channel)
				return &priv->channel_info[i];
		}
		break;

4549
	case IEEE80211_BAND_2GHZ:
Z
Zhu Yi 已提交
4550 4551 4552
		if (channel >= 1 && channel <= 14)
			return &priv->channel_info[channel - 1];
		break;
4553 4554
	case IEEE80211_NUM_BANDS:
		WARN_ON(1);
Z
Zhu Yi 已提交
4555 4556 4557 4558 4559 4560 4561 4562
	}

	return NULL;
}

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

4563 4564 4565
/**
 * iwl3945_init_channel_map - Set up driver's info for all possible channels
 */
C
Christoph Hellwig 已提交
4566
static int iwl3945_init_channel_map(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4567 4568 4569
{
	int eeprom_ch_count = 0;
	const u8 *eeprom_ch_index = NULL;
C
Christoph Hellwig 已提交
4570
	const struct iwl3945_eeprom_channel *eeprom_ch_info = NULL;
Z
Zhu Yi 已提交
4571
	int band, ch;
C
Christoph Hellwig 已提交
4572
	struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587

	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 已提交
4588 4589 4590 4591 4592
	    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 已提交
4593 4594 4595

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

C
Christoph Hellwig 已提交
4596
	priv->channel_info = kzalloc(sizeof(struct iwl3945_channel_info) *
Z
Zhu Yi 已提交
4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610
				     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 已提交
4611
		iwl3945_init_band_reference(priv, band, &eeprom_ch_count,
Z
Zhu Yi 已提交
4612 4613 4614 4615 4616
					&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];
4617 4618
			ch_info->band = (band == 1) ? IEEE80211_BAND_2GHZ :
			    IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644

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

4645
			IWL_DEBUG_INFO("Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x"
Z
Zhu Yi 已提交
4646 4647 4648 4649
				       " %ddBm): Ad-Hoc %ssupported\n",
				       ch_info->channel,
				       is_channel_a_band(ch_info) ?
				       "5.2" : "2.4",
4650
				       CHECK_AND_PRINT(VALID),
Z
Zhu Yi 已提交
4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674
				       CHECK_AND_PRINT(IBSS),
				       CHECK_AND_PRINT(ACTIVE),
				       CHECK_AND_PRINT(RADAR),
				       CHECK_AND_PRINT(WIDE),
				       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++;
		}
	}

4675
	/* Set up txpower settings in driver for all channels */
Z
Zhu Yi 已提交
4676 4677 4678 4679 4680 4681
	if (iwl3945_txpower_set_from_eeprom(priv))
		return -EIO;

	return 0;
}

4682 4683 4684 4685 4686 4687 4688 4689 4690
/*
 * 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 已提交
4691 4692 4693
/* 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.  */
4694 4695 4696 4697 4698
#define IWL_ACTIVE_DWELL_TIME_24    (30)	/* all times in msec */
#define IWL_ACTIVE_DWELL_TIME_52    (20)

#define IWL_ACTIVE_DWELL_FACTOR_24GHZ (3)
#define IWL_ACTIVE_DWELL_FACTOR_52GHZ (2)
Z
Zhu Yi 已提交
4699 4700 4701 4702 4703 4704 4705 4706

/* 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 */
4707
#define IWL_ACTIVE_QUIET_TIME       __constant_cpu_to_le16(10)	/* msec */
Z
Zhu Yi 已提交
4708 4709 4710 4711 4712 4713 4714 4715 4716

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

K
Kolekar, Abhijeet 已提交
4717
#define IWL_SCAN_PROBE_MASK(n)	 (BIT(n) | (BIT(n) - BIT(1)))
4718

4719
static inline u16 iwl3945_get_active_dwell_time(struct iwl3945_priv *priv,
4720 4721
						enum ieee80211_band band,
						u8 n_probes)
Z
Zhu Yi 已提交
4722
{
4723
	if (band == IEEE80211_BAND_5GHZ)
4724 4725
		return IWL_ACTIVE_DWELL_TIME_52 +
			IWL_ACTIVE_DWELL_FACTOR_52GHZ * (n_probes + 1);
Z
Zhu Yi 已提交
4726
	else
4727 4728
		return IWL_ACTIVE_DWELL_TIME_24 +
			IWL_ACTIVE_DWELL_FACTOR_24GHZ * (n_probes + 1);
Z
Zhu Yi 已提交
4729 4730
}

4731 4732
static u16 iwl3945_get_passive_dwell_time(struct iwl3945_priv *priv,
					  enum ieee80211_band band)
Z
Zhu Yi 已提交
4733
{
4734
	u16 passive = (band == IEEE80211_BAND_2GHZ) ?
Z
Zhu Yi 已提交
4735 4736 4737
	    IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_24 :
	    IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_52;

C
Christoph Hellwig 已提交
4738
	if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750
		/* 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;
	}

	return passive;
}

4751 4752
static int iwl3945_get_channels_for_scan(struct iwl3945_priv *priv,
					 enum ieee80211_band band,
4753
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
4754
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
4755 4756
{
	const struct ieee80211_channel *channels = NULL;
4757
	const struct ieee80211_supported_band *sband;
C
Christoph Hellwig 已提交
4758
	const struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
4759 4760 4761 4762
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

4763 4764
	sband = iwl3945_get_band(priv, band);
	if (!sband)
Z
Zhu Yi 已提交
4765 4766
		return 0;

4767
	channels = sband->channels;
Z
Zhu Yi 已提交
4768

4769
	active_dwell = iwl3945_get_active_dwell_time(priv, band, n_probes);
4770
	passive_dwell = iwl3945_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
4771

4772 4773 4774
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

4775
	for (i = 0, added = 0; i < sband->n_channels; i++) {
4776 4777 4778
		if (channels[i].flags & IEEE80211_CHAN_DISABLED)
			continue;

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

4781
		ch_info = iwl3945_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
4782
		if (!is_channel_valid(ch_info)) {
4783
			IWL_DEBUG_SCAN("Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
4784 4785 4786 4787
				       scan_ch->channel);
			continue;
		}

4788 4789 4790 4791 4792
		scan_ch->active_dwell = cpu_to_le16(active_dwell);
		scan_ch->passive_dwell = cpu_to_le16(passive_dwell);
		/* If passive , set up for auto-switch
		 *  and use long active_dwell time.
		 */
Z
Zhu Yi 已提交
4793
		if (!is_active || is_channel_passive(ch_info) ||
4794
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
4795
			scan_ch->type = 0;	/* passive */
4796 4797 4798
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
4799
			scan_ch->type = 1;	/* active */
4800
		}
Z
Zhu Yi 已提交
4801

4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814
		/* Set direct probe bits. These may be used both for active
		 * scan channels (probes gets sent right away),
		 * or for passive channels (probes get se sent only after
		 * hearing clear Rx packet).*/
		if (IWL_UCODE_API(priv->ucode_ver) >= 2) {
			if (n_probes)
				scan_ch->type |= IWL_SCAN_PROBE_MASK(n_probes);
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
				scan_ch->type |= IWL_SCAN_PROBE_MASK(n_probes);
		}
Z
Zhu Yi 已提交
4815

4816
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
4817 4818 4819 4820
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
4821
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
4822 4823 4824 4825
			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
4826
			 * power level:
4827
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844
			 */
		}

		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 已提交
4845
static void iwl3945_init_hw_rates(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
4846 4847 4848 4849 4850
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
4851 4852 4853 4854 4855
		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 已提交
4856
			/*
4857
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
4858
			 */
C
Christoph Hellwig 已提交
4859
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
4860
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
4861 4862 4863 4864 4865
		}
	}
}

/**
C
Christoph Hellwig 已提交
4866
 * iwl3945_init_geos - Initialize mac80211's geo/channel info based from eeprom
Z
Zhu Yi 已提交
4867
 */
C
Christoph Hellwig 已提交
4868
static int iwl3945_init_geos(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4869
{
C
Christoph Hellwig 已提交
4870
	struct iwl3945_channel_info *ch;
4871
	struct ieee80211_supported_band *sband;
Z
Zhu Yi 已提交
4872 4873 4874 4875 4876
	struct ieee80211_channel *channels;
	struct ieee80211_channel *geo_ch;
	struct ieee80211_rate *rates;
	int i = 0;

4877 4878
	if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
	    priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
Z
Zhu Yi 已提交
4879 4880 4881 4882 4883 4884 4885
		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);
4886
	if (!channels)
Z
Zhu Yi 已提交
4887 4888
		return -ENOMEM;

4889
	rates = kzalloc((sizeof(struct ieee80211_rate) * (IWL_RATE_COUNT + 1)),
Z
Zhu Yi 已提交
4890 4891 4892 4893 4894 4895 4896
			GFP_KERNEL);
	if (!rates) {
		kfree(channels);
		return -ENOMEM;
	}

	/* 5.2GHz channels start after the 2.4GHz channels */
4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907
	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 已提交
4908 4909 4910 4911

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

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

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

4917 4918
		/* FIXME: might be removed if scan is OK*/
		if (!is_channel_valid(ch))
Z
Zhu Yi 已提交
4919 4920 4921
			continue;

		if (is_channel_a_band(ch))
4922
			sband =  &priv->bands[IEEE80211_BAND_5GHZ];
4923
		else
4924
			sband =  &priv->bands[IEEE80211_BAND_2GHZ];
Z
Zhu Yi 已提交
4925

4926 4927 4928
		geo_ch = &sband->channels[sband->n_channels++];

		geo_ch->center_freq = ieee80211_channel_to_frequency(ch->channel);
4929 4930
		geo_ch->max_power = ch->max_power_avg;
		geo_ch->max_antenna_gain = 0xff;
4931
		geo_ch->hw_value = ch->channel;
Z
Zhu Yi 已提交
4932 4933

		if (is_channel_valid(ch)) {
4934 4935
			if (!(ch->flags & EEPROM_CHANNEL_IBSS))
				geo_ch->flags |= IEEE80211_CHAN_NO_IBSS;
Z
Zhu Yi 已提交
4936

4937 4938
			if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
				geo_ch->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
Z
Zhu Yi 已提交
4939 4940

			if (ch->flags & EEPROM_CHANNEL_RADAR)
4941
				geo_ch->flags |= IEEE80211_CHAN_RADAR;
Z
Zhu Yi 已提交
4942 4943 4944 4945

			if (ch->max_power_avg > priv->max_channel_txpower_limit)
				priv->max_channel_txpower_limit =
				    ch->max_power_avg;
4946
		} else {
4947
			geo_ch->flags |= IEEE80211_CHAN_DISABLED;
4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958
		}

		/* 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 已提交
4959 4960
	}

T
Tomas Winkler 已提交
4961 4962
	if ((priv->bands[IEEE80211_BAND_5GHZ].n_channels == 0) &&
	     priv->cfg->sku & IWL_SKU_A) {
Z
Zhu Yi 已提交
4963 4964 4965 4966
		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 已提交
4967
		 priv->cfg->sku &= ~IWL_SKU_A;
Z
Zhu Yi 已提交
4968 4969 4970 4971
	}

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

4975 4976 4977 4978 4979 4980
	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
	if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&priv->bands[IEEE80211_BAND_5GHZ];
Z
Zhu Yi 已提交
4981 4982 4983 4984 4985 4986

	set_bit(STATUS_GEO_CONFIGURED, &priv->status);

	return 0;
}

4987 4988 4989 4990 4991 4992 4993 4994 4995 4996
/*
 * 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 已提交
4997 4998 4999 5000 5001 5002
/******************************************************************************
 *
 * uCode download functions
 *
 ******************************************************************************/

C
Christoph Hellwig 已提交
5003
static void iwl3945_dealloc_ucode_pci(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5004
{
5005 5006 5007 5008 5009 5010
	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 已提交
5011 5012 5013
}

/**
C
Christoph Hellwig 已提交
5014
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
5015 5016
 *     looking at all data.
 */
5017
static int iwl3945_verify_inst_full(struct iwl3945_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
5018 5019 5020 5021 5022 5023 5024 5025
{
	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 已提交
5026
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5027 5028 5029
	if (rc)
		return rc;

C
Christoph Hellwig 已提交
5030
	iwl3945_write_direct32(priv, HBUS_TARG_MEM_RADDR, RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
5031 5032 5033 5034 5035 5036

	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 已提交
5037
		val = _iwl3945_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048
		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 已提交
5049
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5050 5051

	if (!errcnt)
5052
		IWL_DEBUG_INFO("ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
5053 5054 5055 5056 5057 5058

	return rc;
}


/**
C
Christoph Hellwig 已提交
5059
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
5060 5061 5062
 *   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 已提交
5063
static int iwl3945_verify_inst_sparse(struct iwl3945_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
5064 5065 5066 5067 5068 5069 5070 5071
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

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

C
Christoph Hellwig 已提交
5072
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5073 5074 5075 5076 5077 5078 5079
	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 已提交
5080
		iwl3945_write_direct32(priv, HBUS_TARG_MEM_RADDR,
Z
Zhu Yi 已提交
5081
			i + RTC_INST_LOWER_BOUND);
C
Christoph Hellwig 已提交
5082
		val = _iwl3945_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095
		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 已提交
5096
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5097 5098 5099 5100 5101 5102

	return rc;
}


/**
C
Christoph Hellwig 已提交
5103
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
5104 5105
 *    and verify its contents
 */
C
Christoph Hellwig 已提交
5106
static int iwl3945_verify_ucode(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5107 5108 5109 5110 5111 5112 5113 5114
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
5115
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
5116 5117 5118 5119 5120 5121 5122 5123
	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 已提交
5124
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
5125 5126 5127 5128 5129 5130 5131 5132
	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 已提交
5133
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
5134 5135 5136 5137 5138 5139 5140
	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");

5141 5142 5143
	/* 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 已提交
5144 5145
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
5146
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
5147 5148 5149 5150 5151 5152

	return rc;
}


/* check contents of special bootstrap uCode SRAM */
C
Christoph Hellwig 已提交
5153
static int iwl3945_verify_bsm(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5154 5155 5156 5157 5158 5159 5160 5161 5162
{
	__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 已提交
5163
	val = iwl3945_read_prph(priv, BSM_WR_DWCOUNT_REG);
Z
Zhu Yi 已提交
5164 5165
	for (reg = BSM_SRAM_LOWER_BOUND;
	     reg < BSM_SRAM_LOWER_BOUND + len;
5166
	     reg += sizeof(u32), image++) {
C
Christoph Hellwig 已提交
5167
		val = iwl3945_read_prph(priv, reg);
Z
Zhu Yi 已提交
5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183
		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 已提交
5184
 * iwl3945_load_bsm - Load bootstrap instructions
Z
Zhu Yi 已提交
5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214
 *
 * 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 已提交
5215
static int iwl3945_load_bsm(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234
{
	__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
5235
	 *   in host DRAM ... host DRAM physical address bits 31:0 for 3945.
C
Christoph Hellwig 已提交
5236
	 * NOTE:  iwl3945_initialize_alive_start() will replace these values,
Z
Zhu Yi 已提交
5237 5238 5239 5240 5241 5242 5243
	 *        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 已提交
5244
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5245 5246 5247
	if (rc)
		return rc;

C
Christoph Hellwig 已提交
5248 5249 5250 5251
	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 已提交
5252 5253 5254 5255 5256

	/* 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 已提交
5257
		_iwl3945_write_prph(priv, reg_offset,
Z
Zhu Yi 已提交
5258 5259
					  le32_to_cpu(*image));

C
Christoph Hellwig 已提交
5260
	rc = iwl3945_verify_bsm(priv);
Z
Zhu Yi 已提交
5261
	if (rc) {
C
Christoph Hellwig 已提交
5262
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5263 5264 5265 5266
		return rc;
	}

	/* Tell BSM to copy from BSM SRAM into instruction SRAM, when asked */
C
Christoph Hellwig 已提交
5267 5268
	iwl3945_write_prph(priv, BSM_WR_MEM_SRC_REG, 0x0);
	iwl3945_write_prph(priv, BSM_WR_MEM_DST_REG,
Z
Zhu Yi 已提交
5269
				 RTC_INST_LOWER_BOUND);
C
Christoph Hellwig 已提交
5270
	iwl3945_write_prph(priv, BSM_WR_DWCOUNT_REG, len / sizeof(u32));
Z
Zhu Yi 已提交
5271 5272 5273

	/* Load bootstrap code into instruction SRAM now,
	 *   to prepare to load "initialize" uCode */
C
Christoph Hellwig 已提交
5274
	iwl3945_write_prph(priv, BSM_WR_CTRL_REG,
Z
Zhu Yi 已提交
5275 5276 5277 5278
		BSM_WR_CTRL_REG_BIT_START);

	/* Wait for load of bootstrap uCode to finish */
	for (i = 0; i < 100; i++) {
C
Christoph Hellwig 已提交
5279
		done = iwl3945_read_prph(priv, BSM_WR_CTRL_REG);
Z
Zhu Yi 已提交
5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292
		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 已提交
5293
	iwl3945_write_prph(priv, BSM_WR_CTRL_REG,
Z
Zhu Yi 已提交
5294 5295
		BSM_WR_CTRL_REG_BIT_START_EN);

C
Christoph Hellwig 已提交
5296
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5297 5298 5299 5300

	return 0;
}

C
Christoph Hellwig 已提交
5301
static void iwl3945_nic_start(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5302 5303
{
	/* Remove all resets to allow NIC to operate */
C
Christoph Hellwig 已提交
5304
	iwl3945_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
5305 5306 5307
}

/**
C
Christoph Hellwig 已提交
5308
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
5309 5310 5311
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
C
Christoph Hellwig 已提交
5312
static int iwl3945_read_ucode(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5313
{
C
Christoph Hellwig 已提交
5314
	struct iwl3945_ucode *ucode;
5315
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
5316 5317
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
5318 5319 5320 5321
	const char *name_pre = priv->cfg->fw_name_pre;
	const unsigned int api_max = priv->cfg->ucode_api_max;
	const unsigned int api_min = priv->cfg->ucode_api_min;
	char buf[25];
Z
Zhu Yi 已提交
5322 5323
	u8 *src;
	size_t len;
5324
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
5325 5326 5327

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345
	for (index = api_max; index >= api_min; index--) {
		sprintf(buf, "%s%u%s", name_pre, index, ".ucode");
		ret = request_firmware(&ucode_raw, buf, &priv->pci_dev->dev);
		if (ret < 0) {
			IWL_ERROR("%s firmware file req failed: Reason %d\n",
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
				IWL_ERROR("Loaded firmware %s, which is deprecated. Please use API v%u instead.\n",
					  buf, api_max);
			IWL_DEBUG_INFO("Got firmware '%s' file (%zd bytes) from disk\n",
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
5346 5347
	}

5348 5349
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
5350 5351 5352 5353

	/* Make sure that we got at least our header! */
	if (ucode_raw->size < sizeof(*ucode)) {
		IWL_ERROR("File size way too small!\n");
5354
		ret = -EINVAL;
Z
Zhu Yi 已提交
5355 5356 5357 5358 5359 5360
		goto err_release;
	}

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

5361
	priv->ucode_ver = le32_to_cpu(ucode->ver);
5362
	api_ver = IWL_UCODE_API(priv->ucode_ver);
Z
Zhu Yi 已提交
5363 5364 5365 5366 5367 5368
	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);

5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387
	/* api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
	 * on the API version read from firware header from here on forward */

	if (api_ver < api_min || api_ver > api_max) {
		IWL_ERROR("Driver unable to support your firmware API. "
			  "Driver supports v%u, firmware is v%u.\n",
			  api_max, api_ver);
		priv->ucode_ver = 0;
		ret = -EINVAL;
		goto err_release;
	}
	if (api_ver != api_max)
		IWL_ERROR("Firmware has old API version. Expected %u, "
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

	printk(KERN_INFO DRV_NAME " loaded firmware version %u.%u.%u.%u\n",
5388 5389 5390 5391
		       IWL_UCODE_MAJOR(priv->ucode_ver),
		       IWL_UCODE_MINOR(priv->ucode_ver),
		       IWL_UCODE_API(priv->ucode_ver),
		       IWL_UCODE_SERIAL(priv->ucode_ver));
5392 5393
	IWL_DEBUG_INFO("f/w package hdr ucode version raw = 0x%x\n",
		       priv->ucode_ver);
5394 5395 5396 5397 5398
	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 已提交
5399

5400

Z
Zhu Yi 已提交
5401 5402 5403 5404 5405 5406 5407
	/* 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);
5408
		ret = -EINVAL;
Z
Zhu Yi 已提交
5409 5410 5411 5412 5413
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
	if (inst_size > IWL_MAX_INST_SIZE) {
5414 5415 5416
		IWL_DEBUG_INFO("uCode instr len %d too large to fit in\n",
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
5417 5418 5419 5420
		goto err_release;
	}

	if (data_size > IWL_MAX_DATA_SIZE) {
5421 5422 5423
		IWL_DEBUG_INFO("uCode data len %d too large to fit in\n",
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
5424 5425 5426
		goto err_release;
	}
	if (init_size > IWL_MAX_INST_SIZE) {
5427 5428 5429
		IWL_DEBUG_INFO("uCode init instr len %d too large to fit in\n",
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
5430 5431 5432
		goto err_release;
	}
	if (init_data_size > IWL_MAX_DATA_SIZE) {
5433 5434 5435
		IWL_DEBUG_INFO("uCode init data len %d too large to fit in\n",
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
5436 5437 5438
		goto err_release;
	}
	if (boot_size > IWL_MAX_BSM_SIZE) {
5439 5440 5441
		IWL_DEBUG_INFO("uCode boot instr len %d too large to fit in\n",
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
5442 5443 5444 5445 5446 5447 5448 5449 5450
		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;
5451
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
5452 5453

	priv->ucode_data.len = data_size;
5454
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
5455 5456

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

5459 5460 5461
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
5462 5463

	/* Initialization instructions and data */
5464 5465
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
5466
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
5467 5468

		priv->ucode_init_data.len = init_data_size;
5469
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
5470 5471 5472 5473

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

	/* Bootstrap (instructions only, no data) */
5476 5477
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
5478
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
5479

5480 5481 5482
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
5483 5484 5485 5486 5487 5488

	/* 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;
5489
	IWL_DEBUG_INFO("Copying (but not loading) uCode instr len %Zd\n", len);
Z
Zhu Yi 已提交
5490 5491 5492 5493 5494
	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 已提交
5495
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
Z
Zhu Yi 已提交
5496 5497
	src = &ucode->data[inst_size];
	len = priv->ucode_data.len;
5498
	IWL_DEBUG_INFO("Copying (but not loading) uCode data len %Zd\n", len);
Z
Zhu Yi 已提交
5499 5500 5501 5502 5503 5504 5505
	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;
5506 5507
		IWL_DEBUG_INFO("Copying (but not loading) init instr len %Zd\n",
			       len);
Z
Zhu Yi 已提交
5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532
		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");
5533
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
5534
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
5535 5536 5537 5538 5539

 err_release:
	release_firmware(ucode_raw);

 error:
5540
	return ret;
Z
Zhu Yi 已提交
5541 5542 5543 5544
}


/**
C
Christoph Hellwig 已提交
5545
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
5546 5547 5548 5549 5550 5551 5552
 *
 * 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 已提交
5553
static int iwl3945_set_ucode_ptrs(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564
{
	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 已提交
5565
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5566 5567 5568 5569 5570 5571
	if (rc) {
		spin_unlock_irqrestore(&priv->lock, flags);
		return rc;
	}

	/* Tell bootstrap uCode where to find image to load */
C
Christoph Hellwig 已提交
5572 5573 5574
	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 已提交
5575 5576
				 priv->ucode_data.len);

T
Tomas Winkler 已提交
5577
	/* Inst byte count must be last to set up, bit 31 signals uCode
Z
Zhu Yi 已提交
5578
	 *   that all new ptr/size info is in place */
C
Christoph Hellwig 已提交
5579
	iwl3945_write_prph(priv, BSM_DRAM_INST_BYTECOUNT_REG,
Z
Zhu Yi 已提交
5580 5581
				 priv->ucode_code.len | BSM_DRAM_INST_LOAD);

C
Christoph Hellwig 已提交
5582
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5583 5584 5585 5586 5587 5588 5589 5590 5591

	spin_unlock_irqrestore(&priv->lock, flags);

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

	return rc;
}

/**
C
Christoph Hellwig 已提交
5592
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
5593 5594 5595 5596
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
5597
 */
C
Christoph Hellwig 已提交
5598
static void iwl3945_init_alive_start(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610
{
	/* 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 已提交
5611
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
5612 5613 5614 5615 5616 5617 5618 5619 5620 5621
		/* 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 已提交
5622
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634
		/* 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);
}


5635 5636 5637 5638
/* temporary */
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw,
				     struct sk_buff *skb);

Z
Zhu Yi 已提交
5639
/**
C
Christoph Hellwig 已提交
5640
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
5641
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
5642
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
5643
 */
C
Christoph Hellwig 已提交
5644
static void iwl3945_alive_start(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661
{
	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 已提交
5662
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
5663 5664 5665 5666 5667 5668
		/* 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 已提交
5669
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5670

C
Christoph Hellwig 已提交
5671
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5672
	if (rc) {
T
Tomas Winkler 已提交
5673
		IWL_WARNING("Can not read RFKILL status from adapter\n");
Z
Zhu Yi 已提交
5674 5675 5676
		return;
	}

C
Christoph Hellwig 已提交
5677
	rfkill = iwl3945_read_prph(priv, APMG_RFKILL_REG);
Z
Zhu Yi 已提交
5678
	IWL_DEBUG_INFO("RFKILL status: 0x%x\n", rfkill);
C
Christoph Hellwig 已提交
5679
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5680 5681 5682

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
5683
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
5684
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
5685
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
5686 5687 5688 5689 5690 5691 5692 5693 5694 5695
			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);

5696
	/* After the ALIVE response, we can send commands to 3945 uCode */
Z
Zhu Yi 已提交
5697 5698 5699 5700 5701
	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 已提交
5702
	if (iwl3945_is_rfkill(priv))
Z
Zhu Yi 已提交
5703 5704
		return;

5705
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
5706 5707 5708 5709

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

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

C
Christoph Hellwig 已提交
5712 5713 5714
	if (iwl3945_is_associated(priv)) {
		struct iwl3945_rxon_cmd *active_rxon =
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
5715 5716 5717 5718 5719 5720

		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 */
5721
		iwl3945_connection_init_rx_config(priv, priv->iw_mode);
Z
Zhu Yi 已提交
5722 5723 5724
		memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
	}

5725
	/* Configure Bluetooth device coexistence support */
C
Christoph Hellwig 已提交
5726
	iwl3945_send_bt_config(priv);
Z
Zhu Yi 已提交
5727 5728

	/* Configure the adapter for unassociated operation */
C
Christoph Hellwig 已提交
5729
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5730 5731 5732

	iwl3945_reg_txpower_periodic(priv);

5733 5734
	iwl3945_led_register(priv);

Z
Zhu Yi 已提交
5735
	IWL_DEBUG_INFO("ALIVE processing complete.\n");
5736
	set_bit(STATUS_READY, &priv->status);
5737
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
5738 5739

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

5742 5743 5744 5745 5746 5747 5748 5749
	/* reassociate for ADHOC mode */
	if (priv->vif && (priv->iw_mode == NL80211_IFTYPE_ADHOC)) {
		struct sk_buff *beacon = ieee80211_beacon_get(priv->hw,
								priv->vif);
		if (beacon)
			iwl3945_mac_beacon_update(priv->hw, beacon);
	}

Z
Zhu Yi 已提交
5750 5751 5752 5753 5754 5755
	return;

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

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

C
Christoph Hellwig 已提交
5758
static void __iwl3945_down(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770
{
	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);

M
Mohamed Abbas 已提交
5771
	iwl3945_led_unregister(priv);
C
Christoph Hellwig 已提交
5772
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5773 5774 5775 5776 5777 5778 5779 5780 5781 5782

	/* 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 已提交
5783
	iwl3945_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
Z
Zhu Yi 已提交
5784 5785

	/* tell the device to stop sending interrupts */
5786
	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
5787
	iwl3945_disable_interrupts(priv);
5788 5789
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
5790 5791 5792 5793

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

C
Christoph Hellwig 已提交
5794
	/* If we have not previously called iwl3945_init() then
Z
Zhu Yi 已提交
5795
	 * clear all bits but the RF Kill and SUSPEND bits and return */
C
Christoph Hellwig 已提交
5796
	if (!iwl3945_is_init(priv)) {
Z
Zhu Yi 已提交
5797 5798 5799 5800
		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 |
5801 5802
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
5803
			       test_bit(STATUS_IN_SUSPEND, &priv->status) <<
5804 5805 5806
					STATUS_IN_SUSPEND |
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
5807 5808 5809 5810 5811 5812 5813 5814 5815
		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 |
5816 5817
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
5818 5819 5820
			test_bit(STATUS_IN_SUSPEND, &priv->status) <<
				STATUS_IN_SUSPEND |
			test_bit(STATUS_FW_ERROR, &priv->status) <<
5821 5822 5823
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
5824 5825

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

C
Christoph Hellwig 已提交
5829 5830
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
5831 5832

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
5833 5834
	if (!iwl3945_grab_nic_access(priv)) {
		iwl3945_write_prph(priv, APMG_CLK_DIS_REG,
Z
Zhu Yi 已提交
5835
					 APMG_CLK_VAL_DMA_CLK_RQT);
C
Christoph Hellwig 已提交
5836
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5837 5838 5839 5840 5841
	}
	spin_unlock_irqrestore(&priv->lock, flags);

	udelay(5);

C
Christoph Hellwig 已提交
5842 5843 5844
	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 已提交
5845 5846

 exit:
C
Christoph Hellwig 已提交
5847
	memset(&priv->card_alive, 0, sizeof(struct iwl3945_alive_resp));
Z
Zhu Yi 已提交
5848 5849 5850 5851 5852 5853

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
5854
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
5855 5856
}

C
Christoph Hellwig 已提交
5857
static void iwl3945_down(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5858 5859
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5860
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
5861
	mutex_unlock(&priv->mutex);
5862

C
Christoph Hellwig 已提交
5863
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
5864 5865 5866 5867
}

#define MAX_HW_RESTARTS 5

C
Christoph Hellwig 已提交
5868
static int __iwl3945_up(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879
{
	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");
5880 5881 5882
		return -ENODEV;
	}

5883
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
T
Tomas Winkler 已提交
5884
		IWL_ERROR("ucode not available for device bring up\n");
5885 5886 5887
		return -EIO;
	}

5888 5889 5890 5891 5892 5893 5894 5895 5896 5897
	/* 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 已提交
5898
	}
5899

C
Christoph Hellwig 已提交
5900
	iwl3945_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
5901

C
Christoph Hellwig 已提交
5902
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
5903 5904 5905 5906 5907 5908
	if (rc) {
		IWL_ERROR("Unable to int nic\n");
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
C
Christoph Hellwig 已提交
5909 5910
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
5911 5912 5913
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
C
Christoph Hellwig 已提交
5914 5915
	iwl3945_write32(priv, CSR_INT, 0xFFFFFFFF);
	iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
5916 5917

	/* really make sure rfkill handshake bits are cleared */
C
Christoph Hellwig 已提交
5918 5919
	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 已提交
5920 5921 5922 5923 5924

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

5927 5928 5929 5930
	/* 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 已提交
5931 5932
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

C
Christoph Hellwig 已提交
5933
		iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5934 5935 5936 5937

		/* load bootstrap state machine,
		 * load bootstrap program into processor's memory,
		 * prepare to load the "initialize" uCode */
C
Christoph Hellwig 已提交
5938
		rc = iwl3945_load_bsm(priv);
Z
Zhu Yi 已提交
5939 5940 5941 5942 5943 5944 5945

		if (rc) {
			IWL_ERROR("Unable to set up bootstrap uCode: %d\n", rc);
			continue;
		}

		/* start card; "initialize" will load runtime ucode */
C
Christoph Hellwig 已提交
5946
		iwl3945_nic_start(priv);
Z
Zhu Yi 已提交
5947 5948 5949 5950 5951 5952 5953

		IWL_DEBUG_INFO(DRV_NAME " is coming up\n");

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
5954
	__iwl3945_down(priv);
5955
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969

	/* 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 已提交
5970
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
5971
{
C
Christoph Hellwig 已提交
5972 5973
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, init_alive_start.work);
Z
Zhu Yi 已提交
5974 5975 5976 5977 5978

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5979
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
5980 5981 5982
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5983
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
5984
{
C
Christoph Hellwig 已提交
5985 5986
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, alive_start.work);
Z
Zhu Yi 已提交
5987 5988 5989 5990 5991

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5992
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
5993 5994 5995
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5996
static void iwl3945_bg_rf_kill(struct work_struct *work)
Z
Zhu Yi 已提交
5997
{
C
Christoph Hellwig 已提交
5998
	struct iwl3945_priv *priv = container_of(work, struct iwl3945_priv, rf_kill);
Z
Zhu Yi 已提交
5999 6000 6001 6002 6003 6004 6005 6006

	wake_up_interruptible(&priv->wait_command_queue);

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

	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
6007
	if (!iwl3945_is_rfkill(priv)) {
Z
Zhu Yi 已提交
6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022
		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");
	}
6023

Z
Zhu Yi 已提交
6024
	mutex_unlock(&priv->mutex);
6025
	iwl3945_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
6026 6027 6028 6029
}

#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)

C
Christoph Hellwig 已提交
6030
static void iwl3945_bg_scan_check(struct work_struct *data)
Z
Zhu Yi 已提交
6031
{
C
Christoph Hellwig 已提交
6032 6033
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, scan_check.work);
Z
Zhu Yi 已提交
6034 6035 6036 6037 6038 6039 6040 6041 6042 6043

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

Z
Zhu Yi 已提交
6045
		if (!test_bit(STATUS_EXIT_PENDING, &priv->status))
C
Christoph Hellwig 已提交
6046
			iwl3945_send_scan_abort(priv);
Z
Zhu Yi 已提交
6047 6048 6049 6050
	}
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
6051
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
6052
{
C
Christoph Hellwig 已提交
6053 6054 6055
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, request_scan);
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
6056
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
6057
		.len = sizeof(struct iwl3945_scan_cmd),
Z
Zhu Yi 已提交
6058 6059 6060
		.meta.flags = CMD_SIZE_HUGE,
	};
	int rc = 0;
C
Christoph Hellwig 已提交
6061
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
6062
	struct ieee80211_conf *conf = NULL;
6063
	u8 n_probes = 2;
6064
	enum ieee80211_band band;
6065
	DECLARE_SSID_BUF(ssid);
Z
Zhu Yi 已提交
6066 6067 6068 6069 6070

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
6071
	if (!iwl3945_is_ready(priv)) {
Z
Zhu Yi 已提交
6072 6073 6074 6075
		IWL_WARNING("request scan called when driver not ready.\n");
		goto done;
	}

T
Tomas Winkler 已提交
6076
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099
	 * 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 已提交
6100
	if (iwl3945_is_rfkill(priv)) {
Z
Zhu Yi 已提交
6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115
		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 已提交
6116
		priv->scan = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
6117 6118 6119 6120 6121 6122 6123
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
		if (!priv->scan) {
			rc = -ENOMEM;
			goto done;
		}
	}
	scan = priv->scan;
C
Christoph Hellwig 已提交
6124
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
6125 6126 6127 6128

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

C
Christoph Hellwig 已提交
6129
	if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142
		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;
6143
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165
		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",
6166 6167
		     print_ssid(ssid, priv->direct_ssid,
				priv->direct_ssid_len));
Z
Zhu Yi 已提交
6168 6169 6170 6171
		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);
6172 6173
		n_probes++;
	} else
6174
		IWL_DEBUG_SCAN("Kicking off one indirect scan.\n");
Z
Zhu Yi 已提交
6175 6176 6177 6178

	/* 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 已提交
6179
		iwl3945_fill_probe_req(priv, (struct ieee80211_mgmt *)scan->data,
J
Johannes Berg 已提交
6180
			IWL_MAX_SCAN_SIZE - sizeof(*scan)));
Z
Zhu Yi 已提交
6181 6182 6183 6184 6185 6186
	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 */

6187
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
6188 6189 6190
		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;
6191
		band = IEEE80211_BAND_2GHZ;
6192
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
6193 6194
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
		scan->good_CRC_th = IWL_GOOD_CRC_TH;
6195
		band = IEEE80211_BAND_5GHZ;
6196
	} else {
Z
Zhu Yi 已提交
6197 6198 6199 6200 6201 6202 6203
		IWL_WARNING("Invalid scan band count\n");
		goto done;
	}

	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

6204
	if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
Z
Zhu Yi 已提交
6205 6206
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

6207 6208 6209 6210
	scan->channel_count =
		iwl3945_get_channels_for_scan(priv, band, 1, /* active */
					      n_probes,
			(void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);
Z
Zhu Yi 已提交
6211

6212 6213 6214 6215 6216
	if (scan->channel_count == 0) {
		IWL_DEBUG_SCAN("channel count %d\n", scan->channel_count);
		goto done;
	}

Z
Zhu Yi 已提交
6217
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
6218
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
6219 6220 6221 6222
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
C
Christoph Hellwig 已提交
6223
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
6224 6225 6226 6227 6228 6229 6230 6231 6232 6233
	if (rc)
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
6234 6235 6236 6237 6238 6239 6240 6241
	/* can not perform scan make sure we clear scanning
	 * bits from status so next scan request can be performed.
	 * if we dont clear scanning status bit here all next scan
	 * will fail
	*/
	clear_bit(STATUS_SCAN_HW, &priv->status);
	clear_bit(STATUS_SCANNING, &priv->status);

6242
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
6243 6244 6245 6246
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
6247
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
6248
{
C
Christoph Hellwig 已提交
6249
	struct iwl3945_priv *priv = container_of(data, struct iwl3945_priv, up);
Z
Zhu Yi 已提交
6250 6251 6252 6253 6254

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
6255
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
6256
	mutex_unlock(&priv->mutex);
6257
	iwl3945_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
6258 6259
}

C
Christoph Hellwig 已提交
6260
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
6261
{
C
Christoph Hellwig 已提交
6262
	struct iwl3945_priv *priv = container_of(data, struct iwl3945_priv, restart);
Z
Zhu Yi 已提交
6263 6264 6265 6266

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

C
Christoph Hellwig 已提交
6267
	iwl3945_down(priv);
Z
Zhu Yi 已提交
6268 6269 6270
	queue_work(priv->workqueue, &priv->up);
}

C
Christoph Hellwig 已提交
6271
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
6272
{
C
Christoph Hellwig 已提交
6273 6274
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, rx_replenish);
Z
Zhu Yi 已提交
6275 6276 6277 6278 6279

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
6280
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
6281 6282 6283
	mutex_unlock(&priv->mutex);
}

6284 6285
#define IWL_DELAY_NEXT_SCAN (HZ*2)

6286
static void iwl3945_post_associate(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
6287 6288 6289 6290
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

6291
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
6292
		IWL_ERROR("%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
6293 6294 6295 6296
		return;
	}


J
Johannes Berg 已提交
6297 6298
	IWL_DEBUG_ASSOC("Associated as %d to: %pM\n",
			priv->assoc_id, priv->active_rxon.bssid_addr);
Z
Zhu Yi 已提交
6299 6300 6301 6302

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

A
Abhijeet Kolekar 已提交
6303
	if (!priv->vif || !priv->is_open)
6304
		return;
A
Abhijeet Kolekar 已提交
6305

C
Christoph Hellwig 已提交
6306
	iwl3945_scan_cancel_timeout(priv, 200);
6307

Z
Zhu Yi 已提交
6308 6309 6310
	conf = ieee80211_get_hw_conf(priv->hw);

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

C
Christoph Hellwig 已提交
6313 6314 6315
	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 已提交
6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338
			      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;

6339
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
Z
Zhu Yi 已提交
6340 6341 6342 6343
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;

	}

C
Christoph Hellwig 已提交
6344
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6345 6346

	switch (priv->iw_mode) {
6347
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
6348
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
6349 6350
		break;

6351
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
6352

6353
		priv->assoc_id = 1;
C
Christoph Hellwig 已提交
6354
		iwl3945_add_station(priv, priv->bssid, 0, 0);
Z
Zhu Yi 已提交
6355
		iwl3945_sync_sta(priv, IWL_STA_ID,
6356
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
6357 6358
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
6359 6360
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
6361 6362 6363 6364 6365

		break;

	default:
		 IWL_ERROR("%s Should not be called in %d mode\n",
6366
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
6367 6368 6369
		break;
	}

C
Christoph Hellwig 已提交
6370
	iwl3945_activate_qos(priv, 0);
6371

6372 6373
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
6374 6375
}

C
Christoph Hellwig 已提交
6376
static void iwl3945_bg_abort_scan(struct work_struct *work)
Z
Zhu Yi 已提交
6377
{
C
Christoph Hellwig 已提交
6378
	struct iwl3945_priv *priv = container_of(work, struct iwl3945_priv, abort_scan);
Z
Zhu Yi 已提交
6379

C
Christoph Hellwig 已提交
6380
	if (!iwl3945_is_ready(priv))
Z
Zhu Yi 已提交
6381 6382 6383 6384 6385
		return;

	mutex_lock(&priv->mutex);

	set_bit(STATUS_SCAN_ABORTING, &priv->status);
C
Christoph Hellwig 已提交
6386
	iwl3945_send_scan_abort(priv);
Z
Zhu Yi 已提交
6387 6388 6389 6390

	mutex_unlock(&priv->mutex);
}

6391
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed);
6392

C
Christoph Hellwig 已提交
6393
static void iwl3945_bg_scan_completed(struct work_struct *work)
Z
Zhu Yi 已提交
6394
{
C
Christoph Hellwig 已提交
6395 6396
	struct iwl3945_priv *priv =
	    container_of(work, struct iwl3945_priv, scan_completed);
Z
Zhu Yi 已提交
6397 6398 6399 6400 6401 6402

	IWL_DEBUG(IWL_DL_INFO | IWL_DL_SCAN, "SCAN complete scan\n");

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

6403
	if (test_bit(STATUS_CONF_PENDING, &priv->status))
6404
		iwl3945_mac_config(priv->hw, 0);
6405

Z
Zhu Yi 已提交
6406 6407 6408 6409 6410
	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 已提交
6411
	iwl3945_hw_reg_send_txpower(priv);
Z
Zhu Yi 已提交
6412 6413 6414 6415 6416 6417 6418 6419 6420
	mutex_unlock(&priv->mutex);
}

/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

6421 6422
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
6423
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
6424
{
C
Christoph Hellwig 已提交
6425
	struct iwl3945_priv *priv = hw->priv;
6426
	int ret;
Z
Zhu Yi 已提交
6427 6428 6429

	IWL_DEBUG_MAC80211("enter\n");

6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443
	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 已提交
6444 6445 6446
	/* we should be verifying the device is ready to be opened */
	mutex_lock(&priv->mutex);

6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458
	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 已提交
6459

6460
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
6461 6462

	mutex_unlock(&priv->mutex);
6463

6464 6465
	iwl3945_rfkill_set_hw_state(priv);

6466 6467 6468 6469 6470 6471 6472 6473
	if (ret)
		goto out_release_irq;

	IWL_DEBUG_INFO("Start UP work.\n");

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

6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487
	/* 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;
		}
	}

6488
	priv->is_open = 1;
Z
Zhu Yi 已提交
6489 6490
	IWL_DEBUG_MAC80211("leave\n");
	return 0;
6491 6492 6493 6494 6495

out_release_irq:
	free_irq(priv->pci_dev->irq, priv);
out_disable_msi:
	pci_disable_msi(priv->pci_dev);
6496 6497 6498
	pci_disable_device(priv->pci_dev);
	priv->is_open = 0;
	IWL_DEBUG_MAC80211("leave - failed\n");
6499
	return ret;
Z
Zhu Yi 已提交
6500 6501
}

C
Christoph Hellwig 已提交
6502
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
6503
{
C
Christoph Hellwig 已提交
6504
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6505 6506

	IWL_DEBUG_MAC80211("enter\n");
6507

6508 6509 6510 6511 6512
	if (!priv->is_open) {
		IWL_DEBUG_MAC80211("leave - skip\n");
		return;
	}

Z
Zhu Yi 已提交
6513
	priv->is_open = 0;
6514 6515

	if (iwl3945_is_ready_rf(priv)) {
6516 6517 6518
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
6519 6520
		mutex_lock(&priv->mutex);
		iwl3945_scan_cancel_timeout(priv, 100);
6521 6522 6523
		mutex_unlock(&priv->mutex);
	}

6524 6525 6526 6527 6528 6529 6530
	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);
6531

Z
Zhu Yi 已提交
6532 6533 6534
	IWL_DEBUG_MAC80211("leave\n");
}

6535
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
6536
{
C
Christoph Hellwig 已提交
6537
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6538 6539 6540 6541

	IWL_DEBUG_MAC80211("enter\n");

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

6544
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
6545 6546 6547 6548 6549 6550
		dev_kfree_skb_any(skb);

	IWL_DEBUG_MAC80211("leave\n");
	return 0;
}

C
Christoph Hellwig 已提交
6551
static int iwl3945_mac_add_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
6552 6553
				 struct ieee80211_if_init_conf *conf)
{
C
Christoph Hellwig 已提交
6554
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6555 6556
	unsigned long flags;

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

6559 6560
	if (priv->vif) {
		IWL_DEBUG_MAC80211("leave - vif != NULL\n");
6561
		return -EOPNOTSUPP;
Z
Zhu Yi 已提交
6562 6563 6564
	}

	spin_lock_irqsave(&priv->lock, flags);
6565
	priv->vif = conf->vif;
6566
	priv->iw_mode = conf->type;
Z
Zhu Yi 已提交
6567 6568 6569 6570

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
6571 6572

	if (conf->mac_addr) {
J
Johannes Berg 已提交
6573
		IWL_DEBUG_MAC80211("Set: %pM\n", conf->mac_addr);
6574 6575 6576
		memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
	}

6577 6578
	if (iwl3945_is_ready(priv))
		iwl3945_set_mode(priv, conf->type);
Z
Zhu Yi 已提交
6579 6580 6581

	mutex_unlock(&priv->mutex);

6582
	IWL_DEBUG_MAC80211("leave\n");
Z
Zhu Yi 已提交
6583 6584 6585 6586
	return 0;
}

/**
C
Christoph Hellwig 已提交
6587
 * iwl3945_mac_config - mac80211 config callback
Z
Zhu Yi 已提交
6588 6589 6590 6591 6592
 *
 * 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.
 */
6593
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed)
Z
Zhu Yi 已提交
6594
{
C
Christoph Hellwig 已提交
6595 6596
	struct iwl3945_priv *priv = hw->priv;
	const struct iwl3945_channel_info *ch_info;
6597
	struct ieee80211_conf *conf = &hw->conf;
Z
Zhu Yi 已提交
6598
	unsigned long flags;
6599
	int ret = 0;
Z
Zhu Yi 已提交
6600 6601

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

C
Christoph Hellwig 已提交
6604
	if (!iwl3945_is_ready(priv)) {
Z
Zhu Yi 已提交
6605
		IWL_DEBUG_MAC80211("leave - not ready\n");
6606 6607
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
6608 6609
	}

C
Christoph Hellwig 已提交
6610
	if (unlikely(!iwl3945_param_disable_hw_scan &&
Z
Zhu Yi 已提交
6611
		     test_bit(STATUS_SCANNING, &priv->status))) {
6612 6613
		IWL_DEBUG_MAC80211("leave - scanning\n");
		set_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
6614
		mutex_unlock(&priv->mutex);
6615
		return 0;
Z
Zhu Yi 已提交
6616 6617 6618 6619
	}

	spin_lock_irqsave(&priv->lock, flags);

6620 6621
	ch_info = iwl3945_get_channel_info(priv, conf->channel->band,
					   conf->channel->hw_value);
Z
Zhu Yi 已提交
6622
	if (!is_channel_valid(ch_info)) {
6623
		IWL_DEBUG_SCAN("Channel %d [%d] is INVALID for this band.\n",
6624
			       conf->channel->hw_value, conf->channel->band);
Z
Zhu Yi 已提交
6625 6626
		IWL_DEBUG_MAC80211("leave - invalid channel\n");
		spin_unlock_irqrestore(&priv->lock, flags);
6627 6628
		ret = -EINVAL;
		goto out;
Z
Zhu Yi 已提交
6629 6630
	}

6631
	iwl3945_set_rxon_channel(priv, conf->channel->band, conf->channel->hw_value);
Z
Zhu Yi 已提交
6632

6633
	iwl3945_set_flags_for_phymode(priv, conf->channel->band);
Z
Zhu Yi 已提交
6634 6635 6636 6637

	/* 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 已提交
6638
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6639 6640 6641 6642 6643

	spin_unlock_irqrestore(&priv->lock, flags);

#ifdef IEEE80211_CONF_CHANNEL_SWITCH
	if (conf->flags & IEEE80211_CONF_CHANNEL_SWITCH) {
C
Christoph Hellwig 已提交
6644
		iwl3945_hw_channel_switch(priv, conf->channel);
6645
		goto out;
Z
Zhu Yi 已提交
6646 6647 6648
	}
#endif

C
Christoph Hellwig 已提交
6649
	iwl3945_radio_kill_sw(priv, !conf->radio_enabled);
Z
Zhu Yi 已提交
6650 6651 6652

	if (!conf->radio_enabled) {
		IWL_DEBUG_MAC80211("leave - radio disabled\n");
6653
		goto out;
Z
Zhu Yi 已提交
6654 6655
	}

C
Christoph Hellwig 已提交
6656
	if (iwl3945_is_rfkill(priv)) {
Z
Zhu Yi 已提交
6657
		IWL_DEBUG_MAC80211("leave - RF kill\n");
6658 6659
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
6660 6661
	}

C
Christoph Hellwig 已提交
6662
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6663 6664 6665

	if (memcmp(&priv->active_rxon,
		   &priv->staging_rxon, sizeof(priv->staging_rxon)))
C
Christoph Hellwig 已提交
6666
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6667 6668 6669 6670 6671
	else
		IWL_DEBUG_INFO("No re-sending same RXON configuration.\n");

	IWL_DEBUG_MAC80211("leave\n");

6672
out:
6673
	clear_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
6674
	mutex_unlock(&priv->mutex);
6675
	return ret;
Z
Zhu Yi 已提交
6676 6677
}

C
Christoph Hellwig 已提交
6678
static void iwl3945_config_ap(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
6679 6680 6681
{
	int rc = 0;

6682
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
6683 6684 6685
		return;

	/* The following should be done only at AP bring up */
6686
	if (!(iwl3945_is_associated(priv))) {
Z
Zhu Yi 已提交
6687 6688 6689

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

		/* RXON Timing */
C
Christoph Hellwig 已提交
6693 6694 6695
		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 已提交
6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718
				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;

6719
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
Z
Zhu Yi 已提交
6720 6721 6722 6723 6724
				priv->staging_rxon.flags &=
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6725 6726
		iwl3945_commit_rxon(priv);
		iwl3945_add_station(priv, iwl3945_broadcast_addr, 0, 0);
6727
	}
C
Christoph Hellwig 已提交
6728
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
6729 6730 6731 6732 6733 6734

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

6735 6736
static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
Z
Zhu Yi 已提交
6737 6738
				    struct ieee80211_if_conf *conf)
{
C
Christoph Hellwig 已提交
6739
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6740 6741 6742 6743 6744
	int rc;

	if (conf == NULL)
		return -EIO;

6745 6746 6747 6748 6749
	if (priv->vif != vif) {
		IWL_DEBUG_MAC80211("leave - priv->vif != vif\n");
		return 0;
	}

6750
	/* handle this temporarily here */
6751
	if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
6752 6753 6754 6755
	    conf->changed & IEEE80211_IFCC_BEACON) {
		struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
		if (!beacon)
			return -ENOMEM;
6756
		mutex_lock(&priv->mutex);
6757
		rc = iwl3945_mac_beacon_update(hw, beacon);
6758
		mutex_unlock(&priv->mutex);
6759 6760 6761 6762
		if (rc)
			return rc;
	}

6763 6764 6765
	if (!iwl3945_is_alive(priv))
		return -EAGAIN;

Z
Zhu Yi 已提交
6766 6767 6768
	mutex_lock(&priv->mutex);

	if (conf->bssid)
J
Johannes Berg 已提交
6769
		IWL_DEBUG_MAC80211("bssid: %pM\n", conf->bssid);
Z
Zhu Yi 已提交
6770

6771 6772 6773
/*
 * very dubious code was here; the probe filtering flag is never set:
 *
Z
Zhu Yi 已提交
6774 6775
	if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
	    !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
6776
 */
Z
Zhu Yi 已提交
6777

6778
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
6779 6780 6781
		if (!conf->bssid) {
			conf->bssid = priv->mac_addr;
			memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
J
Johannes Berg 已提交
6782 6783
			IWL_DEBUG_MAC80211("bssid was set to: %pM\n",
					   conf->bssid);
Z
Zhu Yi 已提交
6784 6785 6786 6787
		}
		if (priv->ibss_beacon)
			dev_kfree_skb(priv->ibss_beacon);

6788
		priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
Z
Zhu Yi 已提交
6789 6790
	}

6791 6792 6793
	if (iwl3945_is_rfkill(priv))
		goto done;

Z
Zhu Yi 已提交
6794 6795 6796 6797
	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 已提交
6798
		if (iwl3945_scan_cancel_timeout(priv, 100)) {
Z
Zhu Yi 已提交
6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812
			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);

6813
		if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
6814
			iwl3945_config_ap(priv);
Z
Zhu Yi 已提交
6815
		else {
C
Christoph Hellwig 已提交
6816
			rc = iwl3945_commit_rxon(priv);
6817
			if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
C
Christoph Hellwig 已提交
6818
				iwl3945_add_station(priv,
6819
					priv->active_rxon.bssid_addr, 1, 0);
Z
Zhu Yi 已提交
6820 6821 6822
		}

	} else {
C
Christoph Hellwig 已提交
6823
		iwl3945_scan_cancel_timeout(priv, 100);
Z
Zhu Yi 已提交
6824
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6825
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6826 6827
	}

6828
 done:
Z
Zhu Yi 已提交
6829 6830 6831 6832 6833 6834
	IWL_DEBUG_MAC80211("leave\n");
	mutex_unlock(&priv->mutex);

	return 0;
}

C
Christoph Hellwig 已提交
6835
static void iwl3945_configure_filter(struct ieee80211_hw *hw,
6836 6837 6838 6839
				 unsigned int changed_flags,
				 unsigned int *total_flags,
				 int mc_count, struct dev_addr_list *mc_list)
{
6840
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu, Yi 已提交
6841
	__le32 *filter_flags = &priv->staging_rxon.filter_flags;
6842

Z
Zhu, Yi 已提交
6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862
	IWL_DEBUG_MAC80211("Enter: changed: 0x%x, total: 0x%x\n",
			changed_flags, *total_flags);

	if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) {
		if (*total_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))
			*filter_flags |= RXON_FILTER_PROMISC_MSK;
		else
			*filter_flags &= ~RXON_FILTER_PROMISC_MSK;
	}
	if (changed_flags & FIF_ALLMULTI) {
		if (*total_flags & FIF_ALLMULTI)
			*filter_flags |= RXON_FILTER_ACCEPT_GRP_MSK;
		else
			*filter_flags &= ~RXON_FILTER_ACCEPT_GRP_MSK;
	}
	if (changed_flags & FIF_CONTROL) {
		if (*total_flags & FIF_CONTROL)
			*filter_flags |= RXON_FILTER_CTL2HOST_MSK;
		else
			*filter_flags &= ~RXON_FILTER_CTL2HOST_MSK;
6863
	}
Z
Zhu, Yi 已提交
6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877
	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
		if (*total_flags & FIF_BCN_PRBRESP_PROMISC)
			*filter_flags |= RXON_FILTER_BCON_AWARE_MSK;
		else
			*filter_flags &= ~RXON_FILTER_BCON_AWARE_MSK;
	}

	/* We avoid iwl_commit_rxon here to commit the new filter flags
	 * since mac80211 will call ieee80211_hw_config immediately.
	 * (mc_list is not supported at this time). Otherwise, we need to
	 * queue a background iwl_commit_rxon work.
	 */

	*total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
6878
			FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
6879 6880
}

C
Christoph Hellwig 已提交
6881
static void iwl3945_mac_remove_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
6882 6883
				     struct ieee80211_if_init_conf *conf)
{
C
Christoph Hellwig 已提交
6884
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6885 6886 6887 6888

	IWL_DEBUG_MAC80211("enter\n");

	mutex_lock(&priv->mutex);
6889

6890 6891 6892 6893 6894
	if (iwl3945_is_ready_rf(priv)) {
		iwl3945_scan_cancel_timeout(priv, 100);
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
		iwl3945_commit_rxon(priv);
	}
6895 6896
	if (priv->vif == conf->vif) {
		priv->vif = NULL;
Z
Zhu Yi 已提交
6897 6898 6899 6900 6901 6902 6903
		memset(priv->bssid, 0, ETH_ALEN);
	}
	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");
}

6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960
#define IWL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)

static void iwl3945_bss_info_changed(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif,
				     struct ieee80211_bss_conf *bss_conf,
				     u32 changes)
{
	struct iwl3945_priv *priv = hw->priv;

	IWL_DEBUG_MAC80211("changes = 0x%X\n", changes);

	if (changes & BSS_CHANGED_ERP_PREAMBLE) {
		IWL_DEBUG_MAC80211("ERP_PREAMBLE %d\n",
				   bss_conf->use_short_preamble);
		if (bss_conf->use_short_preamble)
			priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
		else
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
	}

	if (changes & BSS_CHANGED_ERP_CTS_PROT) {
		IWL_DEBUG_MAC80211("ERP_CTS %d\n", bss_conf->use_cts_prot);
		if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
			priv->staging_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
		else
			priv->staging_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
	}

	if (changes & BSS_CHANGED_ASSOC) {
		IWL_DEBUG_MAC80211("ASSOC %d\n", bss_conf->assoc);
		/* This should never happen as this function should
		 * never be called from interrupt context. */
		if (WARN_ON_ONCE(in_interrupt()))
			return;
		if (bss_conf->assoc) {
			priv->assoc_id = bss_conf->aid;
			priv->beacon_int = bss_conf->beacon_int;
			priv->timestamp0 = bss_conf->timestamp & 0xFFFFFFFF;
			priv->timestamp1 = (bss_conf->timestamp >> 32) &
					     0xFFFFFFFF;
			priv->assoc_capability = bss_conf->assoc_capability;
			priv->next_scan_jiffies = jiffies +
					IWL_DELAY_NEXT_SCAN_AFTER_ASSOC;
			mutex_lock(&priv->mutex);
			iwl3945_post_associate(priv);
			mutex_unlock(&priv->mutex);
		} else {
			priv->assoc_id = 0;
			IWL_DEBUG_MAC80211("DISASSOC %d\n", bss_conf->assoc);
		}
	} else if (changes && iwl3945_is_associated(priv) && priv->assoc_id) {
			IWL_DEBUG_MAC80211("Associated Changes %d\n", changes);
			iwl3945_send_rxon_assoc(priv);
	}

}

C
Christoph Hellwig 已提交
6961
static int iwl3945_mac_hw_scan(struct ieee80211_hw *hw, u8 *ssid, size_t len)
Z
Zhu Yi 已提交
6962 6963 6964
{
	int rc = 0;
	unsigned long flags;
C
Christoph Hellwig 已提交
6965
	struct iwl3945_priv *priv = hw->priv;
6966
	DECLARE_SSID_BUF(ssid_buf);
Z
Zhu Yi 已提交
6967 6968 6969

	IWL_DEBUG_MAC80211("enter\n");

6970
	mutex_lock(&priv->mutex);
Z
Zhu Yi 已提交
6971 6972
	spin_lock_irqsave(&priv->lock, flags);

C
Christoph Hellwig 已提交
6973
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
6974 6975 6976 6977 6978
		rc = -EIO;
		IWL_DEBUG_MAC80211("leave - not ready or exit pending\n");
		goto out_unlock;
	}

6979
	if (priv->iw_mode == NL80211_IFTYPE_AP) {	/* APs don't scan */
Z
Zhu Yi 已提交
6980 6981 6982 6983 6984
		rc = -EIO;
		IWL_ERROR("ERROR: APs don't scan\n");
		goto out_unlock;
	}

6985 6986 6987 6988 6989 6990
	/* 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;
	}
6991 6992 6993 6994
	/* if we just finished scan ask for delay for a broadcast scan */
	if ((len == 0) && priv->last_scan_jiffies &&
	    time_after(priv->last_scan_jiffies + IWL_DELAY_NEXT_SCAN,
		       jiffies)) {
Z
Zhu Yi 已提交
6995 6996 6997 6998
		rc = -EAGAIN;
		goto out_unlock;
	}
	if (len) {
6999
		IWL_DEBUG_SCAN("direct scan for %s [%d]\n ",
7000
			       print_ssid(ssid_buf, ssid, len), (int)len);
Z
Zhu Yi 已提交
7001 7002 7003 7004 7005

		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);
7006 7007
	} else
		priv->one_direct_scan = 0;
Z
Zhu Yi 已提交
7008

C
Christoph Hellwig 已提交
7009
	rc = iwl3945_scan_initiate(priv);
Z
Zhu Yi 已提交
7010 7011 7012 7013 7014

	IWL_DEBUG_MAC80211("leave\n");

out_unlock:
	spin_unlock_irqrestore(&priv->lock, flags);
7015
	mutex_unlock(&priv->mutex);
Z
Zhu Yi 已提交
7016 7017 7018 7019

	return rc;
}

C
Christoph Hellwig 已提交
7020
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
Z
Zhu Yi 已提交
7021 7022 7023
			   const u8 *local_addr, const u8 *addr,
			   struct ieee80211_key_conf *key)
{
C
Christoph Hellwig 已提交
7024
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7025 7026 7027 7028 7029
	int rc = 0;
	u8 sta_id;

	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7030
	if (!iwl3945_param_hwcrypto) {
Z
Zhu Yi 已提交
7031 7032 7033 7034 7035 7036 7037 7038
		IWL_DEBUG_MAC80211("leave - hwcrypto disabled\n");
		return -EOPNOTSUPP;
	}

	if (is_zero_ether_addr(addr))
		/* only support pairwise keys */
		return -EOPNOTSUPP;

C
Christoph Hellwig 已提交
7039
	sta_id = iwl3945_hw_find_station(priv, addr);
Z
Zhu Yi 已提交
7040
	if (sta_id == IWL_INVALID_STATION) {
J
Johannes Berg 已提交
7041 7042
		IWL_DEBUG_MAC80211("leave - %pM not in station map.\n",
				   addr);
Z
Zhu Yi 已提交
7043 7044 7045 7046 7047
		return -EINVAL;
	}

	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
7048
	iwl3945_scan_cancel_timeout(priv, 100);
7049

Z
Zhu Yi 已提交
7050 7051
	switch (cmd) {
	case  SET_KEY:
C
Christoph Hellwig 已提交
7052
		rc = iwl3945_update_sta_key_info(priv, key, sta_id);
Z
Zhu Yi 已提交
7053
		if (!rc) {
C
Christoph Hellwig 已提交
7054 7055
			iwl3945_set_rxon_hwcrypto(priv, 1);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7056 7057 7058 7059 7060 7061
			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 已提交
7062
		rc = iwl3945_clear_sta_key_info(priv, sta_id);
Z
Zhu Yi 已提交
7063
		if (!rc) {
C
Christoph Hellwig 已提交
7064 7065
			iwl3945_set_rxon_hwcrypto(priv, 0);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078
			IWL_DEBUG_MAC80211("disable hwcrypto key\n");
		}
		break;
	default:
		rc = -EINVAL;
	}

	IWL_DEBUG_MAC80211("leave\n");
	mutex_unlock(&priv->mutex);

	return rc;
}

J
Johannes Berg 已提交
7079
static int iwl3945_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
Z
Zhu Yi 已提交
7080 7081
			   const struct ieee80211_tx_queue_params *params)
{
C
Christoph Hellwig 已提交
7082
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7083 7084 7085 7086 7087
	unsigned long flags;
	int q;

	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7088
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110
		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 =
7111
			cpu_to_le16((params->txop * 32));
Z
Zhu Yi 已提交
7112 7113 7114 7115 7116 7117 7118

	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);
7119
	if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
7120 7121 7122
		iwl3945_activate_qos(priv, 1);
	else if (priv->assoc_id && iwl3945_is_associated(priv))
		iwl3945_activate_qos(priv, 0);
Z
Zhu Yi 已提交
7123 7124 7125 7126 7127 7128 7129

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");
	return 0;
}

C
Christoph Hellwig 已提交
7130
static int iwl3945_mac_get_tx_stats(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
7131 7132
				struct ieee80211_tx_queue_stats *stats)
{
C
Christoph Hellwig 已提交
7133
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7134
	int i, avail;
C
Christoph Hellwig 已提交
7135 7136
	struct iwl3945_tx_queue *txq;
	struct iwl3945_queue *q;
Z
Zhu Yi 已提交
7137 7138 7139 7140
	unsigned long flags;

	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7141
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
7142 7143 7144 7145 7146 7147 7148 7149 7150
		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 已提交
7151
		avail = iwl3945_queue_space(q);
Z
Zhu Yi 已提交
7152

7153 7154 7155
		stats[i].len = q->n_window - avail;
		stats[i].limit = q->n_window - q->high_mark;
		stats[i].count = q->n_window;
Z
Zhu Yi 已提交
7156 7157 7158 7159 7160 7161 7162 7163 7164

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

	IWL_DEBUG_MAC80211("leave\n");

	return 0;
}

C
Christoph Hellwig 已提交
7165
static int iwl3945_mac_get_stats(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
7166 7167 7168 7169 7170 7171 7172 7173
			     struct ieee80211_low_level_stats *stats)
{
	IWL_DEBUG_MAC80211("enter\n");
	IWL_DEBUG_MAC80211("leave\n");

	return 0;
}

C
Christoph Hellwig 已提交
7174
static void iwl3945_mac_reset_tsf(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
7175
{
C
Christoph Hellwig 已提交
7176
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7177 7178 7179 7180 7181
	unsigned long flags;

	mutex_lock(&priv->mutex);
	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7182
	iwl3945_reset_qos(priv);
7183

Z
Zhu Yi 已提交
7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197
	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;
7198
	if ((priv->iw_mode == NL80211_IFTYPE_STATION))
Z
Zhu Yi 已提交
7199 7200 7201 7202
		priv->beacon_int = 0;

	spin_unlock_irqrestore(&priv->lock, flags);

7203 7204 7205 7206 7207 7208
	if (!iwl3945_is_ready_rf(priv)) {
		IWL_DEBUG_MAC80211("leave - not ready\n");
		mutex_unlock(&priv->mutex);
		return;
	}

7209 7210 7211
	/* we are restarting association process
	 * clear RXON_FILTER_ASSOC_MSK bit
	*/
7212
	if (priv->iw_mode != NL80211_IFTYPE_AP) {
C
Christoph Hellwig 已提交
7213
		iwl3945_scan_cancel_timeout(priv, 100);
7214
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
7215
		iwl3945_commit_rxon(priv);
7216 7217
	}

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

Z
Zhu Yi 已提交
7221 7222 7223 7224 7225
		IWL_DEBUG_MAC80211("leave - not in IBSS\n");
		mutex_unlock(&priv->mutex);
		return;
	}

C
Christoph Hellwig 已提交
7226
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
7227 7228 7229 7230 7231 7232 7233

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");

}

7234
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
7235
{
C
Christoph Hellwig 已提交
7236
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7237 7238 7239 7240
	unsigned long flags;

	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7241
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
7242 7243 7244 7245
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		return -EIO;
	}

7246
	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
Z
Zhu Yi 已提交
7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259 7260 7261 7262
		IWL_DEBUG_MAC80211("leave - not IBSS\n");
		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 已提交
7263
	iwl3945_reset_qos(priv);
Z
Zhu Yi 已提交
7264

7265
	iwl3945_post_associate(priv);
Z
Zhu Yi 已提交
7266 7267 7268 7269 7270 7271 7272 7273 7274 7275 7276


	return 0;
}

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

7277
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288

/*
 * 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 已提交
7289
	return sprintf(buf, "0x%08X\n", iwl3945_debug_level);
Z
Zhu Yi 已提交
7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301
}
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 已提交
7302
		iwl3945_debug_level = val;
Z
Zhu Yi 已提交
7303 7304 7305 7306 7307 7308 7309

	return strnlen(buf, count);
}

static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
		   show_debug_level, store_debug_level);

7310
#endif /* CONFIG_IWL3945_DEBUG */
Z
Zhu Yi 已提交
7311 7312 7313 7314

static ssize_t show_temperature(struct device *d,
				struct device_attribute *attr, char *buf)
{
C
Christoph Hellwig 已提交
7315
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7316

C
Christoph Hellwig 已提交
7317
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7318 7319
		return -EAGAIN;

C
Christoph Hellwig 已提交
7320
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
7321 7322 7323 7324 7325 7326 7327
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
C
Christoph Hellwig 已提交
7328
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7329 7330 7331 7332 7333 7334 7335
	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 已提交
7336
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7337 7338 7339 7340 7341 7342 7343 7344
	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 已提交
7345
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
7346 7347 7348 7349 7350 7351 7352 7353 7354

	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 已提交
7355
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7356 7357 7358 7359 7360 7361 7362 7363

	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 已提交
7364
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7365 7366 7367 7368 7369
	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 已提交
7370
		if (iwl3945_scan_cancel_timeout(priv, 100))
Z
Zhu Yi 已提交
7371 7372 7373 7374 7375
			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 已提交
7376
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7377 7378 7379 7380 7381 7382 7383 7384 7385 7386 7387 7388
		}
	}
	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 已提交
7389
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7390 7391 7392 7393 7394 7395 7396 7397 7398

	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 已提交
7399
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7400 7401 7402 7403 7404
	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 已提交
7405
		if (iwl3945_scan_cancel_timeout(priv, 100))
Z
Zhu Yi 已提交
7406 7407 7408 7409 7410 7411
			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 已提交
7412
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7413 7414 7415 7416 7417 7418 7419 7420 7421 7422
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

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

7423
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
7424 7425 7426 7427

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
C
Christoph Hellwig 已提交
7428 7429
	struct iwl3945_priv *priv = dev_get_drvdata(d);
	struct iwl3945_spectrum_notification measure_report;
Z
Zhu Yi 已提交
7430
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
7431
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460
	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 已提交
7461
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486
	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 已提交
7487
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
7488 7489 7490 7491 7492 7493

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
7494
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
7495 7496 7497 7498 7499

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
C
Christoph Hellwig 已提交
7500
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511

	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 已提交
7512
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7513 7514 7515 7516 7517 7518 7519 7520 7521 7522
	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 已提交
7523
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7524 7525 7526 7527 7528 7529
	int rc;
	int mode;

	mode = simple_strtoul(buf, NULL, 0);
	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
7530
	if (!iwl3945_is_ready(priv)) {
Z
Zhu Yi 已提交
7531 7532 7533 7534 7535 7536 7537 7538 7539 7540
		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 已提交
7541
		rc = iwl3945_send_power_mode(priv, IWL_POWER_LEVEL(mode));
Z
Zhu Yi 已提交
7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 7575 7576
		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 已提交
7577
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601
	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");

7602
	return p - buf + 1;
Z
Zhu Yi 已提交
7603 7604 7605 7606 7607 7608 7609 7610 7611

}

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)
{
7612 7613
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
7614 7615 7616 7617 7618 7619 7620
}

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 已提交
7621 7622
	struct iwl3945_priv *priv = dev_get_drvdata(d);
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
7623
	u32 len = 0, ofs = 0;
7624
	u8 *data = (u8 *)&priv->statistics;
Z
Zhu Yi 已提交
7625 7626
	int rc = 0;

C
Christoph Hellwig 已提交
7627
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7628 7629 7630
		return -EAGAIN;

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
7631
	rc = iwl3945_send_statistics_request(priv);
Z
Zhu Yi 已提交
7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645 7646 7647 7648 7649 7650 7651 7652 7653 7654 7655 7656 7657 7658
	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 已提交
7659
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7660

C
Christoph Hellwig 已提交
7661
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7662 7663 7664 7665 7666 7667 7668 7669 7670 7671
		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 已提交
7672
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683

	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 已提交
7684
		priv->antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696
	} 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 已提交
7697 7698
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7699 7700 7701 7702 7703 7704 7705 7706 7707 7708 7709 7710 7711
		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 已提交
7712
		iwl3945_dump_nic_error_log((struct iwl3945_priv *)d->driver_data);
Z
Zhu Yi 已提交
7713 7714 7715 7716 7717 7718 7719 7720 7721 7722 7723 7724 7725

	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 已提交
7726
		iwl3945_dump_nic_event_log((struct iwl3945_priv *)d->driver_data);
Z
Zhu Yi 已提交
7727 7728 7729 7730 7731 7732 7733 7734

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
7735
 * driver setup and tear down
Z
Zhu Yi 已提交
7736 7737 7738
 *
 *****************************************************************************/

C
Christoph Hellwig 已提交
7739
static void iwl3945_setup_deferred_work(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
7740 7741 7742 7743 7744
{
	priv->workqueue = create_workqueue(DRV_NAME);

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
7745 7746 7747 7748 7749 7750 7751 7752 7753 7754 7755 7756 7757
	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->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 已提交
7758 7759

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

C
Christoph Hellwig 已提交
7763
static void iwl3945_cancel_deferred_work(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
7764
{
C
Christoph Hellwig 已提交
7765
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
7766

7767
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
7768 7769 7770 7771 7772
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
7773
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
7774 7775 7776 7777 7778 7779
	&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,
7780
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
7781 7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792
	&dev_attr_measurement.attr,
#endif
	&dev_attr_power_level.attr,
	&dev_attr_retry_rate.attr,
	&dev_attr_statistics.attr,
	&dev_attr_status.attr,
	&dev_attr_temperature.attr,
	&dev_attr_tx_power.attr,

	NULL
};

C
Christoph Hellwig 已提交
7793
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
7794
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
7795
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
7796 7797
};

C
Christoph Hellwig 已提交
7798 7799 7800 7801 7802 7803 7804 7805 7806 7807 7808 7809 7810 7811
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,
	.reset_tsf = iwl3945_mac_reset_tsf,
7812
	.bss_info_changed = iwl3945_bss_info_changed,
C
Christoph Hellwig 已提交
7813
	.hw_scan = iwl3945_mac_hw_scan
Z
Zhu Yi 已提交
7814 7815
};

C
Christoph Hellwig 已提交
7816
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
7817 7818
{
	int err = 0;
C
Christoph Hellwig 已提交
7819
	struct iwl3945_priv *priv;
Z
Zhu Yi 已提交
7820
	struct ieee80211_hw *hw;
T
Tomas Winkler 已提交
7821
	struct iwl_3945_cfg *cfg = (struct iwl_3945_cfg *)(ent->driver_data);
7822
	unsigned long flags;
Z
Zhu Yi 已提交
7823

7824 7825 7826 7827
	/***********************
	 * 1. Allocating HW data
	 * ********************/

7828 7829
	/* Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan. */
C
Christoph Hellwig 已提交
7830
	if (iwl3945_param_disable_hw_scan) {
Z
Zhu Yi 已提交
7831
		IWL_DEBUG_INFO("Disabling hw_scan\n");
C
Christoph Hellwig 已提交
7832
		iwl3945_hw_ops.hw_scan = NULL;
Z
Zhu Yi 已提交
7833 7834
	}

7835
	if ((iwl3945_param_queues_num > IWL39_MAX_NUM_QUEUES) ||
C
Christoph Hellwig 已提交
7836
	    (iwl3945_param_queues_num < IWL_MIN_NUM_QUEUES)) {
Z
Zhu Yi 已提交
7837
		IWL_ERROR("invalid queues_num, should be between %d and %d\n",
7838
			  IWL_MIN_NUM_QUEUES, IWL39_MAX_NUM_QUEUES);
Z
Zhu Yi 已提交
7839 7840 7841 7842 7843 7844
		err = -EINVAL;
		goto out;
	}

	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
C
Christoph Hellwig 已提交
7845
	hw = ieee80211_alloc_hw(sizeof(struct iwl3945_priv), &iwl3945_hw_ops);
Z
Zhu Yi 已提交
7846 7847 7848 7849 7850 7851
	if (hw == NULL) {
		IWL_ERROR("Can not allocate network device\n");
		err = -ENOMEM;
		goto out;
	}

7852
	SET_IEEE80211_DEV(hw, &pdev->dev);
7853

Z
Zhu Yi 已提交
7854 7855 7856
	priv = hw->priv;
	priv->hw = hw;
	priv->pci_dev = pdev;
T
Tomas Winkler 已提交
7857
	priv->cfg = cfg;
7858

7859 7860 7861 7862
	IWL_DEBUG_INFO("*** LOAD DRIVER ***\n");
	hw->rate_control_algorithm = "iwl-3945-rs";
	hw->sta_data_size = sizeof(struct iwl3945_sta_priv);

7863
	/* Select antenna (may be helpful if only one antenna is connected) */
C
Christoph Hellwig 已提交
7864
	priv->antenna = (enum iwl3945_antenna)iwl3945_param_antenna;
7865
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
7866
	iwl3945_debug_level = iwl3945_param_debug;
Z
Zhu Yi 已提交
7867 7868 7869
	atomic_set(&priv->restrict_refcnt, 0);
#endif

7870
	/* Tell mac80211 our characteristics */
7871
	hw->flags = IEEE80211_HW_SIGNAL_DBM |
7872
		    IEEE80211_HW_NOISE_DBM;
Z
Zhu Yi 已提交
7873

7874 7875 7876 7877
	hw->wiphy->interface_modes =
		BIT(NL80211_IFTYPE_STATION) |
		BIT(NL80211_IFTYPE_ADHOC);

7878 7879
	hw->wiphy->fw_handles_regulatory = true;

7880
	/* 4 EDCA QOS priorities */
Z
Zhu Yi 已提交
7881 7882
	hw->queues = 4;

7883 7884 7885
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898 7899 7900 7901 7902 7903 7904
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

	err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
	if (!err)
		err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
	if (err) {
		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;
7905

7906 7907 7908
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
7909 7910 7911 7912 7913 7914 7915 7916 7917 7918
	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);

7919 7920 7921
	/* We disable the RETRY_TIMEOUT register (0x41) to keep
	 * PCI Tx retries from interfering with C3 CPU state */
	pci_write_config_byte(pdev, 0x41, 0x00);
Z
Zhu Yi 已提交
7922

7923 7924 7925
	/* nic init */
	iwl3945_set_bit(priv, CSR_GIO_CHICKEN_BITS,
			CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);
Z
Zhu Yi 已提交
7926

7927
	iwl3945_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
Z
Zhu, Yi 已提交
7928 7929
	err = iwl3945_poll_direct_bit(priv, CSR_GP_CNTRL,
				CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
7930 7931 7932 7933
	if (err < 0) {
		IWL_DEBUG_INFO("Failed to init the card\n");
		goto out_remove_sysfs;
	}
Z
Zhu Yi 已提交
7934

7935 7936 7937 7938 7939 7940 7941 7942 7943 7944 7945 7946 7947
	/***********************
	 * 4. Read EEPROM
	 * ********************/
	/* Read the EEPROM */
	err = iwl3945_eeprom_init(priv);
	if (err) {
		IWL_ERROR("Unable to init EEPROM\n");
		goto out_remove_sysfs;
	}
	/* MAC Address location in EEPROM same for 3945/4965 */
	get_eeprom_mac(priv, priv->mac_addr);
	IWL_DEBUG_INFO("MAC address: %pM\n", priv->mac_addr);
	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
Z
Zhu Yi 已提交
7948

7949 7950 7951
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
7952
	/* Device-specific setup */
C
Christoph Hellwig 已提交
7953
	if (iwl3945_hw_set_hw_setting(priv)) {
Z
Zhu Yi 已提交
7954 7955 7956 7957
		IWL_ERROR("failed to set hw settings\n");
		goto out_iounmap;
	}

7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981
	/***********************
	 * 6. Setup priv
	 * ********************/
	priv->retry_rate = 1;
	priv->ibss_beacon = NULL;

	spin_lock_init(&priv->lock);
	spin_lock_init(&priv->power_data.lock);
	spin_lock_init(&priv->sta_lock);
	spin_lock_init(&priv->hcmd_lock);

	INIT_LIST_HEAD(&priv->free_frames);
	mutex_init(&priv->mutex);

	/* Clear the driver's (not device's) station table */
	iwl3945_clear_stations_table(priv);

	priv->data_retry_limit = -1;
	priv->ieee_channels = NULL;
	priv->ieee_rates = NULL;
	priv->band = IEEE80211_BAND_2GHZ;

	priv->iw_mode = NL80211_IFTYPE_STATION;

C
Christoph Hellwig 已提交
7982
	if (iwl3945_param_qos_enable)
Z
Zhu Yi 已提交
7983 7984
		priv->qos_data.qos_enable = 1;

C
Christoph Hellwig 已提交
7985
	iwl3945_reset_qos(priv);
Z
Zhu Yi 已提交
7986 7987 7988 7989 7990 7991 7992 7993 7994 7995

	priv->qos_data.qos_active = 0;
	priv->qos_data.qos_cap.val = 0;


	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;

7996
	err = iwl3945_init_channel_map(priv);
Z
Zhu Yi 已提交
7997
	if (err) {
7998
		IWL_ERROR("initializing regulatory failed: %d\n", err);
Z
Zhu Yi 已提交
7999 8000 8001
		goto out_release_irq;
	}

8002
	err = iwl3945_init_geos(priv);
Z
Zhu Yi 已提交
8003
	if (err) {
8004 8005
		IWL_ERROR("initializing geos failed: %d\n", err);
		goto out_free_channel_map;
Z
Zhu Yi 已提交
8006 8007
	}

8008 8009 8010 8011 8012 8013 8014 8015 8016 8017 8018 8019
	printk(KERN_INFO DRV_NAME
		": Detected Intel Wireless WiFi Link %s\n", priv->cfg->name);

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

	/* Initialize module parameter values here */
	/* Disable radio (SW RF KILL) via parameter when loading driver */
	if (iwl3945_param_disable) {
		set_bit(STATUS_RF_KILL_SW, &priv->status);
		IWL_DEBUG_INFO("Radio disabled.\n");
8020 8021
	}

8022 8023 8024 8025 8026 8027 8028 8029 8030 8031

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

	spin_lock_irqsave(&priv->lock, flags);
	iwl3945_disable_interrupts(priv);
	spin_unlock_irqrestore(&priv->lock, flags);

	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
8032
	if (err) {
8033 8034
		IWL_ERROR("failed to create sysfs device attributes\n");
		goto out_free_geos;
8035 8036
	}

8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050
	iwl3945_set_rxon_channel(priv, IEEE80211_BAND_2GHZ, 6);
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);

	/***********************
	 * 9. Conclude
	 * ********************/
	pci_save_state(pdev);
	pci_disable_device(pdev);

	/*********************************
	 * 10. Setup and Register mac80211
	 * *******************************/

8051 8052 8053
	err = ieee80211_register_hw(priv->hw);
	if (err) {
		IWL_ERROR("Failed to register network device (error %d)\n", err);
8054
		goto  out_remove_sysfs;
8055
	}
Z
Zhu Yi 已提交
8056

8057 8058
	priv->hw->conf.beacon_int = 100;
	priv->mac80211_registered = 1;
8059

Z
Zhu Yi 已提交
8060

8061 8062 8063 8064 8065
	err = iwl3945_rfkill_init(priv);
	if (err)
		IWL_ERROR("Unable to initialize RFKILL system. "
				  "Ignoring error: %d\n", err);

Z
Zhu Yi 已提交
8066 8067
	return 0;

8068 8069
 out_remove_sysfs:
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
8070 8071 8072 8073
 out_free_geos:
	iwl3945_free_geos(priv);
 out_free_channel_map:
	iwl3945_free_channel_map(priv);
8074

Z
Zhu Yi 已提交
8075 8076 8077 8078

 out_release_irq:
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
C
Christoph Hellwig 已提交
8079
	iwl3945_unset_hw_setting(priv);
Z
Zhu Yi 已提交
8080 8081 8082 8083 8084 8085 8086 8087 8088 8089 8090 8091 8092 8093

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

8094
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
8095
{
C
Christoph Hellwig 已提交
8096
	struct iwl3945_priv *priv = pci_get_drvdata(pdev);
8097
	unsigned long flags;
Z
Zhu Yi 已提交
8098 8099 8100 8101 8102 8103 8104

	if (!priv)
		return;

	IWL_DEBUG_INFO("*** UNLOAD DRIVER ***\n");

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

C
Christoph Hellwig 已提交
8106
	iwl3945_down(priv);
Z
Zhu Yi 已提交
8107

8108 8109 8110 8111 8112 8113 8114 8115 8116
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
	iwl3945_disable_interrupts(priv);
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

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

8119
	iwl3945_rfkill_unregister(priv);
C
Christoph Hellwig 已提交
8120
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
8121 8122

	if (priv->rxq.bd)
C
Christoph Hellwig 已提交
8123 8124
		iwl3945_rx_queue_free(priv, &priv->rxq);
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
8125

C
Christoph Hellwig 已提交
8126 8127
	iwl3945_unset_hw_setting(priv);
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
8128

8129
	if (priv->mac80211_registered)
Z
Zhu Yi 已提交
8130 8131
		ieee80211_unregister_hw(priv->hw);

8132 8133 8134
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
8135
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
8136 8137 8138 8139 8140 8141 8142 8143 8144 8145
	 * 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);

8146 8147
	iwl3945_free_channel_map(priv);
	iwl3945_free_geos(priv);
8148
	kfree(priv->scan);
Z
Zhu Yi 已提交
8149 8150 8151 8152 8153 8154 8155 8156
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}

#ifdef CONFIG_PM

C
Christoph Hellwig 已提交
8157
static int iwl3945_pci_suspend(struct pci_dev *pdev, pm_message_t state)
Z
Zhu Yi 已提交
8158
{
C
Christoph Hellwig 已提交
8159
	struct iwl3945_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
8160

8161 8162 8163 8164 8165
	if (priv->is_open) {
		set_bit(STATUS_IN_SUSPEND, &priv->status);
		iwl3945_mac_stop(priv->hw);
		priv->is_open = 1;
	}
Z
Zhu Yi 已提交
8166 8167 8168 8169 8170 8171

	pci_set_power_state(pdev, PCI_D3hot);

	return 0;
}

C
Christoph Hellwig 已提交
8172
static int iwl3945_pci_resume(struct pci_dev *pdev)
Z
Zhu Yi 已提交
8173
{
C
Christoph Hellwig 已提交
8174
	struct iwl3945_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
8175 8176 8177

	pci_set_power_state(pdev, PCI_D0);

8178 8179
	if (priv->is_open)
		iwl3945_mac_start(priv->hw);
Z
Zhu Yi 已提交
8180

8181
	clear_bit(STATUS_IN_SUSPEND, &priv->status);
Z
Zhu Yi 已提交
8182 8183 8184 8185 8186
	return 0;
}

#endif /* CONFIG_PM */

8187
/*************** RFKILL FUNCTIONS **********/
8188
#ifdef CONFIG_IWL3945_RFKILL
8189 8190 8191 8192 8193 8194
/* software rf-kill from user */
static int iwl3945_rfkill_soft_rf_kill(void *data, enum rfkill_state state)
{
	struct iwl3945_priv *priv = data;
	int err = 0;

8195
	if (!priv->rfkill)
8196 8197 8198 8199 8200
	return 0;

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

T
Tomas Winkler 已提交
8201
	IWL_DEBUG_RF_KILL("we received soft RFKILL set to state %d\n", state);
8202 8203 8204
	mutex_lock(&priv->mutex);

	switch (state) {
8205
	case RFKILL_STATE_UNBLOCKED:
8206
		if (iwl3945_is_rfkill_hw(priv)) {
8207
			err = -EBUSY;
8208 8209 8210
			goto out_unlock;
		}
		iwl3945_radio_kill_sw(priv, 0);
8211
		break;
8212
	case RFKILL_STATE_SOFT_BLOCKED:
8213 8214
		iwl3945_radio_kill_sw(priv, 1);
		break;
8215
	default:
T
Tomas Winkler 已提交
8216
		IWL_WARNING("we received unexpected RFKILL state %d\n", state);
8217
		break;
8218
	}
8219
out_unlock:
8220 8221 8222 8223 8224 8225 8226 8227 8228 8229 8230 8231 8232
	mutex_unlock(&priv->mutex);

	return err;
}

int iwl3945_rfkill_init(struct iwl3945_priv *priv)
{
	struct device *device = wiphy_dev(priv->hw->wiphy);
	int ret = 0;

	BUG_ON(device == NULL);

	IWL_DEBUG_RF_KILL("Initializing RFKILL.\n");
8233 8234
	priv->rfkill = rfkill_allocate(device, RFKILL_TYPE_WLAN);
	if (!priv->rfkill) {
8235 8236 8237 8238 8239
		IWL_ERROR("Unable to allocate rfkill device.\n");
		ret = -ENOMEM;
		goto error;
	}

8240 8241 8242 8243 8244
	priv->rfkill->name = priv->cfg->name;
	priv->rfkill->data = priv;
	priv->rfkill->state = RFKILL_STATE_UNBLOCKED;
	priv->rfkill->toggle_radio = iwl3945_rfkill_soft_rf_kill;
	priv->rfkill->user_claim_unsupported = 1;
8245

8246 8247
	priv->rfkill->dev.class->suspend = NULL;
	priv->rfkill->dev.class->resume = NULL;
8248

8249
	ret = rfkill_register(priv->rfkill);
8250 8251
	if (ret) {
		IWL_ERROR("Unable to register rfkill: %d\n", ret);
8252
		goto freed_rfkill;
8253 8254 8255 8256 8257 8258
	}

	IWL_DEBUG_RF_KILL("RFKILL initialization complete.\n");
	return ret;

freed_rfkill:
8259 8260 8261
	if (priv->rfkill != NULL)
		rfkill_free(priv->rfkill);
	priv->rfkill = NULL;
8262 8263 8264 8265 8266 8267 8268 8269

error:
	IWL_DEBUG_RF_KILL("RFKILL initialization complete.\n");
	return ret;
}

void iwl3945_rfkill_unregister(struct iwl3945_priv *priv)
{
8270 8271
	if (priv->rfkill)
		rfkill_unregister(priv->rfkill);
8272

8273
	priv->rfkill = NULL;
8274 8275 8276 8277 8278 8279
}

/* set rf-kill to the right state. */
void iwl3945_rfkill_set_hw_state(struct iwl3945_priv *priv)
{

8280 8281 8282 8283 8284
	if (!priv->rfkill)
		return;

	if (iwl3945_is_rfkill_hw(priv)) {
		rfkill_force_state(priv->rfkill, RFKILL_STATE_HARD_BLOCKED);
8285
		return;
8286
	}
8287

8288 8289
	if (!iwl3945_is_rfkill_sw(priv))
		rfkill_force_state(priv->rfkill, RFKILL_STATE_UNBLOCKED);
8290
	else
8291
		rfkill_force_state(priv->rfkill, RFKILL_STATE_SOFT_BLOCKED);
8292 8293 8294
}
#endif

Z
Zhu Yi 已提交
8295 8296 8297 8298 8299 8300
/*****************************************************************************
 *
 * driver and module entry point
 *
 *****************************************************************************/

C
Christoph Hellwig 已提交
8301
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
8302
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
8303 8304 8305
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
8306
#ifdef CONFIG_PM
C
Christoph Hellwig 已提交
8307 8308
	.suspend = iwl3945_pci_suspend,
	.resume = iwl3945_pci_resume,
Z
Zhu Yi 已提交
8309 8310 8311
#endif
};

C
Christoph Hellwig 已提交
8312
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
8313 8314 8315 8316 8317
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
8318 8319 8320 8321 8322 8323 8324

	ret = iwl3945_rate_control_register();
	if (ret) {
		IWL_ERROR("Unable to register rate control algorithm: %d\n", ret);
		return ret;
	}

C
Christoph Hellwig 已提交
8325
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
8326 8327
	if (ret) {
		IWL_ERROR("Unable to initialize PCI module\n");
8328
		goto error_register;
Z
Zhu Yi 已提交
8329
	}
8330
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
8331
	ret = driver_create_file(&iwl3945_driver.driver, &driver_attr_debug_level);
Z
Zhu Yi 已提交
8332 8333
	if (ret) {
		IWL_ERROR("Unable to create driver sysfs file\n");
8334
		goto error_debug;
Z
Zhu Yi 已提交
8335 8336 8337 8338
	}
#endif

	return ret;
8339 8340 8341 8342 8343 8344 8345 8346

#ifdef CONFIG_IWL3945_DEBUG
error_debug:
	pci_unregister_driver(&iwl3945_driver);
#endif
error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
8347 8348
}

C
Christoph Hellwig 已提交
8349
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
8350
{
8351
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
8352
	driver_remove_file(&iwl3945_driver.driver, &driver_attr_debug_level);
Z
Zhu Yi 已提交
8353
#endif
C
Christoph Hellwig 已提交
8354
	pci_unregister_driver(&iwl3945_driver);
8355
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
8356 8357
}

8358
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
8359

C
Christoph Hellwig 已提交
8360
module_param_named(antenna, iwl3945_param_antenna, int, 0444);
Z
Zhu Yi 已提交
8361
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
C
Christoph Hellwig 已提交
8362
module_param_named(disable, iwl3945_param_disable, int, 0444);
Z
Zhu Yi 已提交
8363
MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
C
Christoph Hellwig 已提交
8364
module_param_named(hwcrypto, iwl3945_param_hwcrypto, int, 0444);
Z
Zhu Yi 已提交
8365 8366
MODULE_PARM_DESC(hwcrypto,
		 "using hardware crypto engine (default 0 [software])\n");
C
Christoph Hellwig 已提交
8367
module_param_named(debug, iwl3945_param_debug, int, 0444);
Z
Zhu Yi 已提交
8368
MODULE_PARM_DESC(debug, "debug output mask");
C
Christoph Hellwig 已提交
8369
module_param_named(disable_hw_scan, iwl3945_param_disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
8370 8371
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

C
Christoph Hellwig 已提交
8372
module_param_named(queues_num, iwl3945_param_queues_num, int, 0444);
Z
Zhu Yi 已提交
8373 8374 8375
MODULE_PARM_DESC(queues_num, "number of hw queues.");

/* QoS */
C
Christoph Hellwig 已提交
8376
module_param_named(qos_enable, iwl3945_param_qos_enable, int, 0444);
Z
Zhu Yi 已提交
8377 8378
MODULE_PARM_DESC(qos_enable, "enable all QoS functionality");

C
Christoph Hellwig 已提交
8379 8380
module_exit(iwl3945_exit);
module_init(iwl3945_init);