iwl3945-base.c 121.0 KB
Newer Older
Z
Zhu Yi 已提交
1 2
/******************************************************************************
 *
3
 * Copyright(c) 2003 - 2009 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
 * 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>
36
#include <linux/sched.h>
Z
Zhu Yi 已提交
37 38 39 40 41 42 43 44 45 46 47 48
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/wireless.h>
#include <linux/firmware.h>
#include <linux/etherdevice.h>
#include <linux/if_arp.h>

#include <net/ieee80211_radiotap.h>
#include <net/mac80211.h>

#include <asm/div64.h>

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"
54
#include "iwl-sta.h"
Z
Zhu Yi 已提交
55 56
#include "iwl-3945.h"
#include "iwl-helpers.h"
K
Kolekar, Abhijeet 已提交
57
#include "iwl-core.h"
58
#include "iwl-dev.h"
Z
Zhu Yi 已提交
59 60 61 62 63 64 65 66

/*
 * module name, copyright, version, etc.
 */

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

S
Samuel Ortiz 已提交
67
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
68 69 70 71 72
#define VD "d"
#else
#define VD
#endif

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

79
#define DRV_VERSION  IWLWIFI_VERSION VD VS
80
#define DRV_COPYRIGHT	"Copyright(c) 2003-2009 Intel Corporation"
81
#define DRV_AUTHOR     "<ilw@linux.intel.com>"
Z
Zhu Yi 已提交
82 83 84

MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_VERSION(DRV_VERSION);
85
MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
Z
Zhu Yi 已提交
86 87
MODULE_LICENSE("GPL");

88 89
 /* module parameters */
struct iwl_mod_params iwl3945_mod_params = {
90
	.sw_crypto = 1,
91
	.restart_fw = 1,
92 93 94
	/* the rest are 0 by default */
};

95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
/**
 * iwl3945_get_antenna_flags - Get antenna flags for RXON command
 * @priv: eeprom and antenna fields are used to determine antenna flags
 *
 * priv->eeprom39  is used to determine if antenna AUX/MAIN are reversed
 * iwl3945_mod_params.antenna specifies the antenna diversity mode:
 *
 * IWL_ANTENNA_DIVERSITY - NIC selects best antenna by itself
 * IWL_ANTENNA_MAIN      - Force MAIN antenna
 * IWL_ANTENNA_AUX       - Force AUX antenna
 */
__le32 iwl3945_get_antenna_flags(const struct iwl_priv *priv)
{
	struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;

	switch (iwl3945_mod_params.antenna) {
	case IWL_ANTENNA_DIVERSITY:
		return 0;

	case IWL_ANTENNA_MAIN:
		if (eeprom->antenna_switch_type)
			return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_B_MSK;
		return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_A_MSK;

	case IWL_ANTENNA_AUX:
		if (eeprom->antenna_switch_type)
			return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_A_MSK;
		return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_B_MSK;
	}

	/* bad antenna selector value */
	IWL_ERR(priv, "Bad antenna selector value (0x%x)\n",
		iwl3945_mod_params.antenna);

	return 0;		/* "diversity" is default if error */
}

132
static int iwl3945_set_ccmp_dynamic_key_info(struct iwl_priv *priv,
Z
Zhu Yi 已提交
133 134 135 136 137
				   struct ieee80211_key_conf *keyconf,
				   u8 sta_id)
{
	unsigned long flags;
	__le16 key_flags = 0;
138 139 140 141 142 143 144 145 146 147 148
	int ret;

	key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
	key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);

	if (sta_id == priv->hw_params.bcast_sta_id)
		key_flags |= STA_KEY_MULTICAST_MSK;

	keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
	keyconf->hw_key_idx = keyconf->keyidx;
	key_flags &= ~STA_KEY_FLG_INVALID;
Z
Zhu Yi 已提交
149 150

	spin_lock_irqsave(&priv->sta_lock, flags);
151 152 153
	priv->stations[sta_id].keyinfo.alg = keyconf->alg;
	priv->stations[sta_id].keyinfo.keylen = keyconf->keylen;
	memcpy(priv->stations[sta_id].keyinfo.key, keyconf->key,
Z
Zhu Yi 已提交
154 155
	       keyconf->keylen);

156
	memcpy(priv->stations[sta_id].sta.key.key, keyconf->key,
Z
Zhu Yi 已提交
157
	       keyconf->keylen);
158

159
	if ((priv->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
160
			== STA_KEY_FLG_NO_ENC)
161
		priv->stations[sta_id].sta.key.key_offset =
162 163 164 165
				 iwl_get_free_ucode_key_index(priv);
	/* else, we are overriding an existing key => no need to allocated room
	* in uCode. */

166
	WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
167 168
		"no space for a new key");

169 170 171
	priv->stations[sta_id].sta.key.key_flags = key_flags;
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
Z
Zhu Yi 已提交
172

173 174
	IWL_DEBUG_INFO(priv, "hwcrypto: modify ucode station key info\n");

175
	ret = iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
176

Z
Zhu Yi 已提交
177 178
	spin_unlock_irqrestore(&priv->sta_lock, flags);

179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
	return ret;
}

static int iwl3945_set_tkip_dynamic_key_info(struct iwl_priv *priv,
				  struct ieee80211_key_conf *keyconf,
				  u8 sta_id)
{
	return -EOPNOTSUPP;
}

static int iwl3945_set_wep_dynamic_key_info(struct iwl_priv *priv,
				  struct ieee80211_key_conf *keyconf,
				  u8 sta_id)
{
	return -EOPNOTSUPP;
Z
Zhu Yi 已提交
194 195
}

196
static int iwl3945_clear_sta_key_info(struct iwl_priv *priv, u8 sta_id)
Z
Zhu Yi 已提交
197 198 199 200
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);
201 202
	memset(&priv->stations[sta_id].keyinfo, 0, sizeof(struct iwl_hw_key));
	memset(&priv->stations[sta_id].sta.key, 0,
203
		sizeof(struct iwl4965_keyinfo));
204 205 206
	priv->stations[sta_id].sta.key.key_flags = STA_KEY_FLG_NO_ENC;
	priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
Z
Zhu Yi 已提交
207 208
	spin_unlock_irqrestore(&priv->sta_lock, flags);

209
	IWL_DEBUG_INFO(priv, "hwcrypto: clear ucode station key info\n");
210
	iwl_send_add_sta(priv, &priv->stations[sta_id].sta, 0);
Z
Zhu Yi 已提交
211 212 213
	return 0;
}

A
Abhijeet Kolekar 已提交
214
static int iwl3945_set_dynamic_key(struct iwl_priv *priv,
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
			struct ieee80211_key_conf *keyconf, u8 sta_id)
{
	int ret = 0;

	keyconf->hw_key_idx = HW_KEY_DYNAMIC;

	switch (keyconf->alg) {
	case ALG_CCMP:
		ret = iwl3945_set_ccmp_dynamic_key_info(priv, keyconf, sta_id);
		break;
	case ALG_TKIP:
		ret = iwl3945_set_tkip_dynamic_key_info(priv, keyconf, sta_id);
		break;
	case ALG_WEP:
		ret = iwl3945_set_wep_dynamic_key_info(priv, keyconf, sta_id);
		break;
	default:
232
		IWL_ERR(priv, "Unknown alg: %s alg = %d\n", __func__, keyconf->alg);
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
		ret = -EINVAL;
	}

	IWL_DEBUG_WEP(priv, "Set dynamic key: alg= %d len=%d idx=%d sta=%d ret=%d\n",
		      keyconf->alg, keyconf->keylen, keyconf->keyidx,
		      sta_id, ret);

	return ret;
}

static int iwl3945_remove_static_key(struct iwl_priv *priv)
{
	int ret = -EOPNOTSUPP;

	return ret;
}

static int iwl3945_set_static_key(struct iwl_priv *priv,
				struct ieee80211_key_conf *key)
{
	if (key->alg == ALG_WEP)
		return -EOPNOTSUPP;

	IWL_ERR(priv, "Static key invalid: alg %d\n", key->alg);
	return -EINVAL;
}

260
static void iwl3945_clear_free_frames(struct iwl_priv *priv)
Z
Zhu Yi 已提交
261 262 263
{
	struct list_head *element;

264
	IWL_DEBUG_INFO(priv, "%d frames on pre-allocated heap on clear.\n",
Z
Zhu Yi 已提交
265 266 267 268 269
		       priv->frames_count);

	while (!list_empty(&priv->free_frames)) {
		element = priv->free_frames.next;
		list_del(element);
C
Christoph Hellwig 已提交
270
		kfree(list_entry(element, struct iwl3945_frame, list));
Z
Zhu Yi 已提交
271 272 273 274
		priv->frames_count--;
	}

	if (priv->frames_count) {
275
		IWL_WARN(priv, "%d frames still in use.  Did we lose one?\n",
Z
Zhu Yi 已提交
276 277 278 279 280
			    priv->frames_count);
		priv->frames_count = 0;
	}
}

281
static struct iwl3945_frame *iwl3945_get_free_frame(struct iwl_priv *priv)
Z
Zhu Yi 已提交
282
{
C
Christoph Hellwig 已提交
283
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
284 285 286 287
	struct list_head *element;
	if (list_empty(&priv->free_frames)) {
		frame = kzalloc(sizeof(*frame), GFP_KERNEL);
		if (!frame) {
288
			IWL_ERR(priv, "Could not allocate frame!\n");
Z
Zhu Yi 已提交
289 290 291 292 293 294 295 296 297
			return NULL;
		}

		priv->frames_count++;
		return frame;
	}

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

301
static void iwl3945_free_frame(struct iwl_priv *priv, struct iwl3945_frame *frame)
Z
Zhu Yi 已提交
302 303 304 305 306
{
	memset(frame, 0, sizeof(*frame));
	list_add(&frame->list, &priv->free_frames);
}

307
unsigned int iwl3945_fill_beacon_frame(struct iwl_priv *priv,
Z
Zhu Yi 已提交
308
				struct ieee80211_hdr *hdr,
309
				int left)
Z
Zhu Yi 已提交
310 311
{

312
	if (!iwl_is_associated(priv) || !priv->ibss_beacon ||
313 314
	    ((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
	     (priv->iw_mode != NL80211_IFTYPE_AP)))
Z
Zhu Yi 已提交
315 316 317 318 319 320 321 322 323 324
		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;
}

325
static int iwl3945_send_beacon_cmd(struct iwl_priv *priv)
Z
Zhu Yi 已提交
326
{
C
Christoph Hellwig 已提交
327
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
328 329 330 331
	unsigned int frame_size;
	int rc;
	u8 rate;

C
Christoph Hellwig 已提交
332
	frame = iwl3945_get_free_frame(priv);
Z
Zhu Yi 已提交
333 334

	if (!frame) {
335
		IWL_ERR(priv, "Could not obtain free frame buffer for beacon "
Z
Zhu Yi 已提交
336 337 338 339
			  "command.\n");
		return -ENOMEM;
	}

340
	rate = iwl_rate_get_lowest_plcp(priv);
Z
Zhu Yi 已提交
341

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

344
	rc = iwl_send_cmd_pdu(priv, REPLY_TX_BEACON, frame_size,
Z
Zhu Yi 已提交
345 346
			      &frame->u.cmd[0]);

C
Christoph Hellwig 已提交
347
	iwl3945_free_frame(priv, frame);
Z
Zhu Yi 已提交
348 349 350 351

	return rc;
}

352
static void iwl3945_unset_hw_params(struct iwl_priv *priv)
Z
Zhu Yi 已提交
353
{
354
	if (priv->shared_virt)
Z
Zhu Yi 已提交
355
		pci_free_consistent(priv->pci_dev,
C
Christoph Hellwig 已提交
356
				    sizeof(struct iwl3945_shared),
357 358
				    priv->shared_virt,
				    priv->shared_phys);
Z
Zhu Yi 已提交
359 360
}

361
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl_priv *priv,
362
				      struct ieee80211_tx_info *info,
J
Johannes Berg 已提交
363
				      struct iwl_device_cmd *cmd,
Z
Zhu Yi 已提交
364
				      struct sk_buff *skb_frag,
365
				      int sta_id)
Z
Zhu Yi 已提交
366
{
A
Abhijeet Kolekar 已提交
367
	struct iwl3945_tx_cmd *tx_cmd = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
368
	struct iwl_hw_key *keyinfo = &priv->stations[sta_id].keyinfo;
Z
Zhu Yi 已提交
369 370 371

	switch (keyinfo->alg) {
	case ALG_CCMP:
A
Abhijeet Kolekar 已提交
372 373
		tx_cmd->sec_ctl = TX_CMD_SEC_CCM;
		memcpy(tx_cmd->key, keyinfo->key, keyinfo->keylen);
374
		IWL_DEBUG_TX(priv, "tx_cmd with AES hwcrypto\n");
Z
Zhu Yi 已提交
375 376 377 378 379 380
		break;

	case ALG_TKIP:
		break;

	case ALG_WEP:
A
Abhijeet Kolekar 已提交
381
		tx_cmd->sec_ctl = TX_CMD_SEC_WEP |
382
		    (info->control.hw_key->hw_key_idx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT;
Z
Zhu Yi 已提交
383 384

		if (keyinfo->keylen == 13)
A
Abhijeet Kolekar 已提交
385
			tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
Z
Zhu Yi 已提交
386

A
Abhijeet Kolekar 已提交
387
		memcpy(&tx_cmd->key[3], keyinfo->key, keyinfo->keylen);
Z
Zhu Yi 已提交
388

389
		IWL_DEBUG_TX(priv, "Configuring packet for WEP encryption "
390
			     "with key %d\n", info->control.hw_key->hw_key_idx);
Z
Zhu Yi 已提交
391 392 393
		break;

	default:
T
Tomas Winkler 已提交
394
		IWL_ERR(priv, "Unknown encode alg %d\n", keyinfo->alg);
Z
Zhu Yi 已提交
395 396 397 398 399 400 401
		break;
	}
}

/*
 * handle build REPLY_TX command notification.
 */
402
static void iwl3945_build_tx_cmd_basic(struct iwl_priv *priv,
J
Johannes Berg 已提交
403
				  struct iwl_device_cmd *cmd,
404
				  struct ieee80211_tx_info *info,
405
				  struct ieee80211_hdr *hdr, u8 std_id)
Z
Zhu Yi 已提交
406
{
A
Abhijeet Kolekar 已提交
407 408
	struct iwl3945_tx_cmd *tx_cmd = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
	__le32 tx_flags = tx_cmd->tx_flags;
409
	__le16 fc = hdr->frame_control;
Z
Zhu Yi 已提交
410

A
Abhijeet Kolekar 已提交
411
	tx_cmd->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
412
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Z
Zhu Yi 已提交
413
		tx_flags |= TX_CMD_FLG_ACK_MSK;
414
		if (ieee80211_is_mgmt(fc))
Z
Zhu Yi 已提交
415
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
416
		if (ieee80211_is_probe_resp(fc) &&
Z
Zhu Yi 已提交
417 418 419 420 421 422 423
		    !(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;
	}

A
Abhijeet Kolekar 已提交
424
	tx_cmd->sta_id = std_id;
425
	if (ieee80211_has_morefrags(fc))
Z
Zhu Yi 已提交
426 427
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

428 429
	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
A
Abhijeet Kolekar 已提交
430
		tx_cmd->tid_tspec = qc[0] & 0xf;
Z
Zhu Yi 已提交
431
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
432
	} else {
Z
Zhu Yi 已提交
433
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
434
	}
Z
Zhu Yi 已提交
435

436
	priv->cfg->ops->utils->rts_tx_cmd_flag(info, &tx_flags);
Z
Zhu Yi 已提交
437 438 439 440 441

	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);
442 443
	if (ieee80211_is_mgmt(fc)) {
		if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
A
Abhijeet Kolekar 已提交
444
			tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(3);
Z
Zhu Yi 已提交
445
		else
A
Abhijeet Kolekar 已提交
446
			tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(2);
M
Mohamed Abbas 已提交
447
	} else {
A
Abhijeet Kolekar 已提交
448
		tx_cmd->timeout.pm_frame_timeout = 0;
M
Mohamed Abbas 已提交
449
	}
Z
Zhu Yi 已提交
450

A
Abhijeet Kolekar 已提交
451 452 453
	tx_cmd->driver_txop = 0;
	tx_cmd->tx_flags = tx_flags;
	tx_cmd->next_frame_len = 0;
Z
Zhu Yi 已提交
454 455 456 457 458
}

/*
 * start REPLY_TX command process
 */
459
static int iwl3945_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
Z
Zhu Yi 已提交
460 461
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
462
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
A
Abhijeet Kolekar 已提交
463
	struct iwl3945_tx_cmd *tx_cmd;
464
	struct iwl_tx_queue *txq = NULL;
465
	struct iwl_queue *q = NULL;
J
Johannes Berg 已提交
466 467
	struct iwl_device_cmd *out_cmd;
	struct iwl_cmd_meta *out_meta;
Z
Zhu Yi 已提交
468 469
	dma_addr_t phys_addr;
	dma_addr_t txcmd_phys;
470
	int txq_id = skb_get_queue_mapping(skb);
R
Reinette Chatre 已提交
471
	u16 len, idx, len_org, hdr_len; /* TODO: len_org is not used */
472 473
	u8 id;
	u8 unicast;
Z
Zhu Yi 已提交
474
	u8 sta_id;
475
	u8 tid = 0;
Z
Zhu Yi 已提交
476
	u16 seq_number = 0;
477
	__le16 fc;
Z
Zhu Yi 已提交
478
	u8 wait_write_ptr = 0;
479
	u8 *qc = NULL;
Z
Zhu Yi 已提交
480 481 482 483
	unsigned long flags;
	int rc;

	spin_lock_irqsave(&priv->lock, flags);
484
	if (iwl_is_rfkill(priv)) {
485
		IWL_DEBUG_DROP(priv, "Dropping - RF KILL\n");
Z
Zhu Yi 已提交
486 487 488
		goto drop_unlock;
	}

489
	if ((ieee80211_get_tx_rate(priv->hw, info)->hw_value & 0xFF) == IWL_INVALID_RATE) {
490
		IWL_ERR(priv, "ERROR: No TX rate available.\n");
Z
Zhu Yi 已提交
491 492 493 494 495 496
		goto drop_unlock;
	}

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

497
	fc = hdr->frame_control;
Z
Zhu Yi 已提交
498

S
Samuel Ortiz 已提交
499
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
500
	if (ieee80211_is_auth(fc))
501
		IWL_DEBUG_TX(priv, "Sending AUTH frame\n");
502
	else if (ieee80211_is_assoc_req(fc))
503
		IWL_DEBUG_TX(priv, "Sending ASSOC frame\n");
504
	else if (ieee80211_is_reassoc_req(fc))
505
		IWL_DEBUG_TX(priv, "Sending REASSOC frame\n");
Z
Zhu Yi 已提交
506 507
#endif

508
	/* drop all non-injected data frame if we are not associated */
509
	if (ieee80211_is_data(fc) &&
510
	    !(info->flags & IEEE80211_TX_CTL_INJECTED) &&
511
	    (!iwl_is_associated(priv) ||
512
	     ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id))) {
513
		IWL_DEBUG_DROP(priv, "Dropping - !iwl_is_associated\n");
Z
Zhu Yi 已提交
514 515 516 517 518
		goto drop_unlock;
	}

	spin_unlock_irqrestore(&priv->lock, flags);

