iwl3945-base.c 119.4 KB
Newer Older
Z
Zhu Yi 已提交
1 2
/******************************************************************************
 *
3
 * Copyright(c) 2003 - 2009 Intel Corporation. All rights reserved.
Z
Zhu Yi 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 * Portions of this file are derived from the ipw3945 project, as well
 * as portions of the ieee80211 subsystem header files.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 * Contact Information:
25
 *  Intel Linux Wireless <ilw@linux.intel.com>
Z
Zhu Yi 已提交
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/

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

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

#include <asm/div64.h>

48 49
#define DRV_NAME	"iwl3945"

W
Winkler, Tomas 已提交
50 51
#include "iwl-fh.h"
#include "iwl-3945-fh.h"
52
#include "iwl-commands.h"
53
#include "iwl-sta.h"
Z
Zhu Yi 已提交
54 55
#include "iwl-3945.h"
#include "iwl-helpers.h"
K
Kolekar, Abhijeet 已提交
56
#include "iwl-core.h"
57
#include "iwl-dev.h"
Z
Zhu Yi 已提交
58 59 60 61 62 63 64 65

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

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

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

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

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


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

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

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

133
static int iwl3945_set_ccmp_dynamic_key_info(struct iwl_priv *priv,
Z
Zhu Yi 已提交
134 135 136 137 138
				   struct ieee80211_key_conf *keyconf,
				   u8 sta_id)
{
	unsigned long flags;
	__le16 key_flags = 0;
139 140 141 142 143 144 145 146 147 148 149
	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 已提交
150 151

	spin_lock_irqsave(&priv->sta_lock, flags);
152 153 154
	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 已提交
155 156
	       keyconf->keylen);

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

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

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

170 171 172
	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 已提交
173

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

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

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

180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
	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 已提交
195 196
}

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

	spin_lock_irqsave(&priv->sta_lock, flags);
202 203
	memset(&priv->stations[sta_id].keyinfo, 0, sizeof(struct iwl_hw_key));
	memset(&priv->stations[sta_id].sta.key, 0,
204
		sizeof(struct iwl4965_keyinfo));
205 206 207
	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 已提交
208 209
	spin_unlock_irqrestore(&priv->sta_lock, flags);

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

A
Abhijeet Kolekar 已提交
215
static int iwl3945_set_dynamic_key(struct iwl_priv *priv,
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
			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:
233
		IWL_ERR(priv, "Unknown alg: %s alg = %d\n", __func__, keyconf->alg);
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 260
		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;
}

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

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

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

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

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

		priv->frames_count++;
		return frame;
	}

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

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

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

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

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

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

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

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

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

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

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

	return rc;
}

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

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

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

	case ALG_TKIP:
		break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	spin_unlock_irqrestore(&priv->lock, flags);

520
	hdr_len = ieee80211_hdrlen(fc);
521 522

	/* Find (or create) index into station table for destination station */
523 524 525 526
	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 已提交
527
	if (sta_id == IWL_INVALID_STATION) {
528
		IWL_DEBUG_DROP(priv, "Dropping - INVALID STATION: %pM\n",
J
Johannes Berg 已提交
529
			       hdr->addr1);
Z
Zhu Yi 已提交
530 531 532
		goto drop;
	}

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

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

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

	spin_lock_irqsave(&priv->lock, flags);

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

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

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

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

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

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

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

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

	if (!ieee80211_has_morefrags(hdr->frame_control)) {
		txq->need_update = 1;
		if (qc)
602
			priv->stations[sta_id].tid[tid].seq_number = seq_number;
R
Reinette Chatre 已提交
603 604 605 606 607 608 609
	} 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 已提交
610 611 612
	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 已提交
613 614
			   ieee80211_hdrlen(fc));

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

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

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

635 636
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
R
Reinette Chatre 已提交
637 638 639 640
	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 已提交
641 642
	pci_unmap_addr_set(out_meta, mapping, txcmd_phys);
	pci_unmap_len_set(out_meta, len, len);
Z
Zhu Yi 已提交
643

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


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


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

	if (rc)
		return rc;

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

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

	return 0;

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

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

#include "iwl-spectrum.h"

#define BEACON_TIME_MASK_LOW	0x00FFFFFF
#define BEACON_TIME_MASK_HIGH	0xFF000000
#define TIME_UNIT		1024

/*
 * extended beacon time format
 * time in usec will be changed into a 32-bit value in 8:24 format
 * the high 1 byte is the beacon counts
 * the lower 3 bytes is the time in usec within one beacon interval
 */

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

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

759
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
760
		add_time =
C
Christoph Hellwig 已提交
761
		    iwl3945_usecs_to_beacons(
Z
Zhu Yi 已提交
762 763 764 765 766 767 768 769 770 771 772 773
			le64_to_cpu(params->start_time) - priv->last_tsf,
			le16_to_cpu(priv->rxon_timing.beacon_interval));

	memset(&spectrum, 0, sizeof(spectrum));

	spectrum.channel_count = cpu_to_le16(1);
	spectrum.flags =
	    RXON_FLG_TSF2HOST_MSK | RXON_FLG_ANT_A_MSK | RXON_FLG_DIS_DIV_MSK;
	spectrum.filter_flags = MEASUREMENT_FILTER_FLAG;
	cmd.len = sizeof(spectrum);
	spectrum.len = cpu_to_le16(cmd.len - sizeof(spectrum.len));

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

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

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

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

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

Z
Zhu Yi 已提交
816
	free_pages(cmd.reply_page, priv->hw_params.rx_page_order);
Z
Zhu Yi 已提交
817 818 819 820 821

	return rc;
}
#endif

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

	palive = &pkt->u.alive_frame;

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

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

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

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

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

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

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

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

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

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

911
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
912 913 914 915 916 917
	    (!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 */
918
static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
919
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
920
{
Z
Zhu Yi 已提交
921
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
Z
Zhu Yi 已提交
922 923 924
	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
	unsigned long status = priv->status;

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

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


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

	if ((test_bit(STATUS_RF_KILL_HW, &status) !=
J
Johannes Berg 已提交
941 942 943
	     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 已提交
944 945 946 947 948
	else
		wake_up_interruptible(&priv->wait_command_queue);
}

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

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

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

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

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

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

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

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

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


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

	return 0;
}

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

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

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

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

1144
		/* Alloc a new receive buffer */
1145
		page = alloc_pages(gfp_mask, priv->hw_params.rx_page_order);
Z
Zhu Yi 已提交
1146
		if (!page) {
Z
Zhu Yi 已提交
1147
			if (net_ratelimit())
1148 1149 1150 1151 1152 1153
				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 已提交
1154 1155 1156 1157 1158
			/* 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 已提交
1159

1160 1161 1162
		spin_lock_irqsave(&rxq->lock, flags);
		if (list_empty(&rxq->rx_used)) {
			spin_unlock_irqrestore(&rxq->lock, flags);
Z
Zhu Yi 已提交
1163
			__free_pages(page, priv->hw_params.rx_page_order);
1164 1165 1166 1167 1168 1169 1170
			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 已提交
1171
		rxb->page = page;
1172
		/* Get physical address of RB/SKB */
Z
Zhu Yi 已提交
1173 1174 1175
		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 已提交
1176 1177

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

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

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

R
Reinette Chatre 已提交
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
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 已提交
1198 1199 1200 1201 1202 1203 1204 1205
		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);
			priv->alloc_rxb_page--;
			__free_pages(rxq->pool[i].page,
				     priv->hw_params.rx_page_order);
			rxq->pool[i].page = NULL;
R
Reinette Chatre 已提交
1206 1207 1208 1209 1210 1211 1212
		}
		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;
1213
	rxq->write_actual = 0;
Z
Zhu Yi 已提交
1214
	rxq->free_count = 0;
R
Reinette Chatre 已提交
1215 1216 1217
	spin_unlock_irqrestore(&rxq->lock, flags);
}

