iwl3945-base.c 216.3 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>

49 50
#define DRV_NAME	"iwl3945"

W
Winkler, Tomas 已提交
51 52
#include "iwl-fh.h"
#include "iwl-3945-fh.h"
53
#include "iwl-commands.h"
Z
Zhu Yi 已提交
54 55
#include "iwl-3945.h"
#include "iwl-helpers.h"
K
Kolekar, Abhijeet 已提交
56
#include "iwl-core.h"
57
#include "iwl-dev.h"
Z
Zhu Yi 已提交
58

59
static int iwl3945_tx_queue_update_write_ptr(struct iwl_priv *priv,
60
				  struct iwl_tx_queue *txq);
61

Z
Zhu Yi 已提交
62 63 64 65 66 67 68
/*
 * module name, copyright, version, etc.
 */

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

69
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
70 71 72 73 74
#define VD "d"
#else
#define VD
#endif

75
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
76 77 78 79 80
#define VS "s"
#else
#define VS
#endif

81
#define IWL39_VERSION "1.2.26k" VD VS
R
Reinette Chatre 已提交
82
#define DRV_COPYRIGHT	"Copyright(c) 2003-2008 Intel Corporation"
83
#define DRV_AUTHOR     "<ilw@linux.intel.com>"
84
#define DRV_VERSION     IWL39_VERSION
Z
Zhu Yi 已提交
85 86 87 88


MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_VERSION(DRV_VERSION);
89
MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
Z
Zhu Yi 已提交
90 91
MODULE_LICENSE("GPL");

92 93 94 95 96 97
 /* module parameters */
struct iwl_mod_params iwl3945_mod_params = {
	.num_of_queues = IWL39_MAX_NUM_QUEUES,
	/* the rest are 0 by default */
};

Z
Zhu Yi 已提交
98 99 100 101 102
/*************** DMA-QUEUE-GENERAL-FUNCTIONS  *****
 * DMA services
 *
 * Theory of operation
 *
103 104 105 106 107 108 109 110 111
 * 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 已提交
112 113 114 115 116 117
 *
 * 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.
 *
118 119 120
 * 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 已提交
121 122
 ***************************************************/

123 124 125
/**
 * iwl3945_queue_init - Initialize queue's high/low-water and read/write indexes
 */
126
static int iwl3945_queue_init(struct iwl_priv *priv, struct iwl_queue *q,
Z
Zhu Yi 已提交
127 128 129 130 131 132
			  int count, int slots_num, u32 id)
{
	q->n_bd = count;
	q->n_window = slots_num;
	q->id = id;

T
Tomas Winkler 已提交
133 134
	/* count must be power-of-two size, otherwise iwl_queue_inc_wrap
	 * and iwl_queue_dec_wrap are broken. */
Z
Zhu Yi 已提交
135 136 137 138 139 140 141 142 143 144 145 146 147 148
	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;

149
	q->write_ptr = q->read_ptr = 0;
Z
Zhu Yi 已提交
150 151 152 153

	return 0;
}

154 155 156
/**
 * iwl3945_tx_queue_alloc - Alloc driver data and TFD CB for one Tx/cmd queue
 */
157
static int iwl3945_tx_queue_alloc(struct iwl_priv *priv,
158
			      struct iwl_tx_queue *txq, u32 id)
Z
Zhu Yi 已提交
159 160 161
{
	struct pci_dev *dev = priv->pci_dev;

162 163
	/* Driver private data, only for Tx (not command) queues,
	 * not shared with device. */
Z
Zhu Yi 已提交
164 165 166 167
	if (id != IWL_CMD_QUEUE_NUM) {
		txq->txb = kmalloc(sizeof(txq->txb[0]) *
				   TFD_QUEUE_SIZE_MAX, GFP_KERNEL);
		if (!txq->txb) {
168
			IWL_ERR(priv, "kmalloc for auxiliary BD "
Z
Zhu Yi 已提交
169 170 171 172 173 174
				  "structures failed\n");
			goto error;
		}
	} else
		txq->txb = NULL;

175 176
	/* Circular buffer of transmit frame descriptors (TFDs),
	 * shared with device */
177 178
	txq->tfds39 = pci_alloc_consistent(dev,
			sizeof(txq->tfds39[0]) * TFD_QUEUE_SIZE_MAX,
Z
Zhu Yi 已提交
179 180
			&txq->q.dma_addr);

181
	if (!txq->tfds39) {
182
		IWL_ERR(priv, "pci_alloc_consistent(%zd) failed\n",
183
			  sizeof(txq->tfds39[0]) * TFD_QUEUE_SIZE_MAX);
Z
Zhu Yi 已提交
184 185 186 187 188 189 190
		goto error;
	}
	txq->q.id = id;

	return 0;

 error:
191 192
	kfree(txq->txb);
	txq->txb = NULL;
Z
Zhu Yi 已提交
193 194 195 196

	return -ENOMEM;
}

197 198 199
/**
 * iwl3945_tx_queue_init - Allocate and initialize one tx/cmd queue
 */
200
int iwl3945_tx_queue_init(struct iwl_priv *priv,
201
		      struct iwl_tx_queue *txq, int slots_num, u32 txq_id)
Z
Zhu Yi 已提交
202
{
203
	int len, i;
Z
Zhu Yi 已提交
204 205
	int rc = 0;

206 207 208 209 210 211 212 213
	/*
	 * 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.
	 */
214 215 216 217 218 219 220 221 222 223 224 225 226
	len = sizeof(struct iwl_cmd);
	for (i = 0; i <= slots_num; i++) {
		if (i == slots_num) {
			if (txq_id == IWL_CMD_QUEUE_NUM)
				len += IWL_MAX_SCAN_SIZE;
			else
				continue;
		}

		txq->cmd[i] = kmalloc(len, GFP_KERNEL);
		if (!txq->cmd[i])
			goto err;
	}
Z
Zhu Yi 已提交
227

228
	/* Alloc driver data array and TFD circular buffer */
C
Christoph Hellwig 已提交
229
	rc = iwl3945_tx_queue_alloc(priv, txq, txq_id);
230 231
	if (rc)
		goto err;
Z
Zhu Yi 已提交
232 233 234 235

	txq->need_update = 0;

	/* TFD_QUEUE_SIZE_MAX must be power-of-two size, otherwise
T
Tomas Winkler 已提交
236
	 * iwl_queue_inc_wrap and iwl_queue_dec_wrap are broken. */
Z
Zhu Yi 已提交
237
	BUILD_BUG_ON(TFD_QUEUE_SIZE_MAX & (TFD_QUEUE_SIZE_MAX - 1));
238 239

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

242
	/* Tell device where to find queue, enable DMA channel. */
C
Christoph Hellwig 已提交
243
	iwl3945_hw_tx_queue_init(priv, txq);
Z
Zhu Yi 已提交
244 245

	return 0;
246 247 248 249 250 251 252 253 254 255 256
err:
	for (i = 0; i < slots_num; i++) {
		kfree(txq->cmd[i]);
		txq->cmd[i] = NULL;
	}

	if (txq_id == IWL_CMD_QUEUE_NUM) {
		kfree(txq->cmd[slots_num]);
		txq->cmd[slots_num] = NULL;
	}
	return -ENOMEM;
Z
Zhu Yi 已提交
257 258 259
}

/**
C
Christoph Hellwig 已提交
260
 * iwl3945_tx_queue_free - Deallocate DMA queue.
Z
Zhu Yi 已提交
261 262 263
 * @txq: Transmit queue to deallocate.
 *
 * Empty queue by removing and destroying all BD's.
264 265
 * Free all buffers.
 * 0-fill, but do not free "txq" descriptor structure.
Z
Zhu Yi 已提交
266
 */
267
void iwl3945_tx_queue_free(struct iwl_priv *priv, struct iwl_tx_queue *txq)
Z
Zhu Yi 已提交
268
{
269
	struct iwl_queue *q = &txq->q;
Z
Zhu Yi 已提交
270
	struct pci_dev *dev = priv->pci_dev;
271
	int len, i;
Z
Zhu Yi 已提交
272 273 274 275 276

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

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

281
	len = sizeof(struct iwl_cmd) * q->n_window;
Z
Zhu Yi 已提交
282 283 284
	if (q->id == IWL_CMD_QUEUE_NUM)
		len += IWL_MAX_SCAN_SIZE;

285
	/* De-alloc array of command/tx buffers */
286 287
	for (i = 0; i < TFD_TX_CMD_SLOTS; i++)
		kfree(txq->cmd[i]);
Z
Zhu Yi 已提交
288

289
	/* De-alloc circular buffer of TFDs */
Z
Zhu Yi 已提交
290
	if (txq->q.n_bd)
W
Winkler, Tomas 已提交
291
		pci_free_consistent(dev, sizeof(struct iwl3945_tfd) *
292
				    txq->q.n_bd, txq->tfds39, txq->q.dma_addr);
Z
Zhu Yi 已提交
293

294
	/* De-alloc array of per-TFD driver data */
295 296
	kfree(txq->txb);
	txq->txb = NULL;
Z
Zhu Yi 已提交
297

298
	/* 0-fill queue descriptor structure */
Z
Zhu Yi 已提交
299 300 301 302
	memset(txq, 0, sizeof(*txq));
}

/*************** STATION TABLE MANAGEMENT ****
303
 * mac80211 should be examined to determine if sta_info is duplicating
Z
Zhu Yi 已提交
304 305 306 307
 * the functionality provided here
 */

/**************************************************************/
308
#if 0 /* temporary disable till we add real remove station */
309 310 311 312 313
/**
 * iwl3945_remove_station - Remove driver's knowledge of station.
 *
 * NOTE:  This does not remove station from device's station table.
 */
314
static u8 iwl3945_remove_station(struct iwl_priv *priv, const u8 *addr, int is_ap)
Z
Zhu Yi 已提交
315 316 317 318 319 320 321 322 323 324
{
	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))
325
		index = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
326
	else
327
		for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++)
328 329
			if (priv->stations_39[i].used &&
			    !compare_ether_addr(priv->stations_39[i].sta.sta.addr,
Z
Zhu Yi 已提交
330 331 332 333 334 335 336 337
						addr)) {
				index = i;
				break;
			}

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

338 339
	if (priv->stations_39[index].used) {
		priv->stations_39[index].used = 0;
Z
Zhu Yi 已提交
340 341 342 343 344 345 346 347 348
		priv->num_stations--;
	}

	BUG_ON(priv->num_stations < 0);

out:
	spin_unlock_irqrestore(&priv->sta_lock, flags);
	return 0;
}
349
#endif
350 351 352 353 354 355

/**
 * iwl3945_clear_stations_table - Clear the driver's station table
 *
 * NOTE:  This does not clear or otherwise alter the device's station table.
 */
356
static void iwl3945_clear_stations_table(struct iwl_priv *priv)
Z
Zhu Yi 已提交
357 358 359 360 361 362
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);

	priv->num_stations = 0;
363
	memset(priv->stations_39, 0, sizeof(priv->stations_39));
Z
Zhu Yi 已提交
364 365 366 367

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

368 369 370
/**
 * iwl3945_add_station - Add station to station tables in driver and device
 */
371
u8 iwl3945_add_station(struct iwl_priv *priv, const u8 *addr, int is_ap, u8 flags)
Z
Zhu Yi 已提交
372 373 374
{
	int i;
	int index = IWL_INVALID_STATION;
C
Christoph Hellwig 已提交
375
	struct iwl3945_station_entry *station;
Z
Zhu Yi 已提交
376
	unsigned long flags_spin;
377
	u8 rate;
Z
Zhu Yi 已提交
378 379 380 381 382

	spin_lock_irqsave(&priv->sta_lock, flags_spin);
	if (is_ap)
		index = IWL_AP_ID;
	else if (is_broadcast_ether_addr(addr))
383
		index = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
384
	else
385
		for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++) {
386
			if (!compare_ether_addr(priv->stations_39[i].sta.sta.addr,
Z
Zhu Yi 已提交
387 388 389 390 391
						addr)) {
				index = i;
				break;
			}

392
			if (!priv->stations_39[i].used &&
Z
Zhu Yi 已提交
393 394 395 396
			    index == IWL_INVALID_STATION)
				index = i;
		}

397
	/* These two conditions has the same outcome but keep them separate
Z
Zhu Yi 已提交
398 399 400 401 402 403
	  since they have different meaning */
	if (unlikely(index == IWL_INVALID_STATION)) {
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return index;
	}

404 405
	if (priv->stations_39[index].used &&
	   !compare_ether_addr(priv->stations_39[index].sta.sta.addr, addr)) {
Z
Zhu Yi 已提交
406 407 408 409
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return index;
	}

J
Johannes Berg 已提交
410
	IWL_DEBUG_ASSOC("Add STA ID %d: %pM\n", index, addr);
411
	station = &priv->stations_39[index];
Z
Zhu Yi 已提交
412 413 414
	station->used = 1;
	priv->num_stations++;

415
	/* Set up the REPLY_ADD_STA command to send to device */
C
Christoph Hellwig 已提交
416
	memset(&station->sta, 0, sizeof(struct iwl3945_addsta_cmd));
Z
Zhu Yi 已提交
417 418 419 420 421
	memcpy(station->sta.sta.addr, addr, ETH_ALEN);
	station->sta.mode = 0;
	station->sta.sta.sta_id = index;
	station->sta.station_flags = 0;

422
	if (priv->band == IEEE80211_BAND_5GHZ)
423 424 425
		rate = IWL_RATE_6M_PLCP;
	else
		rate =	IWL_RATE_1M_PLCP;
426 427 428

	/* Turn on both antennas for the station... */
	station->sta.rate_n_flags =
C
Christoph Hellwig 已提交
429
			iwl3945_hw_set_rate_n_flags(rate, RATE_MCS_ANT_AB_MSK);
430

Z
Zhu Yi 已提交
431
	spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
432 433

	/* Add station to device's station table */
C
Christoph Hellwig 已提交
434
	iwl3945_send_add_station(priv, &station->sta, flags);
Z
Zhu Yi 已提交
435 436 437 438 439 440 441
	return index;

}


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

442
#define IWL_CMD(x) case x: return #x
Z
Zhu Yi 已提交
443 444 445
#define HOST_COMPLETE_TIMEOUT (HZ / 2)

/**
C
Christoph Hellwig 已提交
446
 * iwl3945_enqueue_hcmd - enqueue a uCode command
Z
Zhu Yi 已提交
447 448 449 450 451 452 453
 * @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.
 */
454
static int iwl3945_enqueue_hcmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
Z
Zhu Yi 已提交
455
{
456
	struct iwl_tx_queue *txq = &priv->txq[IWL_CMD_QUEUE_NUM];
457
	struct iwl_queue *q = &txq->q;
W
Winkler, Tomas 已提交
458
	struct iwl3945_tfd *tfd;
459
	struct iwl_cmd *out_cmd;
Z
Zhu Yi 已提交
460 461 462 463
	u32 idx;
	u16 fix_size = (u16)(cmd->len + sizeof(out_cmd->hdr));
	dma_addr_t phys_addr;
	int pad;
464
	int ret, len;
Z
Zhu Yi 已提交
465 466 467 468 469
	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 */
470
	BUG_ON((fix_size > TFD_MAX_PAYLOAD_SIZE) &&
Z
Zhu Yi 已提交
471 472
	       !(cmd->meta.flags & CMD_SIZE_HUGE));

473

474
	if (iwl_is_rfkill(priv)) {
475 476 477 478
		IWL_DEBUG_INFO("Not sending command - RF KILL");
		return -EIO;
	}

479
	if (iwl_queue_space(q) < ((cmd->meta.flags & CMD_ASYNC) ? 2 : 1)) {
480
		IWL_ERR(priv, "No space for Tx\n");
Z
Zhu Yi 已提交
481 482 483 484 485
		return -ENOSPC;
	}

	spin_lock_irqsave(&priv->hcmd_lock, flags);

486
	tfd = &txq->tfds39[q->write_ptr];
Z
Zhu Yi 已提交
487 488
	memset(tfd, 0, sizeof(*tfd));

489
	idx = get_cmd_index(q, q->write_ptr, cmd->meta.flags & CMD_SIZE_HUGE);
490
	out_cmd = txq->cmd[idx];
Z
Zhu Yi 已提交
491 492 493 494 495 496 497 498 499 500

	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) |
501
			INDEX_TO_SEQ(q->write_ptr));
Z
Zhu Yi 已提交
502
	if (out_cmd->meta.flags & CMD_SIZE_HUGE)
503
		out_cmd->hdr.sequence |= SEQ_HUGE_FRAME;
Z
Zhu Yi 已提交
504

505 506 507 508 509 510 511 512 513
	len = (idx == TFD_CMD_SLOTS) ?
			IWL_MAX_SCAN_SIZE : sizeof(struct iwl_cmd);

	phys_addr = pci_map_single(priv->pci_dev, out_cmd,
					len, PCI_DMA_TODEVICE);
	pci_unmap_addr_set(&out_cmd->meta, mapping, phys_addr);
	pci_unmap_len_set(&out_cmd->meta, len, len);
	phys_addr += offsetof(struct iwl_cmd, hdr);

C
Christoph Hellwig 已提交
514
	iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, phys_addr, fix_size);
Z
Zhu Yi 已提交
515 516

	pad = U32_PAD(cmd->len);
W
Winkler, Tomas 已提交
517
	tfd->control_flags |= cpu_to_le32(TFD_CTL_PAD_SET(pad));
Z
Zhu Yi 已提交
518 519 520 521 522

	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),
523
		     fix_size, q->write_ptr, idx, IWL_CMD_QUEUE_NUM);
Z
Zhu Yi 已提交
524 525

	txq->need_update = 1;
526 527

	/* Increment and update queue's write index */
T
Tomas Winkler 已提交
528
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
C
Christoph Hellwig 已提交
529
	ret = iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
530 531 532 533 534

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

535 536
static int iwl3945_send_cmd_async(struct iwl_priv *priv,
				  struct iwl_host_cmd *cmd)
Z
Zhu Yi 已提交
537 538 539 540 541 542 543 544 545 546 547 548 549 550
{
	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 已提交
551
	ret = iwl3945_enqueue_hcmd(priv, cmd);
Z
Zhu Yi 已提交
552
	if (ret < 0) {
553 554 555
		IWL_ERR(priv,
			"Error sending %s: iwl3945_enqueue_hcmd failed: %d\n",
			get_cmd_string(cmd->id), ret);
Z
Zhu Yi 已提交
556 557 558 559 560
		return ret;
	}
	return 0;
}

561 562
static int iwl3945_send_cmd_sync(struct iwl_priv *priv,
				 struct iwl_host_cmd *cmd)
Z
Zhu Yi 已提交
563 564 565 566 567 568 569 570 571
{
	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);

572
	if (test_and_set_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status)) {
573 574 575
		IWL_ERR(priv,
			"Error sending %s: Already sending a host command\n",
			get_cmd_string(cmd->id));
576 577
		ret = -EBUSY;
		goto out;
Z
Zhu Yi 已提交
578 579 580 581 582 583 584
	}

	set_bit(STATUS_HCMD_ACTIVE, &priv->status);

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

C
Christoph Hellwig 已提交
585
	cmd_idx = iwl3945_enqueue_hcmd(priv, cmd);
Z
Zhu Yi 已提交
586 587
	if (cmd_idx < 0) {
		ret = cmd_idx;
588 589 590
		IWL_ERR(priv,
			"Error sending %s: iwl3945_enqueue_hcmd failed: %d\n",
			get_cmd_string(cmd->id), ret);
Z
Zhu Yi 已提交
591 592 593 594 595 596 597 598
		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)) {
599
			IWL_ERR(priv, "Error sending %s: time out after %dms\n",
Z
Zhu Yi 已提交
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
				  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) {
622
		IWL_ERR(priv, "Error: Response NULL in '%s'\n",
Z
Zhu Yi 已提交
623 624
			  get_cmd_string(cmd->id));
		ret = -EIO;
625
		goto cancel;
Z
Zhu Yi 已提交
626 627 628 629 630 631 632
	}

	ret = 0;
	goto out;

cancel:
	if (cmd->meta.flags & CMD_WANT_SKB) {
633
		struct iwl_cmd *qcmd;
Z
Zhu Yi 已提交
634 635 636 637 638

		/* 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). */
639
		qcmd = priv->txq[IWL_CMD_QUEUE_NUM].cmd[cmd_idx];
Z
Zhu Yi 已提交
640 641 642 643 644 645 646 647
		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:
648
	clear_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status);
Z
Zhu Yi 已提交
649 650 651
	return ret;
}

652
int iwl3945_send_cmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
Z
Zhu Yi 已提交
653 654
{
	if (cmd->meta.flags & CMD_ASYNC)
C
Christoph Hellwig 已提交
655
		return iwl3945_send_cmd_async(priv, cmd);
Z
Zhu Yi 已提交
656

C
Christoph Hellwig 已提交
657
	return iwl3945_send_cmd_sync(priv, cmd);
Z
Zhu Yi 已提交
658 659
}

660
int iwl3945_send_cmd_pdu(struct iwl_priv *priv, u8 id, u16 len, const void *data)
Z
Zhu Yi 已提交
661
{
662
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
663 664 665 666 667
		.id = id,
		.len = len,
		.data = data,
	};

C
Christoph Hellwig 已提交
668
	return iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
669 670
}

671
static int __must_check iwl3945_send_cmd_u32(struct iwl_priv *priv, u8 id, u32 val)
Z
Zhu Yi 已提交
672
{
673
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
674 675 676 677 678
		.id = id,
		.len = sizeof(val),
		.data = &val,
	};

C
Christoph Hellwig 已提交
679
	return iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
680 681
}

682
int iwl3945_send_statistics_request(struct iwl_priv *priv)
Z
Zhu Yi 已提交
683
{
C
Christoph Hellwig 已提交
684
	return iwl3945_send_cmd_u32(priv, REPLY_STATISTICS_CMD, 0);
Z
Zhu Yi 已提交
685 686 687
}

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

692
 * In addition to setting the staging RXON, priv->band is also set.
Z
Zhu Yi 已提交
693 694
 *
 * NOTE:  Does not commit to the hardware; it sets appropriate bit fields
695
 * in the staging RXON flag structure based on the band
Z
Zhu Yi 已提交
696
 */
697
static int iwl3945_set_rxon_channel(struct iwl_priv *priv,
698 699
				    enum ieee80211_band band,
				    u16 channel)
Z
Zhu Yi 已提交
700
{
701
	if (!iwl3945_get_channel_info(priv, band, channel)) {
Z
Zhu Yi 已提交
702
		IWL_DEBUG_INFO("Could not set channel to %d [%d]\n",
703
			       channel, band);
Z
Zhu Yi 已提交
704 705 706
		return -EINVAL;
	}

707
	if ((le16_to_cpu(priv->staging39_rxon.channel) == channel) &&
708
	    (priv->band == band))
Z
Zhu Yi 已提交
709 710
		return 0;

711
	priv->staging39_rxon.channel = cpu_to_le16(channel);
712
	if (band == IEEE80211_BAND_5GHZ)
713
		priv->staging39_rxon.flags &= ~RXON_FLG_BAND_24G_MSK;
Z
Zhu Yi 已提交
714
	else
715
		priv->staging39_rxon.flags |= RXON_FLG_BAND_24G_MSK;
Z
Zhu Yi 已提交
716

717
	priv->band = band;
Z
Zhu Yi 已提交
718

719
	IWL_DEBUG_INFO("Staging channel set to %d [%d]\n", channel, band);
Z
Zhu Yi 已提交
720 721 722 723 724

	return 0;
}

/**
C
Christoph Hellwig 已提交
725
 * iwl3945_check_rxon_cmd - validate RXON structure is valid
Z
Zhu Yi 已提交
726 727 728 729 730
 *
 * 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
 */
731
static int iwl3945_check_rxon_cmd(struct iwl_priv *priv)
Z
Zhu Yi 已提交
732 733 734
{
	int error = 0;
	int counter = 1;
735
	struct iwl3945_rxon_cmd *rxon = &priv->staging39_rxon;
Z
Zhu Yi 已提交
736 737 738 739 740 741

	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)
742
			IWL_WARN(priv, "check 24G fields %d | %d\n",
Z
Zhu Yi 已提交
743 744 745 746 747
				    counter++, error);
	} else {
		error |= (rxon->flags & RXON_FLG_SHORT_SLOT_MSK) ?
				0 : le32_to_cpu(RXON_FLG_SHORT_SLOT_MSK);
		if (error)
748
			IWL_WARN(priv, "check 52 fields %d | %d\n",
Z
Zhu Yi 已提交
749 750 751
				    counter++, error);
		error |= le32_to_cpu(rxon->flags & RXON_FLG_CCK_MSK);
		if (error)
752
			IWL_WARN(priv, "check 52 CCK %d | %d\n",
Z
Zhu Yi 已提交
753 754 755 756
				    counter++, error);
	}
	error |= (rxon->node_addr[0] | rxon->bssid_addr[0]) & 0x1;
	if (error)
757
		IWL_WARN(priv, "check mac addr %d | %d\n", counter++, error);