519
	hdr_len = ieee80211_hdrlen(fc);
520 521

	/* Find (or create) index into station table for destination station */
522 523 524 525
	if (info->flags & IEEE80211_TX_CTL_INJECTED)
		sta_id = priv->hw_params.bcast_sta_id;
	else
		sta_id = iwl_get_sta_id(priv, hdr);
Z
Zhu Yi 已提交
526
	if (sta_id == IWL_INVALID_STATION) {
527
		IWL_DEBUG_DROP(priv, "Dropping - INVALID STATION: %pM\n",
J
Johannes Berg 已提交
528
			       hdr->addr1);
Z
Zhu Yi 已提交
529 530 531
		goto drop;
	}

532
	IWL_DEBUG_RATE(priv, "station Id %d\n", sta_id);
Z
Zhu Yi 已提交
533

534 535
	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
536
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
537 538
		if (unlikely(tid >= MAX_TID_COUNT))
			goto drop;
539
		seq_number = priv->stations[sta_id].tid[tid].seq_number &
Z
Zhu Yi 已提交
540 541 542
				IEEE80211_SCTL_SEQ;
		hdr->seq_ctrl = cpu_to_le16(seq_number) |
			(hdr->seq_ctrl &
543
				cpu_to_le16(IEEE80211_SCTL_FRAG));
Z
Zhu Yi 已提交
544 545
		seq_number += 0x10;
	}
546 547

	/* Descriptor for chosen Tx queue */
548
	txq = &priv->txq[txq_id];
Z
Zhu Yi 已提交
549 550 551 552
	q = &txq->q;

	spin_lock_irqsave(&priv->lock, flags);

553
	idx = get_cmd_index(q, q->write_ptr, 0);
Z
Zhu Yi 已提交
554

555
	/* Set up driver data for this TFD */
W
Winkler, Tomas 已提交
556
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl_tx_info));
557
	txq->txb[q->write_ptr].skb[0] = skb;
558 559

	/* Init first empty entry in queue's array of Tx/cmd buffers */
560
	out_cmd = txq->cmd[idx];
J
Johannes Berg 已提交
561
	out_meta = &txq->meta[idx];
A
Abhijeet Kolekar 已提交
562
	tx_cmd = (struct iwl3945_tx_cmd *)out_cmd->cmd.payload;
Z
Zhu Yi 已提交
563
	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
A
Abhijeet Kolekar 已提交
564
	memset(tx_cmd, 0, sizeof(*tx_cmd));
565 566 567 568 569 570 571

	/*
	 * 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 已提交
572 573
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
574
				INDEX_TO_SEQ(q->write_ptr)));
575 576

	/* Copy MAC header from skb into command buffer */
A
Abhijeet Kolekar 已提交
577
	memcpy(tx_cmd->hdr, hdr, hdr_len);
Z
Zhu Yi 已提交
578

R
Reinette Chatre 已提交
579 580 581 582 583 584 585 586 587 588 589 590

	if (info->control.hw_key)
		iwl3945_build_tx_cmd_hwcrypto(priv, info, out_cmd, skb, sta_id);

	/* TODO need this for burst mode later on */
	iwl3945_build_tx_cmd_basic(priv, out_cmd, info, hdr, sta_id);

	/* set is_hcca to 0; it probably will never be implemented */
	iwl3945_hw_build_tx_cmd_rate(priv, out_cmd, info, hdr, sta_id, 0);

	/* Total # bytes to be transmitted */
	len = (u16)skb->len;
A
Abhijeet Kolekar 已提交
591
	tx_cmd->len = cpu_to_le16(len);
R
Reinette Chatre 已提交
592

593
	iwl_dbg_log_tx_data_frame(priv, len, hdr);
594
	iwl_update_stats(priv, true, fc, len);
A
Abhijeet Kolekar 已提交
595 596
	tx_cmd->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
	tx_cmd->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;
R
Reinette Chatre 已提交
597 598 599 600

	if (!ieee80211_has_morefrags(hdr->frame_control)) {
		txq->need_update = 1;
		if (qc)
601
			priv->stations[sta_id].tid[tid].seq_number = seq_number;
R
Reinette Chatre 已提交
602 603 604 605 606 607 608
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

	IWL_DEBUG_TX(priv, "sequence nr = 0X%x \n",
		     le16_to_cpu(out_cmd->hdr.sequence));
A
Abhijeet Kolekar 已提交
609 610 611
	IWL_DEBUG_TX(priv, "tx_flags = 0X%x \n", le32_to_cpu(tx_cmd->tx_flags));
	iwl_print_hex_dump(priv, IWL_DL_TX, tx_cmd, sizeof(*tx_cmd));
	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx_cmd->hdr,
R
Reinette Chatre 已提交
612 613
			   ieee80211_hdrlen(fc));

614 615 616 617 618 619 620 621 622
	/*
	 * 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.
	 */
623
	len = sizeof(struct iwl3945_tx_cmd) +
624
			sizeof(struct iwl_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
625 626 627 628 629 630 631 632 633

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

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

634 635
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
R
Reinette Chatre 已提交
636 637 638 639
	txcmd_phys = pci_map_single(priv->pci_dev, &out_cmd->hdr,
				    len, PCI_DMA_TODEVICE);
	/* we do not map meta data ... so we can safely access address to
	 * provide to unmap command*/
J
Johannes Berg 已提交
640 641
	pci_unmap_addr_set(out_meta, mapping, txcmd_phys);
	pci_unmap_len_set(out_meta, len, len);
Z
Zhu Yi 已提交
642

643 644
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
645 646
	priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
						   txcmd_phys, len, 1, 0);
Z
Zhu Yi 已提交
647 648


649 650
	/* 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 已提交
651 652 653 654
	len = skb->len - hdr_len;
	if (len) {
		phys_addr = pci_map_single(priv->pci_dev, skb->data + hdr_len,
					   len, PCI_DMA_TODEVICE);
655 656 657
		priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
							   phys_addr, len,
							   0, U32_PAD(len));
Z
Zhu Yi 已提交
658 659 660
	}


661
	/* Tell device the write index *just past* this latest filled TFD */
T
Tomas Winkler 已提交
662
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
663
	rc = iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
664 665 666 667 668
	spin_unlock_irqrestore(&priv->lock, flags);

	if (rc)
		return rc;

669
	if ((iwl_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
670 671 672 673
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
674
			iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
675 676 677
			spin_unlock_irqrestore(&priv->lock, flags);
		}

678
		iwl_stop_queue(priv, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
679 680 681 682 683 684 685 686 687 688
	}

	return 0;

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

689
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
690 691 692 693 694 695 696 697 698 699 700 701 702 703

#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 已提交
704
static u32 iwl3945_usecs_to_beacons(u32 usec, u32 beacon_interval)
Z
Zhu Yi 已提交
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
{
	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 已提交
723
static __le32 iwl3945_add_beacon_time(u32 base, u32 addon, u32 beacon_interval)
Z
Zhu Yi 已提交
724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
{
	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);
}

742
static int iwl3945_get_measurement(struct iwl_priv *priv,
Z
Zhu Yi 已提交
743 744 745
			       struct ieee80211_measurement_params *params,
			       u8 type)
{
746
	struct iwl_spectrum_cmd spectrum;
Z
Zhu Yi 已提交
747
	struct iwl_rx_packet *pkt;
748
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
749 750
		.id = REPLY_SPECTRUM_MEASUREMENT_CMD,
		.data = (void *)&spectrum,
J
Johannes Berg 已提交
751
		.flags = CMD_WANT_SKB,
Z
Zhu Yi 已提交
752 753 754 755 756 757
	};
	u32 add_time = le64_to_cpu(params->start_time);
	int rc;
	int spectrum_resp_status;
	int duration = le16_to_cpu(params->duration);

758
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
759
		add_time =
C
Christoph Hellwig 已提交
760
		    iwl3945_usecs_to_beacons(
Z
Zhu Yi 已提交
761 762 763 764 765 766 767 768 769 770 771 772
			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));

773
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
774
		spectrum.start_time =
C
Christoph Hellwig 已提交
775
		    iwl3945_add_beacon_time(priv->last_beacon_time,
Z
Zhu Yi 已提交
776 777 778 779 780 781 782 783
				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;
784
	if (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK)
Z
Zhu Yi 已提交
785 786 787
		spectrum.flags |= RXON_FLG_BAND_24G_MSK |
		    RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK;

788
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
789 790 791
	if (rc)
		return rc;

Z
Zhu Yi 已提交
792 793
	pkt = (struct iwl_rx_packet *)cmd.reply_page;
	if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
794
		IWL_ERR(priv, "Bad return from REPLY_RX_ON_ASSOC command\n");
Z
Zhu Yi 已提交
795 796 797
		rc = -EIO;
	}

Z
Zhu Yi 已提交
798
	spectrum_resp_status = le16_to_cpu(pkt->u.spectrum.status);
Z
Zhu Yi 已提交
799 800
	switch (spectrum_resp_status) {
	case 0:		/* Command will be handled */
Z
Zhu Yi 已提交
801
		if (pkt->u.spectrum.id != 0xff) {
802
			IWL_DEBUG_INFO(priv, "Replaced existing measurement: %d\n",
Z
Zhu Yi 已提交
803
						pkt->u.spectrum.id);
Z
Zhu Yi 已提交
804 805 806 807 808 809 810 811 812 813 814
			priv->measurement_status &= ~MEASUREMENT_READY;
		}
		priv->measurement_status |= MEASUREMENT_ACTIVE;
		rc = 0;
		break;

	case 1:		/* Command will not be handled */
		rc = -EAGAIN;
		break;
	}

815
	iwl_free_pages(priv, cmd.reply_page);
Z
Zhu Yi 已提交
816 817 818 819 820

	return rc;
}
#endif

