iwl3945-base.c 233.5 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
 *
 * Portions of this file are derived from the ipw3945 project, as well
 * as portions of the ieee80211 subsystem header files.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 * Contact Information:
25
 *  Intel Linux Wireless <ilw@linux.intel.com>
Z
Zhu Yi 已提交
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/

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

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

#include <asm/div64.h>

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
int iwl3945_param_hwcrypto;        /* def: 0 = use software encryption */
72
int iwl3945_param_queues_num = IWL39_MAX_NUM_QUEUES; /* def: 8 Tx queues */
Z
Zhu Yi 已提交
73 74 75 76 77 78 79 80 81

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

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

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

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


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

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

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

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

139
	if (q->read_ptr > q->write_ptr)
Z
Zhu Yi 已提交
140 141 142 143 144 145 146 147 148 149 150
		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 已提交
151
int iwl3945_x2_queue_used(const struct iwl3945_queue *q, int i)
Z
Zhu Yi 已提交
152
{
153 154 155
	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 已提交
156 157
}

T
Tomas Winkler 已提交
158

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

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

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

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

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

	return 0;
}

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

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

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

	return -ENOMEM;
}

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

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

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

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

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

	return 0;
}

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

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

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

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

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

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

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

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

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

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

/**************************************************************/
340
#if 0 /* temporary disable till we add real remove station */
341 342 343 344 345
/**
 * iwl3945_remove_station - Remove driver's knowledge of station.
 *
 * NOTE:  This does not remove station from device's station table.
 */
C
Christoph Hellwig 已提交
346
static u8 iwl3945_remove_station(struct iwl3945_priv *priv, const u8 *addr, int is_ap)
Z
Zhu Yi 已提交
347 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
{
	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;
}
381
#endif
382 383 384 385 386 387

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

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

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

429
	/* These two conditions has the same outcome but keep them separate
Z
Zhu Yi 已提交
430 431 432 433 434 435 436 437 438 439 440 441
	  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 已提交
442
	IWL_DEBUG_ASSOC("Add STA ID %d: %pM\n", index, addr);
Z
Zhu Yi 已提交
443 444 445 446
	station = &priv->stations[index];
	station->used = 1;
	priv->num_stations++;

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

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

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

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

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

}

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

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

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

494 495 496 497 498 499 500 501 502 503
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 已提交
504
static inline int iwl3945_is_rfkill(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
505
{
506 507
	return iwl3945_is_rfkill_hw(priv) ||
		iwl3945_is_rfkill_sw(priv);
Z
Zhu Yi 已提交
508 509
}

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

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

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

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

521
#define IWL_CMD(x) case x: return #x
Z
Zhu Yi 已提交
522 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

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

604 605 606 607 608 609

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

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

	spin_lock_irqsave(&priv->hcmd_lock, flags);

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

	control_flags = (u32 *) tfd;

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

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

	txq->need_update = 1;
653 654

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

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

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

C
Christoph Hellwig 已提交
686
static int iwl3945_send_cmd_sync(struct iwl3945_priv *priv, struct iwl3945_host_cmd *cmd)
Z
Zhu Yi 已提交
687 688 689 690 691 692 693 694 695
{
	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);

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

	set_bit(STATUS_HCMD_ACTIVE, &priv->status);

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

C
Christoph Hellwig 已提交
708
	cmd_idx = iwl3945_enqueue_hcmd(priv, cmd);
Z
Zhu Yi 已提交
709 710
	if (cmd_idx < 0) {
		ret = cmd_idx;
C
Christoph Hellwig 已提交
711
		IWL_ERROR("Error sending %s: iwl3945_enqueue_hcmd failed: %d\n",
Z
Zhu Yi 已提交
712 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
			  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 已提交
755
		struct iwl3945_cmd *qcmd;
Z
Zhu Yi 已提交
756 757 758 759 760 761 762 763 764 765 766 767 768 769

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return 0;
}

/**
C
Christoph Hellwig 已提交
847
 * iwl3945_check_rxon_cmd - validate RXON structure is valid
Z
Zhu Yi 已提交
848 849 850 851 852
 *
 * 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 已提交
853
static int iwl3945_check_rxon_cmd(struct iwl3945_rxon_cmd *rxon)
Z
Zhu Yi 已提交
854 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
{
	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 已提交
919
		IWL_ERROR("Not a valid iwl3945_rxon_assoc_cmd field values\n");
Z
Zhu Yi 已提交
920 921 922 923 924 925
		return -1;
	}
	return 0;
}

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

	/* These items are only settable from the full RXON command */