1218 1219
void iwl3945_rx_replenish(void *data)
{
1220
	struct iwl_priv *priv = data;
1221 1222
	unsigned long flags;

1223
	iwl3945_rx_allocate(priv, GFP_KERNEL);
Z
Zhu Yi 已提交
1224 1225

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

1230 1231 1232 1233 1234 1235 1236 1237
static void iwl3945_rx_replenish_now(struct iwl_priv *priv)
{
	iwl3945_rx_allocate(priv, GFP_ATOMIC);

	iwl3945_rx_queue_restock(priv);
}


R
Reinette Chatre 已提交
1238 1239 1240 1241 1242 1243 1244 1245 1246
/* 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 已提交
1247 1248 1249 1250 1251 1252 1253 1254
		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);
			__free_pages(rxq->pool[i].page,
				     priv->hw_params.rx_page_order);
			rxq->pool[i].page = NULL;
			priv->alloc_rxb_page--;
R
Reinette Chatre 已提交
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
		}
	}

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


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

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

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

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

#define PERFECT_RSSI (-20) /* dBm */
#define WORST_RSSI (-95)   /* dBm */
#define RSSI_RANGE (PERFECT_RSSI - WORST_RSSI)

/* Calculate an indication of rx signal quality (a percentage, not dBm!).
 * See http://www.ces.clemson.edu/linux/signal_quality.shtml for info
 *   about formulas used below. */
C
Christoph Hellwig 已提交
1311
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345
{
	int sig_qual;
	int degradation = PERFECT_RSSI - rssi_dbm;

	/* If we get a noise measurement, use signal-to-noise ratio (SNR)
	 * as indicator; formula is (signal dbm - noise dbm).
	 * SNR at or above 40 is a great signal (100%).
	 * Below that, scale to fit SNR of 0 - 40 dB within 0 - 100% indicator.
	 * Weakest usable signal is usually 10 - 15 dB SNR. */
	if (noise_dbm) {
		if (rssi_dbm - noise_dbm >= 40)
			return 100;
		else if (rssi_dbm < noise_dbm)
			return 0;
		sig_qual = ((rssi_dbm - noise_dbm) * 5) / 2;

	/* Else use just the signal level.
	 * This formula is a least squares fit of data points collected and
	 *   compared with a reference system that had a percentage (%) display
	 *   for signal quality. */
	} else
		sig_qual = (100 * (RSSI_RANGE * RSSI_RANGE) - degradation *
			    (15 * RSSI_RANGE + 62 * degradation)) /
			   (RSSI_RANGE * RSSI_RANGE);

	if (sig_qual > 100)
		sig_qual = 100;
	else if (sig_qual < 1)
		sig_qual = 0;

	return sig_qual;
}

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

1364 1365
	/* 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 已提交
1366
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
1367 1368
	i = rxq->read;

1369
	/* calculate total frames need to be restock after handling RX */
1370
	total_empty = r - rxq->write_actual;
1371 1372 1373 1374
	if (total_empty < 0)
		total_empty += RX_QUEUE_SIZE;

	if (total_empty > (RX_QUEUE_SIZE / 2))
1375
		fill_rx = 1;
Z
Zhu Yi 已提交
1376 1377
	/* Rx interrupt, but nothing sent from uCode */
	if (i == r)
1378
		IWL_DEBUG_RX(priv, "r = %d, i = %d\n", r, i);
Z
Zhu Yi 已提交
1379 1380 1381 1382

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

1383
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
1384 1385 1386 1387 1388 1389
		 * 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 已提交
1390 1391 1392 1393
		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 已提交
1394

J
Johannes Berg 已提交
1395 1396 1397
		trace_iwlwifi_dev_rx(priv, pkt,
			le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK);

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

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

1441 1442 1443 1444
		/* 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 已提交
1445
		if (rxb->page != NULL) {
1446 1447 1448 1449 1450 1451 1452
			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 已提交
1453 1454

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

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

	/* Backtrack one entry */
1470
	rxq->read = i;
1471 1472 1473 1474
	if (fill_rx)
		iwl3945_rx_replenish_now(priv);
	else
		iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1475 1476
}

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

1485
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508
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))

1509
void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1510 1511 1512 1513 1514 1515 1516
{
	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 已提交
1517
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1518
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1519 1520 1521 1522
		return;
	}


1523
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
1524 1525

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

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

1550 1551 1552 1553
		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 已提交
1554 1555
		trace_iwlwifi_dev_ucode_error(priv, desc, time, data1, 0,
					0, blink1, blink2, ilink1, ilink2);
Z
Zhu Yi 已提交
1556 1557 1558
	}
}

1559
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
1560 1561

/**
C
Christoph Hellwig 已提交
1562
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
1563 1564
 *
 */
1565
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588
				u32 num_events, u32 mode)
{
	u32 i;
	u32 base;       /* SRAM byte address of event log header */
	u32 event_size;	/* 2 u32s, or 3 u32s if timestamp recorded */
	u32 ptr;        /* SRAM byte address of log data */
	u32 ev, time, data; /* event log data */

	if (num_events == 0)
		return;

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

	if (mode == 0)
		event_size = 2 * sizeof(u32);
	else
		event_size = 3 * sizeof(u32);

	ptr = base + EVENT_START_OFFSET + (start_idx * event_size);

	/* "time" is actually "data" for mode 0 (no timestamp).
	 * place event id # at far right for easier visual parsing. */
	for (i = 0; i < num_events; i++) {
1589
		ev = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1590
		ptr += sizeof(u32);
1591
		time = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1592
		ptr += sizeof(u32);
1593 1594 1595
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
J
Johannes Berg 已提交
1596
			trace_iwlwifi_dev_ucode_event(priv, 0, time, ev);
1597
		} else {
1598
			data = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1599
			ptr += sizeof(u32);
1600
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
J
Johannes Berg 已提交
1601
			trace_iwlwifi_dev_ucode_event(priv, time, data, ev);
Z
Zhu Yi 已提交
1602 1603 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
void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1610 1611 1612 1613 1614 1615 1616 1617 1618
{
	u32 base;       /* SRAM byte address of event log header */
	u32 capacity;   /* event log capacity in # entries */
	u32 mode;       /* 0 - no timestamp, 1 - timestamp recorded */
	u32 num_wraps;  /* # times uCode wrapped to top of log */
	u32 next_entry; /* index of next entry to be written by uCode */
	u32 size;       /* # entries that we'll print */

	base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
C
Christoph Hellwig 已提交
1619
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1620
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1621 1622 1623 1624
		return;
	}

	/* event log header */
1625 1626 1627 1628
	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 已提交
1629

B
Ben Cahill 已提交
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
	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 已提交
1642 1643 1644 1645
	size = num_wraps ? capacity : next_entry;

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

1650
	IWL_ERR(priv, "Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
1651 1652 1653 1654 1655
		  size, num_wraps);

	/* if uCode has wrapped back to top of log, start at the oldest entry,
	 * i.e the next one that uCode would fill. */
	if (num_wraps)
C
Christoph Hellwig 已提交
1656
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
1657 1658 1659
				    capacity - next_entry, mode);

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

}
1663 1664 1665 1666 1667 1668 1669 1670 1671 1672
#else
void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
{
}

void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
{
}

#endif
Z
Zhu Yi 已提交
1673

1674
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1675 1676 1677 1678
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
S
Samuel Ortiz 已提交
1679
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1680 1681 1682 1683 1684 1685 1686 1687
	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. */
1688 1689
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
1690 1691 1692 1693

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

S
Samuel Ortiz 已提交
1697
#ifdef CONFIG_IWLWIFI_DEBUG
1698
	if (iwl_get_debug_level(priv) & IWL_DL_ISR) {
1699
		/* just for debug */
1700
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
1701
		IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
Z
Zhu Yi 已提交
1702 1703 1704 1705
			      inta, inta_mask, inta_fh);
	}
#endif

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

Z
Zhu Yi 已提交
1708 1709 1710 1711
	/* 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 已提交
1712
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
1713
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
1714
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
1715 1716 1717 1718
		inta |= CSR_INT_BIT_FH_TX;

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

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

1724
		priv->isr_stats.hw++;
1725
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1726 1727 1728 1729 1730 1731

		handled |= CSR_INT_BIT_HW_ERR;

		return;
	}

S
Samuel Ortiz 已提交
1732
#ifdef CONFIG_IWLWIFI_DEBUG
1733
	if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
1734
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
1735
		if (inta & CSR_INT_BIT_SCD) {
1736
			IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
1737
				      "the frame/frames.\n");
1738 1739
			priv->isr_stats.sch++;
		}
Z
Zhu Yi 已提交
1740 1741

		/* Alive notification via Rx interrupt will do the real work */
1742
		if (inta & CSR_INT_BIT_ALIVE) {
1743
			IWL_DEBUG_ISR(priv, "Alive interrupt\n");
1744 1745
			priv->isr_stats.alive++;
		}
Z
Zhu Yi 已提交
1746 1747 1748
	}
#endif
	/* Safely ignore these bits for debug checks below */
1749
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
1750 1751 1752

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
1753 1754
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
1755 1756
		priv->isr_stats.sw++;
		priv->isr_stats.sw_err = inta;
1757
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1758 1759 1760 1761 1762
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
1763
		IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
1764
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
1765 1766 1767 1768 1769 1770
		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 已提交
1771

1772
		priv->isr_stats.wakeup++;
Z
Zhu Yi 已提交
1773 1774 1775 1776 1777 1778 1779
		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 已提交
1780
		iwl3945_rx_handle(priv);
1781
		priv->isr_stats.rx++;
Z
Zhu Yi 已提交
1782 1783 1784 1785
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

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

1789
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
M
Mohamed Abbas 已提交
1790 1791
		iwl_write_direct32(priv, FH39_TCSR_CREDIT
					(FH39_SRVC_CHNL), 0x0);
Z
Zhu Yi 已提交
1792 1793 1794
		handled |= CSR_INT_BIT_FH_TX;
	}

1795
	if (inta & ~handled) {
1796
		IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
1797 1798
		priv->isr_stats.unhandled++;
	}
Z
Zhu Yi 已提交
1799

1800
	if (inta & ~priv->inta_mask) {
1801
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
1802
			 inta & ~priv->inta_mask);
1803
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
1804 1805 1806
	}

	/* Re-enable all interrupts */
1807 1808
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
1809
		iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
1810

S
Samuel Ortiz 已提交
1811
#ifdef CONFIG_IWLWIFI_DEBUG
1812
	if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
1813 1814 1815
		inta = iwl_read32(priv, CSR_INT);
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
1816
		IWL_DEBUG_ISR(priv, "End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
Z
Zhu Yi 已提交
1817 1818 1819 1820 1821
			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
	}
#endif
}

1822
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
1823
					 enum ieee80211_band band,
