iwl3945-base.c 216.8 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
int iwl3945_x2_queue_used(const struct iwl_queue *q, int i)
Z
Zhu Yi 已提交
124
{
125 126 127
	return q->write_ptr > q->read_ptr ?
		(i >= q->read_ptr && i < q->write_ptr) :
		!(i < q->read_ptr && i >= q->write_ptr);
Z
Zhu Yi 已提交
128 129
}

130 131 132
/**
 * iwl3945_queue_init - Initialize queue's high/low-water and read/write indexes
 */
133
static int iwl3945_queue_init(struct iwl_priv *priv, struct iwl_queue *q,
Z
Zhu Yi 已提交
134 135 136 137 138 139
			  int count, int slots_num, u32 id)
{
	q->n_bd = count;
	q->n_window = slots_num;
	q->id = id;

T
Tomas Winkler 已提交
140 141
	/* count must be power-of-two size, otherwise iwl_queue_inc_wrap
	 * and iwl_queue_dec_wrap are broken. */
Z
Zhu Yi 已提交
142 143 144 145 146 147 148 149 150 151 152 153 154 155
	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;

156
	q->write_ptr = q->read_ptr = 0;
Z
Zhu Yi 已提交
157 158 159 160

	return 0;
}

161 162 163
/**
 * iwl3945_tx_queue_alloc - Alloc driver data and TFD CB for one Tx/cmd queue
 */
164
static int iwl3945_tx_queue_alloc(struct iwl_priv *priv,
165
			      struct iwl_tx_queue *txq, u32 id)
Z
Zhu Yi 已提交
166 167 168
{
	struct pci_dev *dev = priv->pci_dev;

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

182 183
	/* Circular buffer of transmit frame descriptors (TFDs),
	 * shared with device */
184 185
	txq->tfds39 = pci_alloc_consistent(dev,
			sizeof(txq->tfds39[0]) * TFD_QUEUE_SIZE_MAX,
Z
Zhu Yi 已提交
186 187
			&txq->q.dma_addr);

188
	if (!txq->tfds39) {
189
		IWL_ERR(priv, "pci_alloc_consistent(%zd) failed\n",
190
			  sizeof(txq->tfds39[0]) * TFD_QUEUE_SIZE_MAX);
Z
Zhu Yi 已提交
191 192 193 194 195 196 197
		goto error;
	}
	txq->q.id = id;

	return 0;

 error:
198 199
	kfree(txq->txb);
	txq->txb = NULL;
Z
Zhu Yi 已提交
200 201 202 203

	return -ENOMEM;
}

204 205 206
/**
 * iwl3945_tx_queue_init - Allocate and initialize one tx/cmd queue
 */
207
int iwl3945_tx_queue_init(struct iwl_priv *priv,
208
		      struct iwl_tx_queue *txq, int slots_num, u32 txq_id)
Z
Zhu Yi 已提交
209
{
210
	int len, i;
Z
Zhu Yi 已提交
211 212
	int rc = 0;

213 214 215 216 217 218 219 220
	/*
	 * 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.
	 */
221 222 223 224 225 226 227 228 229 230 231 232 233
	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 已提交
234

235
	/* Alloc driver data array and TFD circular buffer */
C
Christoph Hellwig 已提交
236
	rc = iwl3945_tx_queue_alloc(priv, txq, txq_id);
237 238
	if (rc)
		goto err;
Z
Zhu Yi 已提交
239 240 241 242

	txq->need_update = 0;

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

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

249
	/* Tell device where to find queue, enable DMA channel. */
C
Christoph Hellwig 已提交
250
	iwl3945_hw_tx_queue_init(priv, txq);
Z
Zhu Yi 已提交
251 252

	return 0;
253 254 255 256 257 258 259 260 261 262 263
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 已提交
264 265 266
}

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

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

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

288
	len = sizeof(struct iwl_cmd) * q->n_window;
Z
Zhu Yi 已提交
289 290 291
	if (q->id == IWL_CMD_QUEUE_NUM)
		len += IWL_MAX_SCAN_SIZE;

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

296
	/* De-alloc circular buffer of TFDs */
Z
Zhu Yi 已提交
297
	if (txq->q.n_bd)
W
Winkler, Tomas 已提交
298
		pci_free_consistent(dev, sizeof(struct iwl3945_tfd) *
299
				    txq->q.n_bd, txq->tfds39, txq->q.dma_addr);
Z
Zhu Yi 已提交
300

301
	/* De-alloc array of per-TFD driver data */
302 303
	kfree(txq->txb);
	txq->txb = NULL;
Z
Zhu Yi 已提交
304

305
	/* 0-fill queue descriptor structure */
Z
Zhu Yi 已提交
306 307 308 309
	memset(txq, 0, sizeof(*txq));
}

/*************** STATION TABLE MANAGEMENT ****
310
 * mac80211 should be examined to determine if sta_info is duplicating
Z
Zhu Yi 已提交
311 312 313 314
 * the functionality provided here
 */

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

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

345 346
	if (priv->stations_39[index].used) {
		priv->stations_39[index].used = 0;
Z
Zhu Yi 已提交
347 348 349 350 351 352 353 354 355
		priv->num_stations--;
	}

	BUG_ON(priv->num_stations < 0);

out:
	spin_unlock_irqrestore(&priv->sta_lock, flags);
	return 0;
}
356
#endif
357 358 359 360 361 362

/**
 * iwl3945_clear_stations_table - Clear the driver's station table
 *
 * NOTE:  This does not clear or otherwise alter the device's station table.
 */
363
static void iwl3945_clear_stations_table(struct iwl_priv *priv)
Z
Zhu Yi 已提交
364 365 366 367 368 369
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);

	priv->num_stations = 0;
370
	memset(priv->stations_39, 0, sizeof(priv->stations_39));
Z
Zhu Yi 已提交
371 372 373 374

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

375 376 377
/**
 * iwl3945_add_station - Add station to station tables in driver and device
 */
378
u8 iwl3945_add_station(struct iwl_priv *priv, const u8 *addr, int is_ap, u8 flags)
Z
Zhu Yi 已提交
379 380 381
{
	int i;
	int index = IWL_INVALID_STATION;
C
Christoph Hellwig 已提交
382
	struct iwl3945_station_entry *station;
Z
Zhu Yi 已提交
383
	unsigned long flags_spin;
384
	u8 rate;
Z
Zhu Yi 已提交
385 386 387 388 389

	spin_lock_irqsave(&priv->sta_lock, flags_spin);
	if (is_ap)
		index = IWL_AP_ID;
	else if (is_broadcast_ether_addr(addr))
390
		index = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
391
	else
392
		for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++) {
393
			if (!compare_ether_addr(priv->stations_39[i].sta.sta.addr,
Z
Zhu Yi 已提交
394 395 396 397 398
						addr)) {
				index = i;
				break;
			}

399
			if (!priv->stations_39[i].used &&
Z
Zhu Yi 已提交
400 401 402 403
			    index == IWL_INVALID_STATION)
				index = i;
		}

404
	/* These two conditions has the same outcome but keep them separate
Z
Zhu Yi 已提交
405 406 407 408 409 410
	  since they have different meaning */
	if (unlikely(index == IWL_INVALID_STATION)) {
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return index;
	}

411 412
	if (priv->stations_39[index].used &&
	   !compare_ether_addr(priv->stations_39[index].sta.sta.addr, addr)) {
Z
Zhu Yi 已提交
413 414 415 416
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return index;
	}

J
Johannes Berg 已提交
417
	IWL_DEBUG_ASSOC("Add STA ID %d: %pM\n", index, addr);
418
	station = &priv->stations_39[index];
Z
Zhu Yi 已提交
419 420 421
	station->used = 1;
	priv->num_stations++;

422
	/* Set up the REPLY_ADD_STA command to send to device */
C
Christoph Hellwig 已提交
423
	memset(&station->sta, 0, sizeof(struct iwl3945_addsta_cmd));
Z
Zhu Yi 已提交
424 425 426 427 428
	memcpy(station->sta.sta.addr, addr, ETH_ALEN);
	station->sta.mode = 0;
	station->sta.sta.sta_id = index;
	station->sta.station_flags = 0;

429
	if (priv->band == IEEE80211_BAND_5GHZ)
430 431 432
		rate = IWL_RATE_6M_PLCP;
	else
		rate =	IWL_RATE_1M_PLCP;
433 434 435

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

Z
Zhu Yi 已提交
438
	spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
439 440

	/* Add station to device's station table */
C
Christoph Hellwig 已提交
441
	iwl3945_send_add_station(priv, &station->sta, flags);
Z
Zhu Yi 已提交
442 443 444 445 446 447 448
	return index;

}


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

449
#define IWL_CMD(x) case x: return #x
Z
Zhu Yi 已提交
450 451 452
#define HOST_COMPLETE_TIMEOUT (HZ / 2)

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

480

481
	if (iwl_is_rfkill(priv)) {
482 483 484 485
		IWL_DEBUG_INFO("Not sending command - RF KILL");
		return -EIO;
	}

486
	if (iwl_queue_space(q) < ((cmd->meta.flags & CMD_ASYNC) ? 2 : 1)) {
487
		IWL_ERR(priv, "No space for Tx\n");
Z
Zhu Yi 已提交
488 489 490 491 492
		return -ENOSPC;
	}

	spin_lock_irqsave(&priv->hcmd_lock, flags);

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

496
	idx = get_cmd_index(q, q->write_ptr, cmd->meta.flags & CMD_SIZE_HUGE);
497
	out_cmd = txq->cmd[idx];
Z
Zhu Yi 已提交
498 499 500 501 502 503 504 505 506 507

	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) |
508
			INDEX_TO_SEQ(q->write_ptr));
Z
Zhu Yi 已提交
509
	if (out_cmd->meta.flags & CMD_SIZE_HUGE)
510
		out_cmd->hdr.sequence |= SEQ_HUGE_FRAME;
Z
Zhu Yi 已提交
511

512 513 514 515 516 517 518 519 520
	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 已提交
521
	iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, phys_addr, fix_size);
Z
Zhu Yi 已提交
522 523

	pad = U32_PAD(cmd->len);
W
Winkler, Tomas 已提交
524
	tfd->control_flags |= cpu_to_le32(TFD_CTL_PAD_SET(pad));
Z
Zhu Yi 已提交
525 526 527 528 529

	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),
530
		     fix_size, q->write_ptr, idx, IWL_CMD_QUEUE_NUM);
Z
Zhu Yi 已提交
531 532

	txq->need_update = 1;
533 534

	/* Increment and update queue's write index */
T
Tomas Winkler 已提交
535
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
C
Christoph Hellwig 已提交
536
	ret = iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
537 538 539 540 541

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

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

568 569
static int iwl3945_send_cmd_sync(struct iwl_priv *priv,
				 struct iwl_host_cmd *cmd)
Z
Zhu Yi 已提交
570 571 572 573 574 575 576 577 578
{
	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);

579
	if (test_and_set_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status)) {
580 581 582
		IWL_ERR(priv,
			"Error sending %s: Already sending a host command\n",
			get_cmd_string(cmd->id));
583 584
		ret = -EBUSY;
		goto out;
Z
Zhu Yi 已提交
585 586 587 588 589 590 591
	}

	set_bit(STATUS_HCMD_ACTIVE, &priv->status);

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

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

	ret = 0;
	goto out;

cancel:
	if (cmd->meta.flags & CMD_WANT_SKB) {
640
		struct iwl_cmd *qcmd;
Z
Zhu Yi 已提交
641 642 643 644 645

		/* 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). */
646
		qcmd = priv->txq[IWL_CMD_QUEUE_NUM].cmd[cmd_idx];
Z
Zhu Yi 已提交
647 648 649 650 651 652 653 654
		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:
655
	clear_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status);
Z
Zhu Yi 已提交
656 657 658
	return ret;
}

659
int iwl3945_send_cmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
Z
Zhu Yi 已提交
660 661
{
	if (cmd->meta.flags & CMD_ASYNC)
C
Christoph Hellwig 已提交
662
		return iwl3945_send_cmd_async(priv, cmd);
Z
Zhu Yi 已提交
663

C
Christoph Hellwig 已提交
664
	return iwl3945_send_cmd_sync(priv, cmd);
Z
Zhu Yi 已提交
665 666
}

667
int iwl3945_send_cmd_pdu(struct iwl_priv *priv, u8 id, u16 len, const void *data)
Z
Zhu Yi 已提交
668
{
669
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
670 671 672 673 674
		.id = id,
		.len = len,
		.data = data,
	};

C
Christoph Hellwig 已提交
675
	return iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
676 677
}

678
static int __must_check iwl3945_send_cmd_u32(struct iwl_priv *priv, u8 id, u32 val)
Z
Zhu Yi 已提交
679
{
680
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
681 682 683 684 685
		.id = id,
		.len = sizeof(val),
		.data = &val,
	};

C
Christoph Hellwig 已提交
686
	return iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
687 688
}

689
int iwl3945_send_statistics_request(struct iwl_priv *priv)
Z
Zhu Yi 已提交
690
{
C
Christoph Hellwig 已提交
691
	return iwl3945_send_cmd_u32(priv, REPLY_STATISTICS_CMD, 0);
Z
Zhu Yi 已提交
692 693 694
}

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

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

714
	if ((le16_to_cpu(priv->staging39_rxon.channel) == channel) &&
715
	    (priv->band == band))
Z
Zhu Yi 已提交
716 717
		return 0;

718
	priv->staging39_rxon.channel = cpu_to_le16(channel);
719
	if (band == IEEE80211_BAND_5GHZ)
720
		priv->staging39_rxon.flags &= ~RXON_FLG_BAND_24G_MSK;
Z
Zhu Yi 已提交
721
	else
722
		priv->staging39_rxon.flags |= RXON_FLG_BAND_24G_MSK;
Z
Zhu Yi 已提交
723

724
	priv->band = band;
Z
Zhu Yi 已提交
725

726
	IWL_DEBUG_INFO("Staging channel set to %d [%d]\n", channel, band);
Z
Zhu Yi 已提交
727 728 729 730 731

	return 0;
}

/**
C
Christoph Hellwig 已提交
732
 * iwl3945_check_rxon_cmd - validate RXON structure is valid
Z
Zhu Yi 已提交
733 734 735 736 737
 *
 * 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
 */
738
static int iwl3945_check_rxon_cmd(struct iwl_priv *priv)
Z
Zhu Yi 已提交
739 740 741
{
	int error = 0;
	int counter = 1;
742
	struct iwl3945_rxon_cmd *rxon = &priv->staging39_rxon;
Z
Zhu Yi 已提交
743 744 745 746 747 748

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

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

	error |= (le16_to_cpu(rxon->assoc_id) > 2007);
	if (error)
774
		IWL_WARN(priv, "check assoc id %d | %d\n", counter++, error);
Z
Zhu Yi 已提交
775 776 777 778

	error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK))
			== (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK));
	if (error)
779
		IWL_WARN(priv, "check CCK and short slot %d | %d\n",
Z
Zhu Yi 已提交
780 781 782 783 784
			    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)
785
		IWL_WARN(priv, "check CCK & auto detect %d | %d\n",
Z
Zhu Yi 已提交
786 787 788 789 790
			    counter++, error);

	error |= ((rxon->flags & (RXON_FLG_AUTO_DETECT_MSK |
			RXON_FLG_TGG_PROTECT_MSK)) == RXON_FLG_TGG_PROTECT_MSK);
	if (error)
791
		IWL_WARN(priv, "check TGG and auto detect %d | %d\n",
Z
Zhu Yi 已提交
792 793 794 795 796 797
			    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)
798
		IWL_WARN(priv, "check antenna %d %d\n", counter++, error);
Z
Zhu Yi 已提交
799 800

	if (error)
801
		IWL_WARN(priv, "Tuning to channel %d\n",
Z
Zhu Yi 已提交
802 803 804
			    le16_to_cpu(rxon->channel));

	if (error) {
805
		IWL_ERR(priv, "Not a valid rxon_assoc_cmd field values\n");
Z
Zhu Yi 已提交
806 807 808 809 810 811
		return -1;
	}
	return 0;
}

/**
812
 * iwl3945_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
813
 * @priv: staging_rxon is compared to active_rxon
Z
Zhu Yi 已提交
814
 *
815 816 817
 * 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 已提交
818
 */
819
static int iwl3945_full_rxon_required(struct iwl_priv *priv)
Z
Zhu Yi 已提交
820 821 822
{

	/* These items are only settable from the full RXON command */
823
	if (!(iwl3945_is_associated(priv)) ||
824 825 826 827 828 829 830 831 832 833 834
	    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 已提交
835 836 837 838 839 840 841
		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 */
842 843
	if ((priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK) !=
	    (priv->active39_rxon.flags & RXON_FLG_BAND_24G_MSK))
Z
Zhu Yi 已提交
844 845 846
		return 1;

	/* Check if we are switching association toggle */
847 848
	if ((priv->staging39_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) !=
		(priv->active39_rxon.filter_flags & RXON_FILTER_ASSOC_MSK))
Z
Zhu Yi 已提交
849 850 851 852 853
		return 1;

	return 0;
}

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

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

876 877 878 879
	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 已提交
880 881
	rxon_assoc.reserved = 0;

C
Christoph Hellwig 已提交
882
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
883 884 885
	if (rc)
		return rc;

886
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
887
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
888
		IWL_ERR(priv, "Bad return from REPLY_RXON_ASSOC command\n");
Z
Zhu Yi 已提交
889 890 891 892 893 894 895 896 897 898
		rc = -EIO;
	}

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

	return rc;
}

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

912
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
913 914 915
		return -1;

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

	/* select antenna */
919
	priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
920
	    ~(RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_SEL_MSK);
921
	priv->staging39_rxon.flags |= iwl3945_get_antenna_flags(priv);
Z
Zhu Yi 已提交
922

923
	rc = iwl3945_check_rxon_cmd(priv);
Z
Zhu Yi 已提交
924
	if (rc) {
925
		IWL_ERR(priv, "Invalid RXON configuration.  Not committing.\n");
Z
Zhu Yi 已提交
926 927 928 929
		return -EINVAL;
	}

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

940
		memcpy(active_rxon, &priv->staging39_rxon, sizeof(*active_rxon));
Z
Zhu Yi 已提交
941 942 943 944 945 946 947 948

		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 已提交
949
	if (iwl3945_is_associated(priv) &&
950
	    (priv->staging39_rxon.filter_flags & RXON_FILTER_ASSOC_MSK)) {
Z
Zhu Yi 已提交
951 952 953
		IWL_DEBUG_INFO("Toggling associated bit on current RXON\n");
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;

C
Christoph Hellwig 已提交
954 955
		rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON,
				      sizeof(struct iwl3945_rxon_cmd),
956
				      &priv->active39_rxon);
Z
Zhu Yi 已提交
957 958 959 960 961

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

	/* Apply the new configuration */
C
Christoph Hellwig 已提交
978
	rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON,
979
			      sizeof(struct iwl3945_rxon_cmd), &priv->staging39_rxon);
Z
Zhu Yi 已提交
980
	if (rc) {
981
		IWL_ERR(priv, "Error setting new configuration (%d).\n", rc);
Z
Zhu Yi 已提交
982 983 984
		return rc;
	}

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

C
Christoph Hellwig 已提交
987
	iwl3945_clear_stations_table(priv);
988

Z
Zhu Yi 已提交
989 990
	/* 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 已提交
991
	rc = iwl3945_hw_reg_send_txpower(priv);
Z
Zhu Yi 已提交
992
	if (rc) {
993
		IWL_ERR(priv, "Error setting Tx power (%d).\n", rc);
Z
Zhu Yi 已提交
994 995 996 997
		return rc;
	}

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

1014
	/* Init the hardware's rate fallback order based on the band */
Z
Zhu Yi 已提交
1015 1016
	rc = iwl3945_init_hw_rate_table(priv);
	if (rc) {
1017
		IWL_ERR(priv, "Error setting HW rate table: %02X\n", rc);
Z
Zhu Yi 已提交
1018 1019 1020 1021 1022 1023
		return -EIO;
	}

	return 0;
}

1024
static int iwl3945_send_bt_config(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1025
{
1026
	struct iwl_bt_cmd bt_cmd = {
Z
Zhu Yi 已提交
1027 1028 1029 1030 1031 1032 1033
		.flags = 3,
		.lead_time = 0xAA,
		.max_kill = 1,
		.kill_ack_mask = 0,
		.kill_cts_mask = 0,
	};

C
Christoph Hellwig 已提交
1034
	return iwl3945_send_cmd_pdu(priv, REPLY_BT_CONFIG,
1035
					sizeof(bt_cmd), &bt_cmd);
Z
Zhu Yi 已提交
1036 1037
}

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

1061
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078
	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;
}

