iwl3945-base.c 118.2 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
{
368
	struct iwl3945_tx_cmd *tx = (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:
373 374
		tx->sec_ctl = TX_CMD_SEC_CCM;
		memcpy(tx->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:
382
		tx->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)
386
			tx->sec_ctl |= TX_CMD_SEC_KEY128;
Z
Zhu Yi 已提交
387

388
		memcpy(&tx->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
{
408 409
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
	__le32 tx_flags = tx->tx_flags;
410
	__le16 fc = hdr->frame_control;
Z
Zhu Yi 已提交
411

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

425
	tx->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);
431
		tx->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))
445
			tx->timeout.pm_frame_timeout = cpu_to_le16(3);
Z
Zhu Yi 已提交
446
		else
447
			tx->timeout.pm_frame_timeout = cpu_to_le16(2);
M
Mohamed Abbas 已提交
448
	} else {
449
		tx->timeout.pm_frame_timeout = 0;
M
Mohamed Abbas 已提交
450
	}
Z
Zhu Yi 已提交
451

452 453 454
	tx->driver_txop = 0;
	tx->tx_flags = tx_flags;
	tx->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);
464
	struct iwl3945_tx_cmd *tx;
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];
563
	tx = (struct iwl3945_tx_cmd *)out_cmd->cmd.payload;
Z
Zhu Yi 已提交
564
	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
565
	memset(tx, 0, sizeof(*tx));
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 */
578
	memcpy(tx->hdr, hdr, hdr_len);
Z
Zhu Yi 已提交
579

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

	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;
	tx->len = cpu_to_le16(len);

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

	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 610
	} 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));
	IWL_DEBUG_TX(priv, "tx_flags = 0X%x \n", le32_to_cpu(tx->tx_flags));
611 612
	iwl_print_hex_dump(priv, IWL_DL_TX, tx, sizeof(*tx));
	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx->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;
748
	struct iwl_rx_packet *res;
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;

J
Johannes Berg 已提交
793
	res = (struct iwl_rx_packet *)cmd.reply_skb->data;
Z
Zhu Yi 已提交
794
	if (res->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 799 800 801 802
		rc = -EIO;
	}

	spectrum_resp_status = le16_to_cpu(res->u.spectrum.status);
	switch (spectrum_resp_status) {
	case 0:		/* Command will be handled */
		if (res->u.spectrum.id != 0xff) {
803
			IWL_DEBUG_INFO(priv, "Replaced existing measurement: %d\n",
804
						res->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;
	}

J
Johannes Berg 已提交
816
	dev_kfree_skb_any(cmd.reply_skb);
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
{
825 826
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
	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
862
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
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
898
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
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
{
921
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
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 */
1085
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->real_dma_addr);
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;
1125
	struct sk_buff *skb;
Z
Zhu Yi 已提交
1126
	unsigned long flags;
A
Abhijeet Kolekar 已提交
1127 1128 1129 1130 1131 1132 1133 1134 1135

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

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

1137 1138
		if (rxq->free_count > RX_LOW_WATERMARK)
			priority |= __GFP_NOWARN;
1139
		/* Alloc a new receive buffer */
1140 1141
		skb = alloc_skb(priv->hw_params.rx_buf_size, priority);
		if (!skb) {
Z
Zhu Yi 已提交
1142
			if (net_ratelimit())
1143 1144 1145 1146 1147 1148
				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 已提交
1149 1150 1151 1152 1153
			/* 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 已提交
1154

1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
		spin_lock_irqsave(&rxq->lock, flags);
		if (list_empty(&rxq->rx_used)) {
			spin_unlock_irqrestore(&rxq->lock, flags);
			dev_kfree_skb_any(skb);
			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);

		rxb->skb = skb;

Z
Zhu Yi 已提交
1168 1169 1170 1171 1172 1173 1174 1175
		/* If radiotap head is required, reserve some headroom here.
		 * The physical head count is a variable rx_stats->phy_count.
		 * We reserve 4 bytes here. Plus these extra bytes, the
		 * headroom of the physical head should be enough for the
		 * radiotap head that iwl3945 supported. See iwl3945_rt.
		 */
		skb_reserve(rxb->skb, 4);

1176
		/* Get physical address of RB/SKB */
1177 1178 1179 1180
		rxb->real_dma_addr = pci_map_single(priv->pci_dev,
						rxb->skb->data,
						priv->hw_params.rx_buf_size,
						PCI_DMA_FROMDEVICE);
A
Abhijeet Kolekar 已提交
1181 1182

		spin_lock_irqsave(&rxq->lock, flags);
Z
Zhu Yi 已提交
1183
		list_add_tail(&rxb->list, &rxq->rx_free);
A
Abhijeet Kolekar 已提交
1184
		priv->alloc_rxb_skb++;
Z
Zhu Yi 已提交
1185
		rxq->free_count++;
A
Abhijeet Kolekar 已提交
1186
		spin_unlock_irqrestore(&rxq->lock, flags);
Z
Zhu Yi 已提交
1187
	}
1188 1189
}

R
Reinette Chatre 已提交
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
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 */
		if (rxq->pool[i].skb != NULL) {
			pci_unmap_single(priv->pci_dev,
					 rxq->pool[i].real_dma_addr,
					 priv->hw_params.rx_buf_size,
					 PCI_DMA_FROMDEVICE);
			priv->alloc_rxb_skb--;
			dev_kfree_skb(rxq->pool[i].skb);
			rxq->pool[i].skb = NULL;
		}
		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;
	rxq->free_count = 0;
1217
	rxq->write_actual = 0;
R
Reinette Chatre 已提交
1218 1219 1220
	spin_unlock_irqrestore(&rxq->lock, flags);
}

1221 1222
void iwl3945_rx_replenish(void *data)
{
1223
	struct iwl_priv *priv = data;
1224 1225
	unsigned long flags;

1226
	iwl3945_rx_allocate(priv, GFP_KERNEL);
Z
Zhu Yi 已提交
1227 1228

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

1233 1234 1235 1236 1237 1238 1239 1240
static void iwl3945_rx_replenish_now(struct iwl_priv *priv)
{
	iwl3945_rx_allocate(priv, GFP_ATOMIC);

	iwl3945_rx_queue_restock(priv);
}


R
Reinette Chatre 已提交
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
/* 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++) {
		if (rxq->pool[i].skb != NULL) {
			pci_unmap_single(priv->pci_dev,
					 rxq->pool[i].real_dma_addr,
					 priv->hw_params.rx_buf_size,
					 PCI_DMA_FROMDEVICE);
			dev_kfree_skb(rxq->pool[i].skb);
		}
	}

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

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

	/* 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 已提交
1312
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
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 1346
{
	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;
}

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

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

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

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

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

1384
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
1385 1386 1387 1388 1389 1390
		 * then a bug has been introduced in the queue refilling
		 * routines -- catch it here */
		BUG_ON(rxb == NULL);

		rxq->queue[i] = NULL;

R
Reinette Chatre 已提交
1391 1392 1393
		pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
				priv->hw_params.rx_buf_size,
				PCI_DMA_FROMDEVICE);
1394
		pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
1395

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

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

		if (reclaim) {
1425
			/* Invoke any callbacks, transfer the skb to caller, and
1426
			 * fire off the (possibly) blocking iwl_send_cmd()
Z
Zhu Yi 已提交
1427 1428
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
1429
				iwl_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
1430
			else
1431
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446
		}

		/* For now we just don't re-use anything.  We can tweak this
		 * later to try and re-use notification packets and SKBs that
		 * fail to Rx correctly */
		if (rxb->skb != NULL) {
			priv->alloc_rxb_skb--;
			dev_kfree_skb_any(rxb->skb);
			rxb->skb = NULL;
		}

		spin_lock_irqsave(&rxq->lock, flags);
		list_add_tail(&rxb->list, &priv->rxq.rx_used);
		spin_unlock_irqrestore(&rxq->lock, flags);
		i = (i + 1) & RX_QUEUE_MASK;
1447 1448 1449 1450 1451 1452
		/* If there are a lot of unused frames,
		 * restock the Rx queue so ucode won't assert. */
		if (fill_rx) {
			count++;
			if (count >= 8) {
				priv->rxq.read = i;
1453
				iwl3945_rx_replenish_now(priv);
1454 1455 1456
				count = 0;
			}
		}
Z
Zhu Yi 已提交
1457 1458 1459 1460
	}

	/* Backtrack one entry */
	priv->rxq.read = i;
1461 1462 1463 1464
	if (fill_rx)
		iwl3945_rx_replenish_now(priv);
	else
		iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1465 1466
}

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

1475
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
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))

1499
void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1500 1501 1502 1503 1504 1505 1506
{
	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 已提交
1507
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1508
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1509 1510 1511 1512
		return;
	}


1513
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
1514 1515

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

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

1540 1541 1542 1543
		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 已提交
1544 1545
		trace_iwlwifi_dev_ucode_error(priv, desc, time, data1, 0,
					0, blink1, blink2, ilink1, ilink2);
Z
Zhu Yi 已提交
1546 1547 1548
	}
}

1549
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
1550 1551

/**
C
Christoph Hellwig 已提交
1552
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
1553 1554
 *
 */
1555
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578
				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++) {
1579
		ev = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1580
		ptr += sizeof(u32);
1581
		time = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1582
		ptr += sizeof(u32);
1583 1584 1585
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
J
Johannes Berg 已提交
1586
			trace_iwlwifi_dev_ucode_event(priv, 0, time, ev);
1587
		} else {
1588
			data = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1589
			ptr += sizeof(u32);
1590
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
J
Johannes Berg 已提交
1591
			trace_iwlwifi_dev_ucode_event(priv, time, data, ev);
Z
Zhu Yi 已提交
1592 1593 1594 1595
		}
	}
}

1596
void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1597 1598 1599 1600 1601 1602 1603 1604 1605
{
	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 已提交
1606
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1607
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1608 1609 1610 1611
		return;
	}

	/* event log header */
1612 1613 1614 1615
	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 已提交
1616 1617 1618 1619 1620

	size = num_wraps ? capacity : next_entry;

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

1625
	IWL_ERR(priv, "Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
1626 1627 1628 1629 1630
		  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 已提交
1631
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
1632 1633 1634
				    capacity - next_entry, mode);

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

}
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647
#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 已提交
1648

1649
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1650 1651 1652 1653
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
S
Samuel Ortiz 已提交
1654
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1655 1656 1657 1658 1659 1660 1661 1662
	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. */
1663 1664
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
1665 1666 1667 1668

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

S
Samuel Ortiz 已提交
1672
#ifdef CONFIG_IWLWIFI_DEBUG
1673
	if (iwl_get_debug_level(priv) & IWL_DL_ISR) {
1674
		/* just for debug */
1675
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
1676
		IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
Z
Zhu Yi 已提交
1677 1678 1679 1680 1681 1682 1683 1684
			      inta, inta_mask, inta_fh);
	}
#endif

	/* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
	 * atomic, make sure that inta covers all the interrupts that
	 * we've discovered, even if FH interrupt came in just after
	 * reading CSR_INT. */
T
Tomas Winkler 已提交
1685
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
1686
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
1687
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
1688 1689 1690 1691
		inta |= CSR_INT_BIT_FH_TX;

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

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

1697
		priv->isr_stats.hw++;
1698
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1699 1700 1701 1702 1703 1704 1705 1706

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

S
Samuel Ortiz 已提交
1707
#ifdef CONFIG_IWLWIFI_DEBUG
1708
	if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
1709
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
1710
		if (inta & CSR_INT_BIT_SCD) {
1711
			IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
1712
				      "the frame/frames.\n");
1713 1714
			priv->isr_stats.sch++;
		}
Z
Zhu Yi 已提交
1715 1716

		/* Alive notification via Rx interrupt will do the real work */
1717
		if (inta & CSR_INT_BIT_ALIVE) {
1718
			IWL_DEBUG_ISR(priv, "Alive interrupt\n");
1719 1720
			priv->isr_stats.alive++;
		}
Z
Zhu Yi 已提交
1721 1722 1723
	}
#endif
	/* Safely ignore these bits for debug checks below */
1724
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
1725 1726 1727

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
1728 1729
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
1730 1731
		priv->isr_stats.sw++;
		priv->isr_stats.sw_err = inta;
1732
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1733 1734 1735 1736 1737
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
1738
		IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
1739
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
1740 1741 1742 1743 1744 1745
		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 已提交
1746

1747
		priv->isr_stats.wakeup++;
Z
Zhu Yi 已提交
1748 1749 1750 1751 1752 1753 1754
		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 已提交
1755
		iwl3945_rx_handle(priv);
1756
		priv->isr_stats.rx++;
Z
Zhu Yi 已提交
1757 1758 1759 1760
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

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

1764
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
M
Mohamed Abbas 已提交
1765 1766
		iwl_write_direct32(priv, FH39_TCSR_CREDIT
					(FH39_SRVC_CHNL), 0x0);
Z
Zhu Yi 已提交
1767 1768 1769
		handled |= CSR_INT_BIT_FH_TX;
	}

1770
	if (inta & ~handled) {
1771
		IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
1772 1773
		priv->isr_stats.unhandled++;
	}
Z
Zhu Yi 已提交
1774

1775
	if (inta & ~priv->inta_mask) {
1776
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
1777
			 inta & ~priv->inta_mask);
1778
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
1779 1780 1781
	}

	/* Re-enable all interrupts */
1782 1783
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
1784
		iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
1785

S
Samuel Ortiz 已提交
1786
#ifdef CONFIG_IWLWIFI_DEBUG
1787
	if (iwl_get_debug_level(priv) & (IWL_DL_ISR)) {
1788 1789 1790
		inta = iwl_read32(priv, CSR_INT);
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
1791
		IWL_DEBUG_ISR(priv, "End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
Z
Zhu Yi 已提交
1792 1793 1794 1795 1796 1797
			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
	}
#endif
	spin_unlock_irqrestore(&priv->lock, flags);
}

1798
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
1799
					 enum ieee80211_band band,
1800
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
1801
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
1802
{
1803
	struct ieee80211_channel *chan;
1804
	const struct ieee80211_supported_band *sband;
1805
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
1806 1807 1808 1809
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
1810
	sband = iwl_get_hw_mode(priv, band);
1811
	if (!sband)
Z
Zhu Yi 已提交
1812 1813
		return 0;

S
Samuel Ortiz 已提交
1814 1815
	active_dwell = iwl_get_active_dwell_time(priv, band, n_probes);
	passive_dwell = iwl_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
1816

1817 1818 1819
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

1820 1821 1822 1823
	for (i = 0, added = 0; i < priv->scan_request->n_channels; i++) {
		chan = priv->scan_request->channels[i];

		if (chan->band != band)
1824 1825
			continue;

1826
		scan_ch->channel = chan->hw_value;
Z
Zhu Yi 已提交
1827

1828
		ch_info = iwl_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
1829
		if (!is_channel_valid(ch_info)) {
1830
			IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
1831 1832 1833 1834
				       scan_ch->channel);
			continue;
		}

1835 1836 1837 1838 1839
		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 已提交
1840
		if (!is_active || is_channel_passive(ch_info) ||
1841
		    (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
1842
			scan_ch->type = 0;	/* passive */
1843 1844 1845
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
1846
			scan_ch->type = 1;	/* active */
1847
		}
Z
Zhu Yi 已提交
1848

1849 1850 1851 1852 1853 1854
		/* 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)
1855
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
1856 1857 1858 1859
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
1860
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
1861
		}
Z
Zhu Yi 已提交
1862

1863
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
1864 1865 1866 1867
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
1868
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
1869 1870 1871 1872
			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
1873
			 * power level:
1874
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
1875 1876 1877
			 */
		}

1878
		IWL_DEBUG_SCAN(priv, "Scanning %d [%s %d]\n",
Z
Zhu Yi 已提交
1879 1880 1881 1882 1883 1884 1885 1886 1887
			       scan_ch->channel,
			       (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
			       (scan_ch->type & 1) ?
			       active_dwell : passive_dwell);

		scan_ch++;
		added++;
	}

1888
	IWL_DEBUG_SCAN(priv, "total channels to scan %d \n", added);
Z
Zhu Yi 已提交
1889 1890 1891
	return added;
}

1892
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1893 1894 1895 1896 1897
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
1898 1899 1900 1901
		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;
1902
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
1903
			/*
1904
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
1905
			 */
C
Christoph Hellwig 已提交
1906
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
1907
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
1908 1909 1910 1911 1912 1913 1914 1915 1916 1917
		}
	}
}

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

1918
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1919
{
1920 1921 1922 1923 1924 1925
	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 已提交
1926 1927 1928
}

/**
C
Christoph Hellwig 已提交
1929
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
1930 1931
 *     looking at all data.
 */
1932
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
1933 1934 1935 1936 1937 1938
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

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

1941
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
1942
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
1943 1944 1945 1946 1947 1948

	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 */
1949
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
1950
		if (val != le32_to_cpu(*image)) {
1951
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
				  "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)
1963 1964
		IWL_DEBUG_INFO(priv,
			"ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
1965 1966 1967 1968 1969 1970

	return rc;
}


/**
C
Christoph Hellwig 已提交
1971
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
1972 1973 1974
 *   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.
 */
1975
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
1976 1977 1978 1979 1980 1981
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

1982
	IWL_DEBUG_INFO(priv, "ucode inst image size is %u\n", len);
Z
Zhu Yi 已提交
1983 1984 1985 1986 1987

	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 */
1988
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
1989
			i + IWL39_RTC_INST_LOWER_BOUND);
1990
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
1991 1992
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
1993
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008
				  "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 已提交
2009
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
2010 2011
 *    and verify its contents
 */
2012
static int iwl3945_verify_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2013 2014 2015 2016 2017 2018 2019 2020
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2021
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2022
	if (rc == 0) {
2023
		IWL_DEBUG_INFO(priv, "Bootstrap uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2024 2025 2026 2027 2028 2029
		return 0;
	}

	/* Try initialize */
	image = (__le32 *)priv->ucode_init.v_addr;
	len = priv->ucode_init.len;
C
Christoph Hellwig 已提交
2030
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2031
	if (rc == 0) {
2032
		IWL_DEBUG_INFO(priv, "Initialize uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2033 2034 2035 2036 2037 2038
		return 0;
	}

	/* Try runtime/protocol */
	image = (__le32 *)priv->ucode_code.v_addr;
	len = priv->ucode_code.len;
C
Christoph Hellwig 已提交
2039
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2040
	if (rc == 0) {
2041
		IWL_DEBUG_INFO(priv, "Runtime uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2042 2043 2044
		return 0;
	}

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

2047 2048 2049
	/* 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 已提交
2050 2051
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2052
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
2053 2054 2055 2056

	return rc;
}

2057
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2058 2059
{
	/* Remove all resets to allow NIC to operate */
2060
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
2061 2062 2063
}

/**
C
Christoph Hellwig 已提交
2064
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
2065 2066 2067
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
2068
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2069
{
2070
	const struct iwl_ucode_header *ucode;
2071
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
2072 2073
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
2074 2075 2076 2077
	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 已提交
2078 2079
	u8 *src;
	size_t len;
2080
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
2081 2082 2083

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
2084 2085 2086 2087
	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) {
2088
			IWL_ERR(priv, "%s firmware file req failed: %d\n",
2089 2090 2091 2092 2093 2094 2095
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
2096 2097 2098
				IWL_ERR(priv, "Loaded firmware %s, "
					"which is deprecated. "
					" Please use API v%u instead.\n",
2099
					  buf, api_max);
2100 2101
			IWL_DEBUG_INFO(priv, "Got firmware '%s' file "
				       "(%zd bytes) from disk\n",
2102 2103 2104
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
2105 2106
	}

2107 2108
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
2109 2110

	/* Make sure that we got at least our header! */
2111
	if (ucode_raw->size <  priv->cfg->ops->ucode->get_header_size(1)) {
2112
		IWL_ERR(priv, "File size way too small!\n");
2113
		ret = -EINVAL;
Z
Zhu Yi 已提交
2114 2115 2116 2117
		goto err_release;
	}

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

2120
	priv->ucode_ver = le32_to_cpu(ucode->ver);
2121
	api_ver = IWL_UCODE_API(priv->ucode_ver);
2122 2123 2124 2125 2126 2127 2128
	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 已提交
2129

2130 2131
	/* api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
2132
	 * on the API version read from firmware header from here on forward */
2133 2134

	if (api_ver < api_min || api_ver > api_max) {
2135
		IWL_ERR(priv, "Driver unable to support your firmware API. "
2136 2137 2138 2139 2140 2141 2142
			  "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)
2143
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
2144 2145 2146 2147
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
2148 2149 2150 2151 2152 2153
	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));

2154
	IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
2155
		       priv->ucode_ver);
2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
	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 已提交
2166

2167

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

2173 2174 2175
		IWL_DEBUG_INFO(priv,
			"uCode file size %zd does not match expected size\n",
			ucode_raw->size);
2176
		ret = -EINVAL;
Z
Zhu Yi 已提交
2177 2178 2179 2180
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
2181
	if (inst_size > IWL39_MAX_INST_SIZE) {
2182
		IWL_DEBUG_INFO(priv, "uCode instr len %d too large to fit in\n",
2183 2184
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2185 2186 2187
		goto err_release;
	}

2188
	if (data_size > IWL39_MAX_DATA_SIZE) {
2189
		IWL_DEBUG_INFO(priv, "uCode data len %d too large to fit in\n",
2190 2191
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2192 2193
		goto err_release;
	}
2194
	if (init_size > IWL39_MAX_INST_SIZE) {
2195 2196
		IWL_DEBUG_INFO(priv,
				"uCode init instr len %d too large to fit in\n",
2197 2198
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2199 2200
		goto err_release;
	}
2201
	if (init_data_size > IWL39_MAX_DATA_SIZE) {
2202 2203
		IWL_DEBUG_INFO(priv,
				"uCode init data len %d too large to fit in\n",
2204 2205
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2206 2207
		goto err_release;
	}
2208
	if (boot_size > IWL39_MAX_BSM_SIZE) {
2209 2210
		IWL_DEBUG_INFO(priv,
				"uCode boot instr len %d too large to fit in\n",
2211 2212
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2213 2214 2215 2216 2217 2218 2219 2220 2221
		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;
2222
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
2223 2224

	priv->ucode_data.len = data_size;
2225
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
2226 2227

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

2230 2231 2232
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
2233 2234

	/* Initialization instructions and data */
2235 2236
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
2237
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
2238 2239

		priv->ucode_init_data.len = init_data_size;
2240
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
2241 2242 2243 2244

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

	/* Bootstrap (instructions only, no data) */
2247 2248
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
2249
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
2250

2251 2252 2253
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
2254 2255 2256 2257

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

	/* Runtime instructions (first block of data in file) */
2258
	len = inst_size;
2259 2260
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode instr len %zd\n", len);
Z
Zhu Yi 已提交
2261
	memcpy(priv->ucode_code.v_addr, src, len);
2262 2263
	src += len;

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

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
2268
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
2269
	len = data_size;
2270 2271
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode data len %zd\n", len);
Z
Zhu Yi 已提交
2272 2273
	memcpy(priv->ucode_data.v_addr, src, len);
	memcpy(priv->ucode_data_backup.v_addr, src, len);
2274
	src += len;
Z
Zhu Yi 已提交
2275 2276 2277

	/* Initialization instructions (3rd block) */
	if (init_size) {
2278
		len = init_size;
2279 2280
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init instr len %zd\n", len);
Z
Zhu Yi 已提交
2281
		memcpy(priv->ucode_init.v_addr, src, len);
2282
		src += len;
Z
Zhu Yi 已提交
2283 2284 2285 2286
	}

	/* Initialization data (4th block) */
	if (init_data_size) {
2287
		len = init_data_size;
2288 2289
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init data len %zd\n", len);
Z
Zhu Yi 已提交
2290
		memcpy(priv->ucode_init_data.v_addr, src, len);
2291
		src += len;
Z
Zhu Yi 已提交
2292 2293 2294
	}

	/* Bootstrap instructions (5th block) */
2295
	len = boot_size;
2296 2297
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) boot instr len %zd\n", len);
Z
Zhu Yi 已提交
2298 2299 2300 2301 2302 2303 2304
	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:
2305
	IWL_ERR(priv, "failed to allocate pci memory\n");
2306
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
2307
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
2308 2309 2310 2311 2312

 err_release:
	release_firmware(ucode_raw);

 error:
2313
	return ret;
Z
Zhu Yi 已提交
2314 2315 2316 2317
}


/**
C
Christoph Hellwig 已提交
2318
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
2319 2320 2321 2322 2323 2324 2325
 *
 * 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.
 */
2326
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2327 2328 2329 2330 2331 2332 2333 2334 2335
{
	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 */
2336 2337 2338
	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 已提交
2339 2340
				 priv->ucode_data.len);

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

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

M
Mohamed Abbas 已提交
2348
	return 0;
Z
Zhu Yi 已提交
2349 2350 2351
}

/**
C
Christoph Hellwig 已提交
2352
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2353 2354 2355 2356
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
2357
 */
2358
static void iwl3945_init_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2359 2360 2361 2362 2363
{
	/* 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 */
2364
		IWL_DEBUG_INFO(priv, "Initialize Alive failed.\n");
Z
Zhu Yi 已提交
2365 2366 2367 2368 2369 2370
		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 已提交
2371
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2372 2373
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2374
		IWL_DEBUG_INFO(priv, "Bad \"initialize\" uCode load.\n");
Z
Zhu Yi 已提交
2375 2376 2377 2378 2379 2380
		goto restart;
	}

	/* Send pointers to protocol/runtime uCode image ... init code will
	 * load and launch runtime uCode, which will send us another "Alive"
	 * notification. */
2381
	IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
C
Christoph Hellwig 已提交
2382
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
2383 2384
		/* Runtime instruction load won't happen;
		 * take it all the way back down so we can try again */
2385
		IWL_DEBUG_INFO(priv, "Couldn't set up uCode pointers.\n");
Z
Zhu Yi 已提交
2386 2387 2388 2389 2390 2391 2392 2393 2394
		goto restart;
	}
	return;

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

/**
C
Christoph Hellwig 已提交
2395
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2396
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
2397
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
2398
 */
2399
static void iwl3945_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2400 2401 2402 2403
{
	int thermal_spin = 0;
	u32 rfkill;

2404
	IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
2405 2406 2407 2408

	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 */
2409
		IWL_DEBUG_INFO(priv, "Alive failed.\n");
Z
Zhu Yi 已提交
2410 2411 2412 2413 2414 2415
		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 已提交
2416
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2417 2418
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2419
		IWL_DEBUG_INFO(priv, "Bad runtime uCode load.\n");
Z
Zhu Yi 已提交
2420 2421 2422
		goto restart;
	}

2423
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2424

2425
	rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
2426
	IWL_DEBUG_INFO(priv, "RFKILL status: 0x%x\n", rfkill);
Z
Zhu Yi 已提交
2427 2428 2429

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
2430
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
2431
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
2432
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
2433 2434 2435 2436 2437
			thermal_spin++;
			udelay(10);
		}

		if (thermal_spin)
2438
			IWL_DEBUG_INFO(priv, "Thermal calibration took %dus\n",
Z
Zhu Yi 已提交
2439 2440 2441 2442
				       thermal_spin * 10);
	} else
		set_bit(STATUS_RF_KILL_HW, &priv->status);

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

2446
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
2447 2448
		return;

2449
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
2450 2451 2452 2453

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

2454
	iwl_power_update_mode(priv, false);
Z
Zhu Yi 已提交
2455

2456
	if (iwl_is_associated(priv)) {
C
Christoph Hellwig 已提交
2457
		struct iwl3945_rxon_cmd *active_rxon =
2458
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
2459

2460
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
Z
Zhu Yi 已提交
2461 2462 2463
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
2464
		iwl_connection_init_rx_config(priv, priv->iw_mode);
Z
Zhu Yi 已提交
2465 2466
	}

2467
	/* Configure Bluetooth device coexistence support */
2468
	iwl_send_bt_config(priv);
Z
Zhu Yi 已提交
2469 2470

	/* Configure the adapter for unassociated operation */
A
Abhijeet Kolekar 已提交
2471
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
2472 2473 2474

	iwl3945_reg_txpower_periodic(priv);

J
Johannes Berg 已提交
2475
	iwl_leds_init(priv);
2476

2477
	IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
2478
	set_bit(STATUS_READY, &priv->status);
2479
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
2480

2481 2482 2483 2484 2485
	/* 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)
2486
			iwl_mac_beacon_update(priv->hw, beacon);
2487 2488
	}

A
Abhijeet Kolekar 已提交
2489
	if (test_and_clear_bit(STATUS_MODE_PENDING, &priv->status))
2490
		iwl_set_mode(priv, priv->iw_mode);
A
Abhijeet Kolekar 已提交
2491

Z
Zhu Yi 已提交
2492 2493 2494 2495 2496 2497
	return;

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

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

2500
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2501 2502 2503 2504 2505
{
	unsigned long flags;
	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
	struct ieee80211_conf *conf = NULL;

2506
	IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
Z
Zhu Yi 已提交
2507 2508 2509 2510 2511 2512

	conf = ieee80211_get_hw_conf(priv->hw);

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

2513
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2514 2515 2516 2517 2518 2519 2520 2521 2522 2523

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

	/* tell the device to stop sending interrupts */
2527
	spin_lock_irqsave(&priv->lock, flags);
2528
	iwl_disable_interrupts(priv);
2529 2530
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
2531 2532 2533 2534

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

C
Christoph Hellwig 已提交
2535
	/* If we have not previously called iwl3945_init() then
2536
	 * clear all bits but the RF Kill bits and return */
2537
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
2538 2539
		priv->status = test_bit(STATUS_RF_KILL_HW, &priv->status) <<
					STATUS_RF_KILL_HW |
2540 2541
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
2542 2543
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2544 2545 2546
		goto exit;
	}

2547
	/* ...otherwise clear out all the status bits but the RF Kill
J
Johannes Berg 已提交
2548
	 * bit and continue taking the NIC down. */
Z
Zhu Yi 已提交
2549 2550
	priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
				STATUS_RF_KILL_HW |
2551 2552
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
2553
			test_bit(STATUS_FW_ERROR, &priv->status) <<
2554 2555 2556
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2557

C
Christoph Hellwig 已提交
2558 2559
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
2560

M
Mohamed Abbas 已提交
2561 2562
	iwl_write_prph(priv, APMG_CLK_DIS_REG,
				APMG_CLK_VAL_DMA_CLK_RQT);
Z
Zhu Yi 已提交
2563 2564 2565

	udelay(5);

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

Z
Zhu Yi 已提交
2569
 exit:
2570
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
2571 2572 2573 2574 2575 2576

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
2577
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
2578 2579
}

2580
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2581 2582
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2583
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
2584
	mutex_unlock(&priv->mutex);
2585

C
Christoph Hellwig 已提交
2586
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
2587 2588 2589 2590
}

#define MAX_HW_RESTARTS 5

2591
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2592 2593 2594 2595
{
	int rc, i;

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

2600
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
2601
		IWL_ERR(priv, "ucode not available for device bring up\n");
2602 2603 2604
		return -EIO;
	}

2605
	/* If platform's RF_KILL switch is NOT set to KILL */
2606
	if (iwl_read32(priv, CSR_GP_CNTRL) &
2607 2608 2609 2610
				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);
2611 2612
		IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
		return -ENODEV;
Z
Zhu Yi 已提交
2613
	}
2614

2615
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
2616

C
Christoph Hellwig 已提交
2617
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
2618
	if (rc) {
2619
		IWL_ERR(priv, "Unable to int nic\n");
Z
Zhu Yi 已提交
2620 2621 2622 2623
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
2624 2625
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
2626 2627 2628
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
2629
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2630
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
2631 2632

	/* really make sure rfkill handshake bits are cleared */
2633 2634
	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 已提交
2635 2636 2637 2638 2639

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

2642 2643 2644 2645
	/* 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 已提交
2646 2647
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

2648
		iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2649 2650 2651 2652

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

		if (rc) {
2656 2657
			IWL_ERR(priv,
				"Unable to set up bootstrap uCode: %d\n", rc);
Z
Zhu Yi 已提交
2658 2659 2660 2661
			continue;
		}

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

2664
		IWL_DEBUG_INFO(priv, DRV_NAME " is coming up\n");
Z
Zhu Yi 已提交
2665 2666 2667 2668 2669

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
2670
	__iwl3945_down(priv);
2671
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
2672 2673 2674

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
2675
	IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
Z
Zhu Yi 已提交
2676 2677 2678 2679 2680 2681 2682 2683 2684 2685
	return -EIO;
}


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

C
Christoph Hellwig 已提交
2686
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2687
{
2688 2689
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, init_alive_start.work);
Z
Zhu Yi 已提交
2690 2691 2692 2693 2694

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2695
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
2696 2697 2698
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
2699
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
2700
{
2701 2702
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, alive_start.work);
Z
Zhu Yi 已提交
2703 2704 2705 2706 2707

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2708
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
2709 2710 2711
	mutex_unlock(&priv->mutex);
}

2712 2713 2714 2715 2716 2717
/*
 * 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).
 */
2718 2719 2720 2721
static void iwl3945_rfkill_poll(struct work_struct *data)
{
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rfkill_poll.work);
2722 2723 2724
	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);
2725

2726 2727 2728 2729 2730
	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);
2731

2732 2733 2734 2735 2736
		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");
	}
2737

2738 2739
	/* Keep this running, even if radio now enabled.  This will be
	 * cancelled in mac_start() if system decides to start again */
2740 2741 2742 2743 2744
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   round_jiffies_relative(2 * HZ));

}

Z
Zhu Yi 已提交
2745
#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)
C
Christoph Hellwig 已提交
2746
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
2747
{
2748 2749
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
2750
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
2751
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
2752
		.len = sizeof(struct iwl3945_scan_cmd),
J
Johannes Berg 已提交
2753
		.flags = CMD_SIZE_HUGE,
Z
Zhu Yi 已提交
2754 2755
	};
	int rc = 0;
C
Christoph Hellwig 已提交
2756
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
2757
	struct ieee80211_conf *conf = NULL;
J
Johannes Berg 已提交
2758
	u8 n_probes = 0;
2759
	enum ieee80211_band band;
J
Johannes Berg 已提交
2760
	bool is_active = false;
Z
Zhu Yi 已提交
2761 2762 2763 2764 2765

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

2766 2767
	cancel_delayed_work(&priv->scan_check);

2768
	if (!iwl_is_ready(priv)) {
2769
		IWL_WARN(priv, "request scan called when driver not ready.\n");
Z
Zhu Yi 已提交
2770 2771 2772
		goto done;
	}

T
Tomas Winkler 已提交
2773
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
2774 2775 2776 2777 2778 2779 2780
	 * 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)) {
2781 2782
		IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests  "
				"Ignoring second request.\n");
Z
Zhu Yi 已提交
2783 2784 2785 2786 2787
		rc = -EIO;
		goto done;
	}

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
2788
		IWL_DEBUG_SCAN(priv, "Aborting scan due to device shutdown\n");
Z
Zhu Yi 已提交
2789 2790 2791 2792
		goto done;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
2793 2794
		IWL_DEBUG_HC(priv,
			"Scan request while abort pending. Queuing.\n");
Z
Zhu Yi 已提交
2795 2796 2797
		goto done;
	}

2798
	if (iwl_is_rfkill(priv)) {
2799
		IWL_DEBUG_HC(priv, "Aborting scan due to RF Kill activation\n");
Z
Zhu Yi 已提交
2800 2801 2802 2803
		goto done;
	}

	if (!test_bit(STATUS_READY, &priv->status)) {
2804 2805
		IWL_DEBUG_HC(priv,
			"Scan request while uninitialized. Queuing.\n");
Z
Zhu Yi 已提交
2806 2807 2808 2809
		goto done;
	}

	if (!priv->scan_bands) {
2810
		IWL_DEBUG_HC(priv, "Aborting scan due to no requested bands\n");
Z
Zhu Yi 已提交
2811 2812 2813
		goto done;
	}

W
Winkler, Tomas 已提交
2814 2815
	if (!priv->scan) {
		priv->scan = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
2816
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
W
Winkler, Tomas 已提交
2817
		if (!priv->scan) {
Z
Zhu Yi 已提交
2818 2819 2820 2821
			rc = -ENOMEM;
			goto done;
		}
	}
W
Winkler, Tomas 已提交
2822
	scan = priv->scan;
C
Christoph Hellwig 已提交
2823
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
2824 2825 2826 2827

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

2828
	if (iwl_is_associated(priv)) {
Z
Zhu Yi 已提交
2829 2830 2831 2832 2833 2834
		u16 interval = 0;
		u32 extra;
		u32 suspend_time = 100;
		u32 scan_suspend_time = 100;
		unsigned long flags;

2835
		IWL_DEBUG_INFO(priv, "Scanning while associated...\n");
Z
Zhu Yi 已提交
2836 2837 2838 2839 2840 2841

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

		scan->suspend_time = 0;
2842
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856
		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);
2857
		IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n",
Z
Zhu Yi 已提交
2858 2859 2860
			       scan_suspend_time, interval);
	}

J
Johannes Berg 已提交
2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877
	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;
2878
	} else
J
Johannes Berg 已提交
2879
		IWL_DEBUG_SCAN(priv, "Kicking off passive scan.\n");
Z
Zhu Yi 已提交
2880 2881 2882 2883

	/* 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;
2884
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
2885 2886 2887 2888
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

2889
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
2890 2891 2892
		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;
2893
		band = IEEE80211_BAND_2GHZ;
2894
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
2895
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
2896 2897 2898 2899 2900 2901
		/*
		 * 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;
2902
		band = IEEE80211_BAND_5GHZ;
2903
	} else {
2904
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
2905 2906 2907
		goto done;
	}

S
Samuel Ortiz 已提交
2908
	scan->tx_cmd.len = cpu_to_le16(
J
Johannes Berg 已提交
2909 2910 2911 2912 2913
			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 已提交
2914

Z
Zhu Yi 已提交
2915 2916 2917
	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

2918
	if (iwl_is_monitor_mode(priv))
Z
Zhu Yi 已提交
2919 2920
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

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

2925
	if (scan->channel_count == 0) {
2926
		IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count);
2927 2928 2929
		goto done;
	}

Z
Zhu Yi 已提交
2930
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
2931
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
2932 2933 2934 2935
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
2936
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
	if (rc)
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
2947 2948 2949 2950 2951 2952 2953 2954
	/* 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);

2955
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
2956 2957 2958 2959
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
2960
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
2961
{
2962
	struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
Z
Zhu Yi 已提交
2963 2964 2965 2966 2967

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2968
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
2969 2970 2971
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
2972
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
2973
{
2974
	struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
Z
Zhu Yi 已提交
2975 2976 2977 2978

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

J
Johannes Berg 已提交
2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989
	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 已提交
2990 2991
}

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

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

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

3005 3006
#define IWL_DELAY_NEXT_SCAN (HZ*2)

3007
void iwl3945_post_associate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3008 3009 3010 3011
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

3012
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
3013
		IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
3014 3015 3016 3017
		return;
	}


3018
	IWL_DEBUG_ASSOC(priv, "Associated as %d to: %pM\n",
3019
			priv->assoc_id, priv->active_rxon.bssid_addr);
Z
Zhu Yi 已提交
3020 3021 3022 3023

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

A
Abhijeet Kolekar 已提交
3024
	if (!priv->vif || !priv->is_open)
3025
		return;
A
Abhijeet Kolekar 已提交
3026

3027
	iwl_scan_cancel_timeout(priv, 200);
3028

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

3031
	priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3032
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3033

3034
	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
3035
	iwl_setup_rxon_timing(priv);
3036
	rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
3037 3038
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
3039
		IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3040 3041
			    "Attempting to continue.\n");

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

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

3046
	IWL_DEBUG_ASSOC(priv, "assoc id %d beacon interval %d\n",
Z
Zhu Yi 已提交
3047 3048 3049
			priv->assoc_id, priv->beacon_int);

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3050
		priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3051
	else
3052
		priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
3053

3054
	if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3055
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
3056
			priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3057
		else
3058
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3059

3060
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3061
			priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
3062 3063 3064

	}

A
Abhijeet Kolekar 已提交
3065
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3066 3067

	switch (priv->iw_mode) {
3068
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
3069
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
3070 3071
		break;

3072
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
3073

3074
		priv->assoc_id = 1;
3075
		iwl_add_station(priv, priv->bssid, 0, CMD_SYNC, NULL);
Z
Zhu Yi 已提交
3076
		iwl3945_sync_sta(priv, IWL_STA_ID,
3077
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
3078 3079
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
3080 3081
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3082 3083 3084 3085

		break;

	default:
3086
		 IWL_ERR(priv, "%s Should not be called in %d mode\n",
3087
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
3088 3089 3090
		break;
	}

3091
	iwl_activate_qos(priv, 0);
3092

3093 3094
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
3095 3096
}

Z
Zhu Yi 已提交
3097 3098 3099 3100 3101 3102
/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

3103 3104
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
3105
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3106
{
3107
	struct iwl_priv *priv = hw->priv;
3108
	int ret;
Z
Zhu Yi 已提交
3109

3110
	IWL_DEBUG_MAC80211(priv, "enter\n");
Z
Zhu Yi 已提交
3111 3112 3113 3114

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

3115 3116 3117 3118 3119 3120
	/* 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) {
3121
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
3122 3123 3124 3125
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
3126

3127
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
3128 3129

	mutex_unlock(&priv->mutex);
3130

3131 3132 3133
	if (ret)
		goto out_release_irq;

3134
	IWL_DEBUG_INFO(priv, "Start UP work.\n");
3135

3136 3137 3138 3139 3140 3141 3142
	/* 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)) {
3143 3144 3145
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
3146 3147 3148 3149 3150
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

3151 3152 3153 3154
	/* 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 已提交
3155 3156
	iwl_led_start(priv);

3157
	priv->is_open = 1;
3158
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3159
	return 0;
3160 3161

out_release_irq:
3162
	priv->is_open = 0;
3163
	IWL_DEBUG_MAC80211(priv, "leave - failed\n");
3164
	return ret;
Z
Zhu Yi 已提交
3165 3166
}

C
Christoph Hellwig 已提交
3167
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
3168
{
3169
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3170

3171
	IWL_DEBUG_MAC80211(priv, "enter\n");
3172

3173
	if (!priv->is_open) {
3174
		IWL_DEBUG_MAC80211(priv, "leave - skip\n");
3175 3176 3177
		return;
	}

Z
Zhu Yi 已提交
3178
	priv->is_open = 0;
3179

3180
	if (iwl_is_ready_rf(priv)) {
3181 3182 3183
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
3184
		mutex_lock(&priv->mutex);
3185
		iwl_scan_cancel_timeout(priv, 100);
3186 3187 3188
		mutex_unlock(&priv->mutex);
	}

3189 3190 3191
	iwl3945_down(priv);

	flush_workqueue(priv->workqueue);
3192 3193 3194 3195

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

3197
	IWL_DEBUG_MAC80211(priv, "leave\n");
Z
Zhu Yi 已提交
3198 3199
}

3200
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
3201
{
3202
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
3203

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

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

3209
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
3210 3211
		dev_kfree_skb_any(skb);

3212
	IWL_DEBUG_MAC80211(priv, "leave\n");
3213
	return NETDEV_TX_OK;
Z
Zhu Yi 已提交
3214 3215
}

A
Abhijeet Kolekar 已提交
3216
void iwl3945_config_ap(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3217 3218 3219
{
	int rc = 0;

3220
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
3221 3222 3223
		return;

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

		/* RXON - unassoc (to set timing command) */
3227
		priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3228
		iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3229 3230

		/* RXON Timing */
3231
		memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
3232
		iwl_setup_rxon_timing(priv);
3233 3234 3235
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
				      sizeof(priv->rxon_timing),
				      &priv->rxon_timing);
Z
Zhu Yi 已提交
3236
		if (rc)
3237
			IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
3238 3239 3240
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
3241
		priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
3242
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
3243
			priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3244 3245
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
3246
			priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3247 3248
				~RXON_FLG_SHORT_PREAMBLE_MSK;

3249
		if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
3250 3251
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
3252
				priv->staging_rxon.flags |=
Z
Zhu Yi 已提交
3253 3254
					RXON_FLG_SHORT_SLOT_MSK;
			else
3255
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3256 3257
					~RXON_FLG_SHORT_SLOT_MSK;

3258
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
3259
				priv->staging_rxon.flags &=
Z
Zhu Yi 已提交
3260 3261 3262
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
3263
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
A
Abhijeet Kolekar 已提交
3264
		iwlcore_commit_rxon(priv);
3265
		iwl_add_station(priv, iwl_bcast_addr, 0, CMD_SYNC, NULL);
3266
	}
C
Christoph Hellwig 已提交
3267
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
3268 3269 3270 3271 3272 3273

	/* 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 已提交
3274
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3275 3276 3277
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
Z
Zhu Yi 已提交
3278
{
3279
	struct iwl_priv *priv = hw->priv;
3280
	const u8 *addr;
3281 3282 3283
	int ret = 0;
	u8 sta_id = IWL_INVALID_STATION;
	u8 static_key;
Z
Zhu Yi 已提交
3284

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

3287
	if (iwl3945_mod_params.sw_crypto) {
3288
		IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
Z
Zhu Yi 已提交
3289 3290 3291
		return -EOPNOTSUPP;
	}

3292
	addr = sta ? sta->addr : iwl_bcast_addr;
3293 3294 3295
	static_key = !iwl_is_associated(priv);

	if (!static_key) {
3296
		sta_id = iwl_find_station(priv, addr);
3297
		if (sta_id == IWL_INVALID_STATION) {
3298
			IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
3299 3300 3301
					    addr);
			return -EINVAL;
		}
Z
Zhu Yi 已提交
3302 3303 3304
	}

	mutex_lock(&priv->mutex);
3305
	iwl_scan_cancel_timeout(priv, 100);
3306
	mutex_unlock(&priv->mutex);
3307

Z
Zhu Yi 已提交
3308
	switch (cmd) {
3309 3310 3311 3312 3313 3314
	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 已提交
3315 3316
		break;
	case DISABLE_KEY:
3317 3318 3319 3320 3321
		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 已提交
3322 3323
		break;
	default:
3324
		ret = -EINVAL;
Z
Zhu Yi 已提交
3325 3326
	}

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

3329
	return ret;
Z
Zhu Yi 已提交
3330 3331 3332 3333 3334 3335 3336 3337
}

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

S
Samuel Ortiz 已提交
3338
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
3339 3340 3341 3342 3343 3344 3345

/*
 * 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.
3346
 *
3347 3348 3349
 * 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 已提交
3350
 */
3351 3352
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
3353
{
3354 3355
	struct iwl_priv *priv = dev_get_drvdata(d);
	return sprintf(buf, "0x%08X\n", iwl_get_debug_level(priv));
Z
Zhu Yi 已提交
3356
}
3357 3358
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
3359 3360
				 const char *buf, size_t count)
{
3361
	struct iwl_priv *priv = dev_get_drvdata(d);
3362 3363
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
3364

3365 3366
	ret = strict_strtoul(buf, 0, &val);
	if (ret)
T
Tomas Winkler 已提交
3367
		IWL_INFO(priv, "%s is not in hex or decimal form.\n", buf);
3368
	else {
3369
		priv->debug_level = val;
3370 3371 3372 3373
		if (iwl_alloc_traffic_mem(priv))
			IWL_ERR(priv,
				"Not enough memory to generate traffic log\n");
	}
Z
Zhu Yi 已提交
3374 3375 3376
	return strnlen(buf, count);
}

3377 3378
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
3379

S
Samuel Ortiz 已提交
3380
#endif /* CONFIG_IWLWIFI_DEBUG */
Z
Zhu Yi 已提交
3381 3382 3383 3384

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

3387
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3388 3389
		return -EAGAIN;

C
Christoph Hellwig 已提交
3390
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
3391 3392 3393 3394 3395 3396 3397
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
3398
	struct iwl_priv *priv = dev_get_drvdata(d);
3399
	return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
Z
Zhu Yi 已提交
3400 3401 3402 3403 3404 3405
}

static ssize_t store_tx_power(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
3406
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3407 3408 3409 3410 3411
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
3412
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
3413
	else
C
Christoph Hellwig 已提交
3414
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
3415 3416 3417 3418 3419 3420 3421 3422 3423

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

3426
	return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
Z
Zhu Yi 已提交
3427 3428 3429 3430 3431 3432
}

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

	mutex_lock(&priv->mutex);
3437
	if (le32_to_cpu(priv->staging_rxon.flags) != flags) {
Z
Zhu Yi 已提交
3438
		/* Cancel any currently running scans... */
3439
		if (iwl_scan_cancel_timeout(priv, 100))
3440
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
3441
		else {
3442
			IWL_DEBUG_INFO(priv, "Committing rxon.flags = 0x%04X\n",
Z
Zhu Yi 已提交
3443
				       flags);
3444
			priv->staging_rxon.flags = cpu_to_le32(flags);
A
Abhijeet Kolekar 已提交
3445
			iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457
		}
	}
	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)
{
3458
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3459 3460

	return sprintf(buf, "0x%04X\n",
3461
		le32_to_cpu(priv->active_rxon.filter_flags));
Z
Zhu Yi 已提交
3462 3463 3464 3465 3466 3467
}

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

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

	return count;
}

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

3492
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3493 3494 3495 3496

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
3497
	struct iwl_priv *priv = dev_get_drvdata(d);
3498
	struct iwl_spectrum_notification measure_report;
Z
Zhu Yi 已提交
3499
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
3500
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529
	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)
{
3530
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3531
	struct ieee80211_measurement_params params = {
3532
		.channel = le16_to_cpu(priv->active_rxon.channel),
Z
Zhu Yi 已提交
3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553
		.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);
	}

3554
	IWL_DEBUG_INFO(priv, "Invoking measurement of type %d on "
Z
Zhu Yi 已提交
3555
		       "channel %d (for '%s')\n", type, params.channel, buf);
C
Christoph Hellwig 已提交
3556
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
3557 3558 3559 3560 3561 3562

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
3563
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
3564 3565 3566 3567 3568

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
3569
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580

	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)
{
3581
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3582 3583 3584 3585 3586 3587
	return sprintf(buf, "%d", priv->retry_rate);
}

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

3588

Z
Zhu Yi 已提交
3589 3590 3591
static ssize_t show_channels(struct device *d,
			     struct device_attribute *attr, char *buf)
{
3592 3593
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
3594 3595 3596 3597 3598 3599 3600
}

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
3601
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
3602
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
3603
	u32 len = 0, ofs = 0;
3604
	u8 *data = (u8 *)&priv->statistics_39;
Z
Zhu Yi 已提交
3605 3606
	int rc = 0;

3607
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3608 3609 3610
		return -EAGAIN;

	mutex_lock(&priv->mutex);
3611
	rc = iwl_send_statistics_request(priv, 0);
Z
Zhu Yi 已提交
3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638
	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)
{
3639
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3640

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

3644
	return sprintf(buf, "%d\n", iwl3945_mod_params.antenna);
Z
Zhu Yi 已提交
3645 3646 3647 3648 3649 3650
}

static ssize_t store_antenna(struct device *d,
			     struct device_attribute *attr,
			     const char *buf, size_t count)
{
3651
	struct iwl_priv *priv __maybe_unused = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3652 3653 3654 3655 3656 3657
	int ant;

	if (count == 0)
		return 0;

	if (sscanf(buf, "%1i", &ant) != 1) {
3658
		IWL_DEBUG_INFO(priv, "not in hex or decimal form.\n");
Z
Zhu Yi 已提交
3659 3660 3661 3662
		return count;
	}

	if ((ant >= 0) && (ant <= 2)) {
3663
		IWL_DEBUG_INFO(priv, "Setting antenna select to %d.\n", ant);
3664
		iwl3945_mod_params.antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
3665
	} else
3666
		IWL_DEBUG_INFO(priv, "Bad antenna select value %d.\n", ant);
Z
Zhu Yi 已提交
3667 3668 3669 3670 3671 3672 3673 3674 3675 3676


	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)
{
3677
	struct iwl_priv *priv = dev_get_drvdata(d);
3678
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3679 3680 3681 3682 3683 3684 3685 3686 3687 3688
		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)
{
3689
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3690 3691 3692
	char *p = (char *)buf;

	if (p[0] == '1')
3693
		iwl3945_dump_nic_error_log(priv);
Z
Zhu Yi 已提交
3694 3695 3696 3697 3698 3699 3700 3701

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
3702
 * driver setup and tear down
Z
Zhu Yi 已提交
3703 3704 3705
 *
 *****************************************************************************/

3706
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3707
{
3708
	priv->workqueue = create_singlethread_workqueue(DRV_NAME);
Z
Zhu Yi 已提交
3709 3710 3711

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
3712 3713 3714 3715 3716 3717
	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);
3718
	INIT_DELAYED_WORK(&priv->rfkill_poll, iwl3945_rfkill_poll);
S
Samuel Ortiz 已提交
3719 3720 3721 3722
	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 已提交
3723 3724

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
3725 3726

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

3730
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3731
{
C
Christoph Hellwig 已提交
3732
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
3733

3734
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
3735 3736 3737 3738 3739
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
3740
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
3741 3742 3743 3744 3745
	&dev_attr_antenna.attr,
	&dev_attr_channels.attr,
	&dev_attr_dump_errors.attr,
	&dev_attr_flags.attr,
	&dev_attr_filter_flags.attr,
3746
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3747 3748 3749 3750 3751 3752 3753
	&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 已提交
3754
#ifdef CONFIG_IWLWIFI_DEBUG
3755 3756
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
3757 3758 3759
	NULL
};

C
Christoph Hellwig 已提交
3760
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
3761
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
3762
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
3763 3764
};

C
Christoph Hellwig 已提交
3765 3766 3767 3768
static struct ieee80211_ops iwl3945_hw_ops = {
	.tx = iwl3945_mac_tx,
	.start = iwl3945_mac_start,
	.stop = iwl3945_mac_stop,
3769
	.add_interface = iwl_mac_add_interface,
3770
	.remove_interface = iwl_mac_remove_interface,
3771
	.config = iwl_mac_config,
3772
	.configure_filter = iwl_configure_filter,
C
Christoph Hellwig 已提交
3773
	.set_key = iwl3945_mac_set_key,
3774
	.get_tx_stats = iwl_mac_get_tx_stats,
A
Abhijeet Kolekar 已提交
3775
	.conf_tx = iwl_mac_conf_tx,
3776
	.reset_tsf = iwl_mac_reset_tsf,
3777
	.bss_info_changed = iwl_bss_info_changed,
3778
	.hw_scan = iwl_mac_hw_scan
Z
Zhu Yi 已提交
3779 3780
};

3781
static int iwl3945_init_drv(struct iwl_priv *priv)
3782 3783
{
	int ret;
3784
	struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797

	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 */
3798
	iwl_clear_stations_table(priv);
3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812

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

	priv->iw_mode = NL80211_IFTYPE_STATION;

	iwl_reset_qos(priv);

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

	priv->rates_mask = IWL_RATES_MASK;
3813
	priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
3814

3815 3816 3817 3818 3819 3820 3821
	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);
3822 3823 3824 3825 3826
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

3827 3828 3829 3830 3831 3832
	/* Set up txpower settings in driver for all channels */
	if (iwl3945_txpower_set_from_eeprom(priv)) {
		ret = -EIO;
		goto err_free_channel_map;
	}

3833
	ret = iwlcore_init_geos(priv);
3834 3835 3836 3837
	if (ret) {
		IWL_ERR(priv, "initializing geos failed: %d\n", ret);
		goto err_free_channel_map;
	}
3838 3839
	iwl3945_init_hw_rates(priv, priv->ieee_rates);

3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857
	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 已提交
3858
		    IEEE80211_HW_NOISE_DBM |
3859 3860 3861
		    IEEE80211_HW_SPECTRUM_MGMT |
		    IEEE80211_HW_SUPPORTS_PS |
		    IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
3862 3863 3864 3865 3866 3867 3868

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

	hw->wiphy->custom_regulatory = true;

3869 3870 3871
	/* Firmware does not support this */
	hw->wiphy->disable_beacon_hints = true;

J
Johannes Berg 已提交
3872 3873 3874
	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;
3875

3876 3877 3878
	/* Default value; 4 EDCA QOS priorities */
	hw->queues = 4;

3879 3880 3881
	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
3882

3883 3884 3885
	if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&priv->bands[IEEE80211_BAND_5GHZ];
3886

3887 3888 3889 3890 3891 3892
	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;
3893

3894
	return 0;
3895 3896
}

C
Christoph Hellwig 已提交
3897
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
3898 3899
{
	int err = 0;
3900
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
3901
	struct ieee80211_hw *hw;
3902
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
3903
	struct iwl3945_eeprom *eeprom;
3904
	unsigned long flags;
Z
Zhu Yi 已提交
3905

3906 3907 3908 3909
	/***********************
	 * 1. Allocating HW data
	 * ********************/

Z
Zhu Yi 已提交
3910 3911
	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
3912
	hw = iwl_alloc_all(cfg, &iwl3945_hw_ops);
Z
Zhu Yi 已提交
3913
	if (hw == NULL) {
3914
		printk(KERN_ERR DRV_NAME "Can not allocate network device\n");
Z
Zhu Yi 已提交
3915 3916 3917 3918
		err = -ENOMEM;
		goto out;
	}
	priv = hw->priv;
3919
	SET_IEEE80211_DEV(hw, &pdev->dev);
3920

3921 3922 3923 3924
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
3925
	if (iwl3945_mod_params.disable_hw_scan) {
3926
		IWL_DEBUG_INFO(priv, "Disabling hw_scan\n");
3927 3928 3929
		iwl3945_hw_ops.hw_scan = NULL;
	}

3930

3931
	IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
3932 3933
	priv->cfg = cfg;
	priv->pci_dev = pdev;
3934
	priv->inta_mask = CSR_INI_SET_MASK;
3935

S
Samuel Ortiz 已提交
3936
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
3937 3938
	atomic_set(&priv->restrict_refcnt, 0);
#endif
3939 3940
	if (iwl_alloc_traffic_mem(priv))
		IWL_ERR(priv, "Not enough memory to generate traffic log\n");
Z
Zhu Yi 已提交
3941

3942 3943 3944
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
3945 3946 3947 3948 3949 3950 3951
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

3952
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
3953
	if (!err)
3954
		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
3955
	if (err) {
T
Tomas Winkler 已提交
3956
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
3957 3958 3959 3960 3961 3962 3963
		goto out_pci_disable_device;
	}

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

3965 3966 3967
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
3968 3969 3970 3971 3972 3973
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

3974
	IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
Z
Zhu Yi 已提交
3975
			(unsigned long long) pci_resource_len(pdev, 0));
3976
	IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
Z
Zhu Yi 已提交
3977

3978 3979 3980
	/* 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 已提交
3981

M
Mohamed Abbas 已提交
3982 3983 3984 3985 3986
	/* this spin lock will be used in apm_ops.init and EEPROM access
	 * we should init now
	 */
	spin_lock_init(&priv->reg_lock);

3987 3988
	/* amp init */
	err = priv->cfg->ops->lib->apm_ops.init(priv);
3989
	if (err < 0) {
3990
		IWL_DEBUG_INFO(priv, "Failed to init the card\n");
3991
		goto out_iounmap;
3992
	}
Z
Zhu Yi 已提交
3993

3994 3995 3996
	/***********************
	 * 4. Read EEPROM
	 * ********************/
3997

3998
	/* Read the EEPROM */
3999
	err = iwl_eeprom_init(priv);
4000
	if (err) {
4001
		IWL_ERR(priv, "Unable to init EEPROM\n");
4002
		goto out_iounmap;
4003 4004
	}
	/* MAC Address location in EEPROM same for 3945/4965 */
4005 4006
	eeprom = (struct iwl3945_eeprom *)priv->eeprom;
	memcpy(priv->mac_addr, eeprom->mac_address, ETH_ALEN);
4007
	IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->mac_addr);
4008
	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
Z
Zhu Yi 已提交
4009

4010 4011 4012
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
4013
	/* Device-specific setup */
4014
	if (iwl3945_hw_set_hw_params(priv)) {
4015
		IWL_ERR(priv, "failed to set hw settings\n");
4016
		goto out_eeprom_free;
Z
Zhu Yi 已提交
4017 4018
	}

4019 4020 4021 4022
	/***********************
	 * 6. Setup priv
	 * ********************/

4023
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
4024
	if (err) {
4025
		IWL_ERR(priv, "initializing driver failed\n");
4026
		goto out_unset_hw_params;
Z
Zhu Yi 已提交
4027 4028
	}

T
Tomas Winkler 已提交
4029 4030
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
4031 4032

	/***********************
4033
	 * 7. Setup Services
4034 4035 4036
	 * ********************/

	spin_lock_irqsave(&priv->lock, flags);
4037
	iwl_disable_interrupts(priv);
4038 4039
	spin_unlock_irqrestore(&priv->lock, flags);

4040 4041
	pci_enable_msi(priv->pci_dev);

M
Mohamed Abbas 已提交
4042 4043
	err = request_irq(priv->pci_dev->irq, priv->cfg->ops->lib->isr,
			  IRQF_SHARED, DRV_NAME, priv);
4044 4045 4046 4047 4048
	if (err) {
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

4049
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
4050
	if (err) {
4051
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
4052
		goto out_release_irq;
4053 4054
	}

4055 4056
	iwl_set_rxon_channel(priv,
			     &priv->bands[IEEE80211_BAND_2GHZ].channels[5]);
4057 4058
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);
B
Ben Cahill 已提交
4059
	iwl_power_initialize(priv);
4060 4061

	/*********************************
4062
	 * 8. Setup and Register mac80211
4063 4064
	 * *******************************/

4065
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
4066

4067 4068 4069
	err = iwl3945_setup_mac(priv);
	if (err)
		goto  out_remove_sysfs;
4070

A
Abhijeet Kolekar 已提交
4071 4072 4073 4074
	err = iwl_dbgfs_register(priv, DRV_NAME);
	if (err)
		IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);

4075 4076 4077 4078
	/* Start monitoring the killswitch */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   2 * HZ);

Z
Zhu Yi 已提交
4079 4080
	return 0;

4081
 out_remove_sysfs:
4082 4083
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
4084
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
4085
 out_release_irq:
4086 4087 4088
	free_irq(priv->pci_dev->irq, priv);
 out_disable_msi:
	pci_disable_msi(priv->pci_dev);
4089 4090 4091 4092 4093 4094
	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 已提交
4095 4096 4097 4098 4099 4100
 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);
4101
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
4102
 out_ieee80211_free_hw:
4103
	iwl_free_traffic_mem(priv);
4104
	ieee80211_free_hw(priv->hw);
Z
Zhu Yi 已提交
4105 4106 4107 4108
 out:
	return err;
}

4109
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
4110
{
4111
	struct iwl_priv *priv = pci_get_drvdata(pdev);
4112
	unsigned long flags;
Z
Zhu Yi 已提交
4113 4114 4115 4116

	if (!priv)
		return;

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

A
Abhijeet Kolekar 已提交
4119 4120
	iwl_dbgfs_unregister(priv);

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

4123 4124 4125 4126 4127 4128
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
4129

4130 4131 4132 4133
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
4134
	iwl_disable_interrupts(priv);
4135 4136 4137 4138
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

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

4141
	cancel_delayed_work_sync(&priv->rfkill_poll);
4142

C
Christoph Hellwig 已提交
4143
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
4144 4145

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

4149
	iwl3945_unset_hw_params(priv);
4150
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
4151

4152 4153 4154
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
4155
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
4156 4157 4158 4159
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
4160
	iwl_free_traffic_mem(priv);
Z
Zhu Yi 已提交
4161

4162 4163 4164
	free_irq(pdev->irq, priv);
	pci_disable_msi(pdev);

Z
Zhu Yi 已提交
4165 4166 4167 4168 4169
	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

4170
	iwl_free_channel_map(priv);
4171
	iwlcore_free_geos(priv);
W
Winkler, Tomas 已提交
4172
	kfree(priv->scan);
Z
Zhu Yi 已提交
4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}


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

C
Christoph Hellwig 已提交
4186
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
4187
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
4188 4189 4190
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
4191
#ifdef CONFIG_PM
4192 4193
	.suspend = iwl_pci_suspend,
	.resume = iwl_pci_resume,
Z
Zhu Yi 已提交
4194 4195 4196
#endif
};

C
Christoph Hellwig 已提交
4197
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
4198 4199 4200 4201 4202
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
4203 4204 4205

	ret = iwl3945_rate_control_register();
	if (ret) {
4206 4207
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
4208 4209 4210
		return ret;
	}

C
Christoph Hellwig 已提交
4211
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
4212
	if (ret) {
4213
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
4214
		goto error_register;
Z
Zhu Yi 已提交
4215 4216 4217
	}

	return ret;
4218 4219 4220 4221

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
4222 4223
}

C
Christoph Hellwig 已提交
4224
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
4225
{
C
Christoph Hellwig 已提交
4226
	pci_unregister_driver(&iwl3945_driver);
4227
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
4228 4229
}

4230
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
4231

4232
module_param_named(antenna, iwl3945_mod_params.antenna, int, S_IRUGO);
Z
Zhu Yi 已提交
4233
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
4234
module_param_named(swcrypto, iwl3945_mod_params.sw_crypto, int, S_IRUGO);
4235 4236
MODULE_PARM_DESC(swcrypto,
		 "using software crypto (default 1 [software])\n");
4237
#ifdef CONFIG_IWLWIFI_DEBUG
4238
module_param_named(debug, iwl_debug_level, uint, S_IRUGO | S_IWUSR);
Z
Zhu Yi 已提交
4239
MODULE_PARM_DESC(debug, "debug output mask");
4240
#endif
4241 4242
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan,
		   int, S_IRUGO);
Z
Zhu Yi 已提交
4243
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");
4244
module_param_named(fw_restart3945, iwl3945_mod_params.restart_fw, int, S_IRUGO);
4245 4246
MODULE_PARM_DESC(fw_restart3945, "restart firmware in case of error");

C
Christoph Hellwig 已提交
4247 4248
module_exit(iwl3945_exit);
module_init(iwl3945_init);