iwl3945-base.c 121.6 KB
Newer Older
Z
Zhu Yi 已提交
1 2
/******************************************************************************
 *
3
 * Copyright(c) 2003 - 2010 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
#include "iwl-3945.h"
K
Kolekar, Abhijeet 已提交
56
#include "iwl-core.h"
57
#include "iwl-helpers.h"
58
#include "iwl-dev.h"
59
#include "iwl-spectrum.h"
Z
Zhu Yi 已提交
60 61 62 63 64 65 66 67

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

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

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

74 75 76 77 78 79
/*
 * add "s" to indicate spectrum measurement included.
 * we add it here to be consistent with previous releases in which
 * this was configurable.
 */
#define DRV_VERSION  IWLWIFI_VERSION VD "s"
80
#define DRV_COPYRIGHT	"Copyright(c) 2003-2010 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->_3945.shared_virt)
355 356
		dma_free_coherent(&priv->pci_dev->dev,
				  sizeof(struct iwl3945_shared),
357 358
				  priv->_3945.shared_virt,
				  priv->_3945.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
	unsigned long flags;

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

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

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

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

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

	spin_unlock_irqrestore(&priv->lock, flags);

509
	hdr_len = ieee80211_hdrlen(fc);
510 511

	/* Find (or create) index into station table for destination station */
512 513 514 515
	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 已提交
516
	if (sta_id == IWL_INVALID_STATION) {
517
		IWL_DEBUG_DROP(priv, "Dropping - INVALID STATION: %pM\n",
J
Johannes Berg 已提交
518
			       hdr->addr1);
Z
Zhu Yi 已提交
519 520 521
		goto drop;
	}

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

524 525
	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
526
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
527 528
		if (unlikely(tid >= MAX_TID_COUNT))
			goto drop;
529
		seq_number = priv->stations[sta_id].tid[tid].seq_number &
Z
Zhu Yi 已提交
530 531 532
				IEEE80211_SCTL_SEQ;
		hdr->seq_ctrl = cpu_to_le16(seq_number) |
			(hdr->seq_ctrl &
533
				cpu_to_le16(IEEE80211_SCTL_FRAG));
Z
Zhu Yi 已提交
534 535
		seq_number += 0x10;
	}
536 537

	/* Descriptor for chosen Tx queue */
538
	txq = &priv->txq[txq_id];
Z
Zhu Yi 已提交
539 540
	q = &txq->q;

Z
Zhu Yi 已提交
541 542 543
	if ((iwl_queue_space(q) < q->high_mark))
		goto drop;

Z
Zhu Yi 已提交
544 545
	spin_lock_irqsave(&priv->lock, flags);

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

548
	/* Set up driver data for this TFD */
W
Winkler, Tomas 已提交
549
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl_tx_info));
550
	txq->txb[q->write_ptr].skb[0] = skb;
551 552

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

	/*
	 * 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 已提交
565 566
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
567
				INDEX_TO_SEQ(q->write_ptr)));
568 569

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

R
Reinette Chatre 已提交
572 573 574 575 576 577 578 579 580 581 582 583

	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 已提交
584
	tx_cmd->len = cpu_to_le16(len);
R
Reinette Chatre 已提交
585

586
	iwl_dbg_log_tx_data_frame(priv, len, hdr);
587
	iwl_update_stats(priv, true, fc, len);
A
Abhijeet Kolekar 已提交
588 589
	tx_cmd->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
	tx_cmd->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;
R
Reinette Chatre 已提交
590 591 592 593

	if (!ieee80211_has_morefrags(hdr->frame_control)) {
		txq->need_update = 1;
		if (qc)
594
			priv->stations[sta_id].tid[tid].seq_number = seq_number;
R
Reinette Chatre 已提交
595 596 597 598 599 600 601
	} 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 已提交
602 603 604
	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 已提交
605 606
			   ieee80211_hdrlen(fc));

607 608 609 610 611 612 613 614 615
	/*
	 * 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.
	 */
616
	len = sizeof(struct iwl3945_tx_cmd) +
617
			sizeof(struct iwl_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
618 619 620 621 622 623 624 625 626

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

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

627 628
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
R
Reinette Chatre 已提交
629 630 631 632
	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 已提交
633 634
	pci_unmap_addr_set(out_meta, mapping, txcmd_phys);
	pci_unmap_len_set(out_meta, len, len);
Z
Zhu Yi 已提交
635

636 637
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
638 639
	priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
						   txcmd_phys, len, 1, 0);
Z
Zhu Yi 已提交
640 641


642 643
	/* 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 已提交
644 645 646 647
	len = skb->len - hdr_len;
	if (len) {
		phys_addr = pci_map_single(priv->pci_dev, skb->data + hdr_len,
					   len, PCI_DMA_TODEVICE);
648 649 650
		priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
							   phys_addr, len,
							   0, U32_PAD(len));
Z
Zhu Yi 已提交
651 652 653
	}


654
	/* Tell device the write index *just past* this latest filled TFD */
T
Tomas Winkler 已提交
655
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
656
	iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
657 658
	spin_unlock_irqrestore(&priv->lock, flags);

659
	if ((iwl_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
660 661 662 663
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
664
			iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
665 666 667
			spin_unlock_irqrestore(&priv->lock, flags);
		}

668
		iwl_stop_queue(priv, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
	}

	return 0;

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

#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 已提交
690
static u32 iwl3945_usecs_to_beacons(u32 usec, u32 beacon_interval)
Z
Zhu Yi 已提交
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
{
	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 已提交
709
static __le32 iwl3945_add_beacon_time(u32 base, u32 addon, u32 beacon_interval)
Z
Zhu Yi 已提交
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
{
	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);
}

728
static int iwl3945_get_measurement(struct iwl_priv *priv,
Z
Zhu Yi 已提交
729 730 731
			       struct ieee80211_measurement_params *params,
			       u8 type)
{
732
	struct iwl_spectrum_cmd spectrum;
Z
Zhu Yi 已提交
733
	struct iwl_rx_packet *pkt;
734
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
735 736
		.id = REPLY_SPECTRUM_MEASUREMENT_CMD,
		.data = (void *)&spectrum,
J
Johannes Berg 已提交
737
		.flags = CMD_WANT_SKB,
Z
Zhu Yi 已提交
738 739 740 741 742 743
	};
	u32 add_time = le64_to_cpu(params->start_time);
	int rc;
	int spectrum_resp_status;
	int duration = le16_to_cpu(params->duration);

744
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
745
		add_time =
C
Christoph Hellwig 已提交
746
		    iwl3945_usecs_to_beacons(
747
			le64_to_cpu(params->start_time) - priv->_3945.last_tsf,
Z
Zhu Yi 已提交
748 749 750 751 752 753 754 755 756 757 758
			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));

759
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
760
		spectrum.start_time =
761
		    iwl3945_add_beacon_time(priv->_3945.last_beacon_time,
Z
Zhu Yi 已提交
762 763 764 765 766 767 768 769
				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;
770
	if (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK)
Z
Zhu Yi 已提交
771 772 773
		spectrum.flags |= RXON_FLG_BAND_24G_MSK |
		    RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK;

774
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
775 776 777
	if (rc)
		return rc;

Z
Zhu Yi 已提交
778 779
	pkt = (struct iwl_rx_packet *)cmd.reply_page;
	if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
780
		IWL_ERR(priv, "Bad return from REPLY_RX_ON_ASSOC command\n");
Z
Zhu Yi 已提交
781 782 783
		rc = -EIO;
	}

Z
Zhu Yi 已提交
784
	spectrum_resp_status = le16_to_cpu(pkt->u.spectrum.status);
Z
Zhu Yi 已提交
785 786
	switch (spectrum_resp_status) {
	case 0:		/* Command will be handled */
Z
Zhu Yi 已提交
787
		if (pkt->u.spectrum.id != 0xff) {
788
			IWL_DEBUG_INFO(priv, "Replaced existing measurement: %d\n",
Z
Zhu Yi 已提交
789
						pkt->u.spectrum.id);
Z
Zhu Yi 已提交
790 791 792 793 794 795 796 797 798 799 800
			priv->measurement_status &= ~MEASUREMENT_READY;
		}
		priv->measurement_status |= MEASUREMENT_ACTIVE;
		rc = 0;
		break;

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

801
	iwl_free_pages(priv, cmd.reply_page);
Z
Zhu Yi 已提交
802 803 804 805

	return rc;
}