1824
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
1825
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
1826
{
1827
	struct ieee80211_channel *chan;
1828
	const struct ieee80211_supported_band *sband;
1829
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
1830 1831 1832 1833
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
1834
	sband = iwl_get_hw_mode(priv, band);
1835
	if (!sband)
Z
Zhu Yi 已提交
1836 1837
		return 0;

S
Samuel Ortiz 已提交
1838 1839
	active_dwell = iwl_get_active_dwell_time(priv, band, n_probes);
	passive_dwell = iwl_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
1840

1841 1842 1843
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

1844 1845 1846 1847
	for (i = 0, added = 0; i < priv->scan_request->n_channels; i++) {
		chan = priv->scan_request->channels[i];

		if (chan->band != band)
1848 1849
			continue;

1850
		scan_ch->channel = chan->hw_value;
Z
Zhu Yi 已提交
1851

1852
		ch_info = iwl_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
1853
		if (!is_channel_valid(ch_info)) {
1854
			IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
1855 1856 1857 1858
				       scan_ch->channel);
			continue;
		}

1859 1860 1861 1862 1863
		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 已提交
1864
		if (!is_active || is_channel_passive(ch_info) ||
1865
		    (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
1866
			scan_ch->type = 0;	/* passive */
1867 1868 1869
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
1870
			scan_ch->type = 1;	/* active */
1871
		}
Z
Zhu Yi 已提交
1872

1873 1874 1875 1876 1877 1878
		/* 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)
1879
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
1880 1881 1882 1883
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
1884
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
1885
		}
Z
Zhu Yi 已提交
1886

1887
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
1888 1889 1890 1891
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
1892
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
1893 1894 1895 1896
			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
1897
			 * power level:
1898
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
1899 1900 1901
			 */
		}

1902
		IWL_DEBUG_SCAN(priv, "Scanning %d [%s %d]\n",
Z
Zhu Yi 已提交
1903 1904 1905 1906 1907 1908 1909 1910 1911
			       scan_ch->channel,
			       (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
			       (scan_ch->type & 1) ?
			       active_dwell : passive_dwell);

		scan_ch++;
		added++;
	}

1912
	IWL_DEBUG_SCAN(priv, "total channels to scan %d \n", added);
Z
Zhu Yi 已提交
1913 1914 1915
	return added;
}

1916
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1917 1918 1919 1920 1921
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
1922 1923 1924 1925
		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;
1926
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
1927
			/*
1928
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
1929
			 */
C
Christoph Hellwig 已提交
1930
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
1931
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
		}
	}
}

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

1942
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1943
{
1944 1945 1946 1947 1948 1949
	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 已提交
1950 1951 1952
}

/**
C
Christoph Hellwig 已提交
1953
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
1954 1955
 *     looking at all data.
 */
1956
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
1957 1958 1959 1960 1961 1962
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

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

1965
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
1966
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
1967 1968 1969 1970 1971 1972

	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 */
1973
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
1974
		if (val != le32_to_cpu(*image)) {
1975
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986
				  "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)
1987 1988
		IWL_DEBUG_INFO(priv,
			"ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
1989 1990 1991 1992 1993 1994

	return rc;
}


/**
C
Christoph Hellwig 已提交
1995
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
1996 1997 1998
 *   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.
 */
1999
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2000 2001 2002 2003 2004 2005
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

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

	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 */
2012
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
2013
			i + IWL39_RTC_INST_LOWER_BOUND);
2014
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
2015 2016
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
2017
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
				  "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 已提交
2033
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
2034 2035
 *    and verify its contents
 */
2036
static int iwl3945_verify_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2037 2038 2039 2040 2041 2042 2043 2044
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2045
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2046
	if (rc == 0) {
2047
		IWL_DEBUG_INFO(priv, "Bootstrap uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2048 2049 2050 2051 2052 2053
		return 0;
	}

	/* Try initialize */
	image = (__le32 *)priv->ucode_init.v_addr;
	len = priv->ucode_init.len;
C
Christoph Hellwig 已提交
2054
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2055
	if (rc == 0) {
2056
		IWL_DEBUG_INFO(priv, "Initialize uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2057 2058 2059 2060 2061 2062
		return 0;
	}

	/* Try runtime/protocol */
	image = (__le32 *)priv->ucode_code.v_addr;
	len = priv->ucode_code.len;
C
Christoph Hellwig 已提交
2063
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2064
	if (rc == 0) {
2065
		IWL_DEBUG_INFO(priv, "Runtime uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2066 2067 2068
		return 0;
	}

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

2071 2072 2073
	/* 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 已提交
2074 2075
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2076
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
2077 2078 2079 2080

	return rc;
}

2081
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2082 2083
{
	/* Remove all resets to allow NIC to operate */
2084
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
2085 2086 2087
}

/**
C
Christoph Hellwig 已提交
2088
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
2089 2090 2091
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
2092
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2093
{
2094
	const struct iwl_ucode_header *ucode;
2095
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
2096 2097
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
2098 2099 2100 2101
	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 已提交
2102 2103
	u8 *src;
	size_t len;
2104
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
2105 2106 2107

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
2108 2109 2110 2111
	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) {
2112
			IWL_ERR(priv, "%s firmware file req failed: %d\n",
2113 2114 2115 2116 2117 2118 2119
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
2120 2121 2122
				IWL_ERR(priv, "Loaded firmware %s, "
					"which is deprecated. "
					" Please use API v%u instead.\n",
2123
					  buf, api_max);
2124 2125
			IWL_DEBUG_INFO(priv, "Got firmware '%s' file "
				       "(%zd bytes) from disk\n",
2126 2127 2128
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
2129 2130
	}

2131 2132
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
2133 2134

	/* Make sure that we got at least our header! */
2135
	if (ucode_raw->size <  priv->cfg->ops->ucode->get_header_size(1)) {
2136
		IWL_ERR(priv, "File size way too small!\n");
2137
		ret = -EINVAL;
Z
Zhu Yi 已提交
2138 2139 2140 2141
		goto err_release;
	}

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

2144
	priv->ucode_ver = le32_to_cpu(ucode->ver);
2145
	api_ver = IWL_UCODE_API(priv->ucode_ver);
2146 2147 2148 2149 2150 2151 2152
	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 已提交
2153

2154 2155
	/* api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
2156
	 * on the API version read from firmware header from here on forward */
2157 2158

	if (api_ver < api_min || api_ver > api_max) {
2159
		IWL_ERR(priv, "Driver unable to support your firmware API. "
2160 2161 2162 2163 2164 2165 2166
			  "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)
2167
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
2168 2169 2170 2171
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
2172 2173 2174 2175 2176 2177
	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));

2178 2179 2180 2181 2182 2183 2184 2185
	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));

2186
	IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
2187
		       priv->ucode_ver);
2188 2189 2190 2191 2192 2193 2194 2195 2196 2197
	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 已提交
2198

2199

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

2205 2206 2207
		IWL_DEBUG_INFO(priv,
			"uCode file size %zd does not match expected size\n",
			ucode_raw->size);
2208
		ret = -EINVAL;