1079
static int iwl3945_add_sta_sync_callback(struct iwl_priv *priv,
1080
				     struct iwl_cmd *cmd, struct sk_buff *skb)
Z
Zhu Yi 已提交
1081
{
1082
	struct iwl_rx_packet *res = NULL;
Z
Zhu Yi 已提交
1083 1084

	if (!skb) {
1085
		IWL_ERR(priv, "Error: Response NULL in REPLY_ADD_STA.\n");
Z
Zhu Yi 已提交
1086 1087 1088
		return 1;
	}

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

1107
int iwl3945_send_add_station(struct iwl_priv *priv,
C
Christoph Hellwig 已提交
1108
			 struct iwl3945_addsta_cmd *sta, u8 flags)
Z
Zhu Yi 已提交
1109
{
1110
	struct iwl_rx_packet *res = NULL;
Z
Zhu Yi 已提交
1111
	int rc = 0;
1112
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
1113
		.id = REPLY_ADD_STA,
C
Christoph Hellwig 已提交
1114
		.len = sizeof(struct iwl3945_addsta_cmd),
Z
Zhu Yi 已提交
1115 1116 1117 1118 1119
		.meta.flags = flags,
		.data = sta,
	};

	if (flags & CMD_ASYNC)
C
Christoph Hellwig 已提交
1120
		cmd.meta.u.callback = iwl3945_add_sta_sync_callback;
Z
Zhu Yi 已提交
1121 1122 1123
	else
		cmd.meta.flags |= CMD_WANT_SKB;

C
Christoph Hellwig 已提交
1124
	rc = iwl3945_send_cmd(priv, &cmd);
Z
Zhu Yi 已提交
1125 1126 1127 1128

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

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

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

	return rc;
}

1154
static int iwl3945_update_sta_key_info(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
				   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);
1174 1175 1176
	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 已提交
1177 1178
	       keyconf->keylen);

1179
	memcpy(priv->stations_39[sta_id].sta.key.key, keyconf->key,
Z
Zhu Yi 已提交
1180
	       keyconf->keylen);
1181 1182 1183
	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 已提交
1184 1185 1186 1187

	spin_unlock_irqrestore(&priv->sta_lock, flags);

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

1192
static int iwl3945_clear_sta_key_info(struct iwl_priv *priv, u8 sta_id)
Z
Zhu Yi 已提交
1193 1194 1195 1196
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);
1197 1198
	memset(&priv->stations_39[sta_id].keyinfo, 0, sizeof(struct iwl3945_hw_key));
	memset(&priv->stations_39[sta_id].sta.key, 0,
1199
		sizeof(struct iwl4965_keyinfo));
1200 1201 1202
	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 已提交
1203 1204 1205
	spin_unlock_irqrestore(&priv->sta_lock, flags);

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

1210
static void iwl3945_clear_free_frames(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1211 1212 1213 1214 1215 1216 1217 1218 1219
{
	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 已提交
1220
		kfree(list_entry(element, struct iwl3945_frame, list));
Z
Zhu Yi 已提交
1221 1222 1223 1224
		priv->frames_count--;
	}

	if (priv->frames_count) {
1225
		IWL_WARN(priv, "%d frames still in use.  Did we lose one?\n",
Z
Zhu Yi 已提交
1226 1227 1228 1229 1230
			    priv->frames_count);
		priv->frames_count = 0;
	}
}

1231
static struct iwl3945_frame *iwl3945_get_free_frame(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1232
{
C
Christoph Hellwig 已提交
1233
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
1234 1235 1236 1237
	struct list_head *element;
	if (list_empty(&priv->free_frames)) {
		frame = kzalloc(sizeof(*frame), GFP_KERNEL);
		if (!frame) {
1238
			IWL_ERR(priv, "Could not allocate frame!\n");
Z
Zhu Yi 已提交
1239 1240 1241 1242 1243 1244 1245 1246 1247
			return NULL;
		}

		priv->frames_count++;
		return frame;
	}

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

1251
static void iwl3945_free_frame(struct iwl_priv *priv, struct iwl3945_frame *frame)
Z
Zhu Yi 已提交
1252 1253 1254 1255 1256
{
	memset(frame, 0, sizeof(*frame));
	list_add(&frame->list, &priv->free_frames);
}

1257
unsigned int iwl3945_fill_beacon_frame(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1258
				struct ieee80211_hdr *hdr,
1259
				int left)
Z
Zhu Yi 已提交
1260 1261
{

C
Christoph Hellwig 已提交
1262
	if (!iwl3945_is_associated(priv) || !priv->ibss_beacon ||
1263 1264
	    ((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
	     (priv->iw_mode != NL80211_IFTYPE_AP)))
Z
Zhu Yi 已提交
1265 1266 1267 1268 1269 1270 1271 1272 1273 1274
		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;
}

1275
static u8 iwl3945_rate_get_lowest_plcp(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1276 1277
{
	u8 i;
1278 1279 1280
	int rate_mask;

	/* Set rate mask*/
1281
	if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK)
1282
		rate_mask = priv->active_rate_basic & IWL_CCK_RATES_MASK;
1283
	else
1284
		rate_mask = priv->active_rate_basic & IWL_OFDM_RATES_MASK;
Z
Zhu Yi 已提交
1285 1286

	for (i = IWL_RATE_1M_INDEX; i != IWL_RATE_INVALID;
C
Christoph Hellwig 已提交
1287
	     i = iwl3945_rates[i].next_ieee) {
Z
Zhu Yi 已提交
1288
		if (rate_mask & (1 << i))
C
Christoph Hellwig 已提交
1289
			return iwl3945_rates[i].plcp;
Z
Zhu Yi 已提交
1290 1291
	}

1292
	/* No valid rate was found. Assign the lowest one */
1293
	if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK)
1294 1295 1296
		return IWL_RATE_1M_PLCP;
	else
		return IWL_RATE_6M_PLCP;
Z
Zhu Yi 已提交
1297 1298
}

1299
static int iwl3945_send_beacon_cmd(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1300
{
C
Christoph Hellwig 已提交
1301
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
1302 1303 1304 1305
	unsigned int frame_size;
	int rc;
	u8 rate;

C
Christoph Hellwig 已提交
1306
	frame = iwl3945_get_free_frame(priv);
Z
Zhu Yi 已提交
1307 1308

	if (!frame) {
1309
		IWL_ERR(priv, "Could not obtain free frame buffer for beacon "
Z
Zhu Yi 已提交
1310 1311 1312 1313
			  "command.\n");
		return -ENOMEM;
	}

1314
	rate = iwl3945_rate_get_lowest_plcp(priv);
Z
Zhu Yi 已提交
1315

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

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

C
Christoph Hellwig 已提交
1321
	iwl3945_free_frame(priv, frame);
Z
Zhu Yi 已提交
1322 1323 1324 1325 1326 1327 1328 1329 1330 1331

	return rc;
}

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

1332
static void get_eeprom_mac(struct iwl_priv *priv, u8 *mac)
Z
Zhu Yi 已提交
1333
{
1334
	memcpy(mac, priv->eeprom39.mac_address, 6);
Z
Zhu Yi 已提交
1335 1336
}

1337 1338 1339 1340 1341 1342 1343 1344
/*
 * 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!).
 */
1345
static inline int iwl3945_eeprom_acquire_semaphore(struct iwl_priv *priv)
1346
{
1347
	_iwl_clear_bit(priv, CSR_EEPROM_GP, CSR_EEPROM_GP_IF_OWNER_MSK);
1348 1349 1350
	return 0;
}

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

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

1377
	/* Make sure driver (instead of uCode) is allowed to read EEPROM */
1378 1379
	ret = iwl3945_eeprom_acquire_semaphore(priv);
	if (ret < 0) {
1380
		IWL_ERR(priv, "Failed to acquire EEPROM semaphore.\n");
Z
Zhu Yi 已提交
1381 1382 1383 1384 1385
		return -ENOENT;
	}

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

1388
		_iwl_write32(priv, CSR_EEPROM_REG,
1389
				 CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
1390 1391
		_iwl_clear_bit(priv, CSR_EEPROM_REG, CSR_EEPROM_REG_BIT_CMD);
		ret = iwl_poll_direct_bit(priv, CSR_EEPROM_REG,
1392 1393 1394
					      CSR_EEPROM_REG_READ_VALID_MSK,
					      IWL_EEPROM_ACCESS_TIMEOUT);
		if (ret < 0) {
1395
			IWL_ERR(priv, "Time out reading EEPROM[%d]\n", addr);
1396
			return ret;
Z
Zhu Yi 已提交
1397
		}
1398

1399
		r = _iwl_read_direct32(priv, CSR_EEPROM_REG);
1400
		e[addr / 2] = le16_to_cpu((__force __le16)(r >> 16));
Z
Zhu Yi 已提交
1401 1402 1403 1404 1405
	}

	return 0;
}

1406
static void iwl3945_unset_hw_params(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1407
{
1408
	if (priv->shared_virt)
Z
Zhu Yi 已提交
1409
		pci_free_consistent(priv->pci_dev,
C
Christoph Hellwig 已提交
1410
				    sizeof(struct iwl3945_shared),
1411 1412
				    priv->shared_virt,
				    priv->shared_phys);
Z
Zhu Yi 已提交
1413 1414 1415
}

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

	for (bit = 1, i = 0; i < IWL_RATE_COUNT; i++, bit <<= 1) {
		if (bit & supported_rate) {
			ret_rates |= bit;
C
Christoph Hellwig 已提交
1431
			rates[*cnt] = iwl3945_rates[i].ieee |
1432 1433 1434 1435 1436
				((bit & basic_rate) ? 0x80 : 0x00);
			(*cnt)++;
			(*left)--;
			if ((*left <= 0) ||
			    (*cnt >= IWL_SUPPORTED_RATES_IE_LEN))
Z
Zhu Yi 已提交
1437 1438 1439 1440 1441 1442 1443 1444
				break;
		}
	}

	return ret_rates;
}

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

	/* 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);
1463
	memcpy(frame->da, iwl_bcast_addr, ETH_ALEN);
Z
Zhu Yi 已提交
1464
	memcpy(frame->sa, priv->mac_addr, ETH_ALEN);
1465
	memcpy(frame->bssid, iwl_bcast_addr, ETH_ALEN);
Z
Zhu Yi 已提交
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
	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;
1484

Z
Zhu Yi 已提交
1485 1486 1487
	/* ... fill it in... */
	*pos++ = WLAN_EID_SUPP_RATES;
	*pos = 0;
1488 1489 1490

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

1493
	cck_rates = IWL_CCK_RATES_MASK & active_rates;
C
Christoph Hellwig 已提交
1494
	ret_rates = iwl3945_supported_rate_to_ie(pos, cck_rates,
1495 1496 1497
			priv->active_rate_basic, &left);
	active_rates &= ~ret_rates;

C
Christoph Hellwig 已提交
1498
	ret_rates = iwl3945_supported_rate_to_ie(pos, active_rates,
1499 1500 1501
				 priv->active_rate_basic, &left);
	active_rates &= ~ret_rates;

Z
Zhu Yi 已提交
1502 1503
	len += 2 + *pos;
	pos += (*pos) + 1;
1504
	if (active_rates == 0)
Z
Zhu Yi 已提交
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
		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 已提交
1515
	iwl3945_supported_rate_to_ie(pos, active_rates,
1516
				 priv->active_rate_basic, &left);
Z
Zhu Yi 已提交
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
	if (*pos > 0)
		len += 2 + *pos;

 fill_end:
	return (u16)len;
}

/*
 * QoS  support
*/
1527
static int iwl3945_send_qos_params_command(struct iwl_priv *priv,
1528
				       struct iwl_qosparam_cmd *qos)
Z
Zhu Yi 已提交
1529 1530
{

C
Christoph Hellwig 已提交
1531
	return iwl3945_send_cmd_pdu(priv, REPLY_QOS_PARAM,
1532
				sizeof(struct iwl_qosparam_cmd), qos);
Z
Zhu Yi 已提交
1533 1534
}

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

C
Christoph Hellwig 已提交
1560
		iwl3945_send_qos_params_command(priv,
Z
Zhu Yi 已提交
1561 1562 1563 1564 1565 1566 1567 1568 1569
				&(priv->qos_data.def_qos_parm));
	}
}

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

1570 1571 1572

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