821
static void iwl3945_rx_reply_alive(struct iwl_priv *priv,
822
			       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
823
{
Z
Zhu Yi 已提交
824
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
825
	struct iwl_alive_resp *palive;
Z
Zhu Yi 已提交
826 827 828 829
	struct delayed_work *pwork;

	palive = &pkt->u.alive_frame;

830
	IWL_DEBUG_INFO(priv, "Alive ucode status 0x%08X revision "
Z
Zhu Yi 已提交
831 832 833 834 835
		       "0x%01X 0x%01X\n",
		       palive->is_valid, palive->ver_type,
		       palive->ver_subtype);

	if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
836
		IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
837 838
		memcpy(&priv->card_alive_init, &pkt->u.alive_frame,
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
839 840
		pwork = &priv->init_alive_start;
	} else {
841
		IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
842
		memcpy(&priv->card_alive, &pkt->u.alive_frame,
843
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
844
		pwork = &priv->alive_start;
C
Christoph Hellwig 已提交
845
		iwl3945_disable_events(priv);
Z
Zhu Yi 已提交
846 847 848 849 850 851 852 853
	}

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

857
static void iwl3945_rx_reply_add_sta(struct iwl_priv *priv,
858
				 struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
859
{
860
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
861
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
862
#endif
Z
Zhu Yi 已提交
863

864
	IWL_DEBUG_RX(priv, "Received REPLY_ADD_STA: 0x%02X\n", pkt->u.status);
Z
Zhu Yi 已提交
865 866 867
	return;
}

C
Christoph Hellwig 已提交
868
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
869
{
870 871
	struct iwl_priv *priv =
		container_of(work, struct iwl_priv, beacon_update);
Z
Zhu Yi 已提交
872 873 874
	struct sk_buff *beacon;

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

	if (!beacon) {
878
		IWL_ERR(priv, "update beacon failed\n");
Z
Zhu Yi 已提交
879 880 881 882 883 884 885 886 887 888 889
		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 已提交
890
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
891 892
}

893
static void iwl3945_rx_beacon_notif(struct iwl_priv *priv,
894
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
895
{
S
Samuel Ortiz 已提交
896
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
897
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
C
Christoph Hellwig 已提交
898
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
899 900
	u8 rate = beacon->beacon_notify_hdr.rate;

901
	IWL_DEBUG_RX(priv, "beacon status %x retries %d iss %d "
Z
Zhu Yi 已提交
902 903 904 905 906 907 908 909
		"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

910
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
911 912 913 914 915 916
	    (!test_bit(STATUS_EXIT_PENDING, &priv->status)))
		queue_work(priv->workqueue, &priv->beacon_update);
}

/* Handle notification from uCode that card's power state is changing
 * due to software, hardware, or critical temperature RFKILL */
917
static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
918
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
919
{
Z
Zhu Yi 已提交
920
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
Z
Zhu Yi 已提交
921 922 923
	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
	unsigned long status = priv->status;

924
	IWL_WARN(priv, "Card state received: HW:%s SW:%s\n",
Z
Zhu Yi 已提交
925 926 927
			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
			  (flags & SW_CARD_DISABLED) ? "Kill" : "On");

928
	iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
929 930 931 932 933 934 935 936
		    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);


937
	iwl_scan_cancel(priv);
Z
Zhu Yi 已提交
938 939

	if ((test_bit(STATUS_RF_KILL_HW, &status) !=
J
Johannes Berg 已提交
940 941 942
	     test_bit(STATUS_RF_KILL_HW, &priv->status)))
		wiphy_rfkill_set_hw_state(priv->hw->wiphy,
				test_bit(STATUS_RF_KILL_HW, &priv->status));
Z
Zhu Yi 已提交
943 944 945 946 947
	else
		wake_up_interruptible(&priv->wait_command_queue);
}

/**
C
Christoph Hellwig 已提交
948
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
949 950 951 952 953 954 955
 *
 * 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.
 */
956
static void iwl3945_setup_rx_handlers(struct iwl_priv *priv)
Z
Zhu Yi 已提交
957
{
C
Christoph Hellwig 已提交
958 959
	priv->rx_handlers[REPLY_ALIVE] = iwl3945_rx_reply_alive;
	priv->rx_handlers[REPLY_ADD_STA] = iwl3945_rx_reply_add_sta;
960
	priv->rx_handlers[REPLY_ERROR] = iwl_rx_reply_error;
961
	priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl_rx_csa;
A
Abhijeet Kolekar 已提交
962
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
963
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
A
Abhijeet Kolekar 已提交
964
	    iwl_rx_pm_debug_statistics_notif;
C
Christoph Hellwig 已提交
965
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
966

967 968 969 970
	/*
	 * 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 已提交
971
	 */
C
Christoph Hellwig 已提交
972 973
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
974

975
	iwl_setup_spectrum_handlers(priv);
976
	iwl_setup_rx_scan_handlers(priv);
C
Christoph Hellwig 已提交
977
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
978

979
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
980
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
}

/************************** 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.
 *
1005
 * During initialization, the host sets up the READ queue position to the first
Z
Zhu Yi 已提交
1006 1007
 * INDEX position, and WRITE to the last (READ - 1 wrapped)
 *
1008
 * When the firmware places a packet in a buffer, it will advance the READ index
Z
Zhu Yi 已提交
1009 1010 1011 1012 1013 1014 1015
 * 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
1016
 *   to replenish the iwl->rxq->rx_free.
C
Christoph Hellwig 已提交
1017
 * + In iwl3945_rx_replenish (scheduled) if 'processed' != 'read' then the
Z
Zhu Yi 已提交
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
 *   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:
 *
1030
 * iwl3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
C
Christoph Hellwig 已提交
1031
 *                            iwl3945_rx_queue_restock
1032
 * iwl3945_rx_queue_restock() Moves available buffers from rx_free into Rx
Z
Zhu Yi 已提交
1033 1034
 *                            queue, updates firmware pointers, and updates
 *                            the WRITE index.  If insufficient rx_free buffers
C
Christoph Hellwig 已提交
1035
 *                            are available, schedules iwl3945_rx_replenish
Z
Zhu Yi 已提交
1036 1037
 *
 * -- enable interrupts --
1038
 * ISR - iwl3945_rx()         Detach iwl_rx_mem_buffers from pool up to the
Z
Zhu Yi 已提交
1039 1040
 *                            READ INDEX, detaching the SKB from the pool.
 *                            Moves the packet buffer from queue to rx_used.
C
Christoph Hellwig 已提交
1041
 *                            Calls iwl3945_rx_queue_restock to refill any empty
Z
Zhu Yi 已提交
1042 1043 1044 1045 1046 1047
 *                            slots.
 * ...
 *
 */

/**
1048
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
1049
 */
1050
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1051 1052 1053 1054 1055 1056
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

/**
C
Christoph Hellwig 已提交
1057
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
1058
 *
1059
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
1060
 * and we have free pre-allocated buffers, fill the ranks as much
1061
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
1062 1063 1064 1065 1066
 *
 * 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.
 */
1067
static int iwl3945_rx_queue_restock(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1068
{
1069
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1070
	struct list_head *element;
1071
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1072 1073 1074 1075 1076
	unsigned long flags;
	int write, rc;

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
1077
	while ((iwl_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
1078
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
1079
		element = rxq->rx_free.next;
1080
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
Z
Zhu Yi 已提交
1081
		list_del(element);
1082 1083

		/* Point to Rx buffer via next RBD in circular buffer */
Z
Zhu Yi 已提交
1084
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->page_dma);
Z
Zhu Yi 已提交
1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
		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);


1096 1097
	/* If we've added more space for the firmware to place data, tell it.
	 * Increment device's write pointer in multiples of 8. */
1098
	if ((rxq->write_actual != (rxq->write & ~0x7))
Z
Zhu Yi 已提交
1099 1100 1101 1102
	    || (abs(rxq->write - rxq->read) > 7)) {
		spin_lock_irqsave(&rxq->lock, flags);
		rxq->need_update = 1;
		spin_unlock_irqrestore(&rxq->lock, flags);
1103
		rc = iwl_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
1104 1105 1106 1107 1108 1109 1110 1111
		if (rc)
			return rc;
	}

	return 0;
}

/**
C
Christoph Hellwig 已提交
1112
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
1113 1114 1115
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
1116
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
1117
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
1118
 */
1119
static void iwl3945_rx_allocate(struct iwl_priv *priv, gfp_t priority)
Z
Zhu Yi 已提交
1120
{
1121
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1122
	struct list_head *element;
1123
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1124
	struct page *page;
Z
Zhu Yi 已提交
1125
	unsigned long flags;
1126
	gfp_t gfp_mask = priority;
A
Abhijeet Kolekar 已提交
1127 1128 1129 1130 1131 1132 1133 1134 1135

	while (1) {
		spin_lock_irqsave(&rxq->lock, flags);

		if (list_empty(&rxq->rx_used)) {
			spin_unlock_irqrestore(&rxq->lock, flags);
			return;
		}
		spin_unlock_irqrestore(&rxq->lock, flags);
1136

1137
		if (rxq->free_count > RX_LOW_WATERMARK)
1138
			gfp_mask |= __GFP_NOWARN;
Z
Zhu Yi 已提交
1139 1140

		if (priv->hw_params.rx_page_order > 0)
1141
			gfp_mask |= __GFP_COMP;
Z
Zhu Yi 已提交
1142

1143
		/* Alloc a new receive buffer */
1144
		page = alloc_pages(gfp_mask, priv->hw_params.rx_page_order);
Z
Zhu Yi 已提交
1145
		if (!page) {
Z
Zhu Yi 已提交
1146
			if (net_ratelimit())
1147 1148 1149 1150 1151 1152
				IWL_DEBUG_INFO(priv, "Failed to allocate SKB buffer.\n");
			if ((rxq->free_count <= RX_LOW_WATERMARK) &&
			    net_ratelimit())
				IWL_CRIT(priv, "Failed to allocate SKB buffer with %s. Only %u free buffers remaining.\n",
					 priority == GFP_ATOMIC ?  "GFP_ATOMIC" : "GFP_KERNEL",
					 rxq->free_count);
Z
Zhu Yi 已提交
1153 1154 1155 1156 1157
			/* 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 已提交
1158

1159 1160 1161
		spin_lock_irqsave(&rxq->lock, flags);
		if (list_empty(&rxq->rx_used)) {
			spin_unlock_irqrestore(&rxq->lock, flags);
Z
Zhu Yi 已提交
1162
			__free_pages(page, priv->hw_params.rx_page_order);
1163 1164 1165 1166 1167 1168 1169
			return;
		}
		element = rxq->rx_used.next;
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
		list_del(element);
		spin_unlock_irqrestore(&rxq->lock, flags);

Z
Zhu Yi 已提交
1170
		rxb->page = page;
1171
		/* Get physical address of RB/SKB */
Z
Zhu Yi 已提交
1172 1173 1174
		rxb->page_dma = pci_map_page(priv->pci_dev, page, 0,
				PAGE_SIZE << priv->hw_params.rx_page_order,
				PCI_DMA_FROMDEVICE);
A
Abhijeet Kolekar 已提交
1175 1176

		spin_lock_irqsave(&rxq->lock, flags);
Z
Zhu Yi 已提交
1177

Z
Zhu Yi 已提交
1178 1179
		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
Z
Zhu Yi 已提交
1180 1181
		priv->alloc_rxb_page++;

A
Abhijeet Kolekar 已提交
1182
		spin_unlock_irqrestore(&rxq->lock, flags);
Z
Zhu Yi 已提交
1183
	}
1184 1185
}

R
Reinette Chatre 已提交
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
void iwl3945_rx_queue_reset(struct iwl_priv *priv, struct iwl_rx_queue *rxq)
{
	unsigned long flags;
	int i;
	spin_lock_irqsave(&rxq->lock, flags);
	INIT_LIST_HEAD(&rxq->rx_free);
	INIT_LIST_HEAD(&rxq->rx_used);
	/* Fill the rx_used queue with _all_ of the Rx buffers */
	for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
		/* In the reset function, these buffers may have been allocated
		 * to an SKB, so we need to unmap and free potential storage */
Z
Zhu Yi 已提交
1197 1198 1199 1200
		if (rxq->pool[i].page != NULL) {
			pci_unmap_page(priv->pci_dev, rxq->pool[i].page_dma,
				PAGE_SIZE << priv->hw_params.rx_page_order,
				PCI_DMA_FROMDEVICE);
1201
			__iwl_free_pages(priv, rxq->pool[i].page);
Z
Zhu Yi 已提交
1202
			rxq->pool[i].page = NULL;
R
Reinette Chatre 已提交
1203 1204 1205 1206 1207 1208 1209
		}
		list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
	}

	/* Set us so that we have processed and used all buffers, but have
	 * not restocked the Rx queue with fresh buffers */
	rxq->read = rxq->write = 0;
1210
	rxq->write_actual = 0;
Z
Zhu Yi 已提交
1211
	rxq->free_count = 0;
R
Reinette Chatre 已提交
1212 1213 1214
	spin_unlock_irqrestore(&rxq->lock, flags);
}

1215 1216
void iwl3945_rx_replenish(void *data)
{
1217
	struct iwl_priv *priv = data;
1218 1219
	unsigned long flags;

1220
	iwl3945_rx_allocate(priv, GFP_KERNEL);
Z
Zhu Yi 已提交
1221 1222

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
1223
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1224 1225 1226
	spin_unlock_irqrestore(&priv->lock, flags);
}

1227 1228 1229 1230 1231 1232 1233 1234
static void iwl3945_rx_replenish_now(struct iwl_priv *priv)
{
	iwl3945_rx_allocate(priv, GFP_ATOMIC);

	iwl3945_rx_queue_restock(priv);
}


R
Reinette Chatre 已提交
1235 1236 1237 1238 1239 1240 1241 1242 1243
/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
 * This free routine walks the list of POOL entries and if SKB is set to
 * non NULL it is unmapped and freed
 */
static void iwl3945_rx_queue_free(struct iwl_priv *priv, struct iwl_rx_queue *rxq)
{
	int i;
	for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
Z
Zhu Yi 已提交
1244 1245 1246 1247
		if (rxq->pool[i].page != NULL) {
			pci_unmap_page(priv->pci_dev, rxq->pool[i].page_dma,
				PAGE_SIZE << priv->hw_params.rx_page_order,
				PCI_DMA_FROMDEVICE);
1248
			__iwl_free_pages(priv, rxq->pool[i].page);
Z
Zhu Yi 已提交
1249
			rxq->pool[i].page = NULL;
R
Reinette Chatre 已提交
1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
		}
	}

	pci_free_consistent(priv->pci_dev, 4 * RX_QUEUE_SIZE, rxq->bd,
			    rxq->dma_addr);
	pci_free_consistent(priv->pci_dev, sizeof(struct iwl_rb_status),
			    rxq->rb_stts, rxq->rb_stts_dma);
	rxq->bd = NULL;
	rxq->rb_stts  = NULL;
}


Z
Zhu Yi 已提交
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279
/* 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 已提交
1280
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
1281
{
1282 1283
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
1284 1285
		return 60;

1286
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
1287
	 *   add 20 dB to make up for divide by 10 */
1288
	if (sig_ratio >= 100)
1289
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305

	/* 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 已提交
1306
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
{
	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;
}

/**
1341
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
1342 1343 1344 1345 1346
 *
 * Uses the priv->rx_handlers callback function array to invoke
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
1347
static void iwl3945_rx_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1348
{
1349
	struct iwl_rx_mem_buffer *rxb;
1350
	struct iwl_rx_packet *pkt;
1351
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1352 1353 1354
	u32 r, i;
	int reclaim;
	unsigned long flags;
1355
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
1356
	u32 count = 8;
1357
	int total_empty = 0;
Z
Zhu Yi 已提交
1358

1359 1360
	/* 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 已提交
1361
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
1362 1363
	i = rxq->read;

1364
	/* calculate total frames need to be restock after handling RX */
1365
	total_empty = r - rxq->write_actual;
1366 1367 1368 1369
	if (total_empty < 0)
		total_empty += RX_QUEUE_SIZE;

	if (total_empty > (RX_QUEUE_SIZE / 2))
1370
		fill_rx = 1;
Z
Zhu Yi 已提交
1371 1372
	/* Rx interrupt, but nothing sent from uCode */
	if (i == r)
1373
		IWL_DEBUG_RX(priv, "r = %d, i = %d\n", r, i);
Z
Zhu Yi 已提交
1374 1375 1376 1377

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

1378
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
1379 1380 1381 1382 1383 1384
		 * then a bug has been introduced in the queue refilling
		 * routines -- catch it here */
		BUG_ON(rxb == NULL);

		rxq->queue[i] = NULL;

Z
Zhu Yi 已提交
1385 1386 1387 1388
		pci_unmap_page(priv->pci_dev, rxb->page_dma,
			       PAGE_SIZE << priv->hw_params.rx_page_order,
			       PCI_DMA_FROMDEVICE);
		pkt = rxb_addr(rxb);
Z
Zhu Yi 已提交
1389

J
Johannes Berg 已提交
1390 1391 1392
		trace_iwlwifi_dev_rx(priv, pkt,
			le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK);

Z
Zhu Yi 已提交
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
		/* 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 已提交
1405
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
1406
		if (priv->rx_handlers[pkt->hdr.cmd]) {
1407
			IWL_DEBUG_RX(priv, "r = %d, i = %d, %s, 0x%02x\n", r, i,
Z
Zhu Yi 已提交
1408
				get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
1409
			priv->isr_stats.rx_handlers[pkt->hdr.cmd]++;
1410
			priv->rx_handlers[pkt->hdr.cmd] (priv, rxb);
Z
Zhu Yi 已提交
1411 1412
		} else {
			/* No handling needed */
Z
Zhu Yi 已提交
1413 1414
			IWL_DEBUG_RX(priv,
				"r %d i %d No handler needed for %s, 0x%02x\n",
Z
Zhu Yi 已提交
1415 1416 1417 1418
				r, i, get_cmd_string(pkt->hdr.cmd),
				pkt->hdr.cmd);
		}

1419 1420 1421 1422 1423 1424 1425
		/*
		 * XXX: After here, we should always check rxb->page
		 * against NULL before touching it or its virtual
		 * memory (pkt). Because some rx_handler might have
		 * already taken or freed the pages.
		 */

Z
Zhu Yi 已提交
1426
		if (reclaim) {
Z
Zhu Yi 已提交
1427 1428
			/* Invoke any callbacks, transfer the buffer to caller,
			 * and fire off the (possibly) blocking iwl_send_cmd()
Z
Zhu Yi 已提交
1429
			 * as we reclaim the driver command queue */
1430
			if (rxb->page)
1431
				iwl_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
1432
			else
1433
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
1434 1435
		}

1436 1437 1438 1439
		/* Reuse the page if possible. For notification packets and
		 * SKBs that fail to Rx correctly, add them back into the
		 * rx_free list for reuse later. */
		spin_lock_irqsave(&rxq->lock, flags);
Z
Zhu Yi 已提交
1440
		if (rxb->page != NULL) {
1441 1442 1443 1444 1445 1446 1447
			rxb->page_dma = pci_map_page(priv->pci_dev, rxb->page,
				0, PAGE_SIZE << priv->hw_params.rx_page_order,
				PCI_DMA_FROMDEVICE);
			list_add_tail(&rxb->list, &rxq->rx_free);
			rxq->free_count++;
		} else
			list_add_tail(&rxb->list, &rxq->rx_used);
Z
Zhu Yi 已提交
1448 1449

		spin_unlock_irqrestore(&rxq->lock, flags);
1450

Z
Zhu Yi 已提交
1451
		i = (i + 1) & RX_QUEUE_MASK;
1452 1453 1454 1455 1456
		/* If there are a lot of unused frames,
		 * restock the Rx queue so ucode won't assert. */
		if (fill_rx) {
			count++;
			if (count >= 8) {
1457
				rxq->read = i;
1458
				iwl3945_rx_replenish_now(priv);
1459 1460 1461
				count = 0;
			}
		}
Z
Zhu Yi 已提交
1462 1463 1464
	}

	/* Backtrack one entry */
1465
	rxq->read = i;
1466 1467 1468 1469
	if (fill_rx)
		iwl3945_rx_replenish_now(priv);
	else
		iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1470 1471
}

1472
/* call this function to flush any scheduled tasklet */
1473
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
1474
{
T
Tomas Winkler 已提交
1475
	/* wait to make sure we flush pending tasklet*/
1476 1477 1478 1479
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}

Z
Zhu Yi 已提交
1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502
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))