Z
Zhu Yi 已提交
2209 2210 2211 2212
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
2213
	if (inst_size > IWL39_MAX_INST_SIZE) {
2214
		IWL_DEBUG_INFO(priv, "uCode instr len %d too large to fit in\n",
2215 2216
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2217 2218 2219
		goto err_release;
	}

2220
	if (data_size > IWL39_MAX_DATA_SIZE) {
2221
		IWL_DEBUG_INFO(priv, "uCode data len %d too large to fit in\n",
2222 2223
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2224 2225
		goto err_release;
	}
2226
	if (init_size > IWL39_MAX_INST_SIZE) {
2227 2228
		IWL_DEBUG_INFO(priv,
				"uCode init instr len %d too large to fit in\n",
2229 2230
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2231 2232
		goto err_release;
	}
2233
	if (init_data_size > IWL39_MAX_DATA_SIZE) {
2234 2235
		IWL_DEBUG_INFO(priv,
				"uCode init data len %d too large to fit in\n",
2236 2237
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2238 2239
		goto err_release;
	}
2240
	if (boot_size > IWL39_MAX_BSM_SIZE) {
2241 2242
		IWL_DEBUG_INFO(priv,
				"uCode boot instr len %d too large to fit in\n",
2243 2244
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2245 2246 2247 2248 2249 2250 2251 2252 2253
		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;
2254
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
2255 2256

	priv->ucode_data.len = data_size;
2257
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
2258 2259

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

2262 2263 2264
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
2265 2266

	/* Initialization instructions and data */
2267 2268
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
2269
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
2270 2271

		priv->ucode_init_data.len = init_data_size;
2272
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
2273 2274 2275 2276

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

	/* Bootstrap (instructions only, no data) */
2279 2280
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
2281
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
2282

2283 2284 2285
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
2286 2287 2288 2289

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

	/* Runtime instructions (first block of data in file) */
2290
	len = inst_size;
2291 2292
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode instr len %zd\n", len);
Z
Zhu Yi 已提交
2293
	memcpy(priv->ucode_code.v_addr, src, len);
2294 2295
	src += len;

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

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
2300
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
2301
	len = data_size;
2302 2303
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode data len %zd\n", len);
Z
Zhu Yi 已提交
2304 2305
	memcpy(priv->ucode_data.v_addr, src, len);
	memcpy(priv->ucode_data_backup.v_addr, src, len);
2306
	src += len;
Z
Zhu Yi 已提交
2307 2308 2309

	/* Initialization instructions (3rd block) */
	if (init_size) {
2310
		len = init_size;
2311 2312
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init instr len %zd\n", len);
Z
Zhu Yi 已提交
2313
		memcpy(priv->ucode_init.v_addr, src, len);
2314
		src += len;
Z
Zhu Yi 已提交
2315 2316 2317 2318
	}

	/* Initialization data (4th block) */
	if (init_data_size) {
2319
		len = init_data_size;
2320 2321
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init data len %zd\n", len);
Z
Zhu Yi 已提交
2322
		memcpy(priv->ucode_init_data.v_addr, src, len);
2323
		src += len;
Z
Zhu Yi 已提交
2324 2325 2326
	}

	/* Bootstrap instructions (5th block) */
2327
	len = boot_size;
2328 2329
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) boot instr len %zd\n", len);
Z
Zhu Yi 已提交
2330 2331 2332 2333 2334 2335 2336
	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:
2337
	IWL_ERR(priv, "failed to allocate pci memory\n");
2338
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
2339
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
2340 2341 2342 2343 2344

 err_release:
	release_firmware(ucode_raw);

 error:
2345
	return ret;
Z
Zhu Yi 已提交
2346 2347 2348 2349
}


/**
C
Christoph Hellwig 已提交
2350
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
2351 2352 2353 2354 2355 2356 2357
 *
 * 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.
 */
2358
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2359 2360 2361 2362 2363 2364 2365 2366 2367
{
	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 */
2368 2369 2370
	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 已提交
2371 2372
				 priv->ucode_data.len);

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

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

M
Mohamed Abbas 已提交
2380
	return 0;
Z
Zhu Yi 已提交
2381 2382 2383
}

/**
C
Christoph Hellwig 已提交
2384
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2385 2386 2387 2388
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
2389
 */
2390
static void iwl3945_init_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2391 2392 2393 2394 2395
{
	/* 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 */
2396
		IWL_DEBUG_INFO(priv, "Initialize Alive failed.\n");
Z
Zhu Yi 已提交
2397 2398 2399 2400 2401 2402
		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 已提交
2403
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2404 2405
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2406
		IWL_DEBUG_INFO(priv, "Bad \"initialize\" uCode load.\n");
Z
Zhu Yi 已提交
2407 2408 2409 2410 2411 2412
		goto restart;
	}

	/* Send pointers to protocol/runtime uCode image ... init code will
	 * load and launch runtime uCode, which will send us another "Alive"
	 * notification. */
2413
	IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
C
Christoph Hellwig 已提交
2414
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
2415 2416
		/* Runtime instruction load won't happen;
		 * take it all the way back down so we can try again */
2417
		IWL_DEBUG_INFO(priv, "Couldn't set up uCode pointers.\n");
Z
Zhu Yi 已提交
2418 2419 2420 2421 2422 2423 2424 2425 2426
		goto restart;
	}
	return;

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

/**
C
Christoph Hellwig 已提交
2427
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2428
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
2429
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
2430
 */
2431
static void iwl3945_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2432 2433 2434 2435
{
	int thermal_spin = 0;
	u32 rfkill;

2436
	IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
2437 2438 2439 2440

	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 */
2441
		IWL_DEBUG_INFO(priv, "Alive failed.\n");
Z
Zhu Yi 已提交
2442 2443 2444 2445 2446 2447
		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 已提交
2448
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2449 2450
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2451
		IWL_DEBUG_INFO(priv, "Bad runtime uCode load.\n");
Z
Zhu Yi 已提交
2452 2453 2454
		goto restart;
	}

2455
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2456

2457
	rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
2458
	IWL_DEBUG_INFO(priv, "RFKILL status: 0x%x\n", rfkill);
Z
Zhu Yi 已提交
2459 2460 2461

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
2462
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
2463
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
2464
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
2465 2466 2467 2468 2469
			thermal_spin++;
			udelay(10);
		}

		if (thermal_spin)
2470
			IWL_DEBUG_INFO(priv, "Thermal calibration took %dus\n",
Z
Zhu Yi 已提交
2471 2472 2473 2474
				       thermal_spin * 10);
	} else
		set_bit(STATUS_RF_KILL_HW, &priv->status);

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

2478
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
2479 2480
		return;

2481
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
2482 2483 2484 2485

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

2486
	iwl_power_update_mode(priv, false);
Z
Zhu Yi 已提交
2487

2488
	if (iwl_is_associated(priv)) {
C
Christoph Hellwig 已提交
2489
		struct iwl3945_rxon_cmd *active_rxon =
2490
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
2491

2492
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
Z
Zhu Yi 已提交
2493 2494 2495
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
2496
		iwl_connection_init_rx_config(priv, priv->iw_mode);
Z
Zhu Yi 已提交
2497 2498
	}

2499
	/* Configure Bluetooth device coexistence support */
2500
	iwl_send_bt_config(priv);
Z
Zhu Yi 已提交
2501 2502

	/* Configure the adapter for unassociated operation */
A
Abhijeet Kolekar 已提交
2503
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
2504 2505 2506

	iwl3945_reg_txpower_periodic(priv);

J
Johannes Berg 已提交
2507
	iwl_leds_init(priv);
2508

2509
	IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
2510
	set_bit(STATUS_READY, &priv->status);
2511
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
2512

2513 2514 2515 2516 2517
	/* reassociate for ADHOC mode */
	if (priv->vif && (priv->iw_mode == NL80211_IFTYPE_ADHOC)) {
		struct sk_buff *beacon = ieee80211_beacon_get(priv->hw,
								priv->vif);
		if (beacon)
2518
			iwl_mac_beacon_update(priv->hw, beacon);
2519 2520
	}

A
Abhijeet Kolekar 已提交
2521
	if (test_and_clear_bit(STATUS_MODE_PENDING, &priv->status))
2522
		iwl_set_mode(priv, priv->iw_mode);
A
Abhijeet Kolekar 已提交
2523

Z
Zhu Yi 已提交
2524 2525 2526 2527 2528 2529
	return;

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

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

2532
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2533 2534 2535 2536 2537
{
	unsigned long flags;
	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
	struct ieee80211_conf *conf = NULL;

2538
	IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
Z
Zhu Yi 已提交
2539 2540 2541 2542 2543 2544

	conf = ieee80211_get_hw_conf(priv->hw);

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

2545
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2546 2547 2548 2549 2550 2551 2552 2553 2554 2555

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

	/* tell the device to stop sending interrupts */
2559
	spin_lock_irqsave(&priv->lock, flags);
2560
	iwl_disable_interrupts(priv);
2561 2562
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
2563 2564 2565 2566

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

C
Christoph Hellwig 已提交
2567
	/* If we have not previously called iwl3945_init() then
2568
	 * clear all bits but the RF Kill bits and return */
2569
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
2570 2571
		priv->status = test_bit(STATUS_RF_KILL_HW, &priv->status) <<
					STATUS_RF_KILL_HW |
2572 2573
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
2574 2575
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2576 2577 2578
		goto exit;
	}

2579
	/* ...otherwise clear out all the status bits but the RF Kill
J
Johannes Berg 已提交
2580
	 * bit and continue taking the NIC down. */
Z
Zhu Yi 已提交
2581 2582
	priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
				STATUS_RF_KILL_HW |
2583 2584
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
2585
			test_bit(STATUS_FW_ERROR, &priv->status) <<
2586 2587 2588
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2589

C
Christoph Hellwig 已提交
2590 2591
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
2592

M
Mohamed Abbas 已提交
2593 2594
	iwl_write_prph(priv, APMG_CLK_DIS_REG,
				APMG_CLK_VAL_DMA_CLK_RQT);
Z
Zhu Yi 已提交
2595 2596 2597

	udelay(5);

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

Z
Zhu Yi 已提交
2601
 exit:
2602
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
2603 2604 2605 2606 2607 2608

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
2609
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
2610 2611
}

2612
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2613 2614
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2615
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
2616
	mutex_unlock(&priv->mutex);
2617

C
Christoph Hellwig 已提交
2618
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
2619 2620 2621 2622
}

#define MAX_HW_RESTARTS 5

2623
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2624 2625 2626 2627
{
	int rc, i;

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

2632
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
2633
		IWL_ERR(priv, "ucode not available for device bring up\n");
2634 2635 2636
		return -EIO;
	}

2637
	/* If platform's RF_KILL switch is NOT set to KILL */
2638
	if (iwl_read32(priv, CSR_GP_CNTRL) &
2639 2640 2641 2642
				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);
2643 2644
		IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
		return -ENODEV;
Z
Zhu Yi 已提交
2645
	}
2646

2647
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
2648

C
Christoph Hellwig 已提交
2649
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
2650
	if (rc) {
2651
		IWL_ERR(priv, "Unable to int nic\n");
Z
Zhu Yi 已提交
2652 2653 2654 2655
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
2656 2657
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
2658 2659 2660
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
2661
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2662
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
2663 2664

	/* really make sure rfkill handshake bits are cleared */
2665 2666
	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 已提交
2667 2668 2669 2670 2671

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

2674 2675 2676 2677
	/* 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 已提交
2678 2679
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

2680
		iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2681 2682 2683 2684

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

		if (rc) {
2688 2689
			IWL_ERR(priv,
				"Unable to set up bootstrap uCode: %d\n", rc);
Z
Zhu Yi 已提交
2690 2691 2692 2693
			continue;
		}

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

2696
		IWL_DEBUG_INFO(priv, DRV_NAME " is coming up\n");
Z
Zhu Yi 已提交
2697 2698 2699 2700 2701

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
2702
	__iwl3945_down(priv);
2703
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
2704 2705 2706

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
2707
	IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
Z
Zhu Yi 已提交
2708 2709 2710 2711 2712 2713 2714 2715 2716 2717
	return -EIO;
}


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

C
Christoph Hellwig 已提交
2718
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2719
{
2720 2721
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, init_alive_start.work);
Z
Zhu Yi 已提交
2722 2723 2724 2725 2726

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2727
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
2728 2729 2730
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
2731
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2732
{
2733 2734
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, alive_start.work);
Z
Zhu Yi 已提交
2735 2736 2737 2738 2739

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2740
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
2741 2742 2743
	mutex_unlock(&priv->mutex);
}

2744 2745 2746 2747 2748 2749
/*
 * 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).
 */
2750 2751 2752 2753
static void iwl3945_rfkill_poll(struct work_struct *data)
{
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rfkill_poll.work);
2754 2755 2756
	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);