937
	if (!(iwl3945_is_associated(priv)) ||
Z
Zhu Yi 已提交
938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967
	    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 已提交
968
static int iwl3945_send_rxon_assoc(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
969 970
{
	int rc = 0;
C
Christoph Hellwig 已提交
971 972 973
	struct iwl3945_rx_packet *res = NULL;
	struct iwl3945_rxon_assoc_cmd rxon_assoc;
	struct iwl3945_host_cmd cmd = {
Z
Zhu Yi 已提交
974 975 976 977 978
		.id = REPLY_RXON_ASSOC,
		.len = sizeof(rxon_assoc),
		.meta.flags = CMD_WANT_SKB,
		.data = &rxon_assoc,
	};
C
Christoph Hellwig 已提交
979 980
	const struct iwl3945_rxon_cmd *rxon1 = &priv->staging_rxon;
	const struct iwl3945_rxon_cmd *rxon2 = &priv->active_rxon;
Z
Zhu Yi 已提交
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

C
Christoph Hellwig 已提交
1275
	res = (struct iwl3945_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
	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 已提交
1300
static int iwl3945_update_sta_key_info(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
1301 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
				   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 已提交
1334
	iwl3945_send_add_station(priv, &priv->stations[sta_id].sta, 0);
Z
Zhu Yi 已提交
1335 1336 1337
	return 0;
}

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

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

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

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

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

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

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

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

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

1437 1438 1439 1440 1441
	/* 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 已提交
1442 1443
}

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

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

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

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

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

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

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

	return rc;
}

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

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

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

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

	/* eeprom is an array of 16bit values */
	for (addr = 0; addr < sz; addr += sizeof(u16)) {
1531
		u32 r;
Z
Zhu Yi 已提交
1532

1533 1534 1535 1536 1537 1538 1539
		_iwl3945_write32(priv, CSR_EEPROM_REG,
				 CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
		_iwl3945_clear_bit(priv, CSR_EEPROM_REG, CSR_EEPROM_REG_BIT_CMD);
		ret = iwl3945_poll_direct_bit(priv, CSR_EEPROM_REG,
					      CSR_EEPROM_REG_READ_VALID_MSK,
					      IWL_EEPROM_ACCESS_TIMEOUT);
		if (ret < 0) {
J
Jiri Slaby 已提交
1540
			IWL_ERROR("Time out reading EEPROM[%d]\n", addr);
1541
			return ret;
Z
Zhu Yi 已提交
1542
		}
1543 1544

		r = _iwl3945_read_direct32(priv, CSR_EEPROM_REG);
1545
		e[addr / 2] = le16_to_cpu((__force __le16)(r >> 16));
Z
Zhu Yi 已提交
1546 1547 1548 1549 1550
	}

	return 0;
}

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

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

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

	return ret_rates;
}

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

	/* 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 已提交
1608
	memcpy(frame->da, iwl3945_broadcast_addr, ETH_ALEN);
Z
Zhu Yi 已提交
1609
	memcpy(frame->sa, priv->mac_addr, ETH_ALEN);
C
Christoph Hellwig 已提交
1610
	memcpy(frame->bssid, iwl3945_broadcast_addr, ETH_ALEN);
Z
Zhu Yi 已提交
1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
	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;
1629

Z
Zhu Yi 已提交
1630 1631 1632
	/* ... fill it in... */
	*pos++ = WLAN_EID_SUPP_RATES;
	*pos = 0;
1633 1634 1635

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

1638
	cck_rates = IWL_CCK_RATES_MASK & active_rates;
C
Christoph Hellwig 已提交
1639
	ret_rates = iwl3945_supported_rate_to_ie(pos, cck_rates,
1640 1641 1642
			priv->active_rate_basic, &left);
	active_rates &= ~ret_rates;

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

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

 fill_end:
	return (u16)len;
}

/*
 * QoS  support
*/
C
Christoph Hellwig 已提交
1672 1673
static int iwl3945_send_qos_params_command(struct iwl3945_priv *priv,
				       struct iwl3945_qosparam_cmd *qos)
Z
Zhu Yi 已提交
1674 1675
{

C
Christoph Hellwig 已提交
1676 1677
	return iwl3945_send_cmd_pdu(priv, REPLY_QOS_PARAM,
				sizeof(struct iwl3945_qosparam_cmd), qos);
Z
Zhu Yi 已提交
1678 1679
}

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

1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706
	/* QoS always active in AP and ADHOC mode
	 * In STA mode wait for association
	 */
	if (priv->iw_mode == NL80211_IFTYPE_ADHOC ||
	    priv->iw_mode == NL80211_IFTYPE_AP)
		priv->qos_data.qos_active = 1;
	else
		priv->qos_data.qos_active = 0;


	/* check for legacy mode */
	if ((priv->iw_mode == NL80211_IFTYPE_ADHOC &&
	     (priv->active_rate & IWL_OFDM_RATES_MASK) == 0) ||
	    (priv->iw_mode == NL80211_IFTYPE_STATION &&
	     (priv->staging_rxon.flags & RXON_FLG_SHORT_SLOT_MSK) == 0)) {
Z
Zhu Yi 已提交
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
		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
{
	unsigned long flags;

	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
		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 已提交
1792
	if (force || iwl3945_is_associated(priv)) {
T
Tomas Winkler 已提交
1793
		IWL_DEBUG_QOS("send QoS cmd with QoS active %d \n",
Z
Zhu Yi 已提交
1794 1795
			      priv->qos_data.qos_active);

C
Christoph Hellwig 已提交
1796
		iwl3945_send_qos_params_command(priv,
Z
Zhu Yi 已提交
1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
				&(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 已提交
1817
/* for TIM  0-10 */
C
Christoph Hellwig 已提交
1818
static struct iwl3945_power_vec_entry range_0[IWL_POWER_AC] = {
Z
Zhu Yi 已提交
1819 1820 1821 1822 1823 1824 1825 1826
	{{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 已提交
1827
/* for TIM > 10 */
C
Christoph Hellwig 已提交
1828
static struct iwl3945_power_vec_entry range_1[IWL_POWER_AC] = {
Z
Zhu Yi 已提交
1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840
	{{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 已提交
1841
int iwl3945_power_init_handle(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
1842 1843
{
	int rc = 0, i;
C
Christoph Hellwig 已提交
1844 1845
	struct iwl3945_power_mgr *pow_data;
	int size = sizeof(struct iwl3945_power_vec_entry) * IWL_POWER_AC;
Z
Zhu Yi 已提交
1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
	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 已提交
1864
		struct iwl3945_powertable_cmd *cmd;
Z
Zhu Yi 已提交
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879

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

	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 已提交
1901
	memcpy(cmd, &range[mode].cmd, sizeof(struct iwl3945_powertable_cmd));
Z
Zhu Yi 已提交
1902 1903 1904 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

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

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

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

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

C
Christoph Hellwig 已提交
2015
	ret = iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031
	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 已提交
2032
static __le16 iwl3945_adjust_beacon_interval(u16 beacon_val)
Z
Zhu Yi 已提交
2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044
{
	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 已提交
2045
static void iwl3945_setup_rxon_timing(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066
{
	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);

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

		priv->rxon_timing.atim_window = 0;
	} else {
		priv->rxon_timing.beacon_interval =
C
Christoph Hellwig 已提交
2082
			iwl3945_adjust_beacon_interval(conf->beacon_int);
Z
Zhu Yi 已提交
2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
		/* 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 已提交
2101
static int iwl3945_scan_initiate(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2102
{
C
Christoph Hellwig 已提交
2103
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119
		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");
2120 2121 2122 2123
	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 已提交
2124 2125 2126 2127 2128 2129 2130 2131 2132
	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 已提交
2133
static int iwl3945_set_rxon_hwcrypto(struct iwl3945_priv *priv, int hw_decrypt)
Z
Zhu Yi 已提交
2134
{
C
Christoph Hellwig 已提交
2135
	struct iwl3945_rxon_cmd *rxon = &priv->staging_rxon;
Z
Zhu Yi 已提交
2136 2137 2138 2139 2140 2141 2142 2143 2144

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

	return 0;
}

2145 2146
static void iwl3945_set_flags_for_phymode(struct iwl3945_priv *priv,
					  enum ieee80211_band band)
Z
Zhu Yi 已提交
2147
{
2148
	if (band == IEEE80211_BAND_5GHZ) {
Z
Zhu Yi 已提交
2149 2150 2151 2152 2153
		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 已提交
2154
		/* Copied from iwl3945_bg_post_associate() */
Z
Zhu Yi 已提交
2155 2156 2157 2158 2159
		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;

2160
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
Z
Zhu Yi 已提交
2161 2162 2163 2164 2165 2166 2167 2168 2169
			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;
	}
}

/*
2170
 * initialize rxon structure with default values from eeprom
Z
Zhu Yi 已提交
2171
 */
2172 2173
static void iwl3945_connection_init_rx_config(struct iwl3945_priv *priv,
					      int mode)
Z
Zhu Yi 已提交
2174
{
C
Christoph Hellwig 已提交
2175
	const struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
2176 2177 2178

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

2179
	switch (mode) {
2180
	case NL80211_IFTYPE_AP:
Z
Zhu Yi 已提交
2181 2182 2183
		priv->staging_rxon.dev_type = RXON_DEV_TYPE_AP;
		break;

2184
	case NL80211_IFTYPE_STATION:
Z
Zhu Yi 已提交
2185 2186 2187 2188
		priv->staging_rxon.dev_type = RXON_DEV_TYPE_ESS;
		priv->staging_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
		break;

2189
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
2190 2191 2192 2193 2194 2195
		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;

2196
	case NL80211_IFTYPE_MONITOR:
Z
Zhu Yi 已提交
2197 2198 2199 2200
		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;
2201
	default:
2202
		IWL_ERROR("Unsupported interface type %d\n", mode);
2203
		break;
Z
Zhu Yi 已提交
2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214
	}

#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

2215
	ch_info = iwl3945_get_channel_info(priv, priv->band,
2216
				       le16_to_cpu(priv->active_rxon.channel));
Z
Zhu Yi 已提交
2217 2218 2219 2220 2221 2222 2223 2224

	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
	 */
2225
	if ((mode == NL80211_IFTYPE_ADHOC) && !(is_channel_ibss(ch_info)))
Z
Zhu Yi 已提交
2226 2227 2228 2229
		ch_info = &priv->channel_info[0];

	priv->staging_rxon.channel = cpu_to_le16(ch_info->channel);
	if (is_channel_a_band(ch_info))
2230
		priv->band = IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
2231
	else
2232
		priv->band = IEEE80211_BAND_2GHZ;
Z
Zhu Yi 已提交
2233

2234
	iwl3945_set_flags_for_phymode(priv, priv->band);
Z
Zhu Yi 已提交
2235 2236 2237 2238 2239 2240 2241

	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 已提交
2242
static int iwl3945_set_mode(struct iwl3945_priv *priv, int mode)
Z
Zhu Yi 已提交
2243
{
2244
	if (mode == NL80211_IFTYPE_ADHOC) {
C
Christoph Hellwig 已提交
2245
		const struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
2246

C
Christoph Hellwig 已提交
2247
		ch_info = iwl3945_get_channel_info(priv,
2248
			priv->band,
Z
Zhu Yi 已提交
2249 2250 2251 2252 2253 2254 2255 2256 2257
			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;
		}
	}

2258
	iwl3945_connection_init_rx_config(priv, mode);
Z
Zhu Yi 已提交
2259 2260
	memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);

C
Christoph Hellwig 已提交
2261
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
2262

T
Tomas Winkler 已提交
2263
	/* don't commit rxon if rf-kill is on*/
2264 2265 2266 2267 2268 2269 2270 2271 2272 2273
	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 已提交
2274
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
2275 2276 2277 2278

	return 0;
}

C
Christoph Hellwig 已提交
2279
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl3945_priv *priv,
2280
				      struct ieee80211_tx_info *info,
C
Christoph Hellwig 已提交
2281
				      struct iwl3945_cmd *cmd,
Z
Zhu Yi 已提交
2282 2283 2284
				      struct sk_buff *skb_frag,
				      int last_frag)
{
2285
	struct iwl3945_hw_key *keyinfo =
2286
	    &priv->stations[info->control.hw_key->hw_key_idx].keyinfo;
Z
Zhu Yi 已提交
2287 2288 2289 2290 2291

	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 已提交
2292
		IWL_DEBUG_TX("tx_cmd with AES hwcrypto\n");
Z
Zhu Yi 已提交
2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308
		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 |
2309
		    (info->control.hw_key->hw_key_idx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT;
Z
Zhu Yi 已提交
2310 2311 2312 2313 2314 2315 2316

		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 "
2317
			     "with key %d\n", info->control.hw_key->hw_key_idx);
Z
Zhu Yi 已提交
2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328
		break;

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

/*
 * handle build REPLY_TX command notification.
 */
C
Christoph Hellwig 已提交
2329 2330
static void iwl3945_build_tx_cmd_basic(struct iwl3945_priv *priv,
				  struct iwl3945_cmd *cmd,
2331
				  struct ieee80211_tx_info *info,
Z
Zhu Yi 已提交
2332 2333 2334
				  struct ieee80211_hdr *hdr,
				  int is_unicast, u8 std_id)
{
2335
	__le16 fc = hdr->frame_control;
Z
Zhu Yi 已提交
2336
	__le32 tx_flags = cmd->cmd.tx.tx_flags;
2337
	u8 rc_flags = info->control.rates[0].flags;
Z
Zhu Yi 已提交
2338 2339

	cmd->cmd.tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
2340
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Z
Zhu Yi 已提交
2341
		tx_flags |= TX_CMD_FLG_ACK_MSK;
2342
		if (ieee80211_is_mgmt(fc))
Z
Zhu Yi 已提交
2343
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
2344
		if (ieee80211_is_probe_resp(fc) &&
Z
Zhu Yi 已提交
2345 2346 2347 2348 2349 2350 2351 2352
		    !(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;
2353
	if (ieee80211_has_morefrags(fc))
Z
Zhu Yi 已提交
2354 2355
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

2356 2357
	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
2358
		cmd->cmd.tx.tid_tspec = qc[0] & 0xf;
Z
Zhu Yi 已提交
2359
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
2360
	} else {
Z
Zhu Yi 已提交
2361
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
2362
	}
Z
Zhu Yi 已提交
2363

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

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

2393 2394 2395
/**
 * iwl3945_get_sta_id - Find station's index within station table
 */
C
Christoph Hellwig 已提交
2396
static int iwl3945_get_sta_id(struct iwl3945_priv *priv, struct ieee80211_hdr *hdr)
Z
Zhu Yi 已提交
2397 2398 2399 2400
{
	int sta_id;
	u16 fc = le16_to_cpu(hdr->frame_control);

2401
	/* If this frame is broadcast or management, use broadcast station id */
Z
Zhu Yi 已提交
2402 2403 2404 2405 2406 2407
	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) {

2408 2409
	/* If we are a client station in a BSS network, use the special
	 * AP station entry (that's the only station we communicate with) */
2410
	case NL80211_IFTYPE_STATION:
Z
Zhu Yi 已提交
2411 2412 2413
		return IWL_AP_ID;

	/* If we are an AP, then find the station, or use BCAST */
2414
	case NL80211_IFTYPE_AP:
C
Christoph Hellwig 已提交
2415
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
2416 2417 2418 2419
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;
		return priv->hw_setting.bcast_sta_id;

2420 2421
	/* If this frame is going out to an IBSS network, find the station,
	 * or create a new station table entry */
2422
	case NL80211_IFTYPE_ADHOC: {
2423
		/* Create new station table entry */
C
Christoph Hellwig 已提交
2424
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
2425 2426 2427
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

C
Christoph Hellwig 已提交
2428
		sta_id = iwl3945_add_station(priv, hdr->addr1, 0, CMD_ASYNC);
Z
Zhu Yi 已提交
2429 2430 2431 2432

		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

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

Z
Zhu Yi 已提交
2444
	default:
J
Jiri Slaby 已提交
2445
		IWL_WARNING("Unknown mode of operation: %d\n", priv->iw_mode);
Z
Zhu Yi 已提交
2446 2447 2448 2449 2450 2451 2452
		return priv->hw_setting.bcast_sta_id;
	}
}

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

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
2478
	if (iwl3945_is_rfkill(priv)) {
Z
Zhu Yi 已提交
2479 2480 2481 2482
		IWL_DEBUG_DROP("Dropping - RF KILL\n");
		goto drop_unlock;
	}

2483
	if ((ieee80211_get_tx_rate(priv->hw, info)->hw_value & 0xFF) == IWL_INVALID_RATE) {
Z
Zhu Yi 已提交
2484 2485 2486 2487 2488 2489 2490
		IWL_ERROR("ERROR: No TX rate available.\n");
		goto drop_unlock;
	}

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

2491
	fc = hdr->frame_control;
Z
Zhu Yi 已提交
2492

2493
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
2494 2495
	if (ieee80211_is_auth(fc))
		IWL_DEBUG_TX("Sending AUTH frame\n");
2496
	else if (ieee80211_is_assoc_req(fc))
Z
Zhu Yi 已提交
2497
		IWL_DEBUG_TX("Sending ASSOC frame\n");
2498
	else if (ieee80211_is_reassoc_req(fc))
Z
Zhu Yi 已提交
2499 2500 2501
		IWL_DEBUG_TX("Sending REASSOC frame\n");
#endif

2502
	/* drop all data frame if we are not associated */
2503
	if (ieee80211_is_data(fc) &&
2504
	    (priv->iw_mode != NL80211_IFTYPE_MONITOR) && /* packet injection */
2505
	    (!iwl3945_is_associated(priv) ||
2506
	     ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id))) {
C
Christoph Hellwig 已提交
2507
		IWL_DEBUG_DROP("Dropping - !iwl3945_is_associated\n");
Z
Zhu Yi 已提交
2508 2509 2510 2511 2512
		goto drop_unlock;
	}

	spin_unlock_irqrestore(&priv->lock, flags);

2513
	hdr_len = ieee80211_hdrlen(fc);
2514 2515

	/* Find (or create) index into station table for destination station */
C
Christoph Hellwig 已提交
2516
	sta_id = iwl3945_get_sta_id(priv, hdr);
Z
Zhu Yi 已提交
2517
	if (sta_id == IWL_INVALID_STATION) {
J
Johannes Berg 已提交
2518 2519
		IWL_DEBUG_DROP("Dropping - INVALID STATION: %pM\n",
			       hdr->addr1);
Z
Zhu Yi 已提交
2520 2521 2522 2523 2524
		goto drop;
	}

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

2525 2526
	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
2527
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
Z
Zhu Yi 已提交
2528 2529 2530 2531 2532 2533 2534
		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;
	}
2535 2536

	/* Descriptor for chosen Tx queue */
Z
Zhu Yi 已提交
2537 2538 2539 2540 2541
	txq = &priv->txq[txq_id];
	q = &txq->q;

	spin_lock_irqsave(&priv->lock, flags);

2542
	/* Set up first empty TFD within this queue's circular TFD buffer */
2543
	tfd = &txq->bd[q->write_ptr];
Z
Zhu Yi 已提交
2544 2545
	memset(tfd, 0, sizeof(*tfd));
	control_flags = (u32 *) tfd;
2546
	idx = get_cmd_index(q, q->write_ptr, 0);
Z
Zhu Yi 已提交
2547

2548
	/* Set up driver data for this TFD */
C
Christoph Hellwig 已提交
2549
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl3945_tx_info));
2550
	txq->txb[q->write_ptr].skb[0] = skb;
2551 2552

	/* Init first empty entry in queue's array of Tx/cmd buffers */
Z
Zhu Yi 已提交
2553 2554 2555
	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));
2556 2557 2558 2559 2560 2561 2562

	/*
	 * 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 已提交
2563 2564
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
2565
				INDEX_TO_SEQ(q->write_ptr)));
2566 2567

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

2570 2571 2572 2573 2574 2575 2576 2577 2578
	/*
	 * 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 已提交
2579
	len = priv->hw_setting.tx_cmd_len +
C
Christoph Hellwig 已提交
2580
		sizeof(struct iwl3945_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
2581 2582 2583 2584 2585 2586 2587 2588 2589

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

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

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

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

2599
	if (info->control.hw_key)
2600
		iwl3945_build_tx_cmd_hwcrypto(priv, info, out_cmd, skb, 0);
Z
Zhu Yi 已提交
2601

2602 2603
	/* 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 已提交
2604 2605 2606 2607
	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 已提交
2608
		iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, phys_addr, len);
Z
Zhu Yi 已提交
2609 2610 2611
	}

	if (!len)
2612
		/* If there is no payload, then we use only one Tx buffer */
Z
Zhu Yi 已提交
2613 2614
		*control_flags = TFD_CTL_COUNT_SET(1);
	else
2615 2616
		/* Else use 2 buffers.
		 * Tell 3945 about any padding after MAC header */
Z
Zhu Yi 已提交
2617 2618 2619
		*control_flags = TFD_CTL_COUNT_SET(2) |
			TFD_CTL_PAD_SET(U32_PAD(len));

2620
	/* Total # bytes to be transmitted */
Z
Zhu Yi 已提交
2621 2622 2623 2624
	len = (u16)skb->len;
	out_cmd->cmd.tx.len = cpu_to_le16(len);

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

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

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

2633
	if (!ieee80211_has_morefrags(hdr->frame_control)) {
Z
Zhu Yi 已提交
2634
		txq->need_update = 1;
2635
		if (qc)
Z
Zhu Yi 已提交
2636 2637 2638 2639 2640 2641
			priv->stations[sta_id].tid[tid].seq_number = seq_number;
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

C
Christoph Hellwig 已提交
2642
	iwl3945_print_hex_dump(IWL_DL_TX, out_cmd->cmd.payload,
Z
Zhu Yi 已提交
2643 2644
			   sizeof(out_cmd->cmd.tx));

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

2648
	/* Tell device the write index *just past* this latest filled TFD */
T
Tomas Winkler 已提交
2649
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
C
Christoph Hellwig 已提交
2650
	rc = iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
2651 2652 2653 2654 2655
	spin_unlock_irqrestore(&priv->lock, flags);

	if (rc)
		return rc;

C
Christoph Hellwig 已提交
2656
	if ((iwl3945_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
2657 2658 2659 2660
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
C
Christoph Hellwig 已提交
2661
			iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
2662 2663 2664
			spin_unlock_irqrestore(&priv->lock, flags);
		}

2665
		ieee80211_stop_queue(priv->hw, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
2666 2667 2668 2669 2670 2671 2672 2673 2674 2675
	}

	return 0;

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

C
Christoph Hellwig 已提交
2676
static void iwl3945_set_rate(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
2677
{
2678
	const struct ieee80211_supported_band *sband = NULL;
Z
Zhu Yi 已提交
2679 2680 2681
	struct ieee80211_rate *rate;
	int i;

2682 2683
	sband = iwl3945_get_band(priv, priv->band);
	if (!sband) {
2684 2685 2686
		IWL_ERROR("Failed to set rate: unable to get hw mode\n");
		return;
	}
Z
Zhu Yi 已提交
2687 2688 2689 2690

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

2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701
	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 已提交
2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729
	}

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

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
2755
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
Z
Zhu Yi 已提交
2756 2757 2758 2759 2760 2761 2762 2763

	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 已提交
2764 2765 2766
	iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
	if (!iwl3945_grab_nic_access(priv))
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
2767 2768 2769 2770 2771 2772 2773 2774
	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;
	}

2775 2776
	if (priv->is_open)
		queue_work(priv->workqueue, &priv->restart);
Z
Zhu Yi 已提交
2777 2778 2779
	return;
}

C
Christoph Hellwig 已提交
2780
void iwl3945_set_decrypted_flag(struct iwl3945_priv *priv, struct sk_buff *skb,
Z
Zhu Yi 已提交
2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811
			    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;
	}
}

2812
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826

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

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

	/* 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 已提交
2981 2982
static void iwl3945_rx_reply_add_sta(struct iwl3945_priv *priv,
				 struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2983
{
C
Christoph Hellwig 已提交
2984
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
2985 2986 2987 2988 2989

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

C
Christoph Hellwig 已提交
2990 2991
static void iwl3945_rx_reply_error(struct iwl3945_priv *priv,
			       struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2992
{
C
Christoph Hellwig 已提交
2993
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005

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

	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 已提交
3035 3036
static void iwl3945_rx_pm_sleep_notif(struct iwl3945_priv *priv,
				  struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3037
{
3038
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
3039 3040
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_sleep_notification *sleep = &(pkt->u.sleep_notif);
Z
Zhu Yi 已提交
3041 3042 3043 3044 3045
	IWL_DEBUG_RX("sleep mode: %d, src: %d\n",
		     sleep->pm_sleep_mode, sleep->pm_wakeup_src);
#endif
}

C
Christoph Hellwig 已提交
3046 3047
static void iwl3945_rx_pm_debug_statistics_notif(struct iwl3945_priv *priv,
					     struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3048
{
C
Christoph Hellwig 已提交
3049
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
3050 3051 3052
	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 已提交
3053
	iwl3945_print_hex_dump(IWL_DL_RADIO, pkt->u.raw, le32_to_cpu(pkt->len));
Z
Zhu Yi 已提交
3054 3055
}

C
Christoph Hellwig 已提交
3056
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
3057
{
C
Christoph Hellwig 已提交
3058 3059
	struct iwl3945_priv *priv =
		container_of(work, struct iwl3945_priv, beacon_update);
Z
Zhu Yi 已提交
3060 3061 3062
	struct sk_buff *beacon;

	/* Pull updated AP beacon from mac80211. will fail if not in AP mode */
3063
	beacon = ieee80211_beacon_get(priv->hw, priv->vif);
Z
Zhu Yi 已提交
3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077

	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 已提交
3078
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3079 3080
}

C
Christoph Hellwig 已提交
3081 3082
static void iwl3945_rx_beacon_notif(struct iwl3945_priv *priv,
				struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3083
{
3084
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
3085 3086
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097
	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

3098
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
3099 3100 3101 3102 3103
	    (!test_bit(STATUS_EXIT_PENDING, &priv->status)))
		queue_work(priv->workqueue, &priv->beacon_update);
}

/* Service response to REPLY_SCAN_CMD (0x80) */
C
Christoph Hellwig 已提交
3104 3105
static void iwl3945_rx_reply_scan(struct iwl3945_priv *priv,
			      struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3106
{
3107
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
3108 3109 3110
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_scanreq_notification *notif =
	    (struct iwl3945_scanreq_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
3111 3112 3113 3114 3115 3116

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

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

	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;
3155
	priv->next_scan_jiffies = 0;
Z
Zhu Yi 已提交
3156 3157 3158
}

/* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
C
Christoph Hellwig 已提交
3159 3160
static void iwl3945_rx_scan_complete_notif(struct iwl3945_priv *priv,
				       struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3161
{
C
Christoph Hellwig 已提交
3162 3163
	struct iwl3945_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl3945_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
Z
Zhu Yi 已提交
3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176

	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",
3177 3178
		       (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) ?
							"2.4" : "5.2",
Z
Zhu Yi 已提交
3179 3180 3181
		       jiffies_to_msecs(elapsed_jiffies
					(priv->scan_pass_start, jiffies)));

3182 3183 3184 3185 3186 3187 3188
	/* 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 已提交
3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202

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

	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 已提交
3259
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
3260 3261 3262 3263 3264 3265 3266
 *
 * 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 已提交
3267
static void iwl3945_setup_rx_handlers(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3268
{
C
Christoph Hellwig 已提交
3269 3270 3271 3272
	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 已提交
3273
	priv->rx_handlers[SPECTRUM_MEASURE_NOTIFICATION] =
C
Christoph Hellwig 已提交
3274 3275
	    iwl3945_rx_spectrum_measure_notif;
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl3945_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
3276
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
C
Christoph Hellwig 已提交
3277 3278
	    iwl3945_rx_pm_debug_statistics_notif;
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
3279

3280 3281 3282 3283
	/*
	 * 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 已提交
3284
	 */
C
Christoph Hellwig 已提交
3285 3286
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
3287

C
Christoph Hellwig 已提交
3288 3289
	priv->rx_handlers[REPLY_SCAN_CMD] = iwl3945_rx_reply_scan;
	priv->rx_handlers[SCAN_START_NOTIFICATION] = iwl3945_rx_scan_start_notif;
Z
Zhu Yi 已提交
3290
	priv->rx_handlers[SCAN_RESULTS_NOTIFICATION] =
C
Christoph Hellwig 已提交
3291
	    iwl3945_rx_scan_results_notif;
Z
Zhu Yi 已提交
3292
	priv->rx_handlers[SCAN_COMPLETE_NOTIFICATION] =
C
Christoph Hellwig 已提交
3293 3294
	    iwl3945_rx_scan_complete_notif;
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
3295

3296
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
3297
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
3298 3299
}

3300 3301 3302 3303 3304 3305 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
/**
 * 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 已提交
3332
/**
C
Christoph Hellwig 已提交
3333
 * iwl3945_tx_cmd_complete - Pull unused buffers off the queue and reclaim them
Z
Zhu Yi 已提交
3334 3335 3336 3337 3338 3339
 * @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 已提交
3340 3341
static void iwl3945_tx_cmd_complete(struct iwl3945_priv *priv,
				struct iwl3945_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3342
{
C
Christoph Hellwig 已提交
3343
	struct iwl3945_rx_packet *pkt = (struct iwl3945_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
3344 3345 3346 3347 3348
	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 已提交
3349
	struct iwl3945_cmd *cmd;
Z
Zhu Yi 已提交
3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363

	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;

3364
	iwl3945_cmd_queue_reclaim(priv, txq_id, index);
Z
Zhu Yi 已提交
3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393

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

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

	spin_lock_irqsave(&q->lock, flags);

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

3466
	/* If power-saving is in use, make sure device is awake */
Z
Zhu Yi 已提交
3467
	if (test_bit(STATUS_POWER_PMI, &priv->status)) {
C
Christoph Hellwig 已提交
3468
		reg = iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
Z
Zhu Yi 已提交
3469 3470

		if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
C
Christoph Hellwig 已提交
3471
			iwl3945_set_bit(priv, CSR_GP_CNTRL,
Z
Zhu Yi 已提交
3472 3473 3474 3475
				    CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
			goto exit_unlock;
		}

C
Christoph Hellwig 已提交
3476
		rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
3477 3478 3479
		if (rc)
			goto exit_unlock;

3480
		/* Device expects a multiple of 8 */
C
Christoph Hellwig 已提交
3481
		iwl3945_write_direct32(priv, FH_RSCSR_CHNL0_WPTR,
Z
Zhu Yi 已提交
3482
				     q->write & ~0x7);
C
Christoph Hellwig 已提交
3483
		iwl3945_release_nic_access(priv);
3484 3485

	/* Else device is assumed to be awake */
Z
Zhu Yi 已提交
3486
	} else
3487
		/* Device expects a multiple of 8 */
C
Christoph Hellwig 已提交
3488
		iwl3945_write32(priv, FH_RSCSR_CHNL0_WPTR, q->write & ~0x7);
Z
Zhu Yi 已提交
3489 3490 3491 3492 3493 3494 3495 3496 3497 3498


	q->need_update = 0;

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

/**
3499
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
3500
 */
C
Christoph Hellwig 已提交
3501
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
3502 3503 3504 3505 3506 3507
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

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

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
C
Christoph Hellwig 已提交
3528
	while ((iwl3945_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
3529
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
3530
		element = rxq->rx_free.next;
C
Christoph Hellwig 已提交
3531
		rxb = list_entry(element, struct iwl3945_rx_mem_buffer, list);
Z
Zhu Yi 已提交
3532
		list_del(element);
3533 3534

		/* Point to Rx buffer via next RBD in circular buffer */
C
Christoph Hellwig 已提交
3535
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->dma_addr);
Z
Zhu Yi 已提交
3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546
		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);


3547 3548
	/* 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 已提交
3549 3550 3551 3552 3553
	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 已提交
3554
		rc = iwl3945_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
3555 3556 3557 3558 3559 3560 3561 3562
		if (rc)
			return rc;
	}

	return 0;
}

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

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592
		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 已提交
3593 3594 3595 3596 3597 3598 3599 3600 3601

		/* 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 已提交
3602 3603
		priv->alloc_rxb_skb++;
		list_del(element);
3604 3605

		/* Get physical address of RB/SKB */
Z
Zhu Yi 已提交
3606 3607 3608 3609 3610 3611 3612
		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);
3613 3614 3615 3616 3617
}

/*
 * this should be called while priv->lock is locked
 */
3618
static void __iwl3945_rx_replenish(void *data)
3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632
{
	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 已提交
3633 3634

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
3635
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
3636 3637 3638 3639
	spin_unlock_irqrestore(&priv->lock, flags);
}

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

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

Z
Zhu Yi 已提交
3676 3677 3678
	/* 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);
3679

Z
Zhu Yi 已提交
3680 3681 3682 3683 3684 3685 3686 3687
	/* 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 已提交
3688
void iwl3945_rx_queue_reset(struct iwl3945_priv *priv, struct iwl3945_rx_queue *rxq)
Z
Zhu Yi 已提交
3689 3690 3691 3692 3693 3694 3695 3696 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
{
	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 已提交
3735
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
3736
{
3737 3738
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
3739 3740
		return 60;

3741
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
3742
	 *   add 20 dB to make up for divide by 10 */
3743
	if (sig_ratio >= 100)
3744
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760

	/* 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 已提交
3761
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
3762 3763 3764 3765 3766 3767 3768 3769 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
{
	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;
}

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

3813 3814
	/* 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 已提交
3815
	r = iwl3945_hw_get_rx_read(priv);
Z
Zhu Yi 已提交
3816 3817
	i = rxq->read;

3818 3819
	if (iwl3945_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
		fill_rx = 1;
Z
Zhu Yi 已提交
3820 3821 3822 3823 3824 3825 3826
	/* 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];

3827
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
3828 3829 3830 3831 3832 3833 3834 3835 3836
		 * 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 已提交
3837
		pkt = (struct iwl3945_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850

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

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

3907 3908 3909
/**
 * iwl3945_tx_queue_update_write_ptr - Send new write index to hardware
 */
C
Christoph Hellwig 已提交
3910 3911
static int iwl3945_tx_queue_update_write_ptr(struct iwl3945_priv *priv,
				  struct iwl3945_tx_queue *txq)
Z
Zhu Yi 已提交
3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924
{
	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 已提交
3925
		reg = iwl3945_read32(priv, CSR_UCODE_DRV_GP1);
Z
Zhu Yi 已提交
3926 3927 3928

		if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
			IWL_DEBUG_INFO("Requesting wakeup, GP1 = 0x%x\n", reg);
C
Christoph Hellwig 已提交
3929
			iwl3945_set_bit(priv, CSR_GP_CNTRL,
Z
Zhu Yi 已提交
3930 3931 3932 3933 3934
				    CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
			return rc;
		}

		/* restore this queue's parameters in nic hardware. */
C
Christoph Hellwig 已提交
3935
		rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
3936 3937
		if (rc)
			return rc;
C
Christoph Hellwig 已提交
3938
		iwl3945_write_direct32(priv, HBUS_TARG_WRPTR,
3939
				     txq->q.write_ptr | (txq_id << 8));
C
Christoph Hellwig 已提交
3940
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
3941 3942 3943 3944

	/* 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 已提交
3945
		iwl3945_write32(priv, HBUS_TARG_WRPTR,
3946
			    txq->q.write_ptr | (txq_id << 8));
Z
Zhu Yi 已提交
3947 3948 3949 3950 3951 3952

	txq->need_update = 0;

	return rc;
}

3953
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
3954
static void iwl3945_print_rx_config_cmd(struct iwl3945_rxon_cmd *rxon)
Z
Zhu Yi 已提交
3955 3956
{
	IWL_DEBUG_RADIO("RX CONFIG:\n");
C
Christoph Hellwig 已提交
3957
	iwl3945_print_hex_dump(IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
Z
Zhu Yi 已提交
3958 3959 3960 3961 3962 3963 3964 3965
	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 已提交
3966 3967
	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 已提交
3968 3969 3970 3971
	IWL_DEBUG_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
}
#endif

C
Christoph Hellwig 已提交
3972
static void iwl3945_enable_interrupts(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3973 3974 3975
{
	IWL_DEBUG_ISR("Enabling interrupts\n");
	set_bit(STATUS_INT_ENABLED, &priv->status);
C
Christoph Hellwig 已提交
3976
	iwl3945_write32(priv, CSR_INT_MASK, CSR_INI_SET_MASK);
Z
Zhu Yi 已提交
3977 3978
}

3979 3980 3981 3982

/* call this function to flush any scheduled tasklet */
static inline void iwl_synchronize_irq(struct iwl3945_priv *priv)
{
T
Tomas Winkler 已提交
3983
	/* wait to make sure we flush pending tasklet*/
3984 3985 3986 3987 3988
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}


C
Christoph Hellwig 已提交
3989
static inline void iwl3945_disable_interrupts(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
3990 3991 3992 3993
{
	clear_bit(STATUS_INT_ENABLED, &priv->status);

	/* disable interrupts from uCode/NIC to host */
C
Christoph Hellwig 已提交
3994
	iwl3945_write32(priv, CSR_INT_MASK, 0x00000000);
Z
Zhu Yi 已提交
3995 3996 3997

	/* acknowledge/clear/reset any interrupts still pending
	 * from uCode or flow handler (Rx/Tx DMA) */
C
Christoph Hellwig 已提交
3998 3999
	iwl3945_write32(priv, CSR_INT, 0xffffffff);
	iwl3945_write32(priv, CSR_FH_INT_STATUS, 0xffffffff);
Z
Zhu Yi 已提交
4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025
	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 已提交
4026
static void iwl3945_dump_nic_error_log(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4027 4028 4029 4030 4031 4032 4033 4034
{
	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 已提交
4035
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
Z
Zhu Yi 已提交
4036 4037 4038 4039
		IWL_ERROR("Not valid error log pointer 0x%08X\n", base);
		return;
	}

C
Christoph Hellwig 已提交
4040
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
4041 4042 4043 4044 4045
	if (rc) {
		IWL_WARNING("Can not read from adapter at this time.\n");
		return;
	}

C
Christoph Hellwig 已提交
4046
	count = iwl3945_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
4047 4048 4049

	if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
		IWL_ERROR("Start IWL Error Log Dump:\n");
4050
		IWL_ERROR("Status: 0x%08lX, count: %d\n", priv->status, count);
Z
Zhu Yi 已提交
4051 4052 4053 4054 4055 4056 4057
	}

	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 已提交
4058
		desc = iwl3945_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
4059
		time =
C
Christoph Hellwig 已提交
4060
		    iwl3945_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
4061
		blink1 =
C
Christoph Hellwig 已提交
4062
		    iwl3945_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
4063
		blink2 =
C
Christoph Hellwig 已提交
4064
		    iwl3945_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
4065
		ilink1 =
C
Christoph Hellwig 已提交
4066
		    iwl3945_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
4067
		ilink2 =
C
Christoph Hellwig 已提交
4068
		    iwl3945_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
4069
		data1 =
C
Christoph Hellwig 已提交
4070
		    iwl3945_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
4071 4072 4073 4074 4075 4076 4077

		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 已提交
4078
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4079 4080 4081

}

4082
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
4083 4084

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

C
Christoph Hellwig 已提交
4127
static void iwl3945_dump_nic_event_log(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4128 4129 4130 4131 4132 4133 4134 4135 4136 4137
{
	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 已提交
4138
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
Z
Zhu Yi 已提交
4139 4140 4141 4142
		IWL_ERROR("Invalid event log pointer 0x%08X\n", base);
		return;
	}

C
Christoph Hellwig 已提交
4143
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
4144 4145 4146 4147 4148 4149
	if (rc) {
		IWL_WARNING("Can not read from adapter at this time.\n");
		return;
	}

	/* event log header */
C
Christoph Hellwig 已提交
4150 4151 4152 4153
	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 已提交
4154 4155 4156 4157 4158

	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
4159
		IWL_ERROR("Start IWL Event Log Dump: nothing in log\n");
C
Christoph Hellwig 已提交
4160
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4161 4162 4163
		return;
	}

4164
	IWL_ERROR("Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
4165 4166 4167 4168 4169
		  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 已提交
4170
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
4171 4172 4173
				    capacity - next_entry, mode);

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

C
Christoph Hellwig 已提交
4176
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
4177 4178 4179
}

/**
C
Christoph Hellwig 已提交
4180
 * iwl3945_irq_handle_error - called for HW or SW error interrupt from card
Z
Zhu Yi 已提交
4181
 */
C
Christoph Hellwig 已提交
4182
static void iwl3945_irq_handle_error(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4183
{
C
Christoph Hellwig 已提交
4184
	/* Set the FW error flag -- cleared on iwl3945_down */
Z
Zhu Yi 已提交
4185 4186 4187 4188 4189
	set_bit(STATUS_FW_ERROR, &priv->status);

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

4190
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
4191 4192 4193 4194
	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 已提交
4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207
	}
#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 已提交
4208
		if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
4209 4210 4211 4212 4213 4214 4215 4216
			memcpy(&priv->recovery_rxon, &priv->active_rxon,
			       sizeof(priv->recovery_rxon));
			priv->error_recovering = 1;
		}
		queue_work(priv->workqueue, &priv->restart);
	}
}

C
Christoph Hellwig 已提交
4217
static void iwl3945_error_recovery(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4218 4219 4220 4221 4222 4223
{
	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 已提交
4224
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
4225

C
Christoph Hellwig 已提交
4226
	iwl3945_add_station(priv, priv->bssid, 1, 0);
Z
Zhu Yi 已提交
4227 4228 4229 4230 4231 4232 4233

	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 已提交
4234
static void iwl3945_irq_tasklet(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4235 4236 4237 4238
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
4239
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
4240 4241 4242 4243 4244 4245 4246 4247
	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 已提交
4248 4249
	inta = iwl3945_read32(priv, CSR_INT);
	iwl3945_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
4250 4251 4252 4253

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

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

C
Christoph Hellwig 已提交
4282
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
4283 4284 4285 4286 4287 4288 4289 4290

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

4291
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
4292
	if (iwl3945_debug_level & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
4293
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
4294 4295 4296
		if (inta & CSR_INT_BIT_SCD)
			IWL_DEBUG_ISR("Scheduler finished to transmit "
				      "the frame/frames.\n");
Z
Zhu Yi 已提交
4297 4298 4299 4300 4301 4302 4303

		/* 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 */
4304
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
4305 4306 4307 4308 4309

	/* 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 已提交
4310
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
4311 4312 4313 4314 4315 4316
		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 已提交
4317 4318 4319 4320 4321 4322 4323
		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 已提交
4324 4325 4326 4327 4328 4329 4330 4331

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

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

	/* Discover which interrupts are active/pending */
C
Christoph Hellwig 已提交
4393 4394
	inta = iwl3945_read32(priv, CSR_INT);
	inta_fh = iwl3945_read32(priv, CSR_FH_INT_STATUS);
Z
Zhu Yi 已提交
4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405

	/* 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 已提交
4406
		IWL_WARNING("HARDWARE GONE?? INTA == 0x%08x\n", inta);
4407
		goto unplugged;
Z
Zhu Yi 已提交
4408 4409 4410 4411 4412
	}

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

4413 4414
	inta &= ~CSR_INT_BIT_SCD;

C
Christoph Hellwig 已提交
4415
	/* iwl3945_irq_tasklet() will service interrupts and re-enable them */
4416 4417
	if (likely(inta || inta_fh))
		tasklet_schedule(&priv->irq_tasklet);
4418
unplugged:
Z
Zhu Yi 已提交
4419 4420 4421 4422 4423 4424
	spin_unlock(&priv->lock);

	return IRQ_HANDLED;

 none:
	/* re-enable interrupts here since we don't have anything to service. */
4425 4426 4427
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
		iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
4428 4429 4430 4431 4432 4433
	spin_unlock(&priv->lock);
	return IRQ_NONE;
}

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

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

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

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

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

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

4523 4524 4525 4526 4527
/**
 * iwl3945_get_channel_info - Find driver's private channel info
 *
 * Based on band and channel number.
 */
C
Christoph Hellwig 已提交
4528
const struct iwl3945_channel_info *iwl3945_get_channel_info(const struct iwl3945_priv *priv,
4529
						    enum ieee80211_band band, u16 channel)
Z
Zhu Yi 已提交
4530 4531 4532
{
	int i;

4533 4534
	switch (band) {
	case IEEE80211_BAND_5GHZ:
Z
Zhu Yi 已提交
4535 4536 4537 4538 4539 4540
		for (i = 14; i < priv->channel_count; i++) {
			if (priv->channel_info[i].channel == channel)
				return &priv->channel_info[i];
		}
		break;

4541
	case IEEE80211_BAND_2GHZ:
Z
Zhu Yi 已提交
4542 4543 4544
		if (channel >= 1 && channel <= 14)
			return &priv->channel_info[channel - 1];
		break;
4545 4546
	case IEEE80211_NUM_BANDS:
		WARN_ON(1);
Z
Zhu Yi 已提交
4547 4548 4549 4550 4551 4552 4553 4554
	}

	return NULL;
}

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

4555 4556 4557
/**
 * iwl3945_init_channel_map - Set up driver's info for all possible channels
 */
C
Christoph Hellwig 已提交
4558
static int iwl3945_init_channel_map(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4559 4560 4561
{
	int eeprom_ch_count = 0;
	const u8 *eeprom_ch_index = NULL;
C
Christoph Hellwig 已提交
4562
	const struct iwl3945_eeprom_channel *eeprom_ch_info = NULL;
Z
Zhu Yi 已提交
4563
	int band, ch;
C
Christoph Hellwig 已提交
4564
	struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579

	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 已提交
4580 4581 4582 4583 4584
	    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 已提交
4585 4586 4587

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

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

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

4637
			IWL_DEBUG_INFO("Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x"
Z
Zhu Yi 已提交
4638 4639 4640 4641
				       " %ddBm): Ad-Hoc %ssupported\n",
				       ch_info->channel,
				       is_channel_a_band(ch_info) ?
				       "5.2" : "2.4",
4642
				       CHECK_AND_PRINT(VALID),
Z
Zhu Yi 已提交
4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666
				       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++;
		}
	}

4667
	/* Set up txpower settings in driver for all channels */
Z
Zhu Yi 已提交
4668 4669 4670 4671 4672 4673
	if (iwl3945_txpower_set_from_eeprom(priv))
		return -EIO;

	return 0;
}

4674 4675 4676 4677 4678 4679 4680 4681 4682
/*
 * 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 已提交
4683 4684 4685
/* 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.  */
4686 4687 4688 4689 4690
#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 已提交
4691 4692 4693 4694 4695 4696 4697 4698

/* 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 */
4699
#define IWL_ACTIVE_QUIET_TIME       __constant_cpu_to_le16(10)	/* msec */
Z
Zhu Yi 已提交
4700 4701 4702 4703 4704 4705 4706 4707 4708

/* 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 已提交
4709
#define IWL_SCAN_PROBE_MASK(n)	 (BIT(n) | (BIT(n) - BIT(1)))
4710

4711
static inline u16 iwl3945_get_active_dwell_time(struct iwl3945_priv *priv,
4712 4713
						enum ieee80211_band band,
						u8 n_probes)
Z
Zhu Yi 已提交
4714
{
4715
	if (band == IEEE80211_BAND_5GHZ)
4716 4717
		return IWL_ACTIVE_DWELL_TIME_52 +
			IWL_ACTIVE_DWELL_FACTOR_52GHZ * (n_probes + 1);
Z
Zhu Yi 已提交
4718
	else
4719 4720
		return IWL_ACTIVE_DWELL_TIME_24 +
			IWL_ACTIVE_DWELL_FACTOR_24GHZ * (n_probes + 1);
Z
Zhu Yi 已提交
4721 4722
}

4723 4724
static u16 iwl3945_get_passive_dwell_time(struct iwl3945_priv *priv,
					  enum ieee80211_band band)
Z
Zhu Yi 已提交
4725
{
4726
	u16 passive = (band == IEEE80211_BAND_2GHZ) ?
Z
Zhu Yi 已提交
4727 4728 4729
	    IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_24 :
	    IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_52;

C
Christoph Hellwig 已提交
4730
	if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742
		/* 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;
}

4743 4744
static int iwl3945_get_channels_for_scan(struct iwl3945_priv *priv,
					 enum ieee80211_band band,
4745
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
4746
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
4747 4748
{
	const struct ieee80211_channel *channels = NULL;
4749
	const struct ieee80211_supported_band *sband;
C
Christoph Hellwig 已提交
4750
	const struct iwl3945_channel_info *ch_info;
Z
Zhu Yi 已提交
4751 4752 4753 4754
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

4755 4756
	sband = iwl3945_get_band(priv, band);
	if (!sband)
Z
Zhu Yi 已提交
4757 4758
		return 0;

4759
	channels = sband->channels;
Z
Zhu Yi 已提交
4760

4761
	active_dwell = iwl3945_get_active_dwell_time(priv, band, n_probes);
4762
	passive_dwell = iwl3945_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
4763

4764 4765 4766
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

4767
	for (i = 0, added = 0; i < sband->n_channels; i++) {
4768 4769 4770
		if (channels[i].flags & IEEE80211_CHAN_DISABLED)
			continue;

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

4773
		ch_info = iwl3945_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
4774
		if (!is_channel_valid(ch_info)) {
4775
			IWL_DEBUG_SCAN("Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
4776 4777 4778 4779
				       scan_ch->channel);
			continue;
		}

4780 4781 4782 4783 4784
		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 已提交
4785
		if (!is_active || is_channel_passive(ch_info) ||
4786
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
4787
			scan_ch->type = 0;	/* passive */
4788 4789 4790
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
4791
			scan_ch->type = 1;	/* active */
4792
		}
Z
Zhu Yi 已提交
4793

4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806
		/* 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 已提交
4807

4808
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
4809 4810 4811 4812
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
4813
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
4814 4815 4816 4817
			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
4818
			 * power level:
4819
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836
			 */
		}

		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 已提交
4837
static void iwl3945_init_hw_rates(struct iwl3945_priv *priv,
Z
Zhu Yi 已提交
4838 4839 4840 4841 4842
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
4843 4844 4845 4846 4847
		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 已提交
4848
			/*
4849
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
4850
			 */
C
Christoph Hellwig 已提交
4851
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
4852
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
4853 4854 4855 4856 4857
		}
	}
}

/**
C
Christoph Hellwig 已提交
4858
 * iwl3945_init_geos - Initialize mac80211's geo/channel info based from eeprom
Z
Zhu Yi 已提交
4859
 */
C
Christoph Hellwig 已提交
4860
static int iwl3945_init_geos(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4861
{
C
Christoph Hellwig 已提交
4862
	struct iwl3945_channel_info *ch;
4863
	struct ieee80211_supported_band *sband;
Z
Zhu Yi 已提交
4864 4865 4866 4867 4868
	struct ieee80211_channel *channels;
	struct ieee80211_channel *geo_ch;
	struct ieee80211_rate *rates;
	int i = 0;

4869 4870
	if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
	    priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
Z
Zhu Yi 已提交
4871 4872 4873 4874 4875 4876 4877
		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);
4878
	if (!channels)
Z
Zhu Yi 已提交
4879 4880
		return -ENOMEM;

4881
	rates = kzalloc((sizeof(struct ieee80211_rate) * (IWL_RATE_COUNT + 1)),
Z
Zhu Yi 已提交
4882 4883 4884 4885 4886 4887 4888
			GFP_KERNEL);
	if (!rates) {
		kfree(channels);
		return -ENOMEM;
	}

	/* 5.2GHz channels start after the 2.4GHz channels */
4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899
	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 已提交
4900 4901 4902 4903

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

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

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

4909 4910
		/* FIXME: might be removed if scan is OK*/
		if (!is_channel_valid(ch))
Z
Zhu Yi 已提交
4911 4912 4913
			continue;

		if (is_channel_a_band(ch))
4914
			sband =  &priv->bands[IEEE80211_BAND_5GHZ];
4915
		else
4916
			sband =  &priv->bands[IEEE80211_BAND_2GHZ];
Z
Zhu Yi 已提交
4917

4918 4919 4920
		geo_ch = &sband->channels[sband->n_channels++];

		geo_ch->center_freq = ieee80211_channel_to_frequency(ch->channel);
4921 4922
		geo_ch->max_power = ch->max_power_avg;
		geo_ch->max_antenna_gain = 0xff;
4923
		geo_ch->hw_value = ch->channel;
Z
Zhu Yi 已提交
4924 4925

		if (is_channel_valid(ch)) {
4926 4927
			if (!(ch->flags & EEPROM_CHANNEL_IBSS))
				geo_ch->flags |= IEEE80211_CHAN_NO_IBSS;
Z
Zhu Yi 已提交
4928

4929 4930
			if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
				geo_ch->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
Z
Zhu Yi 已提交
4931 4932

			if (ch->flags & EEPROM_CHANNEL_RADAR)
4933
				geo_ch->flags |= IEEE80211_CHAN_RADAR;
Z
Zhu Yi 已提交
4934 4935 4936 4937

			if (ch->max_power_avg > priv->max_channel_txpower_limit)
				priv->max_channel_txpower_limit =
				    ch->max_power_avg;
4938
		} else {
4939
			geo_ch->flags |= IEEE80211_CHAN_DISABLED;
4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950
		}

		/* 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 已提交
4951 4952
	}

T
Tomas Winkler 已提交
4953 4954
	if ((priv->bands[IEEE80211_BAND_5GHZ].n_channels == 0) &&
	     priv->cfg->sku & IWL_SKU_A) {
Z
Zhu Yi 已提交
4955 4956 4957 4958
		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 已提交
4959
		 priv->cfg->sku &= ~IWL_SKU_A;
Z
Zhu Yi 已提交
4960 4961 4962 4963
	}

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

4967 4968 4969 4970 4971 4972
	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 已提交
4973 4974 4975 4976 4977 4978

	set_bit(STATUS_GEO_CONFIGURED, &priv->status);

	return 0;
}

4979 4980 4981 4982 4983 4984 4985 4986 4987 4988
/*
 * 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 已提交
4989 4990 4991 4992 4993 4994
/******************************************************************************
 *
 * uCode download functions
 *
 ******************************************************************************/

C
Christoph Hellwig 已提交
4995
static void iwl3945_dealloc_ucode_pci(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
4996
{
4997 4998 4999 5000 5001 5002
	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 已提交
5003 5004 5005
}

/**
C
Christoph Hellwig 已提交
5006
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
5007 5008
 *     looking at all data.
 */
5009
static int iwl3945_verify_inst_full(struct iwl3945_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
5010 5011 5012 5013 5014 5015 5016 5017
{
	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 已提交
5018
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5019 5020 5021
	if (rc)
		return rc;

C
Christoph Hellwig 已提交
5022
	iwl3945_write_direct32(priv, HBUS_TARG_MEM_RADDR, RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
5023 5024 5025 5026 5027 5028

	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 已提交
5029
		val = _iwl3945_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040
		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 已提交
5041
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5042 5043

	if (!errcnt)
5044
		IWL_DEBUG_INFO("ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
5045 5046 5047 5048 5049 5050

	return rc;
}


/**
C
Christoph Hellwig 已提交
5051
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
5052 5053 5054
 *   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 已提交
5055
static int iwl3945_verify_inst_sparse(struct iwl3945_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
5056 5057 5058 5059 5060 5061 5062 5063
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

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

C
Christoph Hellwig 已提交
5064
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5065 5066 5067 5068 5069 5070 5071
	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 已提交
5072
		iwl3945_write_direct32(priv, HBUS_TARG_MEM_RADDR,
Z
Zhu Yi 已提交
5073
			i + RTC_INST_LOWER_BOUND);
C
Christoph Hellwig 已提交
5074
		val = _iwl3945_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087
		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 已提交
5088
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5089 5090 5091 5092 5093 5094

	return rc;
}


/**
C
Christoph Hellwig 已提交
5095
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
5096 5097
 *    and verify its contents
 */
C
Christoph Hellwig 已提交
5098
static int iwl3945_verify_ucode(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5099 5100 5101 5102 5103 5104 5105 5106
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
5107
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
5108 5109 5110 5111 5112 5113 5114 5115
	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 已提交
5116
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
5117 5118 5119 5120 5121 5122 5123 5124
	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 已提交
5125
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
5126 5127 5128 5129 5130 5131 5132
	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");

5133 5134 5135
	/* 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 已提交
5136 5137
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
5138
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
5139 5140 5141 5142 5143 5144

	return rc;
}


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

C
Christoph Hellwig 已提交
5240 5241 5242 5243
	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 已提交
5244 5245 5246 5247 5248

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

C
Christoph Hellwig 已提交
5252
	rc = iwl3945_verify_bsm(priv);
Z
Zhu Yi 已提交
5253
	if (rc) {
C
Christoph Hellwig 已提交
5254
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5255 5256 5257 5258
		return rc;
	}

	/* Tell BSM to copy from BSM SRAM into instruction SRAM, when asked */
C
Christoph Hellwig 已提交
5259 5260
	iwl3945_write_prph(priv, BSM_WR_MEM_SRC_REG, 0x0);
	iwl3945_write_prph(priv, BSM_WR_MEM_DST_REG,
Z
Zhu Yi 已提交
5261
				 RTC_INST_LOWER_BOUND);
C
Christoph Hellwig 已提交
5262
	iwl3945_write_prph(priv, BSM_WR_DWCOUNT_REG, len / sizeof(u32));
Z
Zhu Yi 已提交
5263 5264 5265

	/* Load bootstrap code into instruction SRAM now,
	 *   to prepare to load "initialize" uCode */
C
Christoph Hellwig 已提交
5266
	iwl3945_write_prph(priv, BSM_WR_CTRL_REG,
Z
Zhu Yi 已提交
5267 5268 5269 5270
		BSM_WR_CTRL_REG_BIT_START);

	/* Wait for load of bootstrap uCode to finish */
	for (i = 0; i < 100; i++) {
C
Christoph Hellwig 已提交
5271
		done = iwl3945_read_prph(priv, BSM_WR_CTRL_REG);
Z
Zhu Yi 已提交
5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284
		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 已提交
5285
	iwl3945_write_prph(priv, BSM_WR_CTRL_REG,
Z
Zhu Yi 已提交
5286 5287
		BSM_WR_CTRL_REG_BIT_START_EN);

C
Christoph Hellwig 已提交
5288
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5289 5290 5291 5292

	return 0;
}

C
Christoph Hellwig 已提交
5293
static void iwl3945_nic_start(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5294 5295
{
	/* Remove all resets to allow NIC to operate */
C
Christoph Hellwig 已提交
5296
	iwl3945_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
5297 5298 5299
}

/**
C
Christoph Hellwig 已提交
5300
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
5301 5302 5303
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
C
Christoph Hellwig 已提交
5304
static int iwl3945_read_ucode(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5305
{
C
Christoph Hellwig 已提交
5306
	struct iwl3945_ucode *ucode;
5307
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
5308 5309
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
5310 5311 5312 5313
	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 已提交
5314 5315
	u8 *src;
	size_t len;
5316
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
5317 5318 5319

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337
	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 已提交
5338 5339
	}

5340 5341
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
5342 5343 5344 5345

	/* Make sure that we got at least our header! */
	if (ucode_raw->size < sizeof(*ucode)) {
		IWL_ERROR("File size way too small!\n");
5346
		ret = -EINVAL;
Z
Zhu Yi 已提交
5347 5348 5349 5350 5351 5352
		goto err_release;
	}

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

5353
	priv->ucode_ver = le32_to_cpu(ucode->ver);
5354
	api_ver = IWL_UCODE_API(priv->ucode_ver);
Z
Zhu Yi 已提交
5355 5356 5357 5358 5359 5360
	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);

5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379
	/* 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",
5380 5381 5382 5383
		       IWL_UCODE_MAJOR(priv->ucode_ver),
		       IWL_UCODE_MINOR(priv->ucode_ver),
		       IWL_UCODE_API(priv->ucode_ver),
		       IWL_UCODE_SERIAL(priv->ucode_ver));
5384 5385
	IWL_DEBUG_INFO("f/w package hdr ucode version raw = 0x%x\n",
		       priv->ucode_ver);
5386 5387 5388 5389 5390
	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 已提交
5391

5392

Z
Zhu Yi 已提交
5393 5394 5395 5396 5397 5398 5399
	/* 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);
5400
		ret = -EINVAL;
Z
Zhu Yi 已提交
5401 5402 5403 5404 5405
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
	if (inst_size > IWL_MAX_INST_SIZE) {
5406 5407 5408
		IWL_DEBUG_INFO("uCode instr len %d too large to fit in\n",
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
5409 5410 5411 5412
		goto err_release;
	}

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

	priv->ucode_data.len = data_size;
5446
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
5447 5448

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

5451 5452 5453
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
5454 5455

	/* Initialization instructions and data */
5456 5457
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
5458
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
5459 5460

		priv->ucode_init_data.len = init_data_size;
5461
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
5462 5463 5464 5465

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

	/* Bootstrap (instructions only, no data) */
5468 5469
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
5470
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
5471

5472 5473 5474
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
5475 5476 5477 5478 5479 5480

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

 err_release:
	release_firmware(ucode_raw);

 error:
5532
	return ret;
Z
Zhu Yi 已提交
5533 5534 5535 5536
}


/**
C
Christoph Hellwig 已提交
5537
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
5538 5539 5540 5541 5542 5543 5544
 *
 * 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 已提交
5545
static int iwl3945_set_ucode_ptrs(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556
{
	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 已提交
5557
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5558 5559 5560 5561 5562 5563
	if (rc) {
		spin_unlock_irqrestore(&priv->lock, flags);
		return rc;
	}

	/* Tell bootstrap uCode where to find image to load */
C
Christoph Hellwig 已提交
5564 5565 5566
	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 已提交
5567 5568
				 priv->ucode_data.len);

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

C
Christoph Hellwig 已提交
5574
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5575 5576 5577 5578 5579 5580 5581 5582 5583

	spin_unlock_irqrestore(&priv->lock, flags);

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

	return rc;
}

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


5627 5628 5629 5630
/* temporary */
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw,
				     struct sk_buff *skb);

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

C
Christoph Hellwig 已提交
5663
	rc = iwl3945_grab_nic_access(priv);
Z
Zhu Yi 已提交
5664
	if (rc) {
T
Tomas Winkler 已提交
5665
		IWL_WARNING("Can not read RFKILL status from adapter\n");
Z
Zhu Yi 已提交
5666 5667 5668
		return;
	}

C
Christoph Hellwig 已提交
5669
	rfkill = iwl3945_read_prph(priv, APMG_RFKILL_REG);
Z
Zhu Yi 已提交
5670
	IWL_DEBUG_INFO("RFKILL status: 0x%x\n", rfkill);
C
Christoph Hellwig 已提交
5671
	iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5672 5673 5674

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
5675
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
5676
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
5677
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
5678 5679 5680 5681 5682 5683 5684 5685 5686 5687
			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);

5688
	/* After the ALIVE response, we can send commands to 3945 uCode */
Z
Zhu Yi 已提交
5689 5690 5691 5692 5693
	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 已提交
5694
	if (iwl3945_is_rfkill(priv))
Z
Zhu Yi 已提交
5695 5696
		return;

5697
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
5698 5699 5700 5701

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

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

C
Christoph Hellwig 已提交
5704 5705 5706
	if (iwl3945_is_associated(priv)) {
		struct iwl3945_rxon_cmd *active_rxon =
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
5707 5708 5709 5710 5711 5712

		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 */
5713
		iwl3945_connection_init_rx_config(priv, priv->iw_mode);
Z
Zhu Yi 已提交
5714 5715 5716
		memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
	}

5717
	/* Configure Bluetooth device coexistence support */
C
Christoph Hellwig 已提交
5718
	iwl3945_send_bt_config(priv);
Z
Zhu Yi 已提交
5719 5720

	/* Configure the adapter for unassociated operation */
C
Christoph Hellwig 已提交
5721
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5722 5723 5724

	iwl3945_reg_txpower_periodic(priv);

5725 5726
	iwl3945_led_register(priv);

Z
Zhu Yi 已提交
5727
	IWL_DEBUG_INFO("ALIVE processing complete.\n");
5728
	set_bit(STATUS_READY, &priv->status);
5729
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
5730 5731

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

5734 5735 5736 5737 5738 5739 5740 5741
	/* 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 已提交
5742 5743 5744 5745 5746 5747
	return;

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

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

C
Christoph Hellwig 已提交
5750
static void __iwl3945_down(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762
{
	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 已提交
5763
	iwl3945_led_unregister(priv);
C
Christoph Hellwig 已提交
5764
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5765 5766 5767 5768 5769 5770 5771 5772 5773 5774

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

	/* tell the device to stop sending interrupts */
5778
	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
5779
	iwl3945_disable_interrupts(priv);
5780 5781
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
5782 5783 5784 5785

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

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

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

C
Christoph Hellwig 已提交
5821 5822
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
5823 5824

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
5825 5826
	if (!iwl3945_grab_nic_access(priv)) {
		iwl3945_write_prph(priv, APMG_CLK_DIS_REG,
Z
Zhu Yi 已提交
5827
					 APMG_CLK_VAL_DMA_CLK_RQT);
C
Christoph Hellwig 已提交
5828
		iwl3945_release_nic_access(priv);
Z
Zhu Yi 已提交
5829 5830 5831 5832 5833
	}
	spin_unlock_irqrestore(&priv->lock, flags);

	udelay(5);

C
Christoph Hellwig 已提交
5834 5835 5836
	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 已提交
5837 5838

 exit:
C
Christoph Hellwig 已提交
5839
	memset(&priv->card_alive, 0, sizeof(struct iwl3945_alive_resp));
Z
Zhu Yi 已提交
5840 5841 5842 5843 5844 5845

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
5846
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
5847 5848
}

C
Christoph Hellwig 已提交
5849
static void iwl3945_down(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5850 5851
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5852
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
5853
	mutex_unlock(&priv->mutex);
5854

C
Christoph Hellwig 已提交
5855
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
5856 5857 5858 5859
}

#define MAX_HW_RESTARTS 5

C
Christoph Hellwig 已提交
5860
static int __iwl3945_up(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871
{
	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");
5872 5873 5874
		return -ENODEV;
	}

5875
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
T
Tomas Winkler 已提交
5876
		IWL_ERROR("ucode not available for device bring up\n");
5877 5878 5879
		return -EIO;
	}

5880 5881 5882 5883 5884 5885 5886 5887 5888 5889
	/* 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 已提交
5890
	}
5891

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

C
Christoph Hellwig 已提交
5894
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
5895 5896 5897 5898 5899 5900
	if (rc) {
		IWL_ERROR("Unable to int nic\n");
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
C
Christoph Hellwig 已提交
5901 5902
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl3945_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
5903 5904 5905
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
C
Christoph Hellwig 已提交
5906 5907
	iwl3945_write32(priv, CSR_INT, 0xFFFFFFFF);
	iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
5908 5909

	/* really make sure rfkill handshake bits are cleared */
C
Christoph Hellwig 已提交
5910 5911
	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 已提交
5912 5913 5914 5915 5916

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

5919 5920 5921 5922
	/* 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 已提交
5923 5924
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

C
Christoph Hellwig 已提交
5925
		iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5926 5927 5928 5929

		/* load bootstrap state machine,
		 * load bootstrap program into processor's memory,
		 * prepare to load the "initialize" uCode */
C
Christoph Hellwig 已提交
5930
		rc = iwl3945_load_bsm(priv);
Z
Zhu Yi 已提交
5931 5932 5933 5934 5935 5936 5937

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

		/* start card; "initialize" will load runtime ucode */
C
Christoph Hellwig 已提交
5938
		iwl3945_nic_start(priv);
Z
Zhu Yi 已提交
5939 5940 5941 5942 5943 5944 5945

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

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
5946
	__iwl3945_down(priv);
5947
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961

	/* 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 已提交
5962
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
5963
{
C
Christoph Hellwig 已提交
5964 5965
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, init_alive_start.work);
Z
Zhu Yi 已提交
5966 5967 5968 5969 5970

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5971
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
5972 5973 5974
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5975
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
5976
{
C
Christoph Hellwig 已提交
5977 5978
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, alive_start.work);
Z
Zhu Yi 已提交
5979 5980 5981 5982 5983

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5984
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
5985 5986 5987
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5988
static void iwl3945_bg_rf_kill(struct work_struct *work)
Z
Zhu Yi 已提交
5989
{
C
Christoph Hellwig 已提交
5990
	struct iwl3945_priv *priv = container_of(work, struct iwl3945_priv, rf_kill);
Z
Zhu Yi 已提交
5991 5992 5993 5994 5995 5996 5997 5998

	wake_up_interruptible(&priv->wait_command_queue);

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

	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
5999
	if (!iwl3945_is_rfkill(priv)) {
Z
Zhu Yi 已提交
6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014
		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");
	}
6015

Z
Zhu Yi 已提交
6016
	mutex_unlock(&priv->mutex);
6017
	iwl3945_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
6018 6019 6020 6021
}

#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)

C
Christoph Hellwig 已提交
6022
static void iwl3945_bg_scan_check(struct work_struct *data)
Z
Zhu Yi 已提交
6023
{
C
Christoph Hellwig 已提交
6024 6025
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, scan_check.work);
Z
Zhu Yi 已提交
6026 6027 6028 6029 6030 6031 6032 6033 6034 6035

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

Z
Zhu Yi 已提交
6037
		if (!test_bit(STATUS_EXIT_PENDING, &priv->status))
C
Christoph Hellwig 已提交
6038
			iwl3945_send_scan_abort(priv);
Z
Zhu Yi 已提交
6039 6040 6041 6042
	}
	mutex_unlock(&priv->mutex);
}

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

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
6063
	if (!iwl3945_is_ready(priv)) {
Z
Zhu Yi 已提交
6064 6065 6066 6067
		IWL_WARNING("request scan called when driver not ready.\n");
		goto done;
	}

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

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

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

	/* 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 已提交
6171
		iwl3945_fill_probe_req(priv, (struct ieee80211_mgmt *)scan->data,
J
Johannes Berg 已提交
6172
			IWL_MAX_SCAN_SIZE - sizeof(*scan)));
Z
Zhu Yi 已提交
6173 6174 6175 6176 6177 6178
	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 */

6179
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
6180 6181 6182
		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;
6183
		band = IEEE80211_BAND_2GHZ;
6184
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
6185 6186
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
		scan->good_CRC_th = IWL_GOOD_CRC_TH;
6187
		band = IEEE80211_BAND_5GHZ;
6188
	} else {
Z
Zhu Yi 已提交
6189 6190 6191 6192 6193 6194 6195
		IWL_WARNING("Invalid scan band count\n");
		goto done;
	}

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

6196
	if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
Z
Zhu Yi 已提交
6197 6198
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

6199 6200 6201 6202
	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 已提交
6203

6204 6205 6206 6207 6208
	if (scan->channel_count == 0) {
		IWL_DEBUG_SCAN("channel count %d\n", scan->channel_count);
		goto done;
	}

Z
Zhu Yi 已提交
6209
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
6210
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
6211 6212 6213 6214
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
C
Christoph Hellwig 已提交
6215
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
6216 6217 6218 6219 6220 6221 6222 6223 6224 6225
	if (rc)
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
6226 6227 6228 6229 6230 6231 6232 6233
	/* 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);

6234
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
6235 6236 6237 6238
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
6239
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
6240
{
C
Christoph Hellwig 已提交
6241
	struct iwl3945_priv *priv = container_of(data, struct iwl3945_priv, up);
Z
Zhu Yi 已提交
6242 6243 6244 6245 6246

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
6247
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
6248
	mutex_unlock(&priv->mutex);
6249
	iwl3945_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
6250 6251
}

C
Christoph Hellwig 已提交
6252
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
6253
{
C
Christoph Hellwig 已提交
6254
	struct iwl3945_priv *priv = container_of(data, struct iwl3945_priv, restart);
Z
Zhu Yi 已提交
6255 6256 6257 6258

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

C
Christoph Hellwig 已提交
6259
	iwl3945_down(priv);
Z
Zhu Yi 已提交
6260 6261 6262
	queue_work(priv->workqueue, &priv->up);
}

C
Christoph Hellwig 已提交
6263
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
6264
{
C
Christoph Hellwig 已提交
6265 6266
	struct iwl3945_priv *priv =
	    container_of(data, struct iwl3945_priv, rx_replenish);
Z
Zhu Yi 已提交
6267 6268 6269 6270 6271

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
6272
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
6273 6274 6275
	mutex_unlock(&priv->mutex);
}

6276 6277
#define IWL_DELAY_NEXT_SCAN (HZ*2)

6278
static void iwl3945_post_associate(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
6279 6280 6281 6282
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

6283
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
6284
		IWL_ERROR("%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
6285 6286 6287 6288
		return;
	}


J
Johannes Berg 已提交
6289 6290
	IWL_DEBUG_ASSOC("Associated as %d to: %pM\n",
			priv->assoc_id, priv->active_rxon.bssid_addr);
Z
Zhu Yi 已提交
6291 6292 6293 6294

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

A
Abhijeet Kolekar 已提交
6295
	if (!priv->vif || !priv->is_open)
6296
		return;
A
Abhijeet Kolekar 已提交
6297

C
Christoph Hellwig 已提交
6298
	iwl3945_scan_cancel_timeout(priv, 200);
6299

Z
Zhu Yi 已提交
6300 6301 6302
	conf = ieee80211_get_hw_conf(priv->hw);

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

C
Christoph Hellwig 已提交
6305 6306 6307
	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 已提交
6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330
			      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;

6331
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
Z
Zhu Yi 已提交
6332 6333 6334 6335
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;

	}

C
Christoph Hellwig 已提交
6336
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6337 6338

	switch (priv->iw_mode) {
6339
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
6340
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
6341 6342
		break;

6343
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
6344

6345
		priv->assoc_id = 1;
C
Christoph Hellwig 已提交
6346
		iwl3945_add_station(priv, priv->bssid, 0, 0);
Z
Zhu Yi 已提交
6347
		iwl3945_sync_sta(priv, IWL_STA_ID,
6348
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
6349 6350
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
6351 6352
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
6353 6354 6355 6356 6357

		break;

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

C
Christoph Hellwig 已提交
6362
	iwl3945_activate_qos(priv, 0);
6363

6364 6365
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
6366 6367
}

C
Christoph Hellwig 已提交
6368
static void iwl3945_bg_abort_scan(struct work_struct *work)
Z
Zhu Yi 已提交
6369
{
C
Christoph Hellwig 已提交
6370
	struct iwl3945_priv *priv = container_of(work, struct iwl3945_priv, abort_scan);
Z
Zhu Yi 已提交
6371

C
Christoph Hellwig 已提交
6372
	if (!iwl3945_is_ready(priv))
Z
Zhu Yi 已提交
6373 6374 6375 6376 6377
		return;

	mutex_lock(&priv->mutex);

	set_bit(STATUS_SCAN_ABORTING, &priv->status);
C
Christoph Hellwig 已提交
6378
	iwl3945_send_scan_abort(priv);
Z
Zhu Yi 已提交
6379 6380 6381 6382

	mutex_unlock(&priv->mutex);
}

6383
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed);
6384

C
Christoph Hellwig 已提交
6385
static void iwl3945_bg_scan_completed(struct work_struct *work)
Z
Zhu Yi 已提交
6386
{
C
Christoph Hellwig 已提交
6387 6388
	struct iwl3945_priv *priv =
	    container_of(work, struct iwl3945_priv, scan_completed);
Z
Zhu Yi 已提交
6389 6390 6391 6392 6393 6394

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

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

6395
	if (test_bit(STATUS_CONF_PENDING, &priv->status))
6396
		iwl3945_mac_config(priv->hw, 0);
6397

Z
Zhu Yi 已提交
6398 6399 6400 6401 6402
	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 已提交
6403
	iwl3945_hw_reg_send_txpower(priv);
Z
Zhu Yi 已提交
6404 6405 6406 6407 6408 6409 6410 6411 6412
	mutex_unlock(&priv->mutex);
}

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

6413 6414
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
6415
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
6416
{
C
Christoph Hellwig 已提交
6417
	struct iwl3945_priv *priv = hw->priv;
6418
	int ret;
Z
Zhu Yi 已提交
6419 6420 6421

	IWL_DEBUG_MAC80211("enter\n");

6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435
	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 已提交
6436 6437 6438
	/* we should be verifying the device is ready to be opened */
	mutex_lock(&priv->mutex);

6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450
	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 已提交
6451

6452
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
6453 6454

	mutex_unlock(&priv->mutex);
6455

6456 6457
	iwl3945_rfkill_set_hw_state(priv);

6458 6459 6460 6461 6462 6463 6464 6465
	if (ret)
		goto out_release_irq;

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

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

6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479
	/* 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;
		}
	}

6480
	priv->is_open = 1;
Z
Zhu Yi 已提交
6481 6482
	IWL_DEBUG_MAC80211("leave\n");
	return 0;
6483 6484 6485 6486 6487

out_release_irq:
	free_irq(priv->pci_dev->irq, priv);
out_disable_msi:
	pci_disable_msi(priv->pci_dev);
6488 6489 6490
	pci_disable_device(priv->pci_dev);
	priv->is_open = 0;
	IWL_DEBUG_MAC80211("leave - failed\n");
6491
	return ret;
Z
Zhu Yi 已提交
6492 6493
}

C
Christoph Hellwig 已提交
6494
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
6495
{
C
Christoph Hellwig 已提交
6496
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6497 6498

	IWL_DEBUG_MAC80211("enter\n");
6499

6500 6501 6502 6503 6504
	if (!priv->is_open) {
		IWL_DEBUG_MAC80211("leave - skip\n");
		return;
	}

Z
Zhu Yi 已提交
6505
	priv->is_open = 0;
6506 6507

	if (iwl3945_is_ready_rf(priv)) {
6508 6509 6510
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
6511 6512
		mutex_lock(&priv->mutex);
		iwl3945_scan_cancel_timeout(priv, 100);
6513 6514 6515
		mutex_unlock(&priv->mutex);
	}

6516 6517 6518 6519 6520 6521 6522
	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);
6523

Z
Zhu Yi 已提交
6524 6525 6526
	IWL_DEBUG_MAC80211("leave\n");
}

6527
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
6528
{
C
Christoph Hellwig 已提交
6529
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6530 6531 6532 6533

	IWL_DEBUG_MAC80211("enter\n");

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

6536
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
6537 6538 6539 6540 6541 6542
		dev_kfree_skb_any(skb);

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

C
Christoph Hellwig 已提交
6543
static int iwl3945_mac_add_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
6544 6545
				 struct ieee80211_if_init_conf *conf)
{
C
Christoph Hellwig 已提交
6546
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6547 6548
	unsigned long flags;

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

6551 6552
	if (priv->vif) {
		IWL_DEBUG_MAC80211("leave - vif != NULL\n");
6553
		return -EOPNOTSUPP;
Z
Zhu Yi 已提交
6554 6555 6556
	}

	spin_lock_irqsave(&priv->lock, flags);
6557
	priv->vif = conf->vif;
6558
	priv->iw_mode = conf->type;
Z
Zhu Yi 已提交
6559 6560 6561 6562

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
6563 6564

	if (conf->mac_addr) {
J
Johannes Berg 已提交
6565
		IWL_DEBUG_MAC80211("Set: %pM\n", conf->mac_addr);
6566 6567 6568
		memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
	}

6569 6570
	if (iwl3945_is_ready(priv))
		iwl3945_set_mode(priv, conf->type);
Z
Zhu Yi 已提交
6571 6572 6573

	mutex_unlock(&priv->mutex);

6574
	IWL_DEBUG_MAC80211("leave\n");
Z
Zhu Yi 已提交
6575 6576 6577 6578
	return 0;
}

/**
C
Christoph Hellwig 已提交
6579
 * iwl3945_mac_config - mac80211 config callback
Z
Zhu Yi 已提交
6580 6581 6582 6583 6584
 *
 * 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.
 */
6585
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed)
Z
Zhu Yi 已提交
6586
{
C
Christoph Hellwig 已提交
6587 6588
	struct iwl3945_priv *priv = hw->priv;
	const struct iwl3945_channel_info *ch_info;
6589
	struct ieee80211_conf *conf = &hw->conf;
Z
Zhu Yi 已提交
6590
	unsigned long flags;
6591
	int ret = 0;
Z
Zhu Yi 已提交
6592 6593

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

C
Christoph Hellwig 已提交
6596
	if (!iwl3945_is_ready(priv)) {
Z
Zhu Yi 已提交
6597
		IWL_DEBUG_MAC80211("leave - not ready\n");
6598 6599
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
6600 6601
	}

C
Christoph Hellwig 已提交
6602
	if (unlikely(!iwl3945_param_disable_hw_scan &&
Z
Zhu Yi 已提交
6603
		     test_bit(STATUS_SCANNING, &priv->status))) {
6604 6605
		IWL_DEBUG_MAC80211("leave - scanning\n");
		set_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
6606
		mutex_unlock(&priv->mutex);
6607
		return 0;
Z
Zhu Yi 已提交
6608 6609 6610 6611
	}

	spin_lock_irqsave(&priv->lock, flags);

6612 6613
	ch_info = iwl3945_get_channel_info(priv, conf->channel->band,
					   conf->channel->hw_value);
Z
Zhu Yi 已提交
6614
	if (!is_channel_valid(ch_info)) {
6615
		IWL_DEBUG_SCAN("Channel %d [%d] is INVALID for this band.\n",
6616
			       conf->channel->hw_value, conf->channel->band);
Z
Zhu Yi 已提交
6617 6618
		IWL_DEBUG_MAC80211("leave - invalid channel\n");
		spin_unlock_irqrestore(&priv->lock, flags);
6619 6620
		ret = -EINVAL;
		goto out;
Z
Zhu Yi 已提交
6621 6622
	}

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

6625
	iwl3945_set_flags_for_phymode(priv, conf->channel->band);
Z
Zhu Yi 已提交
6626 6627 6628 6629

	/* 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 已提交
6630
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6631 6632 6633 6634 6635

	spin_unlock_irqrestore(&priv->lock, flags);

#ifdef IEEE80211_CONF_CHANNEL_SWITCH
	if (conf->flags & IEEE80211_CONF_CHANNEL_SWITCH) {
C
Christoph Hellwig 已提交
6636
		iwl3945_hw_channel_switch(priv, conf->channel);
6637
		goto out;
Z
Zhu Yi 已提交
6638 6639 6640
	}
#endif

C
Christoph Hellwig 已提交
6641
	iwl3945_radio_kill_sw(priv, !conf->radio_enabled);
Z
Zhu Yi 已提交
6642 6643 6644

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

C
Christoph Hellwig 已提交
6648
	if (iwl3945_is_rfkill(priv)) {
Z
Zhu Yi 已提交
6649
		IWL_DEBUG_MAC80211("leave - RF kill\n");
6650 6651
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
6652 6653
	}

C
Christoph Hellwig 已提交
6654
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6655 6656 6657

	if (memcmp(&priv->active_rxon,
		   &priv->staging_rxon, sizeof(priv->staging_rxon)))
C
Christoph Hellwig 已提交
6658
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6659 6660 6661 6662 6663
	else
		IWL_DEBUG_INFO("No re-sending same RXON configuration.\n");

	IWL_DEBUG_MAC80211("leave\n");

6664
out:
6665
	clear_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
6666
	mutex_unlock(&priv->mutex);
6667
	return ret;
Z
Zhu Yi 已提交
6668 6669
}

C
Christoph Hellwig 已提交
6670
static void iwl3945_config_ap(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
6671 6672 6673
{
	int rc = 0;

6674
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
6675 6676 6677
		return;

	/* The following should be done only at AP bring up */
6678
	if (!(iwl3945_is_associated(priv))) {
Z
Zhu Yi 已提交
6679 6680 6681

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

		/* RXON Timing */
C
Christoph Hellwig 已提交
6685 6686 6687
		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 已提交
6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710
				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;

6711
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
Z
Zhu Yi 已提交
6712 6713 6714 6715 6716
				priv->staging_rxon.flags &=
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6717 6718
		iwl3945_commit_rxon(priv);
		iwl3945_add_station(priv, iwl3945_broadcast_addr, 0, 0);
6719
	}
C
Christoph Hellwig 已提交
6720
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
6721 6722 6723 6724 6725 6726

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

6727 6728
static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
Z
Zhu Yi 已提交
6729 6730
				    struct ieee80211_if_conf *conf)
{
C
Christoph Hellwig 已提交
6731
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6732 6733 6734 6735 6736
	int rc;

	if (conf == NULL)
		return -EIO;

6737 6738 6739 6740 6741
	if (priv->vif != vif) {
		IWL_DEBUG_MAC80211("leave - priv->vif != vif\n");
		return 0;
	}

6742
	/* handle this temporarily here */
6743
	if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
6744 6745 6746 6747
	    conf->changed & IEEE80211_IFCC_BEACON) {
		struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
		if (!beacon)
			return -ENOMEM;
6748
		mutex_lock(&priv->mutex);
6749
		rc = iwl3945_mac_beacon_update(hw, beacon);
6750
		mutex_unlock(&priv->mutex);
6751 6752 6753 6754
		if (rc)
			return rc;
	}

6755 6756 6757
	if (!iwl3945_is_alive(priv))
		return -EAGAIN;

Z
Zhu Yi 已提交
6758 6759 6760
	mutex_lock(&priv->mutex);

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

6763 6764 6765
/*
 * very dubious code was here; the probe filtering flag is never set:
 *
Z
Zhu Yi 已提交
6766 6767
	if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
	    !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
6768
 */
Z
Zhu Yi 已提交
6769

6770
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
6771 6772 6773
		if (!conf->bssid) {
			conf->bssid = priv->mac_addr;
			memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
J
Johannes Berg 已提交
6774 6775
			IWL_DEBUG_MAC80211("bssid was set to: %pM\n",
					   conf->bssid);
Z
Zhu Yi 已提交
6776 6777 6778 6779
		}
		if (priv->ibss_beacon)
			dev_kfree_skb(priv->ibss_beacon);

6780
		priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
Z
Zhu Yi 已提交
6781 6782
	}

6783 6784 6785
	if (iwl3945_is_rfkill(priv))
		goto done;

Z
Zhu Yi 已提交
6786 6787 6788 6789
	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 已提交
6790
		if (iwl3945_scan_cancel_timeout(priv, 100)) {
Z
Zhu Yi 已提交
6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804
			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);

6805
		if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
6806
			iwl3945_config_ap(priv);
Z
Zhu Yi 已提交
6807
		else {
C
Christoph Hellwig 已提交
6808
			rc = iwl3945_commit_rxon(priv);
6809
			if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
C
Christoph Hellwig 已提交
6810
				iwl3945_add_station(priv,
6811
					priv->active_rxon.bssid_addr, 1, 0);
Z
Zhu Yi 已提交
6812 6813 6814
		}

	} else {
C
Christoph Hellwig 已提交
6815
		iwl3945_scan_cancel_timeout(priv, 100);
Z
Zhu Yi 已提交
6816
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6817
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6818 6819
	}

6820
 done:
Z
Zhu Yi 已提交
6821 6822 6823 6824 6825 6826
	IWL_DEBUG_MAC80211("leave\n");
	mutex_unlock(&priv->mutex);

	return 0;
}

C
Christoph Hellwig 已提交
6827
static void iwl3945_configure_filter(struct ieee80211_hw *hw,
6828 6829 6830 6831
				 unsigned int changed_flags,
				 unsigned int *total_flags,
				 int mc_count, struct dev_addr_list *mc_list)
{
6832
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu, Yi 已提交
6833
	__le32 *filter_flags = &priv->staging_rxon.filter_flags;
6834

Z
Zhu, Yi 已提交
6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854
	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;
6855
	}
Z
Zhu, Yi 已提交
6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869
	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 |
6870
			FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
6871 6872
}

C
Christoph Hellwig 已提交
6873
static void iwl3945_mac_remove_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
6874 6875
				     struct ieee80211_if_init_conf *conf)
{
C
Christoph Hellwig 已提交
6876
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6877 6878 6879 6880