1503
void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1504 1505 1506 1507 1508 1509 1510
{
	u32 i;
	u32 desc, time, count, base, data1;
	u32 blink1, blink2, ilink1, ilink2;

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

C
Christoph Hellwig 已提交
1511
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1512
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1513 1514 1515 1516
		return;
	}


1517
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
1518 1519

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

1525
	IWL_ERR(priv, "Desc       Time       asrtPC  blink2 "
Z
Zhu Yi 已提交
1526 1527 1528 1529
		  "ilink1  nmiPC   Line\n");
	for (i = ERROR_START_OFFSET;
	     i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
	     i += ERROR_ELEM_SIZE) {
1530
		desc = iwl_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
1531
		time =
1532
		    iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
1533
		blink1 =
1534
		    iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
1535
		blink2 =
1536
		    iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
1537
		ilink1 =
1538
		    iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
1539
		ilink2 =
1540
		    iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
1541
		data1 =
1542
		    iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
1543

1544 1545 1546 1547
		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);
J
Johannes Berg 已提交
1548 1549
		trace_iwlwifi_dev_ucode_error(priv, desc, time, data1, 0,
					0, blink1, blink2, ilink1, ilink2);
Z
Zhu Yi 已提交
1550 1551 1552
	}
}

1553
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
1554 1555

/**
C
Christoph Hellwig 已提交
1556
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
1557 1558
 *
 */
1559
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
1560 1561 1562 1563 1564 1565 1566
				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 */
B
Ben Cahill 已提交
1567
	unsigned long reg_flags;
Z
Zhu Yi 已提交
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580

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

B
Ben Cahill 已提交
1581 1582 1583 1584 1585 1586 1587 1588
	/* Make sure device is powered up for SRAM reads */
	spin_lock_irqsave(&priv->reg_lock, reg_flags);
	iwl_grab_nic_access(priv);

	/* Set starting address; reads will auto-increment */
	_iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR, ptr);
	rmb();

Z
Zhu Yi 已提交
1589 1590 1591
	/* "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++) {
B
Ben Cahill 已提交
1592 1593
		ev = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
		time = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
1594 1595 1596
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
J
Johannes Berg 已提交
1597
			trace_iwlwifi_dev_ucode_event(priv, 0, time, ev);
1598
		} else {
B
Ben Cahill 已提交
1599
			data = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
1600
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
J
Johannes Berg 已提交
1601
			trace_iwlwifi_dev_ucode_event(priv, time, data, ev);
Z
Zhu Yi 已提交
1602 1603
		}
	}
B
Ben Cahill 已提交
1604 1605 1606 1607

	/* Allow device to power down */
	iwl_release_nic_access(priv);
	spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
Z
Zhu Yi 已提交
1608 1609
}

1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
/**
 * iwl3945_print_last_event_logs - Dump the newest # of event log to syslog
 */
static void iwl3945_print_last_event_logs(struct iwl_priv *priv, u32 capacity,
				      u32 num_wraps, u32 next_entry,
				      u32 size, u32 mode)
{
	/*
	 * display the newest DEFAULT_LOG_ENTRIES entries
	 * i.e the entries just before the next ont that uCode would fill.
	 */
	if (num_wraps) {
		if (next_entry < size) {
			iwl3945_print_event_log(priv,
					capacity - (size - next_entry),
					size - next_entry, mode);
			iwl3945_print_event_log(priv, 0,
				    next_entry, mode);
		} else
			iwl3945_print_event_log(priv, next_entry - size,
				    size, mode);
	} else {
		if (next_entry < size)
			iwl3945_print_event_log(priv, 0, next_entry, mode);
		else
			iwl3945_print_event_log(priv, next_entry - size,
					    size, mode);
	}
}

B
Ben Cahill 已提交
1640 1641 1642
/* For sanity check only.  Actual size is determined by uCode, typ. 512 */
#define IWL3945_MAX_EVENT_LOG_SIZE (512)

1643 1644 1645
#define DEFAULT_IWL3945_DUMP_EVENT_LOG_ENTRIES (20)

void iwl3945_dump_nic_event_log(struct iwl_priv *priv, bool full_log)
Z
Zhu Yi 已提交
1646 1647 1648 1649 1650 1651 1652 1653 1654
{
	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 已提交
1655
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1656
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1657 1658 1659 1660
		return;
	}

	/* event log header */
1661 1662 1663 1664
	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 已提交
1665

B
Ben Cahill 已提交
1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677
	if (capacity > IWL3945_MAX_EVENT_LOG_SIZE) {
		IWL_ERR(priv, "Log capacity %d is bogus, limit to %d entries\n",
			capacity, IWL3945_MAX_EVENT_LOG_SIZE);
		capacity = IWL3945_MAX_EVENT_LOG_SIZE;
	}

	if (next_entry > IWL3945_MAX_EVENT_LOG_SIZE) {
		IWL_ERR(priv, "Log write index %d is bogus, limit to %d\n",
			next_entry, IWL3945_MAX_EVENT_LOG_SIZE);
		next_entry = IWL3945_MAX_EVENT_LOG_SIZE;
	}

Z
Zhu Yi 已提交
1678 1679 1680 1681
	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
1682
		IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
Z
Zhu Yi 已提交
1683 1684 1685
		return;
	}

1686
#ifdef CONFIG_IWLWIFI_DEBUG
1687
	if (!(iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS) && !full_log)
1688 1689 1690 1691 1692 1693 1694 1695 1696
		size = (size > DEFAULT_IWL3945_DUMP_EVENT_LOG_ENTRIES)
			? DEFAULT_IWL3945_DUMP_EVENT_LOG_ENTRIES : size;
#else
	size = (size > DEFAULT_IWL3945_DUMP_EVENT_LOG_ENTRIES)
		? DEFAULT_IWL3945_DUMP_EVENT_LOG_ENTRIES : size;
#endif

	IWL_ERR(priv, "Start IWL Event Log Dump: display last %d count\n",
		  size);
Z
Zhu Yi 已提交
1697

1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712
#ifdef CONFIG_IWLWIFI_DEBUG
	if ((iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS) || full_log) {
		/* 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)
			iwl3945_print_event_log(priv, next_entry,
				    capacity - next_entry, mode);

		/* (then/else) start at top of log */
		iwl3945_print_event_log(priv, 0, next_entry, mode);
	} else
		iwl3945_print_last_event_logs(priv, capacity, num_wraps,
					next_entry, size, mode);
1713
#else
1714 1715 1716
	iwl3945_print_last_event_logs(priv, capacity, num_wraps,
				next_entry, size, mode);
#endif
1717 1718 1719

}

1720
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1721 1722 1723 1724
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
S
Samuel Ortiz 已提交
1725
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1726 1727 1728 1729 1730 1731 1732 1733
	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. */
1734 1735
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
1736 1737 1738 1739

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

S
Samuel Ortiz 已提交
1743
#ifdef CONFIG_IWLWIFI_DEBUG
1744
	if (iwl_get_debug_level(priv) & IWL_DL_ISR) {
1745
		/* just for debug */
1746
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
1747
		IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
Z
Zhu Yi 已提交
1748 1749 1750 1751
			      inta, inta_mask, inta_fh);
	}
#endif

Z
Zhu Yi 已提交
1752 1753
	spin_unlock_irqrestore(&priv->lock, flags);

Z
Zhu Yi 已提交
1754 1755 1756 1757
	/* 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 已提交
1758
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
1759
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
1760
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
1761 1762 1763 1764
		inta |= CSR_INT_BIT_FH_TX;

	/* Now service all interrupt bits discovered above. */
	if (inta & CSR_INT_BIT_HW_ERR) {
1765
		IWL_ERR(priv, "Hardware error detected.  Restarting.\n");
Z
Zhu Yi 已提交
1766 1767

		/* Tell the device to stop sending interrupts */
1768
		iwl_disable_interrupts(priv);
Z
Zhu Yi 已提交
1769

1770
		priv->isr_stats.hw++;
1771
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1772 1773 1774 1775 1776 1777

		handled |= CSR_INT_BIT_HW_ERR;

		return;
	}

S
Samuel Ortiz 已提交
1778
#ifdef CONFIG_IWLWIFI_DEBUG
1779
	if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
1780
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
1781
		if (inta & CSR_INT_BIT_SCD) {
1782
			IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
1783
				      "the frame/frames.\n");
1784 1785
			priv->isr_stats.sch++;
		}
Z
Zhu Yi 已提交
1786 1787

		/* Alive notification via Rx interrupt will do the real work */
1788
		if (inta & CSR_INT_BIT_ALIVE) {
1789
			IWL_DEBUG_ISR(priv, "Alive interrupt\n");
1790 1791
			priv->isr_stats.alive++;
		}
Z
Zhu Yi 已提交
1792 1793 1794
	}
#endif
	/* Safely ignore these bits for debug checks below */
1795
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
1796 1797 1798

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
1799 1800
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
1801 1802
		priv->isr_stats.sw++;
		priv->isr_stats.sw_err = inta;
1803
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1804 1805 1806 1807 1808
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
1809
		IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
1810
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
1811 1812 1813 1814 1815 1816
		iwl_txq_update_write_ptr(priv, &priv->txq[0]);
		iwl_txq_update_write_ptr(priv, &priv->txq[1]);
		iwl_txq_update_write_ptr(priv, &priv->txq[2]);
		iwl_txq_update_write_ptr(priv, &priv->txq[3]);
		iwl_txq_update_write_ptr(priv, &priv->txq[4]);
		iwl_txq_update_write_ptr(priv, &priv->txq[5]);
Z
Zhu Yi 已提交
1817

1818
		priv->isr_stats.wakeup++;
Z
Zhu Yi 已提交
1819 1820 1821 1822 1823 1824 1825
		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 已提交
1826
		iwl3945_rx_handle(priv);
1827
		priv->isr_stats.rx++;
Z
Zhu Yi 已提交
1828 1829 1830 1831
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

	if (inta & CSR_INT_BIT_FH_TX) {
1832
		IWL_DEBUG_ISR(priv, "Tx interrupt\n");
1833
		priv->isr_stats.tx++;
Z
Zhu Yi 已提交
1834

1835
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
M
Mohamed Abbas 已提交
1836 1837
		iwl_write_direct32(priv, FH39_TCSR_CREDIT
					(FH39_SRVC_CHNL), 0x0);
Z
Zhu Yi 已提交
1838 1839 1840
		handled |= CSR_INT_BIT_FH_TX;
	}

1841
	if (inta & ~handled) {
1842
		IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
1843 1844
		priv->isr_stats.unhandled++;
	}
Z
Zhu Yi 已提交
1845

1846
	if (inta & ~priv->inta_mask) {
1847
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
1848
			 inta & ~priv->inta_mask);
1849
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
1850 1851 1852
	}

	/* Re-enable all interrupts */
1853 1854
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
1855
		iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
1856

S
Samuel Ortiz 已提交
1857
#ifdef CONFIG_IWLWIFI_DEBUG
1858
	if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
1859 1860 1861
		inta = iwl_read32(priv, CSR_INT);
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
1862
		IWL_DEBUG_ISR(priv, "End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
Z
Zhu Yi 已提交
1863 1864 1865 1866 1867
			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
	}
#endif
}

1868
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
1869
					 enum ieee80211_band band,
1870
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
1871
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
1872
{
1873
	struct ieee80211_channel *chan;
1874
	const struct ieee80211_supported_band *sband;
1875
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
1876 1877 1878 1879
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
1880
	sband = iwl_get_hw_mode(priv, band);
1881
	if (!sband)
Z
Zhu Yi 已提交
1882 1883
		return 0;

S
Samuel Ortiz 已提交
1884 1885
	active_dwell = iwl_get_active_dwell_time(priv, band, n_probes);
	passive_dwell = iwl_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
1886

1887 1888 1889
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

1890 1891 1892 1893
	for (i = 0, added = 0; i < priv->scan_request->n_channels; i++) {
		chan = priv->scan_request->channels[i];

		if (chan->band != band)
1894 1895
			continue;

1896
		scan_ch->channel = chan->hw_value;
Z
Zhu Yi 已提交
1897

1898
		ch_info = iwl_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
1899
		if (!is_channel_valid(ch_info)) {
1900
			IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
1901 1902 1903 1904
				       scan_ch->channel);
			continue;
		}

1905 1906 1907 1908 1909
		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 已提交
1910
		if (!is_active || is_channel_passive(ch_info) ||
1911
		    (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
1912
			scan_ch->type = 0;	/* passive */
1913 1914 1915
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
1916
			scan_ch->type = 1;	/* active */
1917
		}
Z
Zhu Yi 已提交
1918

1919 1920 1921 1922 1923 1924
		/* 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)
1925
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
1926 1927 1928 1929
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
1930
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
1931
		}
Z
Zhu Yi 已提交
1932

1933
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
1934 1935 1936 1937
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
1938
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
1939 1940 1941 1942
			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
1943
			 * power level:
1944
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
1945 1946 1947
			 */
		}

1948
		IWL_DEBUG_SCAN(priv, "Scanning %d [%s %d]\n",
Z
Zhu Yi 已提交
1949 1950 1951 1952 1953 1954 1955 1956 1957
			       scan_ch->channel,
			       (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
			       (scan_ch->type & 1) ?
			       active_dwell : passive_dwell);

		scan_ch++;
		added++;
	}

1958
	IWL_DEBUG_SCAN(priv, "total channels to scan %d \n", added);
Z
Zhu Yi 已提交
1959 1960 1961
	return added;
}