2757

2758 2759 2760 2761 2762
	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);
2763

2764 2765 2766 2767 2768
		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");
	}
2769

2770 2771
	/* Keep this running, even if radio now enabled.  This will be
	 * cancelled in mac_start() if system decides to start again */
2772 2773 2774 2775 2776
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   round_jiffies_relative(2 * HZ));

}

Z
Zhu Yi 已提交
2777
#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)
C
Christoph Hellwig 已提交
2778
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
2779
{
2780 2781
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
2782
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
2783
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
2784
		.len = sizeof(struct iwl3945_scan_cmd),
J
Johannes Berg 已提交
2785
		.flags = CMD_SIZE_HUGE,
Z
Zhu Yi 已提交
2786 2787
	};
	int rc = 0;
C
Christoph Hellwig 已提交
2788
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
2789
	struct ieee80211_conf *conf = NULL;
J
Johannes Berg 已提交
2790
	u8 n_probes = 0;
2791
	enum ieee80211_band band;
J
Johannes Berg 已提交
2792
	bool is_active = false;
Z
Zhu Yi 已提交
2793 2794 2795 2796 2797

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

2798 2799
	cancel_delayed_work(&priv->scan_check);

2800
	if (!iwl_is_ready(priv)) {
2801
		IWL_WARN(priv, "request scan called when driver not ready.\n");
Z
Zhu Yi 已提交
2802 2803 2804
		goto done;
	}

T
Tomas Winkler 已提交
2805
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
2806 2807 2808 2809 2810 2811 2812
	 * 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)) {
2813 2814
		IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests  "
				"Ignoring second request.\n");
Z
Zhu Yi 已提交
2815 2816 2817 2818 2819
		rc = -EIO;
		goto done;
	}

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
2820
		IWL_DEBUG_SCAN(priv, "Aborting scan due to device shutdown\n");
Z
Zhu Yi 已提交
2821 2822 2823 2824
		goto done;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
2825 2826
		IWL_DEBUG_HC(priv,
			"Scan request while abort pending. Queuing.\n");
Z
Zhu Yi 已提交
2827 2828 2829
		goto done;
	}

2830
	if (iwl_is_rfkill(priv)) {
2831
		IWL_DEBUG_HC(priv, "Aborting scan due to RF Kill activation\n");
Z
Zhu Yi 已提交
2832 2833 2834 2835
		goto done;
	}

	if (!test_bit(STATUS_READY, &priv->status)) {
2836 2837
		IWL_DEBUG_HC(priv,
			"Scan request while uninitialized. Queuing.\n");
Z
Zhu Yi 已提交
2838 2839 2840 2841
		goto done;
	}

	if (!priv->scan_bands) {
2842
		IWL_DEBUG_HC(priv, "Aborting scan due to no requested bands\n");
Z
Zhu Yi 已提交
2843 2844 2845
		goto done;
	}

W
Winkler, Tomas 已提交
2846 2847
	if (!priv->scan) {
		priv->scan = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
2848
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
W
Winkler, Tomas 已提交
2849
		if (!priv->scan) {
Z
Zhu Yi 已提交
2850 2851 2852 2853
			rc = -ENOMEM;
			goto done;
		}
	}
W
Winkler, Tomas 已提交
2854
	scan = priv->scan;
C
Christoph Hellwig 已提交
2855
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
2856 2857 2858 2859

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

2860
	if (iwl_is_associated(priv)) {
Z
Zhu Yi 已提交
2861 2862 2863 2864 2865 2866
		u16 interval = 0;
		u32 extra;
		u32 suspend_time = 100;
		u32 scan_suspend_time = 100;
		unsigned long flags;

2867
		IWL_DEBUG_INFO(priv, "Scanning while associated...\n");
Z
Zhu Yi 已提交
2868 2869 2870 2871 2872 2873

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

		scan->suspend_time = 0;
2874
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888
		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);
2889
		IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n",
Z
Zhu Yi 已提交
2890 2891 2892
			       scan_suspend_time, interval);
	}

J
Johannes Berg 已提交
2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909
	if (priv->scan_request->n_ssids) {
		int i, p = 0;
		IWL_DEBUG_SCAN(priv, "Kicking off active scan\n");
		for (i = 0; i < priv->scan_request->n_ssids; i++) {
			/* always does wildcard anyway */
			if (!priv->scan_request->ssids[i].ssid_len)
				continue;
			scan->direct_scan[p].id = WLAN_EID_SSID;
			scan->direct_scan[p].len =
				priv->scan_request->ssids[i].ssid_len;
			memcpy(scan->direct_scan[p].ssid,
			       priv->scan_request->ssids[i].ssid,
			       priv->scan_request->ssids[i].ssid_len);
			n_probes++;
			p++;
		}
		is_active = true;
2910
	} else
J
Johannes Berg 已提交
2911
		IWL_DEBUG_SCAN(priv, "Kicking off passive scan.\n");
Z
Zhu Yi 已提交
2912 2913 2914 2915

	/* 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;
2916
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
2917 2918 2919 2920
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

2921
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
2922 2923 2924
		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;
2925
		band = IEEE80211_BAND_2GHZ;
2926
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
2927
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
2928 2929 2930 2931 2932 2933
		/*
		 * 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;
2934
		band = IEEE80211_BAND_5GHZ;
2935
	} else {
2936
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
2937 2938 2939
		goto done;
	}

S
Samuel Ortiz 已提交
2940
	scan->tx_cmd.len = cpu_to_le16(
J
Johannes Berg 已提交
2941 2942 2943 2944 2945
			iwl_fill_probe_req(priv,
				(struct ieee80211_mgmt *)scan->data,
				priv->scan_request->ie,
				priv->scan_request->ie_len,
				IWL_MAX_SCAN_SIZE - sizeof(*scan)));
S
Samuel Ortiz 已提交
2946

Z
Zhu Yi 已提交
2947 2948 2949
	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

2950
	if (iwl_is_monitor_mode(priv))
Z
Zhu Yi 已提交
2951 2952
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

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

2957
	if (scan->channel_count == 0) {
2958
		IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count);
2959 2960 2961
		goto done;
	}

Z
Zhu Yi 已提交
2962
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
2963
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
2964 2965 2966 2967
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
2968
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
2969 2970 2971 2972 2973 2974 2975 2976 2977 2978
	if (rc)
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
2979 2980 2981 2982 2983 2984 2985 2986
	/* 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);

2987
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
2988 2989 2990 2991
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
2992
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
2993
{
2994
	struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
Z
Zhu Yi 已提交
2995 2996 2997 2998 2999

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3000
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
3001 3002 3003
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
3004
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
3005
{
3006
	struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
Z
Zhu Yi 已提交
3007 3008 3009 3010

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

J
Johannes Berg 已提交
3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021
	if (test_and_clear_bit(STATUS_FW_ERROR, &priv->status)) {
		mutex_lock(&priv->mutex);
		priv->vif = NULL;
		priv->is_open = 0;
		mutex_unlock(&priv->mutex);
		iwl3945_down(priv);
		ieee80211_restart_hw(priv->hw);
	} else {
		iwl3945_down(priv);
		queue_work(priv->workqueue, &priv->up);
	}
Z
Zhu Yi 已提交
3022 3023
}

C
Christoph Hellwig 已提交
3024
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
3025
{
3026 3027
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rx_replenish);
Z
Zhu Yi 已提交
3028 3029 3030 3031 3032

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
3033
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
3034 3035 3036
	mutex_unlock(&priv->mutex);
}

3037 3038
#define IWL_DELAY_NEXT_SCAN (HZ*2)

3039
void iwl3945_post_associate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3040 3041 3042 3043
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

3044
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
3045
		IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
3046 3047 3048 3049
		return;
	}


3050
	IWL_DEBUG_ASSOC(priv, "Associated as %d to: %pM\n",
3051
			priv->assoc_id, priv->active_rxon.bssid_addr);
Z
Zhu Yi 已提交
3052 3053 3054 3055

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

A
Abhijeet Kolekar 已提交
3056
	if (!priv->vif || !priv->is_open)
3057
		return;
A
Abhijeet Kolekar 已提交
3058

3059
	iwl_scan_cancel_timeout(priv, 200);
3060

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

3063
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3064
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3065

3066
	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
3067
	iwl_setup_rxon_timing(priv);
3068
	rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
3069 3070
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
3071
		IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3072 3073
			    "Attempting to continue.\n");

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

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

3078
	IWL_DEBUG_ASSOC(priv, "assoc id %d beacon interval %d\n",
Z
Zhu Yi 已提交
3079 3080 3081
			priv->assoc_id, priv->beacon_int);

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3082
		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3083
	else
3084
		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3085

3086
	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3087
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
3088
			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3089
		else
3090
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3091

3092
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3093
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3094 3095 3096

	}

A
Abhijeet Kolekar 已提交
3097
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3098 3099

	switch (priv->iw_mode) {
3100
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
3101
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
3102 3103
		break;

3104
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
3105

3106
		priv->assoc_id = 1;
3107
		iwl_add_station(priv, priv->bssid, 0, CMD_SYNC, NULL);
Z
Zhu Yi 已提交
3108
		iwl3945_sync_sta(priv, IWL_STA_ID,
3109
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
3110 3111
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
3112 3113
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3114 3115 3116 3117

		break;

	default:
3118
		 IWL_ERR(priv, "%s Should not be called in %d mode\n",
3119
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
3120 3121 3122
		break;
	}

3123
	iwl_activate_qos(priv, 0);
3124

3125 3126
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
3127 3128
}

Z
Zhu Yi 已提交
3129 3130 3131 3132 3133 3134
/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

3135 3136
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
3137
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3138
{
3139
	struct iwl_priv *priv = hw->priv;
3140
	int ret;
Z
Zhu Yi 已提交
3141

3142
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3143 3144 3145 3146

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

3147 3148 3149 3150 3151 3152
	/* 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) {
3153
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
3154 3155 3156 3157
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
3158

3159
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
3160 3161

	mutex_unlock(&priv->mutex);
3162

3163 3164 3165
	if (ret)
		goto out_release_irq;

3166
	IWL_DEBUG_INFO(priv, "Start UP work.\n");
3167

3168 3169 3170 3171 3172 3173 3174
	/* 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)) {
3175 3176 3177
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
3178 3179 3180 3181 3182
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

3183 3184 3185 3186
	/* ucode is running and will send rfkill notifications,
	 * no need to poll the killswitch state anymore */
	cancel_delayed_work(&priv->rfkill_poll);