	IWL_DEBUG_MAC80211("enter\n");

	mutex_lock(&priv->mutex);
6881

6882 6883 6884 6885 6886
	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);
	}
6887 6888
	if (priv->vif == conf->vif) {
		priv->vif = NULL;
Z
Zhu Yi 已提交
6889 6890 6891 6892 6893 6894 6895
		memset(priv->bssid, 0, ETH_ALEN);
	}
	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");
}

6896 6897 6898 6899 6900 6901 6902 6903 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
#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 已提交
6953
static int iwl3945_mac_hw_scan(struct ieee80211_hw *hw, u8 *ssid, size_t len)
Z
Zhu Yi 已提交
6954 6955 6956
{
	int rc = 0;
	unsigned long flags;
C
Christoph Hellwig 已提交
6957
	struct iwl3945_priv *priv = hw->priv;
6958
	DECLARE_SSID_BUF(ssid_buf);
Z
Zhu Yi 已提交
6959 6960 6961

	IWL_DEBUG_MAC80211("enter\n");

6962
	mutex_lock(&priv->mutex);
Z
Zhu Yi 已提交
6963 6964
	spin_lock_irqsave(&priv->lock, flags);

C
Christoph Hellwig 已提交
6965
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
6966 6967 6968 6969 6970
		rc = -EIO;
		IWL_DEBUG_MAC80211("leave - not ready or exit pending\n");
		goto out_unlock;
	}

