iwl3945-base.c 120.3 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
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/

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

#include <net/ieee80211_radiotap.h>
44
#include <net/lib80211.h>
Z
Zhu Yi 已提交
45 46 47 48
#include <net/mac80211.h>

#include <asm/div64.h>

49 50
#define DRV_NAME	"iwl3945"

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

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

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

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

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

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


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

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

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 133 134
/**
 * 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 */
}

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

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

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

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

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

172 173 174
	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 已提交
175

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

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

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

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

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

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

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

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

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

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

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

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

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

		priv->frames_count++;
		return frame;
	}

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

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

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

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

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

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

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

343
	rate = iwl_rate_get_lowest_plcp(priv);
Z
Zhu Yi 已提交
344

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

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

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

	return rc;
}

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

#define MAX_UCODE_BEACON_INTERVAL	1024
365
#define INTEL_CONN_LISTEN_INTERVAL	cpu_to_le16(0xA)
Z
Zhu Yi 已提交
366

C
Christoph Hellwig 已提交
367
static __le16 iwl3945_adjust_beacon_interval(u16 beacon_val)
Z
Zhu Yi 已提交
368 369 370 371 372 373 374 375 376 377 378 379
{
	u16 new_val = 0;
	u16 beacon_factor = 0;

	beacon_factor =
	    (beacon_val + MAX_UCODE_BEACON_INTERVAL)
		/ MAX_UCODE_BEACON_INTERVAL;
	new_val = beacon_val / beacon_factor;

	return cpu_to_le16(new_val);
}

380
static void iwl3945_setup_rxon_timing(struct iwl_priv *priv)
Z
Zhu Yi 已提交
381 382 383 384 385 386 387 388 389 390
{
	u64 interval_tm_unit;
	u64 tsf, result;
	unsigned long flags;
	struct ieee80211_conf *conf = NULL;
	u16 beacon_int = 0;

	conf = ieee80211_get_hw_conf(priv->hw);

	spin_lock_irqsave(&priv->lock, flags);
391
	priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
Z
Zhu Yi 已提交
392 393
	priv->rxon_timing.listen_interval = INTEL_CONN_LISTEN_INTERVAL;

394
	tsf = priv->timestamp;
Z
Zhu Yi 已提交
395 396 397 398

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

399
	if (priv->iw_mode == NL80211_IFTYPE_STATION) {
Z
Zhu Yi 已提交
400 401 402 403 404 405 406
		if (beacon_int == 0) {
			priv->rxon_timing.beacon_interval = cpu_to_le16(100);
			priv->rxon_timing.beacon_init_val = cpu_to_le32(102400);
		} else {
			priv->rxon_timing.beacon_interval =
				cpu_to_le16(beacon_int);
			priv->rxon_timing.beacon_interval =
C
Christoph Hellwig 已提交
407
			    iwl3945_adjust_beacon_interval(
Z
Zhu Yi 已提交
408 409 410 411 412 413
				le16_to_cpu(priv->rxon_timing.beacon_interval));
		}

		priv->rxon_timing.atim_window = 0;
	} else {
		priv->rxon_timing.beacon_interval =
414 415
			iwl3945_adjust_beacon_interval(
				priv->vif->bss_conf.beacon_int);
Z
Zhu Yi 已提交
416 417 418 419 420 421 422 423 424 425 426
		/* TODO: we need to get atim_window from upper stack
		 * for now we set to 0 */
		priv->rxon_timing.atim_window = 0;
	}

	interval_tm_unit =
		(le16_to_cpu(priv->rxon_timing.beacon_interval) * 1024);
	result = do_div(tsf, interval_tm_unit);
	priv->rxon_timing.beacon_init_val =
	    cpu_to_le32((u32) ((u64) interval_tm_unit - result));

427 428
	IWL_DEBUG_ASSOC(priv,
		"beacon interval %d beacon timer %d beacon tim %d\n",
Z
Zhu Yi 已提交
429 430 431 432 433
		le16_to_cpu(priv->rxon_timing.beacon_interval),
		le32_to_cpu(priv->rxon_timing.beacon_init_val),
		le16_to_cpu(priv->rxon_timing.atim_window));
}

434
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl_priv *priv,
435
				      struct ieee80211_tx_info *info,
436
				      struct iwl_cmd *cmd,
Z
Zhu Yi 已提交
437
				      struct sk_buff *skb_frag,
438
				      int sta_id)
Z
Zhu Yi 已提交
439
{
440
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
441
	struct iwl_hw_key *keyinfo = &priv->stations[sta_id].keyinfo;
Z
Zhu Yi 已提交
442 443 444

	switch (keyinfo->alg) {
	case ALG_CCMP:
445 446
		tx->sec_ctl = TX_CMD_SEC_CCM;
		memcpy(tx->key, keyinfo->key, keyinfo->keylen);
447
		IWL_DEBUG_TX(priv, "tx_cmd with AES hwcrypto\n");
Z
Zhu Yi 已提交
448 449 450 451 452 453
		break;

	case ALG_TKIP:
		break;

	case ALG_WEP:
454
		tx->sec_ctl = TX_CMD_SEC_WEP |
455
		    (info->control.hw_key->hw_key_idx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT;
Z
Zhu Yi 已提交
456 457

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

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

462
		IWL_DEBUG_TX(priv, "Configuring packet for WEP encryption "
463
			     "with key %d\n", info->control.hw_key->hw_key_idx);
Z
Zhu Yi 已提交
464 465 466
		break;

	default:
T
Tomas Winkler 已提交
467
		IWL_ERR(priv, "Unknown encode alg %d\n", keyinfo->alg);
Z
Zhu Yi 已提交
468 469 470 471 472 473 474
		break;
	}
}

/*
 * handle build REPLY_TX command notification.
 */
475
static void iwl3945_build_tx_cmd_basic(struct iwl_priv *priv,
476
				  struct iwl_cmd *cmd,
477
				  struct ieee80211_tx_info *info,
478
				  struct ieee80211_hdr *hdr, u8 std_id)
Z
Zhu Yi 已提交
479
{
480 481
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
	__le32 tx_flags = tx->tx_flags;
482
	__le16 fc = hdr->frame_control;
483
	u8 rc_flags = info->control.rates[0].flags;
Z
Zhu Yi 已提交
484

485
	tx->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
486
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Z
Zhu Yi 已提交
487
		tx_flags |= TX_CMD_FLG_ACK_MSK;
488
		if (ieee80211_is_mgmt(fc))
Z
Zhu Yi 已提交
489
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
490
		if (ieee80211_is_probe_resp(fc) &&
Z
Zhu Yi 已提交
491 492 493 494 495 496 497
		    !(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;
	}

498
	tx->sta_id = std_id;
499
	if (ieee80211_has_morefrags(fc))
Z
Zhu Yi 已提交
500 501
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

502 503
	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
504
		tx->tid_tspec = qc[0] & 0xf;
Z
Zhu Yi 已提交
505
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
506
	} else {
Z
Zhu Yi 已提交
507
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
508
	}
Z
Zhu Yi 已提交
509

510
	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
Z
Zhu Yi 已提交
511 512
		tx_flags |= TX_CMD_FLG_RTS_MSK;
		tx_flags &= ~TX_CMD_FLG_CTS_MSK;
513
	} else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
Z
Zhu Yi 已提交
514 515 516 517 518 519 520 521
		tx_flags &= ~TX_CMD_FLG_RTS_MSK;
		tx_flags |= TX_CMD_FLG_CTS_MSK;
	}

	if ((tx_flags & TX_CMD_FLG_RTS_MSK) || (tx_flags & TX_CMD_FLG_CTS_MSK))
		tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;

	tx_flags &= ~(TX_CMD_FLG_ANT_SEL_MSK);
522 523
	if (ieee80211_is_mgmt(fc)) {
		if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
524
			tx->timeout.pm_frame_timeout = cpu_to_le16(3);
Z
Zhu Yi 已提交
525
		else
526
			tx->timeout.pm_frame_timeout = cpu_to_le16(2);
M
Mohamed Abbas 已提交
527
	} else {
528
		tx->timeout.pm_frame_timeout = 0;
529
#ifdef CONFIG_IWLWIFI_LEDS
M
Mohamed Abbas 已提交
530 531 532
		priv->rxtxpackets += le16_to_cpu(cmd->cmd.tx.len);
#endif
	}
Z
Zhu Yi 已提交
533

534 535 536
	tx->driver_txop = 0;
	tx->tx_flags = tx_flags;
	tx->next_frame_len = 0;
Z
Zhu Yi 已提交
537 538 539 540 541
}

/*
 * start REPLY_TX command process
 */
542
static int iwl3945_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
Z
Zhu Yi 已提交
543 544
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
545
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
546
	struct iwl3945_tx_cmd *tx;
547
	struct iwl_tx_queue *txq = NULL;
548
	struct iwl_queue *q = NULL;
549
	struct iwl_cmd *out_cmd = NULL;
Z
Zhu Yi 已提交
550 551
	dma_addr_t phys_addr;
	dma_addr_t txcmd_phys;
552
	int txq_id = skb_get_queue_mapping(skb);
R
Reinette Chatre 已提交
553
	u16 len, idx, len_org, hdr_len; /* TODO: len_org is not used */
554 555
	u8 id;
	u8 unicast;
Z
Zhu Yi 已提交
556
	u8 sta_id;
557
	u8 tid = 0;
Z
Zhu Yi 已提交
558
	u16 seq_number = 0;
559
	__le16 fc;
Z
Zhu Yi 已提交
560
	u8 wait_write_ptr = 0;
561
	u8 *qc = NULL;
Z
Zhu Yi 已提交
562 563 564 565
	unsigned long flags;
	int rc;

	spin_lock_irqsave(&priv->lock, flags);
566
	if (iwl_is_rfkill(priv)) {
567
		IWL_DEBUG_DROP(priv, "Dropping - RF KILL\n");
Z
Zhu Yi 已提交
568 569 570
		goto drop_unlock;
	}

571
	if ((ieee80211_get_tx_rate(priv->hw, info)->hw_value & 0xFF) == IWL_INVALID_RATE) {
572
		IWL_ERR(priv, "ERROR: No TX rate available.\n");
Z
Zhu Yi 已提交
573 574 575 576 577 578
		goto drop_unlock;
	}

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

579
	fc = hdr->frame_control;
Z
Zhu Yi 已提交
580

S
Samuel Ortiz 已提交
581
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
582
	if (ieee80211_is_auth(fc))
583
		IWL_DEBUG_TX(priv, "Sending AUTH frame\n");
584
	else if (ieee80211_is_assoc_req(fc))
585
		IWL_DEBUG_TX(priv, "Sending ASSOC frame\n");
586
	else if (ieee80211_is_reassoc_req(fc))
587
		IWL_DEBUG_TX(priv, "Sending REASSOC frame\n");
Z
Zhu Yi 已提交
588 589
#endif

590
	/* drop all data frame if we are not associated */
591
	if (ieee80211_is_data(fc) &&
592
	    (!iwl_is_monitor_mode(priv)) && /* packet injection */
593
	    (!iwl_is_associated(priv) ||
594
	     ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id))) {
595
		IWL_DEBUG_DROP(priv, "Dropping - !iwl_is_associated\n");
Z
Zhu Yi 已提交
596 597 598 599 600
		goto drop_unlock;
	}

	spin_unlock_irqrestore(&priv->lock, flags);

601
	hdr_len = ieee80211_hdrlen(fc);
602 603

	/* Find (or create) index into station table for destination station */
604
	sta_id = iwl_get_sta_id(priv, hdr);
Z
Zhu Yi 已提交
605
	if (sta_id == IWL_INVALID_STATION) {
606
		IWL_DEBUG_DROP(priv, "Dropping - INVALID STATION: %pM\n",
J
Johannes Berg 已提交
607
			       hdr->addr1);
Z
Zhu Yi 已提交
608 609 610
		goto drop;
	}

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

613 614
	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
615
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
616
		seq_number = priv->stations[sta_id].tid[tid].seq_number &
Z
Zhu Yi 已提交
617 618 619
				IEEE80211_SCTL_SEQ;
		hdr->seq_ctrl = cpu_to_le16(seq_number) |
			(hdr->seq_ctrl &
620
				cpu_to_le16(IEEE80211_SCTL_FRAG));
Z
Zhu Yi 已提交
621 622
		seq_number += 0x10;
	}
623 624

	/* Descriptor for chosen Tx queue */
625
	txq = &priv->txq[txq_id];
Z
Zhu Yi 已提交
626 627 628 629
	q = &txq->q;

	spin_lock_irqsave(&priv->lock, flags);

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

632
	/* Set up driver data for this TFD */
W
Winkler, Tomas 已提交
633
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl_tx_info));
634
	txq->txb[q->write_ptr].skb[0] = skb;
635 636

	/* Init first empty entry in queue's array of Tx/cmd buffers */
637
	out_cmd = txq->cmd[idx];
638
	tx = (struct iwl3945_tx_cmd *)out_cmd->cmd.payload;
Z
Zhu Yi 已提交
639
	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
640
	memset(tx, 0, sizeof(*tx));
641 642 643 644 645 646 647

	/*
	 * 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 已提交
648 649
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
650
				INDEX_TO_SEQ(q->write_ptr)));
651 652

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

R
Reinette Chatre 已提交
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675

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


	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)
676
			priv->stations[sta_id].tid[tid].seq_number = seq_number;
R
Reinette Chatre 已提交
677 678 679 680 681 682 683 684 685 686 687 688
	} 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));
	iwl_print_hex_dump(priv, IWL_DL_TX, tx, sizeof(*tx));
	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx->hdr,
			   ieee80211_hdrlen(fc));

689 690 691 692 693 694 695 696 697
	/*
	 * 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.
	 */
698
	len = sizeof(struct iwl3945_tx_cmd) +
699
			sizeof(struct iwl_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
700 701 702 703 704 705 706 707 708

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

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

709 710
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
R
Reinette Chatre 已提交
711 712 713 714
	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*/
715
	pci_unmap_addr_set(&out_cmd->meta, mapping, txcmd_phys);
R
Reinette Chatre 已提交
716
	pci_unmap_len_set(&out_cmd->meta, len, len);
Z
Zhu Yi 已提交
717

718 719
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
720 721
	priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
						   txcmd_phys, len, 1, 0);
Z
Zhu Yi 已提交
722 723


724 725
	/* 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 已提交
726 727 728 729
	len = skb->len - hdr_len;
	if (len) {
		phys_addr = pci_map_single(priv->pci_dev, skb->data + hdr_len,
					   len, PCI_DMA_TODEVICE);
730 731 732
		priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
							   phys_addr, len,
							   0, U32_PAD(len));
Z
Zhu Yi 已提交
733 734 735
	}


736
	/* Tell device the write index *just past* this latest filled TFD */
T
Tomas Winkler 已提交
737
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
738
	rc = iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
739 740 741 742 743
	spin_unlock_irqrestore(&priv->lock, flags);

	if (rc)
		return rc;

744
	if ((iwl_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
745 746 747 748
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
749
			iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
750 751 752
			spin_unlock_irqrestore(&priv->lock, flags);
		}

753
		iwl_stop_queue(priv, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
754 755 756 757 758 759 760 761 762 763
	}

	return 0;

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

764
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
765 766 767 768 769 770 771 772 773 774 775 776 777 778

#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 已提交
779
static u32 iwl3945_usecs_to_beacons(u32 usec, u32 beacon_interval)
Z
Zhu Yi 已提交
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
{
	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 已提交
798
static __le32 iwl3945_add_beacon_time(u32 base, u32 addon, u32 beacon_interval)
Z
Zhu Yi 已提交
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
{
	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);
}

817
static int iwl3945_get_measurement(struct iwl_priv *priv,
Z
Zhu Yi 已提交
818 819 820
			       struct ieee80211_measurement_params *params,
			       u8 type)
{
821
	struct iwl_spectrum_cmd spectrum;
822
	struct iwl_rx_packet *res;
823
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
824 825 826 827 828 829 830 831 832
		.id = REPLY_SPECTRUM_MEASUREMENT_CMD,
		.data = (void *)&spectrum,
		.meta.flags = CMD_WANT_SKB,
	};
	u32 add_time = le64_to_cpu(params->start_time);
	int rc;
	int spectrum_resp_status;
	int duration = le16_to_cpu(params->duration);

833
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
834
		add_time =
C
Christoph Hellwig 已提交
835
		    iwl3945_usecs_to_beacons(
Z
Zhu Yi 已提交
836 837 838 839 840 841 842 843 844 845 846 847
			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));

848
	if (iwl_is_associated(priv))
Z
Zhu Yi 已提交
849
		spectrum.start_time =
C
Christoph Hellwig 已提交
850
		    iwl3945_add_beacon_time(priv->last_beacon_time,
Z
Zhu Yi 已提交
851 852 853 854 855 856 857 858
				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;
859
	if (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK)
Z
Zhu Yi 已提交
860 861 862
		spectrum.flags |= RXON_FLG_BAND_24G_MSK |
		    RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK;

863
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
864 865 866
	if (rc)
		return rc;

867
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
868
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
869
		IWL_ERR(priv, "Bad return from REPLY_RX_ON_ASSOC command\n");
Z
Zhu Yi 已提交
870 871 872 873 874 875 876
		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) {
877
			IWL_DEBUG_INFO(priv, "Replaced existing measurement: %d\n",
878
						res->u.spectrum.id);
Z
Zhu Yi 已提交
879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895
			priv->measurement_status &= ~MEASUREMENT_READY;
		}
		priv->measurement_status |= MEASUREMENT_ACTIVE;
		rc = 0;
		break;

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

	dev_kfree_skb_any(cmd.meta.u.skb);

	return rc;
}
#endif

896
static void iwl3945_rx_reply_alive(struct iwl_priv *priv,
897
			       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
898
{
899 900
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl_alive_resp *palive;
Z
Zhu Yi 已提交
901 902 903 904
	struct delayed_work *pwork;

	palive = &pkt->u.alive_frame;

905
	IWL_DEBUG_INFO(priv, "Alive ucode status 0x%08X revision "
Z
Zhu Yi 已提交
906 907 908 909 910
		       "0x%01X 0x%01X\n",
		       palive->is_valid, palive->ver_type,
		       palive->ver_subtype);

	if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
911
		IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
912 913
		memcpy(&priv->card_alive_init, &pkt->u.alive_frame,
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
914 915
		pwork = &priv->init_alive_start;
	} else {
916
		IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
917
		memcpy(&priv->card_alive, &pkt->u.alive_frame,
918
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
919
		pwork = &priv->alive_start;
C
Christoph Hellwig 已提交
920
		iwl3945_disable_events(priv);
Z
Zhu Yi 已提交
921 922 923 924 925 926 927 928
	}

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

932
static void iwl3945_rx_reply_add_sta(struct iwl_priv *priv,
933
				 struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
934
{
935
#ifdef CONFIG_IWLWIFI_DEBUG
936
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
937
#endif
Z
Zhu Yi 已提交
938

939
	IWL_DEBUG_RX(priv, "Received REPLY_ADD_STA: 0x%02X\n", pkt->u.status);
Z
Zhu Yi 已提交
940 941 942
	return;
}

C
Christoph Hellwig 已提交
943
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
944
{
945 946
	struct iwl_priv *priv =
		container_of(work, struct iwl_priv, beacon_update);
Z
Zhu Yi 已提交
947 948 949
	struct sk_buff *beacon;

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

	if (!beacon) {
953
		IWL_ERR(priv, "update beacon failed\n");
Z
Zhu Yi 已提交
954 955 956 957 958 959 960 961 962 963 964
		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 已提交
965
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
966 967
}

968
static void iwl3945_rx_beacon_notif(struct iwl_priv *priv,
969
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
970
{
S
Samuel Ortiz 已提交
971
#ifdef CONFIG_IWLWIFI_DEBUG
972
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
C
Christoph Hellwig 已提交
973
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
974 975
	u8 rate = beacon->beacon_notify_hdr.rate;

976
	IWL_DEBUG_RX(priv, "beacon status %x retries %d iss %d "
Z
Zhu Yi 已提交
977 978 979 980 981 982 983 984
		"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

985
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
986 987 988 989 990 991
	    (!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 */
992
static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
993
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
994
{
995
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
996 997 998
	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
	unsigned long status = priv->status;

999
	IWL_DEBUG_RF_KILL(priv, "Card state received: HW:%s SW:%s\n",
Z
Zhu Yi 已提交
1000 1001 1002
			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
			  (flags & SW_CARD_DISABLED) ? "Kill" : "On");

1003
	iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
1004 1005 1006 1007 1008 1009 1010 1011
		    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);


1012
	iwl_scan_cancel(priv);
Z
Zhu Yi 已提交
1013 1014

	if ((test_bit(STATUS_RF_KILL_HW, &status) !=
J
Johannes Berg 已提交
1015 1016 1017
	     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 已提交
1018 1019 1020 1021 1022
	else
		wake_up_interruptible(&priv->wait_command_queue);
}

/**
C
Christoph Hellwig 已提交
1023
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
1024 1025 1026 1027 1028 1029 1030
 *
 * 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.
 */
1031
static void iwl3945_setup_rx_handlers(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1032
{
C
Christoph Hellwig 已提交
1033 1034
	priv->rx_handlers[REPLY_ALIVE] = iwl3945_rx_reply_alive;
	priv->rx_handlers[REPLY_ADD_STA] = iwl3945_rx_reply_add_sta;
1035
	priv->rx_handlers[REPLY_ERROR] = iwl_rx_reply_error;
1036
	priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl_rx_csa;
A
Abhijeet Kolekar 已提交
1037
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
1038
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
A
Abhijeet Kolekar 已提交
1039
	    iwl_rx_pm_debug_statistics_notif;
C
Christoph Hellwig 已提交
1040
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
1041

1042 1043 1044 1045
	/*
	 * 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 已提交
1046
	 */
C
Christoph Hellwig 已提交
1047 1048
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
1049

1050
	iwl_setup_spectrum_handlers(priv);
1051
	iwl_setup_rx_scan_handlers(priv);
C
Christoph Hellwig 已提交
1052
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
1053

1054
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
1055
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
}

/************************** 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.
 *
1080
 * During initialization, the host sets up the READ queue position to the first
Z
Zhu Yi 已提交
1081 1082
 * INDEX position, and WRITE to the last (READ - 1 wrapped)
 *
1083
 * When the firmware places a packet in a buffer, it will advance the READ index
Z
Zhu Yi 已提交
1084 1085 1086 1087 1088 1089 1090
 * 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
1091
 *   to replenish the iwl->rxq->rx_free.
C
Christoph Hellwig 已提交
1092
 * + In iwl3945_rx_replenish (scheduled) if 'processed' != 'read' then the
Z
Zhu Yi 已提交
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
 *   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:
 *
1105
 * iwl3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
C
Christoph Hellwig 已提交
1106
 *                            iwl3945_rx_queue_restock
1107
 * iwl3945_rx_queue_restock() Moves available buffers from rx_free into Rx
Z
Zhu Yi 已提交
1108 1109
 *                            queue, updates firmware pointers, and updates
 *                            the WRITE index.  If insufficient rx_free buffers
C
Christoph Hellwig 已提交
1110
 *                            are available, schedules iwl3945_rx_replenish
Z
Zhu Yi 已提交
1111 1112
 *
 * -- enable interrupts --
1113
 * ISR - iwl3945_rx()         Detach iwl_rx_mem_buffers from pool up to the
Z
Zhu Yi 已提交
1114 1115
 *                            READ INDEX, detaching the SKB from the pool.
 *                            Moves the packet buffer from queue to rx_used.
C
Christoph Hellwig 已提交
1116
 *                            Calls iwl3945_rx_queue_restock to refill any empty
Z
Zhu Yi 已提交
1117 1118 1119 1120 1121 1122
 *                            slots.
 * ...
 *
 */

/**
1123
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
1124
 */
1125
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1126 1127 1128 1129 1130 1131
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

/**
C
Christoph Hellwig 已提交
1132
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
1133
 *
1134
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
1135
 * and we have free pre-allocated buffers, fill the ranks as much
1136
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
1137 1138 1139 1140 1141
 *
 * 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.
 */
1142
static int iwl3945_rx_queue_restock(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1143
{
1144
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1145
	struct list_head *element;
1146
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1147 1148 1149 1150 1151
	unsigned long flags;
	int write, rc;

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
1152
	while ((iwl_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
1153
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
1154
		element = rxq->rx_free.next;
1155
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
Z
Zhu Yi 已提交
1156
		list_del(element);
1157 1158

		/* Point to Rx buffer via next RBD in circular buffer */
1159
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->real_dma_addr);
Z
Zhu Yi 已提交
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170
		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);


1171 1172
	/* If we've added more space for the firmware to place data, tell it.
	 * Increment device's write pointer in multiples of 8. */
1173
	if ((rxq->write_actual != (rxq->write & ~0x7))
Z
Zhu Yi 已提交
1174 1175 1176 1177
	    || (abs(rxq->write - rxq->read) > 7)) {
		spin_lock_irqsave(&rxq->lock, flags);
		rxq->need_update = 1;
		spin_unlock_irqrestore(&rxq->lock, flags);
1178
		rc = iwl_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
1179 1180 1181 1182 1183 1184 1185 1186
		if (rc)
			return rc;
	}

	return 0;
}

/**
C
Christoph Hellwig 已提交
1187
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
1188 1189 1190
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
1191
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
1192
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
1193
 */
1194
static void iwl3945_rx_allocate(struct iwl_priv *priv, gfp_t priority)
Z
Zhu Yi 已提交
1195
{
1196
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1197
	struct list_head *element;
1198
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
1199
	unsigned long flags;
A
Abhijeet Kolekar 已提交
1200 1201 1202 1203 1204 1205 1206 1207 1208

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

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

Z
Zhu Yi 已提交
1209
		element = rxq->rx_used.next;
1210
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
A
Abhijeet Kolekar 已提交
1211 1212
		list_del(element);
		spin_unlock_irqrestore(&rxq->lock, flags);
1213 1214

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
1215
		rxb->skb =
1216
		    alloc_skb(priv->hw_params.rx_buf_size,
1217
				priority);
Z
Zhu Yi 已提交
1218 1219
		if (!rxb->skb) {
			if (net_ratelimit())
T
Tomas Winkler 已提交
1220
				IWL_CRIT(priv, ": Can not allocate SKB buffers\n");
Z
Zhu Yi 已提交
1221 1222 1223 1224 1225
			/* 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 已提交
1226 1227 1228 1229 1230 1231 1232 1233 1234

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

1235
		/* Get physical address of RB/SKB */
1236 1237 1238 1239
		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 已提交
1240 1241

		spin_lock_irqsave(&rxq->lock, flags);
Z
Zhu Yi 已提交
1242
		list_add_tail(&rxb->list, &rxq->rx_free);
A
Abhijeet Kolekar 已提交
1243
		priv->alloc_rxb_skb++;
Z
Zhu Yi 已提交
1244
		rxq->free_count++;
A
Abhijeet Kolekar 已提交
1245
		spin_unlock_irqrestore(&rxq->lock, flags);
Z
Zhu Yi 已提交
1246
	}
1247 1248
}

R
Reinette Chatre 已提交
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275
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;
1276
	rxq->write_actual = 0;
R
Reinette Chatre 已提交
1277 1278 1279
	spin_unlock_irqrestore(&rxq->lock, flags);
}

1280 1281
void iwl3945_rx_replenish(void *data)
{
1282
	struct iwl_priv *priv = data;
1283 1284
	unsigned long flags;

1285
	iwl3945_rx_allocate(priv, GFP_KERNEL);
Z
Zhu Yi 已提交
1286 1287

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
1288
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1289 1290 1291
	spin_unlock_irqrestore(&priv->lock, flags);
}

1292 1293 1294 1295 1296 1297 1298 1299
static void iwl3945_rx_replenish_now(struct iwl_priv *priv)
{
	iwl3945_rx_allocate(priv, GFP_ATOMIC);

	iwl3945_rx_queue_restock(priv);
}


R
Reinette Chatre 已提交
1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
/* 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 已提交
1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
/* 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 已提交
1345
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
1346
{
1347 1348
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
1349 1350
		return 60;

1351
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
1352
	 *   add 20 dB to make up for divide by 10 */
1353
	if (sig_ratio >= 100)
1354
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370

	/* 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 已提交
1371
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
{
	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;
}

/**
1406
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
1407 1408 1409 1410 1411
 *
 * Uses the priv->rx_handlers callback function array to invoke
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
1412
static void iwl3945_rx_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1413
{
1414
	struct iwl_rx_mem_buffer *rxb;
1415
	struct iwl_rx_packet *pkt;
1416
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
1417 1418 1419
	u32 r, i;
	int reclaim;
	unsigned long flags;
1420
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
1421
	u32 count = 8;
1422
	int total_empty = 0;
Z
Zhu Yi 已提交
1423

1424 1425
	/* 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 已提交
1426
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
1427 1428
	i = rxq->read;

1429 1430 1431 1432 1433 1434
	/* 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))
1435
		fill_rx = 1;
Z
Zhu Yi 已提交
1436 1437
	/* Rx interrupt, but nothing sent from uCode */
	if (i == r)
1438
		IWL_DEBUG(priv, IWL_DL_RX | IWL_DL_ISR, "r = %d, i = %d\n", r, i);
Z
Zhu Yi 已提交
1439 1440 1441 1442

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

1443
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
1444 1445 1446 1447 1448 1449
		 * 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 已提交
1450 1451 1452
		pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
				priv->hw_params.rx_buf_size,
				PCI_DMA_FROMDEVICE);
1453
		pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466

		/* 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 已提交
1467
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
1468
		if (priv->rx_handlers[pkt->hdr.cmd]) {
1469
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1470 1471 1472
				"r = %d, i = %d, %s, 0x%02x\n", r, i,
				get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
			priv->rx_handlers[pkt->hdr.cmd] (priv, rxb);
1473
			priv->isr_stats.rx_handlers[pkt->hdr.cmd]++;
Z
Zhu Yi 已提交
1474 1475
		} else {
			/* No handling needed */
1476
			IWL_DEBUG(priv, IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
1477 1478 1479 1480 1481 1482
				"r %d i %d No handler needed for %s, 0x%02x\n",
				r, i, get_cmd_string(pkt->hdr.cmd),
				pkt->hdr.cmd);
		}

		if (reclaim) {
1483
			/* Invoke any callbacks, transfer the skb to caller, and
1484
			 * fire off the (possibly) blocking iwl_send_cmd()
Z
Zhu Yi 已提交
1485 1486
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
1487
				iwl_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
1488
			else
1489
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
		}

		/* 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;
1505 1506 1507 1508 1509 1510
		/* 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;
1511
				iwl3945_rx_replenish_now(priv);
1512 1513 1514
				count = 0;
			}
		}
Z
Zhu Yi 已提交
1515 1516 1517 1518
	}

	/* Backtrack one entry */
	priv->rxq.read = i;
1519 1520 1521 1522
	if (fill_rx)
		iwl3945_rx_replenish_now(priv);
	else
		iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
1523 1524
}

1525
/* call this function to flush any scheduled tasklet */
1526
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
1527
{
T
Tomas Winkler 已提交
1528
	/* wait to make sure we flush pending tasklet*/
1529 1530 1531 1532
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}

Z
Zhu Yi 已提交
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
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))

1556
static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1557 1558 1559 1560 1561 1562 1563
{
	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 已提交
1564
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1565
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
1566 1567 1568 1569
		return;
	}


1570
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
1571 1572

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

1578
	IWL_ERR(priv, "Desc       Time       asrtPC  blink2 "
Z
Zhu Yi 已提交
1579 1580 1581 1582
		  "ilink1  nmiPC   Line\n");
	for (i = ERROR_START_OFFSET;
	     i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
	     i += ERROR_ELEM_SIZE) {
1583
		desc = iwl_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
1584
		time =
1585
		    iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
1586
		blink1 =
1587
		    iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
1588
		blink2 =
1589
		    iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
1590
		ilink1 =
1591
		    iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
1592
		ilink2 =
1593
		    iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
1594
		data1 =
1595
		    iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
1596

1597 1598 1599 1600
		IWL_ERR(priv,
			"%-13s (#%d) %010u 0x%05X 0x%05X 0x%05X 0x%05X %u\n\n",
			desc_lookup(desc), desc, time, blink1, blink2,
			ilink1, ilink2, data1);
Z
Zhu Yi 已提交
1601 1602 1603 1604
	}

}

1605
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
1606 1607

/**
C
Christoph Hellwig 已提交
1608
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
1609 1610
 *
 */
1611
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634
				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++) {
1635
		ev = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1636
		ptr += sizeof(u32);
1637
		time = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1638
		ptr += sizeof(u32);
1639 1640 1641 1642
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
		} else {
1643
			data = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
1644
			ptr += sizeof(u32);
1645
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
Z
Zhu Yi 已提交
1646 1647 1648 1649
		}
	}
}

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

	/* event log header */
1666 1667 1668 1669
	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 已提交
1670 1671 1672 1673 1674

	size = num_wraps ? capacity : next_entry;

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

1679
	IWL_ERR(priv, "Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
1680 1681 1682 1683 1684
		  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 已提交
1685
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
1686 1687 1688
				    capacity - next_entry, mode);

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

}

1693
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1694 1695 1696 1697
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
S
Samuel Ortiz 已提交
1698
#ifdef CONFIG_IWLWIFI_DEBUG
Z
Zhu Yi 已提交
1699 1700 1701 1702 1703 1704 1705 1706
	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. */
1707 1708
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
1709 1710 1711 1712

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

S
Samuel Ortiz 已提交
1716
#ifdef CONFIG_IWLWIFI_DEBUG
1717
	if (priv->debug_level & IWL_DL_ISR) {
1718
		/* just for debug */
1719
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
1720
		IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
Z
Zhu Yi 已提交
1721 1722 1723 1724 1725 1726 1727 1728
			      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 已提交
1729
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
1730
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
1731
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
1732 1733 1734 1735
		inta |= CSR_INT_BIT_FH_TX;

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

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

1741
		priv->isr_stats.hw++;
1742
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1743 1744 1745 1746 1747 1748 1749 1750

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

S
Samuel Ortiz 已提交
1751
#ifdef CONFIG_IWLWIFI_DEBUG
1752
	if (priv->debug_level & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
1753
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
1754
		if (inta & CSR_INT_BIT_SCD) {
1755
			IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
1756
				      "the frame/frames.\n");
1757 1758
			priv->isr_stats.sch++;
		}
Z
Zhu Yi 已提交
1759 1760

		/* Alive notification via Rx interrupt will do the real work */
1761
		if (inta & CSR_INT_BIT_ALIVE) {
1762
			IWL_DEBUG_ISR(priv, "Alive interrupt\n");
1763 1764
			priv->isr_stats.alive++;
		}
Z
Zhu Yi 已提交
1765 1766 1767
	}
#endif
	/* Safely ignore these bits for debug checks below */
1768
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
1769 1770 1771

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
1772 1773
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
1774 1775
		priv->isr_stats.sw++;
		priv->isr_stats.sw_err = inta;
1776
		iwl_irq_handle_error(priv);
Z
Zhu Yi 已提交
1777 1778 1779 1780 1781
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
1782
		IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
1783
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
1784 1785 1786 1787 1788 1789
		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 已提交
1790

1791
		priv->isr_stats.wakeup++;
Z
Zhu Yi 已提交
1792 1793 1794 1795 1796 1797 1798
		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 已提交
1799
		iwl3945_rx_handle(priv);
1800
		priv->isr_stats.rx++;
Z
Zhu Yi 已提交
1801 1802 1803 1804
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

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

1808
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
M
Mohamed Abbas 已提交
1809 1810
		iwl_write_direct32(priv, FH39_TCSR_CREDIT
					(FH39_SRVC_CHNL), 0x0);
Z
Zhu Yi 已提交
1811 1812 1813
		handled |= CSR_INT_BIT_FH_TX;
	}

1814
	if (inta & ~handled) {
1815
		IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
1816 1817
		priv->isr_stats.unhandled++;
	}
Z
Zhu Yi 已提交
1818

1819
	if (inta & ~priv->inta_mask) {
1820
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
1821
			 inta & ~priv->inta_mask);
1822
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
1823 1824 1825
	}

	/* Re-enable all interrupts */
1826 1827
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
1828
		iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
1829

S
Samuel Ortiz 已提交
1830
#ifdef CONFIG_IWLWIFI_DEBUG
1831
	if (priv->debug_level & (IWL_DL_ISR)) {
1832 1833 1834
		inta = iwl_read32(priv, CSR_INT);
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
1835
		IWL_DEBUG_ISR(priv, "End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
Z
Zhu Yi 已提交
1836 1837 1838 1839 1840 1841
			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
	}
#endif
	spin_unlock_irqrestore(&priv->lock, flags);
}

1842
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
1843
					 enum ieee80211_band band,
1844
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
1845
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
1846 1847
{
	const struct ieee80211_channel *channels = NULL;
1848
	const struct ieee80211_supported_band *sband;
1849
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
1850 1851 1852 1853
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
1854
	sband = iwl_get_hw_mode(priv, band);
1855
	if (!sband)
Z
Zhu Yi 已提交
1856 1857
		return 0;

1858
	channels = sband->channels;
Z
Zhu Yi 已提交
1859

S
Samuel Ortiz 已提交
1860 1861
	active_dwell = iwl_get_active_dwell_time(priv, band, n_probes);
	passive_dwell = iwl_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
1862

1863 1864 1865
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

1866
	for (i = 0, added = 0; i < sband->n_channels; i++) {
1867 1868 1869
		if (channels[i].flags & IEEE80211_CHAN_DISABLED)
			continue;

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

1872
		ch_info = iwl_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
1873
		if (!is_channel_valid(ch_info)) {
1874
			IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
1875 1876 1877 1878
				       scan_ch->channel);
			continue;
		}

1879 1880 1881 1882 1883
		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 已提交
1884
		if (!is_active || is_channel_passive(ch_info) ||
1885
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
1886
			scan_ch->type = 0;	/* passive */
1887 1888 1889
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
1890
			scan_ch->type = 1;	/* active */
1891
		}
Z
Zhu Yi 已提交
1892

1893 1894 1895 1896 1897 1898
		/* 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)
1899
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
1900 1901 1902 1903
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
1904
				scan_ch->type |= IWL39_SCAN_PROBE_MASK(n_probes);
1905
		}
Z
Zhu Yi 已提交
1906

1907
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
1908 1909 1910 1911
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
1912
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
1913 1914 1915 1916
			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
1917
			 * power level:
1918
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
1919 1920 1921
			 */
		}

1922
		IWL_DEBUG_SCAN(priv, "Scanning %d [%s %d]\n",
Z
Zhu Yi 已提交
1923 1924 1925 1926 1927 1928 1929 1930 1931
			       scan_ch->channel,
			       (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
			       (scan_ch->type & 1) ?
			       active_dwell : passive_dwell);

		scan_ch++;
		added++;
	}

1932
	IWL_DEBUG_SCAN(priv, "total channels to scan %d \n", added);
Z
Zhu Yi 已提交
1933 1934 1935
	return added;
}

1936
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1937 1938 1939 1940 1941
			      struct ieee80211_rate *rates)
{
	int i;

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

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

1962
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1963
{
1964 1965 1966 1967 1968 1969
	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 已提交
1970 1971 1972
}

/**
C
Christoph Hellwig 已提交
1973
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
1974 1975
 *     looking at all data.
 */
1976
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
1977 1978 1979 1980 1981 1982
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

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

1985
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
1986
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
1987 1988 1989 1990 1991 1992

	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 */
1993
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
1994
		if (val != le32_to_cpu(*image)) {
1995
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
				  "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)
2007 2008
		IWL_DEBUG_INFO(priv,
			"ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
2009 2010 2011 2012 2013 2014

	return rc;
}


/**
C
Christoph Hellwig 已提交
2015
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
2016 2017 2018
 *   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.
 */
2019
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
2020 2021 2022 2023 2024 2025
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

2026
	IWL_DEBUG_INFO(priv, "ucode inst image size is %u\n", len);
Z
Zhu Yi 已提交
2027 2028 2029 2030 2031

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

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2065
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
2066
	if (rc == 0) {
2067
		IWL_DEBUG_INFO(priv, "Bootstrap uCode is good in inst SRAM\n");
Z
Zhu Yi 已提交
2068 2069 2070 2071 2072 2073
		return 0;
	}

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

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

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

2091 2092 2093
	/* 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 已提交
2094 2095
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
2096
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
2097 2098 2099 2100

	return rc;
}

2101
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2102 2103
{
	/* Remove all resets to allow NIC to operate */
2104
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
2105 2106 2107
}

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

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

2151 2152
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
2153 2154 2155

	/* Make sure that we got at least our header! */
	if (ucode_raw->size < sizeof(*ucode)) {
2156
		IWL_ERR(priv, "File size way too small!\n");
2157
		ret = -EINVAL;
Z
Zhu Yi 已提交
2158 2159 2160 2161 2162 2163
		goto err_release;
	}

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

2164
	priv->ucode_ver = le32_to_cpu(ucode->ver);
2165
	api_ver = IWL_UCODE_API(priv->ucode_ver);
Z
Zhu Yi 已提交
2166 2167 2168 2169 2170 2171
	inst_size = le32_to_cpu(ucode->inst_size);
	data_size = le32_to_cpu(ucode->data_size);
	init_size = le32_to_cpu(ucode->init_size);
	init_data_size = le32_to_cpu(ucode->init_data_size);
	boot_size = le32_to_cpu(ucode->boot_size);

2172 2173
	/* api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
2174
	 * on the API version read from firmware header from here on forward */
2175 2176

	if (api_ver < api_min || api_ver > api_max) {
2177
		IWL_ERR(priv, "Driver unable to support your firmware API. "
2178 2179 2180 2181 2182 2183 2184
			  "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)
2185
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
2186 2187 2188 2189
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
2190 2191 2192 2193 2194 2195
	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));

2196
	IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
2197
		       priv->ucode_ver);
2198 2199 2200 2201 2202 2203 2204 2205 2206 2207
	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 已提交
2208

2209

Z
Zhu Yi 已提交
2210 2211 2212 2213 2214
	/* Verify size of file vs. image size info in file's header */
	if (ucode_raw->size < sizeof(*ucode) +
		inst_size + data_size + init_size +
		init_data_size + boot_size) {

2215 2216
		IWL_DEBUG_INFO(priv, "uCode file size %zd too small\n",
			       ucode_raw->size);
2217
		ret = -EINVAL;
Z
Zhu Yi 已提交
2218 2219 2220 2221
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
2222
	if (inst_size > IWL39_MAX_INST_SIZE) {
2223
		IWL_DEBUG_INFO(priv, "uCode instr len %d too large to fit in\n",
2224 2225
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
2226 2227 2228
		goto err_release;
	}

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

	priv->ucode_data.len = data_size;
2266
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
2267 2268

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

2271 2272 2273
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
2274 2275

	/* Initialization instructions and data */
2276 2277
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
2278
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
2279 2280

		priv->ucode_init_data.len = init_data_size;
2281
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
2282 2283 2284 2285

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

	/* Bootstrap (instructions only, no data) */
2288 2289
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
2290
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
2291

2292 2293 2294
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
2295 2296 2297 2298 2299 2300

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

	/* Runtime instructions (first block of data in file) */
	src = &ucode->data[0];
	len = priv->ucode_code.len;
2301 2302
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode instr len %zd\n", len);
Z
Zhu Yi 已提交
2303
	memcpy(priv->ucode_code.v_addr, src, len);
2304
	IWL_DEBUG_INFO(priv, "uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
Z
Zhu Yi 已提交
2305 2306 2307
		priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
2308
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
Z
Zhu Yi 已提交
2309 2310
	src = &ucode->data[inst_size];
	len = priv->ucode_data.len;
2311 2312
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) uCode data len %zd\n", len);
Z
Zhu Yi 已提交
2313 2314 2315 2316 2317 2318 2319
	memcpy(priv->ucode_data.v_addr, src, len);
	memcpy(priv->ucode_data_backup.v_addr, src, len);

	/* Initialization instructions (3rd block) */
	if (init_size) {
		src = &ucode->data[inst_size + data_size];
		len = priv->ucode_init.len;
2320 2321
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init instr len %zd\n", len);
Z
Zhu Yi 已提交
2322 2323 2324 2325 2326 2327 2328
		memcpy(priv->ucode_init.v_addr, src, len);
	}

	/* Initialization data (4th block) */
	if (init_data_size) {
		src = &ucode->data[inst_size + data_size + init_size];
		len = priv->ucode_init_data.len;
2329 2330
		IWL_DEBUG_INFO(priv,
			"Copying (but not loading) init data len %zd\n", len);
Z
Zhu Yi 已提交
2331 2332 2333 2334 2335 2336
		memcpy(priv->ucode_init_data.v_addr, src, len);
	}

	/* Bootstrap instructions (5th block) */
	src = &ucode->data[inst_size + data_size + init_size + init_data_size];
	len = priv->ucode_boot.len;
2337 2338
	IWL_DEBUG_INFO(priv,
		"Copying (but not loading) boot instr len %zd\n", len);
Z
Zhu Yi 已提交
2339 2340 2341 2342 2343 2344 2345
	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:
2346
	IWL_ERR(priv, "failed to allocate pci memory\n");
2347
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
2348
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
2349 2350 2351 2352 2353

 err_release:
	release_firmware(ucode_raw);

 error:
2354
	return ret;
Z
Zhu Yi 已提交
2355 2356 2357 2358
}


/**
C
Christoph Hellwig 已提交
2359
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
2360 2361 2362 2363 2364 2365 2366
 *
 * 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.
 */
2367
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2368 2369 2370 2371 2372 2373 2374 2375 2376
{
	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 */
2377 2378 2379
	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 已提交
2380 2381
				 priv->ucode_data.len);

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

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

M
Mohamed Abbas 已提交
2389
	return 0;
Z
Zhu Yi 已提交
2390 2391 2392
}

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

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

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

/**
C
Christoph Hellwig 已提交
2436
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
2437
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
2438
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
2439
 */
2440
static void iwl3945_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2441 2442 2443 2444
{
	int thermal_spin = 0;
	u32 rfkill;

2445
	IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
Z
Zhu Yi 已提交
2446 2447 2448 2449

	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 */
2450
		IWL_DEBUG_INFO(priv, "Alive failed.\n");
Z
Zhu Yi 已提交
2451 2452 2453 2454 2455 2456
		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 已提交
2457
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
2458 2459
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
2460
		IWL_DEBUG_INFO(priv, "Bad runtime uCode load.\n");
Z
Zhu Yi 已提交
2461 2462 2463
		goto restart;
	}

2464
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2465

2466
	rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
2467
	IWL_DEBUG_INFO(priv, "RFKILL status: 0x%x\n", rfkill);
Z
Zhu Yi 已提交
2468 2469 2470

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
2471
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
2472
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
2473
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
2474 2475 2476 2477 2478
			thermal_spin++;
			udelay(10);
		}

		if (thermal_spin)
2479
			IWL_DEBUG_INFO(priv, "Thermal calibration took %dus\n",
Z
Zhu Yi 已提交
2480 2481 2482 2483
				       thermal_spin * 10);
	} else
		set_bit(STATUS_RF_KILL_HW, &priv->status);

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

2487
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
2488 2489
		return;

2490
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
2491 2492 2493 2494

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

2495
	iwl_power_update_mode(priv, false);
Z
Zhu Yi 已提交
2496

2497
	if (iwl_is_associated(priv)) {
C
Christoph Hellwig 已提交
2498
		struct iwl3945_rxon_cmd *active_rxon =
2499
				(struct iwl3945_rxon_cmd *)(&priv->active_rxon);
Z
Zhu Yi 已提交
2500

2501
		priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
Z
Zhu Yi 已提交
2502 2503 2504
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
2505
		iwl_connection_init_rx_config(priv, priv->iw_mode);
Z
Zhu Yi 已提交
2506 2507
	}

2508
	/* Configure Bluetooth device coexistence support */
2509
	iwl_send_bt_config(priv);
Z
Zhu Yi 已提交
2510 2511

	/* Configure the adapter for unassociated operation */
A
Abhijeet Kolekar 已提交
2512
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
2513 2514 2515

	iwl3945_reg_txpower_periodic(priv);

2516 2517
	iwl3945_led_register(priv);

2518
	IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
2519
	set_bit(STATUS_READY, &priv->status);
2520
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
2521

2522 2523 2524 2525 2526
	/* 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)
2527
			iwl_mac_beacon_update(priv->hw, beacon);
2528 2529
	}

A
Abhijeet Kolekar 已提交
2530
	if (test_and_clear_bit(STATUS_MODE_PENDING, &priv->status))
2531
		iwl_set_mode(priv, priv->iw_mode);
A
Abhijeet Kolekar 已提交
2532

Z
Zhu Yi 已提交
2533 2534 2535 2536 2537 2538
	return;

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

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

2541
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2542 2543 2544 2545 2546
{
	unsigned long flags;
	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
	struct ieee80211_conf *conf = NULL;

2547
	IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
Z
Zhu Yi 已提交
2548 2549 2550 2551 2552 2553

	conf = ieee80211_get_hw_conf(priv->hw);

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

M
Mohamed Abbas 已提交
2554
	iwl3945_led_unregister(priv);
2555
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2556 2557 2558 2559 2560 2561 2562 2563 2564 2565

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

	/* tell the device to stop sending interrupts */
2569
	spin_lock_irqsave(&priv->lock, flags);
2570
	iwl_disable_interrupts(priv);
2571 2572
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
2573 2574 2575 2576

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

C
Christoph Hellwig 已提交
2577
	/* If we have not previously called iwl3945_init() then
2578
	 * clear all bits but the RF Kill bits and return */
2579
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
2580 2581
		priv->status = test_bit(STATUS_RF_KILL_HW, &priv->status) <<
					STATUS_RF_KILL_HW |
2582 2583
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
2584 2585
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2586 2587 2588
		goto exit;
	}

2589
	/* ...otherwise clear out all the status bits but the RF Kill
J
Johannes Berg 已提交
2590
	 * bit and continue taking the NIC down. */
Z
Zhu Yi 已提交
2591 2592
	priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
				STATUS_RF_KILL_HW |
2593 2594
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
2595
			test_bit(STATUS_FW_ERROR, &priv->status) <<
2596 2597 2598
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
2599

2600
	priv->cfg->ops->lib->apm_ops.reset(priv);
Z
Zhu Yi 已提交
2601
	spin_lock_irqsave(&priv->lock, flags);
2602
	iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
Z
Zhu Yi 已提交
2603 2604
	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
2605 2606
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
2607

M
Mohamed Abbas 已提交
2608 2609
	iwl_write_prph(priv, APMG_CLK_DIS_REG,
				APMG_CLK_VAL_DMA_CLK_RQT);
Z
Zhu Yi 已提交
2610 2611 2612

	udelay(5);

2613
	if (exit_pending)
2614 2615 2616 2617
		priv->cfg->ops->lib->apm_ops.stop(priv);
	else
		priv->cfg->ops->lib->apm_ops.reset(priv);

Z
Zhu Yi 已提交
2618
 exit:
2619
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
2620 2621 2622 2623 2624 2625

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
2626
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
2627 2628
}

2629
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2630 2631
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
2632
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
2633
	mutex_unlock(&priv->mutex);
2634

C
Christoph Hellwig 已提交
2635
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
2636 2637 2638 2639
}

#define MAX_HW_RESTARTS 5

2640
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2641 2642 2643 2644
{
	int rc, i;

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

2649
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
2650
		IWL_ERR(priv, "ucode not available for device bring up\n");
2651 2652 2653
		return -EIO;
	}

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

2664
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
2665

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

	/* make sure rfkill handshake bits are cleared */
2673 2674
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
2675 2676 2677
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
2678
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2679
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
2680 2681

	/* really make sure rfkill handshake bits are cleared */
2682 2683
	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 已提交
2684 2685 2686 2687 2688

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

2691 2692 2693 2694
	/* 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 已提交
2695 2696
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

2697
		iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
2698 2699 2700 2701

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

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

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

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

		return 0;
	}

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

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


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

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

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

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

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

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

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

2761 2762 2763 2764 2765 2766 2767 2768 2769 2770
static void iwl3945_rfkill_poll(struct work_struct *data)
{
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rfkill_poll.work);

	if (iwl_read32(priv, CSR_GP_CNTRL) & 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);

J
Johannes Berg 已提交
2771 2772
	wiphy_rfkill_set_hw_state(priv->hw->wiphy,
			test_bit(STATUS_RF_KILL_HW, &priv->status));
2773 2774 2775 2776 2777 2778

	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   round_jiffies_relative(2 * HZ));

}

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

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

2800 2801
	cancel_delayed_work(&priv->scan_check);

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

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

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

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

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

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

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

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

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

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

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

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

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

J
Johannes Berg 已提交
2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911
	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;
2912
	} else
J
Johannes Berg 已提交
2913
		IWL_DEBUG_SCAN(priv, "Kicking off passive scan.\n");
Z
Zhu Yi 已提交
2914 2915 2916 2917

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

	/* flags + rate selection */

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

S
Samuel Ortiz 已提交
2942
	scan->tx_cmd.len = cpu_to_le16(
J
Johannes Berg 已提交
2943 2944 2945 2946 2947
			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 已提交
2948

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

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

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

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

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

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

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

	mutex_unlock(&priv->mutex);
	return;

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

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

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

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

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

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

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

J
Johannes Berg 已提交
3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023
	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 已提交
3024 3025
}

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

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

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

3039 3040
#define IWL_DELAY_NEXT_SCAN (HZ*2)

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

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


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

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

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

3061
	iwl_scan_cancel_timeout(priv, 200);
3062

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

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

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

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

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

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

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

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

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

	}

A
Abhijeet Kolekar 已提交
3099
	iwlcore_commit_rxon(priv);
Z
Zhu Yi 已提交
3100 3101

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

3106
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
3107

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

		break;

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

3125
	iwl_activate_qos(priv, 0);
3126

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

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

3137 3138
#define UCODE_READY_TIMEOUT	(2 * HZ)

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

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

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

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

3161
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
3162 3163

	mutex_unlock(&priv->mutex);
3164

3165 3166 3167
	if (ret)
		goto out_release_irq;

3168
	IWL_DEBUG_INFO(priv, "Start UP work.\n");
3169

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

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

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

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

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

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

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

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

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

3221 3222 3223
	iwl3945_down(priv);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	/* FIXME - we need to add code here to detect a totally new
	 * configuration, reset the AP, unassoc, rxon timing, assoc,
	 * clear sta table, add BCAST sta... */
}

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

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

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

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

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

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

Z
Zhu Yi 已提交
3340
	switch (cmd) {
3341 3342 3343 3344 3345 3346
	case SET_KEY:
		if (static_key)
			ret = iwl3945_set_static_key(priv, key);
		else
			ret = iwl3945_set_dynamic_key(priv, key, sta_id);
		IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
Z
Zhu Yi 已提交
3347 3348
		break;
	case DISABLE_KEY:
3349 3350 3351 3352 3353
		if (static_key)
			ret = iwl3945_remove_static_key(priv);
		else
			ret = iwl3945_clear_sta_key_info(priv, sta_id);
		IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
Z
Zhu Yi 已提交
3354 3355
		break;
	default:
3356
		ret = -EINVAL;
Z
Zhu Yi 已提交
3357 3358
	}

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

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

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

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

/*
 * 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.
 */
3379 3380
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
3381
{
3382
	struct iwl_priv *priv = dev_get_drvdata(d);
3383 3384

	return sprintf(buf, "0x%08X\n", priv->debug_level);
Z
Zhu Yi 已提交
3385
}
3386 3387
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
3388 3389
				 const char *buf, size_t count)
{
3390
	struct iwl_priv *priv = dev_get_drvdata(d);
3391 3392
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
3393

3394 3395
	ret = strict_strtoul(buf, 0, &val);
	if (ret)
T
Tomas Winkler 已提交
3396
		IWL_INFO(priv, "%s is not in hex or decimal form.\n", buf);
Z
Zhu Yi 已提交
3397
	else
3398
		priv->debug_level = val;
Z
Zhu Yi 已提交
3399 3400 3401 3402

	return strnlen(buf, count);
}

3403 3404
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
3405

S
Samuel Ortiz 已提交
3406
#endif /* CONFIG_IWLWIFI_DEBUG */
Z
Zhu Yi 已提交
3407 3408 3409 3410

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

3413
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3414 3415
		return -EAGAIN;

C
Christoph Hellwig 已提交
3416
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
3417 3418 3419 3420 3421 3422 3423
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
3424
	struct iwl_priv *priv = dev_get_drvdata(d);
3425
	return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
Z
Zhu Yi 已提交
3426 3427 3428 3429 3430 3431
}

static ssize_t store_tx_power(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
3432
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3433 3434 3435 3436 3437
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
3438
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
3439
	else
C
Christoph Hellwig 已提交
3440
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
3441 3442 3443 3444 3445 3446 3447 3448 3449

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

3452
	return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
Z
Zhu Yi 已提交
3453 3454 3455 3456 3457 3458
}

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

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

	return sprintf(buf, "0x%04X\n",
3487
		le32_to_cpu(priv->active_rxon.filter_flags));
Z
Zhu Yi 已提交
3488 3489 3490 3491 3492 3493
}

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

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

	return count;
}

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

3518
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3519 3520 3521 3522

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

3580
	IWL_DEBUG_INFO(priv, "Invoking measurement of type %d on "
Z
Zhu Yi 已提交
3581
		       "channel %d (for '%s')\n", type, params.channel, buf);
C
Christoph Hellwig 已提交
3582
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
3583 3584 3585 3586 3587 3588

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
3589
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
3590 3591 3592 3593 3594

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
3595
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606

	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)
{
3607
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3608 3609 3610 3611 3612 3613
	return sprintf(buf, "%d", priv->retry_rate);
}

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

3614

Z
Zhu Yi 已提交
3615 3616 3617 3618
static ssize_t store_power_level(struct device *d,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
3619
	struct iwl_priv *priv = dev_get_drvdata(d);
3620 3621 3622
	int ret;
	unsigned long mode;

Z
Zhu Yi 已提交
3623 3624 3625

	mutex_lock(&priv->mutex);

3626 3627 3628
	ret = strict_strtoul(buf, 10, &mode);
	if (ret)
		goto out;
Z
Zhu Yi 已提交
3629

3630 3631 3632 3633
	ret = iwl_power_set_user_mode(priv, mode);
	if (ret) {
		IWL_DEBUG_MAC80211(priv, "failed setting power mode.\n");
		goto out;
Z
Zhu Yi 已提交
3634
	}
3635
	ret = count;
Z
Zhu Yi 已提交
3636 3637 3638

 out:
	mutex_unlock(&priv->mutex);
3639
	return ret;
Z
Zhu Yi 已提交
3640 3641
}

3642 3643 3644 3645 3646 3647 3648
static ssize_t show_power_level(struct device *d,
				struct device_attribute *attr, char *buf)
{
	struct iwl_priv *priv = dev_get_drvdata(d);
	int level = priv->power_data.power_mode;
	char *p = buf;

3649
	p += sprintf(p, "%d\n", level);
3650 3651 3652 3653 3654 3655
	return p - buf + 1;
}

static DEVICE_ATTR(power_level, S_IWUSR | S_IRUSR,
		   show_power_level, store_power_level);

Z
Zhu Yi 已提交
3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676
#define MAX_WX_STRING 80

/* Values are in microsecond */
static const s32 timeout_duration[] = {
	350000,
	250000,
	75000,
	37000,
	25000,
};
static const s32 period_duration[] = {
	400000,
	700000,
	1000000,
	1000000,
	1000000
};

static ssize_t show_channels(struct device *d,
			     struct device_attribute *attr, char *buf)
{
3677 3678
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
3679 3680 3681 3682 3683 3684 3685
}

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
3686
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
3687
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
3688
	u32 len = 0, ofs = 0;
3689
	u8 *data = (u8 *)&priv->statistics_39;
Z
Zhu Yi 已提交
3690 3691
	int rc = 0;

3692
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3693 3694 3695
		return -EAGAIN;

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

3726
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
3727 3728
		return -EAGAIN;

3729
	return sprintf(buf, "%d\n", iwl3945_mod_params.antenna);
Z
Zhu Yi 已提交
3730 3731 3732 3733 3734 3735
}

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

	if (count == 0)
		return 0;

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

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


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

	if (p[0] == '1')
3778
		iwl3945_dump_nic_error_log(priv);
Z
Zhu Yi 已提交
3779 3780 3781 3782 3783 3784 3785 3786 3787 3788

	return strnlen(buf, count);
}

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

static ssize_t dump_event_log(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
3789
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
3790 3791 3792
	char *p = (char *)buf;

	if (p[0] == '1')
3793
		iwl3945_dump_nic_event_log(priv);
Z
Zhu Yi 已提交
3794 3795 3796 3797 3798 3799 3800 3801

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
3802
 * driver setup and tear down
Z
Zhu Yi 已提交
3803 3804 3805
 *
 *****************************************************************************/

3806
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3807
{
3808
	priv->workqueue = create_singlethread_workqueue(DRV_NAME);
Z
Zhu Yi 已提交
3809 3810 3811

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
3812 3813 3814 3815 3816 3817
	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);
3818
	INIT_DELAYED_WORK(&priv->rfkill_poll, iwl3945_rfkill_poll);
S
Samuel Ortiz 已提交
3819 3820 3821 3822
	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 已提交
3823 3824

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
3825 3826

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

3830
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3831
{
C
Christoph Hellwig 已提交
3832
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
3833

3834
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
3835 3836 3837 3838 3839
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
3840
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
3841 3842 3843 3844 3845 3846
	&dev_attr_antenna.attr,
	&dev_attr_channels.attr,
	&dev_attr_dump_errors.attr,
	&dev_attr_dump_events.attr,
	&dev_attr_flags.attr,
	&dev_attr_filter_flags.attr,
3847
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
3848 3849 3850 3851 3852 3853 3854 3855
	&dev_attr_measurement.attr,
#endif
	&dev_attr_power_level.attr,
	&dev_attr_retry_rate.attr,
	&dev_attr_statistics.attr,
	&dev_attr_status.attr,
	&dev_attr_temperature.attr,
	&dev_attr_tx_power.attr,
S
Samuel Ortiz 已提交
3856
#ifdef CONFIG_IWLWIFI_DEBUG
3857 3858
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
3859 3860 3861
	NULL
};

C
Christoph Hellwig 已提交
3862
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
3863
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
3864
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
3865 3866
};

C
Christoph Hellwig 已提交
3867 3868 3869 3870
static struct ieee80211_ops iwl3945_hw_ops = {
	.tx = iwl3945_mac_tx,
	.start = iwl3945_mac_start,
	.stop = iwl3945_mac_stop,
3871
	.add_interface = iwl_mac_add_interface,
3872
	.remove_interface = iwl_mac_remove_interface,
3873
	.config = iwl_mac_config,
3874
	.configure_filter = iwl_configure_filter,
C
Christoph Hellwig 已提交
3875
	.set_key = iwl3945_mac_set_key,
3876
	.get_tx_stats = iwl_mac_get_tx_stats,
A
Abhijeet Kolekar 已提交
3877
	.conf_tx = iwl_mac_conf_tx,
3878
	.reset_tsf = iwl_mac_reset_tsf,
3879
	.bss_info_changed = iwl_bss_info_changed,
3880
	.hw_scan = iwl_mac_hw_scan
Z
Zhu Yi 已提交
3881 3882
};

3883
static int iwl3945_init_drv(struct iwl_priv *priv)
3884 3885
{
	int ret;
3886
	struct iwl3945_eeprom *eeprom = (struct iwl3945_eeprom *)priv->eeprom;
3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899

	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 */
3900
	iwl_clear_stations_table(priv);
3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914

	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;
3915 3916
	/* If power management is turned on, default to CAM mode */
	priv->power_mode = IWL_POWER_MODE_CAM;
3917
	priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
3918

3919 3920 3921 3922 3923 3924 3925
	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);
3926 3927 3928 3929 3930
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

3931 3932 3933 3934 3935 3936
	/* Set up txpower settings in driver for all channels */
	if (iwl3945_txpower_set_from_eeprom(priv)) {
		ret = -EIO;
		goto err_free_channel_map;
	}

3937
	ret = iwlcore_init_geos(priv);
3938 3939 3940 3941
	if (ret) {
		IWL_ERR(priv, "initializing geos failed: %d\n", ret);
		goto err_free_channel_map;
	}
3942 3943
	iwl3945_init_hw_rates(priv, priv->ieee_rates);

3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961
	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 已提交
3962 3963
		    IEEE80211_HW_NOISE_DBM |
		    IEEE80211_HW_SPECTRUM_MGMT;
3964 3965 3966 3967 3968 3969 3970

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

	hw->wiphy->custom_regulatory = true;

J
Johannes Berg 已提交
3971 3972 3973
	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;
3974

3975 3976 3977
	/* Default value; 4 EDCA QOS priorities */
	hw->queues = 4;

3978 3979 3980
	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
3981

3982 3983 3984
	if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&priv->bands[IEEE80211_BAND_5GHZ];
3985

3986 3987 3988 3989 3990 3991
	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;
3992

3993
	return 0;
3994 3995
}

C
Christoph Hellwig 已提交
3996
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
3997 3998
{
	int err = 0;
3999
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
4000
	struct ieee80211_hw *hw;
4001
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
4002
	struct iwl3945_eeprom *eeprom;
4003
	unsigned long flags;
Z
Zhu Yi 已提交
4004

4005 4006 4007 4008
	/***********************
	 * 1. Allocating HW data
	 * ********************/

Z
Zhu Yi 已提交
4009 4010
	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
4011
	hw = iwl_alloc_all(cfg, &iwl3945_hw_ops);
Z
Zhu Yi 已提交
4012
	if (hw == NULL) {
4013
		printk(KERN_ERR DRV_NAME "Can not allocate network device\n");
Z
Zhu Yi 已提交
4014 4015 4016 4017
		err = -ENOMEM;
		goto out;
	}
	priv = hw->priv;
4018
	SET_IEEE80211_DEV(hw, &pdev->dev);
4019

4020
	if ((iwl3945_mod_params.num_of_queues > IWL39_MAX_NUM_QUEUES) ||
4021
	     (iwl3945_mod_params.num_of_queues < IWL39_MIN_NUM_QUEUES)) {
4022 4023
		IWL_ERR(priv,
			"invalid queues_num, should be between %d and %d\n",
4024
			IWL39_MIN_NUM_QUEUES, IWL39_MAX_NUM_QUEUES);
4025
		err = -EINVAL;
4026
		goto out_ieee80211_free_hw;
4027 4028
	}

4029 4030 4031 4032
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
4033
	if (iwl3945_mod_params.disable_hw_scan) {
4034
		IWL_DEBUG_INFO(priv, "Disabling hw_scan\n");
4035 4036 4037
		iwl3945_hw_ops.hw_scan = NULL;
	}

4038

4039
	IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
4040 4041
	priv->cfg = cfg;
	priv->pci_dev = pdev;
4042
	priv->inta_mask = CSR_INI_SET_MASK;
4043

S
Samuel Ortiz 已提交
4044
#ifdef CONFIG_IWLWIFI_DEBUG
4045
	priv->debug_level = iwl3945_mod_params.debug;
Z
Zhu Yi 已提交
4046 4047 4048
	atomic_set(&priv->restrict_refcnt, 0);
#endif

4049 4050 4051
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
4052 4053 4054 4055 4056 4057 4058
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

4059
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
4060
	if (!err)
4061
		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
Z
Zhu Yi 已提交
4062
	if (err) {
T
Tomas Winkler 已提交
4063
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
4064 4065 4066 4067 4068 4069 4070
		goto out_pci_disable_device;
	}

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

4072 4073 4074
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
4075 4076 4077 4078 4079 4080
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

4081
	IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
Z
Zhu Yi 已提交
4082
			(unsigned long long) pci_resource_len(pdev, 0));
4083
	IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
Z
Zhu Yi 已提交
4084

4085 4086 4087
	/* 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 已提交
4088

M
Mohamed Abbas 已提交
4089 4090 4091 4092 4093
	/* this spin lock will be used in apm_ops.init and EEPROM access
	 * we should init now
	 */
	spin_lock_init(&priv->reg_lock);

4094 4095
	/* amp init */
	err = priv->cfg->ops->lib->apm_ops.init(priv);
4096
	if (err < 0) {
4097
		IWL_DEBUG_INFO(priv, "Failed to init the card\n");
4098
		goto out_iounmap;
4099
	}
Z
Zhu Yi 已提交
4100

4101 4102 4103
	/***********************
	 * 4. Read EEPROM
	 * ********************/
4104

4105
	/* Read the EEPROM */
4106
	err = iwl_eeprom_init(priv);
4107
	if (err) {
4108
		IWL_ERR(priv, "Unable to init EEPROM\n");
4109
		goto out_iounmap;
4110 4111
	}
	/* MAC Address location in EEPROM same for 3945/4965 */
4112 4113
	eeprom = (struct iwl3945_eeprom *)priv->eeprom;
	memcpy(priv->mac_addr, eeprom->mac_address, ETH_ALEN);
4114
	IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->mac_addr);
4115
	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
Z
Zhu Yi 已提交
4116

4117 4118 4119
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
4120
	/* Device-specific setup */
4121
	if (iwl3945_hw_set_hw_params(priv)) {
4122
		IWL_ERR(priv, "failed to set hw settings\n");
4123
		goto out_eeprom_free;
Z
Zhu Yi 已提交
4124 4125
	}

4126 4127 4128 4129
	/***********************
	 * 6. Setup priv
	 * ********************/

4130
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
4131
	if (err) {
4132
		IWL_ERR(priv, "initializing driver failed\n");
4133
		goto out_unset_hw_params;
Z
Zhu Yi 已提交
4134 4135
	}

T
Tomas Winkler 已提交
4136 4137
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
4138 4139

	/***********************
4140
	 * 7. Setup Services
4141 4142 4143
	 * ********************/

	spin_lock_irqsave(&priv->lock, flags);
4144
	iwl_disable_interrupts(priv);
4145 4146
	spin_unlock_irqrestore(&priv->lock, flags);

4147 4148
	pci_enable_msi(priv->pci_dev);

M
Mohamed Abbas 已提交
4149 4150
	err = request_irq(priv->pci_dev->irq, priv->cfg->ops->lib->isr,
			  IRQF_SHARED, DRV_NAME, priv);
4151 4152 4153 4154 4155
	if (err) {
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

4156
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
4157
	if (err) {
4158
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
4159
		goto out_release_irq;
4160 4161
	}

4162 4163
	iwl_set_rxon_channel(priv,
			     &priv->bands[IEEE80211_BAND_2GHZ].channels[5]);
4164 4165 4166 4167
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);

	/*********************************
4168
	 * 8. Setup and Register mac80211
4169 4170
	 * *******************************/

4171
	iwl_enable_interrupts(priv);
Z
Zhu Yi 已提交
4172

4173 4174 4175
	err = iwl3945_setup_mac(priv);
	if (err)
		goto  out_remove_sysfs;
4176

A
Abhijeet Kolekar 已提交
4177 4178 4179 4180
	err = iwl_dbgfs_register(priv, DRV_NAME);
	if (err)
		IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);

4181 4182 4183 4184
	/* Start monitoring the killswitch */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   2 * HZ);

Z
Zhu Yi 已提交
4185 4186
	return 0;

4187
 out_remove_sysfs:
4188 4189
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
4190
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
Z
Zhu Yi 已提交
4191
 out_release_irq:
4192 4193 4194
	free_irq(priv->pci_dev->irq, priv);
 out_disable_msi:
	pci_disable_msi(priv->pci_dev);
4195 4196 4197 4198 4199 4200
	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 已提交
4201 4202 4203 4204 4205 4206
 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);
4207
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
4208 4209 4210 4211 4212 4213
 out_ieee80211_free_hw:
	ieee80211_free_hw(priv->hw);
 out:
	return err;
}

4214
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
4215
{
4216
	struct iwl_priv *priv = pci_get_drvdata(pdev);
4217
	unsigned long flags;
Z
Zhu Yi 已提交
4218 4219 4220 4221

	if (!priv)
		return;

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

A
Abhijeet Kolekar 已提交
4224 4225
	iwl_dbgfs_unregister(priv);

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

4228 4229 4230 4231 4232 4233
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
4234

4235 4236 4237 4238
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
4239
	iwl_disable_interrupts(priv);
4240 4241 4242 4243
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

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

4246
	cancel_delayed_work_sync(&priv->rfkill_poll);
4247

C
Christoph Hellwig 已提交
4248
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
4249 4250

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

4254
	iwl3945_unset_hw_params(priv);
4255
	iwl_clear_stations_table(priv);
Z
Zhu Yi 已提交
4256

4257 4258 4259
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
4260
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
4261 4262 4263 4264 4265
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;

4266 4267 4268
	free_irq(pdev->irq, priv);
	pci_disable_msi(pdev);

Z
Zhu Yi 已提交
4269 4270 4271 4272 4273
	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

4274
	iwl_free_channel_map(priv);
4275
	iwlcore_free_geos(priv);
W
Winkler, Tomas 已提交
4276
	kfree(priv->scan);
Z
Zhu Yi 已提交
4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}


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

C
Christoph Hellwig 已提交
4290
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
4291
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
4292 4293 4294
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
4295
#ifdef CONFIG_PM
4296 4297
	.suspend = iwl_pci_suspend,
	.resume = iwl_pci_resume,
Z
Zhu Yi 已提交
4298 4299 4300
#endif
};

C
Christoph Hellwig 已提交
4301
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
4302 4303 4304 4305 4306
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
4307 4308 4309

	ret = iwl3945_rate_control_register();
	if (ret) {
4310 4311
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
4312 4313 4314
		return ret;
	}

C
Christoph Hellwig 已提交
4315
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
4316
	if (ret) {
4317
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
4318
		goto error_register;
Z
Zhu Yi 已提交
4319 4320 4321
	}

	return ret;
4322 4323 4324 4325

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
4326 4327
}

C
Christoph Hellwig 已提交
4328
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
4329
{
C
Christoph Hellwig 已提交
4330
	pci_unregister_driver(&iwl3945_driver);
4331
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
4332 4333
}

4334
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
4335

4336
module_param_named(antenna, iwl3945_mod_params.antenna, int, 0444);
Z
Zhu Yi 已提交
4337
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
4338 4339 4340
module_param_named(swcrypto, iwl3945_mod_params.sw_crypto, int, 0444);
MODULE_PARM_DESC(swcrypto,
		 "using software crypto (default 1 [software])\n");
4341
module_param_named(debug, iwl3945_mod_params.debug, uint, 0444);
Z
Zhu Yi 已提交
4342
MODULE_PARM_DESC(debug, "debug output mask");
4343
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
4344 4345
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

4346
module_param_named(queues_num, iwl3945_mod_params.num_of_queues, int, 0444);
Z
Zhu Yi 已提交
4347 4348
MODULE_PARM_DESC(queues_num, "number of hw queues.");

4349 4350 4351
module_param_named(fw_restart3945, iwl3945_mod_params.restart_fw, int, 0444);
MODULE_PARM_DESC(fw_restart3945, "restart firmware in case of error");

C
Christoph Hellwig 已提交
4352 4353
module_exit(iwl3945_exit);
module_init(iwl3945_init);