1962
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1963 1964 1965 1966 1967
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
1968 1969 1970 1971
		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;
1972
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
1973
			/*
1974
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
1975
			 */
C
Christoph Hellwig 已提交
1976
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
1977
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
		}
	}
}

/******************************************************************************
 *
 * uCode download functions
 *
 ******************************************************************************/

1988
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1989
{
1990 1991 1992 1993 1994 1995
	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 已提交
1996 1997 1998
}

/**
C
Christoph Hellwig 已提交
1999
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2000 2001
 *     looking at all data.
 */
2002
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2003 2004 2005 2006 2007 2008
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

2009
	IWL_DEBUG_INFO(priv, "ucode inst image size is %u\n", len);
Z
Zhu Yi 已提交
2010

2011
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2012
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
2013 2014 2015 2016 2017 2018

	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 */
2019
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2020
		if (val != le32_to_cpu(*image)) {
2021
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
				  "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;
		}
	}


	if (!errcnt)
2033 2034
		IWL_DEBUG_INFO(priv,
			"ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
2035 2036 2037 2038 2039 2040

	return rc;
}


/**
C
Christoph Hellwig 已提交
2041
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2042 2043 2044
 *   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.
 */
2045
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2046 2047 2048 2049 2050 2051
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

2052
	IWL_DEBUG_INFO(priv, "ucode inst image size is %u\n", len);
Z
Zhu Yi 已提交
2053 2054 2055 2056 2057

	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 */
2058
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2059
			i + IWL39_RTC_INST_LOWER_BOUND);
2060
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2061 2062
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
2063
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078
				  "offset 0x%x, is 0x%x, s/b 0x%x\n",
				  i, val, *image);
#endif
			rc = -EIO;
			errcnt++;
			if (errcnt >= 3)
				break;
		}
	}

	return rc;
}


/**
C
Christoph Hellwig 已提交
2079
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
2080 2081
 *    and verify its contents
 */
2082
static int iwl3945_verify_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2083 2084 2085 2086 2087 2088 2089 2090
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2091
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2092
	if (rc == 0) {
2093
		IWL_DEBUG_INFO(priv, "Bootstrap uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2094 2095 2096 2097 2098 2099
		return 0;
	}

	/* Try initialize */
	image = (__le32 *)priv->ucode_init.v_addr;
	len = priv->ucode_init.len;
C
Christoph Hellwig 已提交
2100
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2101
	if (rc == 0) {
2102
		IWL_DEBUG_INFO(priv, "Initialize uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2103 2104 2105 2106 2107 2108
		return 0;
	}

	/* Try runtime/protocol */
	image = (__le32 *)priv->ucode_code.v_addr;
	len = priv->ucode_code.len;
C
Christoph Hellwig 已提交
2109
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2110
	if (rc == 0) {
2111
		IWL_DEBUG_INFO(priv, "Runtime uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2112 2113 2114
		return 0;
	}

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

2117 2118 2119
	/* 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 已提交
2120 2121
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2122
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
2123 2124 2125 2126

	return rc;
}

2127
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2128 2129
{
	/* Remove all resets to allow NIC to operate */
2130
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
2131 2132 2133
}

/**
C
Christoph Hellwig 已提交
2134
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
2135 2136 2137
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
2138
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2139
{
2140
	const struct iwl_ucode_header *ucode;
2141
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
2142 2143
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
2144 2145 2146 2147
	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 已提交
2148 2149
	u8 *src;
	size_t len;
2150
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
2151 2152 2153

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
2154 2155 2156 2157
	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) {
2158
			IWL_ERR(priv, "%s firmware file req failed: %d\n",
2159 2160 2161 2162 2163 2164 2165
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
2166 2167 2168
				IWL_ERR(priv, "Loaded firmware %s, "
					"which is deprecated. "
					" Please use API v%u instead.\n",
2169
					  buf, api_max);
2170 2171
			IWL_DEBUG_INFO(priv, "Got firmware '%s' file "
				       "(%zd bytes) from disk\n",
2172 2173 2174
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
2175 2176
	}

2177 2178
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
2179 2180

	/* Make sure that we got at least our header! */
2181
	if (ucode_raw->size <  priv->cfg->ops->ucode->get_header_size(1)) {
2182
		IWL_ERR(priv, "File size way too small!\n");
2183
		ret = -EINVAL;
Z
Zhu Yi 已提交
2184 2185 2186 2187
		goto err_release;
	}

	/* Data from ucode file:  header followed by uCode images */
2188
	ucode = (struct iwl_ucode_header *)ucode_raw->data;
Z
Zhu Yi 已提交
2189

2190
	priv->ucode_ver = le32_to_cpu(ucode->ver);
2191
	api_ver = IWL_UCODE_API(priv->ucode_ver);
2192 2193 2194 2195 2196 2197 2198
	inst_size = priv->cfg->ops->ucode->get_inst_size(ucode, api_ver);
	data_size = priv->cfg->ops->ucode->get_data_size(ucode, api_ver);
	init_size = priv->cfg->ops->ucode->get_init_size(ucode, api_ver);
	init_data_size =
		priv->cfg->ops->ucode->get_init_data_size(ucode, api_ver);
	boot_size = priv->cfg->ops->ucode->get_boot_size(ucode, api_ver);
	src = priv->cfg->ops->ucode->get_data(ucode, api_ver);
Z
Zhu Yi 已提交
2199

2200 2201
	/* api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
2202
	 * on the API version read from firmware header from here on forward */
2203 2204

	if (api_ver < api_min || api_ver > api_max) {
2205
		IWL_ERR(priv, "Driver unable to support your firmware API. "
2206 2207 2208 2209 2210 2211 2212
			  "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)
2213
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
2214 2215 2216 2217
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
2218 2219 2220 2221 2222 2223
	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));

2224 2225 2226 2227 2228 2229 2230 2231
	snprintf(priv->hw->wiphy->fw_version,
		 sizeof(priv->hw->wiphy->fw_version),
		 "%u.%u.%u.%u",
		 IWL_UCODE_MAJOR(priv->ucode_ver),
		 IWL_UCODE_MINOR(priv->ucode_ver),
		 IWL_UCODE_API(priv->ucode_ver),
		 IWL_UCODE_SERIAL(priv->ucode_ver));

2232
	IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
2233
		       priv->ucode_ver);
2234 2235 2236 2237 2238 2239 2240 2241 2242 2243
	IWL_DEBUG_INFO(priv, "f/w package hdr runtime inst size = %u\n",
		       inst_size);
	IWL_DEBUG_INFO(priv, "f/w package hdr runtime data size = %u\n",
		       data_size);
	IWL_DEBUG_INFO(priv, "f/w package hdr init inst size = %u\n",
		       init_size);
	IWL_DEBUG_INFO(priv, "f/w package hdr init data size = %u\n",
		       init_data_size);
	IWL_DEBUG_INFO(priv, "f/w package hdr boot inst size = %u\n",
		       boot_size);
Z
Zhu Yi 已提交
2244

2245

Z
Zhu Yi 已提交
2246
	/* Verify size of file vs. image size info in file's header */
2247
	if (ucode_raw->size != priv->cfg->ops->ucode->get_header_size(api_ver) +
Z
Zhu Yi 已提交
2248 2249 2250
		inst_size + data_size + init_size +
		init_data_size + boot_size) {

2251 2252 2253
		IWL_DEBUG_INFO(priv,
			"uCode file size %zd does not match expected size\n",
			ucode_raw->size);
2254
		ret = -EINVAL;
Z
Zhu Yi 已提交
2255 2256 2257 2258
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
2259
	if (inst_size > IWL39_MAX_INST_SIZE) {
2260
		IWL_DEBUG_INFO(priv, "uCode instr len %d too large to fit in\n",
2261 2262
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2263 2264 2265
		goto err_release;
	}

2266
	if (data_size > IWL39_MAX_DATA_SIZE) {
2267
		IWL_DEBUG_INFO(priv, "uCode data len %d too large to fit in\n",
2268 2269
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2270 2271
		goto err_release;
	}
2272
	if (init_size > IWL39_MAX_INST_SIZE) {
2273 2274
		IWL_DEBUG_INFO(priv,
				"uCode init instr len %d too large to fit in\n",
2275 2276
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2277 2278
		goto err_release;
	}
2279
	if (init_data_size > IWL39_MAX_DATA_SIZE) {
2280 2281
		IWL_DEBUG_INFO(priv,
				"uCode init data len %d too large to fit in\n",
2282 2283
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2284 2285
		goto err_release;
	}
2286
	if (boot_size > IWL39_MAX_BSM_SIZE) {
2287 2288
		IWL_DEBUG_INFO(priv,
				"uCode boot instr len %d too large to fit in\n",
2289 2290
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2291 2292 2293 2294 2295 2296 2297 2298 2299
		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;
2300
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
2301 2302

	priv->ucode_data.len = data_size;
2303
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
2304 2305

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

2308 2309 2310
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
2311 2312

	/* Initialization instructions and data */
2313 2314
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
2315
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
2316 2317

		priv->ucode_init_data.len = init_data_size;
2318
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
2319 2320 2321 2322

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

	/* Bootstrap (instructions only, no data) */
2325 2326
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
2327
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
2328

2329 2330 2331
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
2332 2333 2334 2335

	/* Copy images into buffers for card's bus-master reads ... */

	/* Runtime instructions (first block of data in file) */
2336
	len = inst_size;
2337 2338
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode instr len %zd\n", len);
Z
Zhu Yi 已提交
2339
	memcpy(priv->ucode_code.v_addr, src, len);
2340 2341
	src += len;

2342
	IWL_DEBUG_INFO(priv, "uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
Z
Zhu Yi 已提交
2343 2344 2345
		priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
2346
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
2347
	len = data_size;
2348 2349
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode data len %zd\n", len);
Z
Zhu Yi 已提交
2350 2351
	memcpy(priv->ucode_data.v_addr, src, len);
	memcpy(priv->ucode_data_backup.v_addr, src, len);
2352
	src += len;
Z
Zhu Yi 已提交
2353 2354 2355

	/* Initialization instructions (3rd block) */
	if (init_size) {
2356
		len = init_size;
2357 2358
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init instr len %zd\n", len);
Z
Zhu Yi 已提交
2359
		memcpy(priv->ucode_init.v_addr, src, len);
2360
		src += len;
Z
Zhu Yi 已提交
2361 2362 2363 2364
	}

	/* Initialization data (4th block) */
	if (init_data_size) {
2365
		len = init_data_size;
2366 2367
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init data len %zd\n", len);
Z
Zhu Yi 已提交
2368
		memcpy(priv->ucode_init_data.v_addr, src, len);
2369
		src += len;
Z
Zhu Yi 已提交
2370 2371 2372
	}

	/* Bootstrap instructions (5th block) */
2373
	len = boot_size;
2374 2375
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) boot instr len %zd\n", len);
Z
Zhu Yi 已提交
2376 2377 2378 2379 2380 2381 2382
	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:
2383
	IWL_ERR(priv, "failed to allocate pci memory\n");
2384
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
2385
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
2386 2387 2388 2389 2390

 err_release:
	release_firmware(ucode_raw);

 error:
2391
	return ret;
Z
Zhu Yi 已提交
2392 2393 2394 2395
}


/**
C
Christoph Hellwig 已提交
2396
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
2397 2398 2399 2400 2401 2402 2403
 *
 * 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.
 */
2404
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2405 2406 2407 2408 2409 2410 2411 2412 2413
{
	dma_addr_t pinst;
	dma_addr_t pdata;

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

	/* Tell bootstrap uCode where to find image to load */
2414 2415 2416
	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 已提交
2417 2418
				 priv->ucode_data.len);

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

2424
	IWL_DEBUG_INFO(priv, "Runtime uCode pointers are set.\n");
Z
Zhu Yi 已提交
2425

M
Mohamed Abbas 已提交
2426
	return 0;
Z
Zhu Yi 已提交
2427 2428 2429
}

/**
C
Christoph Hellwig 已提交
2430
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2431 2432 2433 2434
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
2435
 */
2436
static void iwl3945_init_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2437 2438 2439 2440 2441
{
	/* 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 */
2442
		IWL_DEBUG_INFO(priv, "Initialize Alive failed.\n");
Z
Zhu Yi 已提交
2443 2444 2445 2446 2447 2448
		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 已提交
2449
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2450 2451
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2452
		IWL_DEBUG_INFO(priv, "Bad \"initialize\" uCode load.\n");
Z
Zhu Yi 已提交
2453 2454 2455 2456 2457 2458
		goto restart;
	}

	/* Send pointers to protocol/runtime uCode image ... init code will
	 * load and launch runtime uCode, which will send us another "Alive"
	 * notification. */
2459
	IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
C
Christoph Hellwig 已提交
2460
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
2461 2462
		/* Runtime instruction load won't happen;
		 * take it all the way back down so we can try again */
2463
		IWL_DEBUG_INFO(priv, "Couldn't set up uCode pointers.\n");
Z
Zhu Yi 已提交
2464 2465 2466 2467 2468 2469 2470 2471 2472
		goto restart;
	}
	return;

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

/**
C
Christoph Hellwig 已提交
2473
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2474
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
2475
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
2476
 */
2477
static void iwl3945_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2478 2479 2480 2481
{
	int thermal_spin = 0;
	u32 rfkill;

2482
	IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
2483 2484 2485 2486

	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 */
2487
		IWL_DEBUG_INFO(priv, "Alive failed.\n");
Z
Zhu Yi 已提交
2488 2489 2490 2491 2492 2493
		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 已提交
2494
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2495 2496
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2497
		IWL_DEBUG_INFO(priv, "Bad runtime uCode load.\n");
Z
Zhu Yi 已提交
2498 2499 2500
		goto restart;
	}

2501
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2502

2503
	rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
2504
	IWL_DEBUG_INFO(priv, "RFKILL status: 0x%x\n", rfkill);
Z
Zhu Yi 已提交
2505 2506 2507

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
2508
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
2509
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
2510
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
2511 2512 2513 2514 2515
			thermal_spin++;
			udelay(10);
		}

		if (thermal_spin)
2516
			IWL_DEBUG_INFO(priv, "Thermal calibration took %dus\n",
Z
Zhu Yi 已提交
2517 2518 2519 2520
				       thermal_spin * 10);
	} else
		set_bit(STATUS_RF_KILL_HW, &priv->status);

2521
	/* After the ALIVE response, we can send commands to 3945 uCode */
Z
Zhu Yi 已提交
2522 2523
	set_bit(STATUS_ALIVE, &priv->status);

2524
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
2525 2526
		return;

2527
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
2528 2529 2530 2531

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

2532
	iwl_power_update_mode(priv, true);
Z
Zhu Yi 已提交
2533

2534
	if (iwl_is_associated(priv)) {
C
Christoph Hellwig 已提交
2535
		struct iwl3945_rxon_cmd *active_rxon =
2536
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
2537

2538
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
Z
Zhu Yi 已提交
2539 2540 2541
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
2542
		iwl_connection_init_rx_config(priv, priv->iw_mode);
Z
Zhu Yi 已提交
2543 2544
	}

2545
	/* Configure Bluetooth device coexistence support */
2546
	iwl_send_bt_config(priv);
Z
Zhu Yi 已提交
2547 2548

	/* Configure the adapter for unassociated operation */
A
Abhijeet Kolekar 已提交
2549
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
2550 2551 2552

	iwl3945_reg_txpower_periodic(priv);

J
Johannes Berg 已提交
2553
	iwl_leds_init(priv);
2554

2555
	IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
2556
	set_bit(STATUS_READY, &priv->status);
2557
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
2558

2559 2560 2561 2562 2563
	/* 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)
2564
			iwl_mac_beacon_update(priv->hw, beacon);
2565 2566
	}

A
Abhijeet Kolekar 已提交
2567
	if (test_and_clear_bit(STATUS_MODE_PENDING, &priv->status))
2568
		iwl_set_mode(priv, priv->iw_mode);
A
Abhijeet Kolekar 已提交
2569

Z
Zhu Yi 已提交
2570 2571 2572 2573 2574 2575
	return;

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

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

2578
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2579 2580 2581 2582 2583
{
	unsigned long flags;
	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
	struct ieee80211_conf *conf = NULL;

2584
	IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
Z
Zhu Yi 已提交
2585 2586 2587 2588 2589 2590

	conf = ieee80211_get_hw_conf(priv->hw);

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

2591
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2592 2593 2594 2595 2596 2597 2598 2599 2600 2601

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

	/* tell the device to stop sending interrupts */
2605
	spin_lock_irqsave(&priv->lock, flags);
2606
	iwl_disable_interrupts(priv);
2607 2608
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
2609 2610 2611 2612

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

C
Christoph Hellwig 已提交
2613
	/* If we have not previously called iwl3945_init() then
2614
	 * clear all bits but the RF Kill bits and return */
2615
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
2616 2617
		priv->status = test_bit(STATUS_RF_KILL_HW, &priv->status) <<
					STATUS_RF_KILL_HW |
2618 2619
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
2620 2621
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2622 2623 2624
		goto exit;
	}

2625
	/* ...otherwise clear out all the status bits but the RF Kill
J
Johannes Berg 已提交
2626
	 * bit and continue taking the NIC down. */
Z
Zhu Yi 已提交
2627 2628
	priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
				STATUS_RF_KILL_HW |
2629 2630
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
2631
			test_bit(STATUS_FW_ERROR, &priv->status) <<
2632 2633 2634
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2635

C
Christoph Hellwig 已提交
2636 2637
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
2638

B
Ben Cahill 已提交
2639 2640
	/* Power-down device's busmaster DMA clocks */
	iwl_write_prph(priv, APMG_CLK_DIS_REG, APMG_CLK_VAL_DMA_CLK_RQT);
Z
Zhu Yi 已提交
2641 2642
	udelay(5);

2643 2644
	/* Stop the device, and put it in low power state */
	priv->cfg->ops->lib->apm_ops.stop(priv);
2645

Z
Zhu Yi 已提交
2646
 exit:
2647
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
2648 2649 2650 2651 2652 2653

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
2654
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
2655 2656
}

2657
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2658 2659
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2660
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
2661
	mutex_unlock(&priv->mutex);
2662

C
Christoph Hellwig 已提交
2663
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
2664 2665 2666 2667
}