6971 6972 6973 6974 6975 6976
	/* 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;
	}
6977 6978 6979 6980
	/* 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 已提交
6981 6982 6983 6984
		rc = -EAGAIN;
		goto out_unlock;
	}
	if (len) {
6985
		IWL_DEBUG_SCAN("direct scan for %s [%d]\n ",
6986
			       print_ssid(ssid_buf, ssid, len), (int)len);
Z
Zhu Yi 已提交
6987 6988 6989 6990 6991

		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);
6992 6993
	} else
		priv->one_direct_scan = 0;
Z
Zhu Yi 已提交
6994

C
Christoph Hellwig 已提交
6995
	rc = iwl3945_scan_initiate(priv);
Z
Zhu Yi 已提交
6996 6997 6998 6999 7000

	IWL_DEBUG_MAC80211("leave\n");

out_unlock:
	spin_unlock_irqrestore(&priv->lock, flags);
7001
	mutex_unlock(&priv->mutex);
Z
Zhu Yi 已提交
7002 7003 7004 7005

	return rc;
}

C
Christoph Hellwig 已提交
7006
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
Z
Zhu Yi 已提交
7007 7008 7009
			   const u8 *local_addr, const u8 *addr,
			   struct ieee80211_key_conf *key)
{
C
Christoph Hellwig 已提交
7010
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7011 7012 7013 7014 7015
	int rc = 0;
	u8 sta_id;

	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7016
	if (!iwl3945_param_hwcrypto) {
Z
Zhu Yi 已提交
7017 7018 7019 7020 7021 7022 7023 7024
		IWL_DEBUG_MAC80211("leave - hwcrypto disabled\n");
		return -EOPNOTSUPP;
	}

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

C
Christoph Hellwig 已提交
7025
	sta_id = iwl3945_hw_find_station(priv, addr);
Z
Zhu Yi 已提交
7026
	if (sta_id == IWL_INVALID_STATION) {
J
Johannes Berg 已提交
7027 7028
		IWL_DEBUG_MAC80211("leave - %pM not in station map.\n",
				   addr);
Z
Zhu Yi 已提交
7029 7030 7031 7032 7033
		return -EINVAL;
	}

	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
7034
	iwl3945_scan_cancel_timeout(priv, 100);
7035

Z
Zhu Yi 已提交
7036 7037
	switch (cmd) {
	case  SET_KEY:
C
Christoph Hellwig 已提交
7038
		rc = iwl3945_update_sta_key_info(priv, key, sta_id);
Z
Zhu Yi 已提交
7039
		if (!rc) {
C
Christoph Hellwig 已提交
7040 7041
			iwl3945_set_rxon_hwcrypto(priv, 1);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7042 7043 7044 7045 7046 7047
			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 已提交
7048
		rc = iwl3945_clear_sta_key_info(priv, sta_id);
Z
Zhu Yi 已提交
7049
		if (!rc) {
C
Christoph Hellwig 已提交
7050 7051
			iwl3945_set_rxon_hwcrypto(priv, 0);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064
			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 已提交
7065
static int iwl3945_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
Z
Zhu Yi 已提交
7066 7067
			   const struct ieee80211_tx_queue_params *params)
{
C
Christoph Hellwig 已提交
7068
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7069 7070 7071 7072 7073
	unsigned long flags;
	int q;

	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7074
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091
		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;
	}

	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 =
7092
			cpu_to_le16((params->txop * 32));
Z
Zhu Yi 已提交
7093 7094 7095 7096 7097 7098 7099

	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);
7100
	if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
7101 7102 7103
		iwl3945_activate_qos(priv, 1);
	else if (priv->assoc_id && iwl3945_is_associated(priv))
		iwl3945_activate_qos(priv, 0);
Z
Zhu Yi 已提交
7104 7105 7106 7107 7108 7109 7110

	mutex_unlock(&priv->mutex);

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

C
Christoph Hellwig 已提交
7111
static int iwl3945_mac_get_tx_stats(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
7112 7113
				struct ieee80211_tx_queue_stats *stats)
{
C
Christoph Hellwig 已提交
7114
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7115
	int i, avail;
C
Christoph Hellwig 已提交
7116 7117
	struct iwl3945_tx_queue *txq;
	struct iwl3945_queue *q;
Z
Zhu Yi 已提交
7118 7119 7120 7121
	unsigned long flags;

	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7122
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
7123 7124 7125 7126 7127 7128 7129 7130 7131
		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 已提交
7132
		avail = iwl3945_queue_space(q);
Z
Zhu Yi 已提交
7133

7134 7135 7136
		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 已提交
7137 7138 7139 7140 7141 7142 7143 7144 7145

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

	IWL_DEBUG_MAC80211("leave\n");

	return 0;
}

C
Christoph Hellwig 已提交
7146
static int iwl3945_mac_get_stats(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
7147 7148 7149 7150 7151 7152 7153 7154
			     struct ieee80211_low_level_stats *stats)
{
	IWL_DEBUG_MAC80211("enter\n");
	IWL_DEBUG_MAC80211("leave\n");

	return 0;
}

C
Christoph Hellwig 已提交
7155
static void iwl3945_mac_reset_tsf(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
7156
{
C
Christoph Hellwig 已提交
7157
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7158 7159 7160 7161 7162
	unsigned long flags;

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

C
Christoph Hellwig 已提交
7163
	iwl3945_reset_qos(priv);
7164

Z
Zhu Yi 已提交
7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178
	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;
7179
	if ((priv->iw_mode == NL80211_IFTYPE_STATION))
Z
Zhu Yi 已提交
7180 7181 7182 7183
		priv->beacon_int = 0;

	spin_unlock_irqrestore(&priv->lock, flags);

7184 7185 7186 7187 7188 7189
	if (!iwl3945_is_ready_rf(priv)) {
		IWL_DEBUG_MAC80211("leave - not ready\n");
		mutex_unlock(&priv->mutex);
		return;
	}

7190 7191 7192
	/* we are restarting association process
	 * clear RXON_FILTER_ASSOC_MSK bit
	*/