806
static void iwl3945_rx_reply_alive(struct iwl_priv *priv,
807
			       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
808
{
Z
Zhu Yi 已提交
809
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
810
	struct iwl_alive_resp *palive;
Z
Zhu Yi 已提交
811 812 813 814
	struct delayed_work *pwork;

	palive = &pkt->u.alive_frame;

815
	IWL_DEBUG_INFO(priv, "Alive ucode status 0x%08X revision "
Z
Zhu Yi 已提交
816 817 818 819 820
		       "0x%01X 0x%01X\n",
		       palive->is_valid, palive->ver_type,
		       palive->ver_subtype);

	if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
821
		IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
822 823
		memcpy(&priv->card_alive_init, &pkt->u.alive_frame,
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
824 825
		pwork = &priv->init_alive_start;
	} else {
826
		IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
827
		memcpy(&priv->card_alive, &pkt->u.alive_frame,
828
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
829
		pwork = &priv->alive_start;
C
Christoph Hellwig 已提交
830
		iwl3945_disable_events(priv);
Z
Zhu Yi 已提交
831 832 833 834 835 836 837 838
	}

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

842
static void iwl3945_rx_reply_add_sta(struct iwl_priv *priv,
843
				 struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
844
{
845
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
846
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
847
#endif
Z
Zhu Yi 已提交
848

849
	IWL_DEBUG_RX(priv, "Received REPLY_ADD_STA: 0x%02X\n", pkt->u.status);
Z
Zhu Yi 已提交
850 851 852
	return;
}

C
Christoph Hellwig 已提交
853
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
854
{
855 856
	struct iwl_priv *priv =
		container_of(work, struct iwl_priv, beacon_update);
Z
Zhu Yi 已提交
857 858 859
	struct sk_buff *beacon;

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

	if (!beacon) {
863
		IWL_ERR(priv, "update beacon failed\n");
Z
Zhu Yi 已提交
864 865 866 867 868 869 870 871 872 873 874
		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 已提交
875
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
876 877
}

878
static void iwl3945_rx_beacon_notif(struct iwl_priv *priv,
879
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
880
{
S
Samuel Ortiz 已提交
881
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
882
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
C
Christoph Hellwig 已提交
883
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
884 885
	u8 rate = beacon->beacon_notify_hdr.rate;

886
	IWL_DEBUG_RX(priv, "beacon status %x retries %d iss %d "
Z
Zhu Yi 已提交
887 888 889 890 891 892 893 894
		"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

895
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
896 897 898 899 900 901
	    (!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 */
902
static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
903
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
904
{
Z
Zhu Yi 已提交
905
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
Z
Zhu Yi 已提交
906 907 908
	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
	unsigned long status = priv->status;

909
	IWL_WARN(priv, "Card state received: HW:%s SW:%s\n",
Z
Zhu Yi 已提交
910 911 912
			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
			  (flags & SW_CARD_DISABLED) ? "Kill" : "On");

913
	iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
914 915 916 917 918 919 920 921
		    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);


922
	iwl_scan_cancel(priv);
Z
Zhu Yi 已提交
923 924

	if ((test_bit(STATUS_RF_KILL_HW, &status) !=
J
Johannes Berg 已提交
925 926 927
	     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 已提交
928 929 930 931 932
	else
		wake_up_interruptible(&priv->wait_command_queue);
}

/**
C
Christoph Hellwig 已提交
933
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
934 935 936 937 938 939 940
 *
 * 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.
 */
941
static void iwl3945_setup_rx_handlers(struct iwl_priv *priv)
Z
Zhu Yi 已提交
942
{
C
Christoph Hellwig 已提交
943 944
	priv->rx_handlers[REPLY_ALIVE] = iwl3945_rx_reply_alive;
	priv->rx_handlers[REPLY_ADD_STA] = iwl3945_rx_reply_add_sta;
945
	priv->rx_handlers[REPLY_ERROR] = iwl_rx_reply_error;
946
	priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl_rx_csa;
947 948
	priv->rx_handlers[SPECTRUM_MEASURE_NOTIFICATION] =
			iwl_rx_spectrum_measure_notif;
A
Abhijeet Kolekar 已提交
949
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
950
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
A
Abhijeet Kolekar 已提交
951
	    iwl_rx_pm_debug_statistics_notif;
C
Christoph Hellwig 已提交
952
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
953

954 955 956 957
	/*
	 * 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 已提交
958
	 */
C
Christoph Hellwig 已提交
959 960
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
961

962
	iwl_setup_rx_scan_handlers(priv);
C
Christoph Hellwig 已提交
963
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
964

965
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
966
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990
}

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

/**
1034
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
1035
 */
1036
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1037 1038 1039 1040 1041 1042
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

/**
C
Christoph Hellwig 已提交
1043
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
1044
 *
1045
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
1046
 * and we have free pre-allocated buffers, fill the ranks as much
1047
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
1048 1049 1050 1051 1052
 *
 * 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.
 */
1053
static void iwl3945_rx_queue_restock(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1054
{
1055
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1056
	struct list_head *element;
1057
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1058
	unsigned long flags;
1059
	int write;
Z
Zhu Yi 已提交
1060 1061 1062

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
1063
	while ((iwl_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
1064
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
1065
		element = rxq->rx_free.next;
1066
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
Z
Zhu Yi 已提交
1067
		list_del(element);
1068 1069

		/* Point to Rx buffer via next RBD in circular buffer */
Z
Zhu Yi 已提交
1070
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->page_dma);
Z
Zhu Yi 已提交
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
		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);


1082 1083
	/* If we've added more space for the firmware to place data, tell it.
	 * Increment device's write pointer in multiples of 8. */
1084
	if ((rxq->write_actual != (rxq->write & ~0x7))
Z
Zhu Yi 已提交
1085 1086 1087 1088
	    || (abs(rxq->write - rxq->read) > 7)) {
		spin_lock_irqsave(&rxq->lock, flags);
		rxq->need_update = 1;
		spin_unlock_irqrestore(&rxq->lock, flags);
1089
		iwl_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
1090 1091 1092 1093
	}
}

/**
C
Christoph Hellwig 已提交
1094
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
1095 1096 1097
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
1098
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
1099
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
1100
 */
1101
static void iwl3945_rx_allocate(struct iwl_priv *priv, gfp_t priority)
Z
Zhu Yi 已提交
1102
{
1103
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1104
	struct list_head *element;
1105
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1106
	struct page *page;
Z
Zhu Yi 已提交
1107
	unsigned long flags;
1108
	gfp_t gfp_mask = priority;
A
Abhijeet Kolekar 已提交
1109 1110 1111 1112 1113 1114 1115 1116 1117

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

1119
		if (rxq->free_count > RX_LOW_WATERMARK)
1120
			gfp_mask |= __GFP_NOWARN;
Z
Zhu Yi 已提交
1121 1122

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

1125
		/* Alloc a new receive buffer */
1126
		page = alloc_pages(gfp_mask, priv->hw_params.rx_page_order);
Z
Zhu Yi 已提交
1127
		if (!page) {
Z
Zhu Yi 已提交
1128
			if (net_ratelimit())
1129 1130 1131 1132 1133 1134
				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 已提交
1135 1136 1137 1138 1139
			/* 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 已提交
1140

1141 1142 1143
		spin_lock_irqsave(&rxq->lock, flags);
		if (list_empty(&rxq->rx_used)) {
			spin_unlock_irqrestore(&rxq->lock, flags);
Z
Zhu Yi 已提交
1144
			__free_pages(page, priv->hw_params.rx_page_order);
1145 1146 1147 1148 1149 1150 1151
			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 已提交
1152
		rxb->page = page;
1153
		/* Get physical address of RB/SKB */
Z
Zhu Yi 已提交
1154 1155 1156
		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 已提交
1157 1158

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

Z
Zhu Yi 已提交
1160 1161
		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
Z
Zhu Yi 已提交
1162 1163
		priv->alloc_rxb_page++;

A
Abhijeet Kolekar 已提交
1164
		spin_unlock_irqrestore(&rxq->lock, flags);
Z
Zhu Yi 已提交
1165
	}
1166 1167
}

R
Reinette Chatre 已提交
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
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 已提交
1179 1180 1181 1182
		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);
1183
			__iwl_free_pages(priv, rxq->pool[i].page);
Z
Zhu Yi 已提交
1184
			rxq->pool[i].page = NULL;
R
Reinette Chatre 已提交
1185 1186 1187 1188 1189 1190 1191
		}
		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;
1192
	rxq->write_actual = 0;
Z
Zhu Yi 已提交
1193
	rxq->free_count = 0;
R
Reinette Chatre 已提交
1194 1195 1196
	spin_unlock_irqrestore(&rxq->lock, flags);
}

1197 1198
void iwl3945_rx_replenish(void *data)
{
1199
	struct iwl_priv *priv = data;
1200 1201
	unsigned long flags;

1202
	iwl3945_rx_allocate(priv, GFP_KERNEL);
Z
Zhu Yi 已提交
1203 1204

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
1205
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1206 1207 1208
	spin_unlock_irqrestore(&priv->lock, flags);
}

1209 1210 1211 1212 1213 1214 1215 1216
static void iwl3945_rx_replenish_now(struct iwl_priv *priv)
{
	iwl3945_rx_allocate(priv, GFP_ATOMIC);

	iwl3945_rx_queue_restock(priv);
}


R
Reinette Chatre 已提交
1217 1218 1219 1220 1221 1222 1223 1224 1225
/* 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 已提交
1226 1227 1228 1229
		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);
1230
			__iwl_free_pages(priv, rxq->pool[i].page);
Z
Zhu Yi 已提交
1231
			rxq->pool[i].page = NULL;
R
Reinette Chatre 已提交
1232 1233 1234
		}
	}

1235 1236 1237 1238
	dma_free_coherent(&priv->pci_dev->dev, 4 * RX_QUEUE_SIZE, rxq->bd,
			  rxq->dma_addr);
	dma_free_coherent(&priv->pci_dev->dev, sizeof(struct iwl_rb_status),
			  rxq->rb_stts, rxq->rb_stts_dma);
R
Reinette Chatre 已提交
1239 1240 1241 1242 1243
	rxq->bd = NULL;
	rxq->rb_stts  = NULL;
}


Z
Zhu Yi 已提交
1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
/* 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 已提交
1262
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
1263
{
1264 1265
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
1266 1267
		return 60;

1268
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
1269
	 *   add 20 dB to make up for divide by 10 */
1270
	if (sig_ratio >= 100)
1271
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281

	/* We shouldn't see this */
	if (sig_ratio < 1)
		return 0;

	/* Use table for ratios 1:1 - 99:1 */
	return (int)ratio2dB[sig_ratio];
}

/**
1282
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
1283 1284 1285 1286 1287
 *
 * Uses the priv->rx_handlers callback function array to invoke
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
1288
static void iwl3945_rx_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1289
{
1290
	struct iwl_rx_mem_buffer *rxb;
1291
	struct iwl_rx_packet *pkt;
1292
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1293 1294 1295
	u32 r, i;
	int reclaim;
	unsigned long flags;
1296
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
1297
	u32 count = 8;
1298
	int total_empty = 0;
Z
Zhu Yi 已提交
1299

1300 1301
	/* 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 已提交
1302
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
1303 1304
	i = rxq->read;

1305
	/* calculate total frames need to be restock after handling RX */
1306
	total_empty = r - rxq->write_actual;
1307 1308 1309 1310
	if (total_empty < 0)
		total_empty += RX_QUEUE_SIZE;

	if (total_empty > (RX_QUEUE_SIZE / 2))
1311
		fill_rx = 1;
Z
Zhu Yi 已提交
1312 1313
	/* Rx interrupt, but nothing sent from uCode */
	if (i == r)
1314
		IWL_DEBUG_RX(priv, "r = %d, i = %d\n", r, i);
Z
Zhu Yi 已提交
1315 1316 1317 1318

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

1319
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
1320 1321 1322 1323 1324 1325
		 * 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 已提交
1326 1327 1328 1329
		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 已提交
1330

J
Johannes Berg 已提交
1331 1332 1333
		trace_iwlwifi_dev_rx(priv, pkt,
			le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK);

Z
Zhu Yi 已提交
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345
		/* 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 已提交
1346
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
1347
		if (priv->rx_handlers[pkt->hdr.cmd]) {
1348
			IWL_DEBUG_RX(priv, "r = %d, i = %d, %s, 0x%02x\n", r, i,
Z
Zhu Yi 已提交
1349
				get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
1350
			priv->isr_stats.rx_handlers[pkt->hdr.cmd]++;
1351
			priv->rx_handlers[pkt->hdr.cmd] (priv, rxb);
Z
Zhu Yi 已提交
1352 1353
		} else {
			/* No handling needed */
Z
Zhu Yi 已提交
1354 1355
			IWL_DEBUG_RX(priv,
				"r %d i %d No handler needed for %s, 0x%02x\n",
Z
Zhu Yi 已提交
1356 1357 1358 1359
				r, i, get_cmd_string(pkt->hdr.cmd),
				pkt->hdr.cmd);
		}

1360 1361 1362 1363 1364 1365 1366
		/*
		 * 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 已提交
1367
		if (reclaim) {
Z
Zhu Yi 已提交
1368 1369
			/* Invoke any callbacks, transfer the buffer to caller,
			 * and fire off the (possibly) blocking iwl_send_cmd()
Z
Zhu Yi 已提交
1370
			 * as we reclaim the driver command queue */
1371
			if (rxb->page)
1372
				iwl_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
1373
			else
1374
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
1375 1376
		}

1377 1378 1379 1380
		/* 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 已提交
1381
		if (rxb->page != NULL) {
1382 1383 1384 1385 1386 1387 1388
			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 已提交
1389 1390

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

Z
Zhu Yi 已提交
1392
		i = (i + 1) & RX_QUEUE_MASK;
1393 1394 1395 1396 1397
		/* If there are a lot of unused frames,
		 * restock the Rx queue so ucode won't assert. */
		if (fill_rx) {
			count++;
			if (count >= 8) {
1398
				rxq->read = i;
1399
				iwl3945_rx_replenish_now(priv);
1400 1401 1402
				count = 0;
			}
		}
Z
Zhu Yi 已提交
1403 1404 1405
	}

	/* Backtrack one entry */
1406
	rxq->read = i;
1407 1408 1409 1410
	if (fill_rx)
		iwl3945_rx_replenish_now(priv);
	else
		iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1411 1412
}

1413
/* call this function to flush any scheduled tasklet */
1414
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
1415
{
T
Tomas Winkler 已提交
1416
	/* wait to make sure we flush pending tasklet*/
1417 1418 1419 1420
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}

Z
Zhu Yi 已提交
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443
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))

1444
void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1445 1446 1447 1448 1449 1450 1451
{
	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 已提交
1452
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1453
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1454 1455 1456 1457
		return;
	}


1458
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
1459 1460

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

1466
	IWL_ERR(priv, "Desc       Time       asrtPC  blink2 "
Z
Zhu Yi 已提交
1467 1468 1469 1470
		  "ilink1  nmiPC   Line\n");
	for (i = ERROR_START_OFFSET;
	     i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
	     i += ERROR_ELEM_SIZE) {
1471
		desc = iwl_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
1472
		time =
1473
		    iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
1474
		blink1 =
1475
		    iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
1476
		blink2 =
1477
		    iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
1478
		ilink1 =
1479
		    iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
1480
		ilink2 =
1481
		    iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
1482
		data1 =
1483
		    iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
1484

1485 1486 1487 1488
		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 已提交
1489 1490
		trace_iwlwifi_dev_ucode_error(priv, desc, time, data1, 0,
					0, blink1, blink2, ilink1, ilink2);
Z
Zhu Yi 已提交
1491 1492 1493
	}
}