#define MAX_HW_RESTARTS 5

2668
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2669 2670 2671 2672
{
	int rc, i;

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
2673
		IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
Z
Zhu Yi 已提交
2674 2675 2676
		return -EIO;
	}

2677
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
2678
		IWL_ERR(priv, "ucode not available for device bring up\n");
2679 2680 2681
		return -EIO;
	}

2682
	/* If platform's RF_KILL switch is NOT set to KILL */
2683
	if (iwl_read32(priv, CSR_GP_CNTRL) &
2684 2685 2686 2687
				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);
2688 2689
		IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
		return -ENODEV;
Z
Zhu Yi 已提交
2690
	}
2691

2692
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
2693

C
Christoph Hellwig 已提交
2694
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
2695
	if (rc) {
2696
		IWL_ERR(priv, "Unable to int nic\n");
Z
Zhu Yi 已提交
2697 2698 2699 2700
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
2701 2702
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
2703 2704 2705
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
2706
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2707
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
2708 2709

	/* really make sure rfkill handshake bits are cleared */
2710 2711
	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 已提交
2712 2713 2714 2715 2716

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

2719 2720 2721 2722
	/* 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 已提交
2723 2724
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

2725
		iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2726 2727 2728 2729

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

		if (rc) {
2733 2734
			IWL_ERR(priv,
				"Unable to set up bootstrap uCode: %d\n", rc);
Z
Zhu Yi 已提交
2735 2736 2737 2738
			continue;
		}

		/* start card; "initialize" will load runtime ucode */
C
Christoph Hellwig 已提交
2739
		iwl3945_nic_start(priv);
Z
Zhu Yi 已提交
2740

2741
		IWL_DEBUG_INFO(priv, DRV_NAME " is coming up\n");
Z
Zhu Yi 已提交
2742 2743 2744 2745 2746

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
2747
	__iwl3945_down(priv);
2748
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
2749 2750 2751

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
2752
	IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
Z
Zhu Yi 已提交
2753 2754 2755 2756 2757 2758 2759 2760 2761 2762
	return -EIO;
}


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

C
Christoph Hellwig 已提交
2763
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2764
{
2765 2766
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, init_alive_start.work);
Z
Zhu Yi 已提交
2767 2768 2769 2770 2771

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2772
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
2773 2774 2775
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
2776
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2777
{
2778 2779
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, alive_start.work);
Z
Zhu Yi 已提交
2780 2781 2782 2783 2784

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2785
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
2786 2787 2788
	mutex_unlock(&priv->mutex);
}

2789 2790 2791 2792 2793 2794
/*
 * 3945 cannot interrupt driver when hardware rf kill switch toggles;
 * driver must poll CSR_GP_CNTRL_REG register for change.  This register
 * *is* readable even when device has been SW_RESET into low power mode
 * (e.g. during RF KILL).
 */
2795 2796 2797 2798
static void iwl3945_rfkill_poll(struct work_struct *data)
{
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rfkill_poll.work);
2799 2800 2801
	bool old_rfkill = test_bit(STATUS_RF_KILL_HW, &priv->status);
	bool new_rfkill = !(iwl_read32(priv, CSR_GP_CNTRL)
			& CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW);
2802

2803 2804 2805 2806 2807
	if (new_rfkill != old_rfkill) {
		if (new_rfkill)
			set_bit(STATUS_RF_KILL_HW, &priv->status);
		else
			clear_bit(STATUS_RF_KILL_HW, &priv->status);
2808

2809 2810 2811 2812 2813
		wiphy_rfkill_set_hw_state(priv->hw->wiphy, new_rfkill);

		IWL_DEBUG_RF_KILL(priv, "RF_KILL bit toggled to %s.\n",
				new_rfkill ? "disable radio" : "enable radio");
	}
2814

2815 2816
	/* Keep this running, even if radio now enabled.  This will be
	 * cancelled in mac_start() if system decides to start again */
2817 2818 2819 2820 2821
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   round_jiffies_relative(2 * HZ));

}

Z
Zhu Yi 已提交
2822
#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)
C
Christoph Hellwig 已提交
2823
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
2824
{
2825 2826
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
2827
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
2828
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
2829
		.len = sizeof(struct iwl3945_scan_cmd),
J
Johannes Berg 已提交
2830
		.flags = CMD_SIZE_HUGE,
Z
Zhu Yi 已提交
2831 2832
	};
	int rc = 0;
C
Christoph Hellwig 已提交
2833
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
2834
	struct ieee80211_conf *conf = NULL;
J
Johannes Berg 已提交
2835
	u8 n_probes = 0;
2836
	enum ieee80211_band band;
J
Johannes Berg 已提交
2837
	bool is_active = false;
Z
Zhu Yi 已提交
2838 2839 2840 2841 2842

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

2843 2844
	cancel_delayed_work(&priv->scan_check);

2845
	if (!iwl_is_ready(priv)) {
2846
		IWL_WARN(priv, "request scan called when driver not ready.\n");
Z
Zhu Yi 已提交
2847 2848 2849
		goto done;
	}

T
Tomas Winkler 已提交
2850
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
2851 2852 2853 2854 2855 2856 2857
	 * 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)) {
2858 2859
		IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests  "
				"Ignoring second request.\n");
Z
Zhu Yi 已提交
2860 2861 2862 2863 2864
		rc = -EIO;
		goto done;
	}

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
2865
		IWL_DEBUG_SCAN(priv, "Aborting scan due to device shutdown\n");
Z
Zhu Yi 已提交
2866 2867 2868 2869
		goto done;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
2870 2871
		IWL_DEBUG_HC(priv,
			"Scan request while abort pending. Queuing.\n");
Z
Zhu Yi 已提交
2872 2873 2874
		goto done;
	}

2875
	if (iwl_is_rfkill(priv)) {
2876
		IWL_DEBUG_HC(priv, "Aborting scan due to RF Kill activation\n");
Z
Zhu Yi 已提交
2877 2878 2879 2880
		goto done;
	}

	if (!test_bit(STATUS_READY, &priv->status)) {
2881 2882
		IWL_DEBUG_HC(priv,
			"Scan request while uninitialized. Queuing.\n");
Z
Zhu Yi 已提交
2883 2884 2885 2886
		goto done;
	}

	if (!priv->scan_bands) {
2887
		IWL_DEBUG_HC(priv, "Aborting scan due to no requested bands\n");
Z
Zhu Yi 已提交
2888 2889 2890
		goto done;
	}

W
Winkler, Tomas 已提交
2891 2892
	if (!priv->scan) {
		priv->scan = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
2893
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
W
Winkler, Tomas 已提交
2894
		if (!priv->scan) {
Z
Zhu Yi 已提交
2895 2896 2897 2898
			rc = -ENOMEM;
			goto done;
		}
	}
W
Winkler, Tomas 已提交
2899
	scan = priv->scan;
C
Christoph Hellwig 已提交
2900
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
2901 2902 2903 2904

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

2905
	if (iwl_is_associated(priv)) {
Z
Zhu Yi 已提交
2906 2907 2908 2909 2910 2911
		u16 interval = 0;
		u32 extra;
		u32 suspend_time = 100;
		u32 scan_suspend_time = 100;
		unsigned long flags;

2912
		IWL_DEBUG_INFO(priv, "Scanning while associated...\n");
Z
Zhu Yi 已提交
2913 2914 2915 2916 2917 2918

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

		scan->suspend_time = 0;
2919
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933
		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);
2934
		IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n",
Z
Zhu Yi 已提交
2935 2936 2937
			       scan_suspend_time, interval);
	}

J
Johannes Berg 已提交
2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954
	if (priv->scan_request->n_ssids) {
		int i, p = 0;
		IWL_DEBUG_SCAN(priv, "Kicking off active scan\n");
		for (i = 0; i < priv->scan_request->n_ssids; i++) {
			/* always does wildcard anyway */
			if (!priv->scan_request->ssids[i].ssid_len)
				continue;
			scan->direct_scan[p].id = WLAN_EID_SSID;
			scan->direct_scan[p].len =
				priv->scan_request->ssids[i].ssid_len;
			memcpy(scan->direct_scan[p].ssid,
			       priv->scan_request->ssids[i].ssid,
			       priv->scan_request->ssids[i].ssid_len);
			n_probes++;
			p++;
		}
		is_active = true;
2955
	} else
J
Johannes Berg 已提交
2956
		IWL_DEBUG_SCAN(priv, "Kicking off passive scan.\n");
Z
Zhu Yi 已提交
2957 2958 2959 2960

	/* 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.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
2961
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
2962 2963 2964 2965
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

2966
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
2967 2968 2969
		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;
2970
		band = IEEE80211_BAND_2GHZ;
2971
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
2972
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
2973 2974 2975 2976 2977 2978
		/*
		 * If active scaning is requested but a certain channel
		 * is marked passive, we can do active scanning if we
		 * detect transmissions.
		 */
		scan->good_CRC_th = is_active ? IWL_GOOD_CRC_TH : 0;
2979
		band = IEEE80211_BAND_5GHZ;
2980
	} else {
2981
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
2982 2983 2984
		goto done;
	}

S
Samuel Ortiz 已提交
2985
	scan->tx_cmd.len = cpu_to_le16(
J
Johannes Berg 已提交
2986 2987 2988 2989 2990
			iwl_fill_probe_req(priv,
				(struct ieee80211_mgmt *)scan->data,
				priv->scan_request->ie,
				priv->scan_request->ie_len,
				IWL_MAX_SCAN_SIZE - sizeof(*scan)));
S
Samuel Ortiz 已提交
2991

Z
Zhu Yi 已提交
2992 2993 2994
	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

2995
	if (iwl_is_monitor_mode(priv))
Z
Zhu Yi 已提交
2996 2997
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

2998
	scan->channel_count =
J
Johannes Berg 已提交
2999
		iwl3945_get_channels_for_scan(priv, band, is_active, n_probes,
3000
			(void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);
Z
Zhu Yi 已提交
3001

3002
	if (scan->channel_count == 0) {
3003
		IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count);
3004 3005 3006
		goto done;
	}

Z
Zhu Yi 已提交
3007
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
3008
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
3009 3010 3011 3012
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
3013
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
3014 3015 3016 3017 3018 3019 3020 3021 3022 3023
	if (rc)
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
3024 3025 3026 3027 3028 3029 3030 3031
	/* 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);

3032
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
3033 3034 3035 3036
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
3037
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
3038
{
3039
	struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
Z
Zhu Yi 已提交
3040 3041 3042 3043 3044

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3045
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
3046 3047 3048
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
3049
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
3050
{
3051
	struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
Z
Zhu Yi 已提交
3052 3053 3054 3055

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

J
Johannes Berg 已提交
3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066
	if (test_and_clear_bit(STATUS_FW_ERROR, &priv->status)) {
		mutex_lock(&priv->mutex);
		priv->vif = NULL;
		priv->is_open = 0;
		mutex_unlock(&priv->mutex);
		iwl3945_down(priv);
		ieee80211_restart_hw(priv->hw);
	} else {
		iwl3945_down(priv);
		queue_work(priv->workqueue, &priv->up);
	}
Z
Zhu Yi 已提交
3067 3068
}

C
Christoph Hellwig 已提交
3069
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
3070
{
3071 3072
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rx_replenish);
Z
Zhu Yi 已提交
3073 3074 3075 3076 3077

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3078
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
3079 3080 3081
	mutex_unlock(&priv->mutex);
}

3082 3083
#define IWL_DELAY_NEXT_SCAN (HZ*2)

3084
void iwl3945_post_associate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3085 3086 3087 3088
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

3089
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
3090
		IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
3091 3092 3093 3094
		return;
	}


3095
	IWL_DEBUG_ASSOC(priv, "Associated as %d to: %pM\n",
3096
			priv->assoc_id, priv->active_rxon.bssid_addr);
Z
Zhu Yi 已提交
3097 3098 3099 3100

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

A
Abhijeet Kolekar 已提交
3101
	if (!priv->vif || !priv->is_open)
3102
		return;
A
Abhijeet Kolekar 已提交
3103

3104
	iwl_scan_cancel_timeout(priv, 200);
3105

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

3108
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3109
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3110

3111
	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
3112
	iwl_setup_rxon_timing(priv);
3113
	rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
3114 3115
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
3116
		IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3117 3118
			    "Attempting to continue.\n");

3119
	priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
Z
Zhu Yi 已提交
3120

3121
	priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
3122

3123
	IWL_DEBUG_ASSOC(priv, "assoc id %d beacon interval %d\n",
Z
Zhu Yi 已提交
3124 3125 3126
			priv->assoc_id, priv->beacon_int);

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3127
		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3128
	else
3129
		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3130

3131
	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3132
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
3133
			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3134
		else
3135
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3136

3137
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3138
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3139 3140 3141

	}

A
Abhijeet Kolekar 已提交
3142
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3143 3144

	switch (priv->iw_mode) {
3145
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
3146
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
3147 3148
		break;

3149
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
3150

3151
		priv->assoc_id = 1;
3152
		iwl_add_station(priv, priv->bssid, 0, CMD_SYNC, NULL);
Z
Zhu Yi 已提交
3153
		iwl3945_sync_sta(priv, IWL_STA_ID,
3154
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
3155 3156
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
3157 3158
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3159 3160 3161 3162

		break;

	default:
3163
		 IWL_ERR(priv, "%s Should not be called in %d mode\n",
3164
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
3165 3166 3167
		break;
	}

3168
	iwl_activate_qos(priv, 0);
3169

3170 3171
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
3172 3173
}

Z
Zhu Yi 已提交
3174 3175 3176 3177 3178 3179
/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

3180 3181
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
3182
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3183
{
3184
	struct iwl_priv *priv = hw->priv;
3185
	int ret;
Z
Zhu Yi 已提交
3186

3187
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3188 3189 3190 3191

	/* we should be verifying the device is ready to be opened */
	mutex_lock(&priv->mutex);

3192 3193 3194 3195 3196 3197
	/* 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) {
3198
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
3199 3200 3201 3202
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
3203

3204
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
3205 3206

	mutex_unlock(&priv->mutex);
3207

3208 3209 3210
	if (ret)
		goto out_release_irq;

3211
	IWL_DEBUG_INFO(priv, "Start UP work.\n");
3212

3213 3214 3215 3216 3217 3218 3219
	/* 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)) {
3220 3221 3222
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
3223 3224 3225 3226 3227
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

3228 3229 3230 3231
	/* ucode is running and will send rfkill notifications,
	 * no need to poll the killswitch state anymore */
	cancel_delayed_work(&priv->rfkill_poll);

J
Johannes Berg 已提交
3232 3233
	iwl_led_start(priv);

3234
	priv->is_open = 1;
3235
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3236
	return 0;
3237 3238

out_release_irq:
3239
	priv->is_open = 0;
3240
	IWL_DEBUG_MAC80211(priv, "leave - failed\n");
3241
	return ret;
Z
Zhu Yi 已提交
3242 3243
}

C
Christoph Hellwig 已提交
3244
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3245
{
3246
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3247

3248
	IWL_DEBUG_MAC80211(priv, "enter\n");
3249

3250
	if (!priv->is_open) {
3251
		IWL_DEBUG_MAC80211(priv, "leave - skip\n");
3252 3253 3254
		return;
	}

Z
Zhu Yi 已提交
3255
	priv->is_open = 0;
3256

3257
	if (iwl_is_ready_rf(priv)) {
3258 3259 3260
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
3261
		mutex_lock(&priv->mutex);
3262
		iwl_scan_cancel_timeout(priv, 100);
3263 3264 3265
		mutex_unlock(&priv->mutex);
	}

3266 3267 3268
	iwl3945_down(priv);

	flush_workqueue(priv->workqueue);
3269 3270 3271 3272

	/* start polling the killswitch state again */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   round_jiffies_relative(2 * HZ));
3273

3274
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3275 3276
}

3277
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
3278
{
3279
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3280

3281
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3282

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

3286
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
3287 3288
		dev_kfree_skb_any(skb);

3289
	IWL_DEBUG_MAC80211(priv, "leave\n");
3290
	return NETDEV_TX_OK;
Z
Zhu Yi 已提交
3291 3292
}

A
Abhijeet Kolekar 已提交
3293
void iwl3945_config_ap(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3294 3295 3296
{
	int rc = 0;

3297
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
3298 3299 3300
		return;

	/* The following should be done only at AP bring up */
3301
	if (!(iwl_is_associated(priv))) {
Z
Zhu Yi 已提交
3302 3303

		/* RXON - unassoc (to set timing command) */
3304
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3305
		iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3306 3307

		/* RXON Timing */
3308
		memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
3309
		iwl_setup_rxon_timing(priv);
3310 3311 3312
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
				      sizeof(priv->rxon_timing),
				      &priv->rxon_timing);
Z
Zhu Yi 已提交
3313
		if (rc)
3314
			IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3315 3316 3317
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
3318
		priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
3319
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3320
			priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3321 3322
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
3323
			priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3324 3325
				~RXON_FLG_SHORT_PREAMBLE_MSK;

3326
		if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3327 3328
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
3329
				priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3330 3331
					RXON_FLG_SHORT_SLOT_MSK;
			else
3332
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3333 3334
					~RXON_FLG_SHORT_SLOT_MSK;

3335
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3336
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3337 3338 3339
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
3340
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3341
		iwlcore_commit_rxon(priv);
3342
		iwl_add_station(priv, iwl_bcast_addr, 0, CMD_SYNC, NULL);
3343
	}
C
Christoph Hellwig 已提交
3344
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3345 3346 3347 3348 3349 3350

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

C
Christoph Hellwig 已提交
3351
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3352 3353 3354
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
Z
Zhu Yi 已提交
3355
{
3356
	struct iwl_priv *priv = hw->priv;
3357
	const u8 *addr;
3358 3359 3360
	int ret = 0;
	u8 sta_id = IWL_INVALID_STATION;
	u8 static_key;
Z
Zhu Yi 已提交
3361

3362
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3363

3364
	if (iwl3945_mod_params.sw_crypto) {
3365
		IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
Z
Zhu Yi 已提交
3366 3367 3368
		return -EOPNOTSUPP;
	}

3369
	addr = sta ? sta->addr : iwl_bcast_addr;
3370 3371 3372
	static_key = !iwl_is_associated(priv);

	if (!static_key) {
3373
		sta_id = iwl_find_station(priv, addr);
3374
		if (sta_id == IWL_INVALID_STATION) {
3375
			IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
3376 3377 3378
					    addr);
			return -EINVAL;
		}
Z
Zhu Yi 已提交
3379 3380 3381
	}

	mutex_lock(&priv->mutex);
3382
	iwl_scan_cancel_timeout(priv, 100);
3383
	mutex_unlock(&priv->mutex);
3384

Z
Zhu Yi 已提交
3385
	switch (cmd) {
3386 3387 3388 3389 3390 3391
	case SET_KEY:
		if (static_key)
			ret = iwl3945_set_static_key(priv, key);
		else
			ret = iwl3945_set_dynamic_key(priv, key, sta_id);
		IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
Z
Zhu Yi 已提交
3392 3393
		break;
	case DISABLE_KEY:
3394 3395 3396 3397 3398
		if (static_key)
			ret = iwl3945_remove_static_key(priv);
		else
			ret = iwl3945_clear_sta_key_info(priv, sta_id);
		IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
Z
Zhu Yi 已提交
3399 3400
		break;
	default:
3401
		ret = -EINVAL;
Z
Zhu Yi 已提交
3402 3403
	}

3404
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3405

3406
	return ret;
Z
Zhu Yi 已提交
3407 3408 3409 3410 3411 3412 3413 3414
}

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

S
Samuel Ortiz 已提交
3415
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
3416 3417 3418 3419 3420 3421 3422

/*
 * 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.
3423
 *
3424 3425 3426
 * The debug_level being managed using sysfs below is a per device debug
 * level that is used instead of the global debug level if it (the per
 * device debug level) is set.
Z
Zhu Yi 已提交
3427
 */
3428 3429
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
3430
{
3431 3432
	struct iwl_priv *priv = dev_get_drvdata(d);
	return sprintf(buf, "0x%08X\n", iwl_get_debug_level(priv));
Z
Zhu Yi 已提交
3433
}
3434 3435
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
3436 3437
				 const char *buf, size_t count)
{
3438
	struct iwl_priv *priv = dev_get_drvdata(d);
3439 3440
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
3441

3442 3443
	ret = strict_strtoul(buf, 0, &val);
	if (ret)
T
Tomas Winkler 已提交
3444
		IWL_INFO(priv, "%s is not in hex or decimal form.\n", buf);
3445
	else {
3446
		priv->debug_level = val;
3447 3448 3449 3450
		if (iwl_alloc_traffic_mem(priv))
			IWL_ERR(priv,
				"Not enough memory to generate traffic log\n");
	}
Z
Zhu Yi 已提交
3451 3452 3453
	return strnlen(buf, count);
}

3454 3455
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
3456

S
Samuel Ortiz 已提交
3457
#endif /* CONFIG_IWLWIFI_DEBUG */
Z
Zhu Yi 已提交
3458 3459 3460 3461

static ssize_t show_temperature(struct device *d,
				struct device_attribute *attr, char *buf)
{
3462
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3463

3464
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3465 3466
		return -EAGAIN;

C
Christoph Hellwig 已提交
3467
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
3468 3469 3470 3471 3472 3473 3474
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
3475
	struct iwl_priv *priv = dev_get_drvdata(d);
3476
	return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
Z
Zhu Yi 已提交
3477 3478 3479 3480 3481 3482
}

static ssize_t store_tx_power(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
3483
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3484 3485 3486 3487 3488
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
3489
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
3490
	else
C
Christoph Hellwig 已提交
3491
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
3492 3493 3494 3495 3496 3497 3498 3499 3500

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

3503
	return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
Z
Zhu Yi 已提交
3504 3505 3506 3507 3508 3509
}

static ssize_t store_flags(struct device *d,
			   struct device_attribute *attr,
			   const char *buf, size_t count)
{
3510
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3511 3512 3513
	u32 flags = simple_strtoul(buf, NULL, 0);

	mutex_lock(&priv->mutex);
3514
	if (le32_to_cpu(priv->staging_rxon.flags) != flags) {
Z
Zhu Yi 已提交
3515
		/* Cancel any currently running scans... */
3516
		if (iwl_scan_cancel_timeout(priv, 100))
3517
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
3518
		else {
3519
			IWL_DEBUG_INFO(priv, "Committing rxon.flags = 0x%04X\n",
Z
Zhu Yi 已提交
3520
				       flags);
3521
			priv->staging_rxon.flags = cpu_to_le32(flags);
A
Abhijeet Kolekar 已提交
3522
			iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534
		}
	}
	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)
{
3535
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3536 3537

	return sprintf(buf, "0x%04X\n",
3538
		le32_to_cpu(priv->active_rxon.filter_flags));
Z
Zhu Yi 已提交
3539 3540 3541 3542 3543 3544
}

static ssize_t store_filter_flags(struct device *d,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
{
3545
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3546 3547 3548
	u32 filter_flags = simple_strtoul(buf, NULL, 0);

	mutex_lock(&priv->mutex);
3549
	if (le32_to_cpu(priv->staging_rxon.filter_flags) != filter_flags) {
Z
Zhu Yi 已提交
3550
		/* Cancel any currently running scans... */
3551
		if (iwl_scan_cancel_timeout(priv, 100))
3552
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
3553
		else {
3554
			IWL_DEBUG_INFO(priv, "Committing rxon.filter_flags = "
Z
Zhu Yi 已提交
3555
				       "0x%04X\n", filter_flags);
3556
			priv->staging_rxon.filter_flags =
Z
Zhu Yi 已提交
3557
				cpu_to_le32(filter_flags);
A
Abhijeet Kolekar 已提交
3558
			iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3559 3560 3561 3562 3563 3564 3565 3566 3567 3568
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

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

3569
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3570 3571 3572 3573

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
3574
	struct iwl_priv *priv = dev_get_drvdata(d);
3575
	struct iwl_spectrum_notification measure_report;
Z
Zhu Yi 已提交
3576
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
3577
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606
	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)
{
3607
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3608
	struct ieee80211_measurement_params params = {
3609
		.channel = le16_to_cpu(priv->active_rxon.channel),
Z
Zhu Yi 已提交
3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630
		.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);
	}

3631
	IWL_DEBUG_INFO(priv, "Invoking measurement of type %d on "
Z
Zhu Yi 已提交
3632
		       "channel %d (for '%s')\n", type, params.channel, buf);
C
Christoph Hellwig 已提交
3633
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
3634 3635 3636 3637 3638 3639

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
3640
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
3641 3642 3643 3644 3645

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
3646
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657

	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)
{
3658
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3659 3660 3661 3662 3663 3664
	return sprintf(buf, "%d", priv->retry_rate);
}

static DEVICE_ATTR(retry_rate, S_IWUSR | S_IRUSR, show_retry_rate,
		   store_retry_rate);

3665

Z
Zhu Yi 已提交
3666 3667 3668
static ssize_t show_channels(struct device *d,
			     struct device_attribute *attr, char *buf)
{
3669 3670
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
3671 3672 3673 3674 3675 3676 3677
}

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
3678
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
3679
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
3680
	u32 len = 0, ofs = 0;
3681
	u8 *data = (u8 *)&priv->statistics_39;
Z
Zhu Yi 已提交
3682 3683
	int rc = 0;

3684
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3685 3686 3687
		return -EAGAIN;

	mutex_lock(&priv->mutex);
3688
	rc = iwl_send_statistics_request(priv, CMD_SYNC, false);
Z
Zhu Yi 已提交
3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715
	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)
{
3716
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3717

3718
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3719 3720
		return -EAGAIN;

3721
	return sprintf(buf, "%d\n", iwl3945_mod_params.antenna);
Z
Zhu Yi 已提交
3722 3723 3724 3725 3726 3727
}

static ssize_t store_antenna(struct device *d,
			     struct device_attribute *attr,
			     const char *buf, size_t count)
{
3728
	struct iwl_priv *priv __maybe_unused = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3729 3730 3731 3732 3733 3734
	int ant;

	if (count == 0)
		return 0;

	if (sscanf(buf, "%1i", &ant) != 1) {
3735
		IWL_DEBUG_INFO(priv, "not in hex or decimal form.\n");
Z
Zhu Yi 已提交
3736 3737 3738 3739
		return count;
	}

	if ((ant >= 0) && (ant <= 2)) {
3740
		IWL_DEBUG_INFO(priv, "Setting antenna select to %d.\n", ant);
3741
		iwl3945_mod_params.antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
3742
	} else
3743
		IWL_DEBUG_INFO(priv, "Bad antenna select value %d.\n", ant);
Z
Zhu Yi 已提交
3744 3745 3746 3747 3748 3749 3750 3751 3752 3753


	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)
{
3754
	struct iwl_priv *priv = dev_get_drvdata(d);
3755
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3756 3757 3758 3759 3760 3761 3762 3763 3764 3765
		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)
{
3766
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3767 3768 3769
	char *p = (char *)buf;

	if (p[0] == '1')
3770
		iwl3945_dump_nic_error_log(priv);
Z
Zhu Yi 已提交
3771 3772 3773 3774 3775 3776 3777 3778

	return strnlen(buf, count);
}

static DEVICE_ATTR(dump_errors, S_IWUSR, NULL, dump_error_log);

/*****************************************************************************
 *
T
Tomas Winkler 已提交
3779
 * driver setup and tear down
Z
Zhu Yi 已提交
3780 3781 3782
 *
 *****************************************************************************/

3783
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3784
{
3785
	priv->workqueue = create_singlethread_workqueue(DRV_NAME);
Z
Zhu Yi 已提交
3786 3787 3788

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
3789 3790 3791 3792 3793 3794
	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->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);
3795
	INIT_DELAYED_WORK(&priv->rfkill_poll, iwl3945_rfkill_poll);
S
Samuel Ortiz 已提交
3796 3797 3798 3799
	INIT_WORK(&priv->scan_completed, iwl_bg_scan_completed);
	INIT_WORK(&priv->request_scan, iwl3945_bg_request_scan);
	INIT_WORK(&priv->abort_scan, iwl_bg_abort_scan);
	INIT_DELAYED_WORK(&priv->scan_check, iwl_bg_scan_check);
C
Christoph Hellwig 已提交
3800 3801

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
3802 3803

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

3807
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3808
{
C
Christoph Hellwig 已提交
3809
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
3810

3811
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
3812 3813 3814 3815 3816
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
3817
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
3818 3819 3820 3821 3822
	&dev_attr_antenna.attr,
	&dev_attr_channels.attr,
	&dev_attr_dump_errors.attr,
	&dev_attr_flags.attr,
	&dev_attr_filter_flags.attr,
3823
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3824 3825 3826 3827 3828 3829 3830
	&dev_attr_measurement.attr,
#endif
	&dev_attr_retry_rate.attr,
	&dev_attr_statistics.attr,
	&dev_attr_status.attr,
	&dev_attr_temperature.attr,
	&dev_attr_tx_power.attr,
S
Samuel Ortiz 已提交
3831
#ifdef CONFIG_IWLWIFI_DEBUG
3832 3833
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
3834 3835 3836
	NULL
};

C
Christoph Hellwig 已提交
3837
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
3838
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
3839
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
3840 3841
};

C
Christoph Hellwig 已提交
3842 3843 3844 3845
static struct ieee80211_ops iwl3945_hw_ops = {
	.tx = iwl3945_mac_tx,
	.start = iwl3945_mac_start,
	.stop = iwl3945_mac_stop,
3846
	.add_interface = iwl_mac_add_interface,
3847
	.remove_interface = iwl_mac_remove_interface,
3848
	.config = iwl_mac_config,
3849
	.configure_filter = iwl_configure_filter,
C
Christoph Hellwig 已提交
3850
	.set_key = iwl3945_mac_set_key,
3851
	.get_tx_stats = iwl_mac_get_tx_stats,
A
Abhijeet Kolekar 已提交
3852
	.conf_tx = iwl_mac_conf_tx,
3853
	.reset_tsf = iwl_mac_reset_tsf,
3854
	.bss_info_changed = iwl_bss_info_changed,
3855
	.hw_scan = iwl_mac_hw_scan
Z
Zhu Yi 已提交
3856 3857
};

3858
static int iwl3945_init_drv(struct iwl_priv *priv)
3859 3860
{
	int ret;
3861
	struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873

	priv->retry_rate = 1;
	priv->ibss_beacon = NULL;

	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 */
3874
	iwl_clear_stations_table(priv);
3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887

	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;
3888
	priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
3889

3890 3891 3892 3893 3894 3895 3896
	if (eeprom->version < EEPROM_3945_EEPROM_VERSION) {
		IWL_WARN(priv, "Unsupported EEPROM version: 0x%04X\n",
			 eeprom->version);
		ret = -EINVAL;
		goto err;
	}
	ret = iwl_init_channel_map(priv);
3897 3898 3899 3900 3901
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

3902 3903 3904 3905 3906 3907
	/* Set up txpower settings in driver for all channels */
	if (iwl3945_txpower_set_from_eeprom(priv)) {
		ret = -EIO;
		goto err_free_channel_map;
	}

3908
	ret = iwlcore_init_geos(priv);
3909 3910 3911 3912
	if (ret) {
		IWL_ERR(priv, "initializing geos failed: %d\n", ret);
		goto err_free_channel_map;
	}
3913 3914
	iwl3945_init_hw_rates(priv, priv->ieee_rates);

3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932
	return 0;

err_free_channel_map:
	iwl_free_channel_map(priv);
err:
	return ret;
}

static int iwl3945_setup_mac(struct iwl_priv *priv)
{
	int ret;
	struct ieee80211_hw *hw = priv->hw;

	hw->rate_control_algorithm = "iwl-3945-rs";
	hw->sta_data_size = sizeof(struct iwl3945_sta_priv);

	/* Tell mac80211 our characteristics */
	hw->flags = IEEE80211_HW_SIGNAL_DBM |
M
Mohamed Abbas 已提交
3933
		    IEEE80211_HW_NOISE_DBM |
R
Reinette Chatre 已提交
3934 3935 3936 3937 3938
		    IEEE80211_HW_SPECTRUM_MGMT;

	if (!priv->cfg->broken_powersave)
		hw->flags |= IEEE80211_HW_SUPPORTS_PS |
			     IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
3939 3940 3941 3942 3943

	hw->wiphy->interface_modes =
		BIT(NL80211_IFTYPE_STATION) |
		BIT(NL80211_IFTYPE_ADHOC);

J
Johannes Berg 已提交
3944 3945
	hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY |
			    WIPHY_FLAG_DISABLE_BEACON_HINTS;
3946

J
Johannes Berg 已提交
3947 3948 3949
	hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX_3945;
	/* we create the 802.11 header and a zero-length SSID element */
	hw->wiphy->max_scan_ie_len = IWL_MAX_PROBE_REQUEST - 24 - 2;
3950

3951 3952 3953
	/* Default value; 4 EDCA QOS priorities */
	hw->queues = 4;

3954 3955 3956
	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
3957

3958 3959 3960
	if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&priv->bands[IEEE80211_BAND_5GHZ];
3961

3962 3963 3964 3965 3966 3967
	ret = ieee80211_register_hw(priv->hw);
	if (ret) {
		IWL_ERR(priv, "Failed to register hw (error %d)\n", ret);
		return ret;
	}
	priv->mac80211_registered = 1;
3968

3969
	return 0;
3970 3971
}

C
Christoph Hellwig 已提交
3972
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
3973 3974
{
	int err = 0;
3975
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
3976
	struct ieee80211_hw *hw;
3977
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
3978
	struct iwl3945_eeprom *eeprom;
3979
	unsigned long flags;
Z
Zhu Yi 已提交
3980

3981 3982 3983 3984
	/***********************
	 * 1. Allocating HW data
	 * ********************/

Z
Zhu Yi 已提交
3985 3986
	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
3987
	hw = iwl_alloc_all(cfg, &iwl3945_hw_ops);
Z
Zhu Yi 已提交
3988
	if (hw == NULL) {
3989
		printk(KERN_ERR DRV_NAME "Can not allocate network device\n");
Z
Zhu Yi 已提交
3990 3991 3992 3993
		err = -ENOMEM;
		goto out;
	}
	priv = hw->priv;
3994
	SET_IEEE80211_DEV(hw, &pdev->dev);
3995

3996 3997 3998 3999
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
4000
	if (iwl3945_mod_params.disable_hw_scan) {
4001
		IWL_DEBUG_INFO(priv, "Disabling hw_scan\n");
4002 4003 4004
		iwl3945_hw_ops.hw_scan = NULL;
	}

4005

4006
	IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
4007 4008
	priv->cfg = cfg;
	priv->pci_dev = pdev;
4009
	priv->inta_mask = CSR_INI_SET_MASK;
4010

S
Samuel Ortiz 已提交
4011
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
4012 4013
	atomic_set(&priv->restrict_refcnt, 0);
#endif
4014 4015
	if (iwl_alloc_traffic_mem(priv))
		IWL_ERR(priv, "Not enough memory to generate traffic log\n");
Z
Zhu Yi 已提交
4016

4017 4018 4019
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
4020 4021 4022 4023 4024 4025 4026
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

4027
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
4028
	if (!err)
4029
		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
4030
	if (err) {
T
Tomas Winkler 已提交
4031
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
4032 4033 4034 4035 4036 4037 4038
		goto out_pci_disable_device;
	}

	pci_set_drvdata(pdev, priv);
	err = pci_request_regions(pdev, DRV_NAME);
	if (err)
		goto out_pci_disable_device;
4039

4040 4041 4042
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
4043 4044 4045 4046 4047 4048
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

4049
	IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
Z
Zhu Yi 已提交
4050
			(unsigned long long) pci_resource_len(pdev, 0));
4051
	IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
Z
Zhu Yi 已提交
4052

4053 4054 4055
	/* 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 已提交
4056

4057
	/* these spin locks will be used in apm_ops.init and EEPROM access
M
Mohamed Abbas 已提交
4058 4059 4060
	 * we should init now
	 */
	spin_lock_init(&priv->reg_lock);
4061
	spin_lock_init(&priv->lock);
M
Mohamed Abbas 已提交
4062

4063 4064 4065
	/***********************
	 * 4. Read EEPROM
	 * ********************/
4066

4067
	/* Read the EEPROM */
4068
	err = iwl_eeprom_init(priv);
4069
	if (err) {
4070
		IWL_ERR(priv, "Unable to init EEPROM\n");
4071
		goto out_iounmap;
4072 4073
	}
	/* MAC Address location in EEPROM same for 3945/4965 */
4074 4075
	eeprom = (struct iwl3945_eeprom *)priv->eeprom;
	memcpy(priv->mac_addr, eeprom->mac_address, ETH_ALEN);
4076
	IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->mac_addr);
4077
	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
Z
Zhu Yi 已提交
4078

4079 4080 4081
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
4082
	/* Device-specific setup */
4083
	if (iwl3945_hw_set_hw_params(priv)) {
4084
		IWL_ERR(priv, "failed to set hw settings\n");
4085
		goto out_eeprom_free;
Z
Zhu Yi 已提交
4086 4087
	}

4088 4089 4090 4091
	/***********************
	 * 6. Setup priv
	 * ********************/

4092
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
4093
	if (err) {
4094
		IWL_ERR(priv, "initializing driver failed\n");
4095
		goto out_unset_hw_params;
Z
Zhu Yi 已提交
4096 4097
	}

T
Tomas Winkler 已提交
4098 4099
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
4100 4101

	/***********************
4102
	 * 7. Setup Services
4103 4104 4105
	 * ********************/

	spin_lock_irqsave(&priv->lock, flags);
4106
	iwl_disable_interrupts(priv);
4107 4108
	spin_unlock_irqrestore(&priv->lock, flags);

4109 4110
	pci_enable_msi(priv->pci_dev);

M
Mohamed Abbas 已提交
4111 4112
	err = request_irq(priv->pci_dev->irq, priv->cfg->ops->lib->isr,
			  IRQF_SHARED, DRV_NAME, priv);
4113 4114 4115 4116 4117
	if (err) {
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

4118
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
4119
	if (err) {
4120
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
4121
		goto out_release_irq;
4122 4123
	}

4124 4125
	iwl_set_rxon_channel(priv,
			     &priv->bands[IEEE80211_BAND_2GHZ].channels[5]);
4126 4127
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);
B
Ben Cahill 已提交
4128
	iwl_power_initialize(priv);
4129 4130

	/*********************************
4131
	 * 8. Setup and Register mac80211
4132 4133
	 * *******************************/

4134
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
4135

4136 4137 4138
	err = iwl3945_setup_mac(priv);
	if (err)
		goto  out_remove_sysfs;
4139

A
Abhijeet Kolekar 已提交
4140 4141 4142 4143
	err = iwl_dbgfs_register(priv, DRV_NAME);
	if (err)
		IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);

4144 4145 4146 4147
	/* Start monitoring the killswitch */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   2 * HZ);

Z
Zhu Yi 已提交
4148 4149
	return 0;

4150
 out_remove_sysfs:
4151 4152
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
4153
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
4154
 out_release_irq:
4155 4156 4157
	free_irq(priv->pci_dev->irq, priv);
 out_disable_msi:
	pci_disable_msi(priv->pci_dev);
4158 4159 4160 4161 4162 4163
	iwlcore_free_geos(priv);
	iwl_free_channel_map(priv);
 out_unset_hw_params:
	iwl3945_unset_hw_params(priv);
 out_eeprom_free:
	iwl_eeprom_free(priv);
Z
Zhu Yi 已提交
4164 4165 4166 4167 4168 4169
 out_iounmap:
	pci_iounmap(pdev, priv->hw_base);
 out_pci_release_regions:
	pci_release_regions(pdev);
 out_pci_disable_device:
	pci_set_drvdata(pdev, NULL);
4170
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
4171
 out_ieee80211_free_hw:
4172
	iwl_free_traffic_mem(priv);
4173
	ieee80211_free_hw(priv->hw);
Z
Zhu Yi 已提交
4174 4175 4176 4177
 out:
	return err;
}

4178
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
4179
{
4180
	struct iwl_priv *priv = pci_get_drvdata(pdev);
4181
	unsigned long flags;
Z
Zhu Yi 已提交
4182 4183 4184 4185

	if (!priv)
		return;

4186
	IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
Z
Zhu Yi 已提交
4187

A
Abhijeet Kolekar 已提交
4188 4189
	iwl_dbgfs_unregister(priv);

Z
Zhu Yi 已提交
4190
	set_bit(STATUS_EXIT_PENDING, &priv->status);
4191

4192 4193 4194 4195 4196 4197
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
4198

4199 4200 4201 4202 4203 4204 4205 4206 4207
	/*
	 * Make sure device is reset to low power before unloading driver.
	 * This may be redundant with iwl_down(), but there are paths to
	 * run iwl_down() without calling apm_ops.stop(), and there are
	 * paths to avoid running iwl_down() at all before leaving driver.
	 * This (inexpensive) call *makes sure* device is reset.
	 */
	priv->cfg->ops->lib->apm_ops.stop(priv);

4208 4209 4210 4211
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
4212
	iwl_disable_interrupts(priv);
4213 4214 4215 4216
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

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

4219
	cancel_delayed_work_sync(&priv->rfkill_poll);
4220

C
Christoph Hellwig 已提交
4221
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
4222 4223

	if (priv->rxq.bd)
R
Reinette Chatre 已提交
4224
		iwl3945_rx_queue_free(priv, &priv->rxq);
C
Christoph Hellwig 已提交
4225
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
4226

4227
	iwl3945_unset_hw_params(priv);
4228
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
4229

4230 4231 4232
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
4233
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
4234 4235 4236 4237
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
4238
	iwl_free_traffic_mem(priv);
Z
Zhu Yi 已提交
4239

4240 4241 4242
	free_irq(pdev->irq, priv);
	pci_disable_msi(pdev);

Z
Zhu Yi 已提交
4243 4244 4245 4246 4247
	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

4248
	iwl_free_channel_map(priv);
4249
	iwlcore_free_geos(priv);
W
Winkler, Tomas 已提交
4250
	kfree(priv->scan);
Z
Zhu Yi 已提交
4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}


/*****************************************************************************
 *
 * driver and module entry point
 *
 *****************************************************************************/

C
Christoph Hellwig 已提交
4264
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
4265
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
4266 4267 4268
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
4269
#ifdef CONFIG_PM
4270 4271
	.suspend = iwl_pci_suspend,
	.resume = iwl_pci_resume,
Z
Zhu Yi 已提交
4272 4273 4274
#endif
};

C
Christoph Hellwig 已提交
4275
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
4276 4277 4278 4279 4280
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
4281 4282 4283

	ret = iwl3945_rate_control_register();
	if (ret) {
4284 4285
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
4286 4287 4288
		return ret;
	}

C
Christoph Hellwig 已提交
4289
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
4290
	if (ret) {
4291
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
4292
		goto error_register;
Z
Zhu Yi 已提交
4293 4294 4295
	}

	return ret;
4296 4297 4298 4299

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
4300 4301
}

C
Christoph Hellwig 已提交
4302
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
4303
{
C
Christoph Hellwig 已提交
4304
	pci_unregister_driver(&iwl3945_driver);
4305
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
4306 4307
}

4308
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
4309

4310
module_param_named(antenna, iwl3945_mod_params.antenna, int, S_IRUGO);
Z
Zhu Yi 已提交
4311
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
4312
module_param_named(swcrypto, iwl3945_mod_params.sw_crypto, int, S_IRUGO);
4313 4314
MODULE_PARM_DESC(swcrypto,
		 "using software crypto (default 1 [software])\n");
4315
#ifdef CONFIG_IWLWIFI_DEBUG
4316
module_param_named(debug, iwl_debug_level, uint, S_IRUGO | S_IWUSR);
Z
Zhu Yi 已提交
4317
MODULE_PARM_DESC(debug, "debug output mask");
4318
#endif
4319 4320
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan,
		   int, S_IRUGO);
Z
Zhu Yi 已提交
4321
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");
4322
module_param_named(fw_restart3945, iwl3945_mod_params.restart_fw, int, S_IRUGO);
4323 4324
MODULE_PARM_DESC(fw_restart3945, "restart firmware in case of error");

C
Christoph Hellwig 已提交
4325 4326
module_exit(iwl3945_exit);
module_init(iwl3945_init);