7193
	if (priv->iw_mode != NL80211_IFTYPE_AP) {
C
Christoph Hellwig 已提交
7194
		iwl3945_scan_cancel_timeout(priv, 100);
7195
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
7196
		iwl3945_commit_rxon(priv);
7197 7198
	}

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

Z
Zhu Yi 已提交
7202 7203 7204 7205 7206
		IWL_DEBUG_MAC80211("leave - not in IBSS\n");
		mutex_unlock(&priv->mutex);
		return;
	}

C
Christoph Hellwig 已提交
7207
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
7208 7209 7210 7211 7212 7213 7214

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");

}

7215
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
7216
{
C
Christoph Hellwig 已提交
7217
	struct iwl3945_priv *priv = hw->priv;
Z
Zhu Yi 已提交
7218 7219 7220 7221
	unsigned long flags;

	IWL_DEBUG_MAC80211("enter\n");

C
Christoph Hellwig 已提交
7222
	if (!iwl3945_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
7223 7224 7225 7226
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		return -EIO;
	}

7227
	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
Z
Zhu Yi 已提交
7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243
		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 已提交
7244
	iwl3945_reset_qos(priv);
Z
Zhu Yi 已提交
7245

7246
	iwl3945_post_associate(priv);
Z
Zhu Yi 已提交
7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257


	return 0;
}

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