1494
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
1495 1496

/**
C
Christoph Hellwig 已提交
1497
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
1498 1499
 *
 */
W
Wey-Yi Guy 已提交
1500 1501 1502
static int iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
				  u32 num_events, u32 mode,
				  int pos, char **buf, size_t bufsz)
Z
Zhu Yi 已提交
1503 1504 1505 1506 1507 1508
{
	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 已提交
1509
	unsigned long reg_flags;
Z
Zhu Yi 已提交
1510 1511

	if (num_events == 0)
W
Wey-Yi Guy 已提交
1512
		return pos;
Z
Zhu Yi 已提交
1513 1514 1515 1516 1517 1518 1519 1520 1521 1522

	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 已提交
1523 1524 1525 1526 1527 1528 1529 1530
	/* 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 已提交
1531 1532 1533
	/* "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 已提交
1534 1535
		ev = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
		time = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
1536 1537
		if (mode == 0) {
			/* data, ev */
W
Wey-Yi Guy 已提交
1538 1539 1540 1541 1542 1543 1544 1545 1546
			if (bufsz) {
				pos += scnprintf(*buf + pos, bufsz - pos,
						"0x%08x:%04u\n",
						time, ev);
			} else {
				IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
				trace_iwlwifi_dev_ucode_event(priv, 0,
							      time, ev);
			}
1547
		} else {
B
Ben Cahill 已提交
1548
			data = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
W
Wey-Yi Guy 已提交
1549 1550 1551 1552 1553 1554 1555 1556 1557 1558
			if (bufsz) {
				pos += scnprintf(*buf + pos, bufsz - pos,
						"%010u:0x%08x:%04u\n",
						 time, data, ev);
			} else {
				IWL_ERR(priv, "%010u\t0x%08x\t%04u\n",
					time, data, ev);
				trace_iwlwifi_dev_ucode_event(priv, time,
							      data, ev);
			}
Z
Zhu Yi 已提交
1559 1560
		}
	}
B
Ben Cahill 已提交
1561 1562 1563 1564

	/* Allow device to power down */
	iwl_release_nic_access(priv);
	spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
W
Wey-Yi Guy 已提交
1565
	return pos;
Z
Zhu Yi 已提交
1566 1567
}

1568 1569 1570
/**
 * iwl3945_print_last_event_logs - Dump the newest # of event log to syslog
 */
W
Wey-Yi Guy 已提交
1571
static int iwl3945_print_last_event_logs(struct iwl_priv *priv, u32 capacity,
1572
				      u32 num_wraps, u32 next_entry,
W
Wey-Yi Guy 已提交
1573 1574
				      u32 size, u32 mode,
				      int pos, char **buf, size_t bufsz)
1575 1576 1577 1578 1579 1580 1581
{
	/*
	 * 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) {
W
Wey-Yi Guy 已提交
1582 1583 1584 1585 1586 1587 1588
			pos = iwl3945_print_event_log(priv,
					     capacity - (size - next_entry),
					     size - next_entry, mode,
					     pos, buf, bufsz);
			pos = iwl3945_print_event_log(priv, 0,
						      next_entry, mode,
						      pos, buf, bufsz);
1589
		} else
W
Wey-Yi Guy 已提交
1590 1591 1592
			pos = iwl3945_print_event_log(priv, next_entry - size,
						      size, mode,
						      pos, buf, bufsz);
1593 1594
	} else {
		if (next_entry < size)
W
Wey-Yi Guy 已提交
1595 1596 1597
			pos = iwl3945_print_event_log(priv, 0,
						      next_entry, mode,
						      pos, buf, bufsz);
1598
		else
W
Wey-Yi Guy 已提交
1599 1600 1601
			pos = iwl3945_print_event_log(priv, next_entry - size,
						      size, mode,
						      pos, buf, bufsz);
1602
	}
W
Wey-Yi Guy 已提交
1603
	return pos;
1604 1605
}

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

1609 1610
#define DEFAULT_IWL3945_DUMP_EVENT_LOG_ENTRIES (20)

W
Wey-Yi Guy 已提交
1611 1612
int iwl3945_dump_nic_event_log(struct iwl_priv *priv, bool full_log,
			    char **buf, bool display)
Z
Zhu Yi 已提交
1613 1614 1615 1616 1617 1618 1619
{
	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 */
W
Wey-Yi Guy 已提交
1620 1621
	int pos = 0;
	size_t bufsz = 0;
Z
Zhu Yi 已提交
1622 1623

	base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
C
Christoph Hellwig 已提交
1624
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1625
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
1626
		return  -EINVAL;
Z
Zhu Yi 已提交
1627 1628 1629
	}

	/* event log header */
1630 1631 1632 1633
	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 已提交
1634

B
Ben Cahill 已提交
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
	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 已提交
1647 1648 1649 1650
	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
1651
		IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
W
Wey-Yi Guy 已提交
1652
		return pos;
Z
Zhu Yi 已提交
1653 1654
	}

1655
#ifdef CONFIG_IWLWIFI_DEBUG
1656
	if (!(iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS) && !full_log)
1657 1658 1659 1660 1661 1662 1663 1664 1665
		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 已提交
1666

1667
#ifdef CONFIG_IWLWIFI_DEBUG
W
Wey-Yi Guy 已提交
1668 1669 1670 1671 1672 1673 1674
	if (display) {
		if (full_log)
			bufsz = capacity * 48;
		else
			bufsz = size * 48;
		*buf = kmalloc(bufsz, GFP_KERNEL);
		if (!*buf)
1675
			return -ENOMEM;
W
Wey-Yi Guy 已提交
1676
	}
1677 1678 1679 1680 1681 1682
	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)
W
Wey-Yi Guy 已提交
1683 1684 1685
			pos = iwl3945_print_event_log(priv, next_entry,
						capacity - next_entry, mode,
						pos, buf, bufsz);
1686 1687

		/* (then/else) start at top of log */
W
Wey-Yi Guy 已提交
1688 1689
		pos = iwl3945_print_event_log(priv, 0, next_entry, mode,
					      pos, buf, bufsz);
1690
	} else
W
Wey-Yi Guy 已提交
1691 1692 1693
		pos = iwl3945_print_last_event_logs(priv, capacity, num_wraps,
						    next_entry, size, mode,
						    pos, buf, bufsz);
1694
#else
W
Wey-Yi Guy 已提交
1695 1696 1697
	pos = iwl3945_print_last_event_logs(priv, capacity, num_wraps,
					    next_entry, size, mode,
					    pos, buf, bufsz);
1698
#endif
W
Wey-Yi Guy 已提交
1699
	return pos;
1700 1701
}

1702
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1703 1704 1705 1706
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
S
Samuel Ortiz 已提交
1707
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1708 1709 1710 1711 1712 1713 1714 1715
	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. */
1716 1717
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
1718 1719 1720 1721

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

S
Samuel Ortiz 已提交
1725
#ifdef CONFIG_IWLWIFI_DEBUG
1726
	if (iwl_get_debug_level(priv) & IWL_DL_ISR) {
1727
		/* just for debug */
1728
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
1729
		IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
Z
Zhu Yi 已提交
1730 1731 1732 1733
			      inta, inta_mask, inta_fh);
	}
#endif

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

Z
Zhu Yi 已提交
1736 1737 1738 1739
	/* 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 已提交
1740
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
1741
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
1742
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
1743 1744 1745 1746
		inta |= CSR_INT_BIT_FH_TX;

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

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

1752
		priv->isr_stats.hw++;
1753
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1754 1755 1756 1757 1758 1759

		handled |= CSR_INT_BIT_HW_ERR;

		return;
	}

S
Samuel Ortiz 已提交
1760
#ifdef CONFIG_IWLWIFI_DEBUG
1761
	if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
1762
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
1763
		if (inta & CSR_INT_BIT_SCD) {
1764
			IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
1765
				      "the frame/frames.\n");
1766 1767
			priv->isr_stats.sch++;
		}
Z
Zhu Yi 已提交
1768 1769

		/* Alive notification via Rx interrupt will do the real work */
1770
		if (inta & CSR_INT_BIT_ALIVE) {
1771
			IWL_DEBUG_ISR(priv, "Alive interrupt\n");
1772 1773
			priv->isr_stats.alive++;
		}
Z
Zhu Yi 已提交
1774 1775 1776
	}
#endif
	/* Safely ignore these bits for debug checks below */
1777
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
1778 1779 1780

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
1781 1782
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
1783 1784
		priv->isr_stats.sw++;
		priv->isr_stats.sw_err = inta;
1785
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1786 1787 1788 1789 1790
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
1791
		IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
1792
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
1793 1794 1795 1796 1797 1798
		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 已提交
1799

1800
		priv->isr_stats.wakeup++;
Z
Zhu Yi 已提交
1801 1802 1803 1804 1805 1806 1807
		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 已提交
1808
		iwl3945_rx_handle(priv);