1605
int iwl3945_power_init_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1606 1607
{
	int rc = 0, i;
C
Christoph Hellwig 已提交
1608
	struct iwl3945_power_mgr *pow_data;
1609
	int size = sizeof(struct iwl_power_vec_entry) * IWL39_POWER_AC;
Z
Zhu Yi 已提交
1610 1611 1612 1613
	u16 pci_pm;

	IWL_DEBUG_POWER("Initialize power \n");

1614
	pow_data = &(priv->power_data_39);
Z
Zhu Yi 已提交
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627

	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 {
1628
		struct iwl_powertable_cmd *cmd;
Z
Zhu Yi 已提交
1629 1630 1631

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

1632
		for (i = 0; i < IWL39_POWER_AC; i++) {
Z
Zhu Yi 已提交
1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
			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;
}

1644
static int iwl3945_update_power_cmd(struct iwl_priv *priv,
1645
				struct iwl_powertable_cmd *cmd, u32 mode)
Z
Zhu Yi 已提交
1646 1647 1648 1649
{
	int rc = 0, i;
	u8 skip;
	u32 max_sleep = 0;
1650
	struct iwl_power_vec_entry *range;
Z
Zhu Yi 已提交
1651
	u8 period = 0;
C
Christoph Hellwig 已提交
1652
	struct iwl3945_power_mgr *pow_data;
Z
Zhu Yi 已提交
1653 1654 1655 1656 1657

	if (mode > IWL_POWER_INDEX_5) {
		IWL_DEBUG_POWER("Error invalid power mode \n");
		return -1;
	}
1658
	pow_data = &(priv->power_data_39);
Z
Zhu Yi 已提交
1659 1660 1661 1662 1663 1664

	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 已提交
1665
	memcpy(cmd, &range[mode].cmd, sizeof(struct iwl3945_powertable_cmd));
Z
Zhu Yi 已提交
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 1701 1702 1703 1704 1705 1706 1707

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

1708
static int iwl3945_send_power_mode(struct iwl_priv *priv, u32 mode)
Z
Zhu Yi 已提交
1709
{
1710
	u32 uninitialized_var(final_mode);
Z
Zhu Yi 已提交
1711
	int rc;
1712
	struct iwl_powertable_cmd cmd;
Z
Zhu Yi 已提交
1713 1714

	/* If on battery, set to 3,
1715
	 * if plugged into AC power, set to CAM ("continuously aware mode"),
Z
Zhu Yi 已提交
1716 1717
	 * else user level */
	switch (mode) {
1718
	case IWL39_POWER_BATTERY:
Z
Zhu Yi 已提交
1719 1720
		final_mode = IWL_POWER_INDEX_3;
		break;
1721
	case IWL39_POWER_AC:
Z
Zhu Yi 已提交
1722 1723 1724 1725 1726 1727 1728
		final_mode = IWL_POWER_MODE_CAM;
		break;
	default:
		final_mode = mode;
		break;
	}

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

1731 1732 1733
	/* 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 已提交
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743

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

C
Christoph Hellwig 已提交
1781
	ret = iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797
	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 已提交
1798
static __le16 iwl3945_adjust_beacon_interval(u16 beacon_val)
Z
Zhu Yi 已提交
1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810
{
	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);
}

1811
static void iwl3945_setup_rxon_timing(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
{
	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);
1822
	priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
Z
Zhu Yi 已提交
1823 1824
	priv->rxon_timing.listen_interval = INTEL_CONN_LISTEN_INTERVAL;

1825
	tsf = priv->timestamp;
Z
Zhu Yi 已提交
1826 1827 1828 1829

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

1830
	if (priv->iw_mode == NL80211_IFTYPE_STATION) {
Z
Zhu Yi 已提交
1831 1832 1833 1834 1835 1836 1837
		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 已提交
1838
			    iwl3945_adjust_beacon_interval(
Z
Zhu Yi 已提交
1839 1840 1841 1842 1843 1844
				le16_to_cpu(priv->rxon_timing.beacon_interval));
		}

		priv->rxon_timing.atim_window = 0;
	} else {
		priv->rxon_timing.beacon_interval =
C
Christoph Hellwig 已提交
1845
			iwl3945_adjust_beacon_interval(conf->beacon_int);
Z
Zhu Yi 已提交
1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
		/* 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));
}

1864
static int iwl3945_scan_initiate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1865
{
1866
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882
		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");
1883 1884 1885 1886
	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 已提交
1887 1888 1889 1890 1891 1892 1893 1894 1895
	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;
}

1896
static int iwl3945_set_rxon_hwcrypto(struct iwl_priv *priv, int hw_decrypt)
Z
Zhu Yi 已提交
1897
{
1898
	struct iwl3945_rxon_cmd *rxon = &priv->staging39_rxon;
Z
Zhu Yi 已提交
1899 1900 1901 1902 1903 1904 1905 1906 1907

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

	return 0;
}

1908
static void iwl3945_set_flags_for_phymode(struct iwl_priv *priv,
1909
					  enum ieee80211_band band)
Z
Zhu Yi 已提交
1910
{
1911
	if (band == IEEE80211_BAND_5GHZ) {
1912
		priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
1913 1914
		    ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
		      | RXON_FLG_CCK_MSK);
1915
		priv->staging39_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1916
	} else {
C
Christoph Hellwig 已提交
1917
		/* Copied from iwl3945_bg_post_associate() */
Z
Zhu Yi 已提交
1918
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
1919
			priv->staging39_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1920
		else
1921
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1922

1923
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
1924
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1925

1926 1927 1928
		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 已提交
1929 1930 1931 1932
	}
}

/*
1933
 * initialize rxon structure with default values from eeprom
Z
Zhu Yi 已提交
1934
 */
1935
static void iwl3945_connection_init_rx_config(struct iwl_priv *priv,
1936
					      int mode)
Z
Zhu Yi 已提交
1937
{
1938
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
1939

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

1942
	switch (mode) {
1943
	case NL80211_IFTYPE_AP:
1944
		priv->staging39_rxon.dev_type = RXON_DEV_TYPE_AP;
Z
Zhu Yi 已提交
1945 1946
		break;

1947
	case NL80211_IFTYPE_STATION:
1948 1949
		priv->staging39_rxon.dev_type = RXON_DEV_TYPE_ESS;
		priv->staging39_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
Z
Zhu Yi 已提交
1950 1951
		break;

1952
	case NL80211_IFTYPE_ADHOC:
1953 1954 1955
		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 已提交
1956 1957 1958
						  RXON_FILTER_ACCEPT_GRP_MSK;
		break;

1959
	case NL80211_IFTYPE_MONITOR:
1960 1961
		priv->staging39_rxon.dev_type = RXON_DEV_TYPE_SNIFFER;
		priv->staging39_rxon.filter_flags = RXON_FILTER_PROMISC_MSK |
Z
Zhu Yi 已提交
1962 1963
		    RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_ACCEPT_GRP_MSK;
		break;
1964
	default:
1965
		IWL_ERR(priv, "Unsupported interface type %d\n", mode);
1966
		break;
Z
Zhu Yi 已提交
1967 1968 1969 1970 1971 1972
	}

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

1978
	ch_info = iwl3945_get_channel_info(priv, priv->band,
1979
				       le16_to_cpu(priv->active39_rxon.channel));
Z
Zhu Yi 已提交
1980 1981 1982 1983 1984 1985 1986 1987

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

1991
	priv->staging39_rxon.channel = cpu_to_le16(ch_info->channel);
Z
Zhu Yi 已提交
1992
	if (is_channel_a_band(ch_info))
1993
		priv->band = IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
1994
	else
1995
		priv->band = IEEE80211_BAND_2GHZ;
Z
Zhu Yi 已提交
1996

1997
	iwl3945_set_flags_for_phymode(priv, priv->band);
Z
Zhu Yi 已提交
1998

1999
	priv->staging39_rxon.ofdm_basic_rates =
Z
Zhu Yi 已提交
2000
	    (IWL_OFDM_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
2001
	priv->staging39_rxon.cck_basic_rates =
Z
Zhu Yi 已提交
2002 2003 2004
	    (IWL_CCK_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
}

2005
static int iwl3945_set_mode(struct iwl_priv *priv, int mode)
Z
Zhu Yi 已提交
2006
{
2007
	if (mode == NL80211_IFTYPE_ADHOC) {
2008
		const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
2009

C
Christoph Hellwig 已提交
2010
		ch_info = iwl3945_get_channel_info(priv,
2011
			priv->band,
2012
			le16_to_cpu(priv->staging39_rxon.channel));
Z
Zhu Yi 已提交
2013 2014

		if (!ch_info || !is_channel_ibss(ch_info)) {
2015
			IWL_ERR(priv, "channel %d not IBSS channel\n",
2016
				  le16_to_cpu(priv->staging39_rxon.channel));
Z
Zhu Yi 已提交
2017 2018 2019 2020
			return -EINVAL;
		}
	}

2021
	iwl3945_connection_init_rx_config(priv, mode);
2022
	memcpy(priv->staging39_rxon.node_addr, priv->mac_addr, ETH_ALEN);
Z
Zhu Yi 已提交
2023

C
Christoph Hellwig 已提交
2024
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
2025

T
Tomas Winkler 已提交
2026
	/* don't commit rxon if rf-kill is on*/
2027
	if (!iwl_is_ready_rf(priv))
2028 2029 2030 2031
		return -EAGAIN;

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

C
Christoph Hellwig 已提交
2037
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
2038 2039 2040 2041

	return 0;
}

2042
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl_priv *priv,
2043
				      struct ieee80211_tx_info *info,
2044
				      struct iwl_cmd *cmd,
Z
Zhu Yi 已提交
2045 2046 2047
				      struct sk_buff *skb_frag,
				      int last_frag)
{
2048
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
2049
	struct iwl3945_hw_key *keyinfo =
2050
	    &priv->stations_39[info->control.hw_key->hw_key_idx].keyinfo;
Z
Zhu Yi 已提交
2051 2052 2053

	switch (keyinfo->alg) {
	case ALG_CCMP:
2054 2055
		tx->sec_ctl = TX_CMD_SEC_CCM;
		memcpy(tx->key, keyinfo->key, keyinfo->keylen);
T
Tomas Winkler 已提交
2056
		IWL_DEBUG_TX("tx_cmd with AES hwcrypto\n");
Z
Zhu Yi 已提交
2057 2058 2059 2060
		break;

	case ALG_TKIP:
#if 0
2061
		tx->sec_ctl = TX_CMD_SEC_TKIP;
Z
Zhu Yi 已提交
2062 2063

		if (last_frag)
2064
			memcpy(tx->tkip_mic.byte, skb_frag->tail - 8,
Z
Zhu Yi 已提交
2065 2066
			       8);
		else
2067
			memset(tx->tkip_mic.byte, 0, 8);
Z
Zhu Yi 已提交
2068 2069 2070 2071
#endif
		break;

	case ALG_WEP:
2072
		tx->sec_ctl = TX_CMD_SEC_WEP |
2073
		    (info->control.hw_key->hw_key_idx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT;
Z
Zhu Yi 已提交
2074 2075

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

2078
		memcpy(&tx->key[3], keyinfo->key, keyinfo->keylen);
Z
Zhu Yi 已提交
2079 2080

		IWL_DEBUG_TX("Configuring packet for WEP encryption "
2081
			     "with key %d\n", info->control.hw_key->hw_key_idx);
Z
Zhu Yi 已提交
2082 2083 2084
		break;

	default:
T
Tomas Winkler 已提交
2085
		IWL_ERR(priv, "Unknown encode alg %d\n", keyinfo->alg);
Z
Zhu Yi 已提交
2086 2087 2088 2089 2090 2091 2092
		break;
	}
}

/*
 * handle build REPLY_TX command notification.
 */
2093
static void iwl3945_build_tx_cmd_basic(struct iwl_priv *priv,
2094
				  struct iwl_cmd *cmd,
2095
				  struct ieee80211_tx_info *info,
2096
				  struct ieee80211_hdr *hdr, u8 std_id)
Z
Zhu Yi 已提交
2097
{
2098 2099
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
	__le32 tx_flags = tx->tx_flags;
2100
	__le16 fc = hdr->frame_control;
2101
	u8 rc_flags = info->control.rates[0].flags;
Z
Zhu Yi 已提交
2102

2103
	tx->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
2104
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Z
Zhu Yi 已提交
2105
		tx_flags |= TX_CMD_FLG_ACK_MSK;
2106
		if (ieee80211_is_mgmt(fc))
Z
Zhu Yi 已提交
2107
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
2108
		if (ieee80211_is_probe_resp(fc) &&
Z
Zhu Yi 已提交
2109 2110 2111 2112 2113 2114 2115
		    !(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;
	}

2116
	tx->sta_id = std_id;
2117
	if (ieee80211_has_morefrags(fc))
Z
Zhu Yi 已提交
2118 2119
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

2120 2121
	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
2122
		tx->tid_tspec = qc[0] & 0xf;
Z
Zhu Yi 已提交
2123
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
2124
	} else {
Z
Zhu Yi 已提交
2125
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
2126
	}
Z
Zhu Yi 已提交
2127

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

2152 2153 2154
	tx->driver_txop = 0;
	tx->tx_flags = tx_flags;
	tx->next_frame_len = 0;
Z
Zhu Yi 已提交
2155 2156
}

2157 2158 2159
/**
 * iwl3945_get_sta_id - Find station's index within station table
 */
2160
static int iwl3945_get_sta_id(struct iwl_priv *priv, struct ieee80211_hdr *hdr)
Z
Zhu Yi 已提交
2161 2162 2163 2164
{
	int sta_id;
	u16 fc = le16_to_cpu(hdr->frame_control);

2165
	/* If this frame is broadcast or management, use broadcast station id */
Z
Zhu Yi 已提交
2166 2167
	if (((fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA) ||
	    is_multicast_ether_addr(hdr->addr1))
2168
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
2169 2170 2171

	switch (priv->iw_mode) {

2172 2173
	/* If we are a client station in a BSS network, use the special
	 * AP station entry (that's the only station we communicate with) */
2174
	case NL80211_IFTYPE_STATION:
Z
Zhu Yi 已提交
2175 2176 2177
		return IWL_AP_ID;

	/* If we are an AP, then find the station, or use BCAST */
2178
	case NL80211_IFTYPE_AP:
C
Christoph Hellwig 已提交
2179
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
2180 2181
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;
2182
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
2183

2184 2185
	/* If this frame is going out to an IBSS network, find the station,
	 * or create a new station table entry */
2186
	case NL80211_IFTYPE_ADHOC: {
2187
		/* Create new station table entry */
C
Christoph Hellwig 已提交
2188
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
2189 2190 2191
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

C
Christoph Hellwig 已提交
2192
		sta_id = iwl3945_add_station(priv, hdr->addr1, 0, CMD_ASYNC);
Z
Zhu Yi 已提交
2193 2194 2195 2196

		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

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

Z
Zhu Yi 已提交
2208
	default:
2209 2210
		IWL_WARN(priv, "Unknown mode of operation: %d\n",
			priv->iw_mode);
2211
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
2212 2213 2214 2215 2216 2217
	}
}

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

	spin_lock_irqsave(&priv->lock, flags);
2243
	if (iwl_is_rfkill(priv)) {
Z
Zhu Yi 已提交
2244 2245 2246 2247
		IWL_DEBUG_DROP("Dropping - RF KILL\n");
		goto drop_unlock;
	}

2248
	if ((ieee80211_get_tx_rate(priv->hw, info)->hw_value & 0xFF) == IWL_INVALID_RATE) {
2249
		IWL_ERR(priv, "ERROR: No TX rate available.\n");
Z
Zhu Yi 已提交
2250 2251 2252 2253 2254 2255
		goto drop_unlock;
	}

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

2256
	fc = hdr->frame_control;
Z
Zhu Yi 已提交
2257

2258
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
2259 2260
	if (ieee80211_is_auth(fc))
		IWL_DEBUG_TX("Sending AUTH frame\n");
2261
	else if (ieee80211_is_assoc_req(fc))
Z
Zhu Yi 已提交
2262
		IWL_DEBUG_TX("Sending ASSOC frame\n");
2263
	else if (ieee80211_is_reassoc_req(fc))
Z
Zhu Yi 已提交
2264 2265 2266
		IWL_DEBUG_TX("Sending REASSOC frame\n");
#endif

2267
	/* drop all data frame if we are not associated */
2268
	if (ieee80211_is_data(fc) &&
2269
	    (priv->iw_mode != NL80211_IFTYPE_MONITOR) && /* packet injection */
2270
	    (!iwl3945_is_associated(priv) ||
2271
	     ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id))) {
C
Christoph Hellwig 已提交
2272
		IWL_DEBUG_DROP("Dropping - !iwl3945_is_associated\n");
Z
Zhu Yi 已提交
2273 2274 2275 2276 2277
		goto drop_unlock;
	}

	spin_unlock_irqrestore(&priv->lock, flags);

2278
	hdr_len = ieee80211_hdrlen(fc);
2279 2280

	/* Find (or create) index into station table for destination station */
C
Christoph Hellwig 已提交
2281
	sta_id = iwl3945_get_sta_id(priv, hdr);
Z
Zhu Yi 已提交
2282
	if (sta_id == IWL_INVALID_STATION) {
J
Johannes Berg 已提交
2283 2284
		IWL_DEBUG_DROP("Dropping - INVALID STATION: %pM\n",
			       hdr->addr1);
Z
Zhu Yi 已提交
2285 2286 2287 2288 2289
		goto drop;
	}

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

2290 2291
	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
2292
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
2293
		seq_number = priv->stations_39[sta_id].tid[tid].seq_number &
Z
Zhu Yi 已提交
2294 2295 2296 2297 2298 2299
				IEEE80211_SCTL_SEQ;
		hdr->seq_ctrl = cpu_to_le16(seq_number) |
			(hdr->seq_ctrl &
				__constant_cpu_to_le16(IEEE80211_SCTL_FRAG));
		seq_number += 0x10;
	}
2300 2301

	/* Descriptor for chosen Tx queue */
2302
	txq = &priv->txq[txq_id];
Z
Zhu Yi 已提交
2303 2304 2305 2306
	q = &txq->q;

	spin_lock_irqsave(&priv->lock, flags);

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

2312
	/* Set up driver data for this TFD */
W
Winkler, Tomas 已提交
2313
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl_tx_info));
2314
	txq->txb[q->write_ptr].skb[0] = skb;
2315 2316

	/* Init first empty entry in queue's array of Tx/cmd buffers */
2317
	out_cmd = txq->cmd[idx];
2318
	tx = (struct iwl3945_tx_cmd *)out_cmd->cmd.payload;
Z
Zhu Yi 已提交
2319
	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
2320
	memset(tx, 0, sizeof(*tx));
2321 2322 2323 2324 2325 2326 2327

	/*
	 * 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 已提交
2328 2329
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
2330
				INDEX_TO_SEQ(q->write_ptr)));
2331 2332

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

2335 2336 2337 2338 2339 2340 2341 2342 2343
	/*
	 * 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.
	 */
2344
	len = sizeof(struct iwl3945_tx_cmd) +
2345
			sizeof(struct iwl_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
2346 2347 2348 2349 2350 2351 2352 2353 2354

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

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

2355 2356
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
2357 2358 2359 2360 2361 2362 2363 2364
	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 已提交
2365

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

2370
	if (info->control.hw_key)
2371
		iwl3945_build_tx_cmd_hwcrypto(priv, info, out_cmd, skb, 0);
Z
Zhu Yi 已提交
2372

2373 2374
	/* 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 已提交
2375 2376 2377 2378
	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 已提交
2379
		iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, phys_addr, len);
Z
Zhu Yi 已提交
2380 2381 2382
	}

	if (!len)
2383
		/* If there is no payload, then we use only one Tx buffer */
W
Winkler, Tomas 已提交
2384
		tfd->control_flags = cpu_to_le32(TFD_CTL_COUNT_SET(1));
Z
Zhu Yi 已提交
2385
	else
2386 2387
		/* Else use 2 buffers.
		 * Tell 3945 about any padding after MAC header */
W
Winkler, Tomas 已提交
2388 2389
		tfd->control_flags = cpu_to_le32(TFD_CTL_COUNT_SET(2) |
			TFD_CTL_PAD_SET(U32_PAD(len)));
Z
Zhu Yi 已提交
2390

2391
	/* Total # bytes to be transmitted */
Z
Zhu Yi 已提交
2392
	len = (u16)skb->len;
2393
	tx->len = cpu_to_le16(len);
Z
Zhu Yi 已提交
2394 2395

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

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

2401 2402
	tx->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
	tx->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;
Z
Zhu Yi 已提交
2403

2404
	if (!ieee80211_has_morefrags(hdr->frame_control)) {
Z
Zhu Yi 已提交
2405
		txq->need_update = 1;
2406
		if (qc)
2407
			priv->stations_39[sta_id].tid[tid].seq_number = seq_number;
Z
Zhu Yi 已提交
2408 2409 2410 2411 2412
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

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

2415
	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx->hdr,
2416
			   ieee80211_hdrlen(fc));
Z
Zhu Yi 已提交
2417

2418
	/* Tell device the write index *just past* this latest filled TFD */
T
Tomas Winkler 已提交
2419
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
C
Christoph Hellwig 已提交
2420
	rc = iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
2421 2422 2423 2424 2425
	spin_unlock_irqrestore(&priv->lock, flags);

	if (rc)
		return rc;

2426
	if ((iwl_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
2427 2428 2429 2430
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
C
Christoph Hellwig 已提交
2431
			iwl3945_tx_queue_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
2432 2433 2434
			spin_unlock_irqrestore(&priv->lock, flags);
		}

2435
		ieee80211_stop_queue(priv->hw, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
2436 2437 2438 2439 2440 2441 2442 2443 2444 2445
	}

	return 0;

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

2446
static void iwl3945_set_rate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2447
{
2448
	const struct ieee80211_supported_band *sband = NULL;
Z
Zhu Yi 已提交
2449 2450 2451
	struct ieee80211_rate *rate;
	int i;

K
Kolekar, Abhijeet 已提交
2452
	sband = iwl_get_hw_mode(priv, priv->band);
2453
	if (!sband) {
2454
		IWL_ERR(priv, "Failed to set rate: unable to get hw mode\n");
2455 2456
		return;
	}
Z
Zhu Yi 已提交
2457 2458 2459 2460

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

2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
	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 已提交
2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482
	}

	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)
2483
		priv->staging39_rxon.cck_basic_rates =
Z
Zhu Yi 已提交
2484 2485 2486
		    ((priv->active_rate_basic &
		      IWL_CCK_RATES_MASK) >> IWL_FIRST_CCK_RATE) & 0xF;
	else
2487
		priv->staging39_rxon.cck_basic_rates =
Z
Zhu Yi 已提交
2488 2489 2490
		    (IWL_CCK_BASIC_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;

	if (priv->active_rate_basic & IWL_OFDM_BASIC_RATES_MASK)
2491
		priv->staging39_rxon.ofdm_basic_rates =
Z
Zhu Yi 已提交
2492 2493 2494 2495
		    ((priv->active_rate_basic &
		      (IWL_OFDM_BASIC_RATES_MASK | IWL_RATE_6M_MASK)) >>
		      IWL_FIRST_OFDM_RATE) & 0xFF;
	else
2496
		priv->staging39_rxon.ofdm_basic_rates =
Z
Zhu Yi 已提交
2497 2498 2499
		   (IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
}

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

	spin_lock_irqsave(&priv->lock, flags);
2525
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
Z
Zhu Yi 已提交
2526 2527 2528 2529 2530 2531 2532 2533

	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);
2534 2535 2536
	iwl_read32(priv, CSR_UCODE_DRV_GP1);
	if (!iwl_grab_nic_access(priv))
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2537 2538 2539 2540 2541 2542 2543 2544
	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;
	}

2545 2546
	if (priv->is_open)
		queue_work(priv->workqueue, &priv->restart);
Z
Zhu Yi 已提交
2547 2548 2549
	return;
}

2550
void iwl3945_set_decrypted_flag(struct iwl_priv *priv, struct sk_buff *skb,
Z
Zhu Yi 已提交
2551 2552 2553 2554 2555
			    u32 decrypt_res, struct ieee80211_rx_status *stats)
{
	u16 fc =
	    le16_to_cpu(((struct ieee80211_hdr *)skb->data)->frame_control);

2556
	if (priv->active39_rxon.filter_flags & RXON_FILTER_DIS_DECRYPT_MSK)
Z
Zhu Yi 已提交
2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581
		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;
	}
}

2582
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596

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

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

C
Christoph Hellwig 已提交
2681
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
2682 2683 2684
	if (rc)
		return rc;

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

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

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

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

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