7258
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
7259 7260 7261 7262 7263 7264 7265 7266 7267 7268 7269

/*
 * 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 已提交
7270
	return sprintf(buf, "0x%08X\n", iwl3945_debug_level);
Z
Zhu Yi 已提交
7271 7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282
}
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 已提交
7283
		iwl3945_debug_level = val;
Z
Zhu Yi 已提交
7284 7285 7286 7287 7288 7289 7290

	return strnlen(buf, count);
}

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

7291
#endif /* CONFIG_IWL3945_DEBUG */
Z
Zhu Yi 已提交
7292 7293 7294 7295

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

C
Christoph Hellwig 已提交
7298
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7299 7300
		return -EAGAIN;

C
Christoph Hellwig 已提交
7301
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
7302 7303 7304 7305 7306 7307 7308
}

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 已提交
7309
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7310 7311 7312 7313 7314 7315 7316
	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 已提交
7317
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7318 7319 7320 7321 7322 7323 7324 7325
	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 已提交
7326
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
7327 7328 7329 7330 7331 7332 7333 7334 7335

	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 已提交
7336
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7337 7338 7339 7340 7341 7342 7343 7344

	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 已提交
7345
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7346 7347 7348 7349 7350
	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 已提交
7351
		if (iwl3945_scan_cancel_timeout(priv, 100))