J
Johannes Berg 已提交
3187 3188
	iwl_led_start(priv);

3189
	priv->is_open = 1;
3190
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3191
	return 0;
3192 3193

out_release_irq:
3194
	priv->is_open = 0;
3195
	IWL_DEBUG_MAC80211(priv, "leave - failed\n");
3196
	return ret;
Z
Zhu Yi 已提交
3197 3198
}

C
Christoph Hellwig 已提交
3199
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3200
{
3201
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3202

3203
	IWL_DEBUG_MAC80211(priv, "enter\n");
3204

3205
	if (!priv->is_open) {
3206
		IWL_DEBUG_MAC80211(priv, "leave - skip\n");
3207 3208 3209
		return;
	}

Z
Zhu Yi 已提交
3210
	priv->is_open = 0;
3211

3212
	if (iwl_is_ready_rf(priv)) {
3213 3214 3215
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
3216
		mutex_lock(&priv->mutex);
3217
		iwl_scan_cancel_timeout(priv, 100);
3218 3219 3220
		mutex_unlock(&priv->mutex);
	}

3221 3222 3223
	iwl3945_down(priv);

	flush_workqueue(priv->workqueue);
3224 3225 3226 3227

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

3229
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3230 3231
}

3232
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
3233
{
3234
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3235

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

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

3241
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
3242 3243
		dev_kfree_skb_any(skb);

3244
	IWL_DEBUG_MAC80211(priv, "leave\n");
3245
	return NETDEV_TX_OK;
Z
Zhu Yi 已提交
3246 3247
}

A
Abhijeet Kolekar 已提交
3248
void iwl3945_config_ap(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3249 3250 3251
{
	int rc = 0;

3252
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
3253 3254 3255
		return;

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

		/* RXON - unassoc (to set timing command) */
3259
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3260
		iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3261 3262

		/* RXON Timing */
3263
		memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
3264
		iwl_setup_rxon_timing(priv);
3265 3266 3267
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
				      sizeof(priv->rxon_timing),
				      &priv->rxon_timing);
Z
Zhu Yi 已提交
3268
		if (rc)
3269
			IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3270 3271 3272
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
3273
		priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
3274
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3275
			priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3276 3277
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
3278
			priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3279 3280
				~RXON_FLG_SHORT_PREAMBLE_MSK;

3281
		if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3282 3283
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
3284
				priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3285 3286
					RXON_FLG_SHORT_SLOT_MSK;
			else
3287
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3288 3289
					~RXON_FLG_SHORT_SLOT_MSK;

3290
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3291
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3292 3293 3294
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
3295
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3296
		iwlcore_commit_rxon(priv);
3297
		iwl_add_station(priv, iwl_bcast_addr, 0, CMD_SYNC, NULL);
3298
	}
C
Christoph Hellwig 已提交
3299
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3300 3301 3302 3303 3304 3305

	/* 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 已提交
3306
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3307 3308 3309
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
Z
Zhu Yi 已提交
3310
{
3311
	struct iwl_priv *priv = hw->priv;
3312
	const u8 *addr;
3313 3314 3315
	int ret = 0;
	u8 sta_id = IWL_INVALID_STATION;
	u8 static_key;
Z
Zhu Yi 已提交
3316

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

3319
	if (iwl3945_mod_params.sw_crypto) {
3320
		IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
Z
Zhu Yi 已提交
3321 3322 3323
		return -EOPNOTSUPP;
	}

3324
	addr = sta ? sta->addr : iwl_bcast_addr;
3325 3326 3327
	static_key = !iwl_is_associated(priv);

	if (!static_key) {
3328
		sta_id = iwl_find_station(priv, addr);
3329
		if (sta_id == IWL_INVALID_STATION) {
3330
			IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
3331 3332 3333
					    addr);
			return -EINVAL;
		}
Z
Zhu Yi 已提交
3334 3335 3336
	}

	mutex_lock(&priv->mutex);
3337
	iwl_scan_cancel_timeout(priv, 100);
3338
	mutex_unlock(&priv->mutex);
3339

Z
Zhu Yi 已提交
3340
	switch (cmd) {
3341 3342 3343 3344 3345 3346
	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 已提交
3347 3348
		break;
	case DISABLE_KEY:
3349 3350 3351 3352 3353
		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 已提交
3354 3355
		break;
	default:
3356
		ret = -EINVAL;
Z
Zhu Yi 已提交
3357 3358
	}

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

3361
	return ret;
Z
Zhu Yi 已提交
3362 3363 3364 3365 3366 3367 3368 3369
}

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

S
Samuel Ortiz 已提交
3370
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
3371 3372 3373 3374 3375 3376 3377

/*
 * 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.
3378
 *
3379 3380 3381
 * 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 已提交
3382
 */
3383 3384
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
3385
{
3386 3387
	struct iwl_priv *priv = dev_get_drvdata(d);
	return sprintf(buf, "0x%08X\n", iwl_get_debug_level(priv));
Z
Zhu Yi 已提交
3388
}
3389 3390
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
3391 3392
				 const char *buf, size_t count)
{
3393
	struct iwl_priv *priv = dev_get_drvdata(d);
3394 3395
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
3396

3397 3398
	ret = strict_strtoul(buf, 0, &val);
	if (ret)
T
Tomas Winkler 已提交
3399
		IWL_INFO(priv, "%s is not in hex or decimal form.\n", buf);
3400
	else {
3401
		priv->debug_level = val;
3402 3403 3404 3405
		if (iwl_alloc_traffic_mem(priv))
			IWL_ERR(priv,
				"Not enough memory to generate traffic log\n");
	}
Z
Zhu Yi 已提交
3406 3407 3408
	return strnlen(buf, count);
}

3409 3410
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
3411

S
Samuel Ortiz 已提交
3412
#endif /* CONFIG_IWLWIFI_DEBUG */
Z
Zhu Yi 已提交
3413 3414 3415 3416

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

3419
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3420 3421
		return -EAGAIN;

C
Christoph Hellwig 已提交
3422
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
3423 3424 3425 3426 3427 3428 3429
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
3430
	struct iwl_priv *priv = dev_get_drvdata(d);
3431
	return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
Z
Zhu Yi 已提交
3432 3433 3434 3435 3436 3437
}

static ssize_t store_tx_power(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
3438
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3439 3440 3441 3442 3443
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
3444
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
3445
	else
C
Christoph Hellwig 已提交
3446
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
3447 3448 3449 3450 3451 3452 3453 3454 3455

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

3458
	return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
Z
Zhu Yi 已提交
3459 3460 3461 3462 3463 3464
}

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

	mutex_lock(&priv->mutex);
3469
	if (le32_to_cpu(priv->staging_rxon.flags) != flags) {
Z
Zhu Yi 已提交
3470
		/* Cancel any currently running scans... */
3471
		if (iwl_scan_cancel_timeout(priv, 100))
3472
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
3473
		else {
3474
			IWL_DEBUG_INFO(priv, "Committing rxon.flags = 0x%04X\n",
Z
Zhu Yi 已提交
3475
				       flags);
3476
			priv->staging_rxon.flags = cpu_to_le32(flags);
A
Abhijeet Kolekar 已提交
3477
			iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489
		}
	}
	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)
{
3490
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3491 3492

	return sprintf(buf, "0x%04X\n",
3493
		le32_to_cpu(priv->active_rxon.filter_flags));
Z
Zhu Yi 已提交
3494 3495 3496 3497 3498 3499
}

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

	mutex_lock(&priv->mutex);