2759
static void iwl3945_rx_reply_error(struct iwl_priv *priv,
2760
			       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2761
{
2762
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
2763

2764
	IWL_ERR(priv, "Error Reply type 0x%08X cmd %s (0x%02X) "
Z
Zhu Yi 已提交
2765 2766 2767 2768 2769 2770 2771 2772 2773 2774
		"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

2775
static void iwl3945_rx_csa(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2776
{
2777
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2778
	struct iwl3945_rxon_cmd *rxon = (void *)&priv->active39_rxon;
2779
	struct iwl_csa_notification *csa = &(pkt->u.csa_notif);
Z
Zhu Yi 已提交
2780 2781 2782
	IWL_DEBUG_11H("CSA notif: channel %d, status %d\n",
		      le16_to_cpu(csa->channel), le32_to_cpu(csa->status));
	rxon->channel = csa->channel;
2783
	priv->staging39_rxon.channel = csa->channel;
Z
Zhu Yi 已提交
2784 2785
}

2786
static void iwl3945_rx_spectrum_measure_notif(struct iwl_priv *priv,
2787
					  struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2788
{
2789
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
2790
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2791
	struct iwl_spectrum_notification *report = &(pkt->u.spectrum_notif);
Z
Zhu Yi 已提交
2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803

	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
}

2804
static void iwl3945_rx_pm_sleep_notif(struct iwl_priv *priv,
2805
				  struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2806
{
2807
#ifdef CONFIG_IWL3945_DEBUG
2808
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2809
	struct iwl_sleep_notification *sleep = &(pkt->u.sleep_notif);
Z
Zhu Yi 已提交
2810 2811 2812 2813 2814
	IWL_DEBUG_RX("sleep mode: %d, src: %d\n",
		     sleep->pm_sleep_mode, sleep->pm_wakeup_src);
#endif
}

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

C
Christoph Hellwig 已提交
2826
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
2827
{
2828 2829
	struct iwl_priv *priv =
		container_of(work, struct iwl_priv, beacon_update);
Z
Zhu Yi 已提交
2830 2831 2832
	struct sk_buff *beacon;

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

	if (!beacon) {
2836
		IWL_ERR(priv, "update beacon failed\n");
Z
Zhu Yi 已提交
2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847
		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 已提交
2848
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
2849 2850
}

2851
static void iwl3945_rx_beacon_notif(struct iwl_priv *priv,
2852
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2853
{
2854
#ifdef CONFIG_IWL3945_DEBUG
2855
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
C
Christoph Hellwig 已提交
2856
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867
	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

2868
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
2869 2870 2871 2872 2873
	    (!test_bit(STATUS_EXIT_PENDING, &priv->status)))
		queue_work(priv->workqueue, &priv->beacon_update);
}

/* Service response to REPLY_SCAN_CMD (0x80) */
2874
static void iwl3945_rx_reply_scan(struct iwl_priv *priv,
2875
			      struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2876
{
2877
#ifdef CONFIG_IWL3945_DEBUG
2878
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2879 2880
	struct iwl_scanreq_notification *notif =
	    (struct iwl_scanreq_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
2881 2882 2883 2884 2885 2886

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

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

	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;
2925
	priv->next_scan_jiffies = 0;
Z
Zhu Yi 已提交
2926 2927 2928
}

/* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
2929
static void iwl3945_rx_scan_complete_notif(struct iwl_priv *priv,
2930
				       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2931
{
2932
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2933
	struct iwl_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
Z
Zhu Yi 已提交
2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946

	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",
2947 2948
		       (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) ?
							"2.4" : "5.2",
Z
Zhu Yi 已提交
2949 2950 2951
		       jiffies_to_msecs(elapsed_jiffies
					(priv->scan_pass_start, jiffies)));

2952 2953 2954 2955 2956 2957 2958
	/* 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 已提交
2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972

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

3003
	iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016
		    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 已提交
3017
	iwl3945_scan_cancel(priv);
Z
Zhu Yi 已提交
3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028

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

3050 3051 3052 3053
	/*
	 * 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 已提交
3054
	 */
C
Christoph Hellwig 已提交
3055 3056
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
3057

C
Christoph Hellwig 已提交
3058 3059
	priv->rx_handlers[REPLY_SCAN_CMD] = iwl3945_rx_reply_scan;
	priv->rx_handlers[SCAN_START_NOTIFICATION] = iwl3945_rx_scan_start_notif;
Z
Zhu Yi 已提交
3060
	priv->rx_handlers[SCAN_RESULTS_NOTIFICATION] =
C
Christoph Hellwig 已提交
3061
	    iwl3945_rx_scan_results_notif;
Z
Zhu Yi 已提交
3062
	priv->rx_handlers[SCAN_COMPLETE_NOTIFICATION] =
C
Christoph Hellwig 已提交
3063 3064
	    iwl3945_rx_scan_complete_notif;
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
3065

3066
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
3067
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
3068 3069
}

3070 3071 3072 3073 3074
/**
 * 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.
 */
3075
static void iwl3945_cmd_queue_reclaim(struct iwl_priv *priv,
3076 3077
				      int txq_id, int index)
{
3078
	struct iwl_tx_queue *txq = &priv->txq[txq_id];
3079
	struct iwl_queue *q = &txq->q;
3080 3081 3082
	int nfreed = 0;

	if ((index >= q->n_bd) || (iwl3945_x2_queue_used(q, index) == 0)) {
3083
		IWL_ERR(priv, "Read index for DMA queue txq id (%d), index %d, "
3084 3085 3086 3087 3088 3089 3090 3091
			  "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) {
3092
			IWL_ERR(priv, "HCMD skipped: index (%d) %d %d\n", index,
3093 3094 3095 3096 3097 3098 3099 3100 3101
					q->write_ptr, q->read_ptr);
			queue_work(priv->workqueue, &priv->restart);
			break;
		}
		nfreed++;
	}
}


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

	BUG_ON(txq_id != IWL_CMD_QUEUE_NUM);

3123 3124
	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 已提交
3125 3126 3127 3128 3129 3130 3131 3132 3133

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

3134
	iwl3945_cmd_queue_reclaim(priv, txq_id, index);
Z
Zhu Yi 已提交
3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163

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

/**
C
Christoph Hellwig 已提交
3207
 * iwl3945_rx_queue_space - Return number of free slots available in queue.
Z
Zhu Yi 已提交
3208
 */
3209
static int iwl3945_rx_queue_space(const struct iwl_rx_queue *q)
Z
Zhu Yi 已提交
3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221
{
	int s = q->read - q->write;
	if (s <= 0)
		s += RX_QUEUE_SIZE;
	/* keep some buffer to not confuse full and empty queue */
	s -= 2;
	if (s < 0)
		s = 0;
	return s;
}

/**
3222
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
3223
 */
3224
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl_priv *priv,
Z
Zhu Yi 已提交
3225 3226 3227 3228 3229 3230
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

/**
C
Christoph Hellwig 已提交
3231
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
3232
 *
3233
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
3234
 * and we have free pre-allocated buffers, fill the ranks as much
3235
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
3236 3237 3238 3239 3240
 *
 * 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.
 */
3241
static int iwl3945_rx_queue_restock(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3242
{
3243
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3244
	struct list_head *element;
3245
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
3246 3247 3248 3249 3250
	unsigned long flags;
	int write, rc;

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
C
Christoph Hellwig 已提交
3251
	while ((iwl3945_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
3252
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
3253
		element = rxq->rx_free.next;
3254
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
Z
Zhu Yi 已提交
3255
		list_del(element);
3256 3257

		/* Point to Rx buffer via next RBD in circular buffer */
3258
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->real_dma_addr);
Z
Zhu Yi 已提交
3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269
		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);


3270 3271
	/* 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 已提交
3272 3273 3274 3275 3276
	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);
3277
		rc = iwl_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
3278 3279 3280 3281 3282 3283 3284 3285
		if (rc)
			return rc;
	}

	return 0;
}

/**
C
Christoph Hellwig 已提交
3286
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
3287 3288 3289
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
3290
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
3291
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
3292
 */
3293
static void iwl3945_rx_allocate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3294
{
3295
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3296
	struct list_head *element;
3297
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
3298 3299 3300 3301
	unsigned long flags;
	spin_lock_irqsave(&rxq->lock, flags);
	while (!list_empty(&rxq->rx_used)) {
		element = rxq->rx_used.next;
3302
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
3303 3304

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
3305 3306 3307 3308
		rxb->skb =
		    alloc_skb(IWL_RX_BUF_SIZE, __GFP_NOWARN | GFP_ATOMIC);
		if (!rxb->skb) {
			if (net_ratelimit())
T
Tomas Winkler 已提交
3309
				IWL_CRIT(priv, ": Can not allocate SKB buffers\n");
Z
Zhu Yi 已提交
3310 3311 3312 3313 3314
			/* 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 已提交
3315 3316 3317 3318 3319 3320 3321 3322 3323

		/* 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 已提交
3324 3325
		priv->alloc_rxb_skb++;
		list_del(element);
3326 3327

		/* Get physical address of RB/SKB */
3328
		rxb->real_dma_addr =
Z
Zhu Yi 已提交
3329 3330 3331 3332 3333 3334
		    pci_map_single(priv->pci_dev, rxb->skb->data,
				   IWL_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);
3335 3336 3337 3338 3339
}

/*
 * this should be called while priv->lock is locked
 */
3340
static void __iwl3945_rx_replenish(void *data)
3341
{
3342
	struct iwl_priv *priv = data;
3343 3344 3345 3346 3347 3348 3349 3350

	iwl3945_rx_allocate(priv);
	iwl3945_rx_queue_restock(priv);
}


void iwl3945_rx_replenish(void *data)
{
3351
	struct iwl_priv *priv = data;
3352 3353 3354
	unsigned long flags;

	iwl3945_rx_allocate(priv);
Z
Zhu Yi 已提交
3355 3356

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
3357
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378
	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 已提交
3379
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
3380
{
3381 3382
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
3383 3384
		return 60;

3385
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
3386
	 *   add 20 dB to make up for divide by 10 */
3387
	if (sig_ratio >= 100)
3388
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404

	/* 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 已提交
3405
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439
{
	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;
}

/**
3440
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
3441 3442 3443 3444 3445
 *
 * Uses the priv->rx_handlers callback function array to invoke
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
3446
static void iwl3945_rx_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3447
{
3448
	struct iwl_rx_mem_buffer *rxb;
3449
	struct iwl_rx_packet *pkt;
3450
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
3451 3452 3453
	u32 r, i;
	int reclaim;
	unsigned long flags;
3454
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
3455
	u32 count = 8;
Z
Zhu Yi 已提交
3456

3457 3458
	/* 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 已提交
3459
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
3460 3461
	i = rxq->read;

3462 3463
	if (iwl3945_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
		fill_rx = 1;
Z
Zhu Yi 已提交
3464 3465 3466 3467 3468 3469 3470
	/* 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];

3471
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
3472 3473 3474 3475 3476 3477
		 * then a bug has been introduced in the queue refilling
		 * routines -- catch it here */
		BUG_ON(rxb == NULL);

		rxq->queue[i] = NULL;

3478
		pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->real_dma_addr,
Z
Zhu Yi 已提交
3479 3480
					    IWL_RX_BUF_SIZE,
					    PCI_DMA_FROMDEVICE);
3481
		pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494

		/* 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 已提交
3495
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
3496
		if (priv->rx_handlers[pkt->hdr.cmd]) {
3497
			IWL_DEBUG(IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
3498 3499 3500 3501 3502
				"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 */
3503
			IWL_DEBUG(IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
3504 3505 3506 3507 3508 3509
				"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) {
3510 3511
			/* Invoke any callbacks, transfer the skb to caller, and
			 * fire off the (possibly) blocking iwl3945_send_cmd()
Z
Zhu Yi 已提交
3512 3513
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
C
Christoph Hellwig 已提交
3514
				iwl3945_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
3515
			else
3516
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527
		}

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

3528
		pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
Z
Zhu Yi 已提交
3529 3530 3531 3532 3533
				 IWL_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
		spin_lock_irqsave(&rxq->lock, flags);
		list_add_tail(&rxb->list, &priv->rxq.rx_used);
		spin_unlock_irqrestore(&rxq->lock, flags);
		i = (i + 1) & RX_QUEUE_MASK;
3534 3535 3536 3537 3538 3539 3540 3541 3542 3543
		/* 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 已提交
3544 3545 3546 3547
	}

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

3551 3552 3553
/**
 * iwl3945_tx_queue_update_write_ptr - Send new write index to hardware
 */
3554
static int iwl3945_tx_queue_update_write_ptr(struct iwl_priv *priv,
3555
				  struct iwl_tx_queue *txq)
Z
Zhu Yi 已提交
3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568
{
	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. */
3569
		reg = iwl_read32(priv, CSR_UCODE_DRV_GP1);
Z
Zhu Yi 已提交
3570 3571 3572

		if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
			IWL_DEBUG_INFO("Requesting wakeup, GP1 = 0x%x\n", reg);
3573
			iwl_set_bit(priv, CSR_GP_CNTRL,
Z
Zhu Yi 已提交
3574 3575 3576 3577 3578
				    CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
			return rc;
		}

		/* restore this queue's parameters in nic hardware. */
3579
		rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
3580 3581
		if (rc)
			return rc;
3582
		iwl_write_direct32(priv, HBUS_TARG_WRPTR,
3583
				     txq->q.write_ptr | (txq_id << 8));
3584
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3585 3586 3587 3588

	/* 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
3589
		iwl_write32(priv, HBUS_TARG_WRPTR,
3590
			    txq->q.write_ptr | (txq_id << 8));
Z
Zhu Yi 已提交
3591 3592 3593 3594 3595 3596

	txq->need_update = 0;

	return rc;
}

3597
#ifdef CONFIG_IWL3945_DEBUG
3598
static void iwl3945_print_rx_config_cmd(struct iwl_priv *priv,
3599
					struct iwl3945_rxon_cmd *rxon)
Z
Zhu Yi 已提交
3600 3601
{
	IWL_DEBUG_RADIO("RX CONFIG:\n");
3602
	iwl_print_hex_dump(priv, IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
Z
Zhu Yi 已提交
3603 3604 3605 3606 3607 3608 3609 3610
	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 已提交
3611 3612
	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 已提交
3613 3614 3615 3616
	IWL_DEBUG_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
}
#endif

3617
static void iwl3945_enable_interrupts(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3618 3619 3620
{
	IWL_DEBUG_ISR("Enabling interrupts\n");
	set_bit(STATUS_INT_ENABLED, &priv->status);
3621
	iwl_write32(priv, CSR_INT_MASK, CSR_INI_SET_MASK);
Z
Zhu Yi 已提交
3622 3623
}

3624 3625

/* call this function to flush any scheduled tasklet */
3626
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
3627
{
T
Tomas Winkler 已提交
3628
	/* wait to make sure we flush pending tasklet*/
3629 3630 3631 3632 3633
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}


3634
static inline void iwl3945_disable_interrupts(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3635 3636 3637 3638
{
	clear_bit(STATUS_INT_ENABLED, &priv->status);

	/* disable interrupts from uCode/NIC to host */
3639
	iwl_write32(priv, CSR_INT_MASK, 0x00000000);
Z
Zhu Yi 已提交
3640 3641 3642

	/* acknowledge/clear/reset any interrupts still pending
	 * from uCode or flow handler (Rx/Tx DMA) */
3643 3644
	iwl_write32(priv, CSR_INT, 0xffffffff);
	iwl_write32(priv, CSR_FH_INT_STATUS, 0xffffffff);
Z
Zhu Yi 已提交
3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670
	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))

3671
static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3672 3673 3674 3675 3676 3677 3678 3679
{
	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 已提交
3680
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
3681
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
3682 3683 3684
		return;
	}

3685
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
3686
	if (rc) {
3687
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
3688 3689 3690
		return;
	}

3691
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
3692 3693

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

3699
	IWL_ERR(priv, "Desc       Time       asrtPC  blink2 "
Z
Zhu Yi 已提交
3700 3701 3702 3703
		  "ilink1  nmiPC   Line\n");
	for (i = ERROR_START_OFFSET;
	     i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
	     i += ERROR_ELEM_SIZE) {
3704
		desc = iwl_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
3705
		time =
3706
		    iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
3707
		blink1 =
3708
		    iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
3709
		blink2 =
3710
		    iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
3711
		ilink1 =
3712
		    iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
3713
		ilink2 =
3714
		    iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
3715
		data1 =
3716
		    iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
3717

3718 3719 3720 3721
		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 已提交
3722 3723
	}

3724
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3725 3726 3727

}

3728
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
3729 3730

/**
C
Christoph Hellwig 已提交
3731
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
3732
 *
3733
 * NOTE: Must be called with iwl_grab_nic_access() already obtained!
Z
Zhu Yi 已提交
3734
 */
3735
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758
				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++) {
3759
		ev = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
3760
		ptr += sizeof(u32);
3761
		time = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
3762
		ptr += sizeof(u32);
3763 3764 3765 3766
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
		} else {
3767
			data = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
3768
			ptr += sizeof(u32);
3769
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
Z
Zhu Yi 已提交
3770 3771 3772 3773
		}
	}
}

3774
static void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3775 3776 3777 3778 3779 3780 3781 3782 3783 3784
{
	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 已提交
3785
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
3786
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
3787 3788 3789
		return;
	}

3790
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
3791
	if (rc) {
3792
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
3793 3794 3795 3796
		return;
	}

	/* event log header */
3797 3798 3799 3800
	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 已提交
3801 3802 3803 3804 3805

	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
3806
		IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
3807
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3808 3809 3810
		return;
	}

3811
	IWL_ERR(priv, "Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
3812 3813 3814 3815 3816
		  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 已提交
3817
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
3818 3819 3820
				    capacity - next_entry, mode);

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

3823
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3824 3825 3826
}

/**
C
Christoph Hellwig 已提交
3827
 * iwl3945_irq_handle_error - called for HW or SW error interrupt from card
Z
Zhu Yi 已提交
3828
 */
3829
static void iwl3945_irq_handle_error(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3830
{
C
Christoph Hellwig 已提交
3831
	/* Set the FW error flag -- cleared on iwl3945_down */
Z
Zhu Yi 已提交
3832 3833 3834 3835 3836
	set_bit(STATUS_FW_ERROR, &priv->status);

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

3837
#ifdef CONFIG_IWL3945_DEBUG
3838
	if (priv->debug_level & IWL_DL_FW_ERRORS) {
C
Christoph Hellwig 已提交
3839 3840
		iwl3945_dump_nic_error_log(priv);
		iwl3945_dump_nic_event_log(priv);
3841
		iwl3945_print_rx_config_cmd(priv, &priv->staging39_rxon);
Z
Zhu Yi 已提交
3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854
	}
#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 已提交
3855
		if (iwl3945_is_associated(priv)) {
3856 3857
			memcpy(&priv->recovery39_rxon, &priv->active39_rxon,
			       sizeof(priv->recovery39_rxon));
Z
Zhu Yi 已提交
3858 3859 3860 3861 3862 3863
			priv->error_recovering = 1;
		}
		queue_work(priv->workqueue, &priv->restart);
	}
}

3864
static void iwl3945_error_recovery(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3865 3866 3867
{
	unsigned long flags;

3868 3869 3870
	memcpy(&priv->staging39_rxon, &priv->recovery39_rxon,
	       sizeof(priv->staging39_rxon));
	priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
3871
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3872

C
Christoph Hellwig 已提交
3873
	iwl3945_add_station(priv, priv->bssid, 1, 0);
Z
Zhu Yi 已提交
3874 3875

	spin_lock_irqsave(&priv->lock, flags);
3876
	priv->assoc_id = le16_to_cpu(priv->staging39_rxon.assoc_id);
Z
Zhu Yi 已提交
3877 3878 3879 3880
	priv->error_recovering = 0;
	spin_unlock_irqrestore(&priv->lock, flags);
}

3881
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3882 3883 3884 3885
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
3886
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
3887 3888 3889 3890 3891 3892 3893 3894
	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. */
3895 3896
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
3897 3898 3899 3900

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

3904
#ifdef CONFIG_IWL3945_DEBUG
3905
	if (priv->debug_level & IWL_DL_ISR) {
3906
		/* just for debug */
3907
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
Z
Zhu Yi 已提交
3908 3909 3910 3911 3912 3913 3914 3915 3916
		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 已提交
3917
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
3918
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
3919
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
3920 3921 3922 3923
		inta |= CSR_INT_BIT_FH_TX;

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

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

C
Christoph Hellwig 已提交
3929
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
3930 3931 3932 3933 3934 3935 3936 3937

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

3938
#ifdef CONFIG_IWL3945_DEBUG
3939
	if (priv->debug_level & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
3940
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
3941 3942 3943
		if (inta & CSR_INT_BIT_SCD)
			IWL_DEBUG_ISR("Scheduler finished to transmit "
				      "the frame/frames.\n");
Z
Zhu Yi 已提交
3944 3945 3946 3947 3948 3949 3950

		/* 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 */
3951
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
3952 3953 3954

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
3955 3956
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
C
Christoph Hellwig 已提交
3957
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
3958 3959 3960 3961 3962 3963
		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");
3964
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
3965 3966 3967 3968 3969 3970
		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 已提交
3971 3972 3973 3974 3975 3976 3977 3978

		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 已提交
3979
		iwl3945_rx_handle(priv);
Z
Zhu Yi 已提交
3980 3981 3982 3983 3984 3985
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

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

3986 3987 3988
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
		if (!iwl_grab_nic_access(priv)) {
			iwl_write_direct32(priv, FH39_TCSR_CREDIT
3989
					     (FH39_SRVC_CHNL), 0x0);
3990
			iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3991 3992 3993 3994 3995
		}
		handled |= CSR_INT_BIT_FH_TX;
	}

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

	if (inta & ~CSR_INI_SET_MASK) {
3999
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
Z
Zhu Yi 已提交
4000
			 inta & ~CSR_INI_SET_MASK);
4001
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
4002 4003 4004
	}

	/* Re-enable all interrupts */
4005 4006 4007
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
		iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
4008

4009
#ifdef CONFIG_IWL3945_DEBUG
4010
	if (priv->debug_level & (IWL_DL_ISR)) {
4011 4012 4013
		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 已提交
4014 4015 4016 4017 4018 4019 4020
		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 已提交
4021
static irqreturn_t iwl3945_isr(int irq, void *data)
Z
Zhu Yi 已提交
4022
{
4023
	struct iwl_priv *priv = data;
Z
Zhu Yi 已提交
4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034
	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. */
4035 4036
	inta_mask = iwl_read32(priv, CSR_INT_MASK);  /* just for debug */
	iwl_write32(priv, CSR_INT_MASK, 0x00000000);
Z
Zhu Yi 已提交
4037 4038

	/* Discover which interrupts are active/pending */
4039 4040
	inta = iwl_read32(priv, CSR_INT);
	inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
Z
Zhu Yi 已提交
4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051

	/* 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 */
4052
		IWL_WARN(priv, "HARDWARE GONE?? INTA == 0x%08x\n", inta);
4053
		goto unplugged;
Z
Zhu Yi 已提交
4054 4055 4056 4057 4058
	}

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

4059 4060
	inta &= ~CSR_INT_BIT_SCD;

C
Christoph Hellwig 已提交
4061
	/* iwl3945_irq_tasklet() will service interrupts and re-enable them */
4062 4063
	if (likely(inta || inta_fh))
		tasklet_schedule(&priv->irq_tasklet);
4064
unplugged:
Z
Zhu Yi 已提交
4065 4066 4067 4068 4069 4070
	spin_unlock(&priv->lock);

	return IRQ_HANDLED;

 none:
	/* re-enable interrupts here since we don't have anything to service. */
4071 4072 4073
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
		iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
4074 4075 4076 4077 4078 4079
	spin_unlock(&priv->lock);
	return IRQ_NONE;
}

/************************** EEPROM BANDS ****************************
 *
C
Christoph Hellwig 已提交
4080
 * The iwl3945_eeprom_band definitions below provide the mapping from the
Z
Zhu Yi 已提交
4081 4082 4083
 * EEPROM contents to the specific channel number supported for each
 * band.
 *
4084
 * For example, iwl3945_priv->eeprom39.band_3_channels[4] from the band_3
Z
Zhu Yi 已提交
4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109
 * 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 已提交
4110
static const u8 iwl3945_eeprom_band_1[14] = {
Z
Zhu Yi 已提交
4111 4112 4113 4114
	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
};

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

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

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

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

4131
static void iwl3945_init_band_reference(const struct iwl_priv *priv, int band,
Z
Zhu Yi 已提交
4132
				    int *eeprom_ch_count,
4133
				    const struct iwl_eeprom_channel
Z
Zhu Yi 已提交
4134 4135 4136 4137 4138
				    **eeprom_ch_info,
				    const u8 **eeprom_ch_index)
{
	switch (band) {
	case 1:		/* 2.4GHz band */
C
Christoph Hellwig 已提交
4139
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_1);
4140
		*eeprom_ch_info = priv->eeprom39.band_1_channels;
C
Christoph Hellwig 已提交
4141
		*eeprom_ch_index = iwl3945_eeprom_band_1;
Z
Zhu Yi 已提交
4142
		break;
4143
	case 2:		/* 4.9GHz band */
C
Christoph Hellwig 已提交
4144
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_2);
4145
		*eeprom_ch_info = priv->eeprom39.band_2_channels;
C
Christoph Hellwig 已提交
4146
		*eeprom_ch_index = iwl3945_eeprom_band_2;
Z
Zhu Yi 已提交
4147 4148
		break;
	case 3:		/* 5.2GHz band */
C
Christoph Hellwig 已提交
4149
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_3);
4150
		*eeprom_ch_info = priv->eeprom39.band_3_channels;
C
Christoph Hellwig 已提交
4151
		*eeprom_ch_index = iwl3945_eeprom_band_3;
Z
Zhu Yi 已提交
4152
		break;
4153
	case 4:		/* 5.5GHz band */
C
Christoph Hellwig 已提交
4154
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_4);
4155
		*eeprom_ch_info = priv->eeprom39.band_4_channels;
C
Christoph Hellwig 已提交
4156
		*eeprom_ch_index = iwl3945_eeprom_band_4;
Z
Zhu Yi 已提交
4157
		break;
4158
	case 5:		/* 5.7GHz band */
C
Christoph Hellwig 已提交
4159
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_5);
4160
		*eeprom_ch_info = priv->eeprom39.band_5_channels;
C
Christoph Hellwig 已提交
4161
		*eeprom_ch_index = iwl3945_eeprom_band_5;
Z
Zhu Yi 已提交
4162 4163 4164 4165 4166 4167 4168
		break;
	default:
		BUG();
		return;
	}
}

4169 4170 4171 4172 4173
/**
 * iwl3945_get_channel_info - Find driver's private channel info
 *
 * Based on band and channel number.
 */
4174
const struct iwl_channel_info *
4175
iwl3945_get_channel_info(const struct iwl_priv *priv,
4176
			 enum ieee80211_band band, u16 channel)
Z
Zhu Yi 已提交
4177 4178 4179
{
	int i;

4180 4181
	switch (band) {
	case IEEE80211_BAND_5GHZ:
Z
Zhu Yi 已提交
4182 4183 4184 4185 4186 4187
		for (i = 14; i < priv->channel_count; i++) {
			if (priv->channel_info[i].channel == channel)
				return &priv->channel_info[i];
		}
		break;

4188
	case IEEE80211_BAND_2GHZ:
Z
Zhu Yi 已提交
4189 4190 4191
		if (channel >= 1 && channel <= 14)
			return &priv->channel_info[channel - 1];
		break;
4192 4193
	case IEEE80211_NUM_BANDS:
		WARN_ON(1);
Z
Zhu Yi 已提交
4194 4195 4196 4197 4198 4199 4200 4201
	}

	return NULL;
}

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

4202 4203 4204
/**
 * iwl3945_init_channel_map - Set up driver's info for all possible channels
 */
4205
static int iwl3945_init_channel_map(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4206 4207 4208
{
	int eeprom_ch_count = 0;
	const u8 *eeprom_ch_index = NULL;
4209
	const struct iwl_eeprom_channel *eeprom_ch_info = NULL;
Z
Zhu Yi 已提交
4210
	int band, ch;
4211
	struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
4212 4213 4214 4215 4216 4217

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

4218
	if (priv->eeprom39.version < 0x2f) {
4219
		IWL_WARN(priv, "Unsupported EEPROM version: 0x%04X\n",
4220
			    priv->eeprom39.version);
Z
Zhu Yi 已提交
4221 4222 4223 4224 4225 4226
		return -EINVAL;
	}

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

	priv->channel_count =
C
Christoph Hellwig 已提交
4227 4228 4229 4230 4231
	    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 已提交
4232 4233 4234

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

4235
	priv->channel_info = kzalloc(sizeof(struct iwl_channel_info) *
Z
Zhu Yi 已提交
4236 4237
				     priv->channel_count, GFP_KERNEL);
	if (!priv->channel_info) {
4238
		IWL_ERR(priv, "Could not allocate channel_info\n");
Z
Zhu Yi 已提交
4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249
		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 已提交
4250
		iwl3945_init_band_reference(priv, band, &eeprom_ch_count,
Z
Zhu Yi 已提交
4251 4252 4253 4254 4255
					&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];
4256 4257
			ch_info->band = (band == 1) ? IEEE80211_BAND_2GHZ :
			    IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283

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

4284
			IWL_DEBUG_INFO("Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x"
Z
Zhu Yi 已提交
4285 4286 4287 4288
				       " %ddBm): Ad-Hoc %ssupported\n",
				       ch_info->channel,
				       is_channel_a_band(ch_info) ?
				       "5.2" : "2.4",
4289
				       CHECK_AND_PRINT(VALID),
Z
Zhu Yi 已提交
4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313
				       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++;
		}
	}

4314
	/* Set up txpower settings in driver for all channels */
Z
Zhu Yi 已提交
4315 4316 4317 4318 4319 4320
	if (iwl3945_txpower_set_from_eeprom(priv))
		return -EIO;

	return 0;
}

4321 4322 4323
/*
 * iwl3945_free_channel_map - undo allocations in iwl3945_init_channel_map
 */
4324
static void iwl3945_free_channel_map(struct iwl_priv *priv)
4325 4326 4327 4328 4329
{
	kfree(priv->channel_info);
	priv->channel_count = 0;
}

Z
Zhu Yi 已提交
4330 4331 4332
/* 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.  */
4333 4334 4335 4336 4337
#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 已提交
4338 4339 4340 4341 4342 4343 4344 4345

/* 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 */
4346
#define IWL_ACTIVE_QUIET_TIME       __constant_cpu_to_le16(10)	/* msec */
Z
Zhu Yi 已提交
4347 4348 4349 4350 4351 4352 4353 4354 4355

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

4358
static inline u16 iwl3945_get_active_dwell_time(struct iwl_priv *priv,
4359 4360
						enum ieee80211_band band,
						u8 n_probes)
Z
Zhu Yi 已提交
4361
{
4362
	if (band == IEEE80211_BAND_5GHZ)
4363 4364
		return IWL_ACTIVE_DWELL_TIME_52 +
			IWL_ACTIVE_DWELL_FACTOR_52GHZ * (n_probes + 1);
Z
Zhu Yi 已提交
4365
	else
4366 4367
		return IWL_ACTIVE_DWELL_TIME_24 +
			IWL_ACTIVE_DWELL_FACTOR_24GHZ * (n_probes + 1);
Z
Zhu Yi 已提交
4368 4369
}

4370
static u16 iwl3945_get_passive_dwell_time(struct iwl_priv *priv,
4371
					  enum ieee80211_band band)
Z
Zhu Yi 已提交
4372
{
4373
	u16 passive = (band == IEEE80211_BAND_2GHZ) ?
Z
Zhu Yi 已提交
4374 4375 4376
	    IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_24 :
	    IWL_PASSIVE_DWELL_BASE + IWL_PASSIVE_DWELL_TIME_52;

C
Christoph Hellwig 已提交
4377
	if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389
		/* 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;
}

4390
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
4391
					 enum ieee80211_band band,
4392
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
4393
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
4394 4395
{
	const struct ieee80211_channel *channels = NULL;
4396
	const struct ieee80211_supported_band *sband;
4397
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
4398 4399 4400 4401
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
4402
	sband = iwl_get_hw_mode(priv, band);
4403
	if (!sband)
Z
Zhu Yi 已提交
4404 4405
		return 0;

4406
	channels = sband->channels;
Z
Zhu Yi 已提交
4407

4408
	active_dwell = iwl3945_get_active_dwell_time(priv, band, n_probes);
4409
	passive_dwell = iwl3945_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
4410

4411 4412 4413
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

4414
	for (i = 0, added = 0; i < sband->n_channels; i++) {
4415 4416 4417
		if (channels[i].flags & IEEE80211_CHAN_DISABLED)
			continue;

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

4420
		ch_info = iwl3945_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
4421
		if (!is_channel_valid(ch_info)) {
4422
			IWL_DEBUG_SCAN("Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
4423 4424 4425 4426
				       scan_ch->channel);
			continue;
		}

4427 4428 4429 4430 4431
		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 已提交
4432
		if (!is_active || is_channel_passive(ch_info) ||
4433
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
4434
			scan_ch->type = 0;	/* passive */
4435 4436 4437
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
4438
			scan_ch->type = 1;	/* active */
4439
		}
Z
Zhu Yi 已提交
4440

4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453
		/* 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 已提交
4454

4455
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
4456 4457 4458 4459
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
4460
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
4461 4462 4463 4464
			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
4465
			 * power level:
4466
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483
			 */
		}

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

4484
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
4485 4486 4487 4488 4489
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
4490 4491 4492 4493
		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;
4494
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
4495
			/*
4496
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
4497
			 */
C
Christoph Hellwig 已提交
4498
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
4499
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
4500 4501 4502 4503 4504
		}
	}
}