Z
Zhu Yi 已提交
7352 7353 7354 7355 7356
			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 已提交
7357
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369
		}
	}
	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 已提交
7370
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7371 7372 7373 7374 7375 7376 7377 7378 7379

	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 已提交
7380
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
Z
Zhu Yi 已提交
7381 7382 7383 7384 7385
	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 已提交
7386
		if (iwl3945_scan_cancel_timeout(priv, 100))
Z
Zhu Yi 已提交
7387 7388 7389 7390 7391 7392
			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 已提交
7393
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
7394 7395 7396 7397 7398 7399 7400 7401 7402 7403
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

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

7404
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
7405 7406 7407 7408

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
C
Christoph Hellwig 已提交
7409 7410
	struct iwl3945_priv *priv = dev_get_drvdata(d);
	struct iwl3945_spectrum_notification measure_report;
Z
Zhu Yi 已提交
7411
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
7412
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
7413 7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441
	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 已提交
7442
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467
	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 已提交
7468
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
7469 7470 7471 7472 7473 7474

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
7475
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
7476 7477 7478 7479 7480

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
C
Christoph Hellwig 已提交
7481
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492

	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 已提交
7493
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7494 7495 7496 7497 7498 7499 7500 7501 7502 7503
	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 已提交
7504
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7505 7506 7507 7508 7509 7510
	int rc;
	int mode;

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

C
Christoph Hellwig 已提交
7511
	if (!iwl3945_is_ready(priv)) {
Z
Zhu Yi 已提交
7512 7513 7514 7515 7516 7517 7518 7519 7520 7521
		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 已提交
7522
		rc = iwl3945_send_power_mode(priv, IWL_POWER_LEVEL(mode));
Z
Zhu Yi 已提交
7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535 7536 7537 7538 7539 7540 7541 7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557
		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 已提交
7558
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582
	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");

7583
	return p - buf + 1;
Z
Zhu Yi 已提交
7584 7585 7586 7587 7588 7589 7590 7591 7592

}

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)
{
7593 7594
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
7595 7596 7597 7598 7599 7600 7601
}

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 已提交
7602 7603
	struct iwl3945_priv *priv = dev_get_drvdata(d);
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
7604
	u32 len = 0, ofs = 0;
7605
	u8 *data = (u8 *)&priv->statistics;
Z
Zhu Yi 已提交
7606 7607
	int rc = 0;

C
Christoph Hellwig 已提交
7608
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7609 7610 7611
		return -EAGAIN;

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
7612
	rc = iwl3945_send_statistics_request(priv);
Z
Zhu Yi 已提交
7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639
	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 已提交
7640
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7641

C
Christoph Hellwig 已提交
7642
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7643 7644 7645 7646 7647 7648 7649 7650 7651 7652
		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 已提交
7653
	struct iwl3945_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7654 7655 7656 7657 7658 7659 7660 7661 7662 7663 7664

	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 已提交
7665
		priv->antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
7666 7667 7668 7669 7670 7671 7672 7673 7674 7675 7676 7677
	} 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 已提交
7678 7679
	struct iwl3945_priv *priv = (struct iwl3945_priv *)d->driver_data;
	if (!iwl3945_is_alive(priv))
Z
Zhu Yi 已提交
7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692
		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 已提交
7693
		iwl3945_dump_nic_error_log((struct iwl3945_priv *)d->driver_data);
Z
Zhu Yi 已提交
7694 7695 7696 7697 7698 7699 7700 7701 7702 7703 7704 7705 7706

	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 已提交
7707
		iwl3945_dump_nic_event_log((struct iwl3945_priv *)d->driver_data);
Z
Zhu Yi 已提交
7708 7709 7710 7711 7712 7713 7714 7715

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
7716
 * driver setup and tear down
Z
Zhu Yi 已提交
7717 7718 7719
 *
 *****************************************************************************/