3504
	if (le32_to_cpu(priv->staging_rxon.filter_flags) != filter_flags) {
Z
Zhu Yi 已提交
3505
		/* Cancel any currently running scans... */
3506
		if (iwl_scan_cancel_timeout(priv, 100))
3507
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
3508
		else {
3509
			IWL_DEBUG_INFO(priv, "Committing rxon.filter_flags = "
Z
Zhu Yi 已提交
3510
				       "0x%04X\n", filter_flags);
3511
			priv->staging_rxon.filter_flags =
Z
Zhu Yi 已提交
3512
				cpu_to_le32(filter_flags);
A
Abhijeet Kolekar 已提交
3513
			iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3514 3515 3516 3517 3518 3519 3520 3521 3522 3523
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

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

3524
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3525 3526 3527 3528

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
3529
	struct iwl_priv *priv = dev_get_drvdata(d);
3530
	struct iwl_spectrum_notification measure_report;
Z
Zhu Yi 已提交
3531
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
3532
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561
	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)
{
3562
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3563
	struct ieee80211_measurement_params params = {
3564
		.channel = le16_to_cpu(priv->active_rxon.channel),
Z
Zhu Yi 已提交
3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585
		.start_time = cpu_to_le64(priv->last_tsf),
		.duration = cpu_to_le16(1),
	};
	u8 type = IWL_MEASURE_BASIC;
	u8 buffer[32];
	u8 channel;

	if (count) {
		char *p = buffer;
		strncpy(buffer, buf, min(sizeof(buffer), count));
		channel = simple_strtoul(p, NULL, 0);
		if (channel)
			params.channel = channel;

		p = buffer;
		while (*p && *p != ' ')
			p++;
		if (*p)
			type = simple_strtoul(p + 1, NULL, 0);
	}

3586
	IWL_DEBUG_INFO(priv, "Invoking measurement of type %d on "
Z
Zhu Yi 已提交
3587
		       "channel %d (for '%s')\n", type, params.channel, buf);
C
Christoph Hellwig 已提交
3588
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
3589 3590 3591 3592 3593 3594

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
3595
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
3596 3597 3598 3599 3600

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
3601
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612

	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)
{
3613
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3614 3615 3616 3617 3618 3619
	return sprintf(buf, "%d", priv->retry_rate);
}

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

3620

Z
Zhu Yi 已提交
3621 3622 3623
static ssize_t show_channels(struct device *d,
			     struct device_attribute *attr, char *buf)
{
3624 3625
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
3626 3627 3628 3629 3630 3631 3632
}

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
3633
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
3634
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
3635
	u32 len = 0, ofs = 0;
3636
	u8 *data = (u8 *)&priv->statistics_39;
Z
Zhu Yi 已提交
3637 3638
	int rc = 0;

3639
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3640 3641 3642
		return -EAGAIN;

	mutex_lock(&priv->mutex);
3643
	rc = iwl_send_statistics_request(priv, 0);
Z
Zhu Yi 已提交
3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670
	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)
{
3671
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3672

3673
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3674 3675
		return -EAGAIN;

3676
	return sprintf(buf, "%d\n", iwl3945_mod_params.antenna);
Z
Zhu Yi 已提交
3677 3678 3679 3680 3681 3682
}

static ssize_t store_antenna(struct device *d,
			     struct device_attribute *attr,
			     const char *buf, size_t count)
{
3683
	struct iwl_priv *priv __maybe_unused = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3684 3685 3686 3687 3688 3689
	int ant;

	if (count == 0)
		return 0;

	if (sscanf(buf, "%1i", &ant) != 1) {
3690
		IWL_DEBUG_INFO(priv, "not in hex or decimal form.\n");
Z
Zhu Yi 已提交
3691 3692 3693 3694
		return count;
	}

	if ((ant >= 0) && (ant <= 2)) {
3695
		IWL_DEBUG_INFO(priv, "Setting antenna select to %d.\n", ant);
3696
		iwl3945_mod_params.antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
3697
	} else
3698
		IWL_DEBUG_INFO(priv, "Bad antenna select value %d.\n", ant);
Z
Zhu Yi 已提交
3699 3700 3701 3702 3703 3704 3705 3706 3707 3708


	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)
{
3709
	struct iwl_priv *priv = dev_get_drvdata(d);
3710
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3711 3712 3713 3714 3715 3716 3717 3718 3719 3720
		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)
{
3721
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3722 3723 3724
	char *p = (char *)buf;

	if (p[0] == '1')
3725
		iwl3945_dump_nic_error_log(priv);
Z
Zhu Yi 已提交
3726 3727 3728 3729 3730 3731 3732 3733

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
3734
 * driver setup and tear down
Z
Zhu Yi 已提交
3735 3736 3737
 *
 *****************************************************************************/

3738
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3739
{
3740
	priv->workqueue = create_singlethread_workqueue(DRV_NAME);
Z
Zhu Yi 已提交
3741 3742 3743

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
3744 3745 3746 3747 3748 3749
	INIT_WORK(&priv->up, iwl3945_bg_up);
	INIT_WORK(&priv->restart, iwl3945_bg_restart);
	INIT_WORK(&priv->rx_replenish, iwl3945_bg_rx_replenish);
	INIT_WORK(&priv->beacon_update, iwl3945_bg_beacon_update);
	INIT_DELAYED_WORK(&priv->init_alive_start, iwl3945_bg_init_alive_start);
	INIT_DELAYED_WORK(&priv->alive_start, iwl3945_bg_alive_start);
3750
	INIT_DELAYED_WORK(&priv->rfkill_poll, iwl3945_rfkill_poll);
S
Samuel Ortiz 已提交
3751 3752 3753 3754
	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 已提交
3755 3756

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
3757 3758

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

3762
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3763
{
C
Christoph Hellwig 已提交
3764
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
3765

3766
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
3767 3768 3769 3770 3771
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
3772
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
3773 3774 3775 3776 3777
	&dev_attr_antenna.attr,
	&dev_attr_channels.attr,
	&dev_attr_dump_errors.attr,
	&dev_attr_flags.attr,
	&dev_attr_filter_flags.attr,
3778
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3779 3780 3781 3782 3783 3784 3785
	&dev_attr_measurement.attr,
#endif
	&dev_attr_retry_rate.attr,
	&dev_attr_statistics.attr,
	&dev_attr_status.attr,
	&dev_attr_temperature.attr,
	&dev_attr_tx_power.attr,
S
Samuel Ortiz 已提交
3786
#ifdef CONFIG_IWLWIFI_DEBUG
3787 3788
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
3789 3790 3791
	NULL
};

C
Christoph Hellwig 已提交
3792
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
3793
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
3794
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
3795 3796
};

C
Christoph Hellwig 已提交
3797 3798 3799 3800
static struct ieee80211_ops iwl3945_hw_ops = {
	.tx = iwl3945_mac_tx,
	.start = iwl3945_mac_start,
	.stop = iwl3945_mac_stop,
3801
	.add_interface = iwl_mac_add_interface,
3802
	.remove_interface = iwl_mac_remove_interface,
3803
	.config = iwl_mac_config,
3804
	.configure_filter = iwl_configure_filter,
C
Christoph Hellwig 已提交
3805
	.set_key = iwl3945_mac_set_key,
3806
	.get_tx_stats = iwl_mac_get_tx_stats,
A
Abhijeet Kolekar 已提交
3807
	.conf_tx = iwl_mac_conf_tx,
3808
	.reset_tsf = iwl_mac_reset_tsf,
3809
	.bss_info_changed = iwl_bss_info_changed,
3810
	.hw_scan = iwl_mac_hw_scan
Z
Zhu Yi 已提交
3811 3812
};

3813
static int iwl3945_init_drv(struct iwl_priv *priv)
3814 3815
{
	int ret;
3816
	struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829

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

	spin_lock_init(&priv->lock);
	spin_lock_init(&priv->sta_lock);
	spin_lock_init(&priv->hcmd_lock);

	INIT_LIST_HEAD(&priv->free_frames);

	mutex_init(&priv->mutex);

	/* Clear the driver's (not device's) station table */
3830
	iwl_clear_stations_table(priv);
3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843

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

	priv->iw_mode = NL80211_IFTYPE_STATION;

	iwl_reset_qos(priv);

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

	priv->rates_mask = IWL_RATES_MASK;
3844
	priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
3845

3846 3847 3848 3849 3850 3851 3852
	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);
3853 3854 3855 3856 3857
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

3858 3859 3860 3861 3862 3863
	/* Set up txpower settings in driver for all channels */
	if (iwl3945_txpower_set_from_eeprom(priv)) {
		ret = -EIO;
		goto err_free_channel_map;
	}

3864
	ret = iwlcore_init_geos(priv);
3865 3866 3867 3868
	if (ret) {
		IWL_ERR(priv, "initializing geos failed: %d\n", ret);
		goto err_free_channel_map;
	}
3869 3870
	iwl3945_init_hw_rates(priv, priv->ieee_rates);

3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888
	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 已提交
3889
		    IEEE80211_HW_NOISE_DBM |
3890 3891 3892
		    IEEE80211_HW_SPECTRUM_MGMT |
		    IEEE80211_HW_SUPPORTS_PS |
		    IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
3893 3894 3895 3896 3897 3898 3899

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

	hw->wiphy->custom_regulatory = true;

3900 3901 3902
	/* Firmware does not support this */
	hw->wiphy->disable_beacon_hints = true;

J
Johannes Berg 已提交
3903 3904 3905
	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;
3906

3907 3908 3909
	/* Default value; 4 EDCA QOS priorities */
	hw->queues = 4;

3910 3911 3912
	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
3913

3914 3915 3916
	if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&priv->bands[IEEE80211_BAND_5GHZ];
3917

3918 3919 3920 3921 3922 3923
	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;
3924

3925
	return 0;
3926 3927
}

C
Christoph Hellwig 已提交
3928
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
3929 3930
{
	int err = 0;
3931
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
3932
	struct ieee80211_hw *hw;
3933
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
3934
	struct iwl3945_eeprom *eeprom;
3935
	unsigned long flags;
Z
Zhu Yi 已提交
3936

3937 3938 3939 3940
	/***********************
	 * 1. Allocating HW data
	 * ********************/

Z
Zhu Yi 已提交
3941 3942
	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
3943
	hw = iwl_alloc_all(cfg, &iwl3945_hw_ops);
Z
Zhu Yi 已提交
3944
	if (hw == NULL) {
3945
		printk(KERN_ERR DRV_NAME "Can not allocate network device\n");
Z
Zhu Yi 已提交
3946 3947 3948 3949
		err = -ENOMEM;
		goto out;
	}
	priv = hw->priv;
3950
	SET_IEEE80211_DEV(hw, &pdev->dev);
3951

3952 3953 3954 3955
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
3956
	if (iwl3945_mod_params.disable_hw_scan) {
3957
		IWL_DEBUG_INFO(priv, "Disabling hw_scan\n");
3958 3959 3960
		iwl3945_hw_ops.hw_scan = NULL;
	}

3961

3962
	IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
3963 3964
	priv->cfg = cfg;
	priv->pci_dev = pdev;
3965
	priv->inta_mask = CSR_INI_SET_MASK;
3966

S
Samuel Ortiz 已提交
3967
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
3968 3969
	atomic_set(&priv->restrict_refcnt, 0);
#endif
3970 3971
	if (iwl_alloc_traffic_mem(priv))
		IWL_ERR(priv, "Not enough memory to generate traffic log\n");
Z
Zhu Yi 已提交
3972

3973 3974 3975
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
3976 3977 3978 3979 3980 3981 3982
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

3983
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
3984
	if (!err)
3985
		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
3986
	if (err) {
T
Tomas Winkler 已提交
3987
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
3988 3989 3990 3991 3992 3993 3994
		goto out_pci_disable_device;
	}

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

3996 3997 3998
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
3999 4000 4001 4002 4003 4004
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

4005
	IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
Z
Zhu Yi 已提交
4006
			(unsigned long long) pci_resource_len(pdev, 0));
4007
	IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
Z
Zhu Yi 已提交
4008

4009 4010 4011
	/* 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 已提交
4012

M
Mohamed Abbas 已提交
4013 4014 4015 4016 4017
	/* this spin lock will be used in apm_ops.init and EEPROM access
	 * we should init now
	 */
	spin_lock_init(&priv->reg_lock);

4018 4019 4020
	/***********************
	 * 4. Read EEPROM
	 * ********************/
4021

4022
	/* Read the EEPROM */
4023
	err = iwl_eeprom_init(priv);
4024
	if (err) {
4025
		IWL_ERR(priv, "Unable to init EEPROM\n");
4026
		goto out_iounmap;
4027 4028
	}
	/* MAC Address location in EEPROM same for 3945/4965 */
4029 4030
	eeprom = (struct iwl3945_eeprom *)priv->eeprom;
	memcpy(priv->mac_addr, eeprom->mac_address, ETH_ALEN);
4031
	IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->mac_addr);
4032
	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
Z
Zhu Yi 已提交
4033

4034 4035 4036
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
4037
	/* Device-specific setup */
4038
	if (iwl3945_hw_set_hw_params(priv)) {
4039
		IWL_ERR(priv, "failed to set hw settings\n");
4040
		goto out_eeprom_free;
Z
Zhu Yi 已提交
4041 4042
	}

4043 4044 4045 4046
	/***********************
	 * 6. Setup priv
	 * ********************/

4047
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
4048
	if (err) {
4049
		IWL_ERR(priv, "initializing driver failed\n");
4050
		goto out_unset_hw_params;
Z
Zhu Yi 已提交
4051 4052
	}

T
Tomas Winkler 已提交
4053 4054
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
4055 4056

	/***********************
4057
	 * 7. Setup Services
4058 4059 4060
	 * ********************/

	spin_lock_irqsave(&priv->lock, flags);
4061
	iwl_disable_interrupts(priv);
4062 4063
	spin_unlock_irqrestore(&priv->lock, flags);

4064 4065
	pci_enable_msi(priv->pci_dev);

M
Mohamed Abbas 已提交
4066 4067
	err = request_irq(priv->pci_dev->irq, priv->cfg->ops->lib->isr,
			  IRQF_SHARED, DRV_NAME, priv);
4068 4069 4070 4071 4072
	if (err) {
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

4073
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
4074
	if (err) {
4075
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
4076
		goto out_release_irq;
4077 4078
	}

4079 4080
	iwl_set_rxon_channel(priv,
			     &priv->bands[IEEE80211_BAND_2GHZ].channels[5]);
4081 4082
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);
B
Ben Cahill 已提交
4083
	iwl_power_initialize(priv);
4084 4085

	/*********************************
4086
	 * 8. Setup and Register mac80211
4087 4088
	 * *******************************/

4089
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
4090

4091 4092 4093
	err = iwl3945_setup_mac(priv);
	if (err)
		goto  out_remove_sysfs;
4094

A
Abhijeet Kolekar 已提交
4095 4096 4097 4098
	err = iwl_dbgfs_register(priv, DRV_NAME);
	if (err)
		IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);

4099 4100 4101 4102
	/* Start monitoring the killswitch */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   2 * HZ);

Z
Zhu Yi 已提交
4103 4104
	return 0;

4105
 out_remove_sysfs:
4106 4107
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
4108
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
4109
 out_release_irq:
4110 4111 4112
	free_irq(priv->pci_dev->irq, priv);
 out_disable_msi:
	pci_disable_msi(priv->pci_dev);
4113 4114 4115 4116 4117 4118
	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 已提交
4119 4120 4121 4122 4123 4124
 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);
4125
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
4126
 out_ieee80211_free_hw:
4127
	iwl_free_traffic_mem(priv);
4128
	ieee80211_free_hw(priv->hw);
Z
Zhu Yi 已提交
4129 4130 4131 4132
 out:
	return err;
}

4133
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
4134
{
4135
	struct iwl_priv *priv = pci_get_drvdata(pdev);
4136
	unsigned long flags;
Z
Zhu Yi 已提交
4137 4138 4139 4140

	if (!priv)
		return;

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

A
Abhijeet Kolekar 已提交
4143 4144
	iwl_dbgfs_unregister(priv);

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

4147 4148 4149 4150 4151 4152
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
4153

4154 4155 4156 4157 4158 4159 4160 4161 4162
	/*
	 * 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);

4163 4164 4165 4166
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
4167
	iwl_disable_interrupts(priv);
4168 4169 4170 4171
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

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

4174
	cancel_delayed_work_sync(&priv->rfkill_poll);
4175

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

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

4182
	iwl3945_unset_hw_params(priv);
4183
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
4184

4185 4186 4187
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
4188
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
4189 4190 4191 4192
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
4193
	iwl_free_traffic_mem(priv);
Z
Zhu Yi 已提交
4194

4195 4196 4197
	free_irq(pdev->irq, priv);
	pci_disable_msi(pdev);

Z
Zhu Yi 已提交
4198 4199 4200 4201 4202
	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

4203
	iwl_free_channel_map(priv);
4204
	iwlcore_free_geos(priv);
W
Winkler, Tomas 已提交
4205
	kfree(priv->scan);
Z
Zhu Yi 已提交
4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}


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

C
Christoph Hellwig 已提交
4219
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
4220
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
4221 4222 4223
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
4224
#ifdef CONFIG_PM
4225 4226
	.suspend = iwl_pci_suspend,
	.resume = iwl_pci_resume,
Z
Zhu Yi 已提交
4227 4228 4229
#endif
};

C
Christoph Hellwig 已提交
4230
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
4231 4232 4233 4234 4235
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
4236 4237 4238

	ret = iwl3945_rate_control_register();
	if (ret) {
4239 4240
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
4241 4242 4243
		return ret;
	}

C
Christoph Hellwig 已提交
4244
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
4245
	if (ret) {
4246
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
4247
		goto error_register;
Z
Zhu Yi 已提交
4248 4249 4250
	}

	return ret;
4251 4252 4253 4254

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
4255 4256
}

C
Christoph Hellwig 已提交
4257
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
4258
{
C
Christoph Hellwig 已提交
4259
	pci_unregister_driver(&iwl3945_driver);
4260
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
4261 4262
}

4263
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
4264

4265
module_param_named(antenna, iwl3945_mod_params.antenna, int, S_IRUGO);
Z
Zhu Yi 已提交
4266
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
4267
module_param_named(swcrypto, iwl3945_mod_params.sw_crypto, int, S_IRUGO);
4268 4269
MODULE_PARM_DESC(swcrypto,
		 "using software crypto (default 1 [software])\n");
4270
#ifdef CONFIG_IWLWIFI_DEBUG
4271
module_param_named(debug, iwl_debug_level, uint, S_IRUGO | S_IWUSR);
Z
Zhu Yi 已提交
4272
MODULE_PARM_DESC(debug, "debug output mask");
4273
#endif
4274 4275
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan,
		   int, S_IRUGO);
Z
Zhu Yi 已提交
4276
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");
4277
module_param_named(fw_restart3945, iwl3945_mod_params.restart_fw, int, S_IRUGO);
4278 4279
MODULE_PARM_DESC(fw_restart3945, "restart firmware in case of error");

C
Christoph Hellwig 已提交
4280 4281
module_exit(iwl3945_exit);
module_init(iwl3945_init);