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

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

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

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

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

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


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

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

Z
Zhu Yi 已提交
96
/*************** STATION TABLE MANAGEMENT ****
97
 * mac80211 should be examined to determine if sta_info is duplicating
Z
Zhu Yi 已提交
98 99 100 101
 * the functionality provided here
 */

/**************************************************************/
102
#if 0 /* temporary disable till we add real remove station */
103 104 105 106 107
/**
 * iwl3945_remove_station - Remove driver's knowledge of station.
 *
 * NOTE:  This does not remove station from device's station table.
 */
108
static u8 iwl3945_remove_station(struct iwl_priv *priv, const u8 *addr, int is_ap)
Z
Zhu Yi 已提交
109 110 111 112 113 114 115 116 117 118
{
	int index = IWL_INVALID_STATION;
	int i;
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);

	if (is_ap)
		index = IWL_AP_ID;
	else if (is_broadcast_ether_addr(addr))
119
		index = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
120
	else
121
		for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++)
122 123
			if (priv->stations_39[i].used &&
			    !compare_ether_addr(priv->stations_39[i].sta.sta.addr,
Z
Zhu Yi 已提交
124 125 126 127 128 129 130 131
						addr)) {
				index = i;
				break;
			}

	if (unlikely(index == IWL_INVALID_STATION))
		goto out;

132 133
	if (priv->stations_39[index].used) {
		priv->stations_39[index].used = 0;
Z
Zhu Yi 已提交
134 135 136 137 138 139 140 141 142
		priv->num_stations--;
	}

	BUG_ON(priv->num_stations < 0);

out:
	spin_unlock_irqrestore(&priv->sta_lock, flags);
	return 0;
}
143
#endif
144 145 146 147 148 149

/**
 * iwl3945_clear_stations_table - Clear the driver's station table
 *
 * NOTE:  This does not clear or otherwise alter the device's station table.
 */
150
static void iwl3945_clear_stations_table(struct iwl_priv *priv)
Z
Zhu Yi 已提交
151 152 153 154 155 156
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);

	priv->num_stations = 0;
157
	memset(priv->stations_39, 0, sizeof(priv->stations_39));
Z
Zhu Yi 已提交
158 159 160 161

	spin_unlock_irqrestore(&priv->sta_lock, flags);
}

162 163 164
/**
 * iwl3945_add_station - Add station to station tables in driver and device
 */
165
u8 iwl3945_add_station(struct iwl_priv *priv, const u8 *addr, int is_ap, u8 flags)
Z
Zhu Yi 已提交
166 167 168
{
	int i;
	int index = IWL_INVALID_STATION;
C
Christoph Hellwig 已提交
169
	struct iwl3945_station_entry *station;
Z
Zhu Yi 已提交
170
	unsigned long flags_spin;
171
	u8 rate;
Z
Zhu Yi 已提交
172 173 174 175 176

	spin_lock_irqsave(&priv->sta_lock, flags_spin);
	if (is_ap)
		index = IWL_AP_ID;
	else if (is_broadcast_ether_addr(addr))
177
		index = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
178
	else
179
		for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++) {
180
			if (!compare_ether_addr(priv->stations_39[i].sta.sta.addr,
Z
Zhu Yi 已提交
181 182 183 184 185
						addr)) {
				index = i;
				break;
			}

186
			if (!priv->stations_39[i].used &&
Z
Zhu Yi 已提交
187 188 189 190
			    index == IWL_INVALID_STATION)
				index = i;
		}

191
	/* These two conditions has the same outcome but keep them separate
Z
Zhu Yi 已提交
192 193 194 195 196 197
	  since they have different meaning */
	if (unlikely(index == IWL_INVALID_STATION)) {
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return index;
	}

198 199
	if (priv->stations_39[index].used &&
	   !compare_ether_addr(priv->stations_39[index].sta.sta.addr, addr)) {
Z
Zhu Yi 已提交
200 201 202 203
		spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
		return index;
	}

J
Johannes Berg 已提交
204
	IWL_DEBUG_ASSOC("Add STA ID %d: %pM\n", index, addr);
205
	station = &priv->stations_39[index];
Z
Zhu Yi 已提交
206 207 208
	station->used = 1;
	priv->num_stations++;

209
	/* Set up the REPLY_ADD_STA command to send to device */
C
Christoph Hellwig 已提交
210
	memset(&station->sta, 0, sizeof(struct iwl3945_addsta_cmd));
Z
Zhu Yi 已提交
211 212 213 214 215
	memcpy(station->sta.sta.addr, addr, ETH_ALEN);
	station->sta.mode = 0;
	station->sta.sta.sta_id = index;
	station->sta.station_flags = 0;

216
	if (priv->band == IEEE80211_BAND_5GHZ)
217 218 219
		rate = IWL_RATE_6M_PLCP;
	else
		rate =	IWL_RATE_1M_PLCP;
220 221 222

	/* Turn on both antennas for the station... */
	station->sta.rate_n_flags =
C
Christoph Hellwig 已提交
223
			iwl3945_hw_set_rate_n_flags(rate, RATE_MCS_ANT_AB_MSK);
224

Z
Zhu Yi 已提交
225
	spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
226 227

	/* Add station to device's station table */
C
Christoph Hellwig 已提交
228
	iwl3945_send_add_station(priv, &station->sta, flags);
Z
Zhu Yi 已提交
229 230 231 232
	return index;

}

233
int iwl3945_send_statistics_request(struct iwl_priv *priv)
Z
Zhu Yi 已提交
234
{
235
	u32 val = 0;
Z
Zhu Yi 已提交
236

237
	struct iwl_host_cmd cmd = {
238
		.id = REPLY_STATISTICS_CMD,
Z
Zhu Yi 已提交
239 240 241 242
		.len = sizeof(val),
		.data = &val,
	};

243
	return iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
244 245 246
}

/**
C
Christoph Hellwig 已提交
247
 * iwl3945_set_rxon_channel - Set the phymode and channel values in staging RXON
248 249
 * @band: 2.4 or 5 GHz band
 * @channel: Any channel valid for the requested band
Z
Zhu Yi 已提交
250

251
 * In addition to setting the staging RXON, priv->band is also set.
Z
Zhu Yi 已提交
252 253
 *
 * NOTE:  Does not commit to the hardware; it sets appropriate bit fields
254
 * in the staging RXON flag structure based on the band
Z
Zhu Yi 已提交
255
 */
256
static int iwl3945_set_rxon_channel(struct iwl_priv *priv,
257 258
				    enum ieee80211_band band,
				    u16 channel)
Z
Zhu Yi 已提交
259
{
260
	if (!iwl3945_get_channel_info(priv, band, channel)) {
Z
Zhu Yi 已提交
261
		IWL_DEBUG_INFO("Could not set channel to %d [%d]\n",
262
			       channel, band);
Z
Zhu Yi 已提交
263 264 265
		return -EINVAL;
	}

266
	if ((le16_to_cpu(priv->staging39_rxon.channel) == channel) &&
267
	    (priv->band == band))
Z
Zhu Yi 已提交
268 269
		return 0;

270
	priv->staging39_rxon.channel = cpu_to_le16(channel);
271
	if (band == IEEE80211_BAND_5GHZ)
272
		priv->staging39_rxon.flags &= ~RXON_FLG_BAND_24G_MSK;
Z
Zhu Yi 已提交
273
	else
274
		priv->staging39_rxon.flags |= RXON_FLG_BAND_24G_MSK;
Z
Zhu Yi 已提交
275

276
	priv->band = band;
Z
Zhu Yi 已提交
277

278
	IWL_DEBUG_INFO("Staging channel set to %d [%d]\n", channel, band);
Z
Zhu Yi 已提交
279 280 281 282 283

	return 0;
}

/**
C
Christoph Hellwig 已提交
284
 * iwl3945_check_rxon_cmd - validate RXON structure is valid
Z
Zhu Yi 已提交
285 286 287 288 289
 *
 * NOTE:  This is really only useful during development and can eventually
 * be #ifdef'd out once the driver is stable and folks aren't actively
 * making changes
 */
290
static int iwl3945_check_rxon_cmd(struct iwl_priv *priv)
Z
Zhu Yi 已提交
291 292 293
{
	int error = 0;
	int counter = 1;
294
	struct iwl3945_rxon_cmd *rxon = &priv->staging39_rxon;
Z
Zhu Yi 已提交
295 296 297 298 299 300

	if (rxon->flags & RXON_FLG_BAND_24G_MSK) {
		error |= le32_to_cpu(rxon->flags &
				(RXON_FLG_TGJ_NARROW_BAND_MSK |
				 RXON_FLG_RADAR_DETECT_MSK));
		if (error)
301
			IWL_WARN(priv, "check 24G fields %d | %d\n",
Z
Zhu Yi 已提交
302 303 304 305 306
				    counter++, error);
	} else {
		error |= (rxon->flags & RXON_FLG_SHORT_SLOT_MSK) ?
				0 : le32_to_cpu(RXON_FLG_SHORT_SLOT_MSK);
		if (error)
307
			IWL_WARN(priv, "check 52 fields %d | %d\n",
Z
Zhu Yi 已提交
308 309 310
				    counter++, error);
		error |= le32_to_cpu(rxon->flags & RXON_FLG_CCK_MSK);
		if (error)
311
			IWL_WARN(priv, "check 52 CCK %d | %d\n",
Z
Zhu Yi 已提交
312 313 314 315
				    counter++, error);
	}
	error |= (rxon->node_addr[0] | rxon->bssid_addr[0]) & 0x1;
	if (error)
316
		IWL_WARN(priv, "check mac addr %d | %d\n", counter++, error);
Z
Zhu Yi 已提交
317 318 319 320 321

	/* make sure basic rates 6Mbps and 1Mbps are supported */
	error |= (((rxon->ofdm_basic_rates & IWL_RATE_6M_MASK) == 0) &&
		  ((rxon->cck_basic_rates & IWL_RATE_1M_MASK) == 0));
	if (error)
322
		IWL_WARN(priv, "check basic rate %d | %d\n", counter++, error);
Z
Zhu Yi 已提交
323 324 325

	error |= (le16_to_cpu(rxon->assoc_id) > 2007);
	if (error)
326
		IWL_WARN(priv, "check assoc id %d | %d\n", counter++, error);
Z
Zhu Yi 已提交
327 328 329 330

	error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK))
			== (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK));
	if (error)
331
		IWL_WARN(priv, "check CCK and short slot %d | %d\n",
Z
Zhu Yi 已提交
332 333 334 335 336
			    counter++, error);

	error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK))
			== (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK));
	if (error)
337
		IWL_WARN(priv, "check CCK & auto detect %d | %d\n",
Z
Zhu Yi 已提交
338 339 340 341 342
			    counter++, error);

	error |= ((rxon->flags & (RXON_FLG_AUTO_DETECT_MSK |
			RXON_FLG_TGG_PROTECT_MSK)) == RXON_FLG_TGG_PROTECT_MSK);
	if (error)
343
		IWL_WARN(priv, "check TGG and auto detect %d | %d\n",
Z
Zhu Yi 已提交
344 345 346 347 348 349
			    counter++, error);

	if ((rxon->flags & RXON_FLG_DIS_DIV_MSK))
		error |= ((rxon->flags & (RXON_FLG_ANT_B_MSK |
				RXON_FLG_ANT_A_MSK)) == 0);
	if (error)
350
		IWL_WARN(priv, "check antenna %d %d\n", counter++, error);
Z
Zhu Yi 已提交
351 352

	if (error)
353
		IWL_WARN(priv, "Tuning to channel %d\n",
Z
Zhu Yi 已提交
354 355 356
			    le16_to_cpu(rxon->channel));

	if (error) {
357
		IWL_ERR(priv, "Not a valid rxon_assoc_cmd field values\n");
Z
Zhu Yi 已提交
358 359 360 361 362 363
		return -1;
	}
	return 0;
}

/**
364
 * iwl3945_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
365
 * @priv: staging_rxon is compared to active_rxon
Z
Zhu Yi 已提交
366
 *
367 368 369
 * If the RXON structure is changing enough to require a new tune,
 * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
 * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
Z
Zhu Yi 已提交
370
 */
371
static int iwl3945_full_rxon_required(struct iwl_priv *priv)
Z
Zhu Yi 已提交
372 373 374
{

	/* These items are only settable from the full RXON command */
375
	if (!(iwl3945_is_associated(priv)) ||
376 377 378 379 380 381 382 383 384 385 386
	    compare_ether_addr(priv->staging39_rxon.bssid_addr,
			       priv->active39_rxon.bssid_addr) ||
	    compare_ether_addr(priv->staging39_rxon.node_addr,
			       priv->active39_rxon.node_addr) ||
	    compare_ether_addr(priv->staging39_rxon.wlap_bssid_addr,
			       priv->active39_rxon.wlap_bssid_addr) ||
	    (priv->staging39_rxon.dev_type != priv->active39_rxon.dev_type) ||
	    (priv->staging39_rxon.channel != priv->active39_rxon.channel) ||
	    (priv->staging39_rxon.air_propagation !=
	     priv->active39_rxon.air_propagation) ||
	    (priv->staging39_rxon.assoc_id != priv->active39_rxon.assoc_id))
Z
Zhu Yi 已提交
387 388 389 390 391 392 393
		return 1;

	/* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
	 * be updated with the RXON_ASSOC command -- however only some
	 * flag transitions are allowed using RXON_ASSOC */

	/* Check if we are not switching bands */
394 395
	if ((priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK) !=
	    (priv->active39_rxon.flags & RXON_FLG_BAND_24G_MSK))
Z
Zhu Yi 已提交
396 397 398
		return 1;

	/* Check if we are switching association toggle */
399 400
	if ((priv->staging39_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) !=
		(priv->active39_rxon.filter_flags & RXON_FILTER_ASSOC_MSK))
Z
Zhu Yi 已提交
401 402 403 404 405
		return 1;

	return 0;
}

406
static int iwl3945_send_rxon_assoc(struct iwl_priv *priv)
Z
Zhu Yi 已提交
407 408
{
	int rc = 0;
409
	struct iwl_rx_packet *res = NULL;
C
Christoph Hellwig 已提交
410
	struct iwl3945_rxon_assoc_cmd rxon_assoc;
411
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
412 413 414 415 416
		.id = REPLY_RXON_ASSOC,
		.len = sizeof(rxon_assoc),
		.meta.flags = CMD_WANT_SKB,
		.data = &rxon_assoc,
	};
417 418
	const struct iwl3945_rxon_cmd *rxon1 = &priv->staging39_rxon;
	const struct iwl3945_rxon_cmd *rxon2 = &priv->active39_rxon;
Z
Zhu Yi 已提交
419 420 421 422 423 424 425 426 427

	if ((rxon1->flags == rxon2->flags) &&
	    (rxon1->filter_flags == rxon2->filter_flags) &&
	    (rxon1->cck_basic_rates == rxon2->cck_basic_rates) &&
	    (rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) {
		IWL_DEBUG_INFO("Using current RXON_ASSOC.  Not resending.\n");
		return 0;
	}

428 429 430 431
	rxon_assoc.flags = priv->staging39_rxon.flags;
	rxon_assoc.filter_flags = priv->staging39_rxon.filter_flags;
	rxon_assoc.ofdm_basic_rates = priv->staging39_rxon.ofdm_basic_rates;
	rxon_assoc.cck_basic_rates = priv->staging39_rxon.cck_basic_rates;
Z
Zhu Yi 已提交
432 433
	rxon_assoc.reserved = 0;

434
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
435 436 437
	if (rc)
		return rc;

438
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
439
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
440
		IWL_ERR(priv, "Bad return from REPLY_RXON_ASSOC command\n");
Z
Zhu Yi 已提交
441 442 443 444 445 446 447 448 449 450
		rc = -EIO;
	}

	priv->alloc_rxb_skb--;
	dev_kfree_skb_any(cmd.meta.u.skb);

	return rc;
}

/**
C
Christoph Hellwig 已提交
451
 * iwl3945_commit_rxon - commit staging_rxon to hardware
Z
Zhu Yi 已提交
452
 *
453
 * The RXON command in staging_rxon is committed to the hardware and
Z
Zhu Yi 已提交
454 455 456 457
 * the active_rxon structure is updated with the new data.  This
 * function correctly transitions out of the RXON_ASSOC_MSK state if
 * a HW tune is required based on the RXON structure changes.
 */
458
static int iwl3945_commit_rxon(struct iwl_priv *priv)
Z
Zhu Yi 已提交
459 460
{
	/* cast away the const for active_rxon in this function */
461
	struct iwl3945_rxon_cmd *active_rxon = (void *)&priv->active39_rxon;
Z
Zhu Yi 已提交
462 463
	int rc = 0;

464
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
465 466 467
		return -1;

	/* always get timestamp with Rx frame */
468
	priv->staging39_rxon.flags |= RXON_FLG_TSF2HOST_MSK;
Z
Zhu Yi 已提交
469 470

	/* select antenna */
471
	priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
472
	    ~(RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_SEL_MSK);
473
	priv->staging39_rxon.flags |= iwl3945_get_antenna_flags(priv);
Z
Zhu Yi 已提交
474

475
	rc = iwl3945_check_rxon_cmd(priv);
Z
Zhu Yi 已提交
476
	if (rc) {
477
		IWL_ERR(priv, "Invalid RXON configuration.  Not committing.\n");
Z
Zhu Yi 已提交
478 479 480 481
		return -EINVAL;
	}

	/* If we don't need to send a full RXON, we can use
C
Christoph Hellwig 已提交
482
	 * iwl3945_rxon_assoc_cmd which is used to reconfigure filter
Z
Zhu Yi 已提交
483
	 * and other flags for the current radio configuration. */
C
Christoph Hellwig 已提交
484 485
	if (!iwl3945_full_rxon_required(priv)) {
		rc = iwl3945_send_rxon_assoc(priv);
Z
Zhu Yi 已提交
486
		if (rc) {
487
			IWL_ERR(priv, "Error setting RXON_ASSOC "
Z
Zhu Yi 已提交
488 489 490 491
				  "configuration (%d).\n", rc);
			return rc;
		}

492
		memcpy(active_rxon, &priv->staging39_rxon, sizeof(*active_rxon));
Z
Zhu Yi 已提交
493 494 495 496 497 498 499 500

		return 0;
	}

	/* If we are currently associated and the new config requires
	 * an RXON_ASSOC and the new config wants the associated mask enabled,
	 * we must clear the associated from the active configuration
	 * before we apply the new config */
C
Christoph Hellwig 已提交
501
	if (iwl3945_is_associated(priv) &&
502
	    (priv->staging39_rxon.filter_flags & RXON_FILTER_ASSOC_MSK)) {
Z
Zhu Yi 已提交
503 504 505
		IWL_DEBUG_INFO("Toggling associated bit on current RXON\n");
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;

506
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON,
C
Christoph Hellwig 已提交
507
				      sizeof(struct iwl3945_rxon_cmd),
508
				      &priv->active39_rxon);
Z
Zhu Yi 已提交
509 510 511 512 513

		/* If the mask clearing failed then we set
		 * active_rxon back to what it was previously */
		if (rc) {
			active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
514
			IWL_ERR(priv, "Error clearing ASSOC_MSK on current "
Z
Zhu Yi 已提交
515 516 517 518 519 520 521 522
				  "configuration (%d).\n", rc);
			return rc;
		}
	}

	IWL_DEBUG_INFO("Sending RXON\n"
		       "* with%s RXON_FILTER_ASSOC_MSK\n"
		       "* channel = %d\n"
J
Johannes Berg 已提交
523
		       "* bssid = %pM\n",
524
		       ((priv->staging39_rxon.filter_flags &
Z
Zhu Yi 已提交
525
			 RXON_FILTER_ASSOC_MSK) ? "" : "out"),
526
		       le16_to_cpu(priv->staging39_rxon.channel),
J
Johannes Berg 已提交
527
		       priv->staging_rxon.bssid_addr);
Z
Zhu Yi 已提交
528 529

	/* Apply the new configuration */
530
	rc = iwl_send_cmd_pdu(priv, REPLY_RXON,
531
			      sizeof(struct iwl3945_rxon_cmd), &priv->staging39_rxon);
Z
Zhu Yi 已提交
532
	if (rc) {
533
		IWL_ERR(priv, "Error setting new configuration (%d).\n", rc);
Z
Zhu Yi 已提交
534 535 536
		return rc;
	}

537
	memcpy(active_rxon, &priv->staging39_rxon, sizeof(*active_rxon));
Z
Zhu Yi 已提交
538

C
Christoph Hellwig 已提交
539
	iwl3945_clear_stations_table(priv);
540

Z
Zhu Yi 已提交
541 542
	/* If we issue a new RXON command which required a tune then we must
	 * send a new TXPOWER command or we won't be able to Tx any frames */
S
Samuel Ortiz 已提交
543
	rc = priv->cfg->ops->lib->send_tx_power(priv);
Z
Zhu Yi 已提交
544
	if (rc) {
545
		IWL_ERR(priv, "Error setting Tx power (%d).\n", rc);
Z
Zhu Yi 已提交
546 547 548 549
		return rc;
	}

	/* Add the broadcast address so we can send broadcast frames */
550
	if (iwl3945_add_station(priv, iwl_bcast_addr, 0, 0) ==
Z
Zhu Yi 已提交
551
	    IWL_INVALID_STATION) {
552
		IWL_ERR(priv, "Error adding BROADCAST address for transmit.\n");
Z
Zhu Yi 已提交
553 554 555 556 557
		return -EIO;
	}

	/* If we have set the ASSOC_MSK and we are in BSS mode then
	 * add the IWL_AP_ID to the station rate table */
C
Christoph Hellwig 已提交
558
	if (iwl3945_is_associated(priv) &&
559
	    (priv->iw_mode == NL80211_IFTYPE_STATION))
560
		if (iwl3945_add_station(priv, priv->active39_rxon.bssid_addr, 1, 0)
Z
Zhu Yi 已提交
561
		    == IWL_INVALID_STATION) {
562
			IWL_ERR(priv, "Error adding AP address for transmit\n");
Z
Zhu Yi 已提交
563 564 565
			return -EIO;
		}

566
	/* Init the hardware's rate fallback order based on the band */
Z
Zhu Yi 已提交
567 568
	rc = iwl3945_init_hw_rate_table(priv);
	if (rc) {
569
		IWL_ERR(priv, "Error setting HW rate table: %02X\n", rc);
Z
Zhu Yi 已提交
570 571 572 573 574 575
		return -EIO;
	}

	return 0;
}

576
static int iwl3945_send_bt_config(struct iwl_priv *priv)
Z
Zhu Yi 已提交
577
{
578
	struct iwl_bt_cmd bt_cmd = {
Z
Zhu Yi 已提交
579 580 581 582 583 584 585
		.flags = 3,
		.lead_time = 0xAA,
		.max_kill = 1,
		.kill_ack_mask = 0,
		.kill_cts_mask = 0,
	};

586
	return iwl_send_cmd_pdu(priv, REPLY_BT_CONFIG,
587
					sizeof(bt_cmd), &bt_cmd);
Z
Zhu Yi 已提交
588 589
}

590
static int iwl3945_add_sta_sync_callback(struct iwl_priv *priv,
591
				     struct iwl_cmd *cmd, struct sk_buff *skb)
Z
Zhu Yi 已提交
592
{
593
	struct iwl_rx_packet *res = NULL;
Z
Zhu Yi 已提交
594 595

	if (!skb) {
596
		IWL_ERR(priv, "Error: Response NULL in REPLY_ADD_STA.\n");
Z
Zhu Yi 已提交
597 598 599
		return 1;
	}

600
	res = (struct iwl_rx_packet *)skb->data;
Z
Zhu Yi 已提交
601
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
602
		IWL_ERR(priv, "Bad return from REPLY_ADD_STA (0x%08X)\n",
Z
Zhu Yi 已提交
603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
			  res->hdr.flags);
		return 1;
	}

	switch (res->u.add_sta.status) {
	case ADD_STA_SUCCESS_MSK:
		break;
	default:
		break;
	}

	/* We didn't cache the SKB; let the caller free it */
	return 1;
}

618
int iwl3945_send_add_station(struct iwl_priv *priv,
C
Christoph Hellwig 已提交
619
			 struct iwl3945_addsta_cmd *sta, u8 flags)
Z
Zhu Yi 已提交
620
{
621
	struct iwl_rx_packet *res = NULL;
Z
Zhu Yi 已提交
622
	int rc = 0;
623
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
624
		.id = REPLY_ADD_STA,
C
Christoph Hellwig 已提交
625
		.len = sizeof(struct iwl3945_addsta_cmd),
Z
Zhu Yi 已提交
626 627 628 629 630
		.meta.flags = flags,
		.data = sta,
	};

	if (flags & CMD_ASYNC)
C
Christoph Hellwig 已提交
631
		cmd.meta.u.callback = iwl3945_add_sta_sync_callback;
Z
Zhu Yi 已提交
632 633 634
	else
		cmd.meta.flags |= CMD_WANT_SKB;

635
	rc = iwl_send_cmd(priv, &cmd);
Z
Zhu Yi 已提交
636 637 638 639

	if (rc || (flags & CMD_ASYNC))
		return rc;

640
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
641
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
642
		IWL_ERR(priv, "Bad return from REPLY_ADD_STA (0x%08X)\n",
Z
Zhu Yi 已提交
643 644 645 646 647 648 649 650 651 652 653
			  res->hdr.flags);
		rc = -EIO;
	}

	if (rc == 0) {
		switch (res->u.add_sta.status) {
		case ADD_STA_SUCCESS_MSK:
			IWL_DEBUG_INFO("REPLY_ADD_STA PASSED\n");
			break;
		default:
			rc = -EIO;
654
			IWL_WARN(priv, "REPLY_ADD_STA failed\n");
Z
Zhu Yi 已提交
655 656 657 658 659 660 661 662 663 664
			break;
		}
	}

	priv->alloc_rxb_skb--;
	dev_kfree_skb_any(cmd.meta.u.skb);

	return rc;
}

665
static int iwl3945_update_sta_key_info(struct iwl_priv *priv,
Z
Zhu Yi 已提交
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
				   struct ieee80211_key_conf *keyconf,
				   u8 sta_id)
{
	unsigned long flags;
	__le16 key_flags = 0;

	switch (keyconf->alg) {
	case ALG_CCMP:
		key_flags |= STA_KEY_FLG_CCMP;
		key_flags |= cpu_to_le16(
				keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
		key_flags &= ~STA_KEY_FLG_INVALID;
		break;
	case ALG_TKIP:
	case ALG_WEP:
	default:
		return -EINVAL;
	}
	spin_lock_irqsave(&priv->sta_lock, flags);
685 686 687
	priv->stations_39[sta_id].keyinfo.alg = keyconf->alg;
	priv->stations_39[sta_id].keyinfo.keylen = keyconf->keylen;
	memcpy(priv->stations_39[sta_id].keyinfo.key, keyconf->key,
Z
Zhu Yi 已提交
688 689
	       keyconf->keylen);

690
	memcpy(priv->stations_39[sta_id].sta.key.key, keyconf->key,
Z
Zhu Yi 已提交
691
	       keyconf->keylen);
692 693 694
	priv->stations_39[sta_id].sta.key.key_flags = key_flags;
	priv->stations_39[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations_39[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
Z
Zhu Yi 已提交
695 696 697 698

	spin_unlock_irqrestore(&priv->sta_lock, flags);

	IWL_DEBUG_INFO("hwcrypto: modify ucode station key info\n");
699
	iwl3945_send_add_station(priv, &priv->stations_39[sta_id].sta, 0);
Z
Zhu Yi 已提交
700 701 702
	return 0;
}

703
static int iwl3945_clear_sta_key_info(struct iwl_priv *priv, u8 sta_id)
Z
Zhu Yi 已提交
704 705 706 707
{
	unsigned long flags;

	spin_lock_irqsave(&priv->sta_lock, flags);
708 709
	memset(&priv->stations_39[sta_id].keyinfo, 0, sizeof(struct iwl3945_hw_key));
	memset(&priv->stations_39[sta_id].sta.key, 0,
710
		sizeof(struct iwl4965_keyinfo));
711 712 713
	priv->stations_39[sta_id].sta.key.key_flags = STA_KEY_FLG_NO_ENC;
	priv->stations_39[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	priv->stations_39[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
Z
Zhu Yi 已提交
714 715 716
	spin_unlock_irqrestore(&priv->sta_lock, flags);

	IWL_DEBUG_INFO("hwcrypto: clear ucode station key info\n");
717
	iwl3945_send_add_station(priv, &priv->stations_39[sta_id].sta, 0);
Z
Zhu Yi 已提交
718 719 720
	return 0;
}

721
static void iwl3945_clear_free_frames(struct iwl_priv *priv)
Z
Zhu Yi 已提交
722 723 724 725 726 727 728 729 730
{
	struct list_head *element;

	IWL_DEBUG_INFO("%d frames on pre-allocated heap on clear.\n",
		       priv->frames_count);

	while (!list_empty(&priv->free_frames)) {
		element = priv->free_frames.next;
		list_del(element);
C
Christoph Hellwig 已提交
731
		kfree(list_entry(element, struct iwl3945_frame, list));
Z
Zhu Yi 已提交
732 733 734 735
		priv->frames_count--;
	}

	if (priv->frames_count) {
736
		IWL_WARN(priv, "%d frames still in use.  Did we lose one?\n",
Z
Zhu Yi 已提交
737 738 739 740 741
			    priv->frames_count);
		priv->frames_count = 0;
	}
}

742
static struct iwl3945_frame *iwl3945_get_free_frame(struct iwl_priv *priv)
Z
Zhu Yi 已提交
743
{
C
Christoph Hellwig 已提交
744
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
745 746 747 748
	struct list_head *element;
	if (list_empty(&priv->free_frames)) {
		frame = kzalloc(sizeof(*frame), GFP_KERNEL);
		if (!frame) {
749
			IWL_ERR(priv, "Could not allocate frame!\n");
Z
Zhu Yi 已提交
750 751 752 753 754 755 756 757 758
			return NULL;
		}

		priv->frames_count++;
		return frame;
	}

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

762
static void iwl3945_free_frame(struct iwl_priv *priv, struct iwl3945_frame *frame)
Z
Zhu Yi 已提交
763 764 765 766 767
{
	memset(frame, 0, sizeof(*frame));
	list_add(&frame->list, &priv->free_frames);
}

768
unsigned int iwl3945_fill_beacon_frame(struct iwl_priv *priv,
Z
Zhu Yi 已提交
769
				struct ieee80211_hdr *hdr,
770
				int left)
Z
Zhu Yi 已提交
771 772
{

C
Christoph Hellwig 已提交
773
	if (!iwl3945_is_associated(priv) || !priv->ibss_beacon ||
774 775
	    ((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
	     (priv->iw_mode != NL80211_IFTYPE_AP)))
Z
Zhu Yi 已提交
776 777 778 779 780 781 782 783 784 785
		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;
}

786
static u8 iwl3945_rate_get_lowest_plcp(struct iwl_priv *priv)
Z
Zhu Yi 已提交
787 788
{
	u8 i;
789 790 791
	int rate_mask;

	/* Set rate mask*/
792
	if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK)
793
		rate_mask = priv->active_rate_basic & IWL_CCK_RATES_MASK;
794
	else
795
		rate_mask = priv->active_rate_basic & IWL_OFDM_RATES_MASK;
Z
Zhu Yi 已提交
796 797

	for (i = IWL_RATE_1M_INDEX; i != IWL_RATE_INVALID;
C
Christoph Hellwig 已提交
798
	     i = iwl3945_rates[i].next_ieee) {
Z
Zhu Yi 已提交
799
		if (rate_mask & (1 << i))
C
Christoph Hellwig 已提交
800
			return iwl3945_rates[i].plcp;
Z
Zhu Yi 已提交
801 802
	}

803
	/* No valid rate was found. Assign the lowest one */
804
	if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK)
805 806 807
		return IWL_RATE_1M_PLCP;
	else
		return IWL_RATE_6M_PLCP;
Z
Zhu Yi 已提交
808 809
}

810
static int iwl3945_send_beacon_cmd(struct iwl_priv *priv)
Z
Zhu Yi 已提交
811
{
C
Christoph Hellwig 已提交
812
	struct iwl3945_frame *frame;
Z
Zhu Yi 已提交
813 814 815 816
	unsigned int frame_size;
	int rc;
	u8 rate;

C
Christoph Hellwig 已提交
817
	frame = iwl3945_get_free_frame(priv);
Z
Zhu Yi 已提交
818 819

	if (!frame) {
820
		IWL_ERR(priv, "Could not obtain free frame buffer for beacon "
Z
Zhu Yi 已提交
821 822 823 824
			  "command.\n");
		return -ENOMEM;
	}

825
	rate = iwl3945_rate_get_lowest_plcp(priv);
Z
Zhu Yi 已提交
826

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

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

C
Christoph Hellwig 已提交
832
	iwl3945_free_frame(priv, frame);
Z
Zhu Yi 已提交
833 834 835 836 837 838 839 840 841 842

	return rc;
}

/******************************************************************************
 *
 * EEPROM related functions
 *
 ******************************************************************************/

843
static void get_eeprom_mac(struct iwl_priv *priv, u8 *mac)
Z
Zhu Yi 已提交
844
{
845
	memcpy(mac, priv->eeprom39.mac_address, 6);
Z
Zhu Yi 已提交
846 847
}

848 849 850 851 852 853 854 855
/*
 * Clear the OWNER_MSK, to establish driver (instead of uCode running on
 * embedded controller) as EEPROM reader; each read is a series of pulses
 * to/from the EEPROM chip, not a single event, so even reads could conflict
 * if they weren't arbitrated by some ownership mechanism.  Here, the driver
 * simply claims ownership, which should be safe when this function is called
 * (i.e. before loading uCode!).
 */
856
static inline int iwl3945_eeprom_acquire_semaphore(struct iwl_priv *priv)
857
{
858
	_iwl_clear_bit(priv, CSR_EEPROM_GP, CSR_EEPROM_GP_IF_OWNER_MSK);
859 860 861
	return 0;
}

Z
Zhu Yi 已提交
862
/**
C
Christoph Hellwig 已提交
863
 * iwl3945_eeprom_init - read EEPROM contents
Z
Zhu Yi 已提交
864
 *
865
 * Load the EEPROM contents from adapter into priv->eeprom39
Z
Zhu Yi 已提交
866 867 868
 *
 * NOTE:  This routine uses the non-debug IO access functions.
 */
869
int iwl3945_eeprom_init(struct iwl_priv *priv)
Z
Zhu Yi 已提交
870
{
871
	u16 *e = (u16 *)&priv->eeprom39;
872
	u32 gp = iwl_read32(priv, CSR_EEPROM_GP);
873
	int sz = sizeof(priv->eeprom39);
874
	int ret;
Z
Zhu Yi 已提交
875 876 877 878 879 880
	u16 addr;

	/* The EEPROM structure has several padding buffers within it
	 * and when adding new EEPROM maps is subject to programmer errors
	 * which may be very difficult to identify without explicitly
	 * checking the resulting size of the eeprom map. */
881
	BUILD_BUG_ON(sizeof(priv->eeprom39) != IWL_EEPROM_IMAGE_SIZE);
Z
Zhu Yi 已提交
882 883

	if ((gp & CSR_EEPROM_GP_VALID_MSK) == CSR_EEPROM_GP_BAD_SIGNATURE) {
884
		IWL_ERR(priv, "EEPROM not found, EEPROM_GP=0x%08x\n", gp);
Z
Zhu Yi 已提交
885 886 887
		return -ENOENT;
	}

888
	/* Make sure driver (instead of uCode) is allowed to read EEPROM */
889 890
	ret = iwl3945_eeprom_acquire_semaphore(priv);
	if (ret < 0) {
891
		IWL_ERR(priv, "Failed to acquire EEPROM semaphore.\n");
Z
Zhu Yi 已提交
892 893 894 895 896
		return -ENOENT;
	}

	/* eeprom is an array of 16bit values */
	for (addr = 0; addr < sz; addr += sizeof(u16)) {
897
		u32 r;
Z
Zhu Yi 已提交
898

899
		_iwl_write32(priv, CSR_EEPROM_REG,
900
				 CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
901 902
		_iwl_clear_bit(priv, CSR_EEPROM_REG, CSR_EEPROM_REG_BIT_CMD);
		ret = iwl_poll_direct_bit(priv, CSR_EEPROM_REG,
903 904 905
					      CSR_EEPROM_REG_READ_VALID_MSK,
					      IWL_EEPROM_ACCESS_TIMEOUT);
		if (ret < 0) {
906
			IWL_ERR(priv, "Time out reading EEPROM[%d]\n", addr);
907
			return ret;
Z
Zhu Yi 已提交
908
		}
909

910
		r = _iwl_read_direct32(priv, CSR_EEPROM_REG);
911
		e[addr / 2] = le16_to_cpu((__force __le16)(r >> 16));
Z
Zhu Yi 已提交
912 913 914 915 916
	}

	return 0;
}

917
static void iwl3945_unset_hw_params(struct iwl_priv *priv)
Z
Zhu Yi 已提交
918
{
919
	if (priv->shared_virt)
Z
Zhu Yi 已提交
920
		pci_free_consistent(priv->pci_dev,
C
Christoph Hellwig 已提交
921
				    sizeof(struct iwl3945_shared),
922 923
				    priv->shared_virt,
				    priv->shared_phys);
Z
Zhu Yi 已提交
924 925 926 927 928
}

/*
 * QoS  support
*/
929
static int iwl3945_send_qos_params_command(struct iwl_priv *priv,
930
				       struct iwl_qosparam_cmd *qos)
Z
Zhu Yi 已提交
931 932
{

933
	return iwl_send_cmd_pdu(priv, REPLY_QOS_PARAM,
934
				sizeof(struct iwl_qosparam_cmd), qos);
Z
Zhu Yi 已提交
935 936
}

937
static void iwl3945_activate_qos(struct iwl_priv *priv, u8 force)
Z
Zhu Yi 已提交
938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957
{
	unsigned long flags;

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

	spin_lock_irqsave(&priv->lock, flags);
	priv->qos_data.def_qos_parm.qos_flags = 0;

	if (priv->qos_data.qos_cap.q_AP.queue_request &&
	    !priv->qos_data.qos_cap.q_AP.txop_request)
		priv->qos_data.def_qos_parm.qos_flags |=
			QOS_PARAM_FLG_TXOP_TYPE_MSK;

	if (priv->qos_data.qos_active)
		priv->qos_data.def_qos_parm.qos_flags |=
			QOS_PARAM_FLG_UPDATE_EDCA_MSK;

	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
958
	if (force || iwl3945_is_associated(priv)) {
T
Tomas Winkler 已提交
959
		IWL_DEBUG_QOS("send QoS cmd with QoS active %d \n",
Z
Zhu Yi 已提交
960 961
			      priv->qos_data.qos_active);

C
Christoph Hellwig 已提交
962
		iwl3945_send_qos_params_command(priv,
Z
Zhu Yi 已提交
963 964 965 966 967 968 969 970 971
				&(priv->qos_data.def_qos_parm));
	}
}

/*
 * Power management (not Tx power!) functions
 */
#define MSEC_TO_USEC 1024

972

Z
Zhu Yi 已提交
973
/* default power management (not Tx power) table values */
T
Tomas Winkler 已提交
974
/* for TIM  0-10 */
975 976 977 978 979 980 981
static struct iwl_power_vec_entry range_0[IWL_POWER_MAX] = {
	{{NOSLP, SLP_TOUT(0), SLP_TOUT(0), SLP_VEC(0, 0, 0, 0, 0)}, 0},
	{{SLP, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 3, 4, 4)}, 0},
	{{SLP, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(2, 4, 6, 7, 7)}, 0},
	{{SLP, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 6, 9, 9, 10)}, 0},
	{{SLP, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 7, 9, 9, 10)}, 1},
	{{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(4, 7, 10, 10, 10)}, 1}
Z
Zhu Yi 已提交
982 983
};

T
Tomas Winkler 已提交
984
/* for TIM > 10 */
985 986 987 988 989 990 991
static struct iwl_power_vec_entry range_1[IWL_POWER_MAX] = {
	{{NOSLP, SLP_TOUT(0), SLP_TOUT(0), SLP_VEC(0, 0, 0, 0, 0)}, 0},
	{{SLP, SLP_TOUT(200), SLP_TOUT(500), SLP_VEC(1, 2, 3, 4, 0xFF)}, 0},
	{{SLP, SLP_TOUT(200), SLP_TOUT(300), SLP_VEC(2, 4, 6, 7, 0xFF)}, 0},
	{{SLP, SLP_TOUT(50), SLP_TOUT(100), SLP_VEC(2, 6, 9, 9, 0xFF)}, 0},
	{{SLP, SLP_TOUT(50), SLP_TOUT(25), SLP_VEC(2, 7, 9, 9, 0xFF)}, 0},
	{{SLP, SLP_TOUT(25), SLP_TOUT(25), SLP_VEC(4, 7, 10, 10, 0xFF)}, 0}
Z
Zhu Yi 已提交
992 993
};

994
int iwl3945_power_init_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
995 996
{
	int rc = 0, i;
997 998
	struct iwl_power_mgr *pow_data;
	int size = sizeof(struct iwl_power_vec_entry) * IWL_POWER_MAX;
Z
Zhu Yi 已提交
999 1000 1001 1002
	u16 pci_pm;

	IWL_DEBUG_POWER("Initialize power \n");

1003
	pow_data = &priv->power_data;
Z
Zhu Yi 已提交
1004 1005 1006

	memset(pow_data, 0, sizeof(*pow_data));

1007
	pow_data->dtim_period = 1;
Z
Zhu Yi 已提交
1008 1009 1010 1011 1012 1013 1014 1015

	memcpy(&pow_data->pwr_range_0[0], &range_0[0], size);
	memcpy(&pow_data->pwr_range_1[0], &range_1[0], size);

	rc = pci_read_config_word(priv->pci_dev, PCI_LINK_CTRL, &pci_pm);
	if (rc != 0)
		return 0;
	else {
1016
		struct iwl_powertable_cmd *cmd;
Z
Zhu Yi 已提交
1017 1018 1019

		IWL_DEBUG_POWER("adjust power command flags\n");

1020
		for (i = 0; i < IWL_POWER_MAX; i++) {
Z
Zhu Yi 已提交
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
			cmd = &pow_data->pwr_range_0[i].cmd;

			if (pci_pm & 0x1)
				cmd->flags &= ~IWL_POWER_PCI_PM_MSK;
			else
				cmd->flags |= IWL_POWER_PCI_PM_MSK;
		}
	}
	return rc;
}

1032
static int iwl3945_update_power_cmd(struct iwl_priv *priv,
1033
				struct iwl_powertable_cmd *cmd, u32 mode)
Z
Zhu Yi 已提交
1034
{
1035
	struct iwl_power_mgr *pow_data;
1036
	struct iwl_power_vec_entry *range;
1037 1038
	u32 max_sleep = 0;
	int i;
Z
Zhu Yi 已提交
1039
	u8 period = 0;
1040
	bool skip;
Z
Zhu Yi 已提交
1041 1042 1043

	if (mode > IWL_POWER_INDEX_5) {
		IWL_DEBUG_POWER("Error invalid power mode \n");
1044
		return -EINVAL;
Z
Zhu Yi 已提交
1045
	}
1046
	pow_data = &priv->power_data;
Z
Zhu Yi 已提交
1047

1048
	if (pow_data->dtim_period < 10)
Z
Zhu Yi 已提交
1049 1050 1051 1052
		range = &pow_data->pwr_range_0[0];
	else
		range = &pow_data->pwr_range_1[1];

C
Christoph Hellwig 已提交
1053
	memcpy(cmd, &range[mode].cmd, sizeof(struct iwl3945_powertable_cmd));
Z
Zhu Yi 已提交
1054 1055 1056 1057


	if (period == 0) {
		period = 1;
1058 1059 1060
		skip = false;
	} else {
		skip = !!range[mode].no_dtim;
Z
Zhu Yi 已提交
1061 1062
	}

1063
	if (skip) {
Z
Zhu Yi 已提交
1064 1065 1066
		__le32 slp_itrvl = cmd->sleep_interval[IWL_POWER_VEC_SIZE - 1];
		max_sleep = (le32_to_cpu(slp_itrvl) / period) * period;
		cmd->flags |= IWL_POWER_SLEEP_OVER_DTIM_MSK;
1067 1068 1069
	} else {
		max_sleep = period;
		cmd->flags &= ~IWL_POWER_SLEEP_OVER_DTIM_MSK;
Z
Zhu Yi 已提交
1070 1071
	}

1072
	for (i = 0; i < IWL_POWER_VEC_SIZE; i++)
Z
Zhu Yi 已提交
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
		if (le32_to_cpu(cmd->sleep_interval[i]) > max_sleep)
			cmd->sleep_interval[i] = cpu_to_le32(max_sleep);

	IWL_DEBUG_POWER("Flags value = 0x%08X\n", cmd->flags);
	IWL_DEBUG_POWER("Tx timeout = %u\n", le32_to_cpu(cmd->tx_data_timeout));
	IWL_DEBUG_POWER("Rx timeout = %u\n", le32_to_cpu(cmd->rx_data_timeout));
	IWL_DEBUG_POWER("Sleep interval vector = { %d , %d , %d , %d , %d }\n",
			le32_to_cpu(cmd->sleep_interval[0]),
			le32_to_cpu(cmd->sleep_interval[1]),
			le32_to_cpu(cmd->sleep_interval[2]),
			le32_to_cpu(cmd->sleep_interval[3]),
			le32_to_cpu(cmd->sleep_interval[4]));

1086
	return 0;
Z
Zhu Yi 已提交
1087 1088
}

1089
static int iwl3945_send_power_mode(struct iwl_priv *priv, u32 mode)
Z
Zhu Yi 已提交
1090
{
1091
	u32 uninitialized_var(final_mode);
Z
Zhu Yi 已提交
1092
	int rc;
1093
	struct iwl_powertable_cmd cmd;
Z
Zhu Yi 已提交
1094 1095

	/* If on battery, set to 3,
1096
	 * if plugged into AC power, set to CAM ("continuously aware mode"),
Z
Zhu Yi 已提交
1097 1098
	 * else user level */
	switch (mode) {
1099
	case IWL39_POWER_BATTERY:
Z
Zhu Yi 已提交
1100 1101
		final_mode = IWL_POWER_INDEX_3;
		break;
1102
	case IWL39_POWER_AC:
Z
Zhu Yi 已提交
1103 1104 1105 1106 1107 1108 1109
		final_mode = IWL_POWER_MODE_CAM;
		break;
	default:
		final_mode = mode;
		break;
	}

C
Christoph Hellwig 已提交
1110
	iwl3945_update_power_cmd(priv, &cmd, final_mode);
Z
Zhu Yi 已提交
1111

1112
	/* FIXME use get_hcmd_size 3945 command is 4 bytes shorter */
1113 1114
	rc = iwl_send_cmd_pdu(priv, POWER_TABLE_CMD,
			      sizeof(struct iwl3945_powertable_cmd), &cmd);
Z
Zhu Yi 已提交
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126

	if (final_mode == IWL_POWER_MODE_CAM)
		clear_bit(STATUS_POWER_PMI, &priv->status);
	else
		set_bit(STATUS_POWER_PMI, &priv->status);

	return rc;
}

#define MAX_UCODE_BEACON_INTERVAL	1024
#define INTEL_CONN_LISTEN_INTERVAL	__constant_cpu_to_le16(0xA)

C
Christoph Hellwig 已提交
1127
static __le16 iwl3945_adjust_beacon_interval(u16 beacon_val)
Z
Zhu Yi 已提交
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
{
	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);
}

1140
static void iwl3945_setup_rxon_timing(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
{
	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);
1151
	priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
Z
Zhu Yi 已提交
1152 1153
	priv->rxon_timing.listen_interval = INTEL_CONN_LISTEN_INTERVAL;

1154
	tsf = priv->timestamp;
Z
Zhu Yi 已提交
1155 1156 1157 1158

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

1159
	if (priv->iw_mode == NL80211_IFTYPE_STATION) {
Z
Zhu Yi 已提交
1160 1161 1162 1163 1164 1165 1166
		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 已提交
1167
			    iwl3945_adjust_beacon_interval(
Z
Zhu Yi 已提交
1168 1169 1170 1171 1172 1173
				le16_to_cpu(priv->rxon_timing.beacon_interval));
		}

		priv->rxon_timing.atim_window = 0;
	} else {
		priv->rxon_timing.beacon_interval =
C
Christoph Hellwig 已提交
1174
			iwl3945_adjust_beacon_interval(conf->beacon_int);
Z
Zhu Yi 已提交
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
		/* 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));

	IWL_DEBUG_ASSOC
	    ("beacon interval %d beacon timer %d beacon tim %d\n",
		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));
}

1193
static int iwl3945_scan_initiate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1194
{
1195
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
		IWL_DEBUG_SCAN("Aborting scan due to not ready.\n");
		return -EIO;
	}

	if (test_bit(STATUS_SCANNING, &priv->status)) {
		IWL_DEBUG_SCAN("Scan already in progress.\n");
		return -EAGAIN;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
		IWL_DEBUG_SCAN("Scan request while abort pending.  "
			       "Queuing.\n");
		return -EAGAIN;
	}

	IWL_DEBUG_INFO("Starting scan...\n");
1212 1213 1214 1215
	if (priv->cfg->sku & IWL_SKU_G)
		priv->scan_bands |= BIT(IEEE80211_BAND_2GHZ);
	if (priv->cfg->sku & IWL_SKU_A)
		priv->scan_bands |= BIT(IEEE80211_BAND_5GHZ);
Z
Zhu Yi 已提交
1216 1217 1218 1219 1220 1221 1222 1223 1224
	set_bit(STATUS_SCANNING, &priv->status);
	priv->scan_start = jiffies;
	priv->scan_pass_start = priv->scan_start;

	queue_work(priv->workqueue, &priv->request_scan);

	return 0;
}

1225
static int iwl3945_set_rxon_hwcrypto(struct iwl_priv *priv, int hw_decrypt)
Z
Zhu Yi 已提交
1226
{
1227
	struct iwl3945_rxon_cmd *rxon = &priv->staging39_rxon;
Z
Zhu Yi 已提交
1228 1229 1230 1231 1232 1233 1234 1235 1236

	if (hw_decrypt)
		rxon->filter_flags &= ~RXON_FILTER_DIS_DECRYPT_MSK;
	else
		rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK;

	return 0;
}

1237
static void iwl3945_set_flags_for_phymode(struct iwl_priv *priv,
1238
					  enum ieee80211_band band)
Z
Zhu Yi 已提交
1239
{
1240
	if (band == IEEE80211_BAND_5GHZ) {
1241
		priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
1242 1243
		    ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
		      | RXON_FLG_CCK_MSK);
1244
		priv->staging39_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1245
	} else {
C
Christoph Hellwig 已提交
1246
		/* Copied from iwl3945_bg_post_associate() */
Z
Zhu Yi 已提交
1247
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
1248
			priv->staging39_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1249
		else
1250
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1251

1252
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
1253
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
1254

1255 1256 1257
		priv->staging39_rxon.flags |= RXON_FLG_BAND_24G_MSK;
		priv->staging39_rxon.flags |= RXON_FLG_AUTO_DETECT_MSK;
		priv->staging39_rxon.flags &= ~RXON_FLG_CCK_MSK;
Z
Zhu Yi 已提交
1258 1259 1260 1261
	}
}

/*
1262
 * initialize rxon structure with default values from eeprom
Z
Zhu Yi 已提交
1263
 */
1264
static void iwl3945_connection_init_rx_config(struct iwl_priv *priv,
1265
					      int mode)
Z
Zhu Yi 已提交
1266
{
1267
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
1268

1269
	memset(&priv->staging39_rxon, 0, sizeof(priv->staging39_rxon));
Z
Zhu Yi 已提交
1270

1271
	switch (mode) {
1272
	case NL80211_IFTYPE_AP:
1273
		priv->staging39_rxon.dev_type = RXON_DEV_TYPE_AP;
Z
Zhu Yi 已提交
1274 1275
		break;

1276
	case NL80211_IFTYPE_STATION:
1277 1278
		priv->staging39_rxon.dev_type = RXON_DEV_TYPE_ESS;
		priv->staging39_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
Z
Zhu Yi 已提交
1279 1280
		break;

1281
	case NL80211_IFTYPE_ADHOC:
1282 1283 1284
		priv->staging39_rxon.dev_type = RXON_DEV_TYPE_IBSS;
		priv->staging39_rxon.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
		priv->staging39_rxon.filter_flags = RXON_FILTER_BCON_AWARE_MSK |
Z
Zhu Yi 已提交
1285 1286 1287
						  RXON_FILTER_ACCEPT_GRP_MSK;
		break;

1288
	case NL80211_IFTYPE_MONITOR:
1289 1290
		priv->staging39_rxon.dev_type = RXON_DEV_TYPE_SNIFFER;
		priv->staging39_rxon.filter_flags = RXON_FILTER_PROMISC_MSK |
Z
Zhu Yi 已提交
1291 1292
		    RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_ACCEPT_GRP_MSK;
		break;
1293
	default:
1294
		IWL_ERR(priv, "Unsupported interface type %d\n", mode);
1295
		break;
Z
Zhu Yi 已提交
1296 1297 1298 1299 1300 1301
	}

#if 0
	/* TODO:  Figure out when short_preamble would be set and cache from
	 * that */
	if (!hw_to_local(priv->hw)->short_preamble)
1302
		priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
1303
	else
1304
		priv->staging39_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
1305 1306
#endif

1307
	ch_info = iwl3945_get_channel_info(priv, priv->band,
1308
				       le16_to_cpu(priv->active39_rxon.channel));
Z
Zhu Yi 已提交
1309 1310 1311 1312 1313 1314 1315 1316

	if (!ch_info)
		ch_info = &priv->channel_info[0];

	/*
	 * in some case A channels are all non IBSS
	 * in this case force B/G channel
	 */
1317
	if ((mode == NL80211_IFTYPE_ADHOC) && !(is_channel_ibss(ch_info)))
Z
Zhu Yi 已提交
1318 1319
		ch_info = &priv->channel_info[0];

1320
	priv->staging39_rxon.channel = cpu_to_le16(ch_info->channel);
Z
Zhu Yi 已提交
1321
	if (is_channel_a_band(ch_info))
1322
		priv->band = IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
1323
	else
1324
		priv->band = IEEE80211_BAND_2GHZ;
Z
Zhu Yi 已提交
1325

1326
	iwl3945_set_flags_for_phymode(priv, priv->band);
Z
Zhu Yi 已提交
1327

1328
	priv->staging39_rxon.ofdm_basic_rates =
Z
Zhu Yi 已提交
1329
	    (IWL_OFDM_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
1330
	priv->staging39_rxon.cck_basic_rates =
Z
Zhu Yi 已提交
1331 1332 1333
	    (IWL_CCK_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
}

1334
static int iwl3945_set_mode(struct iwl_priv *priv, int mode)
Z
Zhu Yi 已提交
1335
{
1336
	if (mode == NL80211_IFTYPE_ADHOC) {
1337
		const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
1338

C
Christoph Hellwig 已提交
1339
		ch_info = iwl3945_get_channel_info(priv,
1340
			priv->band,
1341
			le16_to_cpu(priv->staging39_rxon.channel));
Z
Zhu Yi 已提交
1342 1343

		if (!ch_info || !is_channel_ibss(ch_info)) {
1344
			IWL_ERR(priv, "channel %d not IBSS channel\n",
1345
				  le16_to_cpu(priv->staging39_rxon.channel));
Z
Zhu Yi 已提交
1346 1347 1348 1349
			return -EINVAL;
		}
	}

1350
	iwl3945_connection_init_rx_config(priv, mode);
1351
	memcpy(priv->staging39_rxon.node_addr, priv->mac_addr, ETH_ALEN);
Z
Zhu Yi 已提交
1352

C
Christoph Hellwig 已提交
1353
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
1354

T
Tomas Winkler 已提交
1355
	/* don't commit rxon if rf-kill is on*/
1356
	if (!iwl_is_ready_rf(priv))
1357 1358 1359
		return -EAGAIN;

	cancel_delayed_work(&priv->scan_check);
1360
	if (iwl_scan_cancel_timeout(priv, 100)) {
1361
		IWL_WARN(priv, "Aborted scan still in progress after 100ms\n");
1362 1363 1364 1365
		IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
		return -EAGAIN;
	}

C
Christoph Hellwig 已提交
1366
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
1367 1368 1369 1370

	return 0;
}

1371
static void iwl3945_build_tx_cmd_hwcrypto(struct iwl_priv *priv,
1372
				      struct ieee80211_tx_info *info,
1373
				      struct iwl_cmd *cmd,
Z
Zhu Yi 已提交
1374 1375 1376
				      struct sk_buff *skb_frag,
				      int last_frag)
{
1377
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
1378
	struct iwl3945_hw_key *keyinfo =
1379
	    &priv->stations_39[info->control.hw_key->hw_key_idx].keyinfo;
Z
Zhu Yi 已提交
1380 1381 1382

	switch (keyinfo->alg) {
	case ALG_CCMP:
1383 1384
		tx->sec_ctl = TX_CMD_SEC_CCM;
		memcpy(tx->key, keyinfo->key, keyinfo->keylen);
T
Tomas Winkler 已提交
1385
		IWL_DEBUG_TX("tx_cmd with AES hwcrypto\n");
Z
Zhu Yi 已提交
1386 1387 1388 1389
		break;

	case ALG_TKIP:
#if 0
1390
		tx->sec_ctl = TX_CMD_SEC_TKIP;
Z
Zhu Yi 已提交
1391 1392

		if (last_frag)
1393
			memcpy(tx->tkip_mic.byte, skb_frag->tail - 8,
Z
Zhu Yi 已提交
1394 1395
			       8);
		else
1396
			memset(tx->tkip_mic.byte, 0, 8);
Z
Zhu Yi 已提交
1397 1398 1399 1400
#endif
		break;

	case ALG_WEP:
1401
		tx->sec_ctl = TX_CMD_SEC_WEP |
1402
		    (info->control.hw_key->hw_key_idx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT;
Z
Zhu Yi 已提交
1403 1404

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

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

		IWL_DEBUG_TX("Configuring packet for WEP encryption "
1410
			     "with key %d\n", info->control.hw_key->hw_key_idx);
Z
Zhu Yi 已提交
1411 1412 1413
		break;

	default:
T
Tomas Winkler 已提交
1414
		IWL_ERR(priv, "Unknown encode alg %d\n", keyinfo->alg);
Z
Zhu Yi 已提交
1415 1416 1417 1418 1419 1420 1421
		break;
	}
}

/*
 * handle build REPLY_TX command notification.
 */
1422
static void iwl3945_build_tx_cmd_basic(struct iwl_priv *priv,
1423
				  struct iwl_cmd *cmd,
1424
				  struct ieee80211_tx_info *info,
1425
				  struct ieee80211_hdr *hdr, u8 std_id)
Z
Zhu Yi 已提交
1426
{
1427 1428
	struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
	__le32 tx_flags = tx->tx_flags;
1429
	__le16 fc = hdr->frame_control;
1430
	u8 rc_flags = info->control.rates[0].flags;
Z
Zhu Yi 已提交
1431

1432
	tx->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
1433
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Z
Zhu Yi 已提交
1434
		tx_flags |= TX_CMD_FLG_ACK_MSK;
1435
		if (ieee80211_is_mgmt(fc))
Z
Zhu Yi 已提交
1436
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
1437
		if (ieee80211_is_probe_resp(fc) &&
Z
Zhu Yi 已提交
1438 1439 1440 1441 1442 1443 1444
		    !(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;
	}

1445
	tx->sta_id = std_id;
1446
	if (ieee80211_has_morefrags(fc))
Z
Zhu Yi 已提交
1447 1448
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

1449 1450
	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
1451
		tx->tid_tspec = qc[0] & 0xf;
Z
Zhu Yi 已提交
1452
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
1453
	} else {
Z
Zhu Yi 已提交
1454
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
1455
	}
Z
Zhu Yi 已提交
1456

1457
	if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
Z
Zhu Yi 已提交
1458 1459
		tx_flags |= TX_CMD_FLG_RTS_MSK;
		tx_flags &= ~TX_CMD_FLG_CTS_MSK;
1460
	} else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
Z
Zhu Yi 已提交
1461 1462 1463 1464 1465 1466 1467 1468
		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);
1469 1470
	if (ieee80211_is_mgmt(fc)) {
		if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
1471
			tx->timeout.pm_frame_timeout = cpu_to_le16(3);
Z
Zhu Yi 已提交
1472
		else
1473
			tx->timeout.pm_frame_timeout = cpu_to_le16(2);
M
Mohamed Abbas 已提交
1474
	} else {
1475
		tx->timeout.pm_frame_timeout = 0;
M
Mohamed Abbas 已提交
1476 1477 1478 1479
#ifdef CONFIG_IWL3945_LEDS
		priv->rxtxpackets += le16_to_cpu(cmd->cmd.tx.len);
#endif
	}
Z
Zhu Yi 已提交
1480

1481 1482 1483
	tx->driver_txop = 0;
	tx->tx_flags = tx_flags;
	tx->next_frame_len = 0;
Z
Zhu Yi 已提交
1484 1485
}

1486 1487 1488
/**
 * iwl3945_get_sta_id - Find station's index within station table
 */
1489
static int iwl3945_get_sta_id(struct iwl_priv *priv, struct ieee80211_hdr *hdr)
Z
Zhu Yi 已提交
1490 1491 1492 1493
{
	int sta_id;
	u16 fc = le16_to_cpu(hdr->frame_control);

1494
	/* If this frame is broadcast or management, use broadcast station id */
Z
Zhu Yi 已提交
1495 1496
	if (((fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA) ||
	    is_multicast_ether_addr(hdr->addr1))
1497
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
1498 1499 1500

	switch (priv->iw_mode) {

1501 1502
	/* If we are a client station in a BSS network, use the special
	 * AP station entry (that's the only station we communicate with) */
1503
	case NL80211_IFTYPE_STATION:
Z
Zhu Yi 已提交
1504 1505 1506
		return IWL_AP_ID;

	/* If we are an AP, then find the station, or use BCAST */
1507
	case NL80211_IFTYPE_AP:
C
Christoph Hellwig 已提交
1508
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
1509 1510
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;
1511
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
1512

1513 1514
	/* If this frame is going out to an IBSS network, find the station,
	 * or create a new station table entry */
1515
	case NL80211_IFTYPE_ADHOC: {
1516
		/* Create new station table entry */
C
Christoph Hellwig 已提交
1517
		sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
Z
Zhu Yi 已提交
1518 1519 1520
		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

C
Christoph Hellwig 已提交
1521
		sta_id = iwl3945_add_station(priv, hdr->addr1, 0, CMD_ASYNC);
Z
Zhu Yi 已提交
1522 1523 1524 1525

		if (sta_id != IWL_INVALID_STATION)
			return sta_id;

J
Johannes Berg 已提交
1526
		IWL_DEBUG_DROP("Station %pM not in station map. "
Z
Zhu Yi 已提交
1527
			       "Defaulting to broadcast...\n",
J
Johannes Berg 已提交
1528
			       hdr->addr1);
1529
		iwl_print_hex_dump(priv, IWL_DL_DROP, (u8 *) hdr, sizeof(*hdr));
1530
		return priv->hw_params.bcast_sta_id;
1531
	}
1532 1533
	/* If we are in monitor mode, use BCAST. This is required for
	 * packet injection. */
1534
	case NL80211_IFTYPE_MONITOR:
1535
		return priv->hw_params.bcast_sta_id;
1536

Z
Zhu Yi 已提交
1537
	default:
1538 1539
		IWL_WARN(priv, "Unknown mode of operation: %d\n",
			priv->iw_mode);
1540
		return priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
1541 1542 1543 1544 1545 1546
	}
}

/*
 * start REPLY_TX command process
 */
1547
static int iwl3945_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
Z
Zhu Yi 已提交
1548 1549
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1550
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1551
	struct iwl3945_tx_cmd *tx;
1552
	struct iwl_tx_queue *txq = NULL;
1553
	struct iwl_queue *q = NULL;
1554
	struct iwl_cmd *out_cmd = NULL;
Z
Zhu Yi 已提交
1555 1556
	dma_addr_t phys_addr;
	dma_addr_t txcmd_phys;
1557
	int txq_id = skb_get_queue_mapping(skb);
1558 1559 1560
	u16 len, idx, len_org, hdr_len;
	u8 id;
	u8 unicast;
Z
Zhu Yi 已提交
1561
	u8 sta_id;
1562
	u8 tid = 0;
Z
Zhu Yi 已提交
1563
	u16 seq_number = 0;
1564
	__le16 fc;
Z
Zhu Yi 已提交
1565
	u8 wait_write_ptr = 0;
1566
	u8 *qc = NULL;
Z
Zhu Yi 已提交
1567 1568 1569 1570
	unsigned long flags;
	int rc;

	spin_lock_irqsave(&priv->lock, flags);
1571
	if (iwl_is_rfkill(priv)) {
Z
Zhu Yi 已提交
1572 1573 1574 1575
		IWL_DEBUG_DROP("Dropping - RF KILL\n");
		goto drop_unlock;
	}

1576
	if ((ieee80211_get_tx_rate(priv->hw, info)->hw_value & 0xFF) == IWL_INVALID_RATE) {
1577
		IWL_ERR(priv, "ERROR: No TX rate available.\n");
Z
Zhu Yi 已提交
1578 1579 1580 1581 1582 1583
		goto drop_unlock;
	}

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

1584
	fc = hdr->frame_control;
Z
Zhu Yi 已提交
1585

1586
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
1587 1588
	if (ieee80211_is_auth(fc))
		IWL_DEBUG_TX("Sending AUTH frame\n");
1589
	else if (ieee80211_is_assoc_req(fc))
Z
Zhu Yi 已提交
1590
		IWL_DEBUG_TX("Sending ASSOC frame\n");
1591
	else if (ieee80211_is_reassoc_req(fc))
Z
Zhu Yi 已提交
1592 1593 1594
		IWL_DEBUG_TX("Sending REASSOC frame\n");
#endif

1595
	/* drop all data frame if we are not associated */
1596
	if (ieee80211_is_data(fc) &&
1597
	    (priv->iw_mode != NL80211_IFTYPE_MONITOR) && /* packet injection */
1598
	    (!iwl3945_is_associated(priv) ||
1599
	     ((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id))) {
C
Christoph Hellwig 已提交
1600
		IWL_DEBUG_DROP("Dropping - !iwl3945_is_associated\n");
Z
Zhu Yi 已提交
1601 1602 1603 1604 1605
		goto drop_unlock;
	}

	spin_unlock_irqrestore(&priv->lock, flags);

1606
	hdr_len = ieee80211_hdrlen(fc);
1607 1608

	/* Find (or create) index into station table for destination station */
C
Christoph Hellwig 已提交
1609
	sta_id = iwl3945_get_sta_id(priv, hdr);
Z
Zhu Yi 已提交
1610
	if (sta_id == IWL_INVALID_STATION) {
J
Johannes Berg 已提交
1611 1612
		IWL_DEBUG_DROP("Dropping - INVALID STATION: %pM\n",
			       hdr->addr1);
Z
Zhu Yi 已提交
1613 1614 1615 1616 1617
		goto drop;
	}

	IWL_DEBUG_RATE("station Id %d\n", sta_id);

1618 1619
	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
1620
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
1621
		seq_number = priv->stations_39[sta_id].tid[tid].seq_number &
Z
Zhu Yi 已提交
1622 1623 1624 1625 1626 1627
				IEEE80211_SCTL_SEQ;
		hdr->seq_ctrl = cpu_to_le16(seq_number) |
			(hdr->seq_ctrl &
				__constant_cpu_to_le16(IEEE80211_SCTL_FRAG));
		seq_number += 0x10;
	}
1628 1629

	/* Descriptor for chosen Tx queue */
1630
	txq = &priv->txq[txq_id];
Z
Zhu Yi 已提交
1631 1632 1633 1634
	q = &txq->q;

	spin_lock_irqsave(&priv->lock, flags);

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

1637
	/* Set up driver data for this TFD */
W
Winkler, Tomas 已提交
1638
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl_tx_info));
1639
	txq->txb[q->write_ptr].skb[0] = skb;
1640 1641

	/* Init first empty entry in queue's array of Tx/cmd buffers */
1642
	out_cmd = txq->cmd[idx];
1643
	tx = (struct iwl3945_tx_cmd *)out_cmd->cmd.payload;
Z
Zhu Yi 已提交
1644
	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
1645
	memset(tx, 0, sizeof(*tx));
1646 1647 1648 1649 1650 1651 1652

	/*
	 * 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 已提交
1653 1654
	out_cmd->hdr.cmd = REPLY_TX;
	out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
1655
				INDEX_TO_SEQ(q->write_ptr)));
1656 1657

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

1660 1661 1662 1663 1664 1665 1666 1667 1668
	/*
	 * 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.
	 */
1669
	len = sizeof(struct iwl3945_tx_cmd) +
1670
			sizeof(struct iwl_cmd_header) + hdr_len;
Z
Zhu Yi 已提交
1671 1672 1673 1674 1675 1676 1677 1678 1679

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

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

1680 1681
	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
1682 1683 1684 1685 1686 1687 1688 1689
	txcmd_phys = pci_map_single(priv->pci_dev,
				    out_cmd, sizeof(struct iwl_cmd),
				    PCI_DMA_TODEVICE);
	pci_unmap_addr_set(&out_cmd->meta, mapping, txcmd_phys);
	pci_unmap_len_set(&out_cmd->meta, len, sizeof(struct iwl_cmd));
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
	txcmd_phys += offsetof(struct iwl_cmd, hdr);
Z
Zhu Yi 已提交
1690

1691 1692
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
1693 1694
	priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
						   txcmd_phys, len, 1, 0);
Z
Zhu Yi 已提交
1695

1696
	if (info->control.hw_key)
1697
		iwl3945_build_tx_cmd_hwcrypto(priv, info, out_cmd, skb, 0);
Z
Zhu Yi 已提交
1698

1699 1700
	/* 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 已提交
1701 1702 1703 1704
	len = skb->len - hdr_len;
	if (len) {
		phys_addr = pci_map_single(priv->pci_dev, skb->data + hdr_len,
					   len, PCI_DMA_TODEVICE);
1705 1706 1707
		priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
							   phys_addr, len,
							   0, U32_PAD(len));
Z
Zhu Yi 已提交
1708 1709
	}

1710
	/* Total # bytes to be transmitted */
Z
Zhu Yi 已提交
1711
	len = (u16)skb->len;
1712
	tx->len = cpu_to_le16(len);
Z
Zhu Yi 已提交
1713 1714

	/* TODO need this for burst mode later on */
1715
	iwl3945_build_tx_cmd_basic(priv, out_cmd, info, hdr, sta_id);
Z
Zhu Yi 已提交
1716 1717

	/* set is_hcca to 0; it probably will never be implemented */
1718
	iwl3945_hw_build_tx_cmd_rate(priv, out_cmd, info, hdr, sta_id, 0);
Z
Zhu Yi 已提交
1719

1720 1721
	tx->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
	tx->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;
Z
Zhu Yi 已提交
1722

1723
	if (!ieee80211_has_morefrags(hdr->frame_control)) {
Z
Zhu Yi 已提交
1724
		txq->need_update = 1;
1725
		if (qc)
1726
			priv->stations_39[sta_id].tid[tid].seq_number = seq_number;
Z
Zhu Yi 已提交
1727 1728 1729 1730 1731
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

1732
	iwl_print_hex_dump(priv, IWL_DL_TX, tx, sizeof(*tx));
Z
Zhu Yi 已提交
1733

1734
	iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx->hdr,
1735
			   ieee80211_hdrlen(fc));
Z
Zhu Yi 已提交
1736

1737
	/* Tell device the write index *just past* this latest filled TFD */
T
Tomas Winkler 已提交
1738
	q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
1739
	rc = iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
1740 1741 1742 1743 1744
	spin_unlock_irqrestore(&priv->lock, flags);

	if (rc)
		return rc;

1745
	if ((iwl_queue_space(q) < q->high_mark)
Z
Zhu Yi 已提交
1746 1747 1748 1749
	    && priv->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&priv->lock, flags);
			txq->need_update = 1;
1750
			iwl_txq_update_write_ptr(priv, txq);
Z
Zhu Yi 已提交
1751 1752 1753
			spin_unlock_irqrestore(&priv->lock, flags);
		}

1754
		ieee80211_stop_queue(priv->hw, skb_get_queue_mapping(skb));
Z
Zhu Yi 已提交
1755 1756 1757 1758 1759 1760 1761 1762 1763 1764
	}

	return 0;

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

1765
static void iwl3945_set_rate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
1766
{
1767
	const struct ieee80211_supported_band *sband = NULL;
Z
Zhu Yi 已提交
1768 1769 1770
	struct ieee80211_rate *rate;
	int i;

K
Kolekar, Abhijeet 已提交
1771
	sband = iwl_get_hw_mode(priv, priv->band);
1772
	if (!sband) {
1773
		IWL_ERR(priv, "Failed to set rate: unable to get hw mode\n");
1774 1775
		return;
	}
Z
Zhu Yi 已提交
1776 1777 1778 1779

	priv->active_rate = 0;
	priv->active_rate_basic = 0;

1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790
	IWL_DEBUG_RATE("Setting rates for %s GHz\n",
		       sband->band == IEEE80211_BAND_2GHZ ? "2.4" : "5");

	for (i = 0; i < sband->n_bitrates; i++) {
		rate = &sband->bitrates[i];
		if ((rate->hw_value < IWL_RATE_COUNT) &&
		    !(rate->flags & IEEE80211_CHAN_DISABLED)) {
			IWL_DEBUG_RATE("Adding rate index %d (plcp %d)\n",
				       rate->hw_value, iwl3945_rates[rate->hw_value].plcp);
			priv->active_rate |= (1 << rate->hw_value);
		}
Z
Zhu Yi 已提交
1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
	}

	IWL_DEBUG_RATE("Set active_rate = %0x, active_rate_basic = %0x\n",
		       priv->active_rate, priv->active_rate_basic);

	/*
	 * If a basic rate is configured, then use it (adding IWL_RATE_1M_MASK)
	 * otherwise set it to the default of all CCK rates and 6, 12, 24 for
	 * OFDM
	 */
	if (priv->active_rate_basic & IWL_CCK_BASIC_RATES_MASK)
1802
		priv->staging39_rxon.cck_basic_rates =
Z
Zhu Yi 已提交
1803 1804 1805
		    ((priv->active_rate_basic &
		      IWL_CCK_RATES_MASK) >> IWL_FIRST_CCK_RATE) & 0xF;
	else
1806
		priv->staging39_rxon.cck_basic_rates =
Z
Zhu Yi 已提交
1807 1808 1809
		    (IWL_CCK_BASIC_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;

	if (priv->active_rate_basic & IWL_OFDM_BASIC_RATES_MASK)
1810
		priv->staging39_rxon.ofdm_basic_rates =
Z
Zhu Yi 已提交
1811 1812 1813 1814
		    ((priv->active_rate_basic &
		      (IWL_OFDM_BASIC_RATES_MASK | IWL_RATE_6M_MASK)) >>
		      IWL_FIRST_OFDM_RATE) & 0xFF;
	else
1815
		priv->staging39_rxon.ofdm_basic_rates =
Z
Zhu Yi 已提交
1816 1817 1818
		   (IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
}

1819
static void iwl3945_radio_kill_sw(struct iwl_priv *priv, int disable_radio)
Z
Zhu Yi 已提交
1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
{
	unsigned long flags;

	if (!!disable_radio == test_bit(STATUS_RF_KILL_SW, &priv->status))
		return;

	IWL_DEBUG_RF_KILL("Manual SW RF KILL set to: RADIO %s\n",
			  disable_radio ? "OFF" : "ON");

	if (disable_radio) {
1830
		iwl_scan_cancel(priv);
Z
Zhu Yi 已提交
1831
		/* FIXME: This is a workaround for AP */
1832
		if (priv->iw_mode != NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
1833
			spin_lock_irqsave(&priv->lock, flags);
1834
			iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
1835 1836
				    CSR_UCODE_SW_BIT_RFKILL);
			spin_unlock_irqrestore(&priv->lock, flags);
1837
			iwl_send_card_state(priv, CARD_STATE_CMD_DISABLE, 0);
Z
Zhu Yi 已提交
1838 1839 1840 1841 1842 1843
			set_bit(STATUS_RF_KILL_SW, &priv->status);
		}
		return;
	}

	spin_lock_irqsave(&priv->lock, flags);
1844
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
Z
Zhu Yi 已提交
1845 1846 1847 1848 1849 1850 1851 1852

	clear_bit(STATUS_RF_KILL_SW, &priv->status);
	spin_unlock_irqrestore(&priv->lock, flags);

	/* wake up ucode */
	msleep(10);

	spin_lock_irqsave(&priv->lock, flags);
1853 1854 1855
	iwl_read32(priv, CSR_UCODE_DRV_GP1);
	if (!iwl_grab_nic_access(priv))
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
1856 1857 1858 1859 1860 1861 1862 1863
	spin_unlock_irqrestore(&priv->lock, flags);

	if (test_bit(STATUS_RF_KILL_HW, &priv->status)) {
		IWL_DEBUG_RF_KILL("Can not turn radio back on - "
				  "disabled by HW switch\n");
		return;
	}

1864 1865
	if (priv->is_open)
		queue_work(priv->workqueue, &priv->restart);
Z
Zhu Yi 已提交
1866 1867 1868
	return;
}

1869
void iwl3945_set_decrypted_flag(struct iwl_priv *priv, struct sk_buff *skb,
Z
Zhu Yi 已提交
1870 1871 1872 1873 1874
			    u32 decrypt_res, struct ieee80211_rx_status *stats)
{
	u16 fc =
	    le16_to_cpu(((struct ieee80211_hdr *)skb->data)->frame_control);

1875
	if (priv->active39_rxon.filter_flags & RXON_FILTER_DIS_DECRYPT_MSK)
Z
Zhu Yi 已提交
1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
		return;

	if (!(fc & IEEE80211_FCTL_PROTECTED))
		return;

	IWL_DEBUG_RX("decrypt_res:0x%x\n", decrypt_res);
	switch (decrypt_res & RX_RES_STATUS_SEC_TYPE_MSK) {
	case RX_RES_STATUS_SEC_TYPE_TKIP:
		if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
		    RX_RES_STATUS_BAD_ICV_MIC)
			stats->flag |= RX_FLAG_MMIC_ERROR;
	case RX_RES_STATUS_SEC_TYPE_WEP:
	case RX_RES_STATUS_SEC_TYPE_CCMP:
		if ((decrypt_res & RX_RES_STATUS_DECRYPT_TYPE_MSK) ==
		    RX_RES_STATUS_DECRYPT_OK) {
			IWL_DEBUG_RX("hw decrypt successfully!!!\n");
			stats->flag |= RX_FLAG_DECRYPTED;
		}
		break;

	default:
		break;
	}
}

1901
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915

#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 已提交
1916
static u32 iwl3945_usecs_to_beacons(u32 usec, u32 beacon_interval)
Z
Zhu Yi 已提交
1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
{
	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 已提交
1935
static __le32 iwl3945_add_beacon_time(u32 base, u32 addon, u32 beacon_interval)
Z
Zhu Yi 已提交
1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953
{
	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);
}

1954
static int iwl3945_get_measurement(struct iwl_priv *priv,
Z
Zhu Yi 已提交
1955 1956 1957
			       struct ieee80211_measurement_params *params,
			       u8 type)
{
1958
	struct iwl_spectrum_cmd spectrum;
1959
	struct iwl_rx_packet *res;
1960
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
1961 1962 1963 1964 1965 1966 1967 1968 1969
		.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);

C
Christoph Hellwig 已提交
1970
	if (iwl3945_is_associated(priv))
Z
Zhu Yi 已提交
1971
		add_time =
C
Christoph Hellwig 已提交
1972
		    iwl3945_usecs_to_beacons(
Z
Zhu Yi 已提交
1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
			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));

C
Christoph Hellwig 已提交
1985
	if (iwl3945_is_associated(priv))
Z
Zhu Yi 已提交
1986
		spectrum.start_time =
C
Christoph Hellwig 已提交
1987
		    iwl3945_add_beacon_time(priv->last_beacon_time,
Z
Zhu Yi 已提交
1988 1989 1990 1991 1992 1993 1994 1995
				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;
1996
	if (priv->active39_rxon.flags & RXON_FLG_BAND_24G_MSK)
Z
Zhu Yi 已提交
1997 1998 1999
		spectrum.flags |= RXON_FLG_BAND_24G_MSK |
		    RXON_FLG_AUTO_DETECT_MSK | RXON_FLG_TGG_PROTECT_MSK;

2000
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
2001 2002 2003
	if (rc)
		return rc;

2004
	res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
Z
Zhu Yi 已提交
2005
	if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
2006
		IWL_ERR(priv, "Bad return from REPLY_RX_ON_ASSOC command\n");
Z
Zhu Yi 已提交
2007 2008 2009 2010 2011 2012 2013
		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) {
2014 2015
			IWL_DEBUG_INFO("Replaced existing measurement: %d\n",
						res->u.spectrum.id);
Z
Zhu Yi 已提交
2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
			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

2033
static void iwl3945_rx_reply_alive(struct iwl_priv *priv,
2034
			       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2035
{
2036 2037
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
	struct iwl_alive_resp *palive;
Z
Zhu Yi 已提交
2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048
	struct delayed_work *pwork;

	palive = &pkt->u.alive_frame;

	IWL_DEBUG_INFO("Alive ucode status 0x%08X revision "
		       "0x%01X 0x%01X\n",
		       palive->is_valid, palive->ver_type,
		       palive->ver_subtype);

	if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
		IWL_DEBUG_INFO("Initialization Alive received.\n");
2049 2050
		memcpy(&priv->card_alive_init, &pkt->u.alive_frame,
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
2051 2052 2053 2054
		pwork = &priv->init_alive_start;
	} else {
		IWL_DEBUG_INFO("Runtime Alive received.\n");
		memcpy(&priv->card_alive, &pkt->u.alive_frame,
2055
		       sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
2056
		pwork = &priv->alive_start;
C
Christoph Hellwig 已提交
2057
		iwl3945_disable_events(priv);
Z
Zhu Yi 已提交
2058 2059 2060 2061 2062 2063 2064 2065
	}

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

2069
static void iwl3945_rx_reply_add_sta(struct iwl_priv *priv,
2070
				 struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2071
{
2072
#ifdef CONFIG_IWLWIFI_DEBUG
2073
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2074
#endif
Z
Zhu Yi 已提交
2075 2076 2077 2078 2079

	IWL_DEBUG_RX("Received REPLY_ADD_STA: 0x%02X\n", pkt->u.status);
	return;
}

2080
static void iwl3945_rx_reply_error(struct iwl_priv *priv,
2081
			       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2082
{
2083
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
2084

2085
	IWL_ERR(priv, "Error Reply type 0x%08X cmd %s (0x%02X) "
Z
Zhu Yi 已提交
2086 2087 2088 2089 2090 2091 2092 2093 2094 2095
		"seq 0x%04X ser 0x%08X\n",
		le32_to_cpu(pkt->u.err_resp.error_type),
		get_cmd_string(pkt->u.err_resp.cmd_id),
		pkt->u.err_resp.cmd_id,
		le16_to_cpu(pkt->u.err_resp.bad_cmd_seq_num),
		le32_to_cpu(pkt->u.err_resp.error_info));
}

#define TX_STATUS_ENTRY(x) case TX_STATUS_FAIL_ ## x: return #x

2096
static void iwl3945_rx_csa(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2097
{
2098
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2099
	struct iwl3945_rxon_cmd *rxon = (void *)&priv->active39_rxon;
2100
	struct iwl_csa_notification *csa = &(pkt->u.csa_notif);
Z
Zhu Yi 已提交
2101 2102 2103
	IWL_DEBUG_11H("CSA notif: channel %d, status %d\n",
		      le16_to_cpu(csa->channel), le32_to_cpu(csa->status));
	rxon->channel = csa->channel;
2104
	priv->staging39_rxon.channel = csa->channel;
Z
Zhu Yi 已提交
2105 2106
}

2107
static void iwl3945_rx_spectrum_measure_notif(struct iwl_priv *priv,
2108
					  struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2109
{
2110
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
2111
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2112
	struct iwl_spectrum_notification *report = &(pkt->u.spectrum_notif);
Z
Zhu Yi 已提交
2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124

	if (!report->state) {
		IWL_DEBUG(IWL_DL_11H | IWL_DL_INFO,
			  "Spectrum Measure Notification: Start\n");
		return;
	}

	memcpy(&priv->measure_report, report, sizeof(*report));
	priv->measurement_status |= MEASUREMENT_READY;
#endif
}

2125
static void iwl3945_rx_pm_sleep_notif(struct iwl_priv *priv,
2126
				  struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2127
{
2128
#ifdef CONFIG_IWL3945_DEBUG
2129
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2130
	struct iwl_sleep_notification *sleep = &(pkt->u.sleep_notif);
Z
Zhu Yi 已提交
2131 2132 2133 2134 2135
	IWL_DEBUG_RX("sleep mode: %d, src: %d\n",
		     sleep->pm_sleep_mode, sleep->pm_wakeup_src);
#endif
}

2136
static void iwl3945_rx_pm_debug_statistics_notif(struct iwl_priv *priv,
2137
					     struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2138
{
2139
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
2140 2141 2142
	IWL_DEBUG_RADIO("Dumping %d bytes of unhandled "
			"notification for %s:\n",
			le32_to_cpu(pkt->len), get_cmd_string(pkt->hdr.cmd));
2143 2144
	iwl_print_hex_dump(priv, IWL_DL_RADIO, pkt->u.raw,
			   le32_to_cpu(pkt->len));
Z
Zhu Yi 已提交
2145 2146
}

C
Christoph Hellwig 已提交
2147
static void iwl3945_bg_beacon_update(struct work_struct *work)
Z
Zhu Yi 已提交
2148
{
2149 2150
	struct iwl_priv *priv =
		container_of(work, struct iwl_priv, beacon_update);
Z
Zhu Yi 已提交
2151 2152 2153
	struct sk_buff *beacon;

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

	if (!beacon) {
2157
		IWL_ERR(priv, "update beacon failed\n");
Z
Zhu Yi 已提交
2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168
		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 已提交
2169
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
2170 2171
}

2172
static void iwl3945_rx_beacon_notif(struct iwl_priv *priv,
2173
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2174
{
2175
#ifdef CONFIG_IWL3945_DEBUG
2176
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
C
Christoph Hellwig 已提交
2177
	struct iwl3945_beacon_notif *beacon = &(pkt->u.beacon_status);
Z
Zhu Yi 已提交
2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188
	u8 rate = beacon->beacon_notify_hdr.rate;

	IWL_DEBUG_RX("beacon status %x retries %d iss %d "
		"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

2189
	if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
Z
Zhu Yi 已提交
2190 2191 2192 2193 2194
	    (!test_bit(STATUS_EXIT_PENDING, &priv->status)))
		queue_work(priv->workqueue, &priv->beacon_update);
}

/* Service response to REPLY_SCAN_CMD (0x80) */
2195
static void iwl3945_rx_reply_scan(struct iwl_priv *priv,
2196
			      struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2197
{
2198
#ifdef CONFIG_IWL3945_DEBUG
2199
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2200 2201
	struct iwl_scanreq_notification *notif =
	    (struct iwl_scanreq_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
2202 2203 2204 2205 2206 2207

	IWL_DEBUG_RX("Scan request status = 0x%x\n", notif->status);
#endif
}

/* Service SCAN_START_NOTIFICATION (0x82) */
2208
static void iwl3945_rx_scan_start_notif(struct iwl_priv *priv,
2209
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2210
{
2211
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2212 2213
	struct iwl_scanstart_notification *notif =
	    (struct iwl_scanstart_notification *)pkt->u.raw;
Z
Zhu Yi 已提交
2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224
	priv->scan_start_tsf = le32_to_cpu(notif->tsf_low);
	IWL_DEBUG_SCAN("Scan start: "
		       "%d [802.11%s] "
		       "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n",
		       notif->channel,
		       notif->band ? "bg" : "a",
		       notif->tsf_high,
		       notif->tsf_low, notif->status, notif->beacon_timer);
}

/* Service SCAN_RESULTS_NOTIFICATION (0x83) */
2225
static void iwl3945_rx_scan_results_notif(struct iwl_priv *priv,
2226
				      struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2227
{
2228
#ifdef CONFIG_IWLWIFI_DEBUG
2229
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2230 2231
	struct iwl_scanresults_notification *notif =
	    (struct iwl_scanresults_notification *)pkt->u.raw;
2232
#endif
Z
Zhu Yi 已提交
2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247

	IWL_DEBUG_SCAN("Scan ch.res: "
		       "%d [802.11%s] "
		       "(TSF: 0x%08X:%08X) - %d "
		       "elapsed=%lu usec (%dms since last)\n",
		       notif->channel,
		       notif->band ? "bg" : "a",
		       le32_to_cpu(notif->tsf_high),
		       le32_to_cpu(notif->tsf_low),
		       le32_to_cpu(notif->statistics[0]),
		       le32_to_cpu(notif->tsf_low) - priv->scan_start_tsf,
		       jiffies_to_msecs(elapsed_jiffies
					(priv->last_scan_jiffies, jiffies)));

	priv->last_scan_jiffies = jiffies;
2248
	priv->next_scan_jiffies = 0;
Z
Zhu Yi 已提交
2249 2250 2251
}

/* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
2252
static void iwl3945_rx_scan_complete_notif(struct iwl_priv *priv,
2253
				       struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2254
{
2255
#ifdef CONFIG_IWLWIFI_DEBUG
2256
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
2257
	struct iwl_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
2258
#endif
Z
Zhu Yi 已提交
2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271

	IWL_DEBUG_SCAN("Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
		       scan_notif->scanned_channels,
		       scan_notif->tsf_low,
		       scan_notif->tsf_high, scan_notif->status);

	/* The HW is no longer scanning */
	clear_bit(STATUS_SCAN_HW, &priv->status);

	/* The scan completion notification came in, so kill that timer... */
	cancel_delayed_work(&priv->scan_check);

	IWL_DEBUG_INFO("Scan pass on %sGHz took %dms\n",
2272 2273
		       (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) ?
							"2.4" : "5.2",
Z
Zhu Yi 已提交
2274 2275 2276
		       jiffies_to_msecs(elapsed_jiffies
					(priv->scan_pass_start, jiffies)));

2277 2278 2279 2280 2281 2282 2283
	/* Remove this scanned band from the list of pending
	 * bands to scan, band G precedes A in order of scanning
	 * as seen in iwl3945_bg_request_scan */
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ))
		priv->scan_bands &= ~BIT(IEEE80211_BAND_2GHZ);
	else if (priv->scan_bands &  BIT(IEEE80211_BAND_5GHZ))
		priv->scan_bands &= ~BIT(IEEE80211_BAND_5GHZ);
Z
Zhu Yi 已提交
2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297

	/* If a request to abort was given, or the scan did not succeed
	 * then we reset the scan state machine and terminate,
	 * re-queuing another scan if one has been requested */
	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
		IWL_DEBUG_INFO("Aborted scan completed.\n");
		clear_bit(STATUS_SCAN_ABORTING, &priv->status);
	} else {
		/* If there are more bands on this scan pass reschedule */
		if (priv->scan_bands > 0)
			goto reschedule;
	}

	priv->last_scan_jiffies = jiffies;
2298
	priv->next_scan_jiffies = 0;
Z
Zhu Yi 已提交
2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
	IWL_DEBUG_INFO("Setting scan to off\n");

	clear_bit(STATUS_SCANNING, &priv->status);

	IWL_DEBUG_INFO("Scan took %dms\n",
		jiffies_to_msecs(elapsed_jiffies(priv->scan_start, jiffies)));

	queue_work(priv->workqueue, &priv->scan_completed);

	return;

reschedule:
	priv->scan_pass_start = jiffies;
	queue_work(priv->workqueue, &priv->request_scan);
}

/* Handle notification from uCode that card's power state is changing
 * due to software, hardware, or critical temperature RFKILL */
2317
static void iwl3945_rx_card_state_notif(struct iwl_priv *priv,
2318
				    struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2319
{
2320
	struct iwl_rx_packet *pkt = (void *)rxb->skb->data;
Z
Zhu Yi 已提交
2321 2322 2323 2324 2325 2326 2327
	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
	unsigned long status = priv->status;

	IWL_DEBUG_RF_KILL("Card state received: HW:%s SW:%s\n",
			  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
			  (flags & SW_CARD_DISABLED) ? "Kill" : "On");

2328
	iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
Z
Zhu Yi 已提交
2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341
		    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);


	if (flags & SW_CARD_DISABLED)
		set_bit(STATUS_RF_KILL_SW, &priv->status);
	else
		clear_bit(STATUS_RF_KILL_SW, &priv->status);

2342
	iwl_scan_cancel(priv);
Z
Zhu Yi 已提交
2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353

	if ((test_bit(STATUS_RF_KILL_HW, &status) !=
	     test_bit(STATUS_RF_KILL_HW, &priv->status)) ||
	    (test_bit(STATUS_RF_KILL_SW, &status) !=
	     test_bit(STATUS_RF_KILL_SW, &priv->status)))
		queue_work(priv->workqueue, &priv->rf_kill);
	else
		wake_up_interruptible(&priv->wait_command_queue);
}

/**
C
Christoph Hellwig 已提交
2354
 * iwl3945_setup_rx_handlers - Initialize Rx handler callbacks
Z
Zhu Yi 已提交
2355 2356 2357 2358 2359 2360 2361
 *
 * 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.
 */
2362
static void iwl3945_setup_rx_handlers(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2363
{
C
Christoph Hellwig 已提交
2364 2365 2366 2367
	priv->rx_handlers[REPLY_ALIVE] = iwl3945_rx_reply_alive;
	priv->rx_handlers[REPLY_ADD_STA] = iwl3945_rx_reply_add_sta;
	priv->rx_handlers[REPLY_ERROR] = iwl3945_rx_reply_error;
	priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl3945_rx_csa;
Z
Zhu Yi 已提交
2368
	priv->rx_handlers[SPECTRUM_MEASURE_NOTIFICATION] =
C
Christoph Hellwig 已提交
2369 2370
	    iwl3945_rx_spectrum_measure_notif;
	priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl3945_rx_pm_sleep_notif;
Z
Zhu Yi 已提交
2371
	priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
C
Christoph Hellwig 已提交
2372 2373
	    iwl3945_rx_pm_debug_statistics_notif;
	priv->rx_handlers[BEACON_NOTIFICATION] = iwl3945_rx_beacon_notif;
Z
Zhu Yi 已提交
2374

2375 2376 2377 2378
	/*
	 * 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 已提交
2379
	 */
C
Christoph Hellwig 已提交
2380 2381
	priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl3945_hw_rx_statistics;
	priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl3945_hw_rx_statistics;
Z
Zhu Yi 已提交
2382

C
Christoph Hellwig 已提交
2383 2384
	priv->rx_handlers[REPLY_SCAN_CMD] = iwl3945_rx_reply_scan;
	priv->rx_handlers[SCAN_START_NOTIFICATION] = iwl3945_rx_scan_start_notif;
Z
Zhu Yi 已提交
2385
	priv->rx_handlers[SCAN_RESULTS_NOTIFICATION] =
C
Christoph Hellwig 已提交
2386
	    iwl3945_rx_scan_results_notif;
Z
Zhu Yi 已提交
2387
	priv->rx_handlers[SCAN_COMPLETE_NOTIFICATION] =
C
Christoph Hellwig 已提交
2388 2389
	    iwl3945_rx_scan_complete_notif;
	priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl3945_rx_card_state_notif;
Z
Zhu Yi 已提交
2390

2391
	/* Set up hardware specific Rx handlers */
C
Christoph Hellwig 已提交
2392
	iwl3945_hw_rx_handler_setup(priv);
Z
Zhu Yi 已提交
2393 2394
}

2395 2396 2397 2398 2399
/**
 * iwl3945_cmd_queue_reclaim - Reclaim CMD queue entries
 * When FW advances 'R' index, all entries between old and new 'R' index
 * need to be reclaimed.
 */
2400
static void iwl3945_cmd_queue_reclaim(struct iwl_priv *priv,
2401 2402
				      int txq_id, int index)
{
2403
	struct iwl_tx_queue *txq = &priv->txq[txq_id];
2404
	struct iwl_queue *q = &txq->q;
2405 2406
	int nfreed = 0;

2407
	if ((index >= q->n_bd) || (iwl_queue_used(q, index) == 0)) {
2408
		IWL_ERR(priv, "Read index for DMA queue txq id (%d), index %d, "
2409 2410 2411 2412 2413 2414 2415 2416
			  "is out of range [0-%d] %d %d.\n", txq_id,
			  index, q->n_bd, q->write_ptr, q->read_ptr);
		return;
	}

	for (index = iwl_queue_inc_wrap(index, q->n_bd); q->read_ptr != index;
		q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd)) {
		if (nfreed > 1) {
2417
			IWL_ERR(priv, "HCMD skipped: index (%d) %d %d\n", index,
2418 2419 2420 2421 2422 2423 2424 2425 2426
					q->write_ptr, q->read_ptr);
			queue_work(priv->workqueue, &priv->restart);
			break;
		}
		nfreed++;
	}
}


Z
Zhu Yi 已提交
2427
/**
C
Christoph Hellwig 已提交
2428
 * iwl3945_tx_cmd_complete - Pull unused buffers off the queue and reclaim them
Z
Zhu Yi 已提交
2429 2430 2431 2432 2433 2434
 * @rxb: Rx buffer to reclaim
 *
 * If an Rx buffer has an async callback associated with it the callback
 * will be executed.  The attached skb (if present) will only be freed
 * if the callback returns 1
 */
2435
static void iwl3945_tx_cmd_complete(struct iwl_priv *priv,
2436
				struct iwl_rx_mem_buffer *rxb)
Z
Zhu Yi 已提交
2437
{
2438
	struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
2439 2440 2441
	u16 sequence = le16_to_cpu(pkt->hdr.sequence);
	int txq_id = SEQ_TO_QUEUE(sequence);
	int index = SEQ_TO_INDEX(sequence);
2442
	int huge =  !!(pkt->hdr.sequence & SEQ_HUGE_FRAME);
Z
Zhu Yi 已提交
2443
	int cmd_index;
2444
	struct iwl_cmd *cmd;
Z
Zhu Yi 已提交
2445

2446 2447 2448 2449 2450 2451 2452 2453
	if (WARN(txq_id != IWL_CMD_QUEUE_NUM,
		 "wrong command queue %d, sequence 0x%X readp=%d writep=%d\n",
		  txq_id, sequence,
		  priv->txq[IWL_CMD_QUEUE_NUM].q.read_ptr,
		  priv->txq[IWL_CMD_QUEUE_NUM].q.write_ptr)) {
		iwl_print_hex_dump(priv, IWL_DL_INFO , rxb, 32);
		return;
	}
Z
Zhu Yi 已提交
2454

2455 2456
	cmd_index = get_cmd_index(&priv->txq[IWL_CMD_QUEUE_NUM].q, index, huge);
	cmd = priv->txq[IWL_CMD_QUEUE_NUM].cmd[cmd_index];
Z
Zhu Yi 已提交
2457 2458 2459 2460 2461 2462 2463 2464 2465

	/* Input error checking is done when commands are added to queue. */
	if (cmd->meta.flags & CMD_WANT_SKB) {
		cmd->meta.source->u.skb = rxb->skb;
		rxb->skb = NULL;
	} else if (cmd->meta.u.callback &&
		   !cmd->meta.u.callback(priv, cmd, rxb->skb))
		rxb->skb = NULL;

2466
	iwl3945_cmd_queue_reclaim(priv, txq_id, index);
Z
Zhu Yi 已提交
2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495

	if (!(cmd->meta.flags & CMD_ASYNC)) {
		clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
		wake_up_interruptible(&priv->wait_command_queue);
	}
}

/************************** 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.
 *
2496
 * During initialization, the host sets up the READ queue position to the first
Z
Zhu Yi 已提交
2497 2498
 * INDEX position, and WRITE to the last (READ - 1 wrapped)
 *
2499
 * When the firmware places a packet in a buffer, it will advance the READ index
Z
Zhu Yi 已提交
2500 2501 2502 2503 2504 2505 2506
 * 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
2507
 *   to replenish the iwl->rxq->rx_free.
C
Christoph Hellwig 已提交
2508
 * + In iwl3945_rx_replenish (scheduled) if 'processed' != 'read' then the
Z
Zhu Yi 已提交
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520
 *   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:
 *
2521
 * iwl3945_rx_replenish()     Replenishes rx_free list from rx_used, and calls
C
Christoph Hellwig 已提交
2522
 *                            iwl3945_rx_queue_restock
2523
 * iwl3945_rx_queue_restock() Moves available buffers from rx_free into Rx
Z
Zhu Yi 已提交
2524 2525
 *                            queue, updates firmware pointers, and updates
 *                            the WRITE index.  If insufficient rx_free buffers
C
Christoph Hellwig 已提交
2526
 *                            are available, schedules iwl3945_rx_replenish
Z
Zhu Yi 已提交
2527 2528
 *
 * -- enable interrupts --
2529
 * ISR - iwl3945_rx()         Detach iwl_rx_mem_buffers from pool up to the
Z
Zhu Yi 已提交
2530 2531
 *                            READ INDEX, detaching the SKB from the pool.
 *                            Moves the packet buffer from queue to rx_used.
C
Christoph Hellwig 已提交
2532
 *                            Calls iwl3945_rx_queue_restock to refill any empty
Z
Zhu Yi 已提交
2533 2534 2535 2536 2537 2538
 *                            slots.
 * ...
 *
 */

/**
2539
 * iwl3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
Z
Zhu Yi 已提交
2540
 */
2541
static inline __le32 iwl3945_dma_addr2rbd_ptr(struct iwl_priv *priv,
Z
Zhu Yi 已提交
2542 2543 2544 2545 2546 2547
					  dma_addr_t dma_addr)
{
	return cpu_to_le32((u32)dma_addr);
}

/**
C
Christoph Hellwig 已提交
2548
 * iwl3945_rx_queue_restock - refill RX queue from pre-allocated pool
Z
Zhu Yi 已提交
2549
 *
2550
 * If there are slots in the RX queue that need to be restocked,
Z
Zhu Yi 已提交
2551
 * and we have free pre-allocated buffers, fill the ranks as much
2552
 * as we can, pulling from rx_free.
Z
Zhu Yi 已提交
2553 2554 2555 2556 2557
 *
 * 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.
 */
2558
static int iwl3945_rx_queue_restock(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2559
{
2560
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
2561
	struct list_head *element;
2562
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
2563 2564 2565 2566 2567
	unsigned long flags;
	int write, rc;

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write & ~0x7;
2568
	while ((iwl_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
2569
		/* Get next free Rx buffer, remove from free list */
Z
Zhu Yi 已提交
2570
		element = rxq->rx_free.next;
2571
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
Z
Zhu Yi 已提交
2572
		list_del(element);
2573 2574

		/* Point to Rx buffer via next RBD in circular buffer */
2575
		rxq->bd[rxq->write] = iwl3945_dma_addr2rbd_ptr(priv, rxb->real_dma_addr);
Z
Zhu Yi 已提交
2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586
		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);


2587 2588
	/* If we've added more space for the firmware to place data, tell it.
	 * Increment device's write pointer in multiples of 8. */
Z
Zhu Yi 已提交
2589 2590 2591 2592 2593
	if ((write != (rxq->write & ~0x7))
	    || (abs(rxq->write - rxq->read) > 7)) {
		spin_lock_irqsave(&rxq->lock, flags);
		rxq->need_update = 1;
		spin_unlock_irqrestore(&rxq->lock, flags);
2594
		rc = iwl_rx_queue_update_write_ptr(priv, rxq);
Z
Zhu Yi 已提交
2595 2596 2597 2598 2599 2600 2601 2602
		if (rc)
			return rc;
	}

	return 0;
}

/**
C
Christoph Hellwig 已提交
2603
 * iwl3945_rx_replenish - Move all used packet from rx_used to rx_free
Z
Zhu Yi 已提交
2604 2605 2606
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
C
Christoph Hellwig 已提交
2607
 * Also restock the Rx queue via iwl3945_rx_queue_restock.
2608
 * This is called as a scheduled work item (except for during initialization)
Z
Zhu Yi 已提交
2609
 */
2610
static void iwl3945_rx_allocate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2611
{
2612
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
2613
	struct list_head *element;
2614
	struct iwl_rx_mem_buffer *rxb;
Z
Zhu Yi 已提交
2615 2616 2617 2618
	unsigned long flags;
	spin_lock_irqsave(&rxq->lock, flags);
	while (!list_empty(&rxq->rx_used)) {
		element = rxq->rx_used.next;
2619
		rxb = list_entry(element, struct iwl_rx_mem_buffer, list);
2620 2621

		/* Alloc a new receive buffer */
Z
Zhu Yi 已提交
2622
		rxb->skb =
2623 2624
		    alloc_skb(priv->hw_params.rx_buf_size,
				__GFP_NOWARN | GFP_ATOMIC);
Z
Zhu Yi 已提交
2625 2626
		if (!rxb->skb) {
			if (net_ratelimit())
T
Tomas Winkler 已提交
2627
				IWL_CRIT(priv, ": Can not allocate SKB buffers\n");
Z
Zhu Yi 已提交
2628 2629 2630 2631 2632
			/* 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 已提交
2633 2634 2635 2636 2637 2638 2639 2640 2641

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

Z
Zhu Yi 已提交
2642 2643
		priv->alloc_rxb_skb++;
		list_del(element);
2644 2645

		/* Get physical address of RB/SKB */
2646 2647 2648 2649
		rxb->real_dma_addr = pci_map_single(priv->pci_dev,
						rxb->skb->data,
						priv->hw_params.rx_buf_size,
						PCI_DMA_FROMDEVICE);
Z
Zhu Yi 已提交
2650 2651 2652 2653
		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);
2654 2655 2656 2657 2658
}

/*
 * this should be called while priv->lock is locked
 */
2659
static void __iwl3945_rx_replenish(void *data)
2660
{
2661
	struct iwl_priv *priv = data;
2662 2663 2664 2665 2666 2667 2668 2669

	iwl3945_rx_allocate(priv);
	iwl3945_rx_queue_restock(priv);
}


void iwl3945_rx_replenish(void *data)
{
2670
	struct iwl_priv *priv = data;
2671 2672 2673
	unsigned long flags;

	iwl3945_rx_allocate(priv);
Z
Zhu Yi 已提交
2674 2675

	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
2676
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697
	spin_unlock_irqrestore(&priv->lock, flags);
}

/* 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 已提交
2698
int iwl3945_calc_db_from_ratio(int sig_ratio)
Z
Zhu Yi 已提交
2699
{
2700 2701
	/* 1000:1 or higher just report as 60 dB */
	if (sig_ratio >= 1000)
Z
Zhu Yi 已提交
2702 2703
		return 60;

2704
	/* 100:1 or higher, divide by 10 and use table,
Z
Zhu Yi 已提交
2705
	 *   add 20 dB to make up for divide by 10 */
2706
	if (sig_ratio >= 100)
2707
		return 20 + (int)ratio2dB[sig_ratio/10];
Z
Zhu Yi 已提交
2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723

	/* 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 已提交
2724
int iwl3945_calc_sig_qual(int rssi_dbm, int noise_dbm)
Z
Zhu Yi 已提交
2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758
{
	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;
}

/**
2759
 * iwl3945_rx_handle - Main entry function for receiving responses from uCode
Z
Zhu Yi 已提交
2760 2761 2762 2763 2764
 *
 * Uses the priv->rx_handlers callback function array to invoke
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
2765
static void iwl3945_rx_handle(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2766
{
2767
	struct iwl_rx_mem_buffer *rxb;
2768
	struct iwl_rx_packet *pkt;
2769
	struct iwl_rx_queue *rxq = &priv->rxq;
Z
Zhu Yi 已提交
2770 2771 2772
	u32 r, i;
	int reclaim;
	unsigned long flags;
2773
	u8 fill_rx = 0;
M
Mohamed Abbas 已提交
2774
	u32 count = 8;
Z
Zhu Yi 已提交
2775

2776 2777
	/* 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 已提交
2778
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) &  0x0FFF;
Z
Zhu Yi 已提交
2779 2780
	i = rxq->read;

2781
	if (iwl_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
2782
		fill_rx = 1;
Z
Zhu Yi 已提交
2783 2784 2785 2786 2787 2788 2789
	/* Rx interrupt, but nothing sent from uCode */
	if (i == r)
		IWL_DEBUG(IWL_DL_RX | IWL_DL_ISR, "r = %d, i = %d\n", r, i);

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

2790
		/* If an RXB doesn't have a Rx queue slot associated with it,
Z
Zhu Yi 已提交
2791 2792 2793 2794 2795 2796
		 * then a bug has been introduced in the queue refilling
		 * routines -- catch it here */
		BUG_ON(rxb == NULL);

		rxq->queue[i] = NULL;

2797
		pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->real_dma_addr,
2798
					    priv->hw_params.rx_buf_size,
Z
Zhu Yi 已提交
2799
					    PCI_DMA_FROMDEVICE);
2800
		pkt = (struct iwl_rx_packet *)rxb->skb->data;
Z
Zhu Yi 已提交
2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813

		/* 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 已提交
2814
		 *   rx_handlers table.  See iwl3945_setup_rx_handlers() */
Z
Zhu Yi 已提交
2815
		if (priv->rx_handlers[pkt->hdr.cmd]) {
2816
			IWL_DEBUG(IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
2817 2818 2819 2820 2821
				"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);
		} else {
			/* No handling needed */
2822
			IWL_DEBUG(IWL_DL_HCMD | IWL_DL_RX | IWL_DL_ISR,
Z
Zhu Yi 已提交
2823 2824 2825 2826 2827 2828
				"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) {
2829
			/* Invoke any callbacks, transfer the skb to caller, and
2830
			 * fire off the (possibly) blocking iwl_send_cmd()
Z
Zhu Yi 已提交
2831 2832
			 * as we reclaim the driver command queue */
			if (rxb && rxb->skb)
C
Christoph Hellwig 已提交
2833
				iwl3945_tx_cmd_complete(priv, rxb);
Z
Zhu Yi 已提交
2834
			else
2835
				IWL_WARN(priv, "Claim null rxb?\n");
Z
Zhu Yi 已提交
2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846
		}

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

2847
		pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
2848 2849
				priv->hw_params.rx_buf_size,
				PCI_DMA_FROMDEVICE);
Z
Zhu Yi 已提交
2850 2851 2852 2853
		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;
2854 2855 2856 2857 2858 2859 2860 2861 2862 2863
		/* 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;
				__iwl3945_rx_replenish(priv);
				count = 0;
			}
		}
Z
Zhu Yi 已提交
2864 2865 2866 2867
	}

	/* Backtrack one entry */
	priv->rxq.read = i;
C
Christoph Hellwig 已提交
2868
	iwl3945_rx_queue_restock(priv);
Z
Zhu Yi 已提交
2869 2870
}

2871
#ifdef CONFIG_IWL3945_DEBUG
2872
static void iwl3945_print_rx_config_cmd(struct iwl_priv *priv,
2873
					struct iwl3945_rxon_cmd *rxon)
Z
Zhu Yi 已提交
2874 2875
{
	IWL_DEBUG_RADIO("RX CONFIG:\n");
2876
	iwl_print_hex_dump(priv, IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
Z
Zhu Yi 已提交
2877 2878 2879 2880 2881 2882 2883 2884
	IWL_DEBUG_RADIO("u16 channel: 0x%x\n", le16_to_cpu(rxon->channel));
	IWL_DEBUG_RADIO("u32 flags: 0x%08X\n", le32_to_cpu(rxon->flags));
	IWL_DEBUG_RADIO("u32 filter_flags: 0x%08x\n",
			le32_to_cpu(rxon->filter_flags));
	IWL_DEBUG_RADIO("u8 dev_type: 0x%x\n", rxon->dev_type);
	IWL_DEBUG_RADIO("u8 ofdm_basic_rates: 0x%02x\n",
			rxon->ofdm_basic_rates);
	IWL_DEBUG_RADIO("u8 cck_basic_rates: 0x%02x\n", rxon->cck_basic_rates);
J
Johannes Berg 已提交
2885 2886
	IWL_DEBUG_RADIO("u8[6] node_addr: %pM\n", rxon->node_addr);
	IWL_DEBUG_RADIO("u8[6] bssid_addr: %pM\n", rxon->bssid_addr);
Z
Zhu Yi 已提交
2887 2888 2889 2890
	IWL_DEBUG_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
}
#endif

2891
static void iwl3945_enable_interrupts(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2892 2893 2894
{
	IWL_DEBUG_ISR("Enabling interrupts\n");
	set_bit(STATUS_INT_ENABLED, &priv->status);
2895
	iwl_write32(priv, CSR_INT_MASK, CSR_INI_SET_MASK);
Z
Zhu Yi 已提交
2896 2897
}

2898 2899

/* call this function to flush any scheduled tasklet */
2900
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
2901
{
T
Tomas Winkler 已提交
2902
	/* wait to make sure we flush pending tasklet*/
2903 2904 2905 2906 2907
	synchronize_irq(priv->pci_dev->irq);
	tasklet_kill(&priv->irq_tasklet);
}


2908
static inline void iwl3945_disable_interrupts(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2909 2910 2911 2912
{
	clear_bit(STATUS_INT_ENABLED, &priv->status);

	/* disable interrupts from uCode/NIC to host */
2913
	iwl_write32(priv, CSR_INT_MASK, 0x00000000);
Z
Zhu Yi 已提交
2914 2915 2916

	/* acknowledge/clear/reset any interrupts still pending
	 * from uCode or flow handler (Rx/Tx DMA) */
2917 2918
	iwl_write32(priv, CSR_INT, 0xffffffff);
	iwl_write32(priv, CSR_FH_INT_STATUS, 0xffffffff);
Z
Zhu Yi 已提交
2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944
	IWL_DEBUG_ISR("Disabled interrupts\n");
}

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

2945
static void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
2946 2947 2948 2949 2950 2951 2952 2953
{
	u32 i;
	u32 desc, time, count, base, data1;
	u32 blink1, blink2, ilink1, ilink2;
	int rc;

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

C
Christoph Hellwig 已提交
2954
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
2955
		IWL_ERR(priv, "Not valid error log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
2956 2957 2958
		return;
	}

2959
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
2960
	if (rc) {
2961
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
2962 2963 2964
		return;
	}

2965
	count = iwl_read_targ_mem(priv, base);
Z
Zhu Yi 已提交
2966 2967

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

2973
	IWL_ERR(priv, "Desc       Time       asrtPC  blink2 "
Z
Zhu Yi 已提交
2974 2975 2976 2977
		  "ilink1  nmiPC   Line\n");
	for (i = ERROR_START_OFFSET;
	     i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
	     i += ERROR_ELEM_SIZE) {
2978
		desc = iwl_read_targ_mem(priv, base + i);
Z
Zhu Yi 已提交
2979
		time =
2980
		    iwl_read_targ_mem(priv, base + i + 1 * sizeof(u32));
Z
Zhu Yi 已提交
2981
		blink1 =
2982
		    iwl_read_targ_mem(priv, base + i + 2 * sizeof(u32));
Z
Zhu Yi 已提交
2983
		blink2 =
2984
		    iwl_read_targ_mem(priv, base + i + 3 * sizeof(u32));
Z
Zhu Yi 已提交
2985
		ilink1 =
2986
		    iwl_read_targ_mem(priv, base + i + 4 * sizeof(u32));
Z
Zhu Yi 已提交
2987
		ilink2 =
2988
		    iwl_read_targ_mem(priv, base + i + 5 * sizeof(u32));
Z
Zhu Yi 已提交
2989
		data1 =
2990
		    iwl_read_targ_mem(priv, base + i + 6 * sizeof(u32));
Z
Zhu Yi 已提交
2991

2992 2993 2994 2995
		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 已提交
2996 2997
	}

2998
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
2999 3000 3001

}

3002
#define EVENT_START_OFFSET  (6 * sizeof(u32))
Z
Zhu Yi 已提交
3003 3004

/**
C
Christoph Hellwig 已提交
3005
 * iwl3945_print_event_log - Dump error event log to syslog
Z
Zhu Yi 已提交
3006
 *
3007
 * NOTE: Must be called with iwl_grab_nic_access() already obtained!
Z
Zhu Yi 已提交
3008
 */
3009
static void iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
Z
Zhu Yi 已提交
3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032
				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++) {
3033
		ev = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
3034
		ptr += sizeof(u32);
3035
		time = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
3036
		ptr += sizeof(u32);
3037 3038 3039 3040
		if (mode == 0) {
			/* data, ev */
			IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
		} else {
3041
			data = iwl_read_targ_mem(priv, ptr);
Z
Zhu Yi 已提交
3042
			ptr += sizeof(u32);
3043
			IWL_ERR(priv, "%010u\t0x%08x\t%04u\n", time, data, ev);
Z
Zhu Yi 已提交
3044 3045 3046 3047
		}
	}
}

3048
static void iwl3945_dump_nic_event_log(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3049 3050 3051 3052 3053 3054 3055 3056 3057 3058
{
	int rc;
	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 已提交
3059
	if (!iwl3945_hw_valid_rtc_data_addr(base)) {
3060
		IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
Z
Zhu Yi 已提交
3061 3062 3063
		return;
	}

3064
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
3065
	if (rc) {
3066
		IWL_WARN(priv, "Can not read from adapter at this time.\n");
Z
Zhu Yi 已提交
3067 3068 3069 3070
		return;
	}

	/* event log header */
3071 3072 3073 3074
	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 已提交
3075 3076 3077 3078 3079

	size = num_wraps ? capacity : next_entry;

	/* bail out if nothing in log */
	if (size == 0) {
3080
		IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
3081
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3082 3083 3084
		return;
	}

3085
	IWL_ERR(priv, "Start IWL Event Log Dump: display count %d, wraps %d\n",
Z
Zhu Yi 已提交
3086 3087 3088 3089 3090
		  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 已提交
3091
		iwl3945_print_event_log(priv, next_entry,
Z
Zhu Yi 已提交
3092 3093 3094
				    capacity - next_entry, mode);

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

3097
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3098 3099 3100
}

/**
C
Christoph Hellwig 已提交
3101
 * iwl3945_irq_handle_error - called for HW or SW error interrupt from card
Z
Zhu Yi 已提交
3102
 */
3103
static void iwl3945_irq_handle_error(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3104
{
C
Christoph Hellwig 已提交
3105
	/* Set the FW error flag -- cleared on iwl3945_down */
Z
Zhu Yi 已提交
3106 3107 3108 3109 3110
	set_bit(STATUS_FW_ERROR, &priv->status);

	/* Cancel currently queued command. */
	clear_bit(STATUS_HCMD_ACTIVE, &priv->status);

3111
#ifdef CONFIG_IWL3945_DEBUG
3112
	if (priv->debug_level & IWL_DL_FW_ERRORS) {
C
Christoph Hellwig 已提交
3113 3114
		iwl3945_dump_nic_error_log(priv);
		iwl3945_dump_nic_event_log(priv);
3115
		iwl3945_print_rx_config_cmd(priv, &priv->staging39_rxon);
Z
Zhu Yi 已提交
3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128
	}
#endif

	wake_up_interruptible(&priv->wait_command_queue);

	/* Keep the restart process from trying to send host
	 * commands by clearing the INIT status bit */
	clear_bit(STATUS_READY, &priv->status);

	if (!test_bit(STATUS_EXIT_PENDING, &priv->status)) {
		IWL_DEBUG(IWL_DL_INFO | IWL_DL_FW_ERRORS,
			  "Restarting adapter due to uCode error.\n");

C
Christoph Hellwig 已提交
3129
		if (iwl3945_is_associated(priv)) {
3130 3131
			memcpy(&priv->recovery39_rxon, &priv->active39_rxon,
			       sizeof(priv->recovery39_rxon));
Z
Zhu Yi 已提交
3132 3133 3134 3135 3136 3137
			priv->error_recovering = 1;
		}
		queue_work(priv->workqueue, &priv->restart);
	}
}

3138
static void iwl3945_error_recovery(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3139 3140 3141
{
	unsigned long flags;

3142 3143 3144
	memcpy(&priv->staging39_rxon, &priv->recovery39_rxon,
	       sizeof(priv->staging39_rxon));
	priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
3145
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
3146

C
Christoph Hellwig 已提交
3147
	iwl3945_add_station(priv, priv->bssid, 1, 0);
Z
Zhu Yi 已提交
3148 3149

	spin_lock_irqsave(&priv->lock, flags);
3150
	priv->assoc_id = le16_to_cpu(priv->staging39_rxon.assoc_id);
Z
Zhu Yi 已提交
3151 3152 3153 3154
	priv->error_recovering = 0;
	spin_unlock_irqrestore(&priv->lock, flags);
}

3155
static void iwl3945_irq_tasklet(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3156 3157 3158 3159
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
3160
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
3161 3162 3163 3164 3165 3166 3167 3168
	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. */
3169 3170
	inta = iwl_read32(priv, CSR_INT);
	iwl_write32(priv, CSR_INT, inta);
Z
Zhu Yi 已提交
3171 3172 3173 3174

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

3178
#ifdef CONFIG_IWL3945_DEBUG
3179
	if (priv->debug_level & IWL_DL_ISR) {
3180
		/* just for debug */
3181
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
Z
Zhu Yi 已提交
3182 3183 3184 3185 3186 3187 3188 3189 3190
		IWL_DEBUG_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
			      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 已提交
3191
	if (inta_fh & CSR39_FH_INT_RX_MASK)
Z
Zhu Yi 已提交
3192
		inta |= CSR_INT_BIT_FH_RX;
T
Tomas Winkler 已提交
3193
	if (inta_fh & CSR39_FH_INT_TX_MASK)
Z
Zhu Yi 已提交
3194 3195 3196 3197
		inta |= CSR_INT_BIT_FH_TX;

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

		/* Tell the device to stop sending interrupts */
C
Christoph Hellwig 已提交
3201
		iwl3945_disable_interrupts(priv);
Z
Zhu Yi 已提交
3202

C
Christoph Hellwig 已提交
3203
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
3204 3205 3206 3207 3208 3209 3210 3211

		handled |= CSR_INT_BIT_HW_ERR;

		spin_unlock_irqrestore(&priv->lock, flags);

		return;
	}

3212
#ifdef CONFIG_IWL3945_DEBUG
3213
	if (priv->debug_level & (IWL_DL_ISR)) {
Z
Zhu Yi 已提交
3214
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
3215 3216 3217
		if (inta & CSR_INT_BIT_SCD)
			IWL_DEBUG_ISR("Scheduler finished to transmit "
				      "the frame/frames.\n");
Z
Zhu Yi 已提交
3218 3219 3220 3221 3222 3223 3224

		/* Alive notification via Rx interrupt will do the real work */
		if (inta & CSR_INT_BIT_ALIVE)
			IWL_DEBUG_ISR("Alive interrupt\n");
	}
#endif
	/* Safely ignore these bits for debug checks below */
3225
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
Z
Zhu Yi 已提交
3226 3227 3228

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
3229 3230
		IWL_ERR(priv, "Microcode SW error detected. "
			"Restarting 0x%X.\n", inta);
C
Christoph Hellwig 已提交
3231
		iwl3945_irq_handle_error(priv);
Z
Zhu Yi 已提交
3232 3233 3234 3235 3236 3237
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/* uCode wakes up after power-down sleep */
	if (inta & CSR_INT_BIT_WAKEUP) {
		IWL_DEBUG_ISR("Wakeup interrupt\n");
3238
		iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
3239 3240 3241 3242 3243 3244
		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 已提交
3245 3246 3247 3248 3249 3250 3251 3252

		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 已提交
3253
		iwl3945_rx_handle(priv);
Z
Zhu Yi 已提交
3254 3255 3256 3257 3258 3259
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

	if (inta & CSR_INT_BIT_FH_TX) {
		IWL_DEBUG_ISR("Tx interrupt\n");

3260 3261 3262
		iwl_write32(priv, CSR_FH_INT_STATUS, (1 << 6));
		if (!iwl_grab_nic_access(priv)) {
			iwl_write_direct32(priv, FH39_TCSR_CREDIT
3263
					     (FH39_SRVC_CHNL), 0x0);
3264
			iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3265 3266 3267 3268 3269
		}
		handled |= CSR_INT_BIT_FH_TX;
	}

	if (inta & ~handled)
3270
		IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
Z
Zhu Yi 已提交
3271 3272

	if (inta & ~CSR_INI_SET_MASK) {
3273
		IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
Z
Zhu Yi 已提交
3274
			 inta & ~CSR_INI_SET_MASK);
3275
		IWL_WARN(priv, "   with FH_INT = 0x%08x\n", inta_fh);
Z
Zhu Yi 已提交
3276 3277 3278
	}

	/* Re-enable all interrupts */
3279 3280 3281
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
		iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
3282

3283
#ifdef CONFIG_IWL3945_DEBUG
3284
	if (priv->debug_level & (IWL_DL_ISR)) {
3285 3286 3287
		inta = iwl_read32(priv, CSR_INT);
		inta_mask = iwl_read32(priv, CSR_INT_MASK);
		inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
Z
Zhu Yi 已提交
3288 3289 3290 3291 3292 3293 3294
		IWL_DEBUG_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
			"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
	}
#endif
	spin_unlock_irqrestore(&priv->lock, flags);
}

C
Christoph Hellwig 已提交
3295
static irqreturn_t iwl3945_isr(int irq, void *data)
Z
Zhu Yi 已提交
3296
{
3297
	struct iwl_priv *priv = data;
Z
Zhu Yi 已提交
3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308
	u32 inta, inta_mask;
	u32 inta_fh;
	if (!priv)
		return IRQ_NONE;

	spin_lock(&priv->lock);

	/* Disable (but don't clear!) interrupts here to avoid
	 *    back-to-back ISRs and sporadic interrupts from our NIC.
	 * If we have something to service, the tasklet will re-enable ints.
	 * If we *don't* have something, we'll re-enable before leaving here. */
3309 3310
	inta_mask = iwl_read32(priv, CSR_INT_MASK);  /* just for debug */
	iwl_write32(priv, CSR_INT_MASK, 0x00000000);
Z
Zhu Yi 已提交
3311 3312

	/* Discover which interrupts are active/pending */
3313 3314
	inta = iwl_read32(priv, CSR_INT);
	inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
Z
Zhu Yi 已提交
3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325

	/* Ignore interrupt if there's nothing in NIC to service.
	 * This may be due to IRQ shared with another device,
	 * or due to sporadic interrupts thrown from our NIC. */
	if (!inta && !inta_fh) {
		IWL_DEBUG_ISR("Ignore interrupt, inta == 0, inta_fh == 0\n");
		goto none;
	}

	if ((inta == 0xFFFFFFFF) || ((inta & 0xFFFFFFF0) == 0xa5a5a5a0)) {
		/* Hardware disappeared */
3326
		IWL_WARN(priv, "HARDWARE GONE?? INTA == 0x%08x\n", inta);
3327
		goto unplugged;
Z
Zhu Yi 已提交
3328 3329 3330 3331 3332
	}

	IWL_DEBUG_ISR("ISR inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
		      inta, inta_mask, inta_fh);

3333 3334
	inta &= ~CSR_INT_BIT_SCD;

C
Christoph Hellwig 已提交
3335
	/* iwl3945_irq_tasklet() will service interrupts and re-enable them */
3336 3337
	if (likely(inta || inta_fh))
		tasklet_schedule(&priv->irq_tasklet);
3338
unplugged:
Z
Zhu Yi 已提交
3339 3340 3341 3342 3343 3344
	spin_unlock(&priv->lock);

	return IRQ_HANDLED;

 none:
	/* re-enable interrupts here since we don't have anything to service. */
3345 3346 3347
	/* only Re-enable if disabled by irq */
	if (test_bit(STATUS_INT_ENABLED, &priv->status))
		iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
3348 3349 3350 3351 3352 3353
	spin_unlock(&priv->lock);
	return IRQ_NONE;
}

/************************** EEPROM BANDS ****************************
 *
C
Christoph Hellwig 已提交
3354
 * The iwl3945_eeprom_band definitions below provide the mapping from the
Z
Zhu Yi 已提交
3355 3356 3357
 * EEPROM contents to the specific channel number supported for each
 * band.
 *
3358
 * For example, iwl3945_priv->eeprom39.band_3_channels[4] from the band_3
Z
Zhu Yi 已提交
3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383
 * definition below maps to physical channel 42 in the 5.2GHz spectrum.
 * The specific geography and calibration information for that channel
 * is contained in the eeprom map itself.
 *
 * During init, we copy the eeprom information and channel map
 * information into priv->channel_info_24/52 and priv->channel_map_24/52
 *
 * channel_map_24/52 provides the index in the channel_info array for a
 * given channel.  We have to have two separate maps as there is channel
 * overlap with the 2.4GHz and 5.2GHz spectrum as seen in band_1 and
 * band_2
 *
 * A value of 0xff stored in the channel_map indicates that the channel
 * is not supported by the hardware at all.
 *
 * A value of 0xfe in the channel_map indicates that the channel is not
 * valid for Tx with the current hardware.  This means that
 * while the system can tune and receive on a given channel, it may not
 * be able to associate or transmit any frames on that
 * channel.  There is no corresponding channel information for that
 * entry.
 *
 *********************************************************************/

/* 2.4 GHz */
C
Christoph Hellwig 已提交
3384
static const u8 iwl3945_eeprom_band_1[14] = {
Z
Zhu Yi 已提交
3385 3386 3387 3388
	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
};

/* 5.2 GHz bands */
3389
static const u8 iwl3945_eeprom_band_2[] = {	/* 4915-5080MHz */
Z
Zhu Yi 已提交
3390 3391 3392
	183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16
};

3393
static const u8 iwl3945_eeprom_band_3[] = {	/* 5170-5320MHz */
Z
Zhu Yi 已提交
3394 3395 3396
	34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
};

C
Christoph Hellwig 已提交
3397
static const u8 iwl3945_eeprom_band_4[] = {	/* 5500-5700MHz */
Z
Zhu Yi 已提交
3398 3399 3400
	100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
};

C
Christoph Hellwig 已提交
3401
static const u8 iwl3945_eeprom_band_5[] = {	/* 5725-5825MHz */
Z
Zhu Yi 已提交
3402 3403 3404
	145, 149, 153, 157, 161, 165
};

3405
static void iwl3945_init_band_reference(const struct iwl_priv *priv, int band,
Z
Zhu Yi 已提交
3406
				    int *eeprom_ch_count,
3407
				    const struct iwl_eeprom_channel
Z
Zhu Yi 已提交
3408 3409 3410 3411 3412
				    **eeprom_ch_info,
				    const u8 **eeprom_ch_index)
{
	switch (band) {
	case 1:		/* 2.4GHz band */
C
Christoph Hellwig 已提交
3413
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_1);
3414
		*eeprom_ch_info = priv->eeprom39.band_1_channels;
C
Christoph Hellwig 已提交
3415
		*eeprom_ch_index = iwl3945_eeprom_band_1;
Z
Zhu Yi 已提交
3416
		break;
3417
	case 2:		/* 4.9GHz band */
C
Christoph Hellwig 已提交
3418
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_2);
3419
		*eeprom_ch_info = priv->eeprom39.band_2_channels;
C
Christoph Hellwig 已提交
3420
		*eeprom_ch_index = iwl3945_eeprom_band_2;
Z
Zhu Yi 已提交
3421 3422
		break;
	case 3:		/* 5.2GHz band */
C
Christoph Hellwig 已提交
3423
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_3);
3424
		*eeprom_ch_info = priv->eeprom39.band_3_channels;
C
Christoph Hellwig 已提交
3425
		*eeprom_ch_index = iwl3945_eeprom_band_3;
Z
Zhu Yi 已提交
3426
		break;
3427
	case 4:		/* 5.5GHz band */
C
Christoph Hellwig 已提交
3428
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_4);
3429
		*eeprom_ch_info = priv->eeprom39.band_4_channels;
C
Christoph Hellwig 已提交
3430
		*eeprom_ch_index = iwl3945_eeprom_band_4;
Z
Zhu Yi 已提交
3431
		break;
3432
	case 5:		/* 5.7GHz band */
C
Christoph Hellwig 已提交
3433
		*eeprom_ch_count = ARRAY_SIZE(iwl3945_eeprom_band_5);
3434
		*eeprom_ch_info = priv->eeprom39.band_5_channels;
C
Christoph Hellwig 已提交
3435
		*eeprom_ch_index = iwl3945_eeprom_band_5;
Z
Zhu Yi 已提交
3436 3437 3438 3439 3440 3441 3442
		break;
	default:
		BUG();
		return;
	}
}

3443 3444 3445 3446 3447
/**
 * iwl3945_get_channel_info - Find driver's private channel info
 *
 * Based on band and channel number.
 */
3448
const struct iwl_channel_info *
3449
iwl3945_get_channel_info(const struct iwl_priv *priv,
3450
			 enum ieee80211_band band, u16 channel)
Z
Zhu Yi 已提交
3451 3452 3453
{
	int i;

3454 3455
	switch (band) {
	case IEEE80211_BAND_5GHZ:
Z
Zhu Yi 已提交
3456 3457 3458 3459 3460 3461
		for (i = 14; i < priv->channel_count; i++) {
			if (priv->channel_info[i].channel == channel)
				return &priv->channel_info[i];
		}
		break;

3462
	case IEEE80211_BAND_2GHZ:
Z
Zhu Yi 已提交
3463 3464 3465
		if (channel >= 1 && channel <= 14)
			return &priv->channel_info[channel - 1];
		break;
3466 3467
	case IEEE80211_NUM_BANDS:
		WARN_ON(1);
Z
Zhu Yi 已提交
3468 3469 3470 3471 3472 3473 3474 3475
	}

	return NULL;
}

#define CHECK_AND_PRINT(x) ((eeprom_ch_info[ch].flags & EEPROM_CHANNEL_##x) \
			    ? # x " " : "")

3476 3477 3478
/**
 * iwl3945_init_channel_map - Set up driver's info for all possible channels
 */
3479
static int iwl3945_init_channel_map(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3480 3481 3482
{
	int eeprom_ch_count = 0;
	const u8 *eeprom_ch_index = NULL;
3483
	const struct iwl_eeprom_channel *eeprom_ch_info = NULL;
Z
Zhu Yi 已提交
3484
	int band, ch;
3485
	struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
3486 3487 3488 3489 3490 3491

	if (priv->channel_count) {
		IWL_DEBUG_INFO("Channel map already initialized.\n");
		return 0;
	}

3492
	if (priv->eeprom39.version < 0x2f) {
3493
		IWL_WARN(priv, "Unsupported EEPROM version: 0x%04X\n",
3494
			    priv->eeprom39.version);
Z
Zhu Yi 已提交
3495 3496 3497 3498 3499 3500
		return -EINVAL;
	}

	IWL_DEBUG_INFO("Initializing regulatory info from EEPROM\n");

	priv->channel_count =
C
Christoph Hellwig 已提交
3501 3502 3503 3504 3505
	    ARRAY_SIZE(iwl3945_eeprom_band_1) +
	    ARRAY_SIZE(iwl3945_eeprom_band_2) +
	    ARRAY_SIZE(iwl3945_eeprom_band_3) +
	    ARRAY_SIZE(iwl3945_eeprom_band_4) +
	    ARRAY_SIZE(iwl3945_eeprom_band_5);
Z
Zhu Yi 已提交
3506 3507 3508

	IWL_DEBUG_INFO("Parsing data for %d channels.\n", priv->channel_count);

3509
	priv->channel_info = kzalloc(sizeof(struct iwl_channel_info) *
Z
Zhu Yi 已提交
3510 3511
				     priv->channel_count, GFP_KERNEL);
	if (!priv->channel_info) {
3512
		IWL_ERR(priv, "Could not allocate channel_info\n");
Z
Zhu Yi 已提交
3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523
		priv->channel_count = 0;
		return -ENOMEM;
	}

	ch_info = priv->channel_info;

	/* Loop through the 5 EEPROM bands adding them in order to the
	 * channel map we maintain (that contains additional information than
	 * what just in the EEPROM) */
	for (band = 1; band <= 5; band++) {

C
Christoph Hellwig 已提交
3524
		iwl3945_init_band_reference(priv, band, &eeprom_ch_count,
Z
Zhu Yi 已提交
3525 3526 3527 3528 3529
					&eeprom_ch_info, &eeprom_ch_index);

		/* Loop through each band adding each of the channels */
		for (ch = 0; ch < eeprom_ch_count; ch++) {
			ch_info->channel = eeprom_ch_index[ch];
3530 3531
			ch_info->band = (band == 1) ? IEEE80211_BAND_2GHZ :
			    IEEE80211_BAND_5GHZ;
Z
Zhu Yi 已提交
3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557

			/* permanently store EEPROM's channel regulatory flags
			 *   and max power in channel info database. */
			ch_info->eeprom = eeprom_ch_info[ch];

			/* Copy the run-time flags so they are there even on
			 * invalid channels */
			ch_info->flags = eeprom_ch_info[ch].flags;

			if (!(is_channel_valid(ch_info))) {
				IWL_DEBUG_INFO("Ch. %d Flags %x [%sGHz] - "
					       "No traffic\n",
					       ch_info->channel,
					       ch_info->flags,
					       is_channel_a_band(ch_info) ?
					       "5.2" : "2.4");
				ch_info++;
				continue;
			}

			/* Initialize regulatory-based run-time data */
			ch_info->max_power_avg = ch_info->curr_txpow =
			    eeprom_ch_info[ch].max_power_avg;
			ch_info->scan_power = eeprom_ch_info[ch].max_power_avg;
			ch_info->min_power = 0;

3558
			IWL_DEBUG_INFO("Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x"
Z
Zhu Yi 已提交
3559 3560 3561 3562
				       " %ddBm): Ad-Hoc %ssupported\n",
				       ch_info->channel,
				       is_channel_a_band(ch_info) ?
				       "5.2" : "2.4",
3563
				       CHECK_AND_PRINT(VALID),
Z
Zhu Yi 已提交
3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576
				       CHECK_AND_PRINT(IBSS),
				       CHECK_AND_PRINT(ACTIVE),
				       CHECK_AND_PRINT(RADAR),
				       CHECK_AND_PRINT(WIDE),
				       CHECK_AND_PRINT(DFS),
				       eeprom_ch_info[ch].flags,
				       eeprom_ch_info[ch].max_power_avg,
				       ((eeprom_ch_info[ch].
					 flags & EEPROM_CHANNEL_IBSS)
					&& !(eeprom_ch_info[ch].
					     flags & EEPROM_CHANNEL_RADAR))
				       ? "" : "not ");

3577
			/* Set the tx_power_user_lmt to the highest power
Z
Zhu Yi 已提交
3578 3579
			 * supported by any channel */
			if (eeprom_ch_info[ch].max_power_avg >
3580 3581
			    priv->tx_power_user_lmt)
				priv->tx_power_user_lmt =
Z
Zhu Yi 已提交
3582 3583 3584 3585 3586 3587
				    eeprom_ch_info[ch].max_power_avg;

			ch_info++;
		}
	}

3588
	/* Set up txpower settings in driver for all channels */
Z
Zhu Yi 已提交
3589 3590 3591 3592 3593 3594
	if (iwl3945_txpower_set_from_eeprom(priv))
		return -EIO;

	return 0;
}

3595 3596 3597
/*
 * iwl3945_free_channel_map - undo allocations in iwl3945_init_channel_map
 */
3598
static void iwl3945_free_channel_map(struct iwl_priv *priv)
3599 3600 3601 3602 3603
{
	kfree(priv->channel_info);
	priv->channel_count = 0;
}

3604
static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
3605
					 enum ieee80211_band band,
3606
				     u8 is_active, u8 n_probes,
C
Christoph Hellwig 已提交
3607
				     struct iwl3945_scan_channel *scan_ch)
Z
Zhu Yi 已提交
3608 3609
{
	const struct ieee80211_channel *channels = NULL;
3610
	const struct ieee80211_supported_band *sband;
3611
	const struct iwl_channel_info *ch_info;
Z
Zhu Yi 已提交
3612 3613 3614 3615
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;

K
Kolekar, Abhijeet 已提交
3616
	sband = iwl_get_hw_mode(priv, band);
3617
	if (!sband)
Z
Zhu Yi 已提交
3618 3619
		return 0;

3620
	channels = sband->channels;
Z
Zhu Yi 已提交
3621

S
Samuel Ortiz 已提交
3622 3623
	active_dwell = iwl_get_active_dwell_time(priv, band, n_probes);
	passive_dwell = iwl_get_passive_dwell_time(priv, band);
Z
Zhu Yi 已提交
3624

3625 3626 3627
	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

3628
	for (i = 0, added = 0; i < sband->n_channels; i++) {
3629 3630 3631
		if (channels[i].flags & IEEE80211_CHAN_DISABLED)
			continue;

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

3634
		ch_info = iwl3945_get_channel_info(priv, band, scan_ch->channel);
Z
Zhu Yi 已提交
3635
		if (!is_channel_valid(ch_info)) {
3636
			IWL_DEBUG_SCAN("Channel %d is INVALID for this band.\n",
Z
Zhu Yi 已提交
3637 3638 3639 3640
				       scan_ch->channel);
			continue;
		}

3641 3642 3643 3644 3645
		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 已提交
3646
		if (!is_active || is_channel_passive(ch_info) ||
3647
		    (channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN)) {
Z
Zhu Yi 已提交
3648
			scan_ch->type = 0;	/* passive */
3649 3650 3651
			if (IWL_UCODE_API(priv->ucode_ver) == 1)
				scan_ch->active_dwell = cpu_to_le16(passive_dwell - 1);
		} else {
Z
Zhu Yi 已提交
3652
			scan_ch->type = 1;	/* active */
3653
		}
Z
Zhu Yi 已提交
3654

3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667
		/* 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)
				scan_ch->type |= IWL_SCAN_PROBE_MASK(n_probes);
		} else {
			/* uCode v1 does not allow setting direct probe bits on
			 * passive channel. */
			if ((scan_ch->type & 1) && n_probes)
				scan_ch->type |= IWL_SCAN_PROBE_MASK(n_probes);
		}
Z
Zhu Yi 已提交
3668

3669
		/* Set txpower levels to defaults */
Z
Zhu Yi 已提交
3670 3671 3672 3673
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */

		/*scan_pwr_info->tpc.tx_gain; */
3674
		if (band == IEEE80211_BAND_5GHZ)
Z
Zhu Yi 已提交
3675 3676 3677 3678
			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
3679
			 * power level:
3680
			 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
Z
Zhu Yi 已提交
3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697
			 */
		}

		IWL_DEBUG_SCAN("Scanning %d [%s %d]\n",
			       scan_ch->channel,
			       (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
			       (scan_ch->type & 1) ?
			       active_dwell : passive_dwell);

		scan_ch++;
		added++;
	}

	IWL_DEBUG_SCAN("total channels to scan %d \n", added);
	return added;
}

3698
static void iwl3945_init_hw_rates(struct iwl_priv *priv,
Z
Zhu Yi 已提交
3699 3700 3701 3702 3703
			      struct ieee80211_rate *rates)
{
	int i;

	for (i = 0; i < IWL_RATE_COUNT; i++) {
3704 3705 3706 3707
		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;
3708
		if ((i > IWL39_LAST_OFDM_RATE) || (i < IWL_FIRST_OFDM_RATE)) {
Z
Zhu Yi 已提交
3709
			/*
3710
			 * If CCK != 1M then set short preamble rate flag.
Z
Zhu Yi 已提交
3711
			 */
C
Christoph Hellwig 已提交
3712
			rates[i].flags |= (iwl3945_rates[i].plcp == 10) ?
3713
				0 : IEEE80211_RATE_SHORT_PREAMBLE;
Z
Zhu Yi 已提交
3714 3715 3716 3717 3718
		}
	}
}

/**
C
Christoph Hellwig 已提交
3719
 * iwl3945_init_geos - Initialize mac80211's geo/channel info based from eeprom
Z
Zhu Yi 已提交
3720
 */
3721
static int iwl3945_init_geos(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3722
{
3723
	struct iwl_channel_info *ch;
3724
	struct ieee80211_supported_band *sband;
Z
Zhu Yi 已提交
3725 3726 3727 3728 3729
	struct ieee80211_channel *channels;
	struct ieee80211_channel *geo_ch;
	struct ieee80211_rate *rates;
	int i = 0;

3730 3731
	if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
	    priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
Z
Zhu Yi 已提交
3732 3733 3734 3735 3736 3737 3738
		IWL_DEBUG_INFO("Geography modes already initialized.\n");
		set_bit(STATUS_GEO_CONFIGURED, &priv->status);
		return 0;
	}

	channels = kzalloc(sizeof(struct ieee80211_channel) *
			   priv->channel_count, GFP_KERNEL);
3739
	if (!channels)
Z
Zhu Yi 已提交
3740 3741
		return -ENOMEM;

3742
	rates = kzalloc((sizeof(struct ieee80211_rate) * (IWL_RATE_COUNT + 1)),
Z
Zhu Yi 已提交
3743 3744 3745 3746 3747 3748 3749
			GFP_KERNEL);
	if (!rates) {
		kfree(channels);
		return -ENOMEM;
	}

	/* 5.2GHz channels start after the 2.4GHz channels */
3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760
	sband = &priv->bands[IEEE80211_BAND_5GHZ];
	sband->channels = &channels[ARRAY_SIZE(iwl3945_eeprom_band_1)];
	/* just OFDM */
	sband->bitrates = &rates[IWL_FIRST_OFDM_RATE];
	sband->n_bitrates = IWL_RATE_COUNT - IWL_FIRST_OFDM_RATE;

	sband = &priv->bands[IEEE80211_BAND_2GHZ];
	sband->channels = channels;
	/* OFDM & CCK */
	sband->bitrates = rates;
	sband->n_bitrates = IWL_RATE_COUNT;
Z
Zhu Yi 已提交
3761 3762 3763 3764

	priv->ieee_channels = channels;
	priv->ieee_rates = rates;

C
Christoph Hellwig 已提交
3765
	iwl3945_init_hw_rates(priv, rates);
Z
Zhu Yi 已提交
3766

3767
	for (i = 0;  i < priv->channel_count; i++) {
Z
Zhu Yi 已提交
3768 3769
		ch = &priv->channel_info[i];

3770 3771
		/* FIXME: might be removed if scan is OK*/
		if (!is_channel_valid(ch))
Z
Zhu Yi 已提交
3772 3773 3774
			continue;

		if (is_channel_a_band(ch))
3775
			sband =  &priv->bands[IEEE80211_BAND_5GHZ];
3776
		else
3777
			sband =  &priv->bands[IEEE80211_BAND_2GHZ];
Z
Zhu Yi 已提交
3778

3779 3780 3781
		geo_ch = &sband->channels[sband->n_channels++];

		geo_ch->center_freq = ieee80211_channel_to_frequency(ch->channel);
3782 3783
		geo_ch->max_power = ch->max_power_avg;
		geo_ch->max_antenna_gain = 0xff;
3784
		geo_ch->hw_value = ch->channel;
Z
Zhu Yi 已提交
3785 3786

		if (is_channel_valid(ch)) {
3787 3788
			if (!(ch->flags & EEPROM_CHANNEL_IBSS))
				geo_ch->flags |= IEEE80211_CHAN_NO_IBSS;
Z
Zhu Yi 已提交
3789

3790 3791
			if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
				geo_ch->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
Z
Zhu Yi 已提交
3792 3793

			if (ch->flags & EEPROM_CHANNEL_RADAR)
3794
				geo_ch->flags |= IEEE80211_CHAN_RADAR;
Z
Zhu Yi 已提交
3795

3796 3797
			if (ch->max_power_avg > priv->tx_power_channel_lmt)
				priv->tx_power_channel_lmt =
Z
Zhu Yi 已提交
3798
				    ch->max_power_avg;
3799
		} else {
3800
			geo_ch->flags |= IEEE80211_CHAN_DISABLED;
3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811
		}

		/* Save flags for reg domain usage */
		geo_ch->orig_flags = geo_ch->flags;

		IWL_DEBUG_INFO("Channel %d Freq=%d[%sGHz] %s flag=0%X\n",
				ch->channel, geo_ch->center_freq,
				is_channel_a_band(ch) ?  "5.2" : "2.4",
				geo_ch->flags & IEEE80211_CHAN_DISABLED ?
				"restricted" : "valid",
				 geo_ch->flags);
Z
Zhu Yi 已提交
3812 3813
	}

T
Tomas Winkler 已提交
3814 3815
	if ((priv->bands[IEEE80211_BAND_5GHZ].n_channels == 0) &&
	     priv->cfg->sku & IWL_SKU_A) {
T
Tomas Winkler 已提交
3816 3817 3818
		IWL_INFO(priv, "Incorrectly detected BG card as ABG. "
			"Please send your PCI ID 0x%04X:0x%04X to maintainer.\n",
			priv->pci_dev->device, priv->pci_dev->subsystem_device);
T
Tomas Winkler 已提交
3819
		 priv->cfg->sku &= ~IWL_SKU_A;
Z
Zhu Yi 已提交
3820 3821
	}

T
Tomas Winkler 已提交
3822
	IWL_INFO(priv, "Tunable channels: %d 802.11bg, %d 802.11a channels\n",
3823 3824
	       priv->bands[IEEE80211_BAND_2GHZ].n_channels,
	       priv->bands[IEEE80211_BAND_5GHZ].n_channels);
Z
Zhu Yi 已提交
3825

3826 3827 3828 3829 3830 3831
	if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
			&priv->bands[IEEE80211_BAND_2GHZ];
	if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
		priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
			&priv->bands[IEEE80211_BAND_5GHZ];
Z
Zhu Yi 已提交
3832 3833 3834 3835 3836 3837

	set_bit(STATUS_GEO_CONFIGURED, &priv->status);

	return 0;
}

3838 3839 3840
/*
 * iwl3945_free_geos - undo allocations in iwl3945_init_geos
 */
3841
static void iwl3945_free_geos(struct iwl_priv *priv)
3842 3843 3844 3845 3846 3847
{
	kfree(priv->ieee_channels);
	kfree(priv->ieee_rates);
	clear_bit(STATUS_GEO_CONFIGURED, &priv->status);
}

Z
Zhu Yi 已提交
3848 3849 3850 3851 3852 3853
/******************************************************************************
 *
 * uCode download functions
 *
 ******************************************************************************/

3854
static void iwl3945_dealloc_ucode_pci(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3855
{
3856 3857 3858 3859 3860 3861
	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 已提交
3862 3863 3864
}

/**
C
Christoph Hellwig 已提交
3865
 * iwl3945_verify_inst_full - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
3866 3867
 *     looking at all data.
 */
3868
static int iwl3945_verify_inst_full(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
3869 3870 3871 3872 3873 3874 3875 3876
{
	u32 val;
	u32 save_len = len;
	int rc = 0;
	u32 errcnt;

	IWL_DEBUG_INFO("ucode inst image size is %u\n", len);

3877
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
3878 3879 3880
	if (rc)
		return rc;

3881
	iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
3882
			       IWL39_RTC_INST_LOWER_BOUND);
Z
Zhu Yi 已提交
3883 3884 3885 3886 3887 3888

	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 */
3889
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
3890
		if (val != le32_to_cpu(*image)) {
3891
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
3892 3893 3894 3895 3896 3897 3898 3899 3900
				  "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;
		}
	}

3901
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3902 3903

	if (!errcnt)
3904
		IWL_DEBUG_INFO("ucode image in INSTRUCTION memory is good\n");
Z
Zhu Yi 已提交
3905 3906 3907 3908 3909 3910

	return rc;
}


/**
C
Christoph Hellwig 已提交
3911
 * iwl3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
Z
Zhu Yi 已提交
3912 3913 3914
 *   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.
 */
3915
static int iwl3945_verify_inst_sparse(struct iwl_priv *priv, __le32 *image, u32 len)
Z
Zhu Yi 已提交
3916 3917 3918 3919 3920 3921 3922 3923
{
	u32 val;
	int rc = 0;
	u32 errcnt = 0;
	u32 i;

	IWL_DEBUG_INFO("ucode inst image size is %u\n", len);

3924
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
3925 3926 3927 3928 3929 3930 3931
	if (rc)
		return rc;

	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 */
3932
		iwl_write_direct32(priv, HBUS_TARG_MEM_RADDR,
3933
			i + IWL39_RTC_INST_LOWER_BOUND);
3934
		val = _iwl_read_direct32(priv, HBUS_TARG_MEM_RDAT);
Z
Zhu Yi 已提交
3935 3936
		if (val != le32_to_cpu(*image)) {
#if 0 /* Enable this if you want to see details */
3937
			IWL_ERR(priv, "uCode INST section is invalid at "
Z
Zhu Yi 已提交
3938 3939 3940 3941 3942 3943 3944 3945 3946 3947
				  "offset 0x%x, is 0x%x, s/b 0x%x\n",
				  i, val, *image);
#endif
			rc = -EIO;
			errcnt++;
			if (errcnt >= 3)
				break;
		}
	}

3948
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
3949 3950 3951 3952 3953 3954

	return rc;
}


/**
C
Christoph Hellwig 已提交
3955
 * iwl3945_verify_ucode - determine which instruction image is in SRAM,
Z
Zhu Yi 已提交
3956 3957
 *    and verify its contents
 */
3958
static int iwl3945_verify_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
3959 3960 3961 3962 3963 3964 3965 3966
{
	__le32 *image;
	u32 len;
	int rc = 0;

	/* Try bootstrap */
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
3967
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
3968 3969 3970 3971 3972 3973 3974 3975
	if (rc == 0) {
		IWL_DEBUG_INFO("Bootstrap uCode is good in inst SRAM\n");
		return 0;
	}

	/* Try initialize */
	image = (__le32 *)priv->ucode_init.v_addr;
	len = priv->ucode_init.len;
C
Christoph Hellwig 已提交
3976
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
3977 3978 3979 3980 3981 3982 3983 3984
	if (rc == 0) {
		IWL_DEBUG_INFO("Initialize uCode is good in inst SRAM\n");
		return 0;
	}

	/* Try runtime/protocol */
	image = (__le32 *)priv->ucode_code.v_addr;
	len = priv->ucode_code.len;
C
Christoph Hellwig 已提交
3985
	rc = iwl3945_verify_inst_sparse(priv, image, len);
Z
Zhu Yi 已提交
3986 3987 3988 3989 3990
	if (rc == 0) {
		IWL_DEBUG_INFO("Runtime uCode is good in inst SRAM\n");
		return 0;
	}

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

3993 3994 3995
	/* 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 已提交
3996 3997
	image = (__le32 *)priv->ucode_boot.v_addr;
	len = priv->ucode_boot.len;
C
Christoph Hellwig 已提交
3998
	rc = iwl3945_verify_inst_full(priv, image, len);
Z
Zhu Yi 已提交
3999 4000 4001 4002

	return rc;
}

4003
static void iwl3945_nic_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4004 4005
{
	/* Remove all resets to allow NIC to operate */
4006
	iwl_write32(priv, CSR_RESET, 0);
Z
Zhu Yi 已提交
4007 4008 4009
}

/**
C
Christoph Hellwig 已提交
4010
 * iwl3945_read_ucode - Read uCode images from disk file.
Z
Zhu Yi 已提交
4011 4012 4013
 *
 * Copy into buffers for card to fetch via bus-mastering
 */
4014
static int iwl3945_read_ucode(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4015
{
4016
	struct iwl_ucode *ucode;
4017
	int ret = -EINVAL, index;
Z
Zhu Yi 已提交
4018 4019
	const struct firmware *ucode_raw;
	/* firmware file name contains uCode/driver compatibility version */
4020 4021 4022 4023
	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 已提交
4024 4025
	u8 *src;
	size_t len;
4026
	u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
Z
Zhu Yi 已提交
4027 4028 4029

	/* Ask kernel firmware_class module to get the boot firmware off disk.
	 * request_firmware() is synchronous, file is in memory on return. */
4030 4031 4032 4033
	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) {
4034
			IWL_ERR(priv, "%s firmware file req failed: %d\n",
4035 4036 4037 4038 4039 4040 4041
				  buf, ret);
			if (ret == -ENOENT)
				continue;
			else
				goto error;
		} else {
			if (index < api_max)
4042 4043 4044
				IWL_ERR(priv, "Loaded firmware %s, "
					"which is deprecated. "
					" Please use API v%u instead.\n",
4045 4046 4047 4048 4049
					  buf, api_max);
			IWL_DEBUG_INFO("Got firmware '%s' file (%zd bytes) from disk\n",
				       buf, ucode_raw->size);
			break;
		}
Z
Zhu Yi 已提交
4050 4051
	}

4052 4053
	if (ret < 0)
		goto error;
Z
Zhu Yi 已提交
4054 4055 4056

	/* Make sure that we got at least our header! */
	if (ucode_raw->size < sizeof(*ucode)) {
4057
		IWL_ERR(priv, "File size way too small!\n");
4058
		ret = -EINVAL;
Z
Zhu Yi 已提交
4059 4060 4061 4062 4063 4064
		goto err_release;
	}

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

4065
	priv->ucode_ver = le32_to_cpu(ucode->ver);
4066
	api_ver = IWL_UCODE_API(priv->ucode_ver);
Z
Zhu Yi 已提交
4067 4068 4069 4070 4071 4072
	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);

4073 4074 4075 4076 4077
	/* api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
	 * on the API version read from firware header from here on forward */

	if (api_ver < api_min || api_ver > api_max) {
4078
		IWL_ERR(priv, "Driver unable to support your firmware API. "
4079 4080 4081 4082 4083 4084 4085
			  "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)
4086
		IWL_ERR(priv, "Firmware has old API version. Expected %u, "
4087 4088 4089 4090
			  "got %u. New firmware can be obtained "
			  "from http://www.intellinuxwireless.org.\n",
			  api_max, api_ver);

T
Tomas Winkler 已提交
4091 4092 4093 4094 4095 4096
	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));

4097 4098
	IWL_DEBUG_INFO("f/w package hdr ucode version raw = 0x%x\n",
		       priv->ucode_ver);
4099 4100 4101 4102 4103
	IWL_DEBUG_INFO("f/w package hdr runtime inst size = %u\n", inst_size);
	IWL_DEBUG_INFO("f/w package hdr runtime data size = %u\n", data_size);
	IWL_DEBUG_INFO("f/w package hdr init inst size = %u\n", init_size);
	IWL_DEBUG_INFO("f/w package hdr init data size = %u\n", init_data_size);
	IWL_DEBUG_INFO("f/w package hdr boot inst size = %u\n", boot_size);
Z
Zhu Yi 已提交
4104

4105

Z
Zhu Yi 已提交
4106 4107 4108 4109 4110 4111 4112
	/* 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) {

		IWL_DEBUG_INFO("uCode file size %d too small\n",
			       (int)ucode_raw->size);
4113
		ret = -EINVAL;
Z
Zhu Yi 已提交
4114 4115 4116 4117
		goto err_release;
	}

	/* Verify that uCode images will fit in card's SRAM */
4118
	if (inst_size > IWL39_MAX_INST_SIZE) {
4119 4120 4121
		IWL_DEBUG_INFO("uCode instr len %d too large to fit in\n",
			       inst_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4122 4123 4124
		goto err_release;
	}

4125
	if (data_size > IWL39_MAX_DATA_SIZE) {
4126 4127 4128
		IWL_DEBUG_INFO("uCode data len %d too large to fit in\n",
			       data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4129 4130
		goto err_release;
	}
4131
	if (init_size > IWL39_MAX_INST_SIZE) {
4132 4133 4134
		IWL_DEBUG_INFO("uCode init instr len %d too large to fit in\n",
				init_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4135 4136
		goto err_release;
	}
4137
	if (init_data_size > IWL39_MAX_DATA_SIZE) {
4138 4139 4140
		IWL_DEBUG_INFO("uCode init data len %d too large to fit in\n",
				init_data_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4141 4142
		goto err_release;
	}
4143
	if (boot_size > IWL39_MAX_BSM_SIZE) {
4144 4145 4146
		IWL_DEBUG_INFO("uCode boot instr len %d too large to fit in\n",
				boot_size);
		ret = -EINVAL;
Z
Zhu Yi 已提交
4147 4148 4149 4150 4151 4152 4153 4154 4155
		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;
4156
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
Z
Zhu Yi 已提交
4157 4158

	priv->ucode_data.len = data_size;
4159
	iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
Z
Zhu Yi 已提交
4160 4161

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

4164 4165 4166
	if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
	    !priv->ucode_data_backup.v_addr)
		goto err_pci_alloc;
Z
Zhu Yi 已提交
4167 4168

	/* Initialization instructions and data */
4169 4170
	if (init_size && init_data_size) {
		priv->ucode_init.len = init_size;
4171
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
4172 4173

		priv->ucode_init_data.len = init_data_size;
4174
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
4175 4176 4177 4178

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

	/* Bootstrap (instructions only, no data) */
4181 4182
	if (boot_size) {
		priv->ucode_boot.len = boot_size;
4183
		iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
Z
Zhu Yi 已提交
4184

4185 4186 4187
		if (!priv->ucode_boot.v_addr)
			goto err_pci_alloc;
	}
Z
Zhu Yi 已提交
4188 4189 4190 4191 4192 4193

	/* 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;
4194
	IWL_DEBUG_INFO("Copying (but not loading) uCode instr len %Zd\n", len);
Z
Zhu Yi 已提交
4195 4196 4197 4198 4199
	memcpy(priv->ucode_code.v_addr, src, len);
	IWL_DEBUG_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
		priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);

	/* Runtime data (2nd block)
C
Christoph Hellwig 已提交
4200
	 * NOTE:  Copy into backup buffer will be done in iwl3945_up()  */
Z
Zhu Yi 已提交
4201 4202
	src = &ucode->data[inst_size];
	len = priv->ucode_data.len;
4203
	IWL_DEBUG_INFO("Copying (but not loading) uCode data len %Zd\n", len);
Z
Zhu Yi 已提交
4204 4205 4206 4207 4208 4209 4210
	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;
4211 4212
		IWL_DEBUG_INFO("Copying (but not loading) init instr len %Zd\n",
			       len);
Z
Zhu Yi 已提交
4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236
		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;
		IWL_DEBUG_INFO("Copying (but not loading) init data len %d\n",
			       (int)len);
		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;
	IWL_DEBUG_INFO("Copying (but not loading) boot instr len %d\n",
		       (int)len);
	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:
4237
	IWL_ERR(priv, "failed to allocate pci memory\n");
4238
	ret = -ENOMEM;
C
Christoph Hellwig 已提交
4239
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
4240 4241 4242 4243 4244

 err_release:
	release_firmware(ucode_raw);

 error:
4245
	return ret;
Z
Zhu Yi 已提交
4246 4247 4248 4249
}


/**
C
Christoph Hellwig 已提交
4250
 * iwl3945_set_ucode_ptrs - Set uCode address location
Z
Zhu Yi 已提交
4251 4252 4253 4254 4255 4256 4257
 *
 * 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.
 */
4258
static int iwl3945_set_ucode_ptrs(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269
{
	dma_addr_t pinst;
	dma_addr_t pdata;
	int rc = 0;
	unsigned long flags;

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

	spin_lock_irqsave(&priv->lock, flags);
4270
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
4271 4272 4273 4274 4275 4276
	if (rc) {
		spin_unlock_irqrestore(&priv->lock, flags);
		return rc;
	}

	/* Tell bootstrap uCode where to find image to load */
4277 4278 4279
	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 已提交
4280 4281
				 priv->ucode_data.len);

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

4287
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
4288 4289 4290 4291 4292 4293 4294 4295 4296

	spin_unlock_irqrestore(&priv->lock, flags);

	IWL_DEBUG_INFO("Runtime uCode pointers are set.\n");

	return rc;
}

/**
C
Christoph Hellwig 已提交
4297
 * iwl3945_init_alive_start - Called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
4298 4299 4300 4301
 *
 * Called after REPLY_ALIVE notification received from "initialize" uCode.
 *
 * Tell "initialize" uCode to go ahead and load the runtime uCode.
4302
 */
4303
static void iwl3945_init_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315
{
	/* 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 */
		IWL_DEBUG_INFO("Initialize Alive failed.\n");
		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 已提交
4316
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
4317 4318 4319 4320 4321 4322 4323 4324 4325 4326
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
		IWL_DEBUG_INFO("Bad \"initialize\" uCode load.\n");
		goto restart;
	}

	/* Send pointers to protocol/runtime uCode image ... init code will
	 * load and launch runtime uCode, which will send us another "Alive"
	 * notification. */
	IWL_DEBUG_INFO("Initialization Alive received.\n");
C
Christoph Hellwig 已提交
4327
	if (iwl3945_set_ucode_ptrs(priv)) {
Z
Zhu Yi 已提交
4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339
		/* Runtime instruction load won't happen;
		 * take it all the way back down so we can try again */
		IWL_DEBUG_INFO("Couldn't set up uCode pointers.\n");
		goto restart;
	}
	return;

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


4340 4341 4342 4343
/* temporary */
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw,
				     struct sk_buff *skb);

Z
Zhu Yi 已提交
4344
/**
C
Christoph Hellwig 已提交
4345
 * iwl3945_alive_start - called after REPLY_ALIVE notification received
Z
Zhu Yi 已提交
4346
 *                   from protocol/runtime uCode (initialization uCode's
C
Christoph Hellwig 已提交
4347
 *                   Alive gets handled by iwl3945_init_alive_start()).
Z
Zhu Yi 已提交
4348
 */
4349
static void iwl3945_alive_start(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366
{
	int rc = 0;
	int thermal_spin = 0;
	u32 rfkill;

	IWL_DEBUG_INFO("Runtime Alive received.\n");

	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 */
		IWL_DEBUG_INFO("Alive failed.\n");
		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 已提交
4367
	if (iwl3945_verify_ucode(priv)) {
Z
Zhu Yi 已提交
4368 4369 4370 4371 4372 4373
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
		IWL_DEBUG_INFO("Bad runtime uCode load.\n");
		goto restart;
	}

C
Christoph Hellwig 已提交
4374
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
4375

4376
	rc = iwl_grab_nic_access(priv);
Z
Zhu Yi 已提交
4377
	if (rc) {
4378
		IWL_WARN(priv, "Can not read RFKILL status from adapter\n");
Z
Zhu Yi 已提交
4379 4380 4381
		return;
	}

4382
	rfkill = iwl_read_prph(priv, APMG_RFKILL_REG);
Z
Zhu Yi 已提交
4383
	IWL_DEBUG_INFO("RFKILL status: 0x%x\n", rfkill);
4384
	iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
4385 4386 4387

	if (rfkill & 0x1) {
		clear_bit(STATUS_RF_KILL_HW, &priv->status);
T
Tomas Winkler 已提交
4388
		/* if RFKILL is not on, then wait for thermal
Z
Zhu Yi 已提交
4389
		 * sensor in adapter to kick in */
C
Christoph Hellwig 已提交
4390
		while (iwl3945_hw_get_temperature(priv) == 0) {
Z
Zhu Yi 已提交
4391 4392 4393 4394 4395 4396 4397 4398 4399 4400
			thermal_spin++;
			udelay(10);
		}

		if (thermal_spin)
			IWL_DEBUG_INFO("Thermal calibration took %dus\n",
				       thermal_spin * 10);
	} else
		set_bit(STATUS_RF_KILL_HW, &priv->status);

4401
	/* After the ALIVE response, we can send commands to 3945 uCode */
Z
Zhu Yi 已提交
4402 4403 4404 4405 4406
	set_bit(STATUS_ALIVE, &priv->status);

	/* Clear out the uCode error bit if it is set */
	clear_bit(STATUS_FW_ERROR, &priv->status);

4407
	if (iwl_is_rfkill(priv))
Z
Zhu Yi 已提交
4408 4409
		return;

4410
	ieee80211_wake_queues(priv->hw);
Z
Zhu Yi 已提交
4411 4412 4413 4414

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

C
Christoph Hellwig 已提交
4415
	iwl3945_send_power_mode(priv, IWL_POWER_LEVEL(priv->power_mode));
Z
Zhu Yi 已提交
4416

C
Christoph Hellwig 已提交
4417 4418
	if (iwl3945_is_associated(priv)) {
		struct iwl3945_rxon_cmd *active_rxon =
4419
				(struct iwl3945_rxon_cmd *)(&priv->active39_rxon);
Z
Zhu Yi 已提交
4420

4421 4422
		memcpy(&priv->staging39_rxon, &priv->active39_rxon,
		       sizeof(priv->staging39_rxon));
Z
Zhu Yi 已提交
4423 4424 4425
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
4426
		iwl3945_connection_init_rx_config(priv, priv->iw_mode);
4427
		memcpy(priv->staging39_rxon.node_addr, priv->mac_addr, ETH_ALEN);
Z
Zhu Yi 已提交
4428 4429
	}

4430
	/* Configure Bluetooth device coexistence support */
C
Christoph Hellwig 已提交
4431
	iwl3945_send_bt_config(priv);
Z
Zhu Yi 已提交
4432 4433

	/* Configure the adapter for unassociated operation */
C
Christoph Hellwig 已提交
4434
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
4435 4436 4437

	iwl3945_reg_txpower_periodic(priv);

4438 4439
	iwl3945_led_register(priv);

Z
Zhu Yi 已提交
4440
	IWL_DEBUG_INFO("ALIVE processing complete.\n");
4441
	set_bit(STATUS_READY, &priv->status);
4442
	wake_up_interruptible(&priv->wait_command_queue);
Z
Zhu Yi 已提交
4443 4444

	if (priv->error_recovering)
C
Christoph Hellwig 已提交
4445
		iwl3945_error_recovery(priv);
Z
Zhu Yi 已提交
4446

4447 4448 4449 4450 4451 4452 4453 4454
	/* 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)
			iwl3945_mac_beacon_update(priv->hw, beacon);
	}

Z
Zhu Yi 已提交
4455 4456 4457 4458 4459 4460
	return;

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

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

4463
static void __iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475
{
	unsigned long flags;
	int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
	struct ieee80211_conf *conf = NULL;

	IWL_DEBUG_INFO(DRV_NAME " is going down\n");

	conf = ieee80211_get_hw_conf(priv->hw);

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

M
Mohamed Abbas 已提交
4476
	iwl3945_led_unregister(priv);
C
Christoph Hellwig 已提交
4477
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
4478 4479 4480 4481 4482 4483 4484 4485 4486 4487

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

	/* tell the device to stop sending interrupts */
4491
	spin_lock_irqsave(&priv->lock, flags);
C
Christoph Hellwig 已提交
4492
	iwl3945_disable_interrupts(priv);
4493 4494
	spin_unlock_irqrestore(&priv->lock, flags);
	iwl_synchronize_irq(priv);
Z
Zhu Yi 已提交
4495 4496 4497 4498

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

C
Christoph Hellwig 已提交
4499
	/* If we have not previously called iwl3945_init() then
Z
Zhu Yi 已提交
4500
	 * clear all bits but the RF Kill and SUSPEND bits and return */
4501
	if (!iwl_is_init(priv)) {
Z
Zhu Yi 已提交
4502 4503 4504 4505
		priv->status = test_bit(STATUS_RF_KILL_HW, &priv->status) <<
					STATUS_RF_KILL_HW |
			       test_bit(STATUS_RF_KILL_SW, &priv->status) <<
					STATUS_RF_KILL_SW |
4506 4507
			       test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
					STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
4508
			       test_bit(STATUS_IN_SUSPEND, &priv->status) <<
4509 4510 4511
					STATUS_IN_SUSPEND |
				test_bit(STATUS_EXIT_PENDING, &priv->status) <<
					STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
4512 4513 4514 4515 4516 4517 4518 4519 4520
		goto exit;
	}

	/* ...otherwise clear out all the status bits but the RF Kill and
	 * SUSPEND bits and continue taking the NIC down. */
	priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
				STATUS_RF_KILL_HW |
			test_bit(STATUS_RF_KILL_SW, &priv->status) <<
				STATUS_RF_KILL_SW |
4521 4522
			test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
				STATUS_GEO_CONFIGURED |
Z
Zhu Yi 已提交
4523 4524 4525
			test_bit(STATUS_IN_SUSPEND, &priv->status) <<
				STATUS_IN_SUSPEND |
			test_bit(STATUS_FW_ERROR, &priv->status) <<
4526 4527 4528
				STATUS_FW_ERROR |
			test_bit(STATUS_EXIT_PENDING, &priv->status) <<
				STATUS_EXIT_PENDING;
Z
Zhu Yi 已提交
4529

4530
	priv->cfg->ops->lib->apm_ops.reset(priv);
Z
Zhu Yi 已提交
4531
	spin_lock_irqsave(&priv->lock, flags);
4532
	iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
Z
Zhu Yi 已提交
4533 4534
	spin_unlock_irqrestore(&priv->lock, flags);

C
Christoph Hellwig 已提交
4535 4536
	iwl3945_hw_txq_ctx_stop(priv);
	iwl3945_hw_rxq_stop(priv);
Z
Zhu Yi 已提交
4537 4538

	spin_lock_irqsave(&priv->lock, flags);
4539 4540
	if (!iwl_grab_nic_access(priv)) {
		iwl_write_prph(priv, APMG_CLK_DIS_REG,
Z
Zhu Yi 已提交
4541
					 APMG_CLK_VAL_DMA_CLK_RQT);
4542
		iwl_release_nic_access(priv);
Z
Zhu Yi 已提交
4543 4544 4545 4546 4547
	}
	spin_unlock_irqrestore(&priv->lock, flags);

	udelay(5);

4548 4549 4550 4551 4552
	if (exit_pending || test_bit(STATUS_IN_SUSPEND, &priv->status))
		priv->cfg->ops->lib->apm_ops.stop(priv);
	else
		priv->cfg->ops->lib->apm_ops.reset(priv);

Z
Zhu Yi 已提交
4553
 exit:
4554
	memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
Z
Zhu Yi 已提交
4555 4556 4557 4558 4559 4560

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

	/* clear out any free frames */
C
Christoph Hellwig 已提交
4561
	iwl3945_clear_free_frames(priv);
Z
Zhu Yi 已提交
4562 4563
}

4564
static void iwl3945_down(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4565 4566
{
	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
4567
	__iwl3945_down(priv);
Z
Zhu Yi 已提交
4568
	mutex_unlock(&priv->mutex);
4569

C
Christoph Hellwig 已提交
4570
	iwl3945_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
4571 4572 4573 4574
}

#define MAX_HW_RESTARTS 5

4575
static int __iwl3945_up(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4576 4577 4578 4579
{
	int rc, i;

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
4580
		IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
Z
Zhu Yi 已提交
4581 4582 4583 4584
		return -EIO;
	}

	if (test_bit(STATUS_RF_KILL_SW, &priv->status)) {
4585
		IWL_WARN(priv, "Radio disabled by SW RF kill (module "
Z
Zhu Yi 已提交
4586
			    "parameter)\n");
4587 4588 4589
		return -ENODEV;
	}

4590
	if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
4591
		IWL_ERR(priv, "ucode not available for device bring up\n");
4592 4593 4594
		return -EIO;
	}

4595
	/* If platform's RF_KILL switch is NOT set to KILL */
4596
	if (iwl_read32(priv, CSR_GP_CNTRL) &
4597 4598 4599 4600 4601
				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);
		if (!test_bit(STATUS_IN_SUSPEND, &priv->status)) {
4602
			IWL_WARN(priv, "Radio disabled by HW RF Kill switch\n");
4603 4604
			return -ENODEV;
		}
Z
Zhu Yi 已提交
4605
	}
4606

4607
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
Z
Zhu Yi 已提交
4608

C
Christoph Hellwig 已提交
4609
	rc = iwl3945_hw_nic_init(priv);
Z
Zhu Yi 已提交
4610
	if (rc) {
4611
		IWL_ERR(priv, "Unable to int nic\n");
Z
Zhu Yi 已提交
4612 4613 4614 4615
		return rc;
	}

	/* make sure rfkill handshake bits are cleared */
4616 4617
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
Z
Zhu Yi 已提交
4618 4619 4620
		    CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);

	/* clear (again), then enable host interrupts */
4621
	iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
C
Christoph Hellwig 已提交
4622
	iwl3945_enable_interrupts(priv);
Z
Zhu Yi 已提交
4623 4624

	/* really make sure rfkill handshake bits are cleared */
4625 4626
	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 已提交
4627 4628 4629 4630 4631

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

4634 4635 4636 4637
	/* 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 已提交
4638 4639
	for (i = 0; i < MAX_HW_RESTARTS; i++) {

C
Christoph Hellwig 已提交
4640
		iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
4641 4642 4643 4644

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

		if (rc) {
4648 4649
			IWL_ERR(priv,
				"Unable to set up bootstrap uCode: %d\n", rc);
Z
Zhu Yi 已提交
4650 4651 4652 4653
			continue;
		}

		/* start card; "initialize" will load runtime ucode */
C
Christoph Hellwig 已提交
4654
		iwl3945_nic_start(priv);
Z
Zhu Yi 已提交
4655 4656 4657 4658 4659 4660 4661

		IWL_DEBUG_INFO(DRV_NAME " is coming up\n");

		return 0;
	}

	set_bit(STATUS_EXIT_PENDING, &priv->status);
C
Christoph Hellwig 已提交
4662
	__iwl3945_down(priv);
4663
	clear_bit(STATUS_EXIT_PENDING, &priv->status);
Z
Zhu Yi 已提交
4664 4665 4666

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
4667
	IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
Z
Zhu Yi 已提交
4668 4669 4670 4671 4672 4673 4674 4675 4676 4677
	return -EIO;
}


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

C
Christoph Hellwig 已提交
4678
static void iwl3945_bg_init_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
4679
{
4680 4681
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, init_alive_start.work);
Z
Zhu Yi 已提交
4682 4683 4684 4685 4686

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
4687
	iwl3945_init_alive_start(priv);
Z
Zhu Yi 已提交
4688 4689 4690
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
4691
static void iwl3945_bg_alive_start(struct work_struct *data)
Z
Zhu Yi 已提交
4692
{
4693 4694
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, alive_start.work);
Z
Zhu Yi 已提交
4695 4696 4697 4698 4699

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
4700
	iwl3945_alive_start(priv);
Z
Zhu Yi 已提交
4701 4702 4703
	mutex_unlock(&priv->mutex);
}

4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722
static void iwl3945_rfkill_poll(struct work_struct *data)
{
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rfkill_poll.work);
	unsigned long status = priv->status;

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

	if (test_bit(STATUS_RF_KILL_HW, &status) != test_bit(STATUS_RF_KILL_HW, &priv->status))
		queue_work(priv->workqueue, &priv->rf_kill);

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

}

Z
Zhu Yi 已提交
4723
#define IWL_SCAN_CHECK_WATCHDOG (7 * HZ)
C
Christoph Hellwig 已提交
4724
static void iwl3945_bg_request_scan(struct work_struct *data)
Z
Zhu Yi 已提交
4725
{
4726 4727
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, request_scan);
4728
	struct iwl_host_cmd cmd = {
Z
Zhu Yi 已提交
4729
		.id = REPLY_SCAN_CMD,
C
Christoph Hellwig 已提交
4730
		.len = sizeof(struct iwl3945_scan_cmd),
Z
Zhu Yi 已提交
4731 4732 4733
		.meta.flags = CMD_SIZE_HUGE,
	};
	int rc = 0;
C
Christoph Hellwig 已提交
4734
	struct iwl3945_scan_cmd *scan;
Z
Zhu Yi 已提交
4735
	struct ieee80211_conf *conf = NULL;
4736
	u8 n_probes = 2;
4737
	enum ieee80211_band band;
4738
	DECLARE_SSID_BUF(ssid);
Z
Zhu Yi 已提交
4739 4740 4741 4742 4743

	conf = ieee80211_get_hw_conf(priv->hw);

	mutex_lock(&priv->mutex);

4744
	if (!iwl_is_ready(priv)) {
4745
		IWL_WARN(priv, "request scan called when driver not ready.\n");
Z
Zhu Yi 已提交
4746 4747 4748
		goto done;
	}

T
Tomas Winkler 已提交
4749
	/* Make sure the scan wasn't canceled before this queued work
Z
Zhu Yi 已提交
4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772
	 * 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)) {
		IWL_DEBUG_INFO("Multiple concurrent scan requests in parallel. "
			       "Ignoring second request.\n");
		rc = -EIO;
		goto done;
	}

	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
		IWL_DEBUG_SCAN("Aborting scan due to device shutdown\n");
		goto done;
	}

	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
		IWL_DEBUG_HC("Scan request while abort pending.  Queuing.\n");
		goto done;
	}

4773
	if (iwl_is_rfkill(priv)) {
Z
Zhu Yi 已提交
4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787
		IWL_DEBUG_HC("Aborting scan due to RF Kill activation\n");
		goto done;
	}

	if (!test_bit(STATUS_READY, &priv->status)) {
		IWL_DEBUG_HC("Scan request while uninitialized.  Queuing.\n");
		goto done;
	}

	if (!priv->scan_bands) {
		IWL_DEBUG_HC("Aborting scan due to no requested bands\n");
		goto done;
	}

W
Winkler, Tomas 已提交
4788 4789
	if (!priv->scan) {
		priv->scan = kmalloc(sizeof(struct iwl3945_scan_cmd) +
Z
Zhu Yi 已提交
4790
				     IWL_MAX_SCAN_SIZE, GFP_KERNEL);
W
Winkler, Tomas 已提交
4791
		if (!priv->scan) {
Z
Zhu Yi 已提交
4792 4793 4794 4795
			rc = -ENOMEM;
			goto done;
		}
	}
W
Winkler, Tomas 已提交
4796
	scan = priv->scan;
C
Christoph Hellwig 已提交
4797
	memset(scan, 0, sizeof(struct iwl3945_scan_cmd) + IWL_MAX_SCAN_SIZE);
Z
Zhu Yi 已提交
4798 4799 4800 4801

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

C
Christoph Hellwig 已提交
4802
	if (iwl3945_is_associated(priv)) {
Z
Zhu Yi 已提交
4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815
		u16 interval = 0;
		u32 extra;
		u32 suspend_time = 100;
		u32 scan_suspend_time = 100;
		unsigned long flags;

		IWL_DEBUG_INFO("Scanning while associated...\n");

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

		scan->suspend_time = 0;
4816
		scan->max_out_time = cpu_to_le32(200 * 1024);
Z
Zhu Yi 已提交
4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838
		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);
		IWL_DEBUG_SCAN("suspend_time 0x%X beacon interval %d\n",
			       scan_suspend_time, interval);
	}

	/* We should add the ability for user to lock to PASSIVE ONLY */
	if (priv->one_direct_scan) {
		IWL_DEBUG_SCAN
		    ("Kicking off one direct scan for '%s'\n",
4839 4840
		     print_ssid(ssid, priv->direct_ssid,
				priv->direct_ssid_len));
Z
Zhu Yi 已提交
4841 4842 4843 4844
		scan->direct_scan[0].id = WLAN_EID_SSID;
		scan->direct_scan[0].len = priv->direct_ssid_len;
		memcpy(scan->direct_scan[0].ssid,
		       priv->direct_ssid, priv->direct_ssid_len);
4845 4846
		n_probes++;
	} else
4847
		IWL_DEBUG_SCAN("Kicking off one indirect scan.\n");
Z
Zhu Yi 已提交
4848 4849 4850 4851

	/* 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;
4852
	scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id;
Z
Zhu Yi 已提交
4853 4854 4855 4856
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	/* flags + rate selection */

4857
	if (priv->scan_bands & BIT(IEEE80211_BAND_2GHZ)) {
Z
Zhu Yi 已提交
4858 4859 4860
		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;
4861
		band = IEEE80211_BAND_2GHZ;
4862
	} else if (priv->scan_bands & BIT(IEEE80211_BAND_5GHZ)) {
Z
Zhu Yi 已提交
4863 4864
		scan->tx_cmd.rate = IWL_RATE_6M_PLCP;
		scan->good_CRC_th = IWL_GOOD_CRC_TH;
4865
		band = IEEE80211_BAND_5GHZ;
4866
	} else {
4867
		IWL_WARN(priv, "Invalid scan band count\n");
Z
Zhu Yi 已提交
4868 4869 4870
		goto done;
	}

S
Samuel Ortiz 已提交
4871 4872 4873 4874 4875
	scan->tx_cmd.len = cpu_to_le16(
		iwl_fill_probe_req(priv, band,
				   (struct ieee80211_mgmt *)scan->data,
				   IWL_MAX_SCAN_SIZE - sizeof(*scan)));

Z
Zhu Yi 已提交
4876 4877 4878
	/* select Rx antennas */
	scan->flags |= iwl3945_get_antenna_flags(priv);

4879
	if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
Z
Zhu Yi 已提交
4880 4881
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

4882 4883 4884 4885
	scan->channel_count =
		iwl3945_get_channels_for_scan(priv, band, 1, /* active */
					      n_probes,
			(void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);
Z
Zhu Yi 已提交
4886

4887 4888 4889 4890 4891
	if (scan->channel_count == 0) {
		IWL_DEBUG_SCAN("channel count %d\n", scan->channel_count);
		goto done;
	}

Z
Zhu Yi 已提交
4892
	cmd.len += le16_to_cpu(scan->tx_cmd.len) +
C
Christoph Hellwig 已提交
4893
	    scan->channel_count * sizeof(struct iwl3945_scan_channel);
Z
Zhu Yi 已提交
4894 4895 4896 4897
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

	set_bit(STATUS_SCAN_HW, &priv->status);
4898
	rc = iwl_send_cmd_sync(priv, &cmd);
Z
Zhu Yi 已提交
4899 4900 4901 4902 4903 4904 4905 4906 4907 4908
	if (rc)
		goto done;

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

	mutex_unlock(&priv->mutex);
	return;

 done:
4909 4910 4911 4912 4913 4914 4915 4916
	/* 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);

4917
	/* inform mac80211 scan aborted */
Z
Zhu Yi 已提交
4918 4919 4920 4921
	queue_work(priv->workqueue, &priv->scan_completed);
	mutex_unlock(&priv->mutex);
}

C
Christoph Hellwig 已提交
4922
static void iwl3945_bg_up(struct work_struct *data)
Z
Zhu Yi 已提交
4923
{
4924
	struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
Z
Zhu Yi 已提交
4925 4926 4927 4928 4929

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
4930
	__iwl3945_up(priv);
Z
Zhu Yi 已提交
4931
	mutex_unlock(&priv->mutex);
S
Samuel Ortiz 已提交
4932
	iwl_rfkill_set_hw_state(priv);
Z
Zhu Yi 已提交
4933 4934
}

C
Christoph Hellwig 已提交
4935
static void iwl3945_bg_restart(struct work_struct *data)
Z
Zhu Yi 已提交
4936
{
4937
	struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
Z
Zhu Yi 已提交
4938 4939 4940 4941

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

C
Christoph Hellwig 已提交
4942
	iwl3945_down(priv);
Z
Zhu Yi 已提交
4943 4944 4945
	queue_work(priv->workqueue, &priv->up);
}

C
Christoph Hellwig 已提交
4946
static void iwl3945_bg_rx_replenish(struct work_struct *data)
Z
Zhu Yi 已提交
4947
{
4948 4949
	struct iwl_priv *priv =
	    container_of(data, struct iwl_priv, rx_replenish);
Z
Zhu Yi 已提交
4950 4951 4952 4953 4954

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

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
4955
	iwl3945_rx_replenish(priv);
Z
Zhu Yi 已提交
4956 4957 4958
	mutex_unlock(&priv->mutex);
}

4959 4960
#define IWL_DELAY_NEXT_SCAN (HZ*2)

4961
static void iwl3945_post_associate(struct iwl_priv *priv)
Z
Zhu Yi 已提交
4962 4963 4964 4965
{
	int rc = 0;
	struct ieee80211_conf *conf = NULL;

4966
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
4967
		IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
Z
Zhu Yi 已提交
4968 4969 4970 4971
		return;
	}


J
Johannes Berg 已提交
4972
	IWL_DEBUG_ASSOC("Associated as %d to: %pM\n",
4973
			priv->assoc_id, priv->active39_rxon.bssid_addr);
Z
Zhu Yi 已提交
4974 4975 4976 4977

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

A
Abhijeet Kolekar 已提交
4978
	if (!priv->vif || !priv->is_open)
4979
		return;
A
Abhijeet Kolekar 已提交
4980

4981
	iwl_scan_cancel_timeout(priv, 200);
4982

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

4985
	priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
4986
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
4987

4988
	memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
4989
	iwl3945_setup_rxon_timing(priv);
4990
	rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
Z
Zhu Yi 已提交
4991 4992
			      sizeof(priv->rxon_timing), &priv->rxon_timing);
	if (rc)
4993
		IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
4994 4995
			    "Attempting to continue.\n");

4996
	priv->staging39_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
Z
Zhu Yi 已提交
4997

4998
	priv->staging39_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
4999 5000 5001 5002 5003

	IWL_DEBUG_ASSOC("assoc id %d beacon interval %d\n",
			priv->assoc_id, priv->beacon_int);

	if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
5004
		priv->staging39_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
5005
	else
5006
		priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
Z
Zhu Yi 已提交
5007

5008
	if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
5009
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
5010
			priv->staging39_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
5011
		else
5012
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
5013

5014
		if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
5015
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
Z
Zhu Yi 已提交
5016 5017 5018

	}

C
Christoph Hellwig 已提交
5019
	iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5020 5021

	switch (priv->iw_mode) {
5022
	case NL80211_IFTYPE_STATION:
C
Christoph Hellwig 已提交
5023
		iwl3945_rate_scale_init(priv->hw, IWL_AP_ID);
Z
Zhu Yi 已提交
5024 5025
		break;

5026
	case NL80211_IFTYPE_ADHOC:
Z
Zhu Yi 已提交
5027

5028
		priv->assoc_id = 1;
C
Christoph Hellwig 已提交
5029
		iwl3945_add_station(priv, priv->bssid, 0, 0);
Z
Zhu Yi 已提交
5030
		iwl3945_sync_sta(priv, IWL_STA_ID,
5031
				 (priv->band == IEEE80211_BAND_5GHZ) ?
Z
Zhu Yi 已提交
5032 5033
				 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP,
				 CMD_ASYNC);
C
Christoph Hellwig 已提交
5034 5035
		iwl3945_rate_scale_init(priv->hw, IWL_STA_ID);
		iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
5036 5037 5038 5039

		break;

	default:
5040
		 IWL_ERR(priv, "%s Should not be called in %d mode\n",
5041
			   __func__, priv->iw_mode);
Z
Zhu Yi 已提交
5042 5043 5044
		break;
	}

C
Christoph Hellwig 已提交
5045
	iwl3945_activate_qos(priv, 0);
5046

5047 5048
	/* we have just associated, don't start scan too early */
	priv->next_scan_jiffies = jiffies + IWL_DELAY_NEXT_SCAN;
5049 5050
}

5051
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed);
5052

Z
Zhu Yi 已提交
5053 5054 5055 5056 5057 5058
/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

5059 5060
#define UCODE_READY_TIMEOUT	(2 * HZ)

C
Christoph Hellwig 已提交
5061
static int iwl3945_mac_start(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
5062
{
5063
	struct iwl_priv *priv = hw->priv;
5064
	int ret;
Z
Zhu Yi 已提交
5065 5066 5067 5068 5069 5070

	IWL_DEBUG_MAC80211("enter\n");

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

5071
	memset(&priv->staging39_rxon, 0, sizeof(struct iwl3945_rxon_cmd));
5072 5073 5074 5075 5076 5077
	/* 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) {
5078
			IWL_ERR(priv, "Could not read microcode: %d\n", ret);
5079 5080 5081 5082
			mutex_unlock(&priv->mutex);
			goto out_release_irq;
		}
	}
Z
Zhu Yi 已提交
5083

5084
	ret = __iwl3945_up(priv);
Z
Zhu Yi 已提交
5085 5086

	mutex_unlock(&priv->mutex);
5087

S
Samuel Ortiz 已提交
5088
	iwl_rfkill_set_hw_state(priv);
5089

5090 5091 5092 5093 5094 5095 5096 5097
	if (ret)
		goto out_release_irq;

	IWL_DEBUG_INFO("Start UP work.\n");

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

5098 5099 5100 5101 5102 5103 5104
	/* 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)) {
5105 5106 5107
			IWL_ERR(priv,
				"Wait for START_ALIVE timeout after %dms.\n",
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
5108 5109 5110 5111 5112
			ret = -ETIMEDOUT;
			goto out_release_irq;
		}
	}

5113 5114 5115 5116
	/* ucode is running and will send rfkill notifications,
	 * no need to poll the killswitch state anymore */
	cancel_delayed_work(&priv->rfkill_poll);

5117
	priv->is_open = 1;
Z
Zhu Yi 已提交
5118 5119
	IWL_DEBUG_MAC80211("leave\n");
	return 0;
5120 5121

out_release_irq:
5122 5123
	priv->is_open = 0;
	IWL_DEBUG_MAC80211("leave - failed\n");
5124
	return ret;
Z
Zhu Yi 已提交
5125 5126
}

C
Christoph Hellwig 已提交
5127
static void iwl3945_mac_stop(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
5128
{
5129
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
5130 5131

	IWL_DEBUG_MAC80211("enter\n");
5132

5133 5134 5135 5136 5137
	if (!priv->is_open) {
		IWL_DEBUG_MAC80211("leave - skip\n");
		return;
	}

Z
Zhu Yi 已提交
5138
	priv->is_open = 0;
5139

5140
	if (iwl_is_ready_rf(priv)) {
5141 5142 5143
		/* stop mac, cancel any scan request and clear
		 * RXON_FILTER_ASSOC_MSK BIT
		 */
5144
		mutex_lock(&priv->mutex);
5145
		iwl_scan_cancel_timeout(priv, 100);
5146 5147 5148
		mutex_unlock(&priv->mutex);
	}

5149 5150 5151
	iwl3945_down(priv);

	flush_workqueue(priv->workqueue);
5152 5153 5154 5155

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

Z
Zhu Yi 已提交
5157 5158 5159
	IWL_DEBUG_MAC80211("leave\n");
}

5160
static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
5161
{
5162
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
5163 5164 5165 5166

	IWL_DEBUG_MAC80211("enter\n");

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

5169
	if (iwl3945_tx_skb(priv, skb))
Z
Zhu Yi 已提交
5170 5171 5172
		dev_kfree_skb_any(skb);

	IWL_DEBUG_MAC80211("leave\n");
5173
	return NETDEV_TX_OK;
Z
Zhu Yi 已提交
5174 5175
}

C
Christoph Hellwig 已提交
5176
static int iwl3945_mac_add_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
5177 5178
				 struct ieee80211_if_init_conf *conf)
{
5179
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
5180 5181
	unsigned long flags;

5182
	IWL_DEBUG_MAC80211("enter: type %d\n", conf->type);
Z
Zhu Yi 已提交
5183

5184 5185
	if (priv->vif) {
		IWL_DEBUG_MAC80211("leave - vif != NULL\n");
5186
		return -EOPNOTSUPP;
Z
Zhu Yi 已提交
5187 5188 5189
	}

	spin_lock_irqsave(&priv->lock, flags);
5190
	priv->vif = conf->vif;
5191
	priv->iw_mode = conf->type;
Z
Zhu Yi 已提交
5192 5193 5194 5195

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
5196 5197

	if (conf->mac_addr) {
J
Johannes Berg 已提交
5198
		IWL_DEBUG_MAC80211("Set: %pM\n", conf->mac_addr);
5199 5200 5201
		memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
	}

5202
	if (iwl_is_ready(priv))
5203
		iwl3945_set_mode(priv, conf->type);
Z
Zhu Yi 已提交
5204 5205 5206

	mutex_unlock(&priv->mutex);

5207
	IWL_DEBUG_MAC80211("leave\n");
Z
Zhu Yi 已提交
5208 5209 5210 5211
	return 0;
}

/**
C
Christoph Hellwig 已提交
5212
 * iwl3945_mac_config - mac80211 config callback
Z
Zhu Yi 已提交
5213 5214 5215 5216 5217
 *
 * We ignore conf->flags & IEEE80211_CONF_SHORT_SLOT_TIME since it seems to
 * be set inappropriately and the driver currently sets the hardware up to
 * use it whenever needed.
 */
5218
static int iwl3945_mac_config(struct ieee80211_hw *hw, u32 changed)
Z
Zhu Yi 已提交
5219
{
5220
	struct iwl_priv *priv = hw->priv;
5221
	const struct iwl_channel_info *ch_info;
5222
	struct ieee80211_conf *conf = &hw->conf;
Z
Zhu Yi 已提交
5223
	unsigned long flags;
5224
	int ret = 0;
Z
Zhu Yi 已提交
5225 5226

	mutex_lock(&priv->mutex);
5227
	IWL_DEBUG_MAC80211("enter to channel %d\n", conf->channel->hw_value);
Z
Zhu Yi 已提交
5228

5229
	if (!iwl_is_ready(priv)) {
Z
Zhu Yi 已提交
5230
		IWL_DEBUG_MAC80211("leave - not ready\n");
5231 5232
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
5233 5234
	}

5235
	if (unlikely(!iwl3945_mod_params.disable_hw_scan &&
Z
Zhu Yi 已提交
5236
		     test_bit(STATUS_SCANNING, &priv->status))) {
5237 5238
		IWL_DEBUG_MAC80211("leave - scanning\n");
		set_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
5239
		mutex_unlock(&priv->mutex);
5240
		return 0;
Z
Zhu Yi 已提交
5241 5242 5243 5244
	}

	spin_lock_irqsave(&priv->lock, flags);

5245 5246
	ch_info = iwl3945_get_channel_info(priv, conf->channel->band,
					   conf->channel->hw_value);
Z
Zhu Yi 已提交
5247
	if (!is_channel_valid(ch_info)) {
5248
		IWL_DEBUG_SCAN("Channel %d [%d] is INVALID for this band.\n",
5249
			       conf->channel->hw_value, conf->channel->band);
Z
Zhu Yi 已提交
5250 5251
		IWL_DEBUG_MAC80211("leave - invalid channel\n");
		spin_unlock_irqrestore(&priv->lock, flags);
5252 5253
		ret = -EINVAL;
		goto out;
Z
Zhu Yi 已提交
5254 5255
	}

5256
	iwl3945_set_rxon_channel(priv, conf->channel->band, conf->channel->hw_value);
Z
Zhu Yi 已提交
5257

5258
	iwl3945_set_flags_for_phymode(priv, conf->channel->band);
Z
Zhu Yi 已提交
5259 5260 5261 5262

	/* The list of supported rates and rate mask can be different
	 * for each phymode; since the phymode may have changed, reset
	 * the rate mask to what mac80211 lists */
C
Christoph Hellwig 已提交
5263
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
5264 5265 5266 5267 5268

	spin_unlock_irqrestore(&priv->lock, flags);

#ifdef IEEE80211_CONF_CHANNEL_SWITCH
	if (conf->flags & IEEE80211_CONF_CHANNEL_SWITCH) {
C
Christoph Hellwig 已提交
5269
		iwl3945_hw_channel_switch(priv, conf->channel);
5270
		goto out;
Z
Zhu Yi 已提交
5271 5272 5273
	}
#endif

C
Christoph Hellwig 已提交
5274
	iwl3945_radio_kill_sw(priv, !conf->radio_enabled);
Z
Zhu Yi 已提交
5275 5276 5277

	if (!conf->radio_enabled) {
		IWL_DEBUG_MAC80211("leave - radio disabled\n");
5278
		goto out;
Z
Zhu Yi 已提交
5279 5280
	}

5281
	if (iwl_is_rfkill(priv)) {
Z
Zhu Yi 已提交
5282
		IWL_DEBUG_MAC80211("leave - RF kill\n");
5283 5284
		ret = -EIO;
		goto out;
Z
Zhu Yi 已提交
5285 5286
	}

C
Christoph Hellwig 已提交
5287
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
5288

5289 5290
	if (memcmp(&priv->active39_rxon,
		   &priv->staging39_rxon, sizeof(priv->staging39_rxon)))
C
Christoph Hellwig 已提交
5291
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5292 5293 5294 5295 5296
	else
		IWL_DEBUG_INFO("No re-sending same RXON configuration.\n");

	IWL_DEBUG_MAC80211("leave\n");

5297
out:
5298
	clear_bit(STATUS_CONF_PENDING, &priv->status);
Z
Zhu Yi 已提交
5299
	mutex_unlock(&priv->mutex);
5300
	return ret;
Z
Zhu Yi 已提交
5301 5302
}

5303
static void iwl3945_config_ap(struct iwl_priv *priv)
Z
Zhu Yi 已提交
5304 5305 5306
{
	int rc = 0;

5307
	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
Z
Zhu Yi 已提交
5308 5309 5310
		return;

	/* The following should be done only at AP bring up */
5311
	if (!(iwl3945_is_associated(priv))) {
Z
Zhu Yi 已提交
5312 5313

		/* RXON - unassoc (to set timing command) */
5314
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
5315
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5316 5317

		/* RXON Timing */
5318
		memset(&priv->rxon_timing, 0, sizeof(struct iwl_rxon_time_cmd));
C
Christoph Hellwig 已提交
5319
		iwl3945_setup_rxon_timing(priv);
5320 5321 5322
		rc = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
				      sizeof(priv->rxon_timing),
				      &priv->rxon_timing);
Z
Zhu Yi 已提交
5323
		if (rc)
5324
			IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
Z
Zhu Yi 已提交
5325 5326 5327
					"Attempting to continue.\n");

		/* FIXME: what should be the assoc_id for AP? */
5328
		priv->staging39_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
Z
Zhu Yi 已提交
5329
		if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
5330
			priv->staging39_rxon.flags |=
Z
Zhu Yi 已提交
5331 5332
				RXON_FLG_SHORT_PREAMBLE_MSK;
		else
5333
			priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
5334 5335
				~RXON_FLG_SHORT_PREAMBLE_MSK;

5336
		if (priv->staging39_rxon.flags & RXON_FLG_BAND_24G_MSK) {
Z
Zhu Yi 已提交
5337 5338
			if (priv->assoc_capability &
				WLAN_CAPABILITY_SHORT_SLOT_TIME)
5339
				priv->staging39_rxon.flags |=
Z
Zhu Yi 已提交
5340 5341
					RXON_FLG_SHORT_SLOT_MSK;
			else
5342
				priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
5343 5344
					~RXON_FLG_SHORT_SLOT_MSK;

5345
			if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
5346
				priv->staging39_rxon.flags &=
Z
Zhu Yi 已提交
5347 5348 5349
					~RXON_FLG_SHORT_SLOT_MSK;
		}
		/* restore RXON assoc */
5350
		priv->staging39_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
5351
		iwl3945_commit_rxon(priv);
5352
		iwl3945_add_station(priv, iwl_bcast_addr, 0, 0);
5353
	}
C
Christoph Hellwig 已提交
5354
	iwl3945_send_beacon_cmd(priv);
Z
Zhu Yi 已提交
5355 5356 5357 5358 5359 5360

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

5361 5362
static int iwl3945_mac_config_interface(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
5363
					struct ieee80211_if_conf *conf)
Z
Zhu Yi 已提交
5364
{
5365
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
5366 5367 5368 5369 5370
	int rc;

	if (conf == NULL)
		return -EIO;

5371 5372 5373 5374 5375
	if (priv->vif != vif) {
		IWL_DEBUG_MAC80211("leave - priv->vif != vif\n");
		return 0;
	}

5376
	/* handle this temporarily here */
5377
	if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
5378 5379 5380 5381
	    conf->changed & IEEE80211_IFCC_BEACON) {
		struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
		if (!beacon)
			return -ENOMEM;
5382
		mutex_lock(&priv->mutex);
5383
		rc = iwl3945_mac_beacon_update(hw, beacon);
5384
		mutex_unlock(&priv->mutex);
5385 5386 5387 5388
		if (rc)
			return rc;
	}

5389
	if (!iwl_is_alive(priv))
5390 5391
		return -EAGAIN;

Z
Zhu Yi 已提交
5392 5393 5394
	mutex_lock(&priv->mutex);

	if (conf->bssid)
J
Johannes Berg 已提交
5395
		IWL_DEBUG_MAC80211("bssid: %pM\n", conf->bssid);
Z
Zhu Yi 已提交
5396

5397 5398 5399
/*
 * very dubious code was here; the probe filtering flag is never set:
 *
Z
Zhu Yi 已提交
5400 5401
	if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
	    !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
5402
 */
Z
Zhu Yi 已提交
5403

5404
	if (priv->iw_mode == NL80211_IFTYPE_AP) {
Z
Zhu Yi 已提交
5405 5406 5407
		if (!conf->bssid) {
			conf->bssid = priv->mac_addr;
			memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
J
Johannes Berg 已提交
5408 5409
			IWL_DEBUG_MAC80211("bssid was set to: %pM\n",
					   conf->bssid);
Z
Zhu Yi 已提交
5410 5411 5412 5413
		}
		if (priv->ibss_beacon)
			dev_kfree_skb(priv->ibss_beacon);

5414
		priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
Z
Zhu Yi 已提交
5415 5416
	}

5417
	if (iwl_is_rfkill(priv))
5418 5419
		goto done;

Z
Zhu Yi 已提交
5420 5421 5422 5423
	if (conf->bssid && !is_zero_ether_addr(conf->bssid) &&
	    !is_multicast_ether_addr(conf->bssid)) {
		/* If there is currently a HW scan going on in the background
		 * then we need to cancel it else the RXON below will fail. */
5424
		if (iwl_scan_cancel_timeout(priv, 100)) {
5425
			IWL_WARN(priv, "Aborted scan still in progress "
Z
Zhu Yi 已提交
5426 5427 5428 5429 5430
				    "after 100ms\n");
			IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
			mutex_unlock(&priv->mutex);
			return -EAGAIN;
		}
5431
		memcpy(priv->staging39_rxon.bssid_addr, conf->bssid, ETH_ALEN);
Z
Zhu Yi 已提交
5432 5433 5434 5435 5436 5437 5438

		/* TODO: Audit driver for usage of these members and see
		 * if mac80211 deprecates them (priv->bssid looks like it
		 * shouldn't be there, but I haven't scanned the IBSS code
		 * to verify) - jpk */
		memcpy(priv->bssid, conf->bssid, ETH_ALEN);

5439
		if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
5440
			iwl3945_config_ap(priv);
Z
Zhu Yi 已提交
5441
		else {
C
Christoph Hellwig 已提交
5442
			rc = iwl3945_commit_rxon(priv);
5443
			if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
C
Christoph Hellwig 已提交
5444
				iwl3945_add_station(priv,
5445
					priv->active39_rxon.bssid_addr, 1, 0);
Z
Zhu Yi 已提交
5446 5447 5448
		}

	} else {
5449
		iwl_scan_cancel_timeout(priv, 100);
5450
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
5451
		iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5452 5453
	}

5454
 done:
Z
Zhu Yi 已提交
5455 5456 5457 5458 5459 5460
	IWL_DEBUG_MAC80211("leave\n");
	mutex_unlock(&priv->mutex);

	return 0;
}

C
Christoph Hellwig 已提交
5461
static void iwl3945_configure_filter(struct ieee80211_hw *hw,
5462 5463 5464 5465
				 unsigned int changed_flags,
				 unsigned int *total_flags,
				 int mc_count, struct dev_addr_list *mc_list)
{
5466
	struct iwl_priv *priv = hw->priv;
5467
	__le32 *filter_flags = &priv->staging39_rxon.filter_flags;
5468

Z
Zhu, Yi 已提交
5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488
	IWL_DEBUG_MAC80211("Enter: changed: 0x%x, total: 0x%x\n",
			changed_flags, *total_flags);

	if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) {
		if (*total_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))
			*filter_flags |= RXON_FILTER_PROMISC_MSK;
		else
			*filter_flags &= ~RXON_FILTER_PROMISC_MSK;
	}
	if (changed_flags & FIF_ALLMULTI) {
		if (*total_flags & FIF_ALLMULTI)
			*filter_flags |= RXON_FILTER_ACCEPT_GRP_MSK;
		else
			*filter_flags &= ~RXON_FILTER_ACCEPT_GRP_MSK;
	}
	if (changed_flags & FIF_CONTROL) {
		if (*total_flags & FIF_CONTROL)
			*filter_flags |= RXON_FILTER_CTL2HOST_MSK;
		else
			*filter_flags &= ~RXON_FILTER_CTL2HOST_MSK;
5489
	}
Z
Zhu, Yi 已提交
5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503
	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
		if (*total_flags & FIF_BCN_PRBRESP_PROMISC)
			*filter_flags |= RXON_FILTER_BCON_AWARE_MSK;
		else
			*filter_flags &= ~RXON_FILTER_BCON_AWARE_MSK;
	}

	/* We avoid iwl_commit_rxon here to commit the new filter flags
	 * since mac80211 will call ieee80211_hw_config immediately.
	 * (mc_list is not supported at this time). Otherwise, we need to
	 * queue a background iwl_commit_rxon work.
	 */

	*total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
5504
			FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
5505 5506
}

C
Christoph Hellwig 已提交
5507
static void iwl3945_mac_remove_interface(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
5508 5509
				     struct ieee80211_if_init_conf *conf)
{
5510
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
5511 5512 5513 5514

	IWL_DEBUG_MAC80211("enter\n");

	mutex_lock(&priv->mutex);
5515

5516
	if (iwl_is_ready_rf(priv)) {
5517
		iwl_scan_cancel_timeout(priv, 100);
5518
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
5519 5520
		iwl3945_commit_rxon(priv);
	}
5521 5522
	if (priv->vif == conf->vif) {
		priv->vif = NULL;
Z
Zhu Yi 已提交
5523 5524 5525 5526 5527 5528 5529
		memset(priv->bssid, 0, ETH_ALEN);
	}
	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");
}

5530 5531 5532 5533 5534 5535 5536
#define IWL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)

static void iwl3945_bss_info_changed(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif,
				     struct ieee80211_bss_conf *bss_conf,
				     u32 changes)
{
5537
	struct iwl_priv *priv = hw->priv;
5538 5539 5540 5541 5542 5543 5544

	IWL_DEBUG_MAC80211("changes = 0x%X\n", changes);

	if (changes & BSS_CHANGED_ERP_PREAMBLE) {
		IWL_DEBUG_MAC80211("ERP_PREAMBLE %d\n",
				   bss_conf->use_short_preamble);
		if (bss_conf->use_short_preamble)
5545
			priv->staging39_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
5546
		else
5547
			priv->staging39_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
5548 5549 5550 5551 5552
	}

	if (changes & BSS_CHANGED_ERP_CTS_PROT) {
		IWL_DEBUG_MAC80211("ERP_CTS %d\n", bss_conf->use_cts_prot);
		if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
5553
			priv->staging39_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
5554
		else
5555
			priv->staging39_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566
	}

	if (changes & BSS_CHANGED_ASSOC) {
		IWL_DEBUG_MAC80211("ASSOC %d\n", bss_conf->assoc);
		/* This should never happen as this function should
		 * never be called from interrupt context. */
		if (WARN_ON_ONCE(in_interrupt()))
			return;
		if (bss_conf->assoc) {
			priv->assoc_id = bss_conf->aid;
			priv->beacon_int = bss_conf->beacon_int;
5567
			priv->timestamp = bss_conf->timestamp;
5568
			priv->assoc_capability = bss_conf->assoc_capability;
5569
			priv->power_data.dtim_period = bss_conf->dtim_period;
5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585
			priv->next_scan_jiffies = jiffies +
					IWL_DELAY_NEXT_SCAN_AFTER_ASSOC;
			mutex_lock(&priv->mutex);
			iwl3945_post_associate(priv);
			mutex_unlock(&priv->mutex);
		} else {
			priv->assoc_id = 0;
			IWL_DEBUG_MAC80211("DISASSOC %d\n", bss_conf->assoc);
		}
	} else if (changes && iwl3945_is_associated(priv) && priv->assoc_id) {
			IWL_DEBUG_MAC80211("Associated Changes %d\n", changes);
			iwl3945_send_rxon_assoc(priv);
	}

}

C
Christoph Hellwig 已提交
5586
static int iwl3945_mac_hw_scan(struct ieee80211_hw *hw, u8 *ssid, size_t len)
Z
Zhu Yi 已提交
5587 5588 5589
{
	int rc = 0;
	unsigned long flags;
5590
	struct iwl_priv *priv = hw->priv;
5591
	DECLARE_SSID_BUF(ssid_buf);
Z
Zhu Yi 已提交
5592 5593 5594

	IWL_DEBUG_MAC80211("enter\n");

5595
	mutex_lock(&priv->mutex);
Z
Zhu Yi 已提交
5596 5597
	spin_lock_irqsave(&priv->lock, flags);

5598
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
5599 5600 5601 5602 5603
		rc = -EIO;
		IWL_DEBUG_MAC80211("leave - not ready or exit pending\n");
		goto out_unlock;
	}

5604 5605 5606 5607 5608 5609
	/* we don't schedule scan within next_scan_jiffies period */
	if (priv->next_scan_jiffies &&
			time_after(priv->next_scan_jiffies, jiffies)) {
		rc = -EAGAIN;
		goto out_unlock;
	}
5610 5611 5612 5613
	/* if we just finished scan ask for delay for a broadcast scan */
	if ((len == 0) && priv->last_scan_jiffies &&
	    time_after(priv->last_scan_jiffies + IWL_DELAY_NEXT_SCAN,
		       jiffies)) {
Z
Zhu Yi 已提交
5614 5615 5616 5617
		rc = -EAGAIN;
		goto out_unlock;
	}
	if (len) {
5618
		IWL_DEBUG_SCAN("direct scan for %s [%d]\n ",
5619
			       print_ssid(ssid_buf, ssid, len), (int)len);
Z
Zhu Yi 已提交
5620 5621 5622 5623 5624

		priv->one_direct_scan = 1;
		priv->direct_ssid_len = (u8)
		    min((u8) len, (u8) IW_ESSID_MAX_SIZE);
		memcpy(priv->direct_ssid, ssid, priv->direct_ssid_len);
5625 5626
	} else
		priv->one_direct_scan = 0;
Z
Zhu Yi 已提交
5627

C
Christoph Hellwig 已提交
5628
	rc = iwl3945_scan_initiate(priv);
Z
Zhu Yi 已提交
5629 5630 5631 5632 5633

	IWL_DEBUG_MAC80211("leave\n");

out_unlock:
	spin_unlock_irqrestore(&priv->lock, flags);
5634
	mutex_unlock(&priv->mutex);
Z
Zhu Yi 已提交
5635 5636 5637 5638

	return rc;
}

C
Christoph Hellwig 已提交
5639
static int iwl3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
5640 5641 5642
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       struct ieee80211_key_conf *key)
Z
Zhu Yi 已提交
5643
{
5644
	struct iwl_priv *priv = hw->priv;
5645
	const u8 *addr;
5646
	int ret;
Z
Zhu Yi 已提交
5647 5648 5649 5650
	u8 sta_id;

	IWL_DEBUG_MAC80211("enter\n");

5651
	if (iwl3945_mod_params.sw_crypto) {
Z
Zhu Yi 已提交
5652 5653 5654 5655
		IWL_DEBUG_MAC80211("leave - hwcrypto disabled\n");
		return -EOPNOTSUPP;
	}

5656
	addr = sta ? sta->addr : iwl_bcast_addr;
C
Christoph Hellwig 已提交
5657
	sta_id = iwl3945_hw_find_station(priv, addr);
Z
Zhu Yi 已提交
5658
	if (sta_id == IWL_INVALID_STATION) {
J
Johannes Berg 已提交
5659 5660
		IWL_DEBUG_MAC80211("leave - %pM not in station map.\n",
				   addr);
Z
Zhu Yi 已提交
5661 5662 5663 5664 5665
		return -EINVAL;
	}

	mutex_lock(&priv->mutex);

5666
	iwl_scan_cancel_timeout(priv, 100);
5667

Z
Zhu Yi 已提交
5668 5669
	switch (cmd) {
	case  SET_KEY:
5670 5671
		ret = iwl3945_update_sta_key_info(priv, key, sta_id);
		if (!ret) {
C
Christoph Hellwig 已提交
5672 5673
			iwl3945_set_rxon_hwcrypto(priv, 1);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5674 5675 5676 5677 5678 5679
			key->hw_key_idx = sta_id;
			IWL_DEBUG_MAC80211("set_key success, using hwcrypto\n");
			key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
		}
		break;
	case DISABLE_KEY:
5680 5681
		ret = iwl3945_clear_sta_key_info(priv, sta_id);
		if (!ret) {
C
Christoph Hellwig 已提交
5682 5683
			iwl3945_set_rxon_hwcrypto(priv, 0);
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5684 5685 5686 5687
			IWL_DEBUG_MAC80211("disable hwcrypto key\n");
		}
		break;
	default:
5688
		ret = -EINVAL;
Z
Zhu Yi 已提交
5689 5690 5691 5692 5693
	}

	IWL_DEBUG_MAC80211("leave\n");
	mutex_unlock(&priv->mutex);

5694
	return ret;
Z
Zhu Yi 已提交
5695 5696
}

J
Johannes Berg 已提交
5697
static int iwl3945_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
Z
Zhu Yi 已提交
5698 5699
			   const struct ieee80211_tx_queue_params *params)
{
5700
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
5701 5702 5703 5704 5705
	unsigned long flags;
	int q;

	IWL_DEBUG_MAC80211("enter\n");

5706
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		return -EIO;
	}

	if (queue >= AC_NUM) {
		IWL_DEBUG_MAC80211("leave - queue >= AC_NUM %d\n", queue);
		return 0;
	}

	q = AC_NUM - 1 - queue;

	spin_lock_irqsave(&priv->lock, flags);

	priv->qos_data.def_qos_parm.ac[q].cw_min = cpu_to_le16(params->cw_min);
	priv->qos_data.def_qos_parm.ac[q].cw_max = cpu_to_le16(params->cw_max);
	priv->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
	priv->qos_data.def_qos_parm.ac[q].edca_txop =
5724
			cpu_to_le16((params->txop * 32));
Z
Zhu Yi 已提交
5725 5726 5727 5728 5729 5730 5731

	priv->qos_data.def_qos_parm.ac[q].reserved1 = 0;
	priv->qos_data.qos_active = 1;

	spin_unlock_irqrestore(&priv->lock, flags);

	mutex_lock(&priv->mutex);
5732
	if (priv->iw_mode == NL80211_IFTYPE_AP)
C
Christoph Hellwig 已提交
5733 5734 5735
		iwl3945_activate_qos(priv, 1);
	else if (priv->assoc_id && iwl3945_is_associated(priv))
		iwl3945_activate_qos(priv, 0);
Z
Zhu Yi 已提交
5736 5737 5738 5739 5740 5741 5742

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");
	return 0;
}

C
Christoph Hellwig 已提交
5743
static int iwl3945_mac_get_tx_stats(struct ieee80211_hw *hw,
Z
Zhu Yi 已提交
5744 5745
				struct ieee80211_tx_queue_stats *stats)
{
5746
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
5747
	int i, avail;
5748
	struct iwl_tx_queue *txq;
5749
	struct iwl_queue *q;
Z
Zhu Yi 已提交
5750 5751 5752 5753
	unsigned long flags;

	IWL_DEBUG_MAC80211("enter\n");

5754
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
5755 5756 5757 5758 5759 5760 5761
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		return -EIO;
	}

	spin_lock_irqsave(&priv->lock, flags);

	for (i = 0; i < AC_NUM; i++) {
5762
		txq = &priv->txq[i];
Z
Zhu Yi 已提交
5763
		q = &txq->q;
5764
		avail = iwl_queue_space(q);
Z
Zhu Yi 已提交
5765

5766 5767 5768
		stats[i].len = q->n_window - avail;
		stats[i].limit = q->n_window - q->high_mark;
		stats[i].count = q->n_window;
Z
Zhu Yi 已提交
5769 5770 5771 5772 5773 5774 5775 5776 5777

	}
	spin_unlock_irqrestore(&priv->lock, flags);

	IWL_DEBUG_MAC80211("leave\n");

	return 0;
}

C
Christoph Hellwig 已提交
5778
static void iwl3945_mac_reset_tsf(struct ieee80211_hw *hw)
Z
Zhu Yi 已提交
5779
{
5780
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
5781 5782 5783 5784 5785
	unsigned long flags;

	mutex_lock(&priv->mutex);
	IWL_DEBUG_MAC80211("enter\n");

5786
	iwl_reset_qos(priv);
5787

Z
Zhu Yi 已提交
5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798
	spin_lock_irqsave(&priv->lock, flags);
	priv->assoc_id = 0;
	priv->assoc_capability = 0;

	/* new association get rid of ibss beacon skb */
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	priv->ibss_beacon = NULL;

	priv->beacon_int = priv->hw->conf.beacon_int;
5799
	priv->timestamp = 0;
5800
	if ((priv->iw_mode == NL80211_IFTYPE_STATION))
Z
Zhu Yi 已提交
5801 5802 5803 5804
		priv->beacon_int = 0;

	spin_unlock_irqrestore(&priv->lock, flags);

5805
	if (!iwl_is_ready_rf(priv)) {
5806 5807 5808 5809 5810
		IWL_DEBUG_MAC80211("leave - not ready\n");
		mutex_unlock(&priv->mutex);
		return;
	}

5811 5812 5813
	/* we are restarting association process
	 * clear RXON_FILTER_ASSOC_MSK bit
	*/
5814
	if (priv->iw_mode != NL80211_IFTYPE_AP) {
5815
		iwl_scan_cancel_timeout(priv, 100);
5816
		priv->staging39_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
C
Christoph Hellwig 已提交
5817
		iwl3945_commit_rxon(priv);
5818 5819
	}

Z
Zhu Yi 已提交
5820
	/* Per mac80211.h: This is only used in IBSS mode... */
5821
	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
5822

Z
Zhu Yi 已提交
5823 5824 5825 5826 5827
		IWL_DEBUG_MAC80211("leave - not in IBSS\n");
		mutex_unlock(&priv->mutex);
		return;
	}

C
Christoph Hellwig 已提交
5828
	iwl3945_set_rate(priv);
Z
Zhu Yi 已提交
5829 5830 5831 5832 5833 5834 5835

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211("leave\n");

}

5836
static int iwl3945_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
Z
Zhu Yi 已提交
5837
{
5838
	struct iwl_priv *priv = hw->priv;
Z
Zhu Yi 已提交
5839 5840 5841 5842
	unsigned long flags;

	IWL_DEBUG_MAC80211("enter\n");

5843
	if (!iwl_is_ready_rf(priv)) {
Z
Zhu Yi 已提交
5844 5845 5846 5847
		IWL_DEBUG_MAC80211("leave - RF not ready\n");
		return -EIO;
	}

5848
	if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
Z
Zhu Yi 已提交
5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864
		IWL_DEBUG_MAC80211("leave - not IBSS\n");
		return -EIO;
	}

	spin_lock_irqsave(&priv->lock, flags);

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

	priv->ibss_beacon = skb;

	priv->assoc_id = 0;

	IWL_DEBUG_MAC80211("leave\n");
	spin_unlock_irqrestore(&priv->lock, flags);

5865
	iwl_reset_qos(priv);
Z
Zhu Yi 已提交
5866

5867
	iwl3945_post_associate(priv);
Z
Zhu Yi 已提交
5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878


	return 0;
}

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

5879
#ifdef CONFIG_IWL3945_DEBUG
Z
Zhu Yi 已提交
5880 5881 5882 5883 5884 5885 5886 5887

/*
 * 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.
 */
5888 5889
static ssize_t show_debug_level(struct device *d,
				struct device_attribute *attr, char *buf)
Z
Zhu Yi 已提交
5890
{
5891
	struct iwl_priv *priv = d->driver_data;
5892 5893

	return sprintf(buf, "0x%08X\n", priv->debug_level);
Z
Zhu Yi 已提交
5894
}
5895 5896
static ssize_t store_debug_level(struct device *d,
				struct device_attribute *attr,
Z
Zhu Yi 已提交
5897 5898
				 const char *buf, size_t count)
{
5899
	struct iwl_priv *priv = d->driver_data;
5900 5901
	unsigned long val;
	int ret;
Z
Zhu Yi 已提交
5902

5903 5904
	ret = strict_strtoul(buf, 0, &val);
	if (ret)
T
Tomas Winkler 已提交
5905
		IWL_INFO(priv, "%s is not in hex or decimal form.\n", buf);
Z
Zhu Yi 已提交
5906
	else
5907
		priv->debug_level = val;
Z
Zhu Yi 已提交
5908 5909 5910 5911

	return strnlen(buf, count);
}

5912 5913
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
			show_debug_level, store_debug_level);
Z
Zhu Yi 已提交
5914

5915
#endif /* CONFIG_IWL3945_DEBUG */
Z
Zhu Yi 已提交
5916 5917 5918 5919

static ssize_t show_temperature(struct device *d,
				struct device_attribute *attr, char *buf)
{
5920
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
5921

5922
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
5923 5924
		return -EAGAIN;

C
Christoph Hellwig 已提交
5925
	return sprintf(buf, "%d\n", iwl3945_hw_get_temperature(priv));
Z
Zhu Yi 已提交
5926 5927 5928 5929 5930 5931 5932
}

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

static ssize_t show_tx_power(struct device *d,
			     struct device_attribute *attr, char *buf)
{
5933
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
5934
	return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
Z
Zhu Yi 已提交
5935 5936 5937 5938 5939 5940
}

static ssize_t store_tx_power(struct device *d,
			      struct device_attribute *attr,
			      const char *buf, size_t count)
{
5941
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
5942 5943 5944 5945 5946
	char *p = (char *)buf;
	u32 val;

	val = simple_strtoul(p, &p, 10);
	if (p == buf)
T
Tomas Winkler 已提交
5947
		IWL_INFO(priv, ": %s is not in decimal form.\n", buf);
Z
Zhu Yi 已提交
5948
	else
C
Christoph Hellwig 已提交
5949
		iwl3945_hw_reg_set_txpower(priv, val);
Z
Zhu Yi 已提交
5950 5951 5952 5953 5954 5955 5956 5957 5958

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

5961
	return sprintf(buf, "0x%04X\n", priv->active39_rxon.flags);
Z
Zhu Yi 已提交
5962 5963 5964 5965 5966 5967
}

static ssize_t store_flags(struct device *d,
			   struct device_attribute *attr,
			   const char *buf, size_t count)
{
5968
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
5969 5970 5971
	u32 flags = simple_strtoul(buf, NULL, 0);

	mutex_lock(&priv->mutex);
5972
	if (le32_to_cpu(priv->staging39_rxon.flags) != flags) {
Z
Zhu Yi 已提交
5973
		/* Cancel any currently running scans... */
5974
		if (iwl_scan_cancel_timeout(priv, 100))
5975
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
5976 5977 5978
		else {
			IWL_DEBUG_INFO("Committing rxon.flags = 0x%04X\n",
				       flags);
5979
			priv->staging39_rxon.flags = cpu_to_le32(flags);
C
Christoph Hellwig 已提交
5980
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992
		}
	}
	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)
{
5993
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
5994 5995

	return sprintf(buf, "0x%04X\n",
5996
		le32_to_cpu(priv->active39_rxon.filter_flags));
Z
Zhu Yi 已提交
5997 5998 5999 6000 6001 6002
}

static ssize_t store_filter_flags(struct device *d,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
{
6003
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
Z
Zhu Yi 已提交
6004 6005 6006
	u32 filter_flags = simple_strtoul(buf, NULL, 0);

	mutex_lock(&priv->mutex);
6007
	if (le32_to_cpu(priv->staging39_rxon.filter_flags) != filter_flags) {
Z
Zhu Yi 已提交
6008
		/* Cancel any currently running scans... */
6009
		if (iwl_scan_cancel_timeout(priv, 100))
6010
			IWL_WARN(priv, "Could not cancel scan.\n");
Z
Zhu Yi 已提交
6011 6012 6013
		else {
			IWL_DEBUG_INFO("Committing rxon.filter_flags = "
				       "0x%04X\n", filter_flags);
6014
			priv->staging39_rxon.filter_flags =
Z
Zhu Yi 已提交
6015
				cpu_to_le32(filter_flags);
C
Christoph Hellwig 已提交
6016
			iwl3945_commit_rxon(priv);
Z
Zhu Yi 已提交
6017 6018 6019 6020 6021 6022 6023 6024 6025 6026
		}
	}
	mutex_unlock(&priv->mutex);

	return count;
}

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

6027
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
6028 6029 6030 6031

static ssize_t show_measurement(struct device *d,
				struct device_attribute *attr, char *buf)
{
6032
	struct iwl_priv *priv = dev_get_drvdata(d);
6033
	struct iwl_spectrum_notification measure_report;
Z
Zhu Yi 已提交
6034
	u32 size = sizeof(measure_report), len = 0, ofs = 0;
6035
	u8 *data = (u8 *)&measure_report;
Z
Zhu Yi 已提交
6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064
	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)
{
6065
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6066
	struct ieee80211_measurement_params params = {
6067
		.channel = le16_to_cpu(priv->active39_rxon.channel),
Z
Zhu Yi 已提交
6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090
		.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);
	}

	IWL_DEBUG_INFO("Invoking measurement of type %d on "
		       "channel %d (for '%s')\n", type, params.channel, buf);
C
Christoph Hellwig 已提交
6091
	iwl3945_get_measurement(priv, &params, type);
Z
Zhu Yi 已提交
6092 6093 6094 6095 6096 6097

	return count;
}

static DEVICE_ATTR(measurement, S_IRUSR | S_IWUSR,
		   show_measurement, store_measurement);
6098
#endif /* CONFIG_IWL3945_SPECTRUM_MEASUREMENT */
Z
Zhu Yi 已提交
6099 6100 6101 6102 6103

static ssize_t store_retry_rate(struct device *d,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
6104
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115

	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)
{
6116
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6117 6118 6119 6120 6121 6122 6123 6124 6125 6126
	return sprintf(buf, "%d", priv->retry_rate);
}

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

static ssize_t store_power_level(struct device *d,
				 struct device_attribute *attr,
				 const char *buf, size_t count)
{
6127
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6128 6129 6130 6131 6132 6133
	int rc;
	int mode;

	mode = simple_strtoul(buf, NULL, 0);
	mutex_lock(&priv->mutex);

6134
	if (!iwl_is_ready(priv)) {
Z
Zhu Yi 已提交
6135 6136 6137 6138
		rc = -EAGAIN;
		goto out;
	}

6139 6140 6141
	if ((mode < 1) || (mode > IWL39_POWER_LIMIT) ||
	    (mode == IWL39_POWER_AC))
		mode = IWL39_POWER_AC;
Z
Zhu Yi 已提交
6142 6143 6144 6145
	else
		mode |= IWL_POWER_ENABLED;

	if (mode != priv->power_mode) {
C
Christoph Hellwig 已提交
6146
		rc = iwl3945_send_power_mode(priv, IWL_POWER_LEVEL(mode));
Z
Zhu Yi 已提交
6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181
		if (rc) {
			IWL_DEBUG_MAC80211("failed setting power mode.\n");
			goto out;
		}
		priv->power_mode = mode;
	}

	rc = count;

 out:
	mutex_unlock(&priv->mutex);
	return rc;
}

#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_power_level(struct device *d,
				struct device_attribute *attr, char *buf)
{
6182
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6183 6184 6185 6186 6187 6188
	int level = IWL_POWER_LEVEL(priv->power_mode);
	char *p = buf;

	p += sprintf(p, "%d ", level);
	switch (level) {
	case IWL_POWER_MODE_CAM:
6189
	case IWL39_POWER_AC:
Z
Zhu Yi 已提交
6190 6191
		p += sprintf(p, "(AC)");
		break;
6192
	case IWL39_POWER_BATTERY:
Z
Zhu Yi 已提交
6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206
		p += sprintf(p, "(BATTERY)");
		break;
	default:
		p += sprintf(p,
			     "(Timeout %dms, Period %dms)",
			     timeout_duration[level - 1] / 1000,
			     period_duration[level - 1] / 1000);
	}

	if (!(priv->power_mode & IWL_POWER_ENABLED))
		p += sprintf(p, " OFF\n");
	else
		p += sprintf(p, " \n");

6207
	return p - buf + 1;
Z
Zhu Yi 已提交
6208 6209 6210 6211 6212 6213 6214 6215 6216

}

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

static ssize_t show_channels(struct device *d,
			     struct device_attribute *attr, char *buf)
{
6217 6218
	/* all this shit doesn't belong into sysfs anyway */
	return 0;
Z
Zhu Yi 已提交
6219 6220 6221 6222 6223 6224 6225
}

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

static ssize_t show_statistics(struct device *d,
			       struct device_attribute *attr, char *buf)
{
6226
	struct iwl_priv *priv = dev_get_drvdata(d);
C
Christoph Hellwig 已提交
6227
	u32 size = sizeof(struct iwl3945_notif_statistics);
Z
Zhu Yi 已提交
6228
	u32 len = 0, ofs = 0;
6229
	u8 *data = (u8 *)&priv->statistics_39;
Z
Zhu Yi 已提交
6230 6231
	int rc = 0;

6232
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
6233 6234 6235
		return -EAGAIN;

	mutex_lock(&priv->mutex);
C
Christoph Hellwig 已提交
6236
	rc = iwl3945_send_statistics_request(priv);
Z
Zhu Yi 已提交
6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263
	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)
{
6264
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6265

6266
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
6267 6268 6269 6270 6271 6272 6273 6274 6275 6276
		return -EAGAIN;

	return sprintf(buf, "%d\n", priv->antenna);
}

static ssize_t store_antenna(struct device *d,
			     struct device_attribute *attr,
			     const char *buf, size_t count)
{
	int ant;
6277
	struct iwl_priv *priv = dev_get_drvdata(d);
Z
Zhu Yi 已提交
6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288

	if (count == 0)
		return 0;

	if (sscanf(buf, "%1i", &ant) != 1) {
		IWL_DEBUG_INFO("not in hex or decimal form.\n");
		return count;
	}

	if ((ant >= 0) && (ant <= 2)) {
		IWL_DEBUG_INFO("Setting antenna select to %d.\n", ant);
C
Christoph Hellwig 已提交
6289
		priv->antenna = (enum iwl3945_antenna)ant;
Z
Zhu Yi 已提交
6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301
	} else
		IWL_DEBUG_INFO("Bad antenna select value %d.\n", ant);


	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)
{
6302
	struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
6303
	if (!iwl_is_alive(priv))
Z
Zhu Yi 已提交
6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316
		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)
{
	char *p = (char *)buf;

	if (p[0] == '1')
6317
		iwl3945_dump_nic_error_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330

	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)
{
	char *p = (char *)buf;

	if (p[0] == '1')
6331
		iwl3945_dump_nic_event_log((struct iwl_priv *)d->driver_data);
Z
Zhu Yi 已提交
6332 6333 6334 6335 6336 6337 6338 6339

	return strnlen(buf, count);
}

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

/*****************************************************************************
 *
T
Tomas Winkler 已提交
6340
 * driver setup and tear down
Z
Zhu Yi 已提交
6341 6342 6343
 *
 *****************************************************************************/

6344
static void iwl3945_setup_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
6345 6346 6347 6348 6349
{
	priv->workqueue = create_workqueue(DRV_NAME);

	init_waitqueue_head(&priv->wait_command_queue);

C
Christoph Hellwig 已提交
6350 6351 6352
	INIT_WORK(&priv->up, iwl3945_bg_up);
	INIT_WORK(&priv->restart, iwl3945_bg_restart);
	INIT_WORK(&priv->rx_replenish, iwl3945_bg_rx_replenish);
S
Samuel Ortiz 已提交
6353
	INIT_WORK(&priv->rf_kill, iwl_bg_rf_kill);
C
Christoph Hellwig 已提交
6354 6355 6356
	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);
6357
	INIT_DELAYED_WORK(&priv->rfkill_poll, iwl3945_rfkill_poll);
S
Samuel Ortiz 已提交
6358 6359 6360 6361
	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 已提交
6362 6363

	iwl3945_hw_setup_deferred_work(priv);
Z
Zhu Yi 已提交
6364 6365

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

6369
static void iwl3945_cancel_deferred_work(struct iwl_priv *priv)
Z
Zhu Yi 已提交
6370
{
C
Christoph Hellwig 已提交
6371
	iwl3945_hw_cancel_deferred_work(priv);
Z
Zhu Yi 已提交
6372

6373
	cancel_delayed_work_sync(&priv->init_alive_start);
Z
Zhu Yi 已提交
6374 6375 6376 6377 6378
	cancel_delayed_work(&priv->scan_check);
	cancel_delayed_work(&priv->alive_start);
	cancel_work_sync(&priv->beacon_update);
}

C
Christoph Hellwig 已提交
6379
static struct attribute *iwl3945_sysfs_entries[] = {
Z
Zhu Yi 已提交
6380 6381 6382 6383 6384 6385
	&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,
6386
#ifdef CONFIG_IWL3945_SPECTRUM_MEASUREMENT
Z
Zhu Yi 已提交
6387 6388 6389 6390 6391 6392 6393 6394
	&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,
6395 6396 6397
#ifdef CONFIG_IWL3945_DEBUG
	&dev_attr_debug_level.attr,
#endif
Z
Zhu Yi 已提交
6398 6399 6400
	NULL
};

C
Christoph Hellwig 已提交
6401
static struct attribute_group iwl3945_attribute_group = {
Z
Zhu Yi 已提交
6402
	.name = NULL,		/* put in device directory */
C
Christoph Hellwig 已提交
6403
	.attrs = iwl3945_sysfs_entries,
Z
Zhu Yi 已提交
6404 6405
};

C
Christoph Hellwig 已提交
6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418
static struct ieee80211_ops iwl3945_hw_ops = {
	.tx = iwl3945_mac_tx,
	.start = iwl3945_mac_start,
	.stop = iwl3945_mac_stop,
	.add_interface = iwl3945_mac_add_interface,
	.remove_interface = iwl3945_mac_remove_interface,
	.config = iwl3945_mac_config,
	.config_interface = iwl3945_mac_config_interface,
	.configure_filter = iwl3945_configure_filter,
	.set_key = iwl3945_mac_set_key,
	.get_tx_stats = iwl3945_mac_get_tx_stats,
	.conf_tx = iwl3945_mac_conf_tx,
	.reset_tsf = iwl3945_mac_reset_tsf,
6419
	.bss_info_changed = iwl3945_bss_info_changed,
C
Christoph Hellwig 已提交
6420
	.hw_scan = iwl3945_mac_hw_scan
Z
Zhu Yi 已提交
6421 6422
};

6423
static int iwl3945_init_drv(struct iwl_priv *priv)
6424 6425 6426 6427 6428 6429 6430
{
	int ret;

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

	spin_lock_init(&priv->lock);
6431
	spin_lock_init(&priv->power_data.lock);
6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455
	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 */
	iwl3945_clear_stations_table(priv);

	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;
	/* If power management is turned on, default to AC mode */
S
Samuel Ortiz 已提交
6456
	priv->power_mode = IWL39_POWER_AC;
6457
	priv->tx_power_user_lmt = IWL_DEFAULT_TX_POWER;
6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478

	ret = iwl3945_init_channel_map(priv);
	if (ret) {
		IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
		goto err;
	}

	ret = iwl3945_init_geos(priv);
	if (ret) {
		IWL_ERR(priv, "initializing geos failed: %d\n", ret);
		goto err_free_channel_map;
	}

	return 0;

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

C
Christoph Hellwig 已提交
6479
static int iwl3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
Z
Zhu Yi 已提交
6480 6481
{
	int err = 0;
6482
	struct iwl_priv *priv;
Z
Zhu Yi 已提交
6483
	struct ieee80211_hw *hw;
6484
	struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
6485
	unsigned long flags;
Z
Zhu Yi 已提交
6486

6487 6488 6489 6490
	/***********************
	 * 1. Allocating HW data
	 * ********************/

Z
Zhu Yi 已提交
6491 6492
	/* mac80211 allocates memory for this device instance, including
	 *   space for this driver's private structure */
6493
	hw = iwl_alloc_all(cfg, &iwl3945_hw_ops);
Z
Zhu Yi 已提交
6494
	if (hw == NULL) {
6495
		printk(KERN_ERR DRV_NAME "Can not allocate network device\n");
Z
Zhu Yi 已提交
6496 6497 6498 6499
		err = -ENOMEM;
		goto out;
	}
	priv = hw->priv;
6500
	SET_IEEE80211_DEV(hw, &pdev->dev);
6501

6502 6503
	if ((iwl3945_mod_params.num_of_queues > IWL39_MAX_NUM_QUEUES) ||
	     (iwl3945_mod_params.num_of_queues < IWL_MIN_NUM_QUEUES)) {
6504 6505 6506
		IWL_ERR(priv,
			"invalid queues_num, should be between %d and %d\n",
			IWL_MIN_NUM_QUEUES, IWL39_MAX_NUM_QUEUES);
6507 6508 6509 6510
		err = -EINVAL;
		goto out;
	}

6511 6512 6513 6514
	/*
	 * Disabling hardware scan means that mac80211 will perform scans
	 * "the hard way", rather than using device's scan.
	 */
6515
	if (iwl3945_mod_params.disable_hw_scan) {
6516 6517 6518 6519
		IWL_DEBUG_INFO("Disabling hw_scan\n");
		iwl3945_hw_ops.hw_scan = NULL;
	}

6520

6521
	IWL_DEBUG_INFO("*** LOAD DRIVER ***\n");
6522 6523
	priv->cfg = cfg;
	priv->pci_dev = pdev;
6524

6525
#ifdef CONFIG_IWL3945_DEBUG
6526
	priv->debug_level = iwl3945_mod_params.debug;
Z
Zhu Yi 已提交
6527 6528
	atomic_set(&priv->restrict_refcnt, 0);
#endif
6529 6530 6531 6532 6533
	hw->rate_control_algorithm = "iwl-3945-rs";
	hw->sta_data_size = sizeof(struct iwl3945_sta_priv);

	/* Select antenna (may be helpful if only one antenna is connected) */
	priv->antenna = (enum iwl3945_antenna)iwl3945_mod_params.antenna;
Z
Zhu Yi 已提交
6534

6535
	/* Tell mac80211 our characteristics */
6536
	hw->flags = IEEE80211_HW_SIGNAL_DBM |
6537
		    IEEE80211_HW_NOISE_DBM;
Z
Zhu Yi 已提交
6538

6539 6540 6541 6542
	hw->wiphy->interface_modes =
		BIT(NL80211_IFTYPE_STATION) |
		BIT(NL80211_IFTYPE_ADHOC);

6543
	hw->wiphy->custom_regulatory = true;
6544

6545
	/* 4 EDCA QOS priorities */
Z
Zhu Yi 已提交
6546 6547
	hw->queues = 4;

6548 6549 6550
	/***************************
	 * 2. Initializing PCI bus
	 * *************************/
Z
Zhu Yi 已提交
6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

	err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
	if (!err)
		err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
	if (err) {
T
Tomas Winkler 已提交
6562
		IWL_WARN(priv, "No suitable DMA available.\n");
Z
Zhu Yi 已提交
6563 6564 6565 6566 6567 6568 6569
		goto out_pci_disable_device;
	}

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

6571 6572 6573
	/***********************
	 * 3. Read REV Register
	 * ********************/
Z
Zhu Yi 已提交
6574 6575 6576 6577 6578 6579 6580 6581 6582 6583
	priv->hw_base = pci_iomap(pdev, 0, 0);
	if (!priv->hw_base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

	IWL_DEBUG_INFO("pci_resource_len = 0x%08llx\n",
			(unsigned long long) pci_resource_len(pdev, 0));
	IWL_DEBUG_INFO("pci_resource_base = %p\n", priv->hw_base);

6584 6585 6586
	/* 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 已提交
6587

6588 6589
	/* amp init */
	err = priv->cfg->ops->lib->apm_ops.init(priv);
6590
	if (err < 0) {
6591 6592
		IWL_DEBUG_INFO("Failed to init APMG\n");
		goto out_iounmap;
6593
	}
Z
Zhu Yi 已提交
6594

6595 6596 6597
	/***********************
	 * 4. Read EEPROM
	 * ********************/
6598

6599 6600 6601
	/* Read the EEPROM */
	err = iwl3945_eeprom_init(priv);
	if (err) {
6602
		IWL_ERR(priv, "Unable to init EEPROM\n");
6603 6604 6605 6606 6607 6608
		goto out_remove_sysfs;
	}
	/* MAC Address location in EEPROM same for 3945/4965 */
	get_eeprom_mac(priv, priv->mac_addr);
	IWL_DEBUG_INFO("MAC address: %pM\n", priv->mac_addr);
	SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
Z
Zhu Yi 已提交
6609

6610 6611 6612
	/***********************
	 * 5. Setup HW Constants
	 * ********************/
Z
Zhu Yi 已提交
6613
	/* Device-specific setup */
6614
	if (iwl3945_hw_set_hw_params(priv)) {
6615
		IWL_ERR(priv, "failed to set hw settings\n");
Z
Zhu Yi 已提交
6616 6617 6618
		goto out_iounmap;
	}

6619 6620 6621 6622
	/***********************
	 * 6. Setup priv
	 * ********************/

6623
	err = iwl3945_init_drv(priv);
Z
Zhu Yi 已提交
6624
	if (err) {
6625 6626
		IWL_ERR(priv, "initializing driver failed\n");
		goto out_free_geos;
Z
Zhu Yi 已提交
6627 6628
	}

T
Tomas Winkler 已提交
6629 6630
	IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s\n",
		priv->cfg->name);
6631 6632 6633 6634 6635 6636 6637

	/***********************************
	 * 7. Initialize Module Parameters
	 * **********************************/

	/* Initialize module parameter values here */
	/* Disable radio (SW RF KILL) via parameter when loading driver */
6638
	if (iwl3945_mod_params.disable) {
6639 6640
		set_bit(STATUS_RF_KILL_SW, &priv->status);
		IWL_DEBUG_INFO("Radio disabled.\n");
6641 6642
	}

6643 6644 6645 6646 6647 6648 6649 6650 6651

	/***********************
	 * 8. Setup Services
	 * ********************/

	spin_lock_irqsave(&priv->lock, flags);
	iwl3945_disable_interrupts(priv);
	spin_unlock_irqrestore(&priv->lock, flags);

6652 6653 6654 6655 6656 6657 6658 6659 6660
	pci_enable_msi(priv->pci_dev);

	err = request_irq(priv->pci_dev->irq, iwl3945_isr, IRQF_SHARED,
			  DRV_NAME, priv);
	if (err) {
		IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
		goto out_disable_msi;
	}

6661
	err = sysfs_create_group(&pdev->dev.kobj, &iwl3945_attribute_group);
6662
	if (err) {
6663
		IWL_ERR(priv, "failed to create sysfs device attributes\n");
6664
		goto out_release_irq;
6665 6666
	}

6667 6668 6669 6670 6671
	iwl3945_set_rxon_channel(priv, IEEE80211_BAND_2GHZ, 6);
	iwl3945_setup_deferred_work(priv);
	iwl3945_setup_rx_handlers(priv);

	/*********************************
6672
	 * 9. Setup and Register mac80211
6673 6674
	 * *******************************/

6675 6676
	err = ieee80211_register_hw(priv->hw);
	if (err) {
6677
		IWL_ERR(priv, "Failed to register network device: %d\n", err);
6678
		goto  out_remove_sysfs;
6679
	}
Z
Zhu Yi 已提交
6680

6681 6682
	priv->hw->conf.beacon_int = 100;
	priv->mac80211_registered = 1;
6683

S
Samuel Ortiz 已提交
6684
	err = iwl_rfkill_init(priv);
6685
	if (err)
6686
		IWL_ERR(priv, "Unable to initialize RFKILL system. "
6687 6688
				  "Ignoring error: %d\n", err);

6689 6690 6691 6692
	/* Start monitoring the killswitch */
	queue_delayed_work(priv->workqueue, &priv->rfkill_poll,
			   2 * HZ);

Z
Zhu Yi 已提交
6693 6694
	return 0;

6695 6696
 out_remove_sysfs:
	sysfs_remove_group(&pdev->dev.kobj, &iwl3945_attribute_group);
6697 6698
 out_free_geos:
	iwl3945_free_geos(priv);
Z
Zhu Yi 已提交
6699 6700

 out_release_irq:
6701
	free_irq(priv->pci_dev->irq, priv);
Z
Zhu Yi 已提交
6702 6703
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
6704
	iwl3945_unset_hw_params(priv);
6705 6706
 out_disable_msi:
	pci_disable_msi(priv->pci_dev);
Z
Zhu Yi 已提交
6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719
 out_iounmap:
	pci_iounmap(pdev, priv->hw_base);
 out_pci_release_regions:
	pci_release_regions(pdev);
 out_pci_disable_device:
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);
 out_ieee80211_free_hw:
	ieee80211_free_hw(priv->hw);
 out:
	return err;
}

6720
static void __devexit iwl3945_pci_remove(struct pci_dev *pdev)
Z
Zhu Yi 已提交
6721
{
6722
	struct iwl_priv *priv = pci_get_drvdata(pdev);
6723
	unsigned long flags;
Z
Zhu Yi 已提交
6724 6725 6726 6727 6728 6729 6730

	if (!priv)
		return;

	IWL_DEBUG_INFO("*** UNLOAD DRIVER ***\n");

	set_bit(STATUS_EXIT_PENDING, &priv->status);
6731

6732 6733 6734 6735 6736 6737
	if (priv->mac80211_registered) {
		ieee80211_unregister_hw(priv->hw);
		priv->mac80211_registered = 0;
	} else {
		iwl3945_down(priv);
	}
Z
Zhu Yi 已提交
6738

6739 6740 6741 6742 6743 6744 6745 6746 6747
	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
	spin_lock_irqsave(&priv->lock, flags);
	iwl3945_disable_interrupts(priv);
	spin_unlock_irqrestore(&priv->lock, flags);

	iwl_synchronize_irq(priv);

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

S
Samuel Ortiz 已提交
6750
	iwl_rfkill_unregister(priv);
6751 6752
	cancel_delayed_work(&priv->rfkill_poll);

C
Christoph Hellwig 已提交
6753
	iwl3945_dealloc_ucode_pci(priv);
Z
Zhu Yi 已提交
6754 6755

	if (priv->rxq.bd)
6756
		iwl_rx_queue_free(priv, &priv->rxq);
C
Christoph Hellwig 已提交
6757
	iwl3945_hw_txq_ctx_free(priv);
Z
Zhu Yi 已提交
6758

6759
	iwl3945_unset_hw_params(priv);
C
Christoph Hellwig 已提交
6760
	iwl3945_clear_stations_table(priv);
Z
Zhu Yi 已提交
6761

6762 6763 6764
	/*netif_stop_queue(dev); */
	flush_workqueue(priv->workqueue);

C
Christoph Hellwig 已提交
6765
	/* ieee80211_unregister_hw calls iwl3945_mac_stop, which flushes
Z
Zhu Yi 已提交
6766 6767 6768 6769 6770
	 * priv->workqueue... so we can't take down the workqueue
	 * until now... */
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;

6771 6772 6773
	free_irq(pdev->irq, priv);
	pci_disable_msi(pdev);

Z
Zhu Yi 已提交
6774 6775 6776 6777 6778
	pci_iounmap(pdev, priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

6779 6780
	iwl3945_free_channel_map(priv);
	iwl3945_free_geos(priv);
W
Winkler, Tomas 已提交
6781
	kfree(priv->scan);
Z
Zhu Yi 已提交
6782 6783 6784 6785 6786 6787 6788 6789
	if (priv->ibss_beacon)
		dev_kfree_skb(priv->ibss_beacon);

	ieee80211_free_hw(priv->hw);
}

#ifdef CONFIG_PM

C
Christoph Hellwig 已提交
6790
static int iwl3945_pci_suspend(struct pci_dev *pdev, pm_message_t state)
Z
Zhu Yi 已提交
6791
{
6792
	struct iwl_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
6793

6794 6795 6796 6797 6798
	if (priv->is_open) {
		set_bit(STATUS_IN_SUSPEND, &priv->status);
		iwl3945_mac_stop(priv->hw);
		priv->is_open = 1;
	}
6799 6800
	pci_save_state(pdev);
	pci_disable_device(pdev);
Z
Zhu Yi 已提交
6801 6802 6803 6804 6805
	pci_set_power_state(pdev, PCI_D3hot);

	return 0;
}

C
Christoph Hellwig 已提交
6806
static int iwl3945_pci_resume(struct pci_dev *pdev)
Z
Zhu Yi 已提交
6807
{
6808
	struct iwl_priv *priv = pci_get_drvdata(pdev);
Z
Zhu Yi 已提交
6809 6810

	pci_set_power_state(pdev, PCI_D0);
6811 6812
	pci_enable_device(pdev);
	pci_restore_state(pdev);
Z
Zhu Yi 已提交
6813

6814 6815
	if (priv->is_open)
		iwl3945_mac_start(priv->hw);
Z
Zhu Yi 已提交
6816

6817
	clear_bit(STATUS_IN_SUSPEND, &priv->status);
Z
Zhu Yi 已提交
6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828
	return 0;
}

#endif /* CONFIG_PM */

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

C
Christoph Hellwig 已提交
6829
static struct pci_driver iwl3945_driver = {
Z
Zhu Yi 已提交
6830
	.name = DRV_NAME,
C
Christoph Hellwig 已提交
6831 6832 6833
	.id_table = iwl3945_hw_card_ids,
	.probe = iwl3945_pci_probe,
	.remove = __devexit_p(iwl3945_pci_remove),
Z
Zhu Yi 已提交
6834
#ifdef CONFIG_PM
C
Christoph Hellwig 已提交
6835 6836
	.suspend = iwl3945_pci_suspend,
	.resume = iwl3945_pci_resume,
Z
Zhu Yi 已提交
6837 6838 6839
#endif
};

C
Christoph Hellwig 已提交
6840
static int __init iwl3945_init(void)
Z
Zhu Yi 已提交
6841 6842 6843 6844 6845
{

	int ret;
	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
6846 6847 6848

	ret = iwl3945_rate_control_register();
	if (ret) {
6849 6850
		printk(KERN_ERR DRV_NAME
		       "Unable to register rate control algorithm: %d\n", ret);
6851 6852 6853
		return ret;
	}

C
Christoph Hellwig 已提交
6854
	ret = pci_register_driver(&iwl3945_driver);
Z
Zhu Yi 已提交
6855
	if (ret) {
6856
		printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
6857
		goto error_register;
Z
Zhu Yi 已提交
6858 6859 6860
	}

	return ret;
6861 6862 6863 6864

error_register:
	iwl3945_rate_control_unregister();
	return ret;
Z
Zhu Yi 已提交
6865 6866
}

C
Christoph Hellwig 已提交
6867
static void __exit iwl3945_exit(void)
Z
Zhu Yi 已提交
6868
{
C
Christoph Hellwig 已提交
6869
	pci_unregister_driver(&iwl3945_driver);
6870
	iwl3945_rate_control_unregister();
Z
Zhu Yi 已提交
6871 6872
}

6873
MODULE_FIRMWARE(IWL3945_MODULE_FIRMWARE(IWL3945_UCODE_API_MAX));
6874

6875
module_param_named(antenna, iwl3945_mod_params.antenna, int, 0444);
Z
Zhu Yi 已提交
6876
MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
6877
module_param_named(disable, iwl3945_mod_params.disable, int, 0444);
Z
Zhu Yi 已提交
6878
MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
6879 6880 6881
module_param_named(swcrypto, iwl3945_mod_params.sw_crypto, int, 0444);
MODULE_PARM_DESC(swcrypto,
		 "using software crypto (default 1 [software])\n");
6882
module_param_named(debug, iwl3945_mod_params.debug, uint, 0444);
Z
Zhu Yi 已提交
6883
MODULE_PARM_DESC(debug, "debug output mask");
6884
module_param_named(disable_hw_scan, iwl3945_mod_params.disable_hw_scan, int, 0444);
Z
Zhu Yi 已提交
6885 6886
MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 0)");

6887
module_param_named(queues_num, iwl3945_mod_params.num_of_queues, int, 0444);
Z
Zhu Yi 已提交
6888 6889
MODULE_PARM_DESC(queues_num, "number of hw queues.");

C
Christoph Hellwig 已提交
6890 6891
module_exit(iwl3945_exit);
module_init(iwl3945_init);