Z
Zhu Yi 已提交
758 759 760 761 762

	/* 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)
763
		IWL_WARN(priv, "check basic rate %d | %d\n", counter++, error);
Z
Zhu Yi 已提交
764 765 766

	error |= (le16_to_cpu(rxon->assoc_id) > 2007);
	if (error)
767
		IWL_WARN(priv, "check assoc id %d | %d\n", counter++, error);
Z
Zhu Yi 已提交
768 769 770 771

	error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK))
			== (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK));
	if (error)
772
		IWL_WARN(priv, "check CCK and short slot %d | %d\n",
Z
Zhu Yi 已提交
773 774 775 776 777
			    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)
778
		IWL_WARN(priv, "check CCK & auto detect %d | %d\n",
Z
Zhu Yi 已提交
779 780 781 782 783
			    counter++, error);

	error |= ((rxon->flags & (RXON_FLG_AUTO_DETECT_MSK |
			RXON_FLG_TGG_PROTECT_MSK)) == RXON_FLG_TGG_PROTECT_MSK);
	if (error)
784
		IWL_WARN(priv, "check TGG and auto detect %d | %d\n",
Z
Zhu Yi 已提交
785 786 787 788 789 790
			    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)
791
		IWL_WARN(priv, "check antenna %d %d\n", counter++, error);
Z
Zhu Yi 已提交
792 793

	if (error)
794
		IWL_WARN(priv, "Tuning to channel %d\n",
Z
Zhu Yi 已提交
795 796 797
			    le16_to_cpu(rxon->channel));

	if (error) {
798
		IWL_ERR(priv, "Not a valid rxon_assoc_cmd field values\n");
Z
Zhu Yi 已提交
799 800 801 802 803 804
		return -1;
	}
	return 0;
}

/**
805
 * iwl3945_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
806
 * @priv: staging_rxon is compared to active_rxon
Z
Zhu Yi 已提交
807
 *
808 809 810
 * 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 已提交
811
 */
812
static int iwl3945_full_rxon_required(struct iwl_priv *priv)
Z
Zhu Yi 已提交
813 814 815
{

	/* These items are only settable from the full RXON command */
816
	if (!(iwl3945_is_associated(priv)) ||
817 818 819 820 821 822 823 824 825 826 827
	    compare_ether_addr(priv->staging39_rxon.bssid_addr,
			       priv->active39_rxon.bssid_addr) ||
	    compare_ether_addr(priv->staging39_rxon.node_addr,
			       priv->active39_rxon.node_addr) ||
	    compare_ether_addr(priv->staging39_rxon.wlap_bssid_addr,
			       priv->active39_rxon.wlap_bssid_addr) ||
	    (priv->staging39_rxon.dev_type != priv->active39_rxon.dev_type) ||
	    (priv->staging39_rxon.channel != priv->active39_rxon.channel) ||
	    (priv->staging39_rxon.air_propagation !=
	     priv->active39_rxon.air_propagation) ||
	    (priv->staging39_rxon.assoc_id != priv->active39_rxon.assoc_id))
Z
Zhu Yi 已提交
828 829 830 831 832 833 834
		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 */
835 836
	if ((priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK) !=
	    (priv->active39_rxon.flags & RXON_FLG_BAND_24G_MSK))
Z
Zhu Yi 已提交
837 838 839
		return 1;

	/* Check if we are switching association toggle */
840 841
	if ((priv->staging39_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) !=
		(priv->active39_rxon.filter_flags & RXON_FILTER_ASSOC_MSK))
Z
Zhu Yi 已提交
842 843 844 845 846
		return 1;

	return 0;
}

847
static int iwl3945_send_rxon_assoc(struct iwl_priv *priv)
Z
Zhu Yi 已提交
848 849
{
	int rc = 0;
850
	struct iwl_rx_packet *res = NULL;
C
Christoph Hellwig 已提交
851
	struct iwl3945_rxon_assoc_cmd rxon_assoc;
852
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
853 854 855 856 857
		.id = REPLY_RXON_ASSOC,
		.len = sizeof(rxon_assoc),
		.meta.flags = CMD_WANT_SKB,
		.data = &rxon_assoc,
	};
858 859
	const struct iwl3945_rxon_cmd *rxon1 = &priv->staging39_rxon;
	const struct iwl3945_rxon_cmd *rxon2 = &priv->active39_rxon;
Z
Zhu Yi 已提交
860 861 862 863 864 865 866 867 868

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

869 870 871 872
	rxon_assoc.flags = priv->staging39_rxon.flags;
	rxon_assoc.filter_flags = priv->staging39_rxon.filter_flags;
	rxon_assoc.ofdm_basic_rates = priv->staging39_rxon.ofdm_basic_rates;
	rxon_assoc.cck_basic_rates = priv->staging39_rxon.cck_basic_rates;
Z
Zhu Yi 已提交
873 874
	rxon_assoc.reserved = 0;

C
Christoph Hellwig 已提交
875
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
876 877 878
	if (rc)
		return rc;

879
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
880
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
881
		IWL_ERR(priv, "Bad return from REPLY_RXON_ASSOC command\n");
Z
Zhu Yi 已提交
882 883 884 885 886 887 888 889 890 891
		rc = -EIO;
	}

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

	return rc;
}

/**
C
Christoph Hellwig 已提交
892
 * iwl3945_commit_rxon - commit staging_rxon to hardware
Z
Zhu Yi 已提交
893
 *
894
 * The RXON command in staging_rxon is committed to the hardware and
Z
Zhu Yi 已提交
895 896 897 898
 * 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.
 */
899
static int iwl3945_commit_rxon(struct iwl_priv *priv)
Z
Zhu Yi 已提交
900 901
{
	/* cast away the const for active_rxon in this function */
902
	struct iwl3945_rxon_cmd *active_rxon = (void *)&priv->active39_rxon;
Z
Zhu Yi 已提交
903 904
	int rc = 0;

905
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
906 907 908
		return -1;

	/* always get timestamp with Rx frame */
909
	priv->staging39_rxon.flags |= RXON_FLG_TSF2HOST_MSK;
Z
Zhu Yi 已提交
910 911

	/* select antenna */
912
	priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
913
	    ~(RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_SEL_MSK);
914
	priv->staging39_rxon.flags |= iwl3945_get_antenna_flags(priv);
Z
Zhu Yi 已提交
915

916
	rc = iwl3945_check_rxon_cmd(priv);
Z
Zhu Yi 已提交
917
	if (rc) {
918
		IWL_ERR(priv, "Invalid RXON configuration.  Not committing.\n");
Z
Zhu Yi 已提交
919 920 921 922
		return -EINVAL;
	}

	/* If we don't need to send a full RXON, we can use
C
Christoph Hellwig 已提交
923
	 * iwl3945_rxon_assoc_cmd which is used to reconfigure filter
Z
Zhu Yi 已提交
924
	 * and other flags for the current radio configuration. */
C
Christoph Hellwig 已提交
925 926
	if (!iwl3945_full_rxon_required(priv)) {
		rc = iwl3945_send_rxon_assoc(priv);
Z
Zhu Yi 已提交
927
		if (rc) {
928
			IWL_ERR(priv, "Error setting RXON_ASSOC "
Z
Zhu Yi 已提交
929 930 931 932
				  "configuration (%d).\n", rc);
			return rc;
		}

933
		memcpy(active_rxon, &priv->staging39_rxon, sizeof(*active_rxon));
Z
Zhu Yi 已提交
934 935 936 937 938 939 940 941

		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 已提交
942
	if (iwl3945_is_associated(priv) &&
943
	    (priv->staging39_rxon.filter_flags & RXON_FILTER_ASSOC_MSK)) {
Z
Zhu Yi 已提交
944 945 946
		IWL_DEBUG_INFO("Toggling associated bit on current RXON\n");
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;

C
Christoph Hellwig 已提交
947 948
		rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON,
				      sizeof(struct iwl3945_rxon_cmd),
949
				      &priv->active39_rxon);
Z
Zhu Yi 已提交
950 951 952 953 954

		/* 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;
955
			IWL_ERR(priv, "Error clearing ASSOC_MSK on current "
Z
Zhu Yi 已提交
956 957 958 959 960 961 962 963
				  "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 已提交
964
		       "* bssid = %pM\n",
965
		       ((priv->staging39_rxon.filter_flags &
Z
Zhu Yi 已提交
966
			 RXON_FILTER_ASSOC_MSK) ? "" : "out"),
967
		       le16_to_cpu(priv->staging39_rxon.channel),
J
Johannes Berg 已提交
968
		       priv->staging_rxon.bssid_addr);
Z
Zhu Yi 已提交
969 970

	/* Apply the new configuration */
C
Christoph Hellwig 已提交
971
	rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON,
972
			      sizeof(struct iwl3945_rxon_cmd), &priv->staging39_rxon);
Z
Zhu Yi 已提交
973
	if (rc) {
974
		IWL_ERR(priv, "Error setting new configuration (%d).\n", rc);
Z
Zhu Yi 已提交
975 976 977
		return rc;
	}

978
	memcpy(active_rxon, &priv->staging39_rxon, sizeof(*active_rxon));
Z
Zhu Yi 已提交
979

C
Christoph Hellwig 已提交
980
	iwl3945_clear_stations_table(priv);
981

Z
Zhu Yi 已提交
982 983
	/* 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 已提交
984
	rc = iwl3945_hw_reg_send_txpower(priv);
Z
Zhu Yi 已提交
985
	if (rc) {
986
		IWL_ERR(priv, "Error setting Tx power (%d).\n", rc);
Z
Zhu Yi 已提交
987 988 989 990
		return rc;
	}

	/* Add the broadcast address so we can send broadcast frames */
991
	if (iwl3945_add_station(priv, iwl_bcast_addr, 0, 0) ==
Z
Zhu Yi 已提交
992
	    IWL_INVALID_STATION) {
993
		IWL_ERR(priv, "Error adding BROADCAST address for transmit.\n");
Z
Zhu Yi 已提交
994 995 996 997 998
		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 已提交
999
	if (iwl3945_is_associated(priv) &&
1000
	    (priv->iw_mode == NL80211_IFTYPE_STATION))
1001
		if (iwl3945_add_station(priv, priv->active39_rxon.bssid_addr, 1, 0)
Z
Zhu Yi 已提交
1002
		    == IWL_INVALID_STATION) {
1003
			IWL_ERR(priv, "Error adding AP address for transmit\n");
Z
Zhu Yi 已提交
1004 1005 1006
			return -EIO;
		}

1007
	/* Init the hardware's rate fallback order based on the band */
Z
Zhu Yi 已提交
1008 1009
	rc = iwl3945_init_hw_rate_table(priv);
	if (rc) {
1010
		IWL_ERR(priv, "Error setting HW rate table: %02X\n", rc);
Z
Zhu Yi 已提交
1011 1012 1013 1014 1015 1016
		return -EIO;
	}

	return 0;
}

1017
static int iwl3945_send_bt_config(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1018
{
1019
	struct iwl_bt_cmd bt_cmd = {
Z
Zhu Yi 已提交
1020 1021 1022 1023 1024 1025 1026
		.flags = 3,
		.lead_time = 0xAA,
		.max_kill = 1,
		.kill_ack_mask = 0,
		.kill_cts_mask = 0,
	};

C
Christoph Hellwig 已提交
1027
	return iwl3945_send_cmd_pdu(priv, REPLY_BT_CONFIG,
1028
					sizeof(bt_cmd), &bt_cmd);
Z
Zhu Yi 已提交
1029 1030
}

1031
static int iwl3945_send_scan_abort(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1032 1033
{
	int rc = 0;
1034
	struct iwl_rx_packet *res;
1035
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
		.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 已提交
1048
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
1049 1050 1051 1052 1053
	if (rc) {
		clear_bit(STATUS_SCAN_ABORTING, &priv->status);
		return rc;
	}

1054
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
	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;
}

1072
static int iwl3945_add_sta_sync_callback(struct iwl_priv *priv,
1073
				     struct iwl_cmd *cmd, struct sk_buff *skb)
Z
Zhu Yi 已提交
1074
{
1075
	struct iwl_rx_packet *res = NULL;
Z
Zhu Yi 已提交
1076 1077

	if (!skb) {
1078
		IWL_ERR(priv, "Error: Response NULL in REPLY_ADD_STA.\n");
Z
Zhu Yi 已提交
1079 1080 1081
		return 1;
	}

1082
	res = (struct iwl_rx_packet *)skb->data;
Z
Zhu Yi 已提交
1083
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
1084
		IWL_ERR(priv, "Bad return from REPLY_ADD_STA (0x%08X)\n",
Z
Zhu Yi 已提交
1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
			  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;
}

1100
int iwl3945_send_add_station(struct iwl_priv *priv,
C
Christoph Hellwig 已提交
1101
			 struct iwl3945_addsta_cmd *sta, u8 flags)
Z
Zhu Yi 已提交
1102
{
1103
	struct iwl_rx_packet *res = NULL;
Z
Zhu Yi 已提交
1104
	int rc = 0;
1105
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
1106
		.id = REPLY_ADD_STA,
C
Christoph Hellwig 已提交
1107
		.len = sizeof(struct iwl3945_addsta_cmd),
Z
Zhu Yi 已提交
1108 1109 1110 1111 1112
		.meta.flags = flags,
		.data = sta,
	};

	if (flags & CMD_ASYNC)
C
Christoph Hellwig 已提交
1113
		cmd.meta.u.callback = iwl3945_add_sta_sync_callback;
Z
Zhu Yi 已提交
1114 1115 1116
	else
		cmd.meta.flags |= CMD_WANT_SKB;

C
Christoph Hellwig 已提交
1117
	rc = iwl3945_send_cmd(priv, &cmd);
Z
Zhu Yi 已提交
1118 1119 1120 1121

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

1122
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1123
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
1124
		IWL_ERR(priv, "Bad return from REPLY_ADD_STA (0x%08X)\n",
Z
Zhu Yi 已提交
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
			  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;
1136
			IWL_WARN(priv, "REPLY_ADD_STA failed\n");
Z
Zhu Yi 已提交
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
			break;
		}
	}

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

	return rc;
}

1147
static int iwl3945_update_sta_key_info(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
				   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);
1167 1168 1169
	priv->stations_39[sta_id].keyinfo.alg = keyconf->alg;
	priv->stations_39[sta_id].keyinfo.keylen = keyconf->keylen;
	memcpy(priv->stations_39[sta_id].keyinfo.key, keyconf->key,
Z
Zhu Yi 已提交
1170 1171
	       keyconf->keylen);

1172
	memcpy(priv->stations_39[sta_id].sta.key.key, keyconf->key,
Z
Zhu Yi 已提交
1173
	       keyconf->keylen);
1174 1175 1176
	priv->stations_39[sta_id].sta.key.key_flags = key_flags;
	priv->stations_39[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations_39[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
Z
Zhu Yi 已提交
1177 1178 1179 1180

	spin_unlock_irqrestore(&priv->sta_lock, flags);

	IWL_DEBUG_INFO("hwcrypto: modify ucode station key info\n");
1181
	iwl3945_send_add_station(priv, &priv->stations_39[sta_id].sta, 0);
Z
Zhu Yi 已提交
1182 1183 1184
	return 0;
}

1185
static int iwl3945_clear_sta_key_info(struct iwl_priv *priv, u8 sta_id)
Z
Zhu Yi 已提交
1186 1187 1188 1189
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);
1190 1191
	memset(&priv->stations_39[sta_id].keyinfo, 0, sizeof(struct iwl3945_hw_key));
	memset(&priv->stations_39[sta_id].sta.key, 0,
1192
		sizeof(struct iwl4965_keyinfo));
1193 1194 1195
	priv->stations_39[sta_id].sta.key.key_flags = STA_KEY_FLG_NO_ENC;
	priv->stations_39[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations_39[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
Z
Zhu Yi 已提交
1196 1197 1198
	spin_unlock_irqrestore(&priv->sta_lock, flags);

	IWL_DEBUG_INFO("hwcrypto: clear ucode station key info\n");
1199
	iwl3945_send_add_station(priv, &priv->stations_39[sta_id].sta, 0);
Z
Zhu Yi 已提交
1200 1201 1202
	return 0;
}

1203
static void iwl3945_clear_free_frames(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1204 1205 1206 1207 1208 1209 1210 1211 1212
{
	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 已提交
1213
		kfree(list_entry(element, struct iwl3945_frame, list));
Z
Zhu Yi 已提交
1214 1215 1216 1217
		priv->frames_count--;
	}

	if (priv->frames_count) {
1218
		IWL_WARN(priv, "%d frames still in use.  Did we lose one?\n",
Z
Zhu Yi 已提交
1219 1220 1221 1222 1223
			    priv->frames_count);
		priv->frames_count = 0;
	}
}

1224
static struct iwl3945_frame *iwl3945_get_free_frame(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1225
{
C
Christoph Hellwig 已提交
1226
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
1227 1228 1229 1230
	struct list_head *element;
	if (list_empty(&priv->free_frames)) {
		frame = kzalloc(sizeof(*frame), GFP_KERNEL);
		if (!frame) {
1231
			IWL_ERR(priv, "Could not allocate frame!\n");
Z
Zhu Yi 已提交
1232 1233 1234 1235 1236 1237 1238 1239 1240
			return NULL;
		}

		priv->frames_count++;
		return frame;
	}

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

1244
static void iwl3945_free_frame(struct iwl_priv *priv, struct iwl3945_frame *frame)
Z
Zhu Yi 已提交
1245 1246 1247 1248 1249
{
	memset(frame, 0, sizeof(*frame));
	list_add(&frame->list, &priv->free_frames);
}

1250
unsigned int iwl3945_fill_beacon_frame(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1251
				struct ieee80211_hdr *hdr,
1252
				int left)
Z
Zhu Yi 已提交
1253 1254
{

C
Christoph Hellwig 已提交
1255
	if (!iwl3945_is_associated(priv) || !priv->ibss_beacon ||
1256 1257
	    ((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
	     (priv->iw_mode != NL80211_IFTYPE_AP)))
Z
Zhu Yi 已提交
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
		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;
}

1268
static u8 iwl3945_rate_get_lowest_plcp(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1269 1270
{
	u8 i;
1271 1272 1273
	int rate_mask;

	/* Set rate mask*/
1274
	if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK)
1275
		rate_mask = priv->active_rate_basic & IWL_CCK_RATES_MASK;
1276
	else
1277
		rate_mask = priv->active_rate_basic & IWL_OFDM_RATES_MASK;
Z
Zhu Yi 已提交
1278 1279

	for (i = IWL_RATE_1M_INDEX; i != IWL_RATE_INVALID;
C
Christoph Hellwig 已提交
1280
	     i = iwl3945_rates[i].next_ieee) {
Z
Zhu Yi 已提交
1281
		if (rate_mask & (1 << i))
C
Christoph Hellwig 已提交
1282
			return iwl3945_rates[i].plcp;
Z
Zhu Yi 已提交
1283 1284
	}

1285
	/* No valid rate was found. Assign the lowest one */
1286
	if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK)
1287 1288 1289
		return IWL_RATE_1M_PLCP;
	else
		return IWL_RATE_6M_PLCP;
Z
Zhu Yi 已提交
1290 1291
}

1292
static int iwl3945_send_beacon_cmd(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1293
{
C
Christoph Hellwig 已提交
1294
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
1295 1296 1297 1298
	unsigned int frame_size;
	int rc;
	u8 rate;

C
Christoph Hellwig 已提交
1299
	frame = iwl3945_get_free_frame(priv);
Z
Zhu Yi 已提交
1300 1301

	if (!frame) {
1302
		IWL_ERR(priv, "Could not obtain free frame buffer for beacon "
Z
Zhu Yi 已提交
1303 1304 1305 1306
			  "command.\n");
		return -ENOMEM;
	}

1307
	rate = iwl3945_rate_get_lowest_plcp(priv);
Z
Zhu Yi 已提交
1308

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

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

C
Christoph Hellwig 已提交
1314
	iwl3945_free_frame(priv, frame);
Z
Zhu Yi 已提交
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324

	return rc;
}

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

1325
static void get_eeprom_mac(struct iwl_priv *priv, u8 *mac)
Z
Zhu Yi 已提交
1326
{
1327
	memcpy(mac, priv->eeprom39.mac_address, 6);
Z
Zhu Yi 已提交
1328 1329
}

1330 1331 1332 1333 1334 1335 1336 1337
/*
 * 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!).
 */
1338
static inline int iwl3945_eeprom_acquire_semaphore(struct iwl_priv *priv)
1339
{
1340
	_iwl_clear_bit(priv, CSR_EEPROM_GP, CSR_EEPROM_GP_IF_OWNER_MSK);
1341 1342 1343
	return 0;
}

Z
Zhu Yi 已提交
1344
/**
C
Christoph Hellwig 已提交
1345
 * iwl3945_eeprom_init - read EEPROM contents
Z
Zhu Yi 已提交
1346
 *
1347
 * Load the EEPROM contents from adapter into priv->eeprom39
Z
Zhu Yi 已提交
1348 1349 1350
 *
 * NOTE:  This routine uses the non-debug IO access functions.
 */
1351
int iwl3945_eeprom_init(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1352
{
1353
	u16 *e = (u16 *)&priv->eeprom39;
1354
	u32 gp = iwl_read32(priv, CSR_EEPROM_GP);
1355
	int sz = sizeof(priv->eeprom39);
1356
	int ret;
Z
Zhu Yi 已提交
1357 1358 1359 1360 1361 1362
	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. */
1363
	BUILD_BUG_ON(sizeof(priv->eeprom39) != IWL_EEPROM_IMAGE_SIZE);
Z
Zhu Yi 已提交
1364 1365

	if ((gp & CSR_EEPROM_GP_VALID_MSK) == CSR_EEPROM_GP_BAD_SIGNATURE) {
1366
		IWL_ERR(priv, "EEPROM not found, EEPROM_GP=0x%08x\n", gp);
Z
Zhu Yi 已提交
1367 1368 1369
		return -ENOENT;
	}

1370
	/* Make sure driver (instead of uCode) is allowed to read EEPROM */
1371 1372
	ret = iwl3945_eeprom_acquire_semaphore(priv);
	if (ret < 0) {
1373
		IWL_ERR(priv, "Failed to acquire EEPROM semaphore.\n");
Z
Zhu Yi 已提交
1374 1375 1376 1377 1378
		return -ENOENT;
	}

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

1381
		_iwl_write32(priv, CSR_EEPROM_REG,
1382
				 CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
1383 1384
		_iwl_clear_bit(priv, CSR_EEPROM_REG, CSR_EEPROM_REG_BIT_CMD);
		ret = iwl_poll_direct_bit(priv, CSR_EEPROM_REG,
1385 1386 1387
					      CSR_EEPROM_REG_READ_VALID_MSK,
					      IWL_EEPROM_ACCESS_TIMEOUT);
		if (ret < 0) {
1388
			IWL_ERR(priv, "Time out reading EEPROM[%d]\n", addr);
1389
			return ret;
Z
Zhu Yi 已提交
1390
		}
1391

1392
		r = _iwl_read_direct32(priv, CSR_EEPROM_REG);
1393
		e[addr / 2] = le16_to_cpu((__force __le16)(r >> 16));
Z
Zhu Yi 已提交
1394 1395 1396 1397 1398
	}

	return 0;
}

1399
static void iwl3945_unset_hw_params(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1400
{
1401
	if (priv->shared_virt)
Z
Zhu Yi 已提交
1402
		pci_free_consistent(priv->pci_dev,
C
Christoph Hellwig 已提交
1403
				    sizeof(struct iwl3945_shared),
1404 1405
				    priv->shared_virt,
				    priv->shared_phys);
Z
Zhu Yi 已提交
1406 1407 1408
}

/**
C
Christoph Hellwig 已提交
1409
 * iwl3945_supported_rate_to_ie - fill in the supported rate in IE field
Z
Zhu Yi 已提交
1410 1411 1412
 *
 * return : set the bit for each supported rate insert in ie
 */
C
Christoph Hellwig 已提交
1413
static u16 iwl3945_supported_rate_to_ie(u8 *ie, u16 supported_rate,
1414
				    u16 basic_rate, int *left)
Z
Zhu Yi 已提交
1415 1416 1417
{
	u16 ret_rates = 0, bit;
	int i;
1418 1419
	u8 *cnt = ie;
	u8 *rates = ie + 1;
Z
Zhu Yi 已提交
1420 1421 1422 1423

	for (bit = 1, i = 0; i < IWL_RATE_COUNT; i++, bit <<= 1) {
		if (bit & supported_rate) {
			ret_rates |= bit;
C
Christoph Hellwig 已提交
1424
			rates[*cnt] = iwl3945_rates[i].ieee |
1425 1426 1427 1428 1429
				((bit & basic_rate) ? 0x80 : 0x00);
			(*cnt)++;
			(*left)--;
			if ((*left <= 0) ||
			    (*cnt >= IWL_SUPPORTED_RATES_IE_LEN))
Z
Zhu Yi 已提交
1430 1431 1432 1433 1434 1435 1436 1437
				break;
		}
	}

	return ret_rates;
}

/**
C
Christoph Hellwig 已提交
1438
 * iwl3945_fill_probe_req - fill in all required fields and IE for probe request
Z
Zhu Yi 已提交
1439
 */
1440
static u16 iwl3945_fill_probe_req(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1441
			      struct ieee80211_mgmt *frame,
J
Johannes Berg 已提交
1442
			      int left)
Z
Zhu Yi 已提交
1443 1444 1445
{
	int len = 0;
	u8 *pos = NULL;
1446
	u16 active_rates, ret_rates, cck_rates;
Z
Zhu Yi 已提交
1447 1448 1449 1450 1451 1452 1453 1454 1455

	/* 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);
1456
	memcpy(frame->da, iwl_bcast_addr, ETH_ALEN);
Z
Zhu Yi 已提交
1457
	memcpy(frame->sa, priv->mac_addr, ETH_ALEN);
1458
	memcpy(frame->bssid, iwl_bcast_addr, ETH_ALEN);
Z
Zhu Yi 已提交
1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476
	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;
1477

Z
Zhu Yi 已提交
1478 1479 1480
	/* ... fill it in... */
	*pos++ = WLAN_EID_SUPP_RATES;
	*pos = 0;
1481 1482 1483

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

1486
	cck_rates = IWL_CCK_RATES_MASK & active_rates;
C
Christoph Hellwig 已提交
1487
	ret_rates = iwl3945_supported_rate_to_ie(pos, cck_rates,
1488 1489 1490
			priv->active_rate_basic, &left);
	active_rates &= ~ret_rates;

C
Christoph Hellwig 已提交
1491
	ret_rates = iwl3945_supported_rate_to_ie(pos, active_rates,
1492 1493 1494
				 priv->active_rate_basic, &left);
	active_rates &= ~ret_rates;

Z
Zhu Yi 已提交
1495 1496
	len += 2 + *pos;
	pos += (*pos) + 1;
1497
	if (active_rates == 0)
Z
Zhu Yi 已提交
1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
		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 已提交
1508
	iwl3945_supported_rate_to_ie(pos, active_rates,
1509
				 priv->active_rate_basic, &left);
Z
Zhu Yi 已提交
1510 1511 1512 1513 1514 1515 1516 1517 1518 1519
	if (*pos > 0)
		len += 2 + *pos;

 fill_end:
	return (u16)len;
}

/*
 * QoS  support
*/
1520
static int iwl3945_send_qos_params_command(struct iwl_priv *priv,
1521
				       struct iwl_qosparam_cmd *qos)
Z
Zhu Yi 已提交
1522 1523
{

C
Christoph Hellwig 已提交
1524
	return iwl3945_send_cmd_pdu(priv, REPLY_QOS_PARAM,
1525
				sizeof(struct iwl_qosparam_cmd), qos);
Z
Zhu Yi 已提交
1526 1527
}

1528
static void iwl3945_activate_qos(struct iwl_priv *priv, u8 force)
Z
Zhu Yi 已提交
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548
{
	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 已提交
1549
	if (force || iwl3945_is_associated(priv)) {
T
Tomas Winkler 已提交
1550
		IWL_DEBUG_QOS("send QoS cmd with QoS active %d \n",
Z
Zhu Yi 已提交
1551 1552
			      priv->qos_data.qos_active);

C
Christoph Hellwig 已提交
1553
		iwl3945_send_qos_params_command(priv,
Z
Zhu Yi 已提交
1554 1555 1556 1557 1558 1559 1560 1561 1562
				&(priv->qos_data.def_qos_parm));
	}
}

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

1563 1564 1565

#define NOSLP __constant_cpu_to_le16(0), 0, 0
#define SLP IWL_POWER_DRIVER_ALLOW_SLEEP_MSK, 0, 0
Z
Zhu Yi 已提交
1566 1567 1568 1569 1570 1571 1572 1573
#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 已提交
1574
/* for TIM  0-10 */
1575
static struct iwl_power_vec_entry range_0[IWL39_POWER_AC] = {
Z
Zhu Yi 已提交
1576 1577 1578 1579 1580 1581 1582 1583
	{{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 已提交
1584
/* for TIM > 10 */
1585
static struct iwl_power_vec_entry range_1[IWL39_POWER_AC] = {
Z
Zhu Yi 已提交
1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
	{{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}
};

1598
int iwl3945_power_init_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1599 1600
{
	int rc = 0, i;
C
Christoph Hellwig 已提交
1601
	struct iwl3945_power_mgr *pow_data;
1602
	int size = sizeof(struct iwl_power_vec_entry) * IWL39_POWER_AC;
Z
Zhu Yi 已提交
1603 1604 1605 1606
	u16 pci_pm;

	IWL_DEBUG_POWER("Initialize power \n");

1607
	pow_data = &(priv->power_data_39);
Z
Zhu Yi 已提交
1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620

	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 {
1621
		struct iwl_powertable_cmd *cmd;
Z
Zhu Yi 已提交
1622 1623 1624

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

1625
		for (i = 0; i < IWL39_POWER_AC; i++) {
Z
Zhu Yi 已提交
1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636
			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;
}

1637
static int iwl3945_update_power_cmd(struct iwl_priv *priv,
1638
				struct iwl_powertable_cmd *cmd, u32 mode)
Z
Zhu Yi 已提交
1639 1640 1641 1642
{
	int rc = 0, i;
	u8 skip;
	u32 max_sleep = 0;
1643
	struct iwl_power_vec_entry *range;
Z
Zhu Yi 已提交
1644
	u8 period = 0;
C
Christoph Hellwig 已提交
1645
	struct iwl3945_power_mgr *pow_data;
Z
Zhu Yi 已提交
1646 1647 1648 1649 1650

	if (mode > IWL_POWER_INDEX_5) {
		IWL_DEBUG_POWER("Error invalid power mode \n");
		return -1;
	}
1651
	pow_data = &(priv->power_data_39);
Z
Zhu Yi 已提交
1652 1653 1654 1655 1656 1657

	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 已提交
1658
	memcpy(cmd, &range[mode].cmd, sizeof(struct iwl3945_powertable_cmd));
Z
Zhu Yi 已提交
1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700

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

1701
static int iwl3945_send_power_mode(struct iwl_priv *priv, u32 mode)
Z
Zhu Yi 已提交
1702
{
1703
	u32 uninitialized_var(final_mode);
Z
Zhu Yi 已提交
1704
	int rc;
1705
	struct iwl_powertable_cmd cmd;
Z
Zhu Yi 已提交
1706 1707

	/* If on battery, set to 3,
1708
	 * if plugged into AC power, set to CAM ("continuously aware mode"),
Z
Zhu Yi 已提交
1709 1710
	 * else user level */
	switch (mode) {
1711
	case IWL39_POWER_BATTERY:
Z
Zhu Yi 已提交
1712 1713
		final_mode = IWL_POWER_INDEX_3;
		break;
1714
	case IWL39_POWER_AC:
Z
Zhu Yi 已提交
1715 1716 1717 1718 1719 1720 1721
		final_mode = IWL_POWER_MODE_CAM;
		break;
	default:
		final_mode = mode;
		break;
	}

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

1724 1725 1726
	/* FIXME use get_hcmd_size 3945 command is 4 bytes shorter */
	rc = iwl3945_send_cmd_pdu(priv, POWER_TABLE_CMD,
				sizeof(struct iwl3945_powertable_cmd), &cmd);
Z
Zhu Yi 已提交
1727 1728 1729 1730 1731 1732 1733 1734 1735 1736

	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 已提交
1737
 * iwl3945_scan_cancel - Cancel any currently executing HW scan
Z
Zhu Yi 已提交
1738 1739 1740
 *
 * NOTE: priv->mutex is not required before calling this function
 */
1741
static int iwl3945_scan_cancel(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763
{
	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 已提交
1764
 * iwl3945_scan_cancel_timeout - Cancel any currently executing HW scan
Z
Zhu Yi 已提交
1765 1766 1767 1768
 * @ms: amount of time to wait (in milliseconds) for scan to abort
 *
 * NOTE: priv->mutex must be held before calling this function
 */
1769
static int iwl3945_scan_cancel_timeout(struct iwl_priv *priv, unsigned long ms)
Z
Zhu Yi 已提交
1770 1771 1772 1773
{
	unsigned long now = jiffies;
	int ret;

C
Christoph Hellwig 已提交
1774
	ret = iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790
	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 已提交
1791
static __le16 iwl3945_adjust_beacon_interval(u16 beacon_val)
Z
Zhu Yi 已提交
1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803
{
	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);
}

1804
static void iwl3945_setup_rxon_timing(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1805 1806 1807 1808 1809 1810 1811 1812 1813 1814
{
	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);
1815
	priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
Z
Zhu Yi 已提交
1816 1817
	priv->rxon_timing.listen_interval = INTEL_CONN_LISTEN_INTERVAL;

1818
	tsf = priv->timestamp;
Z
Zhu Yi 已提交
1819 1820 1821 1822

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

1823
	if (priv->iw_mode == NL80211_IFTYPE_STATION) {
Z
Zhu Yi 已提交
1824 1825 1826 1827 1828 1829 1830
		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 已提交
1831
			    iwl3945_adjust_beacon_interval(
Z
Zhu Yi 已提交
1832 1833 1834 1835 1836 1837
				le16_to_cpu(priv->rxon_timing.beacon_interval));
		}

		priv->rxon_timing.atim_window = 0;
	} else {
		priv->rxon_timing.beacon_interval =
C
Christoph Hellwig 已提交
1838
			iwl3945_adjust_beacon_interval(conf->beacon_int);
Z
Zhu Yi 已提交
1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856
		/* 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));
}

1857
static int iwl3945_scan_initiate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1858
{
1859
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875
		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");
1876 1877 1878 1879
	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 已提交
1880 1881 1882 1883 1884 1885 1886 1887 1888
	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;
}

1889
static int iwl3945_set_rxon_hwcrypto(struct iwl_priv *priv, int hw_decrypt)
Z
Zhu Yi 已提交
1890
{
1891
	struct iwl3945_rxon_cmd *rxon = &priv->staging39_rxon;
Z
Zhu Yi 已提交
1892 1893 1894 1895 1896 1897 1898 1899 1900

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

	return 0;
}

1901
static void iwl3945_set_flags_for_phymode(struct iwl_priv *priv,
1902
					  enum ieee80211_band band)
Z
Zhu Yi 已提交
1903
{
1904
	if (band == IEEE80211_BAND_5GHZ) {
1905
		priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
1906 1907
		    ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
		      | RXON_FLG_CCK_MSK);
1908
		priv->staging39_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1909
	} else {
C
Christoph Hellwig 已提交
1910
		/* Copied from iwl3945_bg_post_associate() */
Z
Zhu Yi 已提交
1911
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
1912
			priv->staging39_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1913
		else
1914
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1915

1916
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
1917
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1918

1919 1920 1921
		priv->staging39_rxon.flags |= RXON_FLG_BAND_24G_MSK;
		priv->staging39_rxon.flags |= RXON_FLG_AUTO_DETECT_MSK;
		priv->staging39_rxon.flags &= ~RXON_FLG_CCK_MSK;
Z
Zhu Yi 已提交
1922 1923 1924 1925
	}
}

/*
1926
 * initialize rxon structure with default values from eeprom
Z
Zhu Yi 已提交
1927
 */
1928
static void iwl3945_connection_init_rx_config(struct iwl_priv *priv,
1929
					      int mode)
Z
Zhu Yi 已提交
1930
{
1931
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
1932

1933
	memset(&priv->staging39_rxon, 0, sizeof(priv->staging39_rxon));
Z
Zhu Yi 已提交
1934

1935
	switch (mode) {
1936
	case NL80211_IFTYPE_AP:
1937
		priv->staging39_rxon.dev_type = RXON_DEV_TYPE_AP;
Z
Zhu Yi 已提交
1938 1939
		break;

1940
	case NL80211_IFTYPE_STATION:
1941 1942
		priv->staging39_rxon.dev_type = RXON_DEV_TYPE_ESS;
		priv->staging39_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
Z
Zhu Yi 已提交
1943 1944
		break;

1945
	case NL80211_IFTYPE_ADHOC:
1946 1947 1948
		priv->staging39_rxon.dev_type = RXON_DEV_TYPE_IBSS;
		priv->staging39_rxon.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
		priv->staging39_rxon.filter_flags = RXON_FILTER_BCON_AWARE_MSK |
Z
Zhu Yi 已提交
1949 1950 1951
						  RXON_FILTER_ACCEPT_GRP_MSK;
		break;

1952
	case NL80211_IFTYPE_MONITOR:
1953 1954
		priv->staging39_rxon.dev_type = RXON_DEV_TYPE_SNIFFER;
		priv->staging39_rxon.filter_flags = RXON_FILTER_PROMISC_MSK |
Z
Zhu Yi 已提交
1955 1956
		    RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_ACCEPT_GRP_MSK;
		break;
1957
	default:
1958
		IWL_ERR(priv, "Unsupported interface type %d\n", mode);
1959
		break;
Z
Zhu Yi 已提交
1960 1961 1962 1963 1964 1965
	}

#if 0
	/* TODO:  Figure out when short_preamble would be set and cache from
	 * that */
	if (!hw_to_local(priv->hw)->short_preamble)
1966
		priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
1967
	else
1968
		priv->staging39_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
1969 1970
#endif

1971
	ch_info = iwl3945_get_channel_info(priv, priv->band,
1972
				       le16_to_cpu(priv->active39_rxon.channel));
Z
Zhu Yi 已提交
1973 1974 1975 1976 1977 1978 1979 1980

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

1984
	priv->staging39_rxon.channel = cpu_to_le16(ch_info->channel);
Z
Zhu Yi 已提交
1985
	if (is_channel_a_band(ch_info))
1986
		priv->band = IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
1987
	else
1988
		priv->band = IEEE80211_BAND_2GHZ;
Z
Zhu Yi 已提交
1989

1990
	iwl3945_set_flags_for_phymode(priv, priv->band);
Z
Zhu Yi 已提交
1991

1992
	priv->staging39_rxon.ofdm_basic_rates =
Z
Zhu Yi 已提交
1993
	    (IWL_OFDM_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
1994
	priv->staging39_rxon.cck_basic_rates =
Z
Zhu Yi 已提交
1995 1996 1997
	    (IWL_CCK_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
}

1998
static int iwl3945_set_mode(struct iwl_priv *priv, int mode)
Z
Zhu Yi 已提交
1999
{
2000
	if (mode == NL80211_IFTYPE_ADHOC) {
2001
		const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
2002

C
Christoph Hellwig 已提交
2003
		ch_info = iwl3945_get_channel_info(priv,
2004
			priv->band,
2005
			le16_to_cpu(priv->staging39_rxon.channel));
Z
Zhu Yi 已提交
2006 2007

		if (!ch_info || !is_channel_ibss(ch_info)) {
2008
			IWL_ERR(priv, "channel %d not IBSS channel\n",
2009
				  le16_to_cpu(priv->staging39_rxon.channel));
Z
Zhu Yi 已提交
2010 2011 2012 2013
			return -EINVAL;
		}
	}

2014
	iwl3945_connection_init_rx_config(priv, mode);
2015
	memcpy(priv->staging39_rxon.node_addr, priv->mac_addr, ETH_ALEN);
Z
Zhu Yi 已提交
2016

C
Christoph Hellwig 已提交
2017
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
2018

T
Tomas Winkler 已提交
2019
	/* don't commit rxon if rf-kill is on*/
2020
	if (!iwl_is_ready_rf(priv))
2021 2022 2023 2024
		return -EAGAIN;

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

C
Christoph Hellwig 已提交
2030
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
2031 2032 2033 2034

	return 0;
}

2035
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl_priv *priv,
2036
				      struct ieee80211_tx_info *info,
2037
				      struct iwl_cmd *cmd,
Z
Zhu Yi 已提交
2038 2039 2040
				      struct sk_buff *skb_frag,
				      int last_frag)
{
2041
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
2042
	struct iwl3945_hw_key *keyinfo =
2043
	    &priv->stations_39[info->control.hw_key->hw_key_idx].keyinfo;
Z
Zhu Yi 已提交
2044 2045 2046

	switch (keyinfo->alg) {
	case ALG_CCMP:
2047 2048
		tx->sec_ctl = TX_CMD_SEC_CCM;
		memcpy(tx->key, keyinfo->key, keyinfo->keylen);
T
Tomas Winkler 已提交
2049
		IWL_DEBUG_TX("tx_cmd with AES hwcrypto\n");
Z
Zhu Yi 已提交
2050 2051 2052 2053
		break;

	case ALG_TKIP:
#if 0
2054
		tx->sec_ctl = TX_CMD_SEC_TKIP;
Z
Zhu Yi 已提交
2055 2056

		if (last_frag)
2057
			memcpy(tx->tkip_mic.byte, skb_frag->tail - 8,
Z
Zhu Yi 已提交
2058 2059
			       8);
		else
2060
			memset(tx->tkip_mic.byte, 0, 8);
Z
Zhu Yi 已提交
2061 2062 2063 2064
#endif
		break;

	case ALG_WEP:
2065
		tx->sec_ctl = TX_CMD_SEC_WEP |
2066
		    (info->control.hw_key->hw_key_idx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT;
Z
Zhu Yi 已提交
2067 2068

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

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

		IWL_DEBUG_TX("Configuring packet for WEP encryption "
2074
			     "with key %d\n", info->control.hw_key->hw_key_idx);
Z
Zhu Yi 已提交
2075 2076 2077
		break;

	default:
T
Tomas Winkler 已提交
2078
		IWL_ERR(priv, "Unknown encode alg %d\n", keyinfo->alg);
Z
Zhu Yi 已提交
2079 2080 2081 2082 2083 2084 2085
		break;
	}
}

/*
 * handle build REPLY_TX command notification.
 */
2086
static void iwl3945_build_tx_cmd_basic(struct iwl_priv *priv,
2087
				  struct iwl_cmd *cmd,
2088
				  struct ieee80211_tx_info *info,
2089
				  struct ieee80211_hdr *hdr, u8 std_id)
Z
Zhu Yi 已提交
2090
{
2091 2092
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
	__le32 tx_flags = tx->tx_flags;
2093
	__le16 fc = hdr->frame_control;
2094
	u8 rc_flags = info->control.rates[0].flags;
Z
Zhu Yi 已提交
2095

2096
	tx->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
2097
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Z
Zhu Yi 已提交
2098
		tx_flags |= TX_CMD_FLG_ACK_MSK;
2099
		if (ieee80211_is_mgmt(fc))
Z
Zhu Yi 已提交
2100
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
2101
		if (ieee80211_is_probe_resp(fc) &&
Z
Zhu Yi 已提交
2102 2103 2104 2105 2106 2107 2108
		    !(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;
	}

2109
	tx->sta_id = std_id;
2110
	if (ieee80211_has_morefrags(fc))
Z
Zhu Yi 已提交
2111 2112
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

2113 2114
	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
2115
		tx->tid_tspec = qc[0] & 0xf;
Z
Zhu Yi 已提交
2116
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
2117
	} else {
Z
Zhu Yi 已提交
2118
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
2119
	}
Z
Zhu Yi 已提交
2120

2121
	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
Z
Zhu Yi 已提交
2122 2123
		tx_flags |= TX_CMD_FLG_RTS_MSK;
		tx_flags &= ~TX_CMD_FLG_CTS_MSK;
2124
	} else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
Z
Zhu Yi 已提交
2125 2126 2127 2128 2129 2130 2131 2132
		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);
2133 2134
	if (ieee80211_is_mgmt(fc)) {
		if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
2135
			tx->timeout.pm_frame_timeout = cpu_to_le16(3);
Z
Zhu Yi 已提交
2136
		else
2137
			tx->timeout.pm_frame_timeout = cpu_to_le16(2);
M
Mohamed Abbas 已提交
2138
	} else {
2139
		tx->timeout.pm_frame_timeout = 0;
M
Mohamed Abbas 已提交
2140 2141 2142 2143
#ifdef CONFIG_IWL3945_LEDS
		priv->rxtxpackets += le16_to_cpu(cmd->cmd.tx.len);
#endif
	}
Z
Zhu Yi 已提交
2144

2145 2146 2147
	tx->driver_txop = 0;
	tx->tx_flags = tx_flags;
	tx->next_frame_len = 0;
Z
Zhu Yi 已提交
2148 2149
}

2150 2151 2152
/**
 * iwl3945_get_sta_id - Find station's index within station table
 */
2153
static int iwl3945_get_sta_id(struct iwl_priv *priv, struct ieee80211_hdr *hdr)
Z
Zhu Yi 已提交
2154 2155 2156 2157
{
	int sta_id;
	u16 fc = le16_to_cpu(hdr->frame_control);

2158
	/* If this frame is broadcast or management, use broadcast station id */
Z
Zhu Yi 已提交
2159 2160
	if (((fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA) ||
	    is_multicast_ether_addr(hdr->addr1))
2161
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
2162 2163 2164

	switch (priv->iw_mode) {

2165 2166
	/* If we are a client station in a BSS network, use the special
	 * AP station entry (that's the only station we communicate with) */
2167
	case NL80211_IFTYPE_STATION:
Z
Zhu Yi 已提交
2168 2169 2170
		return IWL_AP_ID;

	/* If we are an AP, then find the station, or use BCAST */
2171
	case NL80211_IFTYPE_AP:
C
Christoph Hellwig 已提交
2172
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
2173 2174
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;
2175
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
2176

2177 2178
	/* If this frame is going out to an IBSS network, find the station,
	 * or create a new station table entry */
2179
	case NL80211_IFTYPE_ADHOC: {
2180
		/* Create new station table entry */
C
Christoph Hellwig 已提交
2181
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
2182 2183 2184
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

C
Christoph Hellwig 已提交
2185
		sta_id = iwl3945_add_station(priv, hdr->addr1, 0, CMD_ASYNC);
Z
Zhu Yi 已提交
2186 2187 2188 2189

		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

J
Johannes Berg 已提交
2190
		IWL_DEBUG_DROP("Station %pM not in station map. "
Z
Zhu Yi 已提交
2191
			       "Defaulting to broadcast...\n",
J
Johannes Berg 已提交
2192
			       hdr->addr1);
2193
		iwl_print_hex_dump(priv, IWL_DL_DROP, (u8 *) hdr, sizeof(*hdr));
2194
		return priv->hw_params.bcast_sta_id;
2195
	}
2196 2197
	/* If we are in monitor mode, use BCAST. This is required for
	 * packet injection. */
2198
	case NL80211_IFTYPE_MONITOR:
2199
		return priv->hw_params.bcast_sta_id;
2200

Z
Zhu Yi 已提交
2201
	default:
2202 2203
		IWL_WARN(priv, "Unknown mode of operation: %d\n",
			priv->iw_mode);
2204
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
2205 2206 2207 2208 2209 2210
	}
}

/*
 * start REPLY_TX command process
 */
2211
static int iwl3945_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
Z
Zhu Yi 已提交
2212 2213
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2214
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
W
Winkler, Tomas 已提交
2215
	struct iwl3945_tfd *tfd;
2216
	struct iwl3945_tx_cmd *tx;
2217
	struct iwl_tx_queue *txq = NULL;
2218
	struct iwl_queue *q = NULL;
2219
	struct iwl_cmd *out_cmd = NULL;
Z
Zhu Yi 已提交
2220 2221
	dma_addr_t phys_addr;
	dma_addr_t txcmd_phys;
2222
	int txq_id = skb_get_queue_mapping(skb);
2223 2224 2225
	u16 len, idx, len_org, hdr_len;
	u8 id;
	u8 unicast;
Z
Zhu Yi 已提交
2226
	u8 sta_id;
2227
	u8 tid = 0;
Z
Zhu Yi 已提交
2228
	u16 seq_number = 0;
2229
	__le16 fc;
Z
Zhu Yi 已提交
2230
	u8 wait_write_ptr = 0;
2231
	u8 *qc = NULL;
Z
Zhu Yi 已提交
2232 2233 2234 2235
	unsigned long flags;
	int rc;

	spin_lock_irqsave(&priv->lock, flags);
2236
	if (iwl_is_rfkill(priv)) {
Z
Zhu Yi 已提交
2237 2238 2239 2240
		IWL_DEBUG_DROP("Dropping - RF KILL\n");
		goto drop_unlock;
	}

2241
	if ((ieee80211_get_tx_rate(priv->hw, info)->hw_value & 0xFF) == IWL_INVALID_RATE) {
2242
		IWL_ERR(priv, "ERROR: No TX rate available.\n");
Z
Zhu Yi 已提交
2243 2244 2245 2246 2247 2248
		goto drop_unlock;
	}

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

2249
	fc = hdr->frame_control;
Z
Zhu Yi 已提交
2250

2251
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
2252 2253
	if (ieee80211_is_auth(fc))
		IWL_DEBUG_TX("Sending AUTH frame\n");
2254
	else if (ieee80211_is_assoc_req(fc))
Z
Zhu Yi 已提交
2255
		IWL_DEBUG_TX("Sending ASSOC frame\n");
2256
	else if (ieee80211_is_reassoc_req(fc))
Z
Zhu Yi 已提交
2257 2258 2259
		IWL_DEBUG_TX("Sending REASSOC frame\n");
#endif

2260
	/* drop all data frame if we are not associated */
2261
	if (ieee80211_is_data(fc) &&
2262
	    (priv->iw_mode != NL80211_IFTYPE_MONITOR) && /* packet injection */
2263
	    (!iwl3945_is_associated(priv) ||
2264
	     ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id))) {
C
Christoph Hellwig 已提交
2265
		IWL_DEBUG_DROP("Dropping - !iwl3945_is_associated\n");
Z
Zhu Yi 已提交
2266 2267 2268 2269 2270
		goto drop_unlock;
	}

	spin_unlock_irqrestore(&priv->lock, flags);

2271
	hdr_len = ieee80211_hdrlen(fc);
2272 2273

	/* Find (or create) index into station table for destination station */
C
Christoph Hellwig 已提交
2274
	sta_id = iwl3945_get_sta_id(priv, hdr);
Z
Zhu Yi 已提交
2275
	if (sta_id == IWL_INVALID_STATION) {
J
Johannes Berg 已提交
2276 2277
		IWL_DEBUG_DROP("Dropping - INVALID STATION: %pM\n",
			       hdr->addr1);
Z
Zhu Yi 已提交
2278 2279 2280 2281 2282
		goto drop;
	}

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

2283 2284
	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
2285
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
2286
		seq_number = priv->stations_39[sta_id].tid[tid].seq_number &
Z
Zhu Yi 已提交
2287 2288 2289 2290 2291 2292
				IEEE80211_SCTL_SEQ;
		hdr->seq_ctrl = cpu_to_le16(seq_number) |
			(hdr->seq_ctrl &
				__constant_cpu_to_le16(IEEE80211_SCTL_FRAG));
		seq_number += 0x10;
	}
2293 2294

	/* Descriptor for chosen Tx queue */
2295
	txq = &priv->txq[txq_id];
Z
Zhu Yi 已提交
2296 2297 2298 2299
	q = &txq->q;

	spin_lock_irqsave(&priv->lock, flags);

2300
	/* Set up first empty TFD within this queue's circular TFD buffer */
2301
	tfd = &txq->tfds39[q->write_ptr];
Z
Zhu Yi 已提交
2302
	memset(tfd, 0, sizeof(*tfd));
2303
	idx = get_cmd_index(q, q->write_ptr, 0);
Z
Zhu Yi 已提交
2304

2305
	/* Set up driver data for this TFD */
W
Winkler, Tomas 已提交
2306
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl_tx_info));
2307
	txq->txb[q->write_ptr].skb[0] = skb;
2308 2309

	/* Init first empty entry in queue's array of Tx/cmd buffers */
2310
	out_cmd = txq->cmd[idx];
2311
	tx = (struct iwl3945_tx_cmd *)out_cmd->cmd.payload;
Z
Zhu Yi 已提交
2312
	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
2313
	memset(tx, 0, sizeof(*tx));
2314 2315 2316 2317 2318 2319 2320

	/*
	 * 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 已提交
2321 2322
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
2323
				INDEX_TO_SEQ(q->write_ptr)));
2324 2325

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

2328 2329 2330 2331 2332 2333 2334 2335 2336
	/*
	 * 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.
	 */
2337
	len = sizeof(struct iwl3945_tx_cmd) +
2338
			sizeof(struct iwl_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
2339 2340 2341 2342 2343 2344 2345 2346 2347

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

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

2348 2349
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
2350 2351 2352 2353 2354 2355 2356 2357
	txcmd_phys = pci_map_single(priv->pci_dev,
				    out_cmd, sizeof(struct iwl_cmd),
				    PCI_DMA_TODEVICE);
	pci_unmap_addr_set(&out_cmd->meta, mapping, txcmd_phys);
	pci_unmap_len_set(&out_cmd->meta, len, sizeof(struct iwl_cmd));
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
	txcmd_phys += offsetof(struct iwl_cmd, hdr);
Z
Zhu Yi 已提交
2358

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

2363
	if (info->control.hw_key)
2364
		iwl3945_build_tx_cmd_hwcrypto(priv, info, out_cmd, skb, 0);
Z
Zhu Yi 已提交
2365

2366 2367
	/* 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 已提交
2368 2369 2370 2371
	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 已提交
2372
		iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, phys_addr, len);
Z
Zhu Yi 已提交
2373 2374 2375
	}

	if (!len)
2376
		/* If there is no payload, then we use only one Tx buffer */
W
Winkler, Tomas 已提交
2377
		tfd->control_flags = cpu_to_le32(TFD_CTL_COUNT_SET(1));
Z
Zhu Yi 已提交
2378
	else
2379 2380
		/* Else use 2 buffers.
		 * Tell 3945 about any padding after MAC header */
W
Winkler, Tomas 已提交
2381 2382
		tfd->control_flags = cpu_to_le32(TFD_CTL_COUNT_SET(2) |
			TFD_CTL_PAD_SET(U32_PAD(len)));
Z
Zhu Yi 已提交
2383

2384
	/* Total # bytes to be transmitted */
Z
Zhu Yi 已提交
2385
	len = (u16)skb->len;
2386
	tx->len = cpu_to_le16(len);
Z
Zhu Yi 已提交
2387 2388

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

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

2394 2395
	tx->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
	tx->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;
Z
Zhu Yi 已提交
2396

2397
	if (!ieee80211_has_morefrags(hdr->frame_control)) {
Z
Zhu Yi 已提交
2398
		txq->need_update = 1;
2399
		if (qc)
2400
			priv->stations_39[sta_id].tid[tid].seq_number = seq_number;
Z
Zhu Yi 已提交
2401 2402 2403 2404 2405
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

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

2408
	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx->hdr,
2409
			   ieee80211_hdrlen(fc));
Z
Zhu Yi 已提交
2410

2411
	/* Tell device the write index *just past* this latest filled TFD */
T
Tomas Winkler 已提交
2412
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
C
Christoph Hellwig 已提交
2413
	rc = iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
2414 2415 2416 2417 2418
	spin_unlock_irqrestore(&priv->lock, flags);

	if (rc)
		return rc;

2419
	if ((iwl_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
2420 2421 2422 2423
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
C
Christoph Hellwig 已提交
2424
			iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
2425 2426 2427
			spin_unlock_irqrestore(&priv->lock, flags);
		}

2428
		ieee80211_stop_queue(priv->hw, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
2429 2430 2431 2432 2433 2434 2435 2436 2437 2438
	}

	return 0;

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

2439
static void iwl3945_set_rate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2440
{
2441
	const struct ieee80211_supported_band *sband = NULL;
Z
Zhu Yi 已提交
2442 2443 2444
	struct ieee80211_rate *rate;
	int i;

K
Kolekar, Abhijeet 已提交
2445
	sband = iwl_get_hw_mode(priv, priv->band);
2446
	if (!sband) {
2447
		IWL_ERR(priv, "Failed to set rate: unable to get hw mode\n");
2448 2449
		return;
	}
Z
Zhu Yi 已提交
2450 2451 2452 2453

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

2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464
	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 已提交
2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475
	}

	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)
2476
		priv->staging39_rxon.cck_basic_rates =
Z
Zhu Yi 已提交
2477 2478 2479
		    ((priv->active_rate_basic &
		      IWL_CCK_RATES_MASK) >> IWL_FIRST_CCK_RATE) & 0xF;
	else
2480
		priv->staging39_rxon.cck_basic_rates =
Z
Zhu Yi 已提交
2481 2482 2483
		    (IWL_CCK_BASIC_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;

	if (priv->active_rate_basic & IWL_OFDM_BASIC_RATES_MASK)
2484
		priv->staging39_rxon.ofdm_basic_rates =
Z
Zhu Yi 已提交
2485 2486 2487 2488
		    ((priv->active_rate_basic &
		      (IWL_OFDM_BASIC_RATES_MASK | IWL_RATE_6M_MASK)) >>
		      IWL_FIRST_OFDM_RATE) & 0xFF;
	else
2489
		priv->staging39_rxon.ofdm_basic_rates =
Z
Zhu Yi 已提交
2490 2491 2492
		   (IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
}

2493
static void iwl3945_radio_kill_sw(struct iwl_priv *priv, int disable_radio)
Z
Zhu Yi 已提交
2494 2495 2496 2497 2498 2499 2500 2501 2502 2503
{
	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 已提交
2504
		iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
2505
		/* FIXME: This is a workaround for AP */
2506
		if (priv->iw_mode != NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
2507
			spin_lock_irqsave(&priv->lock, flags);
2508
			iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
2509 2510
				    CSR_UCODE_SW_BIT_RFKILL);
			spin_unlock_irqrestore(&priv->lock, flags);
2511
			iwl_send_card_state(priv, CARD_STATE_CMD_DISABLE, 0);
Z
Zhu Yi 已提交
2512 2513 2514 2515 2516 2517
			set_bit(STATUS_RF_KILL_SW, &priv->status);
		}
		return;
	}

	spin_lock_irqsave(&priv->lock, flags);
2518
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
Z
Zhu Yi 已提交
2519 2520 2521 2522 2523 2524 2525 2526

	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);
2527 2528 2529
	iwl_read32(priv, CSR_UCODE_DRV_GP1);
	if (!iwl_grab_nic_access(priv))
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2530 2531 2532 2533 2534 2535 2536 2537
	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;
	}

2538 2539
	if (priv->is_open)
		queue_work(priv->workqueue, &priv->restart);
Z
Zhu Yi 已提交
2540 2541 2542
	return;
}

2543
void iwl3945_set_decrypted_flag(struct iwl_priv *priv, struct sk_buff *skb,
Z
Zhu Yi 已提交
2544 2545 2546 2547 2548
			    u32 decrypt_res, struct ieee80211_rx_status *stats)
{
	u16 fc =
	    le16_to_cpu(((struct ieee80211_hdr *)skb->data)->frame_control);

2549
	if (priv->active39_rxon.filter_flags & RXON_FILTER_DIS_DECRYPT_MSK)
Z
Zhu Yi 已提交
2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574
		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;
	}
}

2575
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589

#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 已提交
2590
static u32 iwl3945_usecs_to_beacons(u32 usec, u32 beacon_interval)
Z
Zhu Yi 已提交
2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608
{
	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 已提交
2609
static __le32 iwl3945_add_beacon_time(u32 base, u32 addon, u32 beacon_interval)
Z
Zhu Yi 已提交
2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627
{
	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);
}

2628
static int iwl3945_get_measurement(struct iwl_priv *priv,
Z
Zhu Yi 已提交
2629 2630 2631
			       struct ieee80211_measurement_params *params,
			       u8 type)
{
2632
	struct iwl_spectrum_cmd spectrum;
2633
	struct iwl_rx_packet *res;
2634
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
2635 2636 2637 2638 2639 2640 2641 2642 2643
		.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 已提交
2644
	if (iwl3945_is_associated(priv))
Z
Zhu Yi 已提交
2645
		add_time =
C
Christoph Hellwig 已提交
2646
		    iwl3945_usecs_to_beacons(
Z
Zhu Yi 已提交
2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658
			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 已提交
2659
	if (iwl3945_is_associated(priv))
Z
Zhu Yi 已提交
2660
		spectrum.start_time =
C
Christoph Hellwig 已提交
2661
		    iwl3945_add_beacon_time(priv->last_beacon_time,
Z
Zhu Yi 已提交
2662 2663 2664 2665 2666 2667 2668 2669
				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;
2670
	if (priv->active39_rxon.flags & RXON_FLG_BAND_24G_MSK)
Z
Zhu Yi 已提交
2671 2672 2673
		spectrum.flags |= RXON_FLG_BAND_24G_MSK |
		    RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK;

C
Christoph Hellwig 已提交
2674
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
2675 2676 2677
	if (rc)
		return rc;

2678
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
2679
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
2680
		IWL_ERR(priv, "Bad return from REPLY_RX_ON_ASSOC command\n");
Z
Zhu Yi 已提交
2681 2682 2683 2684 2685 2686 2687
		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) {
2688 2689
			IWL_DEBUG_INFO("Replaced existing measurement: %d\n",
						res->u.spectrum.id);
Z
Zhu Yi 已提交
2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706
			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

2707
static void iwl3945_rx_reply_alive(struct iwl_priv *priv,
2708
			       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2709
{
2710 2711
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl_alive_resp *palive;
Z
Zhu Yi 已提交
2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722
	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");
2723 2724
		memcpy(&priv->card_alive_init, &pkt->u.alive_frame,
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
2725 2726 2727 2728
		pwork = &priv->init_alive_start;
	} else {
		IWL_DEBUG_INFO("Runtime Alive received.\n");
		memcpy(&priv->card_alive, &pkt->u.alive_frame,
2729
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
2730
		pwork = &priv->alive_start;
C
Christoph Hellwig 已提交
2731
		iwl3945_disable_events(priv);
Z
Zhu Yi 已提交
2732 2733 2734 2735 2736 2737 2738 2739
	}

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

2743
static void iwl3945_rx_reply_add_sta(struct iwl_priv *priv,
2744
				 struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2745
{
2746
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
2747 2748 2749 2750 2751

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

2752
static void iwl3945_rx_reply_error(struct iwl_priv *priv,
2753
			       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2754
{
2755
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
2756

2757
	IWL_ERR(priv, "Error Reply type 0x%08X cmd %s (0x%02X) "
Z
Zhu Yi 已提交
2758 2759 2760 2761 2762 2763 2764 2765 2766 2767
		"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

2768
static void iwl3945_rx_csa(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2769
{
2770
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2771
	struct iwl3945_rxon_cmd *rxon = (void *)&priv->active39_rxon;
2772
	struct iwl_csa_notification *csa = &(pkt->u.csa_notif);
Z
Zhu Yi 已提交
2773 2774 2775
	IWL_DEBUG_11H("CSA notif: channel %d, status %d\n",
		      le16_to_cpu(csa->channel), le32_to_cpu(csa->status));
	rxon->channel = csa->channel;
2776
	priv->staging39_rxon.channel = csa->channel;
Z
Zhu Yi 已提交
2777 2778
}

2779
static void iwl3945_rx_spectrum_measure_notif(struct iwl_priv *priv,
2780
					  struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2781
{
2782
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
2783
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2784
	struct iwl_spectrum_notification *report = &(pkt->u.spectrum_notif);
Z
Zhu Yi 已提交
2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796

	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
}

2797
static void iwl3945_rx_pm_sleep_notif(struct iwl_priv *priv,
2798
				  struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2799
{
2800
#ifdef CONFIG_IWL3945_DEBUG
2801
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2802
	struct iwl_sleep_notification *sleep = &(pkt->u.sleep_notif);
Z
Zhu Yi 已提交
2803 2804 2805 2806 2807
	IWL_DEBUG_RX("sleep mode: %d, src: %d\n",
		     sleep->pm_sleep_mode, sleep->pm_wakeup_src);
#endif
}

2808
static void iwl3945_rx_pm_debug_statistics_notif(struct iwl_priv *priv,
2809
					     struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2810
{
2811
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
2812 2813 2814
	IWL_DEBUG_RADIO("Dumping %d bytes of unhandled "
			"notification for %s:\n",
			le32_to_cpu(pkt->len), get_cmd_string(pkt->hdr.cmd));
2815 2816
	iwl_print_hex_dump(priv, IWL_DL_RADIO, pkt->u.raw,
			   le32_to_cpu(pkt->len));
Z
Zhu Yi 已提交
2817 2818
}

C
Christoph Hellwig 已提交
2819
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
2820
{
2821 2822
	struct iwl_priv *priv =
		container_of(work, struct iwl_priv, beacon_update);
Z
Zhu Yi 已提交
2823 2824 2825
	struct sk_buff *beacon;

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

	if (!beacon) {
2829
		IWL_ERR(priv, "update beacon failed\n");
Z
Zhu Yi 已提交
2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840
		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 已提交
2841
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
2842 2843
}

2844
static void iwl3945_rx_beacon_notif(struct iwl_priv *priv,
2845
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2846
{
2847
#ifdef CONFIG_IWL3945_DEBUG
2848
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
C
Christoph Hellwig 已提交
2849
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860
	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

2861
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
2862 2863 2864 2865 2866
	    (!test_bit(STATUS_EXIT_PENDING, &priv->status)))
		queue_work(priv->workqueue, &priv->beacon_update);
}

/* Service response to REPLY_SCAN_CMD (0x80) */
2867
static void iwl3945_rx_reply_scan(struct iwl_priv *priv,
2868
			      struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2869
{
2870
#ifdef CONFIG_IWL3945_DEBUG
2871
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2872 2873
	struct iwl_scanreq_notification *notif =
	    (struct iwl_scanreq_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
2874 2875 2876 2877 2878 2879

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

/* Service SCAN_START_NOTIFICATION (0x82) */
2880
static void iwl3945_rx_scan_start_notif(struct iwl_priv *priv,
2881
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2882
{
2883
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2884 2885
	struct iwl_scanstart_notification *notif =
	    (struct iwl_scanstart_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896
	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) */
2897
static void iwl3945_rx_scan_results_notif(struct iwl_priv *priv,
2898
				      struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2899
{
2900
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2901 2902
	struct iwl_scanresults_notification *notif =
	    (struct iwl_scanresults_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917

	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;
2918
	priv->next_scan_jiffies = 0;
Z
Zhu Yi 已提交
2919 2920 2921
}

/* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
2922
static void iwl3945_rx_scan_complete_notif(struct iwl_priv *priv,
2923
				       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2924
{
2925
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2926
	struct iwl_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
Z
Zhu Yi 已提交
2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939

	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",
2940 2941
		       (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) ?
							"2.4" : "5.2",
Z
Zhu Yi 已提交
2942 2943 2944
		       jiffies_to_msecs(elapsed_jiffies
					(priv->scan_pass_start, jiffies)));

2945 2946 2947 2948 2949 2950 2951
	/* 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 已提交
2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965

	/* 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;
2966
	priv->next_scan_jiffies = 0;
Z
Zhu Yi 已提交
2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984
	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 */
2985
static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
2986
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2987
{
2988
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
2989 2990 2991 2992 2993 2994 2995
	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");

2996
	iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009
		    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 已提交
3010
	iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021

	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 已提交
3022
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
3023 3024 3025 3026 3027 3028 3029
 *
 * 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.
 */
3030
static void iwl3945_setup_rx_handlers(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3031
{
C
Christoph Hellwig 已提交
3032 3033 3034 3035
	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 已提交
3036
	priv->rx_handlers[SPECTRUM_MEASURE_NOTIFICATION] =
C
Christoph Hellwig 已提交
3037 3038
	    iwl3945_rx_spectrum_measure_notif;
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl3945_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
3039
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
C
Christoph Hellwig 已提交
3040 3041
	    iwl3945_rx_pm_debug_statistics_notif;
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
3042

3043 3044 3045 3046
	/*
	 * 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 已提交
3047
	 */
C
Christoph Hellwig 已提交
3048 3049
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
3050

C
Christoph Hellwig 已提交
3051 3052
	priv->rx_handlers[REPLY_SCAN_CMD] = iwl3945_rx_reply_scan;
	priv->rx_handlers[SCAN_START_NOTIFICATION] = iwl3945_rx_scan_start_notif;
Z
Zhu Yi 已提交
3053
	priv->rx_handlers[SCAN_RESULTS_NOTIFICATION] =
C
Christoph Hellwig 已提交
3054
	    iwl3945_rx_scan_results_notif;
Z
Zhu Yi 已提交
3055
	priv->rx_handlers[SCAN_COMPLETE_NOTIFICATION] =
C
Christoph Hellwig 已提交
3056 3057
	    iwl3945_rx_scan_complete_notif;
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
3058

3059
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
3060
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
3061 3062
}

3063 3064 3065 3066 3067
/**
 * 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.
 */
3068
static void iwl3945_cmd_queue_reclaim(struct iwl_priv *priv,
3069 3070
				      int txq_id, int index)
{
3071
	struct iwl_tx_queue *txq = &priv->txq[txq_id];
3072
	struct iwl_queue *q = &txq->q;
3073 3074
	int nfreed = 0;

3075
	if ((index >= q->n_bd) || (iwl_queue_used(q, index) == 0)) {
3076
		IWL_ERR(priv, "Read index for DMA queue txq id (%d), index %d, "
3077 3078 3079 3080 3081 3082 3083 3084
			  "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) {
3085
			IWL_ERR(priv, "HCMD skipped: index (%d) %d %d\n", index,
3086 3087 3088 3089 3090 3091 3092 3093 3094
					q->write_ptr, q->read_ptr);
			queue_work(priv->workqueue, &priv->restart);
			break;
		}
		nfreed++;
	}
}


Z
Zhu Yi 已提交
3095
/**
C
Christoph Hellwig 已提交
3096
 * iwl3945_tx_cmd_complete - Pull unused buffers off the queue and reclaim them
Z
Zhu Yi 已提交
3097 3098 3099 3100 3101 3102
 * @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
 */
3103
static void iwl3945_tx_cmd_complete(struct iwl_priv *priv,
3104
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
3105
{
3106
	struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
3107 3108 3109
	u16 sequence = le16_to_cpu(pkt->hdr.sequence);
	int txq_id = SEQ_TO_QUEUE(sequence);
	int index = SEQ_TO_INDEX(sequence);
3110
	int huge =  !!(pkt->hdr.sequence & SEQ_HUGE_FRAME);
Z
Zhu Yi 已提交
3111
	int cmd_index;
3112
	struct iwl_cmd *cmd;
Z
Zhu Yi 已提交
3113 3114 3115

	BUG_ON(txq_id != IWL_CMD_QUEUE_NUM);

3116 3117
	cmd_index = get_cmd_index(&priv->txq[IWL_CMD_QUEUE_NUM].q, index, huge);
	cmd = priv->txq[IWL_CMD_QUEUE_NUM].cmd[cmd_index];
Z
Zhu Yi 已提交
3118 3119 3120 3121 3122 3123 3124 3125 3126

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

3127
	iwl3945_cmd_queue_reclaim(priv, txq_id, index);
Z
Zhu Yi 已提交
3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156

	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.
 *
3157
 * During initialization, the host sets up the READ queue position to the first
Z
Zhu Yi 已提交
3158 3159
 * INDEX position, and WRITE to the last (READ - 1 wrapped)
 *
3160
 * When the firmware places a packet in a buffer, it will advance the READ index
Z
Zhu Yi 已提交
3161 3162 3163 3164 3165 3166 3167
 * 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
3168
 *   to replenish the iwl->rxq->rx_free.
C
Christoph Hellwig 已提交
3169
 * + In iwl3945_rx_replenish (scheduled) if 'processed' != 'read' then the
Z
Zhu Yi 已提交
3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181
 *   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:
 *
3182
 * iwl3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
C
Christoph Hellwig 已提交
3183
 *                            iwl3945_rx_queue_restock
3184
 * iwl3945_rx_queue_restock() Moves available buffers from rx_free into Rx
Z
Zhu Yi 已提交
3185 3186
 *                            queue, updates firmware pointers, and updates
 *                            the WRITE index.  If insufficient rx_free buffers
C
Christoph Hellwig 已提交
3187
 *                            are available, schedules iwl3945_rx_replenish
Z
Zhu Yi 已提交
3188 3189
 *
 * -- enable interrupts --
3190
 * ISR - iwl3945_rx()         Detach iwl_rx_mem_buffers from pool up to the
Z
Zhu Yi 已提交
3191 3192
 *                            READ INDEX, detaching the SKB from the pool.
 *                            Moves the packet buffer from queue to rx_used.
C
Christoph Hellwig 已提交
3193
 *                            Calls iwl3945_rx_queue_restock to refill any empty
Z
Zhu Yi 已提交
3194 3195 3196 3197 3198 3199
 *                            slots.
 * ...
 *
 */

/**
3200
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
3201
 */
3202
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl_priv *priv,
Z
Zhu Yi 已提交
3203 3204 3205 3206 3207 3208
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

/**
C
Christoph Hellwig 已提交
3209
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
3210
 *
3211
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
3212
 * and we have free pre-allocated buffers, fill the ranks as much
3213
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
3214 3215 3216 3217 3218
 *
 * 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.
 */
3219
static int iwl3945_rx_queue_restock(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3220
{
3221
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3222
	struct list_head *element;
3223
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
3224 3225 3226 3227 3228
	unsigned long flags;
	int write, rc;

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
3229
	while ((iwl_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
3230
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
3231
		element = rxq->rx_free.next;
3232
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
Z
Zhu Yi 已提交
3233
		list_del(element);
3234 3235

		/* Point to Rx buffer via next RBD in circular buffer */
3236
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->real_dma_addr);
Z
Zhu Yi 已提交
3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247
		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);


3248 3249
	/* 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 已提交
3250 3251 3252 3253 3254
	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);
3255
		rc = iwl_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
3256 3257 3258 3259 3260 3261 3262 3263
		if (rc)
			return rc;
	}

	return 0;
}

/**
C
Christoph Hellwig 已提交
3264
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
3265 3266 3267
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
3268
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
3269
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
3270
 */
3271
static void iwl3945_rx_allocate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3272
{
3273
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3274
	struct list_head *element;
3275
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
3276 3277 3278 3279
	unsigned long flags;
	spin_lock_irqsave(&rxq->lock, flags);
	while (!list_empty(&rxq->rx_used)) {
		element = rxq->rx_used.next;
3280
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
3281 3282

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
3283
		rxb->skb =
3284 3285
		    alloc_skb(priv->hw_params.rx_buf_size,
				__GFP_NOWARN | GFP_ATOMIC);
Z
Zhu Yi 已提交
3286 3287
		if (!rxb->skb) {
			if (net_ratelimit())
T
Tomas Winkler 已提交
3288
				IWL_CRIT(priv, ": Can not allocate SKB buffers\n");
Z
Zhu Yi 已提交
3289 3290 3291 3292 3293
			/* 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 已提交
3294 3295 3296 3297 3298 3299 3300 3301 3302

		/* 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 已提交
3303 3304
		priv->alloc_rxb_skb++;
		list_del(element);
3305 3306

		/* Get physical address of RB/SKB */
3307 3308 3309 3310
		rxb->real_dma_addr = pci_map_single(priv->pci_dev,
						rxb->skb->data,
						priv->hw_params.rx_buf_size,
						PCI_DMA_FROMDEVICE);
Z
Zhu Yi 已提交
3311 3312 3313 3314
		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);
3315 3316 3317 3318 3319
}

/*
 * this should be called while priv->lock is locked
 */
3320
static void __iwl3945_rx_replenish(void *data)
3321
{
3322
	struct iwl_priv *priv = data;
3323 3324 3325 3326 3327 3328 3329 3330

	iwl3945_rx_allocate(priv);
	iwl3945_rx_queue_restock(priv);
}


void iwl3945_rx_replenish(void *data)
{
3331
	struct iwl_priv *priv = data;
3332 3333 3334
	unsigned long flags;

	iwl3945_rx_allocate(priv);
Z
Zhu Yi 已提交
3335 3336

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
3337
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358
	spin_unlock_irqrestore(&priv->lock, flags);
}

/* Convert linear signal-to-noise ratio into dB */
static u8 ratio2dB[100] = {
/*	 0   1   2   3   4   5   6   7   8   9 */
	 0,  0,  6, 10, 12, 14, 16, 17, 18, 19, /* 00 - 09 */
	20, 21, 22, 22, 23, 23, 24, 25, 26, 26, /* 10 - 19 */
	26, 26, 26, 27, 27, 28, 28, 28, 29, 29, /* 20 - 29 */
	29, 30, 30, 30, 31, 31, 31, 31, 32, 32, /* 30 - 39 */
	32, 32, 32, 33, 33, 33, 33, 33, 34, 34, /* 40 - 49 */
	34, 34, 34, 34, 35, 35, 35, 35, 35, 35, /* 50 - 59 */
	36, 36, 36, 36, 36, 36, 36, 37, 37, 37, /* 60 - 69 */
	37, 37, 37, 37, 37, 38, 38, 38, 38, 38, /* 70 - 79 */
	38, 38, 38, 38, 38, 39, 39, 39, 39, 39, /* 80 - 89 */
	39, 39, 39, 39, 39, 40, 40, 40, 40, 40  /* 90 - 99 */
};

/* Calculates a relative dB value from a ratio of linear
 *   (i.e. not dB) signal levels.
 * Conversion assumes that levels are voltages (20*log), not powers (10*log). */
C
Christoph Hellwig 已提交
3359
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
3360
{
3361 3362
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
3363 3364
		return 60;

3365
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
3366
	 *   add 20 dB to make up for divide by 10 */
3367
	if (sig_ratio >= 100)
3368
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384

	/* 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 已提交
3385
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419
{
	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;
}

/**
3420
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
3421 3422 3423 3424 3425
 *
 * Uses the priv->rx_handlers callback function array to invoke
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
3426
static void iwl3945_rx_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3427
{
3428
	struct iwl_rx_mem_buffer *rxb;
3429
	struct iwl_rx_packet *pkt;
3430
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3431 3432 3433
	u32 r, i;
	int reclaim;
	unsigned long flags;
3434
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
3435
	u32 count = 8;
Z
Zhu Yi 已提交
3436

3437 3438
	/* uCode's read index (stored in shared DRAM) indicates the last Rx
	 * buffer that the driver may process (last buffer filled by ucode). */
W
Winkler, Tomas 已提交
3439
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
3440 3441
	i = rxq->read;

3442
	if (iwl_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
3443
		fill_rx = 1;
Z
Zhu Yi 已提交
3444 3445 3446 3447 3448 3449 3450
	/* 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];

3451
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
3452 3453 3454 3455 3456 3457
		 * then a bug has been introduced in the queue refilling
		 * routines -- catch it here */
		BUG_ON(rxb == NULL);

		rxq->queue[i] = NULL;

3458
		pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->real_dma_addr,
3459
					    priv->hw_params.rx_buf_size,
Z
Zhu Yi 已提交
3460
					    PCI_DMA_FROMDEVICE);
3461
		pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474

		/* 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 已提交
3475
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
3476
		if (priv->rx_handlers[pkt->hdr.cmd]) {
3477
			IWL_DEBUG(IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
3478 3479 3480 3481 3482
				"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 */
3483
			IWL_DEBUG(IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
3484 3485 3486 3487 3488 3489
				"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) {
3490 3491
			/* Invoke any callbacks, transfer the skb to caller, and
			 * fire off the (possibly) blocking iwl3945_send_cmd()
Z
Zhu Yi 已提交
3492 3493
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
C
Christoph Hellwig 已提交
3494
				iwl3945_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
3495
			else
3496
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507
		}

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

3508
		pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
3509 3510
				priv->hw_params.rx_buf_size,
				PCI_DMA_FROMDEVICE);
Z
Zhu Yi 已提交
3511 3512 3513 3514
		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;
3515 3516 3517 3518 3519 3520 3521 3522 3523 3524
		/* 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 已提交
3525 3526 3527 3528
	}

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

3532 3533 3534
/**
 * iwl3945_tx_queue_update_write_ptr - Send new write index to hardware
 */
3535
static int iwl3945_tx_queue_update_write_ptr(struct iwl_priv *priv,
3536
				  struct iwl_tx_queue *txq)
Z
Zhu Yi 已提交
3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549
{
	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. */
3550
		reg = iwl_read32(priv, CSR_UCODE_DRV_GP1);
Z
Zhu Yi 已提交
3551 3552 3553

		if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
			IWL_DEBUG_INFO("Requesting wakeup, GP1 = 0x%x\n", reg);
3554
			iwl_set_bit(priv, CSR_GP_CNTRL,
Z
Zhu Yi 已提交
3555 3556 3557 3558 3559
				    CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
			return rc;
		}

		/* restore this queue's parameters in nic hardware. */
3560
		rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
3561 3562
		if (rc)
			return rc;
3563
		iwl_write_direct32(priv, HBUS_TARG_WRPTR,
3564
				     txq->q.write_ptr | (txq_id << 8));
3565
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3566 3567 3568 3569

	/* 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
3570
		iwl_write32(priv, HBUS_TARG_WRPTR,
3571
			    txq->q.write_ptr | (txq_id << 8));
Z
Zhu Yi 已提交
3572 3573 3574 3575 3576 3577

	txq->need_update = 0;

	return rc;
}

3578
#ifdef CONFIG_IWL3945_DEBUG
3579
static void iwl3945_print_rx_config_cmd(struct iwl_priv *priv,
3580
					struct iwl3945_rxon_cmd *rxon)
Z
Zhu Yi 已提交
3581 3582
{
	IWL_DEBUG_RADIO("RX CONFIG:\n");
3583
	iwl_print_hex_dump(priv, IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
Z
Zhu Yi 已提交
3584 3585 3586 3587 3588 3589 3590 3591
	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 已提交
3592 3593
	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 已提交
3594 3595 3596 3597
	IWL_DEBUG_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
}
#endif

3598
static void iwl3945_enable_interrupts(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3599 3600 3601
{
	IWL_DEBUG_ISR("Enabling interrupts\n");
	set_bit(STATUS_INT_ENABLED, &priv->status);
3602
	iwl_write32(priv, CSR_INT_MASK, CSR_INI_SET_MASK);
Z
Zhu Yi 已提交
3603 3604
}

3605 3606

/* call this function to flush any scheduled tasklet */
3607
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
3608
{
T
Tomas Winkler 已提交
3609
	/* wait to make sure we flush pending tasklet*/
3610 3611 3612 3613 3614
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}


3615
static inline void iwl3945_disable_interrupts(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3616 3617 3618 3619
{
	clear_bit(STATUS_INT_ENABLED, &priv->status);

	/* disable interrupts from uCode/NIC to host */
3620
	iwl_write32(priv, CSR_INT_MASK, 0x00000000);
Z
Zhu Yi 已提交
3621 3622 3623

	/* acknowledge/clear/reset any interrupts still pending
	 * from uCode or flow handler (Rx/Tx DMA) */
3624 3625
	iwl_write32(priv, CSR_INT, 0xffffffff);
	iwl_write32(priv, CSR_FH_INT_STATUS, 0xffffffff);
Z
Zhu Yi 已提交
3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651
	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))

3652
static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3653 3654 3655 3656 3657 3658 3659 3660
{
	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 已提交
3661
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
3662
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
3663 3664 3665
		return;
	}

3666
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
3667
	if (rc) {
3668
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
3669 3670 3671
		return;
	}

3672
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
3673 3674

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

3680
	IWL_ERR(priv, "Desc       Time       asrtPC  blink2 "
Z
Zhu Yi 已提交
3681 3682 3683 3684
		  "ilink1  nmiPC   Line\n");
	for (i = ERROR_START_OFFSET;
	     i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
	     i += ERROR_ELEM_SIZE) {
3685
		desc = iwl_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
3686
		time =
3687
		    iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
3688
		blink1 =
3689
		    iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
3690
		blink2 =
3691
		    iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
3692
		ilink1 =
3693
		    iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
3694
		ilink2 =
3695
		    iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
3696
		data1 =
3697
		    iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
3698

3699 3700 3701 3702
		IWL_ERR(priv,
			"%-13s (#%d) %010u 0x%05X 0x%05X 0x%05X 0x%05X %u\n\n",
			desc_lookup(desc), desc, time, blink1, blink2,
			ilink1, ilink2, data1);
Z
Zhu Yi 已提交
3703 3704
	}

3705
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3706 3707 3708

}

3709
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
3710 3711

/**
C
Christoph Hellwig 已提交
3712
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
3713
 *
3714
 * NOTE: Must be called with iwl_grab_nic_access() already obtained!
Z
Zhu Yi 已提交
3715
 */
3716
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739
				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++) {
3740
		ev = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
3741
		ptr += sizeof(u32);
3742
		time = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
3743
		ptr += sizeof(u32);
3744 3745 3746 3747
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
		} else {
3748
			data = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
3749
			ptr += sizeof(u32);
3750
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
Z
Zhu Yi 已提交
3751 3752 3753 3754
		}
	}
}

3755
static void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3756 3757 3758 3759 3760 3761 3762 3763 3764 3765
{
	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 已提交
3766
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
3767
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
3768 3769 3770
		return;
	}

3771
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
3772
	if (rc) {
3773
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
3774 3775 3776 3777
		return;
	}

	/* event log header */
3778 3779 3780 3781
	capacity = iwl_read_targ_mem(priv, base);
	mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32)));
	num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32)));
	next_entry = iwl_read_targ_mem(priv, base + (3 * sizeof(u32)));
Z
Zhu Yi 已提交
3782 3783 3784 3785 3786

	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
3787
		IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
3788
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3789 3790 3791
		return;
	}

3792
	IWL_ERR(priv, "Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
3793 3794 3795 3796 3797
		  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 已提交
3798
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
3799 3800 3801
				    capacity - next_entry, mode);

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

3804
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3805 3806 3807
}

/**
C
Christoph Hellwig 已提交
3808
 * iwl3945_irq_handle_error - called for HW or SW error interrupt from card
Z
Zhu Yi 已提交
3809
 */
3810
static void iwl3945_irq_handle_error(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3811
{
C
Christoph Hellwig 已提交
3812
	/* Set the FW error flag -- cleared on iwl3945_down */
Z
Zhu Yi 已提交
3813 3814 3815 3816 3817
	set_bit(STATUS_FW_ERROR, &priv->status);

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

3818
#ifdef CONFIG_IWL3945_DEBUG
3819
	if (priv->debug_level & IWL_DL_FW_ERRORS) {
C
Christoph Hellwig 已提交
3820 3821
		iwl3945_dump_nic_error_log(priv);
		iwl3945_dump_nic_event_log(priv);
3822
		iwl3945_print_rx_config_cmd(priv, &priv->staging39_rxon);
Z
Zhu Yi 已提交
3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835
	}
#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 已提交
3836
		if (iwl3945_is_associated(priv)) {
3837 3838
			memcpy(&priv->recovery39_rxon, &priv->active39_rxon,
			       sizeof(priv->recovery39_rxon));
Z
Zhu Yi 已提交
3839 3840 3841 3842 3843 3844
			priv->error_recovering = 1;
		}
		queue_work(priv->workqueue, &priv->restart);
	}
}

3845
static void iwl3945_error_recovery(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3846 3847 3848
{
	unsigned long flags;

3849 3850 3851
	memcpy(&priv->staging39_rxon, &priv->recovery39_rxon,
	       sizeof(priv->staging39_rxon));
	priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
3852
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3853

C
Christoph Hellwig 已提交
3854
	iwl3945_add_station(priv, priv->bssid, 1, 0);
Z
Zhu Yi 已提交
3855 3856

	spin_lock_irqsave(&priv->lock, flags);
3857
	priv->assoc_id = le16_to_cpu(priv->staging39_rxon.assoc_id);
Z
Zhu Yi 已提交
3858 3859 3860 3861
	priv->error_recovering = 0;
	spin_unlock_irqrestore(&priv->lock, flags);
}

3862
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3863 3864 3865 3866
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
3867
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
3868 3869 3870 3871 3872 3873 3874 3875
	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. */
3876 3877
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
3878 3879 3880 3881

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

3885
#ifdef CONFIG_IWL3945_DEBUG
3886
	if (priv->debug_level & IWL_DL_ISR) {
3887
		/* just for debug */
3888
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
Z
Zhu Yi 已提交
3889 3890 3891 3892 3893 3894 3895 3896 3897
		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 已提交
3898
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
3899
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
3900
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
3901 3902 3903 3904
		inta |= CSR_INT_BIT_FH_TX;

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

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

C
Christoph Hellwig 已提交
3910
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
3911 3912 3913 3914 3915 3916 3917 3918

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

3919
#ifdef CONFIG_IWL3945_DEBUG
3920
	if (priv->debug_level & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
3921
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
3922 3923 3924
		if (inta & CSR_INT_BIT_SCD)
			IWL_DEBUG_ISR("Scheduler finished to transmit "
				      "the frame/frames.\n");
Z
Zhu Yi 已提交
3925 3926 3927 3928 3929 3930 3931

		/* 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 */
3932
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
3933 3934 3935

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
3936 3937
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
C
Christoph Hellwig 已提交
3938
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
3939 3940 3941 3942 3943 3944
		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");
3945
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
3946 3947 3948 3949 3950 3951
		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 已提交
3952 3953 3954 3955 3956 3957 3958 3959

		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 已提交
3960
		iwl3945_rx_handle(priv);
Z
Zhu Yi 已提交
3961 3962 3963 3964 3965 3966
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

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

3967 3968 3969
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
		if (!iwl_grab_nic_access(priv)) {
			iwl_write_direct32(priv, FH39_TCSR_CREDIT
3970
					     (FH39_SRVC_CHNL), 0x0);
3971
			iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3972 3973 3974 3975 3976
		}
		handled |= CSR_INT_BIT_FH_TX;
	}

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

	if (inta & ~CSR_INI_SET_MASK) {
3980
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
Z
Zhu Yi 已提交
3981
			 inta & ~CSR_INI_SET_MASK);
3982
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
3983 3984 3985
	}

	/* Re-enable all interrupts */
3986 3987 3988
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
		iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
3989

3990
#ifdef CONFIG_IWL3945_DEBUG
3991
	if (priv->debug_level & (IWL_DL_ISR)) {
3992 3993 3994
		inta = iwl_read32(priv, CSR_INT);
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
Z
Zhu Yi 已提交
3995 3996 3997 3998 3999 4000 4001
		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 已提交
4002
static irqreturn_t iwl3945_isr(int irq, void *data)
Z
Zhu Yi 已提交
4003
{
4004
	struct iwl_priv *priv = data;
Z
Zhu Yi 已提交
4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015
	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. */
4016 4017
	inta_mask = iwl_read32(priv, CSR_INT_MASK);  /* just for debug */
	iwl_write32(priv, CSR_INT_MASK, 0x00000000);
Z
Zhu Yi 已提交
4018 4019

	/* Discover which interrupts are active/pending */
4020 4021
	inta = iwl_read32(priv, CSR_INT);
	inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
Z
Zhu Yi 已提交
4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032

	/* 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 */
4033
		IWL_WARN(priv, "HARDWARE GONE?? INTA == 0x%08x\n", inta);
4034
		goto unplugged;
Z
Zhu Yi 已提交
4035 4036 4037 4038 4039
	}

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

4040 4041
	inta &= ~CSR_INT_BIT_SCD;

C
Christoph Hellwig 已提交
4042
	/* iwl3945_irq_tasklet() will service interrupts and re-enable them */
4043 4044
	if (likely(inta || inta_fh))
		tasklet_schedule(&priv->irq_tasklet);
4045
unplugged:
Z
Zhu Yi 已提交
4046 4047 4048 4049 4050 4051
	spin_unlock(&priv->lock);

	return IRQ_HANDLED;

 none:
	/* re-enable interrupts here since we don't have anything to service. */
4052 4053 4054
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
		iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
4055 4056 4057 4058 4059 4060
	spin_unlock(&priv->lock);
	return IRQ_NONE;
}

/************************** EEPROM BANDS ****************************
 *
C
Christoph Hellwig 已提交
4061
 * The iwl3945_eeprom_band definitions below provide the mapping from the
Z
Zhu Yi 已提交
4062 4063 4064
 * EEPROM contents to the specific channel number supported for each
 * band.
 *
4065
 * For example, iwl3945_priv->eeprom39.band_3_channels[4] from the band_3
Z
Zhu Yi 已提交
4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090
 * 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 已提交
4091
static const u8 iwl3945_eeprom_band_1[14] = {
Z
Zhu Yi 已提交
4092 4093 4094 4095
	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
};

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

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

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

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

4112
static void iwl3945_init_band_reference(const struct iwl_priv *priv, int band,
Z
Zhu Yi 已提交
4113
				    int *eeprom_ch_count,
4114
				    const struct iwl_eeprom_channel
Z
Zhu Yi 已提交
4115 4116 4117 4118 4119
				    **eeprom_ch_info,
				    const u8 **eeprom_ch_index)
{
	switch (band) {
	case 1:		/* 2.4GHz band */
C
Christoph Hellwig 已提交
4120
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_1);
4121
		*eeprom_ch_info = priv->eeprom39.band_1_channels;
C
Christoph Hellwig 已提交
4122
		*eeprom_ch_index = iwl3945_eeprom_band_1;
Z
Zhu Yi 已提交
4123
		break;
4124
	case 2:		/* 4.9GHz band */
C
Christoph Hellwig 已提交
4125
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_2);
4126
		*eeprom_ch_info = priv->eeprom39.band_2_channels;
C
Christoph Hellwig 已提交
4127
		*eeprom_ch_index = iwl3945_eeprom_band_2;
Z
Zhu Yi 已提交
4128 4129
		break;
	case 3:		/* 5.2GHz band */
C
Christoph Hellwig 已提交
4130
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_3);
4131
		*eeprom_ch_info = priv->eeprom39.band_3_channels;
C
Christoph Hellwig 已提交
4132
		*eeprom_ch_index = iwl3945_eeprom_band_3;
Z
Zhu Yi 已提交
4133
		break;
4134
	case 4:		/* 5.5GHz band */
C
Christoph Hellwig 已提交
4135
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_4);
4136
		*eeprom_ch_info = priv->eeprom39.band_4_channels;
C
Christoph Hellwig 已提交
4137
		*eeprom_ch_index = iwl3945_eeprom_band_4;
Z
Zhu Yi 已提交
4138
		break;
4139
	case 5:		/* 5.7GHz band */
C
Christoph Hellwig 已提交
4140
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_5);
4141
		*eeprom_ch_info = priv->eeprom39.band_5_channels;
C
Christoph Hellwig 已提交
4142
		*eeprom_ch_index = iwl3945_eeprom_band_5;
Z
Zhu Yi 已提交
4143 4144 4145 4146 4147 4148 4149
		break;
	default:
		BUG();
		return;
	}
}

4150 4151 4152 4153 4154
/**
 * iwl3945_get_channel_info - Find driver's private channel info
 *
 * Based on band and channel number.
 */
4155
const struct iwl_channel_info *
4156
iwl3945_get_channel_info(const struct iwl_priv *priv,
4157
			 enum ieee80211_band band, u16 channel)
Z
Zhu Yi 已提交
4158 4159 4160
{
	int i;

4161 4162
	switch (band) {
	case IEEE80211_BAND_5GHZ:
Z
Zhu Yi 已提交
4163 4164 4165 4166 4167 4168
		for (i = 14; i < priv->channel_count; i++) {
			if (priv->channel_info[i].channel == channel)
				return &priv->channel_info[i];
		}
		break;

4169
	case IEEE80211_BAND_2GHZ:
Z
Zhu Yi 已提交
4170 4171 4172
		if (channel >= 1 && channel <= 14)
			return &priv->channel_info[channel - 1];
		break;
4173 4174
	case IEEE80211_NUM_BANDS:
		WARN_ON(1);
Z
Zhu Yi 已提交
4175 4176 4177 4178 4179 4180 4181 4182
	}

	return NULL;
}

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

4183 4184 4185
/**
 * iwl3945_init_channel_map - Set up driver's info for all possible channels
 */
4186
static int iwl3945_init_channel_map(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4187 4188 4189
{
	int eeprom_ch_count = 0;
	const u8 *eeprom_ch_index = NULL;
4190
	const struct iwl_eeprom_channel *eeprom_ch_info = NULL;
Z
Zhu Yi 已提交
4191
	int band, ch;
4192
	struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
4193 4194 4195 4196 4197 4198

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

4199
	if (priv->eeprom39.version < 0x2f) {
4200
		IWL_WARN(priv, "Unsupported EEPROM version: 0x%04X\n",
4201
			    priv->eeprom39.version);
Z
Zhu Yi 已提交
4202 4203 4204 4205 4206 4207
		return -EINVAL;
	}

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

	priv->channel_count =
C
Christoph Hellwig 已提交
4208 4209 4210 4211 4212
	    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 已提交
4213 4214 4215

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

4216
	priv->channel_info = kzalloc(sizeof(struct iwl_channel_info) *
Z
Zhu Yi 已提交
4217 4218
				     priv->channel_count, GFP_KERNEL);
	if (!priv->channel_info) {
4219
		IWL_ERR(priv, "Could not allocate channel_info\n");
Z
Zhu Yi 已提交
4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230
		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 已提交
4231
		iwl3945_init_band_reference(priv, band, &eeprom_ch_count,
Z
Zhu Yi 已提交
4232 4233 4234 4235 4236
					&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];
4237 4238
			ch_info->band = (band == 1) ? IEEE80211_BAND_2GHZ :
			    IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264

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

4265
			IWL_DEBUG_INFO("Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x"
Z
Zhu Yi 已提交
4266 4267 4268 4269
				       " %ddBm): Ad-Hoc %ssupported\n",
				       ch_info->channel,
				       is_channel_a_band(ch_info) ?
				       "5.2" : "2.4",
4270
				       CHECK_AND_PRINT(VALID),
Z
Zhu Yi 已提交
4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294
				       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++;
		}
	}

4295
	/* Set up txpower settings in driver for all channels */
Z
Zhu Yi 已提交
4296 4297 4298 4299 4300 4301
	if (iwl3945_txpower_set_from_eeprom(priv))
		return -EIO;

	return 0;
}

4302 4303 4304
/*
 * iwl3945_free_channel_map - undo allocations in iwl3945_init_channel_map
 */
4305
static void iwl3945_free_channel_map(struct iwl_priv *priv)
4306 4307 4308 4309 4310
{
	kfree(priv->channel_info);
	priv->channel_count = 0;
}

Z
Zhu Yi 已提交
4311 4312 4313
/* 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.  */
4314 4315 4316 4317 4318
#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 已提交
4319 4320 4321 4322 4323 4324 4325 4326

/* 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 */
4327
#define IWL_ACTIVE_QUIET_TIME       __constant_cpu_to_le16(10)	/* msec */
Z
Zhu Yi 已提交
4328 4329 4330 4331 4332 4333 4334 4335 4336

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

4339
static inline u16 iwl3945_get_active_dwell_time(struct iwl_priv *priv,
4340 4341
						enum ieee80211_band band,
						u8 n_probes)
Z
Zhu Yi 已提交
4342
{
4343
	if (band == IEEE80211_BAND_5GHZ)
4344 4345
		return IWL_ACTIVE_DWELL_TIME_52 +
			IWL_ACTIVE_DWELL_FACTOR_52GHZ * (n_probes + 1);
Z
Zhu Yi 已提交
4346
	else
4347 4348
		return IWL_ACTIVE_DWELL_TIME_24 +
			IWL_ACTIVE_DWELL_FACTOR_24GHZ * (n_probes + 1);
Z
Zhu Yi 已提交
4349 4350
}

4351
static u16 iwl3945_get_passive_dwell_time(struct iwl_priv *priv,
4352
					  enum ieee80211_band band)
Z
Zhu Yi 已提交
4353
{
4354
	u16 passive = (band == IEEE80211_BAND_2GHZ) ?
Z
Zhu Yi 已提交
4355 4356 4357
	    IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_24 :
	    IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_52;

C
Christoph Hellwig 已提交
4358
	if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370
		/* 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;
}

4371
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
4372
					 enum ieee80211_band band,
4373
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
4374
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
4375 4376
{
	const struct ieee80211_channel *channels = NULL;
4377
	const struct ieee80211_supported_band *sband;
4378
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
4379 4380 4381 4382
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
4383
	sband = iwl_get_hw_mode(priv, band);
4384
	if (!sband)
Z
Zhu Yi 已提交
4385 4386
		return 0;

4387
	channels = sband->channels;
Z
Zhu Yi 已提交
4388

4389
	active_dwell = iwl3945_get_active_dwell_time(priv, band, n_probes);
4390
	passive_dwell = iwl3945_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
4391

4392 4393 4394
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

4395
	for (i = 0, added = 0; i < sband->n_channels; i++) {
4396 4397 4398
		if (channels[i].flags & IEEE80211_CHAN_DISABLED)
			continue;

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

4401
		ch_info = iwl3945_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
4402
		if (!is_channel_valid(ch_info)) {
4403
			IWL_DEBUG_SCAN("Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
4404 4405 4406 4407
				       scan_ch->channel);
			continue;
		}

4408 4409 4410 4411 4412
		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 已提交
4413
		if (!is_active || is_channel_passive(ch_info) ||
4414
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
4415
			scan_ch->type = 0;	/* passive */
4416 4417 4418
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
4419
			scan_ch->type = 1;	/* active */
4420
		}
Z
Zhu Yi 已提交
4421

4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434
		/* 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 已提交
4435

4436
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
4437 4438 4439 4440
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
4441
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
4442 4443 4444 4445
			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
4446
			 * power level:
4447
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464
			 */
		}

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

4465
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
4466 4467 4468 4469 4470
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
4471 4472 4473 4474
		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;
4475
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
4476
			/*
4477
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
4478
			 */
C
Christoph Hellwig 已提交
4479
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
4480
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
4481 4482 4483 4484 4485
		}
	}
}

/**
C
Christoph Hellwig 已提交
4486
 * iwl3945_init_geos - Initialize mac80211's geo/channel info based from eeprom
Z
Zhu Yi 已提交
4487
 */
4488
static int iwl3945_init_geos(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4489
{
4490
	struct iwl_channel_info *ch;
4491
	struct ieee80211_supported_band *sband;
Z
Zhu Yi 已提交
4492 4493 4494 4495 4496
	struct ieee80211_channel *channels;
	struct ieee80211_channel *geo_ch;
	struct ieee80211_rate *rates;
	int i = 0;

4497 4498
	if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
	    priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
Z
Zhu Yi 已提交
4499 4500 4501 4502 4503 4504 4505
		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);
4506
	if (!channels)
Z
Zhu Yi 已提交
4507 4508
		return -ENOMEM;

4509
	rates = kzalloc((sizeof(struct ieee80211_rate) * (IWL_RATE_COUNT + 1)),
Z
Zhu Yi 已提交
4510 4511 4512 4513 4514 4515 4516
			GFP_KERNEL);
	if (!rates) {
		kfree(channels);
		return -ENOMEM;
	}

	/* 5.2GHz channels start after the 2.4GHz channels */
4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527
	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 已提交
4528 4529 4530 4531

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

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

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

4537 4538
		/* FIXME: might be removed if scan is OK*/
		if (!is_channel_valid(ch))
Z
Zhu Yi 已提交
4539 4540 4541
			continue;

		if (is_channel_a_band(ch))
4542
			sband =  &priv->bands[IEEE80211_BAND_5GHZ];
4543
		else
4544
			sband =  &priv->bands[IEEE80211_BAND_2GHZ];
Z
Zhu Yi 已提交
4545

4546 4547 4548
		geo_ch = &sband->channels[sband->n_channels++];

		geo_ch->center_freq = ieee80211_channel_to_frequency(ch->channel);
4549 4550
		geo_ch->max_power = ch->max_power_avg;
		geo_ch->max_antenna_gain = 0xff;
4551
		geo_ch->hw_value = ch->channel;
Z
Zhu Yi 已提交
4552 4553

		if (is_channel_valid(ch)) {
4554 4555
			if (!(ch->flags & EEPROM_CHANNEL_IBSS))
				geo_ch->flags |= IEEE80211_CHAN_NO_IBSS;
Z
Zhu Yi 已提交
4556

4557 4558
			if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
				geo_ch->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
Z
Zhu Yi 已提交
4559 4560

			if (ch->flags & EEPROM_CHANNEL_RADAR)
4561
				geo_ch->flags |= IEEE80211_CHAN_RADAR;
Z
Zhu Yi 已提交
4562 4563 4564 4565

			if (ch->max_power_avg > priv->max_channel_txpower_limit)
				priv->max_channel_txpower_limit =
				    ch->max_power_avg;
4566
		} else {
4567
			geo_ch->flags |= IEEE80211_CHAN_DISABLED;
4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578
		}

		/* 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 已提交
4579 4580
	}

T
Tomas Winkler 已提交
4581 4582
	if ((priv->bands[IEEE80211_BAND_5GHZ].n_channels == 0) &&
	     priv->cfg->sku & IWL_SKU_A) {
T
Tomas Winkler 已提交
4583 4584 4585
		IWL_INFO(priv, "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 已提交
4586
		 priv->cfg->sku &= ~IWL_SKU_A;
Z
Zhu Yi 已提交
4587 4588
	}

T
Tomas Winkler 已提交
4589
	IWL_INFO(priv, "Tunable channels: %d 802.11bg, %d 802.11a channels\n",
4590 4591
	       priv->bands[IEEE80211_BAND_2GHZ].n_channels,
	       priv->bands[IEEE80211_BAND_5GHZ].n_channels);
Z
Zhu Yi 已提交
4592

4593 4594 4595 4596 4597 4598
	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 已提交
4599 4600 4601 4602 4603 4604

	set_bit(STATUS_GEO_CONFIGURED, &priv->status);

	return 0;
}

4605 4606 4607
/*
 * iwl3945_free_geos - undo allocations in iwl3945_init_geos
 */
4608
static void iwl3945_free_geos(struct iwl_priv *priv)
4609 4610 4611 4612 4613 4614
{
	kfree(priv->ieee_channels);
	kfree(priv->ieee_rates);
	clear_bit(STATUS_GEO_CONFIGURED, &priv->status);
}

Z
Zhu Yi 已提交
4615 4616 4617 4618 4619 4620
/******************************************************************************
 *
 * uCode download functions
 *
 ******************************************************************************/

4621
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4622
{
4623 4624 4625 4626 4627 4628
	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 已提交
4629 4630 4631
}

/**
C
Christoph Hellwig 已提交
4632
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
4633 4634
 *     looking at all data.
 */
4635
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
4636 4637 4638 4639 4640 4641 4642 4643
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

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

4644
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
4645 4646 4647
	if (rc)
		return rc;

4648
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
4649
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
4650 4651 4652 4653 4654 4655

	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 */
4656
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
4657
		if (val != le32_to_cpu(*image)) {
4658
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
4659 4660 4661 4662 4663 4664 4665 4666 4667
				  "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;
		}
	}

4668
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
4669 4670

	if (!errcnt)
4671
		IWL_DEBUG_INFO("ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
4672 4673 4674 4675 4676 4677

	return rc;
}


/**
C
Christoph Hellwig 已提交
4678
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
4679 4680 4681
 *   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.
 */
4682
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
4683 4684 4685 4686 4687 4688 4689 4690
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

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

4691
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
4692 4693 4694 4695 4696 4697 4698
	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 */
4699
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
4700
			i + IWL39_RTC_INST_LOWER_BOUND);
4701
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
4702 4703
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
4704
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
4705 4706 4707 4708 4709 4710 4711 4712 4713 4714
				  "offset 0x%x, is 0x%x, s/b 0x%x\n",
				  i, val, *image);
#endif
			rc = -EIO;
			errcnt++;
			if (errcnt >= 3)
				break;
		}
	}

4715
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
4716 4717 4718 4719 4720 4721

	return rc;
}


/**
C
Christoph Hellwig 已提交
4722
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
4723 4724
 *    and verify its contents
 */
4725
static int iwl3945_verify_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4726 4727 4728 4729 4730 4731 4732 4733
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
4734
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
4735 4736 4737 4738 4739 4740 4741 4742
	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 已提交
4743
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
4744 4745 4746 4747 4748 4749 4750 4751
	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 已提交
4752
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
4753 4754 4755 4756 4757
	if (rc == 0) {
		IWL_DEBUG_INFO("Runtime uCode is good in inst SRAM\n");
		return 0;
	}

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

4760 4761 4762
	/* 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 已提交
4763 4764
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
4765
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
4766 4767 4768 4769

	return rc;
}

4770
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4771 4772
{
	/* Remove all resets to allow NIC to operate */
4773
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
4774 4775 4776
}

/**
C
Christoph Hellwig 已提交
4777
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
4778 4779 4780
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
4781
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4782
{
4783
	struct iwl_ucode *ucode;
4784
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
4785 4786
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
4787 4788 4789 4790
	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 已提交
4791 4792
	u8 *src;
	size_t len;
4793
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
4794 4795 4796

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
4797 4798 4799 4800
	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) {
4801
			IWL_ERR(priv, "%s firmware file req failed: %d\n",
4802 4803 4804 4805 4806 4807 4808
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
4809 4810 4811
				IWL_ERR(priv, "Loaded firmware %s, "
					"which is deprecated. "
					" Please use API v%u instead.\n",
4812 4813 4814 4815 4816
					  buf, api_max);
			IWL_DEBUG_INFO("Got firmware '%s' file (%zd bytes) from disk\n",
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
4817 4818
	}

4819 4820
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
4821 4822 4823

	/* Make sure that we got at least our header! */
	if (ucode_raw->size < sizeof(*ucode)) {
4824
		IWL_ERR(priv, "File size way too small!\n");
4825
		ret = -EINVAL;
Z
Zhu Yi 已提交
4826 4827 4828 4829 4830 4831
		goto err_release;
	}

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

4832
	priv->ucode_ver = le32_to_cpu(ucode->ver);
4833
	api_ver = IWL_UCODE_API(priv->ucode_ver);
Z
Zhu Yi 已提交
4834 4835 4836 4837 4838 4839
	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);

4840 4841 4842 4843 4844
	/* 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) {
4845
		IWL_ERR(priv, "Driver unable to support your firmware API. "
4846 4847 4848 4849 4850 4851 4852
			  "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)
4853
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
4854 4855 4856 4857
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
4858 4859 4860 4861 4862 4863
	IWL_INFO(priv, "loaded firmware version %u.%u.%u.%u\n",
		IWL_UCODE_MAJOR(priv->ucode_ver),
		IWL_UCODE_MINOR(priv->ucode_ver),
		IWL_UCODE_API(priv->ucode_ver),
		IWL_UCODE_SERIAL(priv->ucode_ver));

4864 4865
	IWL_DEBUG_INFO("f/w package hdr ucode version raw = 0x%x\n",
		       priv->ucode_ver);
4866 4867 4868 4869 4870
	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 已提交
4871

4872

Z
Zhu Yi 已提交
4873 4874 4875 4876 4877 4878 4879
	/* 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);
4880
		ret = -EINVAL;
Z
Zhu Yi 已提交
4881 4882 4883 4884
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
4885
	if (inst_size > IWL39_MAX_INST_SIZE) {
4886 4887 4888
		IWL_DEBUG_INFO("uCode instr len %d too large to fit in\n",
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4889 4890 4891
		goto err_release;
	}

4892
	if (data_size > IWL39_MAX_DATA_SIZE) {
4893 4894 4895
		IWL_DEBUG_INFO("uCode data len %d too large to fit in\n",
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4896 4897
		goto err_release;
	}
4898
	if (init_size > IWL39_MAX_INST_SIZE) {
4899 4900 4901
		IWL_DEBUG_INFO("uCode init instr len %d too large to fit in\n",
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4902 4903
		goto err_release;
	}
4904
	if (init_data_size > IWL39_MAX_DATA_SIZE) {
4905 4906 4907
		IWL_DEBUG_INFO("uCode init data len %d too large to fit in\n",
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4908 4909
		goto err_release;
	}
4910
	if (boot_size > IWL39_MAX_BSM_SIZE) {
4911 4912 4913
		IWL_DEBUG_INFO("uCode boot instr len %d too large to fit in\n",
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4914 4915 4916 4917 4918 4919 4920 4921 4922
		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;
4923
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
4924 4925

	priv->ucode_data.len = data_size;
4926
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
4927 4928

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

4931 4932 4933
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
4934 4935

	/* Initialization instructions and data */
4936 4937
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
4938
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
4939 4940

		priv->ucode_init_data.len = init_data_size;
4941
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
4942 4943 4944 4945

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

	/* Bootstrap (instructions only, no data) */
4948 4949
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
4950
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
4951

4952 4953 4954
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
4955 4956 4957 4958 4959 4960

	/* 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;
4961
	IWL_DEBUG_INFO("Copying (but not loading) uCode instr len %Zd\n", len);
Z
Zhu Yi 已提交
4962 4963 4964 4965 4966
	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 已提交
4967
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
Z
Zhu Yi 已提交
4968 4969
	src = &ucode->data[inst_size];
	len = priv->ucode_data.len;
4970
	IWL_DEBUG_INFO("Copying (but not loading) uCode data len %Zd\n", len);
Z
Zhu Yi 已提交
4971 4972 4973 4974 4975 4976 4977
	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;
4978 4979
		IWL_DEBUG_INFO("Copying (but not loading) init instr len %Zd\n",
			       len);
Z
Zhu Yi 已提交
4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003
		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:
5004
	IWL_ERR(priv, "failed to allocate pci memory\n");
5005
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
5006
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
5007 5008 5009 5010 5011

 err_release:
	release_firmware(ucode_raw);

 error:
5012
	return ret;
Z
Zhu Yi 已提交
5013 5014 5015 5016
}


/**
C
Christoph Hellwig 已提交
5017
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
5018 5019 5020 5021 5022 5023 5024
 *
 * 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.
 */
5025
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036
{
	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);
5037
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
5038 5039 5040 5041 5042 5043
	if (rc) {
		spin_unlock_irqrestore(&priv->lock, flags);
		return rc;
	}

	/* Tell bootstrap uCode where to find image to load */
5044 5045 5046
	iwl_write_prph(priv, BSM_DRAM_INST_PTR_REG, pinst);
	iwl_write_prph(priv, BSM_DRAM_DATA_PTR_REG, pdata);
	iwl_write_prph(priv, BSM_DRAM_DATA_BYTECOUNT_REG,
Z
Zhu Yi 已提交
5047 5048
				 priv->ucode_data.len);

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

5054
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
5055 5056 5057 5058 5059 5060 5061 5062 5063

	spin_unlock_irqrestore(&priv->lock, flags);

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

	return rc;
}

/**
C
Christoph Hellwig 已提交
5064
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
5065 5066 5067 5068
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
5069
 */
5070
static void iwl3945_init_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082
{
	/* 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 已提交
5083
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
5084 5085 5086 5087 5088 5089 5090 5091 5092 5093
		/* 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 已提交
5094
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106
		/* 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);
}


5107 5108 5109 5110
/* temporary */
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw,
				     struct sk_buff *skb);

Z
Zhu Yi 已提交
5111
/**
C
Christoph Hellwig 已提交
5112
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
5113
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
5114
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
5115
 */
5116
static void iwl3945_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133
{
	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 已提交
5134
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
5135 5136 5137 5138 5139 5140
		/* 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 已提交
5141
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5142

5143
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
5144
	if (rc) {
5145
		IWL_WARN(priv, "Can not read RFKILL status from adapter\n");
Z
Zhu Yi 已提交
5146 5147 5148
		return;
	}

5149
	rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
Z
Zhu Yi 已提交
5150
	IWL_DEBUG_INFO("RFKILL status: 0x%x\n", rfkill);
5151
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
5152 5153 5154

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
5155
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
5156
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
5157
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
5158 5159 5160 5161 5162 5163 5164 5165 5166 5167
			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);

5168
	/* After the ALIVE response, we can send commands to 3945 uCode */
Z
Zhu Yi 已提交
5169 5170 5171 5172 5173
	set_bit(STATUS_ALIVE, &priv->status);

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

5174
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
5175 5176
		return;

5177
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
5178 5179 5180 5181

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

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

C
Christoph Hellwig 已提交
5184 5185
	if (iwl3945_is_associated(priv)) {
		struct iwl3945_rxon_cmd *active_rxon =
5186
				(struct iwl3945_rxon_cmd *)(&priv->active39_rxon);
Z
Zhu Yi 已提交
5187

5188 5189
		memcpy(&priv->staging39_rxon, &priv->active39_rxon,
		       sizeof(priv->staging39_rxon));
Z
Zhu Yi 已提交
5190 5191 5192
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
5193
		iwl3945_connection_init_rx_config(priv, priv->iw_mode);
5194
		memcpy(priv->staging39_rxon.node_addr, priv->mac_addr, ETH_ALEN);
Z
Zhu Yi 已提交
5195 5196
	}

5197
	/* Configure Bluetooth device coexistence support */
C
Christoph Hellwig 已提交
5198
	iwl3945_send_bt_config(priv);
Z
Zhu Yi 已提交
5199 5200

	/* Configure the adapter for unassociated operation */
C
Christoph Hellwig 已提交
5201
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5202 5203 5204

	iwl3945_reg_txpower_periodic(priv);

5205 5206
	iwl3945_led_register(priv);

Z
Zhu Yi 已提交
5207
	IWL_DEBUG_INFO("ALIVE processing complete.\n");
5208
	set_bit(STATUS_READY, &priv->status);
5209
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
5210 5211

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

5214 5215 5216 5217 5218 5219 5220 5221
	/* 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 已提交
5222 5223 5224 5225 5226 5227
	return;

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

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

5230
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242
{
	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 已提交
5243
	iwl3945_led_unregister(priv);
C
Christoph Hellwig 已提交
5244
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5245 5246 5247 5248 5249 5250 5251 5252 5253 5254

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

	/* tell the device to stop sending interrupts */
5258
	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
5259
	iwl3945_disable_interrupts(priv);
5260 5261
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
5262 5263 5264 5265

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

C
Christoph Hellwig 已提交
5266
	/* If we have not previously called iwl3945_init() then
Z
Zhu Yi 已提交
5267
	 * clear all bits but the RF Kill and SUSPEND bits and return */
5268
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
5269 5270 5271 5272
		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 |
5273 5274
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
5275
			       test_bit(STATUS_IN_SUSPEND, &priv->status) <<
5276 5277 5278
					STATUS_IN_SUSPEND |
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
5279 5280 5281 5282 5283 5284 5285 5286 5287
		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 |
5288 5289
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
5290 5291 5292
			test_bit(STATUS_IN_SUSPEND, &priv->status) <<
				STATUS_IN_SUSPEND |
			test_bit(STATUS_FW_ERROR, &priv->status) <<
5293 5294 5295
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
5296 5297

	spin_lock_irqsave(&priv->lock, flags);
5298
	iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
Z
Zhu Yi 已提交
5299 5300
	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
5301 5302
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
5303 5304

	spin_lock_irqsave(&priv->lock, flags);
5305 5306
	if (!iwl_grab_nic_access(priv)) {
		iwl_write_prph(priv, APMG_CLK_DIS_REG,
Z
Zhu Yi 已提交
5307
					 APMG_CLK_VAL_DMA_CLK_RQT);
5308
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
5309 5310 5311 5312 5313
	}
	spin_unlock_irqrestore(&priv->lock, flags);

	udelay(5);

K
Kolekar, Abhijeet 已提交
5314
	priv->cfg->ops->lib->apm_ops.reset(priv);
Z
Zhu Yi 已提交
5315
 exit:
5316
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
5317 5318 5319 5320 5321 5322

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
5323
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
5324 5325
}

5326
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5327 5328
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5329
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
5330
	mutex_unlock(&priv->mutex);
5331

C
Christoph Hellwig 已提交
5332
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
5333 5334 5335 5336
}

#define MAX_HW_RESTARTS 5

5337
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5338 5339 5340 5341
{
	int rc, i;

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
5342
		IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
Z
Zhu Yi 已提交
5343 5344 5345 5346
		return -EIO;
	}

	if (test_bit(STATUS_RF_KILL_SW, &priv->status)) {
5347
		IWL_WARN(priv, "Radio disabled by SW RF kill (module "
Z
Zhu Yi 已提交
5348
			    "parameter)\n");
5349 5350 5351
		return -ENODEV;
	}

5352
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
5353
		IWL_ERR(priv, "ucode not available for device bring up\n");
5354 5355 5356
		return -EIO;
	}

5357
	/* If platform's RF_KILL switch is NOT set to KILL */
5358
	if (iwl_read32(priv, CSR_GP_CNTRL) &
5359 5360 5361 5362 5363
				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)) {
5364
			IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
5365 5366
			return -ENODEV;
		}
Z
Zhu Yi 已提交
5367
	}
5368

5369
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
5370

C
Christoph Hellwig 已提交
5371
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
5372
	if (rc) {
5373
		IWL_ERR(priv, "Unable to int nic\n");
Z
Zhu Yi 已提交
5374 5375 5376 5377
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
5378 5379
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
5380 5381 5382
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
5383
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
C
Christoph Hellwig 已提交
5384
	iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
5385 5386

	/* really make sure rfkill handshake bits are cleared */
5387 5388
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
Z
Zhu Yi 已提交
5389 5390 5391 5392 5393

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

5396 5397 5398 5399
	/* 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 已提交
5400 5401
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

C
Christoph Hellwig 已提交
5402
		iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5403 5404 5405 5406

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

		if (rc) {
5410 5411
			IWL_ERR(priv,
				"Unable to set up bootstrap uCode: %d\n", rc);
Z
Zhu Yi 已提交
5412 5413 5414 5415
			continue;
		}

		/* start card; "initialize" will load runtime ucode */
C
Christoph Hellwig 已提交
5416
		iwl3945_nic_start(priv);
Z
Zhu Yi 已提交
5417 5418 5419 5420 5421 5422 5423

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

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
5424
	__iwl3945_down(priv);
5425
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
5426 5427 5428

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
5429
	IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
Z
Zhu Yi 已提交
5430 5431 5432 5433 5434 5435 5436 5437 5438 5439
	return -EIO;
}


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

C
Christoph Hellwig 已提交
5440
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
5441
{
5442 5443
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, init_alive_start.work);
Z
Zhu Yi 已提交
5444 5445 5446 5447 5448

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5449
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
5450 5451 5452
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5453
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
5454
{
5455 5456
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, alive_start.work);
Z
Zhu Yi 已提交
5457 5458 5459 5460 5461

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5462
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
5463 5464 5465
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5466
static void iwl3945_bg_rf_kill(struct work_struct *work)
Z
Zhu Yi 已提交
5467
{
5468
	struct iwl_priv *priv = container_of(work, struct iwl_priv, rf_kill);
Z
Zhu Yi 已提交
5469 5470 5471 5472 5473 5474 5475 5476

	wake_up_interruptible(&priv->wait_command_queue);

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

	mutex_lock(&priv->mutex);

5477
	if (!iwl_is_rfkill(priv)) {
Z
Zhu Yi 已提交
5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488
		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
5489
			IWL_WARN(priv, "Radio Frequency Kill Switch is On:\n"
Z
Zhu Yi 已提交
5490 5491 5492
				    "Kill switch must be turned off for "
				    "wireless networking to work.\n");
	}
5493

Z
Zhu Yi 已提交
5494
	mutex_unlock(&priv->mutex);
5495
	iwl3945_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
5496 5497 5498 5499
}

#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)

C
Christoph Hellwig 已提交
5500
static void iwl3945_bg_scan_check(struct work_struct *data)
Z
Zhu Yi 已提交
5501
{
5502 5503
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, scan_check.work);
Z
Zhu Yi 已提交
5504 5505 5506 5507 5508 5509 5510 5511 5512 5513

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

Z
Zhu Yi 已提交
5515
		if (!test_bit(STATUS_EXIT_PENDING, &priv->status))
C
Christoph Hellwig 已提交
5516
			iwl3945_send_scan_abort(priv);
Z
Zhu Yi 已提交
5517 5518 5519 5520
	}
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5521
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
5522
{
5523 5524
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
5525
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
5526
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
5527
		.len = sizeof(struct iwl3945_scan_cmd),
Z
Zhu Yi 已提交
5528 5529 5530
		.meta.flags = CMD_SIZE_HUGE,
	};
	int rc = 0;
C
Christoph Hellwig 已提交
5531
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
5532
	struct ieee80211_conf *conf = NULL;
5533
	u8 n_probes = 2;
5534
	enum ieee80211_band band;
5535
	DECLARE_SSID_BUF(ssid);
Z
Zhu Yi 已提交
5536 5537 5538 5539 5540

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

5541
	if (!iwl_is_ready(priv)) {
5542
		IWL_WARN(priv, "request scan called when driver not ready.\n");
Z
Zhu Yi 已提交
5543 5544 5545
		goto done;
	}

T
Tomas Winkler 已提交
5546
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569
	 * 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;
	}

5570
	if (iwl_is_rfkill(priv)) {
Z
Zhu Yi 已提交
5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584
		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;
	}

5585 5586
	if (!priv->scan39) {
		priv->scan39 = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
5587
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
5588
		if (!priv->scan39) {
Z
Zhu Yi 已提交
5589 5590 5591 5592
			rc = -ENOMEM;
			goto done;
		}
	}
5593
	scan = priv->scan39;
C
Christoph Hellwig 已提交
5594
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
5595 5596 5597 5598

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

C
Christoph Hellwig 已提交
5599
	if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612
		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;
5613
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635
		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",
5636 5637
		     print_ssid(ssid, priv->direct_ssid,
				priv->direct_ssid_len));
Z
Zhu Yi 已提交
5638 5639 5640 5641
		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);
5642 5643
		n_probes++;
	} else
5644
		IWL_DEBUG_SCAN("Kicking off one indirect scan.\n");
Z
Zhu Yi 已提交
5645 5646 5647 5648

	/* 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 已提交
5649
		iwl3945_fill_probe_req(priv, (struct ieee80211_mgmt *)scan->data,
J
Johannes Berg 已提交
5650
			IWL_MAX_SCAN_SIZE - sizeof(*scan)));
Z
Zhu Yi 已提交
5651
	scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
5652
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
5653 5654 5655 5656
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

5657
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
5658 5659 5660
		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;
5661
		band = IEEE80211_BAND_2GHZ;
5662
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
5663 5664
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
		scan->good_CRC_th = IWL_GOOD_CRC_TH;
5665
		band = IEEE80211_BAND_5GHZ;
5666
	} else {
5667
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
5668 5669 5670 5671 5672 5673
		goto done;
	}

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

5674
	if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
Z
Zhu Yi 已提交
5675 5676
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

5677 5678 5679 5680
	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 已提交
5681

5682 5683 5684 5685 5686
	if (scan->channel_count == 0) {
		IWL_DEBUG_SCAN("channel count %d\n", scan->channel_count);
		goto done;
	}

Z
Zhu Yi 已提交
5687
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
5688
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
5689 5690 5691 5692
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
C
Christoph Hellwig 已提交
5693
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
5694 5695 5696 5697 5698 5699 5700 5701 5702 5703
	if (rc)
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
5704 5705 5706 5707 5708 5709 5710 5711
	/* 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);

5712
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
5713 5714 5715 5716
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5717
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
5718
{
5719
	struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
Z
Zhu Yi 已提交
5720 5721 5722 5723 5724

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5725
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
5726
	mutex_unlock(&priv->mutex);
5727
	iwl3945_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
5728 5729
}

C
Christoph Hellwig 已提交
5730
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
5731
{
5732
	struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
Z
Zhu Yi 已提交
5733 5734 5735 5736

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

C
Christoph Hellwig 已提交
5737
	iwl3945_down(priv);
Z
Zhu Yi 已提交
5738 5739 5740
	queue_work(priv->workqueue, &priv->up);
}

C
Christoph Hellwig 已提交
5741
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
5742
{
5743 5744
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rx_replenish);
Z
Zhu Yi 已提交
5745 5746 5747 5748 5749

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5750
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
5751 5752 5753
	mutex_unlock(&priv->mutex);
}

5754 5755
#define IWL_DELAY_NEXT_SCAN (HZ*2)

5756
static void iwl3945_post_associate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5757 5758 5759 5760
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

5761
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
5762
		IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
5763 5764 5765 5766
		return;
	}


J
Johannes Berg 已提交
5767
	IWL_DEBUG_ASSOC("Associated as %d to: %pM\n",
5768
			priv->assoc_id, priv->active39_rxon.bssid_addr);
Z
Zhu Yi 已提交
5769 5770 5771 5772

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

A
Abhijeet Kolekar 已提交
5773
	if (!priv->vif || !priv->is_open)
5774
		return;
A
Abhijeet Kolekar 已提交
5775

C
Christoph Hellwig 已提交
5776
	iwl3945_scan_cancel_timeout(priv, 200);
5777

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

5780
	priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
5781
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5782

5783
	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
5784 5785
	iwl3945_setup_rxon_timing(priv);
	rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
5786 5787
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
5788
		IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
5789 5790
			    "Attempting to continue.\n");

5791
	priv->staging39_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
Z
Zhu Yi 已提交
5792

5793
	priv->staging39_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
5794 5795 5796 5797 5798

	IWL_DEBUG_ASSOC("assoc id %d beacon interval %d\n",
			priv->assoc_id, priv->beacon_int);

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
5799
		priv->staging39_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
5800
	else
5801
		priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
5802

5803
	if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
5804
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
5805
			priv->staging39_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
5806
		else
5807
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
5808

5809
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
5810
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
5811 5812 5813

	}

C
Christoph Hellwig 已提交
5814
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5815 5816

	switch (priv->iw_mode) {
5817
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
5818
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
5819 5820
		break;

5821
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
5822

5823
		priv->assoc_id = 1;
C
Christoph Hellwig 已提交
5824
		iwl3945_add_station(priv, priv->bssid, 0, 0);
Z
Zhu Yi 已提交
5825
		iwl3945_sync_sta(priv, IWL_STA_ID,
5826
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
5827 5828
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
5829 5830
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
5831 5832 5833 5834

		break;

	default:
5835
		 IWL_ERR(priv, "%s Should not be called in %d mode\n",
5836
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
5837 5838 5839
		break;
	}

C
Christoph Hellwig 已提交
5840
	iwl3945_activate_qos(priv, 0);
5841

5842 5843
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
5844 5845
}

C
Christoph Hellwig 已提交
5846
static void iwl3945_bg_abort_scan(struct work_struct *work)
Z
Zhu Yi 已提交
5847
{
5848
	struct iwl_priv *priv = container_of(work, struct iwl_priv, abort_scan);
Z
Zhu Yi 已提交
5849

5850
	if (!iwl_is_ready(priv))
Z
Zhu Yi 已提交
5851 5852 5853 5854 5855
		return;

	mutex_lock(&priv->mutex);

	set_bit(STATUS_SCAN_ABORTING, &priv->status);
C
Christoph Hellwig 已提交
5856
	iwl3945_send_scan_abort(priv);
Z
Zhu Yi 已提交
5857 5858 5859 5860

	mutex_unlock(&priv->mutex);
}

5861
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed);
5862

C
Christoph Hellwig 已提交
5863
static void iwl3945_bg_scan_completed(struct work_struct *work)
Z
Zhu Yi 已提交
5864
{
5865 5866
	struct iwl_priv *priv =
	    container_of(work, struct iwl_priv, scan_completed);
Z
Zhu Yi 已提交
5867 5868 5869 5870 5871 5872

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

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

5873
	if (test_bit(STATUS_CONF_PENDING, &priv->status))
5874
		iwl3945_mac_config(priv->hw, 0);
5875

Z
Zhu Yi 已提交
5876 5877 5878 5879 5880
	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 已提交
5881
	iwl3945_hw_reg_send_txpower(priv);
Z
Zhu Yi 已提交
5882 5883 5884 5885 5886 5887 5888 5889 5890
	mutex_unlock(&priv->mutex);
}

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

5891 5892
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
5893
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
5894
{
5895
	struct iwl_priv *priv = hw->priv;
5896
	int ret;
Z
Zhu Yi 已提交
5897 5898 5899

	IWL_DEBUG_MAC80211("enter\n");

5900
	if (pci_enable_device(priv->pci_dev)) {
5901
		IWL_ERR(priv, "Fail to pci_enable_device\n");
5902 5903 5904 5905 5906 5907 5908 5909
		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) {
5910
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
5911 5912 5913
		goto out_disable_msi;
	}

Z
Zhu Yi 已提交
5914 5915 5916
	/* we should be verifying the device is ready to be opened */
	mutex_lock(&priv->mutex);

5917
	memset(&priv->staging39_rxon, 0, sizeof(struct iwl3945_rxon_cmd));
5918 5919 5920 5921 5922 5923
	/* 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) {
5924
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
5925 5926 5927 5928
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
5929

5930
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
5931 5932

	mutex_unlock(&priv->mutex);
5933

5934 5935
	iwl3945_rfkill_set_hw_state(priv);

5936 5937 5938 5939 5940 5941 5942 5943
	if (ret)
		goto out_release_irq;

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

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

5944 5945 5946 5947 5948 5949 5950
	/* 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)) {
5951 5952 5953
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
5954 5955 5956 5957 5958
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

5959
	priv->is_open = 1;
Z
Zhu Yi 已提交
5960 5961
	IWL_DEBUG_MAC80211("leave\n");
	return 0;
5962 5963 5964 5965 5966

out_release_irq:
	free_irq(priv->pci_dev->irq, priv);
out_disable_msi:
	pci_disable_msi(priv->pci_dev);
5967 5968 5969
	pci_disable_device(priv->pci_dev);
	priv->is_open = 0;
	IWL_DEBUG_MAC80211("leave - failed\n");
5970
	return ret;
Z
Zhu Yi 已提交
5971 5972
}

C
Christoph Hellwig 已提交
5973
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
5974
{
5975
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
5976 5977

	IWL_DEBUG_MAC80211("enter\n");
5978

5979 5980 5981 5982 5983
	if (!priv->is_open) {
		IWL_DEBUG_MAC80211("leave - skip\n");
		return;
	}

Z
Zhu Yi 已提交
5984
	priv->is_open = 0;
5985

5986
	if (iwl_is_ready_rf(priv)) {
5987 5988 5989
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
5990 5991
		mutex_lock(&priv->mutex);
		iwl3945_scan_cancel_timeout(priv, 100);
5992 5993 5994
		mutex_unlock(&priv->mutex);
	}

5995 5996 5997 5998 5999 6000 6001
	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);
6002

Z
Zhu Yi 已提交
6003 6004 6005
	IWL_DEBUG_MAC80211("leave\n");
}

6006
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
6007
{
6008
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6009 6010 6011 6012

	IWL_DEBUG_MAC80211("enter\n");

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

6015
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
6016 6017 6018
		dev_kfree_skb_any(skb);

	IWL_DEBUG_MAC80211("leave\n");
6019
	return NETDEV_TX_OK;
Z
Zhu Yi 已提交
6020 6021
}

C
Christoph Hellwig 已提交
6022
static int iwl3945_mac_add_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
6023 6024
				 struct ieee80211_if_init_conf *conf)
{
6025
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6026 6027
	unsigned long flags;

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

6030 6031
	if (priv->vif) {
		IWL_DEBUG_MAC80211("leave - vif != NULL\n");
6032
		return -EOPNOTSUPP;
Z
Zhu Yi 已提交
6033 6034 6035
	}

	spin_lock_irqsave(&priv->lock, flags);
6036
	priv->vif = conf->vif;
6037
	priv->iw_mode = conf->type;
Z
Zhu Yi 已提交
6038 6039 6040 6041

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
6042 6043

	if (conf->mac_addr) {
J
Johannes Berg 已提交
6044
		IWL_DEBUG_MAC80211("Set: %pM\n", conf->mac_addr);
6045 6046 6047
		memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
	}

6048
	if (iwl_is_ready(priv))
6049
		iwl3945_set_mode(priv, conf->type);
Z
Zhu Yi 已提交
6050 6051 6052

	mutex_unlock(&priv->mutex);

6053
	IWL_DEBUG_MAC80211("leave\n");
Z
Zhu Yi 已提交
6054 6055 6056 6057
	return 0;
}

/**
C
Christoph Hellwig 已提交
6058
 * iwl3945_mac_config - mac80211 config callback
Z
Zhu Yi 已提交
6059 6060 6061 6062 6063
 *
 * 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.
 */
6064
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed)
Z
Zhu Yi 已提交
6065
{
6066
	struct iwl_priv *priv = hw->priv;
6067
	const struct iwl_channel_info *ch_info;
6068
	struct ieee80211_conf *conf = &hw->conf;
Z
Zhu Yi 已提交
6069
	unsigned long flags;
6070
	int ret = 0;
Z
Zhu Yi 已提交
6071 6072

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

6075
	if (!iwl_is_ready(priv)) {
Z
Zhu Yi 已提交
6076
		IWL_DEBUG_MAC80211("leave - not ready\n");
6077 6078
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
6079 6080
	}

6081
	if (unlikely(!iwl3945_mod_params.disable_hw_scan &&
Z
Zhu Yi 已提交
6082
		     test_bit(STATUS_SCANNING, &priv->status))) {
6083 6084
		IWL_DEBUG_MAC80211("leave - scanning\n");
		set_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
6085
		mutex_unlock(&priv->mutex);
6086
		return 0;
Z
Zhu Yi 已提交
6087 6088 6089 6090
	}

	spin_lock_irqsave(&priv->lock, flags);

6091 6092
	ch_info = iwl3945_get_channel_info(priv, conf->channel->band,
					   conf->channel->hw_value);
Z
Zhu Yi 已提交
6093
	if (!is_channel_valid(ch_info)) {
6094
		IWL_DEBUG_SCAN("Channel %d [%d] is INVALID for this band.\n",
6095
			       conf->channel->hw_value, conf->channel->band);
Z
Zhu Yi 已提交
6096 6097
		IWL_DEBUG_MAC80211("leave - invalid channel\n");
		spin_unlock_irqrestore(&priv->lock, flags);
6098 6099
		ret = -EINVAL;
		goto out;
Z
Zhu Yi 已提交
6100 6101
	}

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

6104
	iwl3945_set_flags_for_phymode(priv, conf->channel->band);
Z
Zhu Yi 已提交
6105 6106 6107 6108

	/* 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 已提交
6109
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6110 6111 6112 6113 6114

	spin_unlock_irqrestore(&priv->lock, flags);

#ifdef IEEE80211_CONF_CHANNEL_SWITCH
	if (conf->flags & IEEE80211_CONF_CHANNEL_SWITCH) {
C
Christoph Hellwig 已提交
6115
		iwl3945_hw_channel_switch(priv, conf->channel);
6116
		goto out;
Z
Zhu Yi 已提交
6117 6118 6119
	}
#endif

C
Christoph Hellwig 已提交
6120
	iwl3945_radio_kill_sw(priv, !conf->radio_enabled);
Z
Zhu Yi 已提交
6121 6122 6123

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

6127
	if (iwl_is_rfkill(priv)) {
Z
Zhu Yi 已提交
6128
		IWL_DEBUG_MAC80211("leave - RF kill\n");
6129 6130
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
6131 6132
	}

C
Christoph Hellwig 已提交
6133
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6134

6135 6136
	if (memcmp(&priv->active39_rxon,
		   &priv->staging39_rxon, sizeof(priv->staging39_rxon)))
C
Christoph Hellwig 已提交
6137
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6138 6139 6140 6141 6142
	else
		IWL_DEBUG_INFO("No re-sending same RXON configuration.\n");

	IWL_DEBUG_MAC80211("leave\n");

6143
out:
6144
	clear_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
6145
	mutex_unlock(&priv->mutex);
6146
	return ret;
Z
Zhu Yi 已提交
6147 6148
}

6149
static void iwl3945_config_ap(struct iwl_priv *priv)
Z
Zhu Yi 已提交
6150 6151 6152
{
	int rc = 0;

6153
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
6154 6155 6156
		return;

	/* The following should be done only at AP bring up */
6157
	if (!(iwl3945_is_associated(priv))) {
Z
Zhu Yi 已提交
6158 6159

		/* RXON - unassoc (to set timing command) */
6160
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6161
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6162 6163

		/* RXON Timing */
6164
		memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
6165 6166
		iwl3945_setup_rxon_timing(priv);
		rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
6167 6168
				sizeof(priv->rxon_timing), &priv->rxon_timing);
		if (rc)
6169
			IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
6170 6171 6172
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
6173
		priv->staging39_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
6174
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
6175
			priv->staging39_rxon.flags |=
Z
Zhu Yi 已提交
6176 6177
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
6178
			priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
6179 6180
				~RXON_FLG_SHORT_PREAMBLE_MSK;

6181
		if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
6182 6183
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
6184
				priv->staging39_rxon.flags |=
Z
Zhu Yi 已提交
6185 6186
					RXON_FLG_SHORT_SLOT_MSK;
			else
6187
				priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
6188 6189
					~RXON_FLG_SHORT_SLOT_MSK;

6190
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
6191
				priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
6192 6193 6194
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
6195
		priv->staging39_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6196
		iwl3945_commit_rxon(priv);
6197
		iwl3945_add_station(priv, iwl_bcast_addr, 0, 0);
6198
	}
C
Christoph Hellwig 已提交
6199
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
6200 6201 6202 6203 6204 6205

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

6206 6207
static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
6208
					struct ieee80211_if_conf *conf)
Z
Zhu Yi 已提交
6209
{
6210
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6211 6212 6213 6214 6215
	int rc;

	if (conf == NULL)
		return -EIO;

6216 6217 6218 6219 6220
	if (priv->vif != vif) {
		IWL_DEBUG_MAC80211("leave - priv->vif != vif\n");
		return 0;
	}

6221
	/* handle this temporarily here */
6222
	if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
6223 6224 6225 6226
	    conf->changed & IEEE80211_IFCC_BEACON) {
		struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
		if (!beacon)
			return -ENOMEM;
6227
		mutex_lock(&priv->mutex);
6228
		rc = iwl3945_mac_beacon_update(hw, beacon);
6229
		mutex_unlock(&priv->mutex);
6230 6231 6232 6233
		if (rc)
			return rc;
	}

6234
	if (!iwl_is_alive(priv))
6235 6236
		return -EAGAIN;

Z
Zhu Yi 已提交
6237 6238 6239
	mutex_lock(&priv->mutex);

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

6242 6243 6244
/*
 * very dubious code was here; the probe filtering flag is never set:
 *
Z
Zhu Yi 已提交
6245 6246
	if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
	    !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
6247
 */
Z
Zhu Yi 已提交
6248

6249
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
6250 6251 6252
		if (!conf->bssid) {
			conf->bssid = priv->mac_addr;
			memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
J
Johannes Berg 已提交
6253 6254
			IWL_DEBUG_MAC80211("bssid was set to: %pM\n",
					   conf->bssid);
Z
Zhu Yi 已提交
6255 6256 6257 6258
		}
		if (priv->ibss_beacon)
			dev_kfree_skb(priv->ibss_beacon);

6259
		priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
Z
Zhu Yi 已提交
6260 6261
	}

6262
	if (iwl_is_rfkill(priv))
6263 6264
		goto done;

Z
Zhu Yi 已提交
6265 6266 6267 6268
	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 已提交
6269
		if (iwl3945_scan_cancel_timeout(priv, 100)) {
6270
			IWL_WARN(priv, "Aborted scan still in progress "
Z
Zhu Yi 已提交
6271 6272 6273 6274 6275
				    "after 100ms\n");
			IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
			mutex_unlock(&priv->mutex);
			return -EAGAIN;
		}
6276
		memcpy(priv->staging39_rxon.bssid_addr, conf->bssid, ETH_ALEN);
Z
Zhu Yi 已提交
6277 6278 6279 6280 6281 6282 6283

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

6284
		if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
6285
			iwl3945_config_ap(priv);
Z
Zhu Yi 已提交
6286
		else {
C
Christoph Hellwig 已提交
6287
			rc = iwl3945_commit_rxon(priv);
6288
			if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
C
Christoph Hellwig 已提交
6289
				iwl3945_add_station(priv,
6290
					priv->active39_rxon.bssid_addr, 1, 0);
Z
Zhu Yi 已提交
6291 6292 6293
		}

	} else {
C
Christoph Hellwig 已提交
6294
		iwl3945_scan_cancel_timeout(priv, 100);
6295
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6296
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6297 6298
	}

6299
 done:
Z
Zhu Yi 已提交
6300 6301 6302 6303 6304 6305
	IWL_DEBUG_MAC80211("leave\n");
	mutex_unlock(&priv->mutex);

	return 0;
}

C
Christoph Hellwig 已提交
6306
static void iwl3945_configure_filter(struct ieee80211_hw *hw,
6307 6308 6309 6310
				 unsigned int changed_flags,
				 unsigned int *total_flags,
				 int mc_count, struct dev_addr_list *mc_list)
{
6311
	struct iwl_priv *priv = hw->priv;
6312
	__le32 *filter_flags = &priv->staging39_rxon.filter_flags;
6313

Z
Zhu, Yi 已提交
6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333
	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;
6334
	}
Z
Zhu, Yi 已提交
6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348
	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 |
6349
			FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
6350 6351
}

C
Christoph Hellwig 已提交
6352
static void iwl3945_mac_remove_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
6353 6354
				     struct ieee80211_if_init_conf *conf)
{
6355
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6356 6357 6358 6359

	IWL_DEBUG_MAC80211("enter\n");

	mutex_lock(&priv->mutex);
6360

6361
	if (iwl_is_ready_rf(priv)) {
6362
		iwl3945_scan_cancel_timeout(priv, 100);
6363
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
6364 6365
		iwl3945_commit_rxon(priv);
	}
6366 6367
	if (priv->vif == conf->vif) {
		priv->vif = NULL;
Z
Zhu Yi 已提交
6368 6369 6370 6371 6372 6373 6374
		memset(priv->bssid, 0, ETH_ALEN);
	}
	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");
}

6375 6376 6377 6378 6379 6380 6381
#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)
{
6382
	struct iwl_priv *priv = hw->priv;
6383 6384 6385 6386 6387 6388 6389

	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)
6390
			priv->staging39_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
6391
		else
6392
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
6393 6394 6395 6396 6397
	}

	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))
6398
			priv->staging39_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
6399
		else
6400
			priv->staging39_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411
	}

	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;
6412
			priv->timestamp = bss_conf->timestamp;
6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429
			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 已提交
6430
static int iwl3945_mac_hw_scan(struct ieee80211_hw *hw, u8 *ssid, size_t len)
Z
Zhu Yi 已提交
6431 6432 6433
{
	int rc = 0;
	unsigned long flags;
6434
	struct iwl_priv *priv = hw->priv;
6435
	DECLARE_SSID_BUF(ssid_buf);
Z
Zhu Yi 已提交
6436 6437 6438

	IWL_DEBUG_MAC80211("enter\n");

6439
	mutex_lock(&priv->mutex);
Z
Zhu Yi 已提交
6440 6441
	spin_lock_irqsave(&priv->lock, flags);

6442
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
6443 6444 6445 6446 6447
		rc = -EIO;
		IWL_DEBUG_MAC80211("leave - not ready or exit pending\n");
		goto out_unlock;
	}

6448 6449 6450 6451 6452 6453
	/* 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;
	}
6454 6455 6456 6457
	/* 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 已提交
6458 6459 6460 6461
		rc = -EAGAIN;
		goto out_unlock;
	}
	if (len) {
6462
		IWL_DEBUG_SCAN("direct scan for %s [%d]\n ",
6463
			       print_ssid(ssid_buf, ssid, len), (int)len);
Z
Zhu Yi 已提交
6464 6465 6466 6467 6468

		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);
6469 6470
	} else
		priv->one_direct_scan = 0;
Z
Zhu Yi 已提交
6471

C
Christoph Hellwig 已提交
6472
	rc = iwl3945_scan_initiate(priv);
Z
Zhu Yi 已提交
6473 6474 6475 6476 6477

	IWL_DEBUG_MAC80211("leave\n");

out_unlock:
	spin_unlock_irqrestore(&priv->lock, flags);
6478
	mutex_unlock(&priv->mutex);
Z
Zhu Yi 已提交
6479 6480 6481 6482

	return rc;
}

C
Christoph Hellwig 已提交
6483
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
6484 6485 6486
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
Z
Zhu Yi 已提交
6487
{
6488
	struct iwl_priv *priv = hw->priv;
6489
	const u8 *addr;
Z
Zhu Yi 已提交
6490 6491
	int rc = 0;
	u8 sta_id;
6492 6493
	static const u8 bcast_addr[ETH_ALEN] =
		{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
Z
Zhu Yi 已提交
6494 6495 6496

	IWL_DEBUG_MAC80211("enter\n");

6497
	if (iwl3945_mod_params.sw_crypto) {
Z
Zhu Yi 已提交
6498 6499 6500 6501
		IWL_DEBUG_MAC80211("leave - hwcrypto disabled\n");
		return -EOPNOTSUPP;
	}

6502
	addr = sta ? sta->addr : bcast_addr;
Z
Zhu Yi 已提交
6503

C
Christoph Hellwig 已提交
6504
	sta_id = iwl3945_hw_find_station(priv, addr);
Z
Zhu Yi 已提交
6505
	if (sta_id == IWL_INVALID_STATION) {
J
Johannes Berg 已提交
6506 6507
		IWL_DEBUG_MAC80211("leave - %pM not in station map.\n",
				   addr);
Z
Zhu Yi 已提交
6508 6509 6510 6511 6512
		return -EINVAL;
	}

	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
6513
	iwl3945_scan_cancel_timeout(priv, 100);
6514

Z
Zhu Yi 已提交
6515 6516
	switch (cmd) {
	case  SET_KEY:
C
Christoph Hellwig 已提交
6517
		rc = iwl3945_update_sta_key_info(priv, key, sta_id);
Z
Zhu Yi 已提交
6518
		if (!rc) {
C
Christoph Hellwig 已提交
6519 6520
			iwl3945_set_rxon_hwcrypto(priv, 1);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6521 6522 6523 6524 6525 6526
			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 已提交
6527
		rc = iwl3945_clear_sta_key_info(priv, sta_id);
Z
Zhu Yi 已提交
6528
		if (!rc) {
C
Christoph Hellwig 已提交
6529 6530
			iwl3945_set_rxon_hwcrypto(priv, 0);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543
			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 已提交
6544
static int iwl3945_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
Z
Zhu Yi 已提交
6545 6546
			   const struct ieee80211_tx_queue_params *params)
{
6547
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6548 6549 6550 6551 6552
	unsigned long flags;
	int q;

	IWL_DEBUG_MAC80211("enter\n");

6553
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570
		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 =
6571
			cpu_to_le16((params->txop * 32));
Z
Zhu Yi 已提交
6572 6573 6574 6575 6576 6577 6578

	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);
6579
	if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
6580 6581 6582
		iwl3945_activate_qos(priv, 1);
	else if (priv->assoc_id && iwl3945_is_associated(priv))
		iwl3945_activate_qos(priv, 0);
Z
Zhu Yi 已提交
6583 6584 6585 6586 6587 6588 6589

	mutex_unlock(&priv->mutex);

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

C
Christoph Hellwig 已提交
6590
static int iwl3945_mac_get_tx_stats(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
6591 6592
				struct ieee80211_tx_queue_stats *stats)
{
6593
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6594
	int i, avail;
6595
	struct iwl_tx_queue *txq;
6596
	struct iwl_queue *q;
Z
Zhu Yi 已提交
6597 6598 6599 6600
	unsigned long flags;

	IWL_DEBUG_MAC80211("enter\n");

6601
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
6602 6603 6604 6605 6606 6607 6608
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		return -EIO;
	}

	spin_lock_irqsave(&priv->lock, flags);

	for (i = 0; i < AC_NUM; i++) {
6609
		txq = &priv->txq[i];
Z
Zhu Yi 已提交
6610
		q = &txq->q;
6611
		avail = iwl_queue_space(q);
Z
Zhu Yi 已提交
6612

6613 6614 6615
		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 已提交
6616 6617 6618 6619 6620 6621 6622 6623 6624

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

	IWL_DEBUG_MAC80211("leave\n");

	return 0;
}

C
Christoph Hellwig 已提交
6625
static void iwl3945_mac_reset_tsf(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
6626
{
6627
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6628 6629 6630 6631 6632
	unsigned long flags;

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

6633
	iwl_reset_qos(priv);
6634

Z
Zhu Yi 已提交
6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646
	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;
6647
	priv->timestamp = 0;
6648
	if ((priv->iw_mode == NL80211_IFTYPE_STATION))
Z
Zhu Yi 已提交
6649 6650 6651 6652
		priv->beacon_int = 0;

	spin_unlock_irqrestore(&priv->lock, flags);

6653
	if (!iwl_is_ready_rf(priv)) {
6654 6655 6656 6657 6658
		IWL_DEBUG_MAC80211("leave - not ready\n");
		mutex_unlock(&priv->mutex);
		return;
	}

6659 6660 6661
	/* we are restarting association process
	 * clear RXON_FILTER_ASSOC_MSK bit
	*/
6662
	if (priv->iw_mode != NL80211_IFTYPE_AP) {
C
Christoph Hellwig 已提交
6663
		iwl3945_scan_cancel_timeout(priv, 100);
6664
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6665
		iwl3945_commit_rxon(priv);
6666 6667
	}

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

Z
Zhu Yi 已提交
6671 6672 6673 6674 6675
		IWL_DEBUG_MAC80211("leave - not in IBSS\n");
		mutex_unlock(&priv->mutex);
		return;
	}

C
Christoph Hellwig 已提交
6676
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6677 6678 6679 6680 6681 6682 6683

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");

}

6684
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
6685
{
6686
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6687 6688 6689 6690
	unsigned long flags;

	IWL_DEBUG_MAC80211("enter\n");

6691
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
6692 6693 6694 6695
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		return -EIO;
	}

6696
	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
Z
Zhu Yi 已提交
6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712
		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);

6713
	iwl_reset_qos(priv);
Z
Zhu Yi 已提交
6714

6715
	iwl3945_post_associate(priv);
Z
Zhu Yi 已提交
6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726


	return 0;
}

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

6727
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
6728 6729 6730 6731 6732 6733 6734 6735

/*
 * 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.
 */
6736 6737
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
6738
{
6739
	struct iwl_priv *priv = d->driver_data;
6740 6741

	return sprintf(buf, "0x%08X\n", priv->debug_level);
Z
Zhu Yi 已提交
6742
}
6743 6744
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
6745 6746
				 const char *buf, size_t count)
{
6747
	struct iwl_priv *priv = d->driver_data;
6748 6749
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
6750

6751 6752
	ret = strict_strtoul(buf, 0, &val);
	if (ret)
T
Tomas Winkler 已提交
6753
		IWL_INFO(priv, "%s is not in hex or decimal form.\n", buf);
Z
Zhu Yi 已提交
6754
	else
6755
		priv->debug_level = val;
Z
Zhu Yi 已提交
6756 6757 6758 6759

	return strnlen(buf, count);
}

6760 6761
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
6762

6763
#endif /* CONFIG_IWL3945_DEBUG */
Z
Zhu Yi 已提交
6764 6765 6766 6767

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

6770
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
6771 6772
		return -EAGAIN;

C
Christoph Hellwig 已提交
6773
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
6774 6775 6776 6777 6778 6779 6780
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
6781
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
6782 6783 6784 6785 6786 6787 6788
	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)
{
6789
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
6790 6791 6792 6793 6794
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
6795
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
6796
	else
C
Christoph Hellwig 已提交
6797
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
6798 6799 6800 6801 6802 6803 6804 6805 6806

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

6809
	return sprintf(buf, "0x%04X\n", priv->active39_rxon.flags);
Z
Zhu Yi 已提交
6810 6811 6812 6813 6814 6815
}

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

	mutex_lock(&priv->mutex);
6820
	if (le32_to_cpu(priv->staging39_rxon.flags) != flags) {
Z
Zhu Yi 已提交
6821
		/* Cancel any currently running scans... */
C
Christoph Hellwig 已提交
6822
		if (iwl3945_scan_cancel_timeout(priv, 100))
6823
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
6824 6825 6826
		else {
			IWL_DEBUG_INFO("Committing rxon.flags = 0x%04X\n",
				       flags);
6827
			priv->staging39_rxon.flags = cpu_to_le32(flags);
C
Christoph Hellwig 已提交
6828
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840
		}
	}
	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)
{
6841
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
6842 6843

	return sprintf(buf, "0x%04X\n",
6844
		le32_to_cpu(priv->active39_rxon.filter_flags));
Z
Zhu Yi 已提交
6845 6846 6847 6848 6849 6850
}

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

	mutex_lock(&priv->mutex);
6855
	if (le32_to_cpu(priv->staging39_rxon.filter_flags) != filter_flags) {
Z
Zhu Yi 已提交
6856
		/* Cancel any currently running scans... */
C
Christoph Hellwig 已提交
6857
		if (iwl3945_scan_cancel_timeout(priv, 100))
6858
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
6859 6860 6861
		else {
			IWL_DEBUG_INFO("Committing rxon.filter_flags = "
				       "0x%04X\n", filter_flags);
6862
			priv->staging39_rxon.filter_flags =
Z
Zhu Yi 已提交
6863
				cpu_to_le32(filter_flags);
C
Christoph Hellwig 已提交
6864
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6865 6866 6867 6868 6869 6870 6871 6872 6873 6874
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

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

6875
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
6876 6877 6878 6879

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
6880
	struct iwl_priv *priv = dev_get_drvdata(d);
6881
	struct iwl_spectrum_notification measure_report;
Z
Zhu Yi 已提交
6882
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
6883
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
6884 6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912
	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)
{
6913
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6914
	struct ieee80211_measurement_params params = {
6915
		.channel = le16_to_cpu(priv->active39_rxon.channel),
Z
Zhu Yi 已提交
6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938
		.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 已提交
6939
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
6940 6941 6942 6943 6944 6945

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
6946
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
6947 6948 6949 6950 6951

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
6952
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963

	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)
{
6964
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6965 6966 6967 6968 6969 6970 6971 6972 6973 6974
	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)
{
6975
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6976 6977 6978 6979 6980 6981
	int rc;
	int mode;

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

6982
	if (!iwl_is_ready(priv)) {
Z
Zhu Yi 已提交
6983 6984 6985 6986
		rc = -EAGAIN;
		goto out;
	}

6987 6988 6989
	if ((mode < 1) || (mode > IWL39_POWER_LIMIT) ||
	    (mode == IWL39_POWER_AC))
		mode = IWL39_POWER_AC;
Z
Zhu Yi 已提交
6990 6991 6992 6993
	else
		mode |= IWL_POWER_ENABLED;

	if (mode != priv->power_mode) {
C
Christoph Hellwig 已提交
6994
		rc = iwl3945_send_power_mode(priv, IWL_POWER_LEVEL(mode));
Z
Zhu Yi 已提交
6995 6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029
		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)
{
7030
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7031 7032 7033 7034 7035 7036
	int level = IWL_POWER_LEVEL(priv->power_mode);
	char *p = buf;

	p += sprintf(p, "%d ", level);
	switch (level) {
	case IWL_POWER_MODE_CAM:
7037
	case IWL39_POWER_AC:
Z
Zhu Yi 已提交
7038 7039
		p += sprintf(p, "(AC)");
		break;
7040
	case IWL39_POWER_BATTERY:
Z
Zhu Yi 已提交
7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054
		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");

7055
	return p - buf + 1;
Z
Zhu Yi 已提交
7056 7057 7058 7059 7060 7061 7062 7063 7064

}

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)
{
7065 7066
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
7067 7068 7069 7070 7071 7072 7073
}

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
7074
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
7075
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
7076
	u32 len = 0, ofs = 0;
7077
	u8 *data = (u8 *)&priv->statistics_39;
Z
Zhu Yi 已提交
7078 7079
	int rc = 0;

7080
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
7081 7082 7083
		return -EAGAIN;

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
7084
	rc = iwl3945_send_statistics_request(priv);
Z
Zhu Yi 已提交
7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111
	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)
{
7112
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7113

7114
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
7115 7116 7117 7118 7119 7120 7121 7122 7123 7124
		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;
7125
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136

	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 已提交
7137
		priv->antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149
	} 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)
{
7150
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
7151
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164
		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')
7165
		iwl3945_dump_nic_error_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178

	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')
7179
		iwl3945_dump_nic_event_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
7180 7181 7182 7183 7184 7185 7186 7187

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
7188
 * driver setup and tear down
Z
Zhu Yi 已提交
7189 7190 7191
 *
 *****************************************************************************/

7192
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
7193 7194 7195 7196 7197
{
	priv->workqueue = create_workqueue(DRV_NAME);

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210
	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 已提交
7211 7212

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

7216
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
7217
{
C
Christoph Hellwig 已提交
7218
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
7219

7220
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
7221 7222 7223 7224 7225
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
7226
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
7227 7228 7229 7230 7231 7232
	&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,
7233
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
7234 7235 7236 7237 7238 7239 7240 7241
	&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,
7242 7243 7244
#ifdef CONFIG_IWL3945_DEBUG
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
7245 7246 7247
	NULL
};

C
Christoph Hellwig 已提交
7248
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
7249
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
7250
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
7251 7252
};

C
Christoph Hellwig 已提交
7253 7254 7255 7256 7257 7258 7259 7260 7261 7262 7263 7264 7265
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_tx_stats = iwl3945_mac_get_tx_stats,
	.conf_tx = iwl3945_mac_conf_tx,
	.reset_tsf = iwl3945_mac_reset_tsf,
7266
	.bss_info_changed = iwl3945_bss_info_changed,
C
Christoph Hellwig 已提交
7267
	.hw_scan = iwl3945_mac_hw_scan
Z
Zhu Yi 已提交
7268 7269
};

7270
static int iwl3945_init_drv(struct iwl_priv *priv)
7271 7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324 7325
{
	int ret;

	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;

	iwl_reset_qos(priv);

	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;

	ret = iwl3945_init_channel_map(priv);
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

	ret = iwl3945_init_geos(priv);
	if (ret) {
		IWL_ERR(priv, "initializing geos failed: %d\n", ret);
		goto err_free_channel_map;
	}

	return 0;

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

C
Christoph Hellwig 已提交
7326
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
7327 7328
{
	int err = 0;
7329
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
7330
	struct ieee80211_hw *hw;
7331
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
7332
	unsigned long flags;
Z
Zhu Yi 已提交
7333

7334 7335 7336 7337
	/***********************
	 * 1. Allocating HW data
	 * ********************/

Z
Zhu Yi 已提交
7338 7339
	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
7340
	hw = iwl_alloc_all(cfg, &iwl3945_hw_ops);
Z
Zhu Yi 已提交
7341
	if (hw == NULL) {
7342
		printk(KERN_ERR DRV_NAME "Can not allocate network device\n");
Z
Zhu Yi 已提交
7343 7344 7345 7346
		err = -ENOMEM;
		goto out;
	}
	priv = hw->priv;
7347
	SET_IEEE80211_DEV(hw, &pdev->dev);
7348

7349 7350
	if ((iwl3945_mod_params.num_of_queues > IWL39_MAX_NUM_QUEUES) ||
	     (iwl3945_mod_params.num_of_queues < IWL_MIN_NUM_QUEUES)) {
7351 7352 7353
		IWL_ERR(priv,
			"invalid queues_num, should be between %d and %d\n",
			IWL_MIN_NUM_QUEUES, IWL39_MAX_NUM_QUEUES);
7354 7355 7356 7357
		err = -EINVAL;
		goto out;
	}

7358 7359 7360 7361
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
7362
	if (iwl3945_mod_params.disable_hw_scan) {
7363 7364 7365 7366
		IWL_DEBUG_INFO("Disabling hw_scan\n");
		iwl3945_hw_ops.hw_scan = NULL;
	}

7367

7368
	IWL_DEBUG_INFO("*** LOAD DRIVER ***\n");
7369 7370
	priv->cfg = cfg;
	priv->pci_dev = pdev;
7371

7372
#ifdef CONFIG_IWL3945_DEBUG
7373
	priv->debug_level = iwl3945_mod_params.debug;
Z
Zhu Yi 已提交
7374 7375
	atomic_set(&priv->restrict_refcnt, 0);
#endif
7376 7377 7378 7379 7380
	hw->rate_control_algorithm = "iwl-3945-rs";
	hw->sta_data_size = sizeof(struct iwl3945_sta_priv);

	/* Select antenna (may be helpful if only one antenna is connected) */
	priv->antenna = (enum iwl3945_antenna)iwl3945_mod_params.antenna;
Z
Zhu Yi 已提交
7381

7382
	/* Tell mac80211 our characteristics */
7383
	hw->flags = IEEE80211_HW_SIGNAL_DBM |
7384
		    IEEE80211_HW_NOISE_DBM;
Z
Zhu Yi 已提交
7385

7386 7387 7388 7389
	hw->wiphy->interface_modes =
		BIT(NL80211_IFTYPE_STATION) |
		BIT(NL80211_IFTYPE_ADHOC);

7390 7391
	hw->wiphy->fw_handles_regulatory = true;

7392
	/* 4 EDCA QOS priorities */
Z
Zhu Yi 已提交
7393 7394
	hw->queues = 4;

7395 7396 7397
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
7398 7399 7400 7401 7402 7403 7404 7405 7406 7407 7408
	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) {
T
Tomas Winkler 已提交
7409
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
7410 7411 7412 7413 7414 7415 7416
		goto out_pci_disable_device;
	}

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

7418 7419 7420
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
7421 7422 7423 7424 7425 7426 7427 7428 7429 7430
	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);

7431 7432 7433
	/* 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 已提交
7434

7435 7436
	/* amp init */
	err = priv->cfg->ops->lib->apm_ops.init(priv);
7437
	if (err < 0) {
7438 7439
		IWL_DEBUG_INFO("Failed to init APMG\n");
		goto out_iounmap;
7440
	}
Z
Zhu Yi 已提交
7441

7442 7443 7444
	/***********************
	 * 4. Read EEPROM
	 * ********************/
7445

7446 7447 7448
	/* Read the EEPROM */
	err = iwl3945_eeprom_init(priv);
	if (err) {
7449
		IWL_ERR(priv, "Unable to init EEPROM\n");
7450 7451 7452 7453 7454 7455
		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 已提交
7456

7457 7458 7459
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
7460
	/* Device-specific setup */
7461
	if (iwl3945_hw_set_hw_params(priv)) {
7462
		IWL_ERR(priv, "failed to set hw settings\n");
Z
Zhu Yi 已提交
7463 7464 7465
		goto out_iounmap;
	}

7466 7467 7468 7469
	/***********************
	 * 6. Setup priv
	 * ********************/

7470
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
7471
	if (err) {
7472 7473
		IWL_ERR(priv, "initializing driver failed\n");
		goto out_free_geos;
Z
Zhu Yi 已提交
7474 7475
	}

T
Tomas Winkler 已提交
7476 7477
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
7478 7479 7480 7481 7482 7483 7484

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

	/* Initialize module parameter values here */
	/* Disable radio (SW RF KILL) via parameter when loading driver */
7485
	if (iwl3945_mod_params.disable) {
7486 7487
		set_bit(STATUS_RF_KILL_SW, &priv->status);
		IWL_DEBUG_INFO("Radio disabled.\n");
7488 7489
	}

7490 7491 7492 7493 7494 7495 7496 7497 7498 7499

	/***********************
	 * 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);
7500
	if (err) {
7501
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
7502
		goto out_release_irq;
7503 7504
	}

7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518
	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
	 * *******************************/

7519 7520
	err = ieee80211_register_hw(priv->hw);
	if (err) {
7521
		IWL_ERR(priv, "Failed to register network device: %d\n", err);
7522
		goto  out_remove_sysfs;
7523
	}
Z
Zhu Yi 已提交
7524

7525 7526
	priv->hw->conf.beacon_int = 100;
	priv->mac80211_registered = 1;
7527

7528 7529
	err = iwl3945_rfkill_init(priv);
	if (err)
7530
		IWL_ERR(priv, "Unable to initialize RFKILL system. "
7531 7532
				  "Ignoring error: %d\n", err);

Z
Zhu Yi 已提交
7533 7534
	return 0;

7535 7536
 out_remove_sysfs:
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
7537 7538
 out_free_geos:
	iwl3945_free_geos(priv);
Z
Zhu Yi 已提交
7539 7540 7541 7542

 out_release_irq:
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
7543
	iwl3945_unset_hw_params(priv);
Z
Zhu Yi 已提交
7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557

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

7558
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
7559
{
7560
	struct iwl_priv *priv = pci_get_drvdata(pdev);
7561
	unsigned long flags;
Z
Zhu Yi 已提交
7562 7563 7564 7565 7566 7567 7568

	if (!priv)
		return;

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

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

7570 7571 7572 7573 7574 7575
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
7576

7577 7578 7579 7580 7581 7582 7583 7584 7585
	/* 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 已提交
7586
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
7587

7588
	iwl3945_rfkill_unregister(priv);
C
Christoph Hellwig 已提交
7589
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
7590 7591

	if (priv->rxq.bd)
7592
		iwl_rx_queue_free(priv, &priv->rxq);
C
Christoph Hellwig 已提交
7593
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
7594

7595
	iwl3945_unset_hw_params(priv);
C
Christoph Hellwig 已提交
7596
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
7597

7598 7599 7600
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
7601
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
7602 7603 7604 7605 7606 7607 7608 7609 7610 7611
	 * 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);

7612 7613
	iwl3945_free_channel_map(priv);
	iwl3945_free_geos(priv);
7614
	kfree(priv->scan39);
Z
Zhu Yi 已提交
7615 7616 7617 7618 7619 7620 7621 7622
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}

#ifdef CONFIG_PM

C
Christoph Hellwig 已提交
7623
static int iwl3945_pci_suspend(struct pci_dev *pdev, pm_message_t state)
Z
Zhu Yi 已提交
7624
{
7625
	struct iwl_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
7626

7627 7628 7629 7630 7631
	if (priv->is_open) {
		set_bit(STATUS_IN_SUSPEND, &priv->status);
		iwl3945_mac_stop(priv->hw);
		priv->is_open = 1;
	}
Z
Zhu Yi 已提交
7632 7633 7634 7635 7636 7637

	pci_set_power_state(pdev, PCI_D3hot);

	return 0;
}

C
Christoph Hellwig 已提交
7638
static int iwl3945_pci_resume(struct pci_dev *pdev)
Z
Zhu Yi 已提交
7639
{
7640
	struct iwl_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
7641 7642 7643

	pci_set_power_state(pdev, PCI_D0);

7644 7645
	if (priv->is_open)
		iwl3945_mac_start(priv->hw);
Z
Zhu Yi 已提交
7646

7647
	clear_bit(STATUS_IN_SUSPEND, &priv->status);
Z
Zhu Yi 已提交
7648 7649 7650 7651 7652
	return 0;
}

#endif /* CONFIG_PM */

7653
/*************** RFKILL FUNCTIONS **********/
7654
#ifdef CONFIG_IWL3945_RFKILL
7655 7656 7657
/* software rf-kill from user */
static int iwl3945_rfkill_soft_rf_kill(void *data, enum rfkill_state state)
{
7658
	struct iwl_priv *priv = data;
7659 7660
	int err = 0;

7661
	if (!priv->rfkill)
7662 7663 7664 7665 7666
	return 0;

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

T
Tomas Winkler 已提交
7667
	IWL_DEBUG_RF_KILL("we received soft RFKILL set to state %d\n", state);
7668 7669 7670
	mutex_lock(&priv->mutex);

	switch (state) {
7671
	case RFKILL_STATE_UNBLOCKED:
7672
		if (iwl_is_rfkill_hw(priv)) {
7673
			err = -EBUSY;
7674 7675 7676
			goto out_unlock;
		}
		iwl3945_radio_kill_sw(priv, 0);
7677
		break;
7678
	case RFKILL_STATE_SOFT_BLOCKED:
7679 7680
		iwl3945_radio_kill_sw(priv, 1);
		break;
7681
	default:
7682
		IWL_WARN(priv, "received unexpected RFKILL state %d\n", state);
7683
		break;
7684
	}
7685
out_unlock:
7686 7687 7688 7689 7690
	mutex_unlock(&priv->mutex);

	return err;
}

7691
int iwl3945_rfkill_init(struct iwl_priv *priv)
7692 7693 7694 7695 7696 7697 7698
{
	struct device *device = wiphy_dev(priv->hw->wiphy);
	int ret = 0;

	BUG_ON(device == NULL);

	IWL_DEBUG_RF_KILL("Initializing RFKILL.\n");
7699 7700
	priv->rfkill = rfkill_allocate(device, RFKILL_TYPE_WLAN);
	if (!priv->rfkill) {
7701
		IWL_ERR(priv, "Unable to allocate rfkill device.\n");
7702 7703 7704 7705
		ret = -ENOMEM;
		goto error;
	}

7706 7707 7708 7709 7710
	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;
7711

7712 7713
	priv->rfkill->dev.class->suspend = NULL;
	priv->rfkill->dev.class->resume = NULL;
7714

7715
	ret = rfkill_register(priv->rfkill);
7716
	if (ret) {
7717
		IWL_ERR(priv, "Unable to register rfkill: %d\n", ret);
7718
		goto freed_rfkill;
7719 7720 7721 7722 7723 7724
	}

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

freed_rfkill:
7725 7726 7727
	if (priv->rfkill != NULL)
		rfkill_free(priv->rfkill);
	priv->rfkill = NULL;
7728 7729 7730 7731 7732 7733

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

7734
void iwl3945_rfkill_unregister(struct iwl_priv *priv)
7735
{
7736 7737
	if (priv->rfkill)
		rfkill_unregister(priv->rfkill);
7738

7739
	priv->rfkill = NULL;
7740 7741 7742
}

/* set rf-kill to the right state. */
7743
void iwl3945_rfkill_set_hw_state(struct iwl_priv *priv)
7744 7745
{

7746 7747 7748
	if (!priv->rfkill)
		return;

7749
	if (iwl_is_rfkill_hw(priv)) {
7750
		rfkill_force_state(priv->rfkill, RFKILL_STATE_HARD_BLOCKED);
7751
		return;
7752
	}
7753

7754
	if (!iwl_is_rfkill_sw(priv))
7755
		rfkill_force_state(priv->rfkill, RFKILL_STATE_UNBLOCKED);
7756
	else
7757
		rfkill_force_state(priv->rfkill, RFKILL_STATE_SOFT_BLOCKED);
7758 7759 7760
}
#endif

Z
Zhu Yi 已提交
7761 7762 7763 7764 7765 7766
/*****************************************************************************
 *
 * driver and module entry point
 *
 *****************************************************************************/

C
Christoph Hellwig 已提交
7767
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
7768
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
7769 7770 7771
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
7772
#ifdef CONFIG_PM
C
Christoph Hellwig 已提交
7773 7774
	.suspend = iwl3945_pci_suspend,
	.resume = iwl3945_pci_resume,
Z
Zhu Yi 已提交
7775 7776 7777
#endif
};

C
Christoph Hellwig 已提交
7778
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
7779 7780 7781 7782 7783
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
7784 7785 7786

	ret = iwl3945_rate_control_register();
	if (ret) {
7787 7788
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
7789 7790 7791
		return ret;
	}

C
Christoph Hellwig 已提交
7792
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
7793
	if (ret) {
7794
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
7795
		goto error_register;
Z
Zhu Yi 已提交
7796 7797 7798
	}

	return ret;
7799 7800 7801 7802

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
7803 7804
}

C
Christoph Hellwig 已提交
7805
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
7806
{
C
Christoph Hellwig 已提交
7807
	pci_unregister_driver(&iwl3945_driver);
7808
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
7809 7810
}

7811
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
7812

7813
module_param_named(antenna, iwl3945_mod_params.antenna, int, 0444);
Z
Zhu Yi 已提交
7814
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
7815
module_param_named(disable, iwl3945_mod_params.disable, int, 0444);
Z
Zhu Yi 已提交
7816
MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
7817
module_param_named(hwcrypto, iwl3945_mod_params.sw_crypto, int, 0444);
Z
Zhu Yi 已提交
7818 7819
MODULE_PARM_DESC(hwcrypto,
		 "using hardware crypto engine (default 0 [software])\n");
7820
module_param_named(debug, iwl3945_mod_params.debug, uint, 0444);
Z
Zhu Yi 已提交
7821
MODULE_PARM_DESC(debug, "debug output mask");
7822
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
7823 7824
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

7825
module_param_named(queues_num, iwl3945_mod_params.num_of_queues, int, 0444);
Z
Zhu Yi 已提交
7826 7827
MODULE_PARM_DESC(queues_num, "number of hw queues.");

C
Christoph Hellwig 已提交
7828 7829
module_exit(iwl3945_exit);
module_init(iwl3945_init);