C
Christoph Hellwig 已提交
7720
static void iwl3945_setup_deferred_work(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
7721 7722 7723 7724 7725
{
	priv->workqueue = create_workqueue(DRV_NAME);

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
7726 7727 7728 7729 7730 7731 7732 7733 7734 7735 7736 7737 7738
	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 已提交
7739 7740

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

C
Christoph Hellwig 已提交
7744
static void iwl3945_cancel_deferred_work(struct iwl3945_priv *priv)
Z
Zhu Yi 已提交
7745
{
C
Christoph Hellwig 已提交
7746
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
7747

7748
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
7749 7750 7751 7752 7753
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
7754
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
7755 7756 7757 7758 7759 7760
	&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,
7761
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
7762 7763 7764 7765 7766 7767 7768 7769 7770 7771 7772 7773
	&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 已提交
7774
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
7775
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
7776
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
7777 7778
};

C
Christoph Hellwig 已提交
7779 7780 7781 7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792
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,
7793
	.bss_info_changed = iwl3945_bss_info_changed,
C
Christoph Hellwig 已提交
7794
	.hw_scan = iwl3945_mac_hw_scan
Z
Zhu Yi 已提交
7795 7796
};

C
Christoph Hellwig 已提交
7797
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
7798 7799
{
	int err = 0;
C
Christoph Hellwig 已提交
7800
	struct iwl3945_priv *priv;
Z
Zhu Yi 已提交
7801
	struct ieee80211_hw *hw;
T
Tomas Winkler 已提交
7802
	struct iwl_3945_cfg *cfg = (struct iwl_3945_cfg *)(ent->driver_data);
7803
	unsigned long flags;
Z
Zhu Yi 已提交
7804

7805 7806 7807 7808
	/***********************
	 * 1. Allocating HW data
	 * ********************/

7809 7810
	/* Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan. */
C
Christoph Hellwig 已提交
7811
	if (iwl3945_param_disable_hw_scan) {
Z
Zhu Yi 已提交
7812
		IWL_DEBUG_INFO("Disabling hw_scan\n");
C
Christoph Hellwig 已提交
7813
		iwl3945_hw_ops.hw_scan = NULL;
Z
Zhu Yi 已提交
7814 7815
	}

7816
	if ((iwl3945_param_queues_num > IWL39_MAX_NUM_QUEUES) ||
C
Christoph Hellwig 已提交
7817
	    (iwl3945_param_queues_num < IWL_MIN_NUM_QUEUES)) {
Z
Zhu Yi 已提交
7818
		IWL_ERROR("invalid queues_num, should be between %d and %d\n",
7819
			  IWL_MIN_NUM_QUEUES, IWL39_MAX_NUM_QUEUES);
Z
Zhu Yi 已提交
7820 7821 7822 7823 7824 7825
		err = -EINVAL;
		goto out;
	}

	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
C
Christoph Hellwig 已提交
7826
	hw = ieee80211_alloc_hw(sizeof(struct iwl3945_priv), &iwl3945_hw_ops);
Z
Zhu Yi 已提交
7827 7828 7829 7830 7831 7832
	if (hw == NULL) {
		IWL_ERROR("Can not allocate network device\n");
		err = -ENOMEM;
		goto out;
	}

7833
	SET_IEEE80211_DEV(hw, &pdev->dev);
7834

Z
Zhu Yi 已提交
7835 7836 7837
	priv = hw->priv;
	priv->hw = hw;
	priv->pci_dev = pdev;
T
Tomas Winkler 已提交
7838
	priv->cfg = cfg;
7839

7840 7841 7842 7843
	IWL_DEBUG_INFO("*** LOAD DRIVER ***\n");
	hw->rate_control_algorithm = "iwl-3945-rs";
	hw->sta_data_size = sizeof(struct iwl3945_sta_priv);

7844
	/* Select antenna (may be helpful if only one antenna is connected) */
C
Christoph Hellwig 已提交
7845
	priv->antenna = (enum iwl3945_antenna)iwl3945_param_antenna;
7846
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
7847
	iwl3945_debug_level = iwl3945_param_debug;
Z
Zhu Yi 已提交
7848 7849 7850
	atomic_set(&priv->restrict_refcnt, 0);
#endif

7851
	/* Tell mac80211 our characteristics */
7852
	hw->flags = IEEE80211_HW_SIGNAL_DBM |
7853
		    IEEE80211_HW_NOISE_DBM;
Z
Zhu Yi 已提交
7854

7855 7856 7857 7858
	hw->wiphy->interface_modes =
		BIT(NL80211_IFTYPE_STATION) |
		BIT(NL80211_IFTYPE_ADHOC);

7859 7860
	hw->wiphy->fw_handles_regulatory = true;

7861
	/* 4 EDCA QOS priorities */
Z
Zhu Yi 已提交
7862 7863
	hw->queues = 4;

7864 7865 7866
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885
	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;
7886

7887 7888 7889
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
7890 7891 7892 7893 7894 7895 7896 7897 7898 7899
	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);

7900 7901 7902
	/* 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 已提交
7903

7904 7905 7906
	/* nic init */
	iwl3945_set_bit(priv, CSR_GIO_CHICKEN_BITS,
			CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);
Z
Zhu Yi 已提交
7907

7908
	iwl3945_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
Z
Zhu, Yi 已提交
7909 7910
	err = iwl3945_poll_direct_bit(priv, CSR_GP_CNTRL,
				CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
7911 7912 7913 7914
	if (err < 0) {
		IWL_DEBUG_INFO("Failed to init the card\n");
		goto out_remove_sysfs;
	}
Z
Zhu Yi 已提交
7915

7916 7917 7918 7919 7920 7921 7922 7923 7924 7925 7926 7927 7928
	/***********************
	 * 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 已提交
7929

7930 7931 7932
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
7933
	/* Device-specific setup */
C
Christoph Hellwig 已提交
7934
	if (iwl3945_hw_set_hw_setting(priv)) {
Z
Zhu Yi 已提交
7935 7936 7937 7938
		IWL_ERROR("failed to set hw settings\n");
		goto out_iounmap;
	}

7939 7940 7941 7942 7943 7944 7945 7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962
	/***********************
	 * 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 已提交
7963
	iwl3945_reset_qos(priv);
Z
Zhu Yi 已提交
7964 7965 7966 7967 7968 7969 7970 7971 7972 7973

	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;

7974
	err = iwl3945_init_channel_map(priv);
Z
Zhu Yi 已提交
7975
	if (err) {
7976
		IWL_ERROR("initializing regulatory failed: %d\n", err);
Z
Zhu Yi 已提交
7977 7978 7979
		goto out_release_irq;
	}

7980
	err = iwl3945_init_geos(priv);
Z
Zhu Yi 已提交
7981
	if (err) {
7982 7983
		IWL_ERROR("initializing geos failed: %d\n", err);
		goto out_free_channel_map;
Z
Zhu Yi 已提交
7984 7985
	}

7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997
	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");
7998 7999
	}

8000 8001 8002 8003 8004 8005 8006 8007 8008 8009

	/***********************
	 * 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);
8010
	if (err) {
8011 8012
		IWL_ERROR("failed to create sysfs device attributes\n");
		goto out_free_geos;
8013 8014
	}

8015 8016 8017 8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028
	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
	 * *******************************/

8029 8030 8031
	err = ieee80211_register_hw(priv->hw);
	if (err) {
		IWL_ERROR("Failed to register network device (error %d)\n", err);
8032
		goto  out_remove_sysfs;
8033
	}
Z
Zhu Yi 已提交
8034

8035 8036
	priv->hw->conf.beacon_int = 100;
	priv->mac80211_registered = 1;
8037

Z
Zhu Yi 已提交
8038

8039 8040 8041 8042 8043
	err = iwl3945_rfkill_init(priv);
	if (err)
		IWL_ERROR("Unable to initialize RFKILL system. "
				  "Ignoring error: %d\n", err);

Z
Zhu Yi 已提交
8044 8045
	return 0;

8046 8047
 out_remove_sysfs:
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
8048 8049 8050 8051
 out_free_geos:
	iwl3945_free_geos(priv);
 out_free_channel_map:
	iwl3945_free_channel_map(priv);
8052

Z
Zhu Yi 已提交
8053 8054 8055 8056

 out_release_irq:
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
C
Christoph Hellwig 已提交
8057
	iwl3945_unset_hw_setting(priv);
Z
Zhu Yi 已提交
8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071

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

8072
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
8073
{
C
Christoph Hellwig 已提交
8074
	struct iwl3945_priv *priv = pci_get_drvdata(pdev);
8075
	unsigned long flags;
Z
Zhu Yi 已提交
8076 8077 8078 8079 8080 8081 8082

	if (!priv)
		return;

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

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

C
Christoph Hellwig 已提交
8084
	iwl3945_down(priv);
Z
Zhu Yi 已提交
8085

8086 8087 8088 8089 8090 8091 8092 8093 8094
	/* 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 已提交
8095
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
8096

8097
	iwl3945_rfkill_unregister(priv);
C
Christoph Hellwig 已提交
8098
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
8099 8100

	if (priv->rxq.bd)
C
Christoph Hellwig 已提交
8101 8102
		iwl3945_rx_queue_free(priv, &priv->rxq);
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
8103

C
Christoph Hellwig 已提交
8104 8105
	iwl3945_unset_hw_setting(priv);
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
8106

8107
	if (priv->mac80211_registered)
Z
Zhu Yi 已提交
8108 8109
		ieee80211_unregister_hw(priv->hw);

8110 8111 8112
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
8113
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
8114 8115 8116 8117 8118 8119 8120 8121 8122 8123
	 * 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);

8124 8125
	iwl3945_free_channel_map(priv);
	iwl3945_free_geos(priv);
8126
	kfree(priv->scan);
Z
Zhu Yi 已提交
8127 8128 8129 8130 8131 8132 8133 8134
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}

#ifdef CONFIG_PM

C
Christoph Hellwig 已提交
8135
static int iwl3945_pci_suspend(struct pci_dev *pdev, pm_message_t state)
Z
Zhu Yi 已提交
8136
{
C
Christoph Hellwig 已提交
8137
	struct iwl3945_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
8138

8139 8140 8141 8142 8143
	if (priv->is_open) {
		set_bit(STATUS_IN_SUSPEND, &priv->status);
		iwl3945_mac_stop(priv->hw);
		priv->is_open = 1;
	}
Z
Zhu Yi 已提交
8144 8145 8146 8147 8148 8149

	pci_set_power_state(pdev, PCI_D3hot);

	return 0;
}

C
Christoph Hellwig 已提交
8150
static int iwl3945_pci_resume(struct pci_dev *pdev)
Z
Zhu Yi 已提交
8151
{
C
Christoph Hellwig 已提交
8152
	struct iwl3945_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
8153 8154 8155

	pci_set_power_state(pdev, PCI_D0);

8156 8157
	if (priv->is_open)
		iwl3945_mac_start(priv->hw);
Z
Zhu Yi 已提交
8158

8159
	clear_bit(STATUS_IN_SUSPEND, &priv->status);
Z
Zhu Yi 已提交
8160 8161 8162 8163 8164
	return 0;
}

#endif /* CONFIG_PM */

8165
/*************** RFKILL FUNCTIONS **********/
8166
#ifdef CONFIG_IWL3945_RFKILL
8167 8168 8169 8170 8171 8172
/* 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;

8173
	if (!priv->rfkill)
8174 8175 8176 8177 8178
	return 0;

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

T
Tomas Winkler 已提交
8179
	IWL_DEBUG_RF_KILL("we received soft RFKILL set to state %d\n", state);
8180 8181 8182
	mutex_lock(&priv->mutex);

	switch (state) {
8183
	case RFKILL_STATE_UNBLOCKED:
8184
		if (iwl3945_is_rfkill_hw(priv)) {
8185
			err = -EBUSY;
8186 8187 8188
			goto out_unlock;
		}
		iwl3945_radio_kill_sw(priv, 0);
8189
		break;
8190
	case RFKILL_STATE_SOFT_BLOCKED:
8191 8192
		iwl3945_radio_kill_sw(priv, 1);
		break;
8193
	default:
T
Tomas Winkler 已提交
8194
		IWL_WARNING("we received unexpected RFKILL state %d\n", state);
8195
		break;
8196
	}
8197
out_unlock:
8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208 8209 8210
	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");
8211 8212
	priv->rfkill = rfkill_allocate(device, RFKILL_TYPE_WLAN);
	if (!priv->rfkill) {
8213 8214 8215 8216 8217
		IWL_ERROR("Unable to allocate rfkill device.\n");
		ret = -ENOMEM;
		goto error;
	}

8218 8219 8220 8221 8222
	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;
8223

8224 8225
	priv->rfkill->dev.class->suspend = NULL;
	priv->rfkill->dev.class->resume = NULL;
8226

8227
	ret = rfkill_register(priv->rfkill);
8228 8229
	if (ret) {
		IWL_ERROR("Unable to register rfkill: %d\n", ret);
8230
		goto freed_rfkill;
8231 8232 8233 8234 8235 8236
	}

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

freed_rfkill:
8237 8238 8239
	if (priv->rfkill != NULL)
		rfkill_free(priv->rfkill);
	priv->rfkill = NULL;
8240 8241 8242 8243 8244 8245 8246 8247

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

void iwl3945_rfkill_unregister(struct iwl3945_priv *priv)
{
8248 8249
	if (priv->rfkill)
		rfkill_unregister(priv->rfkill);
8250

8251
	priv->rfkill = NULL;
8252 8253 8254 8255 8256 8257
}

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

8258 8259 8260 8261 8262
	if (!priv->rfkill)
		return;

	if (iwl3945_is_rfkill_hw(priv)) {
		rfkill_force_state(priv->rfkill, RFKILL_STATE_HARD_BLOCKED);
8263
		return;
8264
	}
8265

8266 8267
	if (!iwl3945_is_rfkill_sw(priv))
		rfkill_force_state(priv->rfkill, RFKILL_STATE_UNBLOCKED);
8268
	else
8269
		rfkill_force_state(priv->rfkill, RFKILL_STATE_SOFT_BLOCKED);
8270 8271 8272
}
#endif

Z
Zhu Yi 已提交
8273 8274 8275 8276 8277 8278
/*****************************************************************************
 *
 * driver and module entry point
 *
 *****************************************************************************/

C
Christoph Hellwig 已提交
8279
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
8280
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
8281 8282 8283
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
8284
#ifdef CONFIG_PM
C
Christoph Hellwig 已提交
8285 8286
	.suspend = iwl3945_pci_suspend,
	.resume = iwl3945_pci_resume,
Z
Zhu Yi 已提交
8287 8288 8289
#endif
};

C
Christoph Hellwig 已提交
8290
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
8291 8292 8293 8294 8295
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
8296 8297 8298 8299 8300 8301 8302

	ret = iwl3945_rate_control_register();
	if (ret) {
		IWL_ERROR("Unable to register rate control algorithm: %d\n", ret);
		return ret;
	}

C
Christoph Hellwig 已提交
8303
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
8304 8305
	if (ret) {
		IWL_ERROR("Unable to initialize PCI module\n");
8306
		goto error_register;
Z
Zhu Yi 已提交
8307
	}
8308
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
8309
	ret = driver_create_file(&iwl3945_driver.driver, &driver_attr_debug_level);
Z
Zhu Yi 已提交
8310 8311
	if (ret) {
		IWL_ERROR("Unable to create driver sysfs file\n");
8312
		goto error_debug;
Z
Zhu Yi 已提交
8313 8314 8315 8316
	}
#endif

	return ret;
8317 8318 8319 8320 8321 8322 8323 8324

#ifdef CONFIG_IWL3945_DEBUG
error_debug:
	pci_unregister_driver(&iwl3945_driver);
#endif
error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
8325 8326
}

C
Christoph Hellwig 已提交
8327
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
8328
{
8329
#ifdef CONFIG_IWL3945_DEBUG
C
Christoph Hellwig 已提交
8330
	driver_remove_file(&iwl3945_driver.driver, &driver_attr_debug_level);
Z
Zhu Yi 已提交
8331
#endif
C
Christoph Hellwig 已提交
8332
	pci_unregister_driver(&iwl3945_driver);
8333
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
8334 8335
}

8336
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
8337

C
Christoph Hellwig 已提交
8338
module_param_named(antenna, iwl3945_param_antenna, int, 0444);
Z
Zhu Yi 已提交
8339
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
C
Christoph Hellwig 已提交
8340
module_param_named(disable, iwl3945_param_disable, int, 0444);
Z
Zhu Yi 已提交
8341
MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
C
Christoph Hellwig 已提交
8342
module_param_named(hwcrypto, iwl3945_param_hwcrypto, int, 0444);
Z
Zhu Yi 已提交
8343 8344
MODULE_PARM_DESC(hwcrypto,
		 "using hardware crypto engine (default 0 [software])\n");
C
Christoph Hellwig 已提交
8345
module_param_named(debug, iwl3945_param_debug, int, 0444);
Z
Zhu Yi 已提交
8346
MODULE_PARM_DESC(debug, "debug output mask");
C
Christoph Hellwig 已提交
8347
module_param_named(disable_hw_scan, iwl3945_param_disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
8348 8349
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

C
Christoph Hellwig 已提交
8350
module_param_named(queues_num, iwl3945_param_queues_num, int, 0444);
Z
Zhu Yi 已提交
8351 8352
MODULE_PARM_DESC(queues_num, "number of hw queues.");

C
Christoph Hellwig 已提交
8353 8354
module_exit(iwl3945_exit);
module_init(iwl3945_init);