/**
C
Christoph Hellwig 已提交
4505
 * iwl3945_init_geos - Initialize mac80211's geo/channel info based from eeprom
Z
Zhu Yi 已提交
4506
 */
4507
static int iwl3945_init_geos(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4508
{
4509
	struct iwl_channel_info *ch;
4510
	struct ieee80211_supported_band *sband;
Z
Zhu Yi 已提交
4511 4512 4513 4514 4515
	struct ieee80211_channel *channels;
	struct ieee80211_channel *geo_ch;
	struct ieee80211_rate *rates;
	int i = 0;

4516 4517
	if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
	    priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
Z
Zhu Yi 已提交
4518 4519 4520 4521 4522 4523 4524
		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);
4525
	if (!channels)
Z
Zhu Yi 已提交
4526 4527
		return -ENOMEM;

4528
	rates = kzalloc((sizeof(struct ieee80211_rate) * (IWL_RATE_COUNT + 1)),
Z
Zhu Yi 已提交
4529 4530 4531 4532 4533 4534 4535
			GFP_KERNEL);
	if (!rates) {
		kfree(channels);
		return -ENOMEM;
	}

	/* 5.2GHz channels start after the 2.4GHz channels */
4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546
	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 已提交
4547 4548 4549 4550

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

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

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

4556 4557
		/* FIXME: might be removed if scan is OK*/
		if (!is_channel_valid(ch))
Z
Zhu Yi 已提交
4558 4559 4560
			continue;

		if (is_channel_a_band(ch))
4561
			sband =  &priv->bands[IEEE80211_BAND_5GHZ];
4562
		else
4563
			sband =  &priv->bands[IEEE80211_BAND_2GHZ];
Z
Zhu Yi 已提交
4564

4565 4566 4567
		geo_ch = &sband->channels[sband->n_channels++];

		geo_ch->center_freq = ieee80211_channel_to_frequency(ch->channel);
4568 4569
		geo_ch->max_power = ch->max_power_avg;
		geo_ch->max_antenna_gain = 0xff;
4570
		geo_ch->hw_value = ch->channel;
Z
Zhu Yi 已提交
4571 4572

		if (is_channel_valid(ch)) {
4573 4574
			if (!(ch->flags & EEPROM_CHANNEL_IBSS))
				geo_ch->flags |= IEEE80211_CHAN_NO_IBSS;
Z
Zhu Yi 已提交
4575

4576 4577
			if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
				geo_ch->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
Z
Zhu Yi 已提交
4578 4579

			if (ch->flags & EEPROM_CHANNEL_RADAR)
4580
				geo_ch->flags |= IEEE80211_CHAN_RADAR;
Z
Zhu Yi 已提交
4581 4582 4583 4584

			if (ch->max_power_avg > priv->max_channel_txpower_limit)
				priv->max_channel_txpower_limit =
				    ch->max_power_avg;
4585
		} else {
4586
			geo_ch->flags |= IEEE80211_CHAN_DISABLED;
4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597
		}

		/* 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 已提交
4598 4599
	}

T
Tomas Winkler 已提交
4600 4601
	if ((priv->bands[IEEE80211_BAND_5GHZ].n_channels == 0) &&
	     priv->cfg->sku & IWL_SKU_A) {
T
Tomas Winkler 已提交
4602 4603 4604
		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 已提交
4605
		 priv->cfg->sku &= ~IWL_SKU_A;
Z
Zhu Yi 已提交
4606 4607
	}

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

4612 4613 4614 4615 4616 4617
	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 已提交
4618 4619 4620 4621 4622 4623

	set_bit(STATUS_GEO_CONFIGURED, &priv->status);

	return 0;
}

4624 4625 4626
/*
 * iwl3945_free_geos - undo allocations in iwl3945_init_geos
 */
4627
static void iwl3945_free_geos(struct iwl_priv *priv)
4628 4629 4630 4631 4632 4633
{
	kfree(priv->ieee_channels);
	kfree(priv->ieee_rates);
	clear_bit(STATUS_GEO_CONFIGURED, &priv->status);
}

Z
Zhu Yi 已提交
4634 4635 4636 4637 4638 4639
/******************************************************************************
 *
 * uCode download functions
 *
 ******************************************************************************/

4640
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4641
{
4642 4643 4644 4645 4646 4647
	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 已提交
4648 4649 4650
}

/**
C
Christoph Hellwig 已提交
4651
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
4652 4653
 *     looking at all data.
 */
4654
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
4655 4656 4657 4658 4659 4660 4661 4662
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

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

4663
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
4664 4665 4666
	if (rc)
		return rc;

4667
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
4668
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
4669 4670 4671 4672 4673 4674

	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 */
4675
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
4676
		if (val != le32_to_cpu(*image)) {
4677
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
4678 4679 4680 4681 4682 4683 4684 4685 4686
				  "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;
		}
	}

4687
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
4688 4689

	if (!errcnt)
4690
		IWL_DEBUG_INFO("ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
4691 4692 4693 4694 4695 4696

	return rc;
}


/**
C
Christoph Hellwig 已提交
4697
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
4698 4699 4700
 *   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.
 */
4701
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
4702 4703 4704 4705 4706 4707 4708 4709
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

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

4710
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
4711 4712 4713 4714 4715 4716 4717
	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 */
4718
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
4719
			i + IWL39_RTC_INST_LOWER_BOUND);
4720
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
4721 4722
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
4723
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
4724 4725 4726 4727 4728 4729 4730 4731 4732 4733
				  "offset 0x%x, is 0x%x, s/b 0x%x\n",
				  i, val, *image);
#endif
			rc = -EIO;
			errcnt++;
			if (errcnt >= 3)
				break;
		}
	}

4734
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
4735 4736 4737 4738 4739 4740

	return rc;
}


/**
C
Christoph Hellwig 已提交
4741
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
4742 4743
 *    and verify its contents
 */
4744
static int iwl3945_verify_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4745 4746 4747 4748 4749 4750 4751 4752
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
4753
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
4754 4755 4756 4757 4758 4759 4760 4761
	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 已提交
4762
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
4763 4764 4765 4766 4767 4768 4769 4770
	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 已提交
4771
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
4772 4773 4774 4775 4776
	if (rc == 0) {
		IWL_DEBUG_INFO("Runtime uCode is good in inst SRAM\n");
		return 0;
	}

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

4779 4780 4781
	/* 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 已提交
4782 4783
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
4784
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
4785 4786 4787 4788

	return rc;
}

4789
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4790 4791
{
	/* Remove all resets to allow NIC to operate */
4792
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
4793 4794 4795
}

/**
C
Christoph Hellwig 已提交
4796
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
4797 4798 4799
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
4800
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4801
{
4802
	struct iwl_ucode *ucode;
4803
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
4804 4805
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
4806 4807 4808 4809
	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 已提交
4810 4811
	u8 *src;
	size_t len;
4812
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
4813 4814 4815

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
4816 4817 4818 4819
	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) {
4820
			IWL_ERR(priv, "%s firmware file req failed: %d\n",
4821 4822 4823 4824 4825 4826 4827
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
4828 4829 4830
				IWL_ERR(priv, "Loaded firmware %s, "
					"which is deprecated. "
					" Please use API v%u instead.\n",
4831 4832 4833 4834 4835
					  buf, api_max);
			IWL_DEBUG_INFO("Got firmware '%s' file (%zd bytes) from disk\n",
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
4836 4837
	}

4838 4839
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
4840 4841 4842

	/* Make sure that we got at least our header! */
	if (ucode_raw->size < sizeof(*ucode)) {
4843
		IWL_ERR(priv, "File size way too small!\n");
4844
		ret = -EINVAL;
Z
Zhu Yi 已提交
4845 4846 4847 4848 4849 4850
		goto err_release;
	}

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

4851
	priv->ucode_ver = le32_to_cpu(ucode->ver);
4852
	api_ver = IWL_UCODE_API(priv->ucode_ver);
Z
Zhu Yi 已提交
4853 4854 4855 4856 4857 4858
	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);

4859 4860 4861 4862 4863
	/* 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) {
4864
		IWL_ERR(priv, "Driver unable to support your firmware API. "
4865 4866 4867 4868 4869 4870 4871
			  "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)
4872
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
4873 4874 4875 4876
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
4877 4878 4879 4880 4881 4882
	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));

4883 4884
	IWL_DEBUG_INFO("f/w package hdr ucode version raw = 0x%x\n",
		       priv->ucode_ver);
4885 4886 4887 4888 4889
	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 已提交
4890

4891

Z
Zhu Yi 已提交
4892 4893 4894 4895 4896 4897 4898
	/* 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);
4899
		ret = -EINVAL;
Z
Zhu Yi 已提交
4900 4901 4902 4903
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
4904
	if (inst_size > IWL39_MAX_INST_SIZE) {
4905 4906 4907
		IWL_DEBUG_INFO("uCode instr len %d too large to fit in\n",
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4908 4909 4910
		goto err_release;
	}

4911
	if (data_size > IWL39_MAX_DATA_SIZE) {
4912 4913 4914
		IWL_DEBUG_INFO("uCode data len %d too large to fit in\n",
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4915 4916
		goto err_release;
	}
4917
	if (init_size > IWL39_MAX_INST_SIZE) {
4918 4919 4920
		IWL_DEBUG_INFO("uCode init instr len %d too large to fit in\n",
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4921 4922
		goto err_release;
	}
4923
	if (init_data_size > IWL39_MAX_DATA_SIZE) {
4924 4925 4926
		IWL_DEBUG_INFO("uCode init data len %d too large to fit in\n",
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4927 4928
		goto err_release;
	}
4929
	if (boot_size > IWL39_MAX_BSM_SIZE) {
4930 4931 4932
		IWL_DEBUG_INFO("uCode boot instr len %d too large to fit in\n",
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4933 4934 4935 4936 4937 4938 4939 4940 4941
		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;
4942
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
4943 4944

	priv->ucode_data.len = data_size;
4945
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
4946 4947

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

4950 4951 4952
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
4953 4954

	/* Initialization instructions and data */
4955 4956
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
4957
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
4958 4959

		priv->ucode_init_data.len = init_data_size;
4960
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
4961 4962 4963 4964

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

	/* Bootstrap (instructions only, no data) */
4967 4968
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
4969
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
4970

4971 4972 4973
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
4974 4975 4976 4977 4978 4979

	/* 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;
4980
	IWL_DEBUG_INFO("Copying (but not loading) uCode instr len %Zd\n", len);
Z
Zhu Yi 已提交
4981 4982 4983 4984 4985
	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 已提交
4986
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
Z
Zhu Yi 已提交
4987 4988
	src = &ucode->data[inst_size];
	len = priv->ucode_data.len;
4989
	IWL_DEBUG_INFO("Copying (but not loading) uCode data len %Zd\n", len);
Z
Zhu Yi 已提交
4990 4991 4992 4993 4994 4995 4996
	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;
4997 4998
		IWL_DEBUG_INFO("Copying (but not loading) init instr len %Zd\n",
			       len);
Z
Zhu Yi 已提交
4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022
		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:
5023
	IWL_ERR(priv, "failed to allocate pci memory\n");
5024
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
5025
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
5026 5027 5028 5029 5030

 err_release:
	release_firmware(ucode_raw);

 error:
5031
	return ret;
Z
Zhu Yi 已提交
5032 5033 5034 5035
}


/**
C
Christoph Hellwig 已提交
5036
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
5037 5038 5039 5040 5041 5042 5043
 *
 * 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.
 */
5044
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055
{
	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);
5056
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
5057 5058 5059 5060 5061 5062
	if (rc) {
		spin_unlock_irqrestore(&priv->lock, flags);
		return rc;
	}

	/* Tell bootstrap uCode where to find image to load */
5063 5064 5065
	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 已提交
5066 5067
				 priv->ucode_data.len);

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

5073
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
5074 5075 5076 5077 5078 5079 5080 5081 5082

	spin_unlock_irqrestore(&priv->lock, flags);

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

	return rc;
}

/**
C
Christoph Hellwig 已提交
5083
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
5084 5085 5086 5087
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
5088
 */
5089
static void iwl3945_init_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101
{
	/* 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 已提交
5102
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
5103 5104 5105 5106 5107 5108 5109 5110 5111 5112
		/* 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 已提交
5113
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125
		/* 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);
}


5126 5127 5128 5129
/* temporary */
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw,
				     struct sk_buff *skb);

Z
Zhu Yi 已提交
5130
/**
C
Christoph Hellwig 已提交
5131
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
5132
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
5133
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
5134
 */
5135
static void iwl3945_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152
{
	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 已提交
5153
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
5154 5155 5156 5157 5158 5159
		/* 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 已提交
5160
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5161

5162
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
5163
	if (rc) {
5164
		IWL_WARN(priv, "Can not read RFKILL status from adapter\n");
Z
Zhu Yi 已提交
5165 5166 5167
		return;
	}

5168
	rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
Z
Zhu Yi 已提交
5169
	IWL_DEBUG_INFO("RFKILL status: 0x%x\n", rfkill);
5170
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
5171 5172 5173

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
5174
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
5175
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
5176
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
5177 5178 5179 5180 5181 5182 5183 5184 5185 5186
			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);

5187
	/* After the ALIVE response, we can send commands to 3945 uCode */
Z
Zhu Yi 已提交
5188 5189 5190 5191 5192
	set_bit(STATUS_ALIVE, &priv->status);

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

5193
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
5194 5195
		return;

5196
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
5197 5198 5199 5200

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

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

C
Christoph Hellwig 已提交
5203 5204
	if (iwl3945_is_associated(priv)) {
		struct iwl3945_rxon_cmd *active_rxon =
5205
				(struct iwl3945_rxon_cmd *)(&priv->active39_rxon);
Z
Zhu Yi 已提交
5206

5207 5208
		memcpy(&priv->staging39_rxon, &priv->active39_rxon,
		       sizeof(priv->staging39_rxon));
Z
Zhu Yi 已提交
5209 5210 5211
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
5212
		iwl3945_connection_init_rx_config(priv, priv->iw_mode);
5213
		memcpy(priv->staging39_rxon.node_addr, priv->mac_addr, ETH_ALEN);
Z
Zhu Yi 已提交
5214 5215
	}

5216
	/* Configure Bluetooth device coexistence support */
C
Christoph Hellwig 已提交
5217
	iwl3945_send_bt_config(priv);
Z
Zhu Yi 已提交
5218 5219

	/* Configure the adapter for unassociated operation */
C
Christoph Hellwig 已提交
5220
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5221 5222 5223

	iwl3945_reg_txpower_periodic(priv);

5224 5225
	iwl3945_led_register(priv);

Z
Zhu Yi 已提交
5226
	IWL_DEBUG_INFO("ALIVE processing complete.\n");
5227
	set_bit(STATUS_READY, &priv->status);
5228
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
5229 5230

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

5233 5234 5235 5236 5237 5238 5239 5240
	/* 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 已提交
5241 5242 5243 5244 5245 5246
	return;

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

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

5249
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261
{
	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 已提交
5262
	iwl3945_led_unregister(priv);
C
Christoph Hellwig 已提交
5263
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5264 5265 5266 5267 5268 5269 5270 5271 5272 5273

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

	/* tell the device to stop sending interrupts */
5277
	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
5278
	iwl3945_disable_interrupts(priv);
5279 5280
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
5281 5282 5283 5284

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

C
Christoph Hellwig 已提交
5285
	/* If we have not previously called iwl3945_init() then
Z
Zhu Yi 已提交
5286
	 * clear all bits but the RF Kill and SUSPEND bits and return */
5287
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
5288 5289 5290 5291
		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 |
5292 5293
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
5294
			       test_bit(STATUS_IN_SUSPEND, &priv->status) <<
5295 5296 5297
					STATUS_IN_SUSPEND |
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
5298 5299 5300 5301 5302 5303 5304 5305 5306
		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 |
5307 5308
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
5309 5310 5311
			test_bit(STATUS_IN_SUSPEND, &priv->status) <<
				STATUS_IN_SUSPEND |
			test_bit(STATUS_FW_ERROR, &priv->status) <<
5312 5313 5314
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
5315 5316

	spin_lock_irqsave(&priv->lock, flags);
5317
	iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
Z
Zhu Yi 已提交
5318 5319
	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
5320 5321
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
5322 5323

	spin_lock_irqsave(&priv->lock, flags);
5324 5325
	if (!iwl_grab_nic_access(priv)) {
		iwl_write_prph(priv, APMG_CLK_DIS_REG,
Z
Zhu Yi 已提交
5326
					 APMG_CLK_VAL_DMA_CLK_RQT);
5327
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
5328 5329 5330 5331 5332
	}
	spin_unlock_irqrestore(&priv->lock, flags);

	udelay(5);

K
Kolekar, Abhijeet 已提交
5333
	priv->cfg->ops->lib->apm_ops.reset(priv);
Z
Zhu Yi 已提交
5334
 exit:
5335
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
5336 5337 5338 5339 5340 5341

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
5342
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
5343 5344
}

5345
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5346 5347
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5348
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
5349
	mutex_unlock(&priv->mutex);
5350

C
Christoph Hellwig 已提交
5351
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
5352 5353 5354 5355
}

#define MAX_HW_RESTARTS 5

5356
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5357 5358 5359 5360
{
	int rc, i;

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
5361
		IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
Z
Zhu Yi 已提交
5362 5363 5364 5365
		return -EIO;
	}

	if (test_bit(STATUS_RF_KILL_SW, &priv->status)) {
5366
		IWL_WARN(priv, "Radio disabled by SW RF kill (module "
Z
Zhu Yi 已提交
5367
			    "parameter)\n");
5368 5369 5370
		return -ENODEV;
	}

5371
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
5372
		IWL_ERR(priv, "ucode not available for device bring up\n");
5373 5374 5375
		return -EIO;
	}

5376
	/* If platform's RF_KILL switch is NOT set to KILL */
5377
	if (iwl_read32(priv, CSR_GP_CNTRL) &
5378 5379 5380 5381 5382
				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)) {
5383
			IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
5384 5385
			return -ENODEV;
		}
Z
Zhu Yi 已提交
5386
	}
5387

5388
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
5389

C
Christoph Hellwig 已提交
5390
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
5391
	if (rc) {
5392
		IWL_ERR(priv, "Unable to int nic\n");
Z
Zhu Yi 已提交
5393 5394 5395 5396
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
5397 5398
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
5399 5400 5401
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
5402
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
C
Christoph Hellwig 已提交
5403
	iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
5404 5405

	/* really make sure rfkill handshake bits are cleared */
5406 5407
	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 已提交
5408 5409 5410 5411 5412

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

5415 5416 5417 5418
	/* 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 已提交
5419 5420
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

C
Christoph Hellwig 已提交
5421
		iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
5422 5423 5424 5425

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

		if (rc) {
5429 5430
			IWL_ERR(priv,
				"Unable to set up bootstrap uCode: %d\n", rc);
Z
Zhu Yi 已提交
5431 5432 5433 5434
			continue;
		}

		/* start card; "initialize" will load runtime ucode */
C
Christoph Hellwig 已提交
5435
		iwl3945_nic_start(priv);
Z
Zhu Yi 已提交
5436 5437 5438 5439 5440 5441 5442

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

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
5443
	__iwl3945_down(priv);
5444
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
5445 5446 5447

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
5448
	IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
Z
Zhu Yi 已提交
5449 5450 5451 5452 5453 5454 5455 5456 5457 5458
	return -EIO;
}


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

C
Christoph Hellwig 已提交
5459
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
5460
{
5461 5462
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, init_alive_start.work);
Z
Zhu Yi 已提交
5463 5464 5465 5466 5467

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5468
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
5469 5470 5471
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5472
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
5473
{
5474 5475
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, alive_start.work);
Z
Zhu Yi 已提交
5476 5477 5478 5479 5480

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5481
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
5482 5483 5484
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5485
static void iwl3945_bg_rf_kill(struct work_struct *work)
Z
Zhu Yi 已提交
5486
{
5487
	struct iwl_priv *priv = container_of(work, struct iwl_priv, rf_kill);
Z
Zhu Yi 已提交
5488 5489 5490 5491 5492 5493 5494 5495

	wake_up_interruptible(&priv->wait_command_queue);

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

	mutex_lock(&priv->mutex);

5496
	if (!iwl_is_rfkill(priv)) {
Z
Zhu Yi 已提交
5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507
		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
5508
			IWL_WARN(priv, "Radio Frequency Kill Switch is On:\n"
Z
Zhu Yi 已提交
5509 5510 5511
				    "Kill switch must be turned off for "
				    "wireless networking to work.\n");
	}
5512

Z
Zhu Yi 已提交
5513
	mutex_unlock(&priv->mutex);
5514
	iwl3945_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
5515 5516 5517 5518
}

#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)

C
Christoph Hellwig 已提交
5519
static void iwl3945_bg_scan_check(struct work_struct *data)
Z
Zhu Yi 已提交
5520
{
5521 5522
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, scan_check.work);
Z
Zhu Yi 已提交
5523 5524 5525 5526 5527 5528 5529 5530 5531 5532

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

Z
Zhu Yi 已提交
5534
		if (!test_bit(STATUS_EXIT_PENDING, &priv->status))
C
Christoph Hellwig 已提交
5535
			iwl3945_send_scan_abort(priv);
Z
Zhu Yi 已提交
5536 5537 5538 5539
	}
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5540
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
5541
{
5542 5543
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
5544
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
5545
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
5546
		.len = sizeof(struct iwl3945_scan_cmd),
Z
Zhu Yi 已提交
5547 5548 5549
		.meta.flags = CMD_SIZE_HUGE,
	};
	int rc = 0;
C
Christoph Hellwig 已提交
5550
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
5551
	struct ieee80211_conf *conf = NULL;
5552
	u8 n_probes = 2;
5553
	enum ieee80211_band band;
5554
	DECLARE_SSID_BUF(ssid);
Z
Zhu Yi 已提交
5555 5556 5557 5558 5559

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

5560
	if (!iwl_is_ready(priv)) {
5561
		IWL_WARN(priv, "request scan called when driver not ready.\n");
Z
Zhu Yi 已提交
5562 5563 5564
		goto done;
	}

T
Tomas Winkler 已提交
5565
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588
	 * 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;
	}

5589
	if (iwl_is_rfkill(priv)) {
Z
Zhu Yi 已提交
5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603
		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;
	}

5604 5605
	if (!priv->scan39) {
		priv->scan39 = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
5606
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
5607
		if (!priv->scan39) {
Z
Zhu Yi 已提交
5608 5609 5610 5611
			rc = -ENOMEM;
			goto done;
		}
	}
5612
	scan = priv->scan39;
C
Christoph Hellwig 已提交
5613
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
5614 5615 5616 5617

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

C
Christoph Hellwig 已提交
5618
	if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631
		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;
5632
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654
		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",
5655 5656
		     print_ssid(ssid, priv->direct_ssid,
				priv->direct_ssid_len));
Z
Zhu Yi 已提交
5657 5658 5659 5660
		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);
5661 5662
		n_probes++;
	} else
5663
		IWL_DEBUG_SCAN("Kicking off one indirect scan.\n");
Z
Zhu Yi 已提交
5664 5665 5666 5667

	/* 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 已提交
5668
		iwl3945_fill_probe_req(priv, (struct ieee80211_mgmt *)scan->data,
J
Johannes Berg 已提交
5669
			IWL_MAX_SCAN_SIZE - sizeof(*scan)));
Z
Zhu Yi 已提交
5670
	scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
5671
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
5672 5673 5674 5675
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

5676
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
5677 5678 5679
		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;
5680
		band = IEEE80211_BAND_2GHZ;
5681
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
5682 5683
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
		scan->good_CRC_th = IWL_GOOD_CRC_TH;
5684
		band = IEEE80211_BAND_5GHZ;
5685
	} else {
5686
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
5687 5688 5689 5690 5691 5692
		goto done;
	}

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

5693
	if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
Z
Zhu Yi 已提交
5694 5695
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

5696 5697 5698 5699
	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 已提交
5700

5701 5702 5703 5704 5705
	if (scan->channel_count == 0) {
		IWL_DEBUG_SCAN("channel count %d\n", scan->channel_count);
		goto done;
	}

Z
Zhu Yi 已提交
5706
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
5707
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
5708 5709 5710 5711
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
C
Christoph Hellwig 已提交
5712
	rc = iwl3945_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
5713 5714 5715 5716 5717 5718 5719 5720 5721 5722
	if (rc)
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
5723 5724 5725 5726 5727 5728 5729 5730
	/* 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);

5731
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
5732 5733 5734 5735
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
5736
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
5737
{
5738
	struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
Z
Zhu Yi 已提交
5739 5740 5741 5742 5743

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5744
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
5745
	mutex_unlock(&priv->mutex);
5746
	iwl3945_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
5747 5748
}

C
Christoph Hellwig 已提交
5749
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
5750
{
5751
	struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
Z
Zhu Yi 已提交
5752 5753 5754 5755

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

C
Christoph Hellwig 已提交
5756
	iwl3945_down(priv);
Z
Zhu Yi 已提交
5757 5758 5759
	queue_work(priv->workqueue, &priv->up);
}

C
Christoph Hellwig 已提交
5760
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
5761
{
5762 5763
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rx_replenish);
Z
Zhu Yi 已提交
5764 5765 5766 5767 5768

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
5769
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
5770 5771 5772
	mutex_unlock(&priv->mutex);
}

5773 5774
#define IWL_DELAY_NEXT_SCAN (HZ*2)

5775
static void iwl3945_post_associate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5776 5777 5778 5779
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

5780
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
5781
		IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
5782 5783 5784 5785
		return;
	}


J
Johannes Berg 已提交
5786
	IWL_DEBUG_ASSOC("Associated as %d to: %pM\n",
5787
			priv->assoc_id, priv->active39_rxon.bssid_addr);
Z
Zhu Yi 已提交
5788 5789 5790 5791

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

A
Abhijeet Kolekar 已提交
5792
	if (!priv->vif || !priv->is_open)
5793
		return;
A
Abhijeet Kolekar 已提交
5794

C
Christoph Hellwig 已提交
5795
	iwl3945_scan_cancel_timeout(priv, 200);
5796

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

5799
	priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
5800
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5801

5802
	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
5803 5804
	iwl3945_setup_rxon_timing(priv);
	rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
5805 5806
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
5807
		IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
5808 5809
			    "Attempting to continue.\n");

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

5812
	priv->staging39_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
5813 5814 5815 5816 5817

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

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
5818
		priv->staging39_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
5819
	else
5820
		priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
5821

5822
	if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
5823
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
5824
			priv->staging39_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
5825
		else
5826
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
5827

5828
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
5829
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
5830 5831 5832

	}

C
Christoph Hellwig 已提交
5833
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5834 5835

	switch (priv->iw_mode) {
5836
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
5837
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
5838 5839
		break;

5840
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
5841

5842
		priv->assoc_id = 1;
C
Christoph Hellwig 已提交
5843
		iwl3945_add_station(priv, priv->bssid, 0, 0);
Z
Zhu Yi 已提交
5844
		iwl3945_sync_sta(priv, IWL_STA_ID,
5845
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
5846 5847
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
5848 5849
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
5850 5851 5852 5853

		break;

	default:
5854
		 IWL_ERR(priv, "%s Should not be called in %d mode\n",
5855
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
5856 5857 5858
		break;
	}

C
Christoph Hellwig 已提交
5859
	iwl3945_activate_qos(priv, 0);
5860

5861 5862
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
5863 5864
}

C
Christoph Hellwig 已提交
5865
static void iwl3945_bg_abort_scan(struct work_struct *work)
Z
Zhu Yi 已提交
5866
{
5867
	struct iwl_priv *priv = container_of(work, struct iwl_priv, abort_scan);
Z
Zhu Yi 已提交
5868

5869
	if (!iwl_is_ready(priv))
Z
Zhu Yi 已提交
5870 5871 5872 5873 5874
		return;

	mutex_lock(&priv->mutex);

	set_bit(STATUS_SCAN_ABORTING, &priv->status);
C
Christoph Hellwig 已提交
5875
	iwl3945_send_scan_abort(priv);
Z
Zhu Yi 已提交
5876 5877 5878 5879

	mutex_unlock(&priv->mutex);
}

5880
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed);
5881

C
Christoph Hellwig 已提交
5882
static void iwl3945_bg_scan_completed(struct work_struct *work)
Z
Zhu Yi 已提交
5883
{
5884 5885
	struct iwl_priv *priv =
	    container_of(work, struct iwl_priv, scan_completed);
Z
Zhu Yi 已提交
5886 5887 5888 5889 5890 5891

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

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

5892
	if (test_bit(STATUS_CONF_PENDING, &priv->status))
5893
		iwl3945_mac_config(priv->hw, 0);
5894

Z
Zhu Yi 已提交
5895 5896 5897 5898 5899
	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 已提交
5900
	iwl3945_hw_reg_send_txpower(priv);
Z
Zhu Yi 已提交
5901 5902 5903 5904 5905 5906 5907 5908 5909
	mutex_unlock(&priv->mutex);
}

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

5910 5911
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
5912
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
5913
{
5914
	struct iwl_priv *priv = hw->priv;
5915
	int ret;
Z
Zhu Yi 已提交
5916 5917 5918

	IWL_DEBUG_MAC80211("enter\n");

5919
	if (pci_enable_device(priv->pci_dev)) {
5920
		IWL_ERR(priv, "Fail to pci_enable_device\n");
5921 5922 5923 5924 5925 5926 5927 5928
		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) {
5929
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
5930 5931 5932
		goto out_disable_msi;
	}

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

5936
	memset(&priv->staging39_rxon, 0, sizeof(struct iwl3945_rxon_cmd));
5937 5938 5939 5940 5941 5942
	/* 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) {
5943
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
5944 5945 5946 5947
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
5948

5949
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
5950 5951

	mutex_unlock(&priv->mutex);
5952

5953 5954
	iwl3945_rfkill_set_hw_state(priv);

5955 5956 5957 5958 5959 5960 5961 5962
	if (ret)
		goto out_release_irq;

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

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

5963 5964 5965 5966 5967 5968 5969
	/* 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)) {
5970 5971 5972
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
5973 5974 5975 5976 5977
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

5978
	priv->is_open = 1;
Z
Zhu Yi 已提交
5979 5980
	IWL_DEBUG_MAC80211("leave\n");
	return 0;
5981 5982 5983 5984 5985

out_release_irq:
	free_irq(priv->pci_dev->irq, priv);
out_disable_msi:
	pci_disable_msi(priv->pci_dev);
5986 5987 5988
	pci_disable_device(priv->pci_dev);
	priv->is_open = 0;
	IWL_DEBUG_MAC80211("leave - failed\n");
5989
	return ret;
Z
Zhu Yi 已提交
5990 5991
}

C
Christoph Hellwig 已提交
5992
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
5993
{
5994
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
5995 5996

	IWL_DEBUG_MAC80211("enter\n");
5997

5998 5999 6000 6001 6002
	if (!priv->is_open) {
		IWL_DEBUG_MAC80211("leave - skip\n");
		return;
	}

Z
Zhu Yi 已提交
6003
	priv->is_open = 0;
6004

6005
	if (iwl_is_ready_rf(priv)) {
6006 6007 6008
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
6009 6010
		mutex_lock(&priv->mutex);
		iwl3945_scan_cancel_timeout(priv, 100);
6011 6012 6013
		mutex_unlock(&priv->mutex);
	}

6014 6015 6016 6017 6018 6019 6020
	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);
6021

Z
Zhu Yi 已提交
6022 6023 6024
	IWL_DEBUG_MAC80211("leave\n");
}

6025
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
6026
{
6027
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6028 6029 6030 6031

	IWL_DEBUG_MAC80211("enter\n");

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

6034
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
6035 6036 6037
		dev_kfree_skb_any(skb);

	IWL_DEBUG_MAC80211("leave\n");
6038
	return NETDEV_TX_OK;
Z
Zhu Yi 已提交
6039 6040
}

C
Christoph Hellwig 已提交
6041
static int iwl3945_mac_add_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
6042 6043
				 struct ieee80211_if_init_conf *conf)
{
6044
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6045 6046
	unsigned long flags;

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

6049 6050
	if (priv->vif) {
		IWL_DEBUG_MAC80211("leave - vif != NULL\n");
6051
		return -EOPNOTSUPP;
Z
Zhu Yi 已提交
6052 6053 6054
	}

	spin_lock_irqsave(&priv->lock, flags);
6055
	priv->vif = conf->vif;
6056
	priv->iw_mode = conf->type;
Z
Zhu Yi 已提交
6057 6058 6059 6060

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
6061 6062

	if (conf->mac_addr) {
J
Johannes Berg 已提交
6063
		IWL_DEBUG_MAC80211("Set: %pM\n", conf->mac_addr);
6064 6065 6066
		memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
	}

6067
	if (iwl_is_ready(priv))
6068
		iwl3945_set_mode(priv, conf->type);
Z
Zhu Yi 已提交
6069 6070 6071

	mutex_unlock(&priv->mutex);

6072
	IWL_DEBUG_MAC80211("leave\n");
Z
Zhu Yi 已提交
6073 6074 6075 6076
	return 0;
}

/**
C
Christoph Hellwig 已提交
6077
 * iwl3945_mac_config - mac80211 config callback
Z
Zhu Yi 已提交
6078 6079 6080 6081 6082
 *
 * 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.
 */
6083
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed)
Z
Zhu Yi 已提交
6084
{
6085
	struct iwl_priv *priv = hw->priv;
6086
	const struct iwl_channel_info *ch_info;
6087
	struct ieee80211_conf *conf = &hw->conf;
Z
Zhu Yi 已提交
6088
	unsigned long flags;
6089
	int ret = 0;
Z
Zhu Yi 已提交
6090 6091

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

6094
	if (!iwl_is_ready(priv)) {
Z
Zhu Yi 已提交
6095
		IWL_DEBUG_MAC80211("leave - not ready\n");
6096 6097
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
6098 6099
	}

6100
	if (unlikely(!iwl3945_mod_params.disable_hw_scan &&
Z
Zhu Yi 已提交
6101
		     test_bit(STATUS_SCANNING, &priv->status))) {
6102 6103
		IWL_DEBUG_MAC80211("leave - scanning\n");
		set_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
6104
		mutex_unlock(&priv->mutex);
6105
		return 0;
Z
Zhu Yi 已提交
6106 6107 6108 6109
	}

	spin_lock_irqsave(&priv->lock, flags);

6110 6111
	ch_info = iwl3945_get_channel_info(priv, conf->channel->band,
					   conf->channel->hw_value);
Z
Zhu Yi 已提交
6112
	if (!is_channel_valid(ch_info)) {
6113
		IWL_DEBUG_SCAN("Channel %d [%d] is INVALID for this band.\n",
6114
			       conf->channel->hw_value, conf->channel->band);
Z
Zhu Yi 已提交
6115 6116
		IWL_DEBUG_MAC80211("leave - invalid channel\n");
		spin_unlock_irqrestore(&priv->lock, flags);
6117 6118
		ret = -EINVAL;
		goto out;
Z
Zhu Yi 已提交
6119 6120
	}

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

6123
	iwl3945_set_flags_for_phymode(priv, conf->channel->band);
Z
Zhu Yi 已提交
6124 6125 6126 6127

	/* 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 已提交
6128
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6129 6130 6131 6132 6133

	spin_unlock_irqrestore(&priv->lock, flags);

#ifdef IEEE80211_CONF_CHANNEL_SWITCH
	if (conf->flags & IEEE80211_CONF_CHANNEL_SWITCH) {
C
Christoph Hellwig 已提交
6134
		iwl3945_hw_channel_switch(priv, conf->channel);
6135
		goto out;
Z
Zhu Yi 已提交
6136 6137 6138
	}
#endif

C
Christoph Hellwig 已提交
6139
	iwl3945_radio_kill_sw(priv, !conf->radio_enabled);
Z
Zhu Yi 已提交
6140 6141 6142

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

6146
	if (iwl_is_rfkill(priv)) {
Z
Zhu Yi 已提交
6147
		IWL_DEBUG_MAC80211("leave - RF kill\n");
6148 6149
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
6150 6151
	}

C
Christoph Hellwig 已提交
6152
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6153

6154 6155
	if (memcmp(&priv->active39_rxon,
		   &priv->staging39_rxon, sizeof(priv->staging39_rxon)))
C
Christoph Hellwig 已提交
6156
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6157 6158 6159 6160 6161
	else
		IWL_DEBUG_INFO("No re-sending same RXON configuration.\n");

	IWL_DEBUG_MAC80211("leave\n");

6162
out:
6163
	clear_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
6164
	mutex_unlock(&priv->mutex);
6165
	return ret;
Z
Zhu Yi 已提交
6166 6167
}

6168
static void iwl3945_config_ap(struct iwl_priv *priv)
Z
Zhu Yi 已提交
6169 6170 6171
{
	int rc = 0;

6172
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
6173 6174 6175
		return;

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

		/* RXON - unassoc (to set timing command) */
6179
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6180
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6181 6182

		/* RXON Timing */
6183
		memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
6184 6185
		iwl3945_setup_rxon_timing(priv);
		rc = iwl3945_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
6186 6187
				sizeof(priv->rxon_timing), &priv->rxon_timing);
		if (rc)
6188
			IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
6189 6190 6191
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
6192
		priv->staging39_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
6193
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
6194
			priv->staging39_rxon.flags |=
Z
Zhu Yi 已提交
6195 6196
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
6197
			priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
6198 6199
				~RXON_FLG_SHORT_PREAMBLE_MSK;

6200
		if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
6201 6202
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
6203
				priv->staging39_rxon.flags |=
Z
Zhu Yi 已提交
6204 6205
					RXON_FLG_SHORT_SLOT_MSK;
			else
6206
				priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
6207 6208
					~RXON_FLG_SHORT_SLOT_MSK;

6209
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
6210
				priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
6211 6212 6213
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
6214
		priv->staging39_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6215
		iwl3945_commit_rxon(priv);
6216
		iwl3945_add_station(priv, iwl_bcast_addr, 0, 0);
6217
	}
C
Christoph Hellwig 已提交
6218
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
6219 6220 6221 6222 6223 6224

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

6225 6226
static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
6227
					struct ieee80211_if_conf *conf)
Z
Zhu Yi 已提交
6228
{
6229
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6230 6231 6232 6233 6234
	int rc;

	if (conf == NULL)
		return -EIO;

6235 6236 6237 6238 6239
	if (priv->vif != vif) {
		IWL_DEBUG_MAC80211("leave - priv->vif != vif\n");
		return 0;
	}

6240
	/* handle this temporarily here */
6241
	if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
6242 6243 6244 6245
	    conf->changed & IEEE80211_IFCC_BEACON) {
		struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
		if (!beacon)
			return -ENOMEM;
6246
		mutex_lock(&priv->mutex);
6247
		rc = iwl3945_mac_beacon_update(hw, beacon);
6248
		mutex_unlock(&priv->mutex);
6249 6250 6251 6252
		if (rc)
			return rc;
	}

6253
	if (!iwl_is_alive(priv))
6254 6255
		return -EAGAIN;

Z
Zhu Yi 已提交
6256 6257 6258
	mutex_lock(&priv->mutex);

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

6261 6262 6263
/*
 * very dubious code was here; the probe filtering flag is never set:
 *
Z
Zhu Yi 已提交
6264 6265
	if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
	    !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
6266
 */
Z
Zhu Yi 已提交
6267

6268
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
6269 6270 6271
		if (!conf->bssid) {
			conf->bssid = priv->mac_addr;
			memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
J
Johannes Berg 已提交
6272 6273
			IWL_DEBUG_MAC80211("bssid was set to: %pM\n",
					   conf->bssid);
Z
Zhu Yi 已提交
6274 6275 6276 6277
		}
		if (priv->ibss_beacon)
			dev_kfree_skb(priv->ibss_beacon);

6278
		priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
Z
Zhu Yi 已提交
6279 6280
	}

6281
	if (iwl_is_rfkill(priv))
6282 6283
		goto done;

Z
Zhu Yi 已提交
6284 6285 6286 6287
	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 已提交
6288
		if (iwl3945_scan_cancel_timeout(priv, 100)) {
6289
			IWL_WARN(priv, "Aborted scan still in progress "
Z
Zhu Yi 已提交
6290 6291 6292 6293 6294
				    "after 100ms\n");
			IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
			mutex_unlock(&priv->mutex);
			return -EAGAIN;
		}
6295
		memcpy(priv->staging39_rxon.bssid_addr, conf->bssid, ETH_ALEN);
Z
Zhu Yi 已提交
6296 6297 6298 6299 6300 6301 6302

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

6303
		if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
6304
			iwl3945_config_ap(priv);
Z
Zhu Yi 已提交
6305
		else {
C
Christoph Hellwig 已提交
6306
			rc = iwl3945_commit_rxon(priv);
6307
			if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
C
Christoph Hellwig 已提交
6308
				iwl3945_add_station(priv,
6309
					priv->active39_rxon.bssid_addr, 1, 0);
Z
Zhu Yi 已提交
6310 6311 6312
		}

	} else {
C
Christoph Hellwig 已提交
6313
		iwl3945_scan_cancel_timeout(priv, 100);
6314
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6315
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6316 6317
	}

6318
 done:
Z
Zhu Yi 已提交
6319 6320 6321 6322 6323 6324
	IWL_DEBUG_MAC80211("leave\n");
	mutex_unlock(&priv->mutex);

	return 0;
}

C
Christoph Hellwig 已提交
6325
static void iwl3945_configure_filter(struct ieee80211_hw *hw,
6326 6327 6328 6329
				 unsigned int changed_flags,
				 unsigned int *total_flags,
				 int mc_count, struct dev_addr_list *mc_list)
{
6330
	struct iwl_priv *priv = hw->priv;
6331
	__le32 *filter_flags = &priv->staging39_rxon.filter_flags;
6332

Z
Zhu, Yi 已提交
6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352
	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;
6353
	}
Z
Zhu, Yi 已提交
6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367
	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 |
6368
			FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
6369 6370
}

C
Christoph Hellwig 已提交
6371
static void iwl3945_mac_remove_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
6372 6373
				     struct ieee80211_if_init_conf *conf)
{
6374
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6375 6376 6377 6378

	IWL_DEBUG_MAC80211("enter\n");

	mutex_lock(&priv->mutex);
6379

6380
	if (iwl_is_ready_rf(priv)) {
6381
		iwl3945_scan_cancel_timeout(priv, 100);
6382
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
6383 6384
		iwl3945_commit_rxon(priv);
	}
6385 6386
	if (priv->vif == conf->vif) {
		priv->vif = NULL;
Z
Zhu Yi 已提交
6387 6388 6389 6390 6391 6392 6393
		memset(priv->bssid, 0, ETH_ALEN);
	}
	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");
}

6394 6395 6396 6397 6398 6399 6400
#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)
{
6401
	struct iwl_priv *priv = hw->priv;
6402 6403 6404 6405 6406 6407 6408

	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)
6409
			priv->staging39_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
6410
		else
6411
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
6412 6413 6414 6415 6416
	}

	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))
6417
			priv->staging39_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
6418
		else
6419
			priv->staging39_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430
	}

	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;
6431
			priv->timestamp = bss_conf->timestamp;
6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448
			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 已提交
6449
static int iwl3945_mac_hw_scan(struct ieee80211_hw *hw, u8 *ssid, size_t len)
Z
Zhu Yi 已提交
6450 6451 6452
{
	int rc = 0;
	unsigned long flags;
6453
	struct iwl_priv *priv = hw->priv;
6454
	DECLARE_SSID_BUF(ssid_buf);
Z
Zhu Yi 已提交
6455 6456 6457

	IWL_DEBUG_MAC80211("enter\n");

6458
	mutex_lock(&priv->mutex);
Z
Zhu Yi 已提交
6459 6460
	spin_lock_irqsave(&priv->lock, flags);

6461
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
6462 6463 6464 6465 6466
		rc = -EIO;
		IWL_DEBUG_MAC80211("leave - not ready or exit pending\n");
		goto out_unlock;
	}

6467 6468 6469 6470 6471 6472
	/* 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;
	}
6473 6474 6475 6476
	/* 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 已提交
6477 6478 6479 6480
		rc = -EAGAIN;
		goto out_unlock;
	}
	if (len) {
6481
		IWL_DEBUG_SCAN("direct scan for %s [%d]\n ",
6482
			       print_ssid(ssid_buf, ssid, len), (int)len);
Z
Zhu Yi 已提交
6483 6484 6485 6486 6487

		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);
6488 6489
	} else
		priv->one_direct_scan = 0;
Z
Zhu Yi 已提交
6490

C
Christoph Hellwig 已提交
6491
	rc = iwl3945_scan_initiate(priv);
Z
Zhu Yi 已提交
6492 6493 6494 6495 6496

	IWL_DEBUG_MAC80211("leave\n");

out_unlock:
	spin_unlock_irqrestore(&priv->lock, flags);
6497
	mutex_unlock(&priv->mutex);
Z
Zhu Yi 已提交
6498 6499 6500 6501

	return rc;
}

C
Christoph Hellwig 已提交
6502
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
6503 6504 6505
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
Z
Zhu Yi 已提交
6506
{
6507
	struct iwl_priv *priv = hw->priv;
6508
	const u8 *addr;
Z
Zhu Yi 已提交
6509 6510
	int rc = 0;
	u8 sta_id;
6511 6512
	static const u8 bcast_addr[ETH_ALEN] =
		{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
Z
Zhu Yi 已提交
6513 6514 6515

	IWL_DEBUG_MAC80211("enter\n");

6516
	if (iwl3945_mod_params.sw_crypto) {
Z
Zhu Yi 已提交
6517 6518 6519 6520
		IWL_DEBUG_MAC80211("leave - hwcrypto disabled\n");
		return -EOPNOTSUPP;
	}

6521
	addr = sta ? sta->addr : bcast_addr;
Z
Zhu Yi 已提交
6522

C
Christoph Hellwig 已提交
6523
	sta_id = iwl3945_hw_find_station(priv, addr);
Z
Zhu Yi 已提交
6524
	if (sta_id == IWL_INVALID_STATION) {
J
Johannes Berg 已提交
6525 6526
		IWL_DEBUG_MAC80211("leave - %pM not in station map.\n",
				   addr);
Z
Zhu Yi 已提交
6527 6528 6529 6530 6531
		return -EINVAL;
	}

	mutex_lock(&priv->mutex);

C
Christoph Hellwig 已提交
6532
	iwl3945_scan_cancel_timeout(priv, 100);
6533

Z
Zhu Yi 已提交
6534 6535
	switch (cmd) {
	case  SET_KEY:
C
Christoph Hellwig 已提交
6536
		rc = iwl3945_update_sta_key_info(priv, key, sta_id);
Z
Zhu Yi 已提交
6537
		if (!rc) {
C
Christoph Hellwig 已提交
6538 6539
			iwl3945_set_rxon_hwcrypto(priv, 1);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6540 6541 6542 6543 6544 6545
			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 已提交
6546
		rc = iwl3945_clear_sta_key_info(priv, sta_id);
Z
Zhu Yi 已提交
6547
		if (!rc) {
C
Christoph Hellwig 已提交
6548 6549
			iwl3945_set_rxon_hwcrypto(priv, 0);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562
			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 已提交
6563
static int iwl3945_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
Z
Zhu Yi 已提交
6564 6565
			   const struct ieee80211_tx_queue_params *params)
{
6566
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6567 6568 6569 6570 6571
	unsigned long flags;
	int q;

	IWL_DEBUG_MAC80211("enter\n");

6572
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589
		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 =
6590
			cpu_to_le16((params->txop * 32));
Z
Zhu Yi 已提交
6591 6592 6593 6594 6595 6596 6597

	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);
6598
	if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
6599 6600 6601
		iwl3945_activate_qos(priv, 1);
	else if (priv->assoc_id && iwl3945_is_associated(priv))
		iwl3945_activate_qos(priv, 0);
Z
Zhu Yi 已提交
6602 6603 6604 6605 6606 6607 6608

	mutex_unlock(&priv->mutex);

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

C
Christoph Hellwig 已提交
6609
static int iwl3945_mac_get_tx_stats(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
6610 6611
				struct ieee80211_tx_queue_stats *stats)
{
6612
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6613
	int i, avail;
6614
	struct iwl_tx_queue *txq;
6615
	struct iwl_queue *q;
Z
Zhu Yi 已提交
6616 6617 6618 6619
	unsigned long flags;

	IWL_DEBUG_MAC80211("enter\n");

6620
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
6621 6622 6623 6624 6625 6626 6627
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		return -EIO;
	}

	spin_lock_irqsave(&priv->lock, flags);

	for (i = 0; i < AC_NUM; i++) {
6628
		txq = &priv->txq[i];
Z
Zhu Yi 已提交
6629
		q = &txq->q;
6630
		avail = iwl_queue_space(q);
Z
Zhu Yi 已提交
6631

6632 6633 6634
		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 已提交
6635 6636 6637 6638 6639 6640 6641 6642 6643

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

	IWL_DEBUG_MAC80211("leave\n");

	return 0;
}

C
Christoph Hellwig 已提交
6644
static void iwl3945_mac_reset_tsf(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
6645
{
6646
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6647 6648 6649 6650 6651
	unsigned long flags;

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

6652
	iwl_reset_qos(priv);
6653

Z
Zhu Yi 已提交
6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665
	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;
6666
	priv->timestamp = 0;
6667
	if ((priv->iw_mode == NL80211_IFTYPE_STATION))
Z
Zhu Yi 已提交
6668 6669 6670 6671
		priv->beacon_int = 0;

	spin_unlock_irqrestore(&priv->lock, flags);

6672
	if (!iwl_is_ready_rf(priv)) {
6673 6674 6675 6676 6677
		IWL_DEBUG_MAC80211("leave - not ready\n");
		mutex_unlock(&priv->mutex);
		return;
	}

6678 6679 6680
	/* we are restarting association process
	 * clear RXON_FILTER_ASSOC_MSK bit
	*/
6681
	if (priv->iw_mode != NL80211_IFTYPE_AP) {
C
Christoph Hellwig 已提交
6682
		iwl3945_scan_cancel_timeout(priv, 100);
6683
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
6684
		iwl3945_commit_rxon(priv);
6685 6686
	}

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

Z
Zhu Yi 已提交
6690 6691 6692 6693 6694
		IWL_DEBUG_MAC80211("leave - not in IBSS\n");
		mutex_unlock(&priv->mutex);
		return;
	}

C
Christoph Hellwig 已提交
6695
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
6696 6697 6698 6699 6700 6701 6702

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");

}

6703
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
6704
{
6705
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
6706 6707 6708 6709
	unsigned long flags;

	IWL_DEBUG_MAC80211("enter\n");

6710
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
6711 6712 6713 6714
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		return -EIO;
	}

6715
	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
Z
Zhu Yi 已提交
6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731
		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);

6732
	iwl_reset_qos(priv);
Z
Zhu Yi 已提交
6733

6734
	iwl3945_post_associate(priv);
Z
Zhu Yi 已提交
6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745


	return 0;
}

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

6746
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
6747 6748 6749 6750 6751 6752 6753 6754

/*
 * 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.
 */
6755 6756
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
6757
{
6758
	struct iwl_priv *priv = d->driver_data;
6759 6760

	return sprintf(buf, "0x%08X\n", priv->debug_level);
Z
Zhu Yi 已提交
6761
}
6762 6763
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
6764 6765
				 const char *buf, size_t count)
{
6766
	struct iwl_priv *priv = d->driver_data;
6767 6768
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
6769

6770 6771
	ret = strict_strtoul(buf, 0, &val);
	if (ret)
T
Tomas Winkler 已提交
6772
		IWL_INFO(priv, "%s is not in hex or decimal form.\n", buf);
Z
Zhu Yi 已提交
6773
	else
6774
		priv->debug_level = val;
Z
Zhu Yi 已提交
6775 6776 6777 6778

	return strnlen(buf, count);
}

6779 6780
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
6781

6782
#endif /* CONFIG_IWL3945_DEBUG */
Z
Zhu Yi 已提交
6783 6784 6785 6786

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

6789
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
6790 6791
		return -EAGAIN;

C
Christoph Hellwig 已提交
6792
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
6793 6794 6795 6796 6797 6798 6799
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
6800
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
6801 6802 6803 6804 6805 6806 6807
	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)
{
6808
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
6809 6810 6811 6812 6813
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
6814
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
6815
	else
C
Christoph Hellwig 已提交
6816
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
6817 6818 6819 6820 6821 6822 6823 6824 6825

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

6828
	return sprintf(buf, "0x%04X\n", priv->active39_rxon.flags);
Z
Zhu Yi 已提交
6829 6830 6831 6832 6833 6834
}

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

	mutex_lock(&priv->mutex);
6839
	if (le32_to_cpu(priv->staging39_rxon.flags) != flags) {
Z
Zhu Yi 已提交
6840
		/* Cancel any currently running scans... */
C
Christoph Hellwig 已提交
6841
		if (iwl3945_scan_cancel_timeout(priv, 100))
6842
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
6843 6844 6845
		else {
			IWL_DEBUG_INFO("Committing rxon.flags = 0x%04X\n",
				       flags);
6846
			priv->staging39_rxon.flags = cpu_to_le32(flags);
C
Christoph Hellwig 已提交
6847
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859
		}
	}
	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)
{
6860
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
6861 6862

	return sprintf(buf, "0x%04X\n",
6863
		le32_to_cpu(priv->active39_rxon.filter_flags));
Z
Zhu Yi 已提交
6864 6865 6866 6867 6868 6869
}

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

	mutex_lock(&priv->mutex);
6874
	if (le32_to_cpu(priv->staging39_rxon.filter_flags) != filter_flags) {
Z
Zhu Yi 已提交
6875
		/* Cancel any currently running scans... */
C
Christoph Hellwig 已提交
6876
		if (iwl3945_scan_cancel_timeout(priv, 100))
6877
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
6878 6879 6880
		else {
			IWL_DEBUG_INFO("Committing rxon.filter_flags = "
				       "0x%04X\n", filter_flags);
6881
			priv->staging39_rxon.filter_flags =
Z
Zhu Yi 已提交
6882
				cpu_to_le32(filter_flags);
C
Christoph Hellwig 已提交
6883
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6884 6885 6886 6887 6888 6889 6890 6891 6892 6893
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

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

6894
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
6895 6896 6897 6898

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
6899
	struct iwl_priv *priv = dev_get_drvdata(d);
6900
	struct iwl_spectrum_notification measure_report;
Z
Zhu Yi 已提交
6901
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
6902
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931
	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)
{
6932
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6933
	struct ieee80211_measurement_params params = {
6934
		.channel = le16_to_cpu(priv->active39_rxon.channel),
Z
Zhu Yi 已提交
6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957
		.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 已提交
6958
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
6959 6960 6961 6962 6963 6964

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
6965
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
6966 6967 6968 6969 6970

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
6971
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982

	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)
{
6983
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6984 6985 6986 6987 6988 6989 6990 6991 6992 6993
	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)
{
6994
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6995 6996 6997 6998 6999 7000
	int rc;
	int mode;

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

7001
	if (!iwl_is_ready(priv)) {
Z
Zhu Yi 已提交
7002 7003 7004 7005
		rc = -EAGAIN;
		goto out;
	}

7006 7007 7008
	if ((mode < 1) || (mode > IWL39_POWER_LIMIT) ||
	    (mode == IWL39_POWER_AC))
		mode = IWL39_POWER_AC;
Z
Zhu Yi 已提交
7009 7010 7011 7012
	else
		mode |= IWL_POWER_ENABLED;

	if (mode != priv->power_mode) {
C
Christoph Hellwig 已提交
7013
		rc = iwl3945_send_power_mode(priv, IWL_POWER_LEVEL(mode));
Z
Zhu Yi 已提交
7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048
		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)
{
7049
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7050 7051 7052 7053 7054 7055
	int level = IWL_POWER_LEVEL(priv->power_mode);
	char *p = buf;

	p += sprintf(p, "%d ", level);
	switch (level) {
	case IWL_POWER_MODE_CAM:
7056
	case IWL39_POWER_AC:
Z
Zhu Yi 已提交
7057 7058
		p += sprintf(p, "(AC)");
		break;
7059
	case IWL39_POWER_BATTERY:
Z
Zhu Yi 已提交
7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073
		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");

7074
	return p - buf + 1;
Z
Zhu Yi 已提交
7075 7076 7077 7078 7079 7080 7081 7082 7083

}

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)
{
7084 7085
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
7086 7087 7088 7089 7090 7091 7092
}

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
7093
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
7094
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
7095
	u32 len = 0, ofs = 0;
7096
	u8 *data = (u8 *)&priv->statistics_39;
Z
Zhu Yi 已提交
7097 7098
	int rc = 0;

7099
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
7100 7101 7102
		return -EAGAIN;

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
7103
	rc = iwl3945_send_statistics_request(priv);
Z
Zhu Yi 已提交
7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130
	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)
{
7131
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7132

7133
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
7134 7135 7136 7137 7138 7139 7140 7141 7142 7143
		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;
7144
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155

	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 已提交
7156
		priv->antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168
	} 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)
{
7169
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
7170
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183
		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')
7184
		iwl3945_dump_nic_error_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197

	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')
7198
		iwl3945_dump_nic_event_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
7199 7200 7201 7202 7203 7204 7205 7206

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
7207
 * driver setup and tear down
Z
Zhu Yi 已提交
7208 7209 7210
 *
 *****************************************************************************/

7211
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
7212 7213 7214 7215 7216
{
	priv->workqueue = create_workqueue(DRV_NAME);

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229
	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 已提交
7230 7231

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

7235
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
7236
{
C
Christoph Hellwig 已提交
7237
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
7238

7239
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
7240 7241 7242 7243 7244
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
7245
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
7246 7247 7248 7249 7250 7251
	&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,
7252
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
7253 7254 7255 7256 7257 7258 7259 7260
	&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,
7261 7262 7263
#ifdef CONFIG_IWL3945_DEBUG
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
7264 7265 7266
	NULL
};

C
Christoph Hellwig 已提交
7267
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
7268
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
7269
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
7270 7271
};

C
Christoph Hellwig 已提交
7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284
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,
7285
	.bss_info_changed = iwl3945_bss_info_changed,
C
Christoph Hellwig 已提交
7286
	.hw_scan = iwl3945_mac_hw_scan
Z
Zhu Yi 已提交
7287 7288
};

7289
static int iwl3945_init_drv(struct iwl_priv *priv)
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 7326 7327 7328 7329 7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344
{
	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 已提交
7345
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
7346 7347
{
	int err = 0;
7348
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
7349
	struct ieee80211_hw *hw;
7350
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
7351
	unsigned long flags;
Z
Zhu Yi 已提交
7352

7353 7354 7355 7356
	/***********************
	 * 1. Allocating HW data
	 * ********************/

Z
Zhu Yi 已提交
7357 7358
	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
7359
	hw = iwl_alloc_all(cfg, &iwl3945_hw_ops);
Z
Zhu Yi 已提交
7360
	if (hw == NULL) {
7361
		printk(KERN_ERR DRV_NAME "Can not allocate network device\n");
Z
Zhu Yi 已提交
7362 7363 7364 7365
		err = -ENOMEM;
		goto out;
	}
	priv = hw->priv;
7366
	SET_IEEE80211_DEV(hw, &pdev->dev);
7367

7368 7369
	if ((iwl3945_mod_params.num_of_queues > IWL39_MAX_NUM_QUEUES) ||
	     (iwl3945_mod_params.num_of_queues < IWL_MIN_NUM_QUEUES)) {
7370 7371 7372
		IWL_ERR(priv,
			"invalid queues_num, should be between %d and %d\n",
			IWL_MIN_NUM_QUEUES, IWL39_MAX_NUM_QUEUES);
7373 7374 7375 7376
		err = -EINVAL;
		goto out;
	}

7377 7378 7379 7380
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
7381
	if (iwl3945_mod_params.disable_hw_scan) {
7382 7383 7384 7385
		IWL_DEBUG_INFO("Disabling hw_scan\n");
		iwl3945_hw_ops.hw_scan = NULL;
	}

7386

7387
	IWL_DEBUG_INFO("*** LOAD DRIVER ***\n");
7388 7389
	priv->cfg = cfg;
	priv->pci_dev = pdev;
7390

7391
#ifdef CONFIG_IWL3945_DEBUG
7392
	priv->debug_level = iwl3945_mod_params.debug;
Z
Zhu Yi 已提交
7393 7394
	atomic_set(&priv->restrict_refcnt, 0);
#endif
7395 7396 7397 7398 7399
	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 已提交
7400

7401
	/* Tell mac80211 our characteristics */
7402
	hw->flags = IEEE80211_HW_SIGNAL_DBM |
7403
		    IEEE80211_HW_NOISE_DBM;
Z
Zhu Yi 已提交
7404

7405 7406 7407 7408
	hw->wiphy->interface_modes =
		BIT(NL80211_IFTYPE_STATION) |
		BIT(NL80211_IFTYPE_ADHOC);

7409 7410
	hw->wiphy->fw_handles_regulatory = true;

7411
	/* 4 EDCA QOS priorities */
Z
Zhu Yi 已提交
7412 7413
	hw->queues = 4;

7414 7415 7416
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427
	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 已提交
7428
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
7429 7430 7431 7432 7433 7434 7435
		goto out_pci_disable_device;
	}

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

7437 7438 7439
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
7440 7441 7442 7443 7444 7445 7446 7447 7448 7449
	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);

7450 7451 7452
	/* 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 已提交
7453

7454 7455
	/* amp init */
	err = priv->cfg->ops->lib->apm_ops.init(priv);
7456
	if (err < 0) {
7457 7458
		IWL_DEBUG_INFO("Failed to init APMG\n");
		goto out_iounmap;
7459
	}
Z
Zhu Yi 已提交
7460

7461 7462 7463
	/***********************
	 * 4. Read EEPROM
	 * ********************/
7464

7465 7466 7467
	/* Read the EEPROM */
	err = iwl3945_eeprom_init(priv);
	if (err) {
7468
		IWL_ERR(priv, "Unable to init EEPROM\n");
7469 7470 7471 7472 7473 7474
		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 已提交
7475

7476 7477 7478
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
7479
	/* Device-specific setup */
7480
	if (iwl3945_hw_set_hw_params(priv)) {
7481
		IWL_ERR(priv, "failed to set hw settings\n");
Z
Zhu Yi 已提交
7482 7483 7484
		goto out_iounmap;
	}

7485 7486 7487 7488
	/***********************
	 * 6. Setup priv
	 * ********************/

7489
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
7490
	if (err) {
7491 7492
		IWL_ERR(priv, "initializing driver failed\n");
		goto out_free_geos;
Z
Zhu Yi 已提交
7493 7494
	}

T
Tomas Winkler 已提交
7495 7496
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
7497 7498 7499 7500 7501 7502 7503

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

	/* Initialize module parameter values here */
	/* Disable radio (SW RF KILL) via parameter when loading driver */
7504
	if (iwl3945_mod_params.disable) {
7505 7506
		set_bit(STATUS_RF_KILL_SW, &priv->status);
		IWL_DEBUG_INFO("Radio disabled.\n");
7507 7508
	}

7509 7510 7511 7512 7513 7514 7515 7516 7517 7518

	/***********************
	 * 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);
7519
	if (err) {
7520
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
7521
		goto out_release_irq;
7522 7523
	}

7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535 7536 7537
	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
	 * *******************************/

7538 7539
	err = ieee80211_register_hw(priv->hw);
	if (err) {
7540
		IWL_ERR(priv, "Failed to register network device: %d\n", err);
7541
		goto  out_remove_sysfs;
7542
	}
Z
Zhu Yi 已提交
7543

7544 7545
	priv->hw->conf.beacon_int = 100;
	priv->mac80211_registered = 1;
7546

7547 7548
	err = iwl3945_rfkill_init(priv);
	if (err)
7549
		IWL_ERR(priv, "Unable to initialize RFKILL system. "
7550 7551
				  "Ignoring error: %d\n", err);

Z
Zhu Yi 已提交
7552 7553
	return 0;

7554 7555
 out_remove_sysfs:
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
7556 7557
 out_free_geos:
	iwl3945_free_geos(priv);
Z
Zhu Yi 已提交
7558 7559 7560 7561

 out_release_irq:
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
7562
	iwl3945_unset_hw_params(priv);
Z
Zhu Yi 已提交
7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 7575 7576

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

7577
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
7578
{
7579
	struct iwl_priv *priv = pci_get_drvdata(pdev);
7580
	unsigned long flags;
Z
Zhu Yi 已提交
7581 7582 7583 7584 7585 7586 7587

	if (!priv)
		return;

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

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

7589 7590 7591 7592 7593 7594
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
7595

7596 7597 7598 7599 7600 7601 7602 7603 7604
	/* 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 已提交
7605
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
7606

7607
	iwl3945_rfkill_unregister(priv);
C
Christoph Hellwig 已提交
7608
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
7609 7610

	if (priv->rxq.bd)
7611
		iwl_rx_queue_free(priv, &priv->rxq);
C
Christoph Hellwig 已提交
7612
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
7613

7614
	iwl3945_unset_hw_params(priv);
C
Christoph Hellwig 已提交
7615
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
7616

7617 7618 7619
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
7620
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
7621 7622 7623 7624 7625 7626 7627 7628 7629 7630
	 * 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);

7631 7632
	iwl3945_free_channel_map(priv);
	iwl3945_free_geos(priv);
7633
	kfree(priv->scan39);
Z
Zhu Yi 已提交
7634 7635 7636 7637 7638 7639 7640 7641
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}

#ifdef CONFIG_PM

C
Christoph Hellwig 已提交
7642
static int iwl3945_pci_suspend(struct pci_dev *pdev, pm_message_t state)
Z
Zhu Yi 已提交
7643
{
7644
	struct iwl_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
7645

7646 7647 7648 7649 7650
	if (priv->is_open) {
		set_bit(STATUS_IN_SUSPEND, &priv->status);
		iwl3945_mac_stop(priv->hw);
		priv->is_open = 1;
	}
Z
Zhu Yi 已提交
7651 7652 7653 7654 7655 7656

	pci_set_power_state(pdev, PCI_D3hot);

	return 0;
}

C
Christoph Hellwig 已提交
7657
static int iwl3945_pci_resume(struct pci_dev *pdev)
Z
Zhu Yi 已提交
7658
{
7659
	struct iwl_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
7660 7661 7662

	pci_set_power_state(pdev, PCI_D0);

7663 7664
	if (priv->is_open)
		iwl3945_mac_start(priv->hw);
Z
Zhu Yi 已提交
7665

7666
	clear_bit(STATUS_IN_SUSPEND, &priv->status);
Z
Zhu Yi 已提交
7667 7668 7669 7670 7671
	return 0;
}

#endif /* CONFIG_PM */

7672
/*************** RFKILL FUNCTIONS **********/
7673
#ifdef CONFIG_IWL3945_RFKILL
7674 7675 7676
/* software rf-kill from user */
static int iwl3945_rfkill_soft_rf_kill(void *data, enum rfkill_state state)
{
7677
	struct iwl_priv *priv = data;
7678 7679
	int err = 0;

7680
	if (!priv->rfkill)
7681 7682 7683 7684 7685
	return 0;

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

T
Tomas Winkler 已提交
7686
	IWL_DEBUG_RF_KILL("we received soft RFKILL set to state %d\n", state);
7687 7688 7689
	mutex_lock(&priv->mutex);

	switch (state) {
7690
	case RFKILL_STATE_UNBLOCKED:
7691
		if (iwl_is_rfkill_hw(priv)) {
7692
			err = -EBUSY;
7693 7694 7695
			goto out_unlock;
		}
		iwl3945_radio_kill_sw(priv, 0);
7696
		break;
7697
	case RFKILL_STATE_SOFT_BLOCKED:
7698 7699
		iwl3945_radio_kill_sw(priv, 1);
		break;
7700
	default:
7701
		IWL_WARN(priv, "received unexpected RFKILL state %d\n", state);
7702
		break;
7703
	}
7704
out_unlock:
7705 7706 7707 7708 7709
	mutex_unlock(&priv->mutex);

	return err;
}

7710
int iwl3945_rfkill_init(struct iwl_priv *priv)
7711 7712 7713 7714 7715 7716 7717
{
	struct device *device = wiphy_dev(priv->hw->wiphy);
	int ret = 0;

	BUG_ON(device == NULL);

	IWL_DEBUG_RF_KILL("Initializing RFKILL.\n");
7718 7719
	priv->rfkill = rfkill_allocate(device, RFKILL_TYPE_WLAN);
	if (!priv->rfkill) {
7720
		IWL_ERR(priv, "Unable to allocate rfkill device.\n");
7721 7722 7723 7724
		ret = -ENOMEM;
		goto error;
	}

7725 7726 7727 7728 7729
	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;
7730

7731 7732
	priv->rfkill->dev.class->suspend = NULL;
	priv->rfkill->dev.class->resume = NULL;
7733

7734
	ret = rfkill_register(priv->rfkill);
7735
	if (ret) {
7736
		IWL_ERR(priv, "Unable to register rfkill: %d\n", ret);
7737
		goto freed_rfkill;
7738 7739 7740 7741 7742 7743
	}

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

freed_rfkill:
7744 7745 7746
	if (priv->rfkill != NULL)
		rfkill_free(priv->rfkill);
	priv->rfkill = NULL;
7747 7748 7749 7750 7751 7752

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

7753
void iwl3945_rfkill_unregister(struct iwl_priv *priv)
7754
{
7755 7756
	if (priv->rfkill)
		rfkill_unregister(priv->rfkill);
7757

7758
	priv->rfkill = NULL;
7759 7760 7761
}

/* set rf-kill to the right state. */
7762
void iwl3945_rfkill_set_hw_state(struct iwl_priv *priv)
7763 7764
{

7765 7766 7767
	if (!priv->rfkill)
		return;

7768
	if (iwl_is_rfkill_hw(priv)) {
7769
		rfkill_force_state(priv->rfkill, RFKILL_STATE_HARD_BLOCKED);
7770
		return;
7771
	}
7772

7773
	if (!iwl_is_rfkill_sw(priv))
7774
		rfkill_force_state(priv->rfkill, RFKILL_STATE_UNBLOCKED);
7775
	else
7776
		rfkill_force_state(priv->rfkill, RFKILL_STATE_SOFT_BLOCKED);
7777 7778 7779
}
#endif

Z
Zhu Yi 已提交
7780 7781 7782 7783 7784 7785
/*****************************************************************************
 *
 * driver and module entry point
 *
 *****************************************************************************/

C
Christoph Hellwig 已提交
7786
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
7787
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
7788 7789 7790
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
7791
#ifdef CONFIG_PM
C
Christoph Hellwig 已提交
7792 7793
	.suspend = iwl3945_pci_suspend,
	.resume = iwl3945_pci_resume,
Z
Zhu Yi 已提交
7794 7795 7796
#endif
};

C
Christoph Hellwig 已提交
7797
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
7798 7799 7800 7801 7802
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
7803 7804 7805

	ret = iwl3945_rate_control_register();
	if (ret) {
7806 7807
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
7808 7809 7810
		return ret;
	}

C
Christoph Hellwig 已提交
7811
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
7812
	if (ret) {
7813
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
7814
		goto error_register;
Z
Zhu Yi 已提交
7815 7816 7817
	}

	return ret;
7818 7819 7820 7821

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
7822 7823
}

C
Christoph Hellwig 已提交
7824
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
7825
{
C
Christoph Hellwig 已提交
7826
	pci_unregister_driver(&iwl3945_driver);
7827
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
7828 7829
}

7830
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
7831

7832
module_param_named(antenna, iwl3945_mod_params.antenna, int, 0444);
Z
Zhu Yi 已提交
7833
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
7834
module_param_named(disable, iwl3945_mod_params.disable, int, 0444);
Z
Zhu Yi 已提交
7835
MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
7836
module_param_named(hwcrypto, iwl3945_mod_params.sw_crypto, int, 0444);
Z
Zhu Yi 已提交
7837 7838
MODULE_PARM_DESC(hwcrypto,
		 "using hardware crypto engine (default 0 [software])\n");
7839
module_param_named(debug, iwl3945_mod_params.debug, uint, 0444);
Z
Zhu Yi 已提交
7840
MODULE_PARM_DESC(debug, "debug output mask");
7841
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
7842 7843
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

7844
module_param_named(queues_num, iwl3945_mod_params.num_of_queues, int, 0444);
Z
Zhu Yi 已提交
7845 7846
MODULE_PARM_DESC(queues_num, "number of hw queues.");

C
Christoph Hellwig 已提交
7847 7848
module_exit(iwl3945_exit);
module_init(iwl3945_init);