1809
		priv->isr_stats.rx++;
Z
Zhu Yi 已提交
1810 1811 1812 1813
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

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

1817
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
M
Mohamed Abbas 已提交
1818 1819
		iwl_write_direct32(priv, FH39_TCSR_CREDIT
					(FH39_SRVC_CHNL), 0x0);
Z
Zhu Yi 已提交
1820 1821 1822
		handled |= CSR_INT_BIT_FH_TX;
	}

1823
	if (inta & ~handled) {
1824
		IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
1825 1826
		priv->isr_stats.unhandled++;
	}
Z
Zhu Yi 已提交
1827

1828
	if (inta & ~priv->inta_mask) {
1829
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
1830
			 inta & ~priv->inta_mask);
1831
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
1832 1833 1834
	}

	/* Re-enable all interrupts */
1835 1836
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
1837
		iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
1838

S
Samuel Ortiz 已提交
1839
#ifdef CONFIG_IWLWIFI_DEBUG
1840
	if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
1841 1842 1843
		inta = iwl_read32(priv, CSR_INT);
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
1844
		IWL_DEBUG_ISR(priv, "End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
Z
Zhu Yi 已提交
1845 1846 1847 1848 1849
			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
	}
#endif
}

1850
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
1851
					 enum ieee80211_band band,
1852
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
1853
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
1854
{
1855
	struct ieee80211_channel *chan;
1856
	const struct ieee80211_supported_band *sband;
1857
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
1858 1859 1860 1861
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
1862
	sband = iwl_get_hw_mode(priv, band);
1863
	if (!sband)
Z
Zhu Yi 已提交
1864 1865
		return 0;

S
Samuel Ortiz 已提交
1866 1867
	active_dwell = iwl_get_active_dwell_time(priv, band, n_probes);
	passive_dwell = iwl_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
1868

1869 1870 1871
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

1872 1873 1874 1875
	for (i = 0, added = 0; i < priv->scan_request->n_channels; i++) {
		chan = priv->scan_request->channels[i];

		if (chan->band != band)
1876 1877
			continue;

1878
		scan_ch->channel = chan->hw_value;
Z
Zhu Yi 已提交
1879

1880
		ch_info = iwl_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
1881
		if (!is_channel_valid(ch_info)) {
1882
			IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
1883 1884 1885 1886
				       scan_ch->channel);
			continue;
		}

1887 1888 1889 1890 1891
		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 已提交
1892
		if (!is_active || is_channel_passive(ch_info) ||
1893
		    (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
1894
			scan_ch->type = 0;	/* passive */
1895 1896 1897
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
1898
			scan_ch->type = 1;	/* active */
1899
		}
Z
Zhu Yi 已提交
1900

1901 1902 1903 1904 1905 1906
		/* 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)
1907
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
1908 1909 1910 1911
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
1912
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
1913
		}
Z
Zhu Yi 已提交
1914

1915
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
1916 1917 1918 1919
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
1920
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
1921 1922 1923 1924
			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
1925
			 * power level:
1926
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
1927 1928 1929
			 */
		}

1930
		IWL_DEBUG_SCAN(priv, "Scanning %d [%s %d]\n",
Z
Zhu Yi 已提交
1931 1932 1933 1934 1935 1936 1937 1938 1939
			       scan_ch->channel,
			       (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
			       (scan_ch->type & 1) ?
			       active_dwell : passive_dwell);

		scan_ch++;
		added++;
	}

1940
	IWL_DEBUG_SCAN(priv, "total channels to scan %d \n", added);
Z
Zhu Yi 已提交
1941 1942 1943
	return added;
}

1944
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1945 1946 1947 1948 1949
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
1950 1951 1952 1953
		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;
1954
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
1955
			/*
1956
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
1957
			 */
C
Christoph Hellwig 已提交
1958
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
1959
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
		}
	}
}

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

1970
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1971
{
1972 1973 1974 1975 1976 1977
	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 已提交
1978 1979 1980
}

/**
C
Christoph Hellwig 已提交
1981
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
1982 1983
 *     looking at all data.
 */
1984
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
1985 1986 1987 1988 1989 1990
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

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

1993
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
1994
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
1995 1996 1997 1998 1999 2000

	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 */
2001
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2002
		if (val != le32_to_cpu(*image)) {
2003
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
				  "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)
2015 2016
		IWL_DEBUG_INFO(priv,
			"ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
2017 2018 2019 2020 2021 2022

	return rc;
}


/**
C
Christoph Hellwig 已提交
2023
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2024 2025 2026
 *   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.
 */
2027
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2028 2029 2030 2031 2032 2033
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

2034
	IWL_DEBUG_INFO(priv, "ucode inst image size is %u\n", len);
Z
Zhu Yi 已提交
2035 2036 2037 2038 2039

	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 */
2040
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2041
			i + IWL39_RTC_INST_LOWER_BOUND);
2042
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2043 2044
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
2045
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060
				  "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 已提交
2061
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
2062 2063
 *    and verify its contents
 */
2064
static int iwl3945_verify_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2065 2066 2067 2068 2069 2070 2071 2072
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2073
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2074
	if (rc == 0) {
2075
		IWL_DEBUG_INFO(priv, "Bootstrap uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2076 2077 2078 2079 2080 2081
		return 0;
	}

	/* Try initialize */
	image = (__le32 *)priv->ucode_init.v_addr;
	len = priv->ucode_init.len;
C
Christoph Hellwig 已提交
2082
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2083
	if (rc == 0) {
2084
		IWL_DEBUG_INFO(priv, "Initialize uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2085 2086 2087 2088 2089 2090
		return 0;
	}

	/* Try runtime/protocol */
	image = (__le32 *)priv->ucode_code.v_addr;
	len = priv->ucode_code.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, "Runtime uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2094 2095 2096
		return 0;
	}

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

2099 2100 2101
	/* 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 已提交
2102 2103
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2104
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
2105 2106 2107 2108

	return rc;
}

2109
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2110 2111
{
	/* Remove all resets to allow NIC to operate */
2112
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
2113 2114 2115
}

/**
C
Christoph Hellwig 已提交
2116
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
2117 2118 2119
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
2120
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2121
{
2122
	const struct iwl_ucode_header *ucode;
2123
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
2124 2125
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
2126 2127 2128 2129
	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 已提交
2130 2131
	u8 *src;
	size_t len;
2132
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
2133 2134 2135

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
2136 2137 2138 2139
	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) {
2140
			IWL_ERR(priv, "%s firmware file req failed: %d\n",
2141 2142 2143 2144 2145 2146 2147
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
2148 2149 2150
				IWL_ERR(priv, "Loaded firmware %s, "
					"which is deprecated. "
					" Please use API v%u instead.\n",
2151
					  buf, api_max);
2152 2153
			IWL_DEBUG_INFO(priv, "Got firmware '%s' file "
				       "(%zd bytes) from disk\n",
2154 2155 2156
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
2157 2158
	}

2159 2160
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
2161 2162

	/* Make sure that we got at least our header! */
2163
	if (ucode_raw->size <  priv->cfg->ops->ucode->get_header_size(1)) {
2164
		IWL_ERR(priv, "File size way too small!\n");
2165
		ret = -EINVAL;
Z
Zhu Yi 已提交
2166 2167 2168 2169
		goto err_release;
	}

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

2172
	priv->ucode_ver = le32_to_cpu(ucode->ver);
2173
	api_ver = IWL_UCODE_API(priv->ucode_ver);
2174 2175 2176 2177 2178 2179 2180
	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 已提交
2181

2182 2183
	/* api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
2184
	 * on the API version read from firmware header from here on forward */
2185 2186

	if (api_ver < api_min || api_ver > api_max) {
2187
		IWL_ERR(priv, "Driver unable to support your firmware API. "
2188 2189 2190 2191 2192 2193 2194
			  "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)
2195
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
2196 2197 2198 2199
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
2200 2201 2202 2203 2204 2205
	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));

2206 2207 2208 2209 2210 2211 2212 2213
	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));

2214
	IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
2215
		       priv->ucode_ver);
2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
	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 已提交
2226

2227

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

2233 2234 2235
		IWL_DEBUG_INFO(priv,
			"uCode file size %zd does not match expected size\n",
			ucode_raw->size);
2236
		ret = -EINVAL;
Z
Zhu Yi 已提交
2237 2238 2239 2240
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
2241
	if (inst_size > IWL39_MAX_INST_SIZE) {
2242
		IWL_DEBUG_INFO(priv, "uCode instr len %d too large to fit in\n",
2243 2244
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2245 2246 2247
		goto err_release;
	}

2248
	if (data_size > IWL39_MAX_DATA_SIZE) {
2249
		IWL_DEBUG_INFO(priv, "uCode data len %d too large to fit in\n",
2250 2251
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2252 2253
		goto err_release;
	}
2254
	if (init_size > IWL39_MAX_INST_SIZE) {
2255 2256
		IWL_DEBUG_INFO(priv,
				"uCode init instr len %d too large to fit in\n",
2257 2258
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2259 2260
		goto err_release;
	}
2261
	if (init_data_size > IWL39_MAX_DATA_SIZE) {
2262 2263
		IWL_DEBUG_INFO(priv,
				"uCode init data len %d too large to fit in\n",
2264 2265
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2266 2267
		goto err_release;
	}
2268
	if (boot_size > IWL39_MAX_BSM_SIZE) {
2269 2270
		IWL_DEBUG_INFO(priv,
				"uCode boot instr len %d too large to fit in\n",
2271 2272
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2273 2274 2275 2276 2277 2278 2279 2280 2281
		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;
2282
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
2283 2284

	priv->ucode_data.len = data_size;
2285
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
2286 2287

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

2290 2291 2292
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
2293 2294

	/* Initialization instructions and data */
2295 2296
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
2297
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
2298 2299

		priv->ucode_init_data.len = init_data_size;
2300
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
2301 2302 2303 2304

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

	/* Bootstrap (instructions only, no data) */
2307 2308
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
2309
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
2310

2311 2312 2313
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
2314 2315 2316 2317

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

	/* Runtime instructions (first block of data in file) */
2318
	len = inst_size;
2319 2320
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode instr len %zd\n", len);
Z
Zhu Yi 已提交
2321
	memcpy(priv->ucode_code.v_addr, src, len);
2322 2323
	src += len;

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

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
2328
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
2329
	len = data_size;
2330 2331
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode data len %zd\n", len);
Z
Zhu Yi 已提交
2332 2333
	memcpy(priv->ucode_data.v_addr, src, len);
	memcpy(priv->ucode_data_backup.v_addr, src, len);
2334
	src += len;
Z
Zhu Yi 已提交
2335 2336 2337

	/* Initialization instructions (3rd block) */
	if (init_size) {
2338
		len = init_size;
2339 2340
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init instr len %zd\n", len);
Z
Zhu Yi 已提交
2341
		memcpy(priv->ucode_init.v_addr, src, len);
2342
		src += len;
Z
Zhu Yi 已提交
2343 2344 2345 2346
	}

	/* Initialization data (4th block) */
	if (init_data_size) {
2347
		len = init_data_size;
2348 2349
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init data len %zd\n", len);
Z
Zhu Yi 已提交
2350
		memcpy(priv->ucode_init_data.v_addr, src, len);
2351
		src += len;
Z
Zhu Yi 已提交
2352 2353 2354
	}

	/* Bootstrap instructions (5th block) */
2355
	len = boot_size;
2356 2357
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) boot instr len %zd\n", len);
Z
Zhu Yi 已提交
2358 2359 2360 2361 2362 2363 2364
	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:
2365
	IWL_ERR(priv, "failed to allocate pci memory\n");
2366
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
2367
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
2368 2369 2370 2371 2372

 err_release:
	release_firmware(ucode_raw);

 error:
2373
	return ret;
Z
Zhu Yi 已提交
2374 2375 2376 2377
}


/**
C
Christoph Hellwig 已提交
2378
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
2379 2380 2381 2382 2383 2384 2385
 *
 * 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.
 */
2386
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2387 2388 2389 2390 2391 2392 2393 2394 2395
{
	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 */
2396 2397 2398
	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 已提交
2399 2400
				 priv->ucode_data.len);

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

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

M
Mohamed Abbas 已提交
2408
	return 0;
Z
Zhu Yi 已提交
2409 2410 2411
}

/**
C
Christoph Hellwig 已提交
2412
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2413 2414 2415 2416
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
2417
 */
2418
static void iwl3945_init_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2419 2420 2421 2422 2423
{
	/* 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 */
2424
		IWL_DEBUG_INFO(priv, "Initialize Alive failed.\n");
Z
Zhu Yi 已提交
2425 2426 2427 2428 2429 2430
		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 已提交
2431
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2432 2433
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2434
		IWL_DEBUG_INFO(priv, "Bad \"initialize\" uCode load.\n");
Z
Zhu Yi 已提交
2435 2436 2437 2438 2439 2440
		goto restart;
	}

	/* Send pointers to protocol/runtime uCode image ... init code will
	 * load and launch runtime uCode, which will send us another "Alive"
	 * notification. */
2441
	IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
C
Christoph Hellwig 已提交
2442
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
2443 2444
		/* Runtime instruction load won't happen;
		 * take it all the way back down so we can try again */
2445
		IWL_DEBUG_INFO(priv, "Couldn't set up uCode pointers.\n");
Z
Zhu Yi 已提交
2446 2447 2448 2449 2450 2451 2452 2453 2454
		goto restart;
	}
	return;

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

/**
C
Christoph Hellwig 已提交
2455
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2456
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
2457
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
2458
 */
2459
static void iwl3945_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2460 2461 2462 2463
{
	int thermal_spin = 0;
	u32 rfkill;

2464
	IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
2465 2466 2467 2468

	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 */
2469
		IWL_DEBUG_INFO(priv, "Alive failed.\n");
Z
Zhu Yi 已提交
2470 2471 2472 2473 2474 2475
		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 已提交
2476
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2477 2478
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2479
		IWL_DEBUG_INFO(priv, "Bad runtime uCode load.\n");
Z
Zhu Yi 已提交
2480 2481 2482
		goto restart;
	}

2483
	rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
2484
	IWL_DEBUG_INFO(priv, "RFKILL status: 0x%x\n", rfkill);
Z
Zhu Yi 已提交
2485 2486 2487

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
2488
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
2489
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
2490
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
2491 2492 2493 2494 2495
			thermal_spin++;
			udelay(10);
		}

		if (thermal_spin)
2496
			IWL_DEBUG_INFO(priv, "Thermal calibration took %dus\n",
Z
Zhu Yi 已提交
2497 2498 2499 2500
				       thermal_spin * 10);
	} else
		set_bit(STATUS_RF_KILL_HW, &priv->status);

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

2504 2505 2506 2507 2508 2509 2510
	if (priv->cfg->ops->lib->recover_from_tx_stall) {
		/* Enable timer to monitor the driver queues */
		mod_timer(&priv->monitor_recover,
			jiffies +
			msecs_to_jiffies(priv->cfg->monitor_recover_period));
	}

2511
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
2512 2513
		return;

2514
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
2515

2516
	priv->active_rate = IWL_RATES_MASK;
Z
Zhu Yi 已提交
2517

2518
	iwl_power_update_mode(priv, true);
Z
Zhu Yi 已提交
2519

2520
	if (iwl_is_associated(priv)) {
C
Christoph Hellwig 已提交
2521
		struct iwl3945_rxon_cmd *active_rxon =
2522
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
2523

2524
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
Z
Zhu Yi 已提交
2525 2526 2527
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
2528
		iwl_connection_init_rx_config(priv, priv->iw_mode);
Z
Zhu Yi 已提交
2529 2530
	}

2531
	/* Configure Bluetooth device coexistence support */
2532
	iwl_send_bt_config(priv);
Z
Zhu Yi 已提交
2533 2534

	/* Configure the adapter for unassociated operation */
A
Abhijeet Kolekar 已提交
2535
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
2536 2537 2538

	iwl3945_reg_txpower_periodic(priv);

J
Johannes Berg 已提交
2539
	iwl_leds_init(priv);
2540

2541
	IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
2542
	set_bit(STATUS_READY, &priv->status);
2543
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
2544 2545 2546 2547 2548 2549 2550

	return;

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

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

2553
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2554 2555 2556 2557 2558
{
	unsigned long flags;
	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
	struct ieee80211_conf *conf = NULL;

2559
	IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
Z
Zhu Yi 已提交
2560 2561 2562 2563 2564 2565

	conf = ieee80211_get_hw_conf(priv->hw);

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

2566 2567
	/* Station information will now be cleared in device */
	iwl_clear_ucode_stations(priv, true);
Z
Zhu Yi 已提交
2568 2569 2570 2571 2572 2573 2574 2575 2576 2577

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

	/* tell the device to stop sending interrupts */
2581
	spin_lock_irqsave(&priv->lock, flags);
2582
	iwl_disable_interrupts(priv);
2583 2584
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
2585 2586 2587 2588

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

C
Christoph Hellwig 已提交
2589
	/* If we have not previously called iwl3945_init() then
2590
	 * clear all bits but the RF Kill bits and return */
2591
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
2592 2593
		priv->status = test_bit(STATUS_RF_KILL_HW, &priv->status) <<
					STATUS_RF_KILL_HW |
2594 2595
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
2596 2597
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2598 2599 2600
		goto exit;
	}

2601
	/* ...otherwise clear out all the status bits but the RF Kill
J
Johannes Berg 已提交
2602
	 * bit and continue taking the NIC down. */
Z
Zhu Yi 已提交
2603 2604
	priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
				STATUS_RF_KILL_HW |
2605 2606
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
2607
			test_bit(STATUS_FW_ERROR, &priv->status) <<
2608 2609 2610
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2611

C
Christoph Hellwig 已提交
2612 2613
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
2614

B
Ben Cahill 已提交
2615 2616
	/* Power-down device's busmaster DMA clocks */
	iwl_write_prph(priv, APMG_CLK_DIS_REG, APMG_CLK_VAL_DMA_CLK_RQT);
Z
Zhu Yi 已提交
2617 2618
	udelay(5);

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

Z
Zhu Yi 已提交
2622
 exit:
2623
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
2624 2625 2626 2627 2628 2629

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
2630
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
2631 2632
}

2633
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2634 2635
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2636
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
2637
	mutex_unlock(&priv->mutex);
2638

C
Christoph Hellwig 已提交
2639
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
2640 2641 2642 2643
}

#define MAX_HW_RESTARTS 5

2644
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2645 2646 2647 2648
{
	int rc, i;

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

2653
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
2654
		IWL_ERR(priv, "ucode not available for device bring up\n");
2655 2656 2657
		return -EIO;
	}

2658
	/* If platform's RF_KILL switch is NOT set to KILL */
2659
	if (iwl_read32(priv, CSR_GP_CNTRL) &
2660 2661 2662 2663
				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);
2664 2665
		IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
		return -ENODEV;
Z
Zhu Yi 已提交
2666
	}
2667

2668
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
2669

C
Christoph Hellwig 已提交
2670
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
2671
	if (rc) {
2672
		IWL_ERR(priv, "Unable to int nic\n");
Z
Zhu Yi 已提交
2673 2674 2675 2676
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
2677 2678
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
2679 2680 2681
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
2682
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2683
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
2684 2685

	/* really make sure rfkill handshake bits are cleared */
2686 2687
	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 已提交
2688 2689 2690 2691 2692

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

2695 2696 2697 2698
	/* 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 已提交
2699 2700 2701 2702 2703
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

		/* load bootstrap state machine,
		 * load bootstrap program into processor's memory,
		 * prepare to load the "initialize" uCode */
2704
		rc = priv->cfg->ops->lib->load_ucode(priv);
Z
Zhu Yi 已提交
2705 2706

		if (rc) {
2707 2708
			IWL_ERR(priv,
				"Unable to set up bootstrap uCode: %d\n", rc);
Z
Zhu Yi 已提交
2709 2710 2711 2712
			continue;
		}

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

2715
		IWL_DEBUG_INFO(priv, DRV_NAME " is coming up\n");
Z
Zhu Yi 已提交
2716 2717 2718 2719 2720

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
2721
	__iwl3945_down(priv);
2722
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
2723 2724 2725

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
2726
	IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
Z
Zhu Yi 已提交
2727 2728 2729 2730 2731 2732 2733 2734 2735 2736
	return -EIO;
}


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

C
Christoph Hellwig 已提交
2737
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2738
{
2739 2740
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, init_alive_start.work);
Z
Zhu Yi 已提交
2741 2742 2743 2744 2745

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2746
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
2747 2748 2749
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
2750
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2751
{
2752 2753
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, alive_start.work);
Z
Zhu Yi 已提交
2754 2755 2756 2757 2758

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2759
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
2760 2761 2762
	mutex_unlock(&priv->mutex);
}

2763 2764 2765 2766 2767 2768
/*
 * 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).
 */
2769 2770 2771
static void iwl3945_rfkill_poll(struct work_struct *data)
{
	struct iwl_priv *priv =
2772
	    container_of(data, struct iwl_priv, _3945.rfkill_poll.work);
2773 2774 2775
	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);
2776

2777 2778 2779 2780 2781
	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);
2782

2783 2784 2785 2786 2787
		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");
	}
2788

2789 2790
	/* Keep this running, even if radio now enabled.  This will be
	 * cancelled in mac_start() if system decides to start again */
2791
	queue_delayed_work(priv->workqueue, &priv->_3945.rfkill_poll,
2792 2793 2794 2795
			   round_jiffies_relative(2 * HZ));

}

Z
Zhu Yi 已提交
2796
#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)
C
Christoph Hellwig 已提交
2797
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
2798
{
2799 2800
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
2801
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
2802
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
2803
		.len = sizeof(struct iwl3945_scan_cmd),
J
Johannes Berg 已提交
2804
		.flags = CMD_SIZE_HUGE,
Z
Zhu Yi 已提交
2805
	};
C
Christoph Hellwig 已提交
2806
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
2807
	struct ieee80211_conf *conf = NULL;
J
Johannes Berg 已提交
2808
	u8 n_probes = 0;
2809
	enum ieee80211_band band;
J
Johannes Berg 已提交
2810
	bool is_active = false;
Z
Zhu Yi 已提交
2811 2812 2813 2814 2815

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

2816 2817
	cancel_delayed_work(&priv->scan_check);

2818
	if (!iwl_is_ready(priv)) {
2819
		IWL_WARN(priv, "request scan called when driver not ready.\n");
Z
Zhu Yi 已提交
2820 2821 2822
		goto done;
	}

T
Tomas Winkler 已提交
2823
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
2824 2825 2826 2827 2828 2829 2830
	 * 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)) {
2831 2832
		IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests  "
				"Ignoring second request.\n");
Z
Zhu Yi 已提交
2833 2834 2835 2836
		goto done;
	}

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
2837
		IWL_DEBUG_SCAN(priv, "Aborting scan due to device shutdown\n");
Z
Zhu Yi 已提交
2838 2839 2840 2841
		goto done;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
2842 2843
		IWL_DEBUG_HC(priv,
			"Scan request while abort pending. Queuing.\n");
Z
Zhu Yi 已提交
2844 2845 2846
		goto done;
	}

2847
	if (iwl_is_rfkill(priv)) {
2848
		IWL_DEBUG_HC(priv, "Aborting scan due to RF Kill activation\n");
Z
Zhu Yi 已提交
2849 2850 2851 2852
		goto done;
	}

	if (!test_bit(STATUS_READY, &priv->status)) {
2853 2854
		IWL_DEBUG_HC(priv,
			"Scan request while uninitialized. Queuing.\n");
Z
Zhu Yi 已提交
2855 2856 2857 2858
		goto done;
	}

	if (!priv->scan_bands) {
2859
		IWL_DEBUG_HC(priv, "Aborting scan due to no requested bands\n");
Z
Zhu Yi 已提交
2860 2861 2862
		goto done;
	}

W
Winkler, Tomas 已提交
2863 2864
	if (!priv->scan) {
		priv->scan = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
2865
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
W
Winkler, Tomas 已提交
2866
		if (!priv->scan) {
2867
			IWL_DEBUG_SCAN(priv, "Fail to allocate scan memory\n");
Z
Zhu Yi 已提交
2868 2869 2870
			goto done;
		}
	}
W
Winkler, Tomas 已提交
2871
	scan = priv->scan;
C
Christoph Hellwig 已提交
2872
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
2873 2874 2875 2876

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

2877
	if (iwl_is_associated(priv)) {
Z
Zhu Yi 已提交
2878 2879 2880 2881 2882 2883
		u16 interval = 0;
		u32 extra;
		u32 suspend_time = 100;
		u32 scan_suspend_time = 100;
		unsigned long flags;

2884
		IWL_DEBUG_INFO(priv, "Scanning while associated...\n");
Z
Zhu Yi 已提交
2885 2886 2887 2888 2889 2890

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

		scan->suspend_time = 0;
2891
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905
		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);
2906
		IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n",
Z
Zhu Yi 已提交
2907 2908 2909
			       scan_suspend_time, interval);
	}

2910 2911 2912
	if (priv->is_internal_short_scan) {
		IWL_DEBUG_SCAN(priv, "Start internal passive scan.\n");
	} else if (priv->scan_request->n_ssids) {
J
Johannes Berg 已提交
2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928
		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;
2929
	} else
J
Johannes Berg 已提交
2930
		IWL_DEBUG_SCAN(priv, "Kicking off passive scan.\n");
Z
Zhu Yi 已提交
2931 2932 2933 2934

	/* 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;
2935
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
2936 2937 2938 2939
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

2940
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
2941 2942 2943
		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;
2944
		band = IEEE80211_BAND_2GHZ;
2945
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
2946
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
2947 2948 2949 2950 2951 2952
		/*
		 * 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;
2953
		band = IEEE80211_BAND_5GHZ;
2954
	} else {
2955
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
2956 2957 2958
		goto done;
	}

2959 2960
	if (!priv->is_internal_short_scan) {
		scan->tx_cmd.len = cpu_to_le16(
J
Johannes Berg 已提交
2961 2962 2963 2964 2965
			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)));
2966 2967 2968 2969 2970 2971 2972
	} else {
		scan->tx_cmd.len = cpu_to_le16(
			iwl_fill_probe_req(priv,
				(struct ieee80211_mgmt *)scan->data,
				NULL, 0,
				IWL_MAX_SCAN_SIZE - sizeof(*scan)));
	}
Z
Zhu Yi 已提交
2973 2974 2975
	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

2976
	if (iwl_is_monitor_mode(priv))
Z
Zhu Yi 已提交
2977 2978
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

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

2983
	if (scan->channel_count == 0) {
2984
		IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count);
2985 2986 2987
		goto done;
	}

Z
Zhu Yi 已提交
2988
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
2989
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
2990 2991 2992 2993
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
2994
	if (iwl_send_cmd_sync(priv, &cmd))
Z
Zhu Yi 已提交
2995 2996 2997 2998 2999 3000 3001 3002 3003
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
3004 3005 3006 3007 3008 3009 3010 3011
	/* 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);

3012
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
3013 3014 3015 3016
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
3017
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
3018
{
3019
	struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
Z
Zhu Yi 已提交
3020 3021 3022 3023

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

J
Johannes Berg 已提交
3024 3025 3026 3027 3028 3029 3030 3031 3032
	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);
J
Johannes Berg 已提交
3033 3034 3035 3036 3037 3038 3039

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

		mutex_lock(&priv->mutex);
		__iwl3945_up(priv);
		mutex_unlock(&priv->mutex);
J
Johannes Berg 已提交
3040
	}
Z
Zhu Yi 已提交
3041 3042
}

C
Christoph Hellwig 已提交
3043
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
3044
{
3045 3046
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rx_replenish);
Z
Zhu Yi 已提交
3047 3048 3049 3050 3051

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3052
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
3053 3054 3055
	mutex_unlock(&priv->mutex);
}

3056 3057
#define IWL_DELAY_NEXT_SCAN (HZ*2)

3058
void iwl3945_post_associate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3059 3060 3061 3062
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

3063
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
3064
		IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
3065 3066 3067 3068
		return;
	}


3069
	IWL_DEBUG_ASSOC(priv, "Associated as %d to: %pM\n",
3070
			priv->assoc_id, priv->active_rxon.bssid_addr);
Z
Zhu Yi 已提交
3071 3072 3073 3074

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

A
Abhijeet Kolekar 已提交
3075
	if (!priv->vif || !priv->is_open)
3076
		return;
A
Abhijeet Kolekar 已提交
3077

3078
	iwl_scan_cancel_timeout(priv, 200);
3079

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

3082
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3083
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3084

3085
	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
3086
	iwl_setup_rxon_timing(priv);
3087
	rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
3088 3089
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
3090
		IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3091 3092
			    "Attempting to continue.\n");

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

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

3097
	IWL_DEBUG_ASSOC(priv, "assoc id %d beacon interval %d\n",
Z
Zhu Yi 已提交
3098 3099 3100
			priv->assoc_id, priv->beacon_int);

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3101
		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3102
	else
3103
		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3104

3105
	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3106
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
3107
			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3108
		else
3109
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3110

3111
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3112
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3113 3114 3115

	}

A
Abhijeet Kolekar 已提交
3116
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3117 3118

	switch (priv->iw_mode) {
3119
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
3120
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
3121 3122
		break;

3123
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
3124

3125
		priv->assoc_id = 1;
3126
		iwl_add_local_station(priv, priv->bssid, false);
Z
Zhu Yi 已提交
3127
		iwl3945_sync_sta(priv, IWL_STA_ID,
3128 3129
				(priv->band == IEEE80211_BAND_5GHZ) ?
				IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
Z
Zhu Yi 已提交
3130
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
3131
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
3132

C
Christoph Hellwig 已提交
3133
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3134 3135 3136 3137

		break;

	default:
3138
		 IWL_ERR(priv, "%s Should not be called in %d mode\n",
3139
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
3140 3141 3142
		break;
	}

3143
	iwl_activate_qos(priv, 0);
3144

3145 3146
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
3147 3148
}

Z
Zhu Yi 已提交
3149 3150 3151 3152 3153 3154
/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

3155 3156
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
3157
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3158
{
3159
	struct iwl_priv *priv = hw->priv;
3160
	int ret;
Z
Zhu Yi 已提交
3161

3162
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3163 3164 3165 3166

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

3167 3168 3169 3170 3171 3172
	/* 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) {
3173
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
3174 3175 3176 3177
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
3178

3179
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
3180 3181

	mutex_unlock(&priv->mutex);
3182

3183 3184 3185
	if (ret)
		goto out_release_irq;

3186
	IWL_DEBUG_INFO(priv, "Start UP work.\n");
3187

3188 3189 3190 3191 3192 3193 3194
	/* 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)) {
3195 3196 3197
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
3198 3199 3200 3201 3202
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

3203 3204
	/* ucode is running and will send rfkill notifications,
	 * no need to poll the killswitch state anymore */
3205
	cancel_delayed_work(&priv->_3945.rfkill_poll);
3206

J
Johannes Berg 已提交
3207 3208
	iwl_led_start(priv);

3209
	priv->is_open = 1;
3210
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3211
	return 0;
3212 3213

out_release_irq:
3214
	priv->is_open = 0;
3215
	IWL_DEBUG_MAC80211(priv, "leave - failed\n");
3216
	return ret;
Z
Zhu Yi 已提交
3217 3218
}

C
Christoph Hellwig 已提交
3219
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3220
{
3221
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3222

3223
	IWL_DEBUG_MAC80211(priv, "enter\n");
3224

3225
	if (!priv->is_open) {
3226
		IWL_DEBUG_MAC80211(priv, "leave - skip\n");
3227 3228 3229
		return;
	}

Z
Zhu Yi 已提交
3230
	priv->is_open = 0;
3231

3232
	if (iwl_is_ready_rf(priv)) {
3233 3234 3235
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
3236
		mutex_lock(&priv->mutex);
3237
		iwl_scan_cancel_timeout(priv, 100);
3238 3239 3240
		mutex_unlock(&priv->mutex);
	}

3241 3242 3243
	iwl3945_down(priv);

	flush_workqueue(priv->workqueue);
3244 3245

	/* start polling the killswitch state again */
3246
	queue_delayed_work(priv->workqueue, &priv->_3945.rfkill_poll,
3247
			   round_jiffies_relative(2 * HZ));
3248

3249
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3250 3251
}

3252
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
3253
{
3254
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3255

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

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

3261
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
3262 3263
		dev_kfree_skb_any(skb);

3264
	IWL_DEBUG_MAC80211(priv, "leave\n");
3265
	return NETDEV_TX_OK;
Z
Zhu Yi 已提交
3266 3267
}

A
Abhijeet Kolekar 已提交
3268
void iwl3945_config_ap(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3269 3270 3271
{
	int rc = 0;

3272
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
3273 3274 3275
		return;

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

		/* RXON - unassoc (to set timing command) */
3279
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3280
		iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3281 3282

		/* RXON Timing */
3283
		memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
3284
		iwl_setup_rxon_timing(priv);
3285 3286 3287
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
				      sizeof(priv->rxon_timing),
				      &priv->rxon_timing);
Z
Zhu Yi 已提交
3288
		if (rc)
3289
			IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3290 3291 3292
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
3293
		priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
3294
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3295
			priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3296 3297
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
3298
			priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3299 3300
				~RXON_FLG_SHORT_PREAMBLE_MSK;

3301
		if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3302 3303
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
3304
				priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3305 3306
					RXON_FLG_SHORT_SLOT_MSK;
			else
3307
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3308 3309
					~RXON_FLG_SHORT_SLOT_MSK;

3310
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3311
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3312 3313 3314
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
3315
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3316
		iwlcore_commit_rxon(priv);
3317
		iwl_add_local_station(priv, iwl_bcast_addr, false);
3318
	}
C
Christoph Hellwig 已提交
3319
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3320 3321 3322 3323 3324 3325

	/* 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 已提交
3326
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3327 3328 3329
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
Z
Zhu Yi 已提交
3330
{
3331
	struct iwl_priv *priv = hw->priv;
3332
	const u8 *addr;
3333 3334 3335
	int ret = 0;
	u8 sta_id = IWL_INVALID_STATION;
	u8 static_key;
Z
Zhu Yi 已提交
3336

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

3339
	if (iwl3945_mod_params.sw_crypto) {
3340
		IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
Z
Zhu Yi 已提交
3341 3342 3343
		return -EOPNOTSUPP;
	}

3344
	addr = sta ? sta->addr : iwl_bcast_addr;
3345 3346 3347
	static_key = !iwl_is_associated(priv);

	if (!static_key) {
3348
		sta_id = iwl_find_station(priv, addr);
3349
		if (sta_id == IWL_INVALID_STATION) {
3350
			IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
3351 3352 3353
					    addr);
			return -EINVAL;
		}
Z
Zhu Yi 已提交
3354 3355 3356
	}

	mutex_lock(&priv->mutex);
3357
	iwl_scan_cancel_timeout(priv, 100);
3358

Z
Zhu Yi 已提交
3359
	switch (cmd) {
3360 3361 3362 3363 3364 3365
	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 已提交
3366 3367
		break;
	case DISABLE_KEY:
3368 3369 3370 3371 3372
		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 已提交
3373 3374
		break;
	default:
3375
		ret = -EINVAL;
Z
Zhu Yi 已提交
3376 3377
	}

3378
	mutex_unlock(&priv->mutex);
3379
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3380

3381
	return ret;
Z
Zhu Yi 已提交
3382 3383
}

3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415
static int iwl3945_mac_sta_add(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta)
{
	struct iwl_priv *priv = hw->priv;
	int ret;
	bool is_ap = priv->iw_mode == NL80211_IFTYPE_STATION;
	u8 sta_id;

	IWL_DEBUG_INFO(priv, "received request to add station %pM\n",
			sta->addr);

	ret = iwl_add_station_common(priv, sta->addr, is_ap, &sta->ht_cap,
				     &sta_id);
	if (ret) {
		IWL_ERR(priv, "Unable to add station %pM (%d)\n",
			sta->addr, ret);
		/* Should we return success if return code is EEXIST ? */
		return ret;
	}

	/* Initialize rate scaling */
	IWL_DEBUG_INFO(priv, "Initializing rate scaling for station %pM \n",
		       sta->addr);
	iwl3945_rs_rate_init(priv, sta, sta_id);

	return 0;



	return ret;
}
Z
Zhu Yi 已提交
3416 3417 3418 3419 3420 3421
/*****************************************************************************
 *
 * sysfs attributes
 *
 *****************************************************************************/

S
Samuel Ortiz 已提交
3422
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
3423 3424 3425 3426 3427 3428 3429

/*
 * 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.
3430
 *
3431 3432 3433
 * 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 已提交
3434
 */
3435 3436
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
3437
{
3438 3439
	struct iwl_priv *priv = dev_get_drvdata(d);
	return sprintf(buf, "0x%08X\n", iwl_get_debug_level(priv));
Z
Zhu Yi 已提交
3440
}
3441 3442
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
3443 3444
				 const char *buf, size_t count)
{
3445
	struct iwl_priv *priv = dev_get_drvdata(d);
3446 3447
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
3448

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

3461 3462
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
3463

S
Samuel Ortiz 已提交
3464
#endif /* CONFIG_IWLWIFI_DEBUG */
Z
Zhu Yi 已提交
3465 3466 3467 3468

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

3471
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3472 3473
		return -EAGAIN;

C
Christoph Hellwig 已提交
3474
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
3475 3476 3477 3478 3479 3480 3481
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
3482
	struct iwl_priv *priv = dev_get_drvdata(d);
3483
	return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
Z
Zhu Yi 已提交
3484 3485 3486 3487 3488 3489
}

static ssize_t store_tx_power(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
3490
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3491 3492 3493 3494 3495
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
3496
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
3497
	else
C
Christoph Hellwig 已提交
3498
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
3499 3500 3501 3502 3503 3504 3505 3506 3507

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

3510
	return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
Z
Zhu Yi 已提交
3511 3512 3513 3514 3515 3516
}

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

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

	return sprintf(buf, "0x%04X\n",
3545
		le32_to_cpu(priv->active_rxon.filter_flags));
Z
Zhu Yi 已提交
3546 3547 3548 3549 3550 3551
}

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

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

	return count;
}

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

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

3636
	IWL_DEBUG_INFO(priv, "Invoking measurement of type %d on "
Z
Zhu Yi 已提交
3637
		       "channel %d (for '%s')\n", type, params.channel, buf);
C
Christoph Hellwig 已提交
3638
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);

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

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

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

3669

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

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
3682
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
3683
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
3684
	u32 len = 0, ofs = 0;
3685
	u8 *data = (u8 *)&priv->_3945.statistics;
Z
Zhu Yi 已提交
3686 3687
	int rc = 0;

3688
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3689 3690 3691
		return -EAGAIN;

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

3722
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3723 3724
		return -EAGAIN;

3725
	return sprintf(buf, "%d\n", iwl3945_mod_params.antenna);
Z
Zhu Yi 已提交
3726 3727 3728 3729 3730 3731
}

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

	if (count == 0)
		return 0;

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

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


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

	if (p[0] == '1')
3774
		iwl3945_dump_nic_error_log(priv);
Z
Zhu Yi 已提交
3775 3776 3777 3778 3779 3780 3781 3782

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
3783
 * driver setup and tear down
Z
Zhu Yi 已提交
3784 3785 3786
 *
 *****************************************************************************/

3787
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3788
{
3789
	priv->workqueue = create_singlethread_workqueue(DRV_NAME);
Z
Zhu Yi 已提交
3790 3791 3792

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
3793 3794 3795 3796 3797
	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);
3798
	INIT_DELAYED_WORK(&priv->_3945.rfkill_poll, iwl3945_rfkill_poll);
S
Samuel Ortiz 已提交
3799 3800 3801 3802
	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 已提交
3803 3804

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
3805

3806 3807 3808 3809 3810 3811 3812
	if (priv->cfg->ops->lib->recover_from_tx_stall) {
		init_timer(&priv->monitor_recover);
		priv->monitor_recover.data = (unsigned long)priv;
		priv->monitor_recover.function =
			priv->cfg->ops->lib->recover_from_tx_stall;
	}

Z
Zhu Yi 已提交
3813
	tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
C
Christoph Hellwig 已提交
3814
		     iwl3945_irq_tasklet, (unsigned long)priv);
Z
Zhu Yi 已提交
3815 3816
}

3817
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3818
{
C
Christoph Hellwig 已提交
3819
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
3820

3821
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
3822 3823 3824
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
3825 3826
	if (priv->cfg->ops->lib->recover_from_tx_stall)
		del_timer_sync(&priv->monitor_recover);
Z
Zhu Yi 已提交
3827 3828
}

C
Christoph Hellwig 已提交
3829
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840
	&dev_attr_antenna.attr,
	&dev_attr_channels.attr,
	&dev_attr_dump_errors.attr,
	&dev_attr_flags.attr,
	&dev_attr_filter_flags.attr,
	&dev_attr_measurement.attr,
	&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 已提交
3841
#ifdef CONFIG_IWLWIFI_DEBUG
3842 3843
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
3844 3845 3846
	NULL
};

C
Christoph Hellwig 已提交
3847
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
3848
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
3849
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
3850 3851
};

C
Christoph Hellwig 已提交
3852 3853 3854 3855
static struct ieee80211_ops iwl3945_hw_ops = {
	.tx = iwl3945_mac_tx,
	.start = iwl3945_mac_start,
	.stop = iwl3945_mac_stop,
3856
	.add_interface = iwl_mac_add_interface,
3857
	.remove_interface = iwl_mac_remove_interface,
3858
	.config = iwl_mac_config,
3859
	.configure_filter = iwl_configure_filter,
C
Christoph Hellwig 已提交
3860
	.set_key = iwl3945_mac_set_key,
A
Abhijeet Kolekar 已提交
3861
	.conf_tx = iwl_mac_conf_tx,
3862
	.reset_tsf = iwl_mac_reset_tsf,
3863
	.bss_info_changed = iwl_bss_info_changed,
3864 3865 3866
	.hw_scan = iwl_mac_hw_scan,
	.sta_add = iwl3945_mac_sta_add,
	.sta_remove = iwl_mac_sta_remove,
Z
Zhu Yi 已提交
3867 3868
};

3869
static int iwl3945_init_drv(struct iwl_priv *priv)
3870 3871
{
	int ret;
3872
	struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
3873 3874 3875 3876 3877 3878 3879 3880 3881 3882

	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);
3883
	mutex_init(&priv->sync_cmd_mutex);
3884 3885 3886 3887 3888 3889

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

	priv->iw_mode = NL80211_IFTYPE_STATION;
3890
	priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
3891 3892 3893 3894 3895 3896

	iwl_reset_qos(priv);

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

3897
	priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
3898

3899 3900 3901 3902 3903 3904 3905
	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);
3906 3907 3908 3909 3910
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

3911 3912 3913 3914 3915 3916
	/* Set up txpower settings in driver for all channels */
	if (iwl3945_txpower_set_from_eeprom(priv)) {
		ret = -EIO;
		goto err_free_channel_map;
	}

3917
	ret = iwlcore_init_geos(priv);
3918 3919 3920 3921
	if (ret) {
		IWL_ERR(priv, "initializing geos failed: %d\n", ret);
		goto err_free_channel_map;
	}
3922 3923
	iwl3945_init_hw_rates(priv, priv->ieee_rates);

3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941
	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 已提交
3942
		    IEEE80211_HW_NOISE_DBM |
R
Reinette Chatre 已提交
3943 3944 3945 3946 3947
		    IEEE80211_HW_SPECTRUM_MGMT;

	if (!priv->cfg->broken_powersave)
		hw->flags |= IEEE80211_HW_SUPPORTS_PS |
			     IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
3948 3949 3950 3951 3952

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

J
Johannes Berg 已提交
3953 3954
	hw->wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY |
			    WIPHY_FLAG_DISABLE_BEACON_HINTS;
3955

J
Johannes Berg 已提交
3956 3957 3958
	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;
3959

3960 3961 3962
	/* Default value; 4 EDCA QOS priorities */
	hw->queues = 4;

3963 3964 3965
	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
3966

3967 3968 3969
	if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&priv->bands[IEEE80211_BAND_5GHZ];
3970

3971 3972 3973 3974 3975 3976
	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;
3977

3978
	return 0;
3979 3980
}

C
Christoph Hellwig 已提交
3981
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
3982 3983
{
	int err = 0;
3984
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
3985
	struct ieee80211_hw *hw;
3986
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
3987
	struct iwl3945_eeprom *eeprom;
3988
	unsigned long flags;
Z
Zhu Yi 已提交
3989

3990 3991 3992 3993
	/***********************
	 * 1. Allocating HW data
	 * ********************/

Z
Zhu Yi 已提交
3994 3995
	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
3996
	hw = iwl_alloc_all(cfg, &iwl3945_hw_ops);
Z
Zhu Yi 已提交
3997
	if (hw == NULL) {
3998
		printk(KERN_ERR DRV_NAME "Can not allocate network device\n");
Z
Zhu Yi 已提交
3999 4000 4001 4002
		err = -ENOMEM;
		goto out;
	}
	priv = hw->priv;
4003
	SET_IEEE80211_DEV(hw, &pdev->dev);
4004

4005 4006 4007 4008
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
4009
	if (iwl3945_mod_params.disable_hw_scan) {
4010
		IWL_DEBUG_INFO(priv, "Disabling hw_scan\n");
4011 4012 4013
		iwl3945_hw_ops.hw_scan = NULL;
	}

4014

4015
	IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
4016 4017
	priv->cfg = cfg;
	priv->pci_dev = pdev;
4018
	priv->inta_mask = CSR_INI_SET_MASK;
4019

S
Samuel Ortiz 已提交
4020
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
4021 4022
	atomic_set(&priv->restrict_refcnt, 0);
#endif
4023 4024
	if (iwl_alloc_traffic_mem(priv))
		IWL_ERR(priv, "Not enough memory to generate traffic log\n");
Z
Zhu Yi 已提交
4025

4026 4027 4028
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
4029 4030 4031 4032 4033 4034 4035
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

4036
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
4037
	if (!err)
4038
		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
4039
	if (err) {
T
Tomas Winkler 已提交
4040
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
4041 4042 4043 4044 4045 4046 4047
		goto out_pci_disable_device;
	}

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

4049 4050 4051
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
4052 4053 4054 4055 4056 4057
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

4058
	IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
Z
Zhu Yi 已提交
4059
			(unsigned long long) pci_resource_len(pdev, 0));
4060
	IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
Z
Zhu Yi 已提交
4061

4062 4063 4064
	/* 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 已提交
4065

4066
	/* these spin locks will be used in apm_ops.init and EEPROM access
M
Mohamed Abbas 已提交
4067 4068 4069
	 * we should init now
	 */
	spin_lock_init(&priv->reg_lock);
4070
	spin_lock_init(&priv->lock);
M
Mohamed Abbas 已提交
4071

4072 4073 4074 4075 4076 4077 4078
	/*
	 * stop and reset the on-board processor just in case it is in a
	 * strange state ... like being left stranded by a primary kernel
	 * and this is now the kdump kernel trying to start up
	 */
	iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);

4079 4080 4081
	/***********************
	 * 4. Read EEPROM
	 * ********************/
4082

4083
	/* Read the EEPROM */
4084
	err = iwl_eeprom_init(priv);
4085
	if (err) {
4086
		IWL_ERR(priv, "Unable to init EEPROM\n");
4087
		goto out_iounmap;
4088 4089
	}
	/* MAC Address location in EEPROM same for 3945/4965 */
4090 4091
	eeprom = (struct iwl3945_eeprom *)priv->eeprom;
	memcpy(priv->mac_addr, eeprom->mac_address, ETH_ALEN);
4092
	IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->mac_addr);
4093
	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
Z
Zhu Yi 已提交
4094

4095 4096 4097
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
4098
	/* Device-specific setup */
4099
	if (iwl3945_hw_set_hw_params(priv)) {
4100
		IWL_ERR(priv, "failed to set hw settings\n");
4101
		goto out_eeprom_free;
Z
Zhu Yi 已提交
4102 4103
	}

4104 4105 4106 4107
	/***********************
	 * 6. Setup priv
	 * ********************/

4108
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
4109
	if (err) {
4110
		IWL_ERR(priv, "initializing driver failed\n");
4111
		goto out_unset_hw_params;
Z
Zhu Yi 已提交
4112 4113
	}

T
Tomas Winkler 已提交
4114 4115
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
4116 4117

	/***********************
4118
	 * 7. Setup Services
4119 4120 4121
	 * ********************/

	spin_lock_irqsave(&priv->lock, flags);
4122
	iwl_disable_interrupts(priv);
4123 4124
	spin_unlock_irqrestore(&priv->lock, flags);

4125 4126
	pci_enable_msi(priv->pci_dev);

M
Mohamed Abbas 已提交
4127 4128
	err = request_irq(priv->pci_dev->irq, priv->cfg->ops->lib->isr,
			  IRQF_SHARED, DRV_NAME, priv);
4129 4130 4131 4132 4133
	if (err) {
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

4134
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
4135
	if (err) {
4136
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
4137
		goto out_release_irq;
4138 4139
	}

4140 4141
	iwl_set_rxon_channel(priv,
			     &priv->bands[IEEE80211_BAND_2GHZ].channels[5]);
4142 4143
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);
B
Ben Cahill 已提交
4144
	iwl_power_initialize(priv);
4145 4146

	/*********************************
4147
	 * 8. Setup and Register mac80211
4148 4149
	 * *******************************/

4150
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
4151

4152 4153 4154
	err = iwl3945_setup_mac(priv);
	if (err)
		goto  out_remove_sysfs;
4155

A
Abhijeet Kolekar 已提交
4156 4157 4158 4159
	err = iwl_dbgfs_register(priv, DRV_NAME);
	if (err)
		IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);

4160
	/* Start monitoring the killswitch */
4161
	queue_delayed_work(priv->workqueue, &priv->_3945.rfkill_poll,
4162 4163
			   2 * HZ);

Z
Zhu Yi 已提交
4164 4165
	return 0;

4166
 out_remove_sysfs:
4167 4168
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
4169
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
4170
 out_release_irq:
4171 4172 4173
	free_irq(priv->pci_dev->irq, priv);
 out_disable_msi:
	pci_disable_msi(priv->pci_dev);
4174 4175 4176 4177 4178 4179
	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 已提交
4180 4181 4182 4183 4184 4185
 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);
4186
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
4187
 out_ieee80211_free_hw:
4188
	iwl_free_traffic_mem(priv);
4189
	ieee80211_free_hw(priv->hw);
Z
Zhu Yi 已提交
4190 4191 4192 4193
 out:
	return err;
}

4194
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
4195
{
4196
	struct iwl_priv *priv = pci_get_drvdata(pdev);
4197
	unsigned long flags;
Z
Zhu Yi 已提交
4198 4199 4200 4201

	if (!priv)
		return;

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

A
Abhijeet Kolekar 已提交
4204 4205
	iwl_dbgfs_unregister(priv);

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

4208 4209 4210 4211 4212 4213
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
4214

4215 4216 4217 4218 4219 4220 4221 4222 4223
	/*
	 * 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);

4224 4225 4226 4227
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
4228
	iwl_disable_interrupts(priv);
4229 4230 4231 4232
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

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

4235
	cancel_delayed_work_sync(&priv->_3945.rfkill_poll);
4236

C
Christoph Hellwig 已提交
4237
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
4238 4239

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

4243
	iwl3945_unset_hw_params(priv);
Z
Zhu Yi 已提交
4244

4245 4246 4247
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
4248
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
4249 4250 4251 4252
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
4253
	iwl_free_traffic_mem(priv);
Z
Zhu Yi 已提交
4254

4255 4256 4257
	free_irq(pdev->irq, priv);
	pci_disable_msi(pdev);

Z
Zhu Yi 已提交
4258 4259 4260 4261 4262
	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

4263
	iwl_free_channel_map(priv);
4264
	iwlcore_free_geos(priv);
W
Winkler, Tomas 已提交
4265
	kfree(priv->scan);
Z
Zhu Yi 已提交
4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}


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

C
Christoph Hellwig 已提交
4279
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
4280
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
4281 4282 4283
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
4284
#ifdef CONFIG_PM
4285 4286
	.suspend = iwl_pci_suspend,
	.resume = iwl_pci_resume,
Z
Zhu Yi 已提交
4287 4288 4289
#endif
};

C
Christoph Hellwig 已提交
4290
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
4291 4292 4293 4294 4295
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
4296 4297 4298

	ret = iwl3945_rate_control_register();
	if (ret) {
4299 4300
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
4301 4302 4303
		return ret;
	}

C
Christoph Hellwig 已提交
4304
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
4305
	if (ret) {
4306
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
4307
		goto error_register;
Z
Zhu Yi 已提交
4308 4309 4310
	}

	return ret;
4311 4312 4313 4314

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
4315 4316
}

C
Christoph Hellwig 已提交
4317
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
4318
{
C
Christoph Hellwig 已提交
4319
	pci_unregister_driver(&iwl3945_driver);
4320
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
4321 4322
}

4323
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
4324

4325
module_param_named(antenna, iwl3945_mod_params.antenna, int, S_IRUGO);
Z
Zhu Yi 已提交
4326
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
4327
module_param_named(swcrypto, iwl3945_mod_params.sw_crypto, int, S_IRUGO);
4328 4329
MODULE_PARM_DESC(swcrypto,
		 "using software crypto (default 1 [software])\n");
4330
#ifdef CONFIG_IWLWIFI_DEBUG
4331
module_param_named(debug, iwl_debug_level, uint, S_IRUGO | S_IWUSR);
Z
Zhu Yi 已提交
4332
MODULE_PARM_DESC(debug, "debug output mask");
4333
#endif
4334 4335
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan,
		   int, S_IRUGO);
Z
Zhu Yi 已提交
4336
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");
4337
module_param_named(fw_restart3945, iwl3945_mod_params.restart_fw, int, S_IRUGO);
4338 4339
MODULE_PARM_DESC(fw_restart3945, "restart firmware in case of error");

C
Christoph Hellwig 已提交
4340 4341
module_exit(iwl3945_exit);
module_init(iwl3945_init);