ipw2200.c 312.8 KB
Newer Older
J
James Ketrenos 已提交
1
/******************************************************************************
2

3
  Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
J
James Ketrenos 已提交
4 5 6 7 8 9 10

  802.11 status code portion of this file from ethereal-0.10.6:
    Copyright 2000, Axis Communications AB
    Ethereal - Network traffic analyzer
    By Gerald Combs <gerald@ethereal.com>
    Copyright 1998 Gerald Combs

11 12
  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
J
James Ketrenos 已提交
13
  published by the Free Software Foundation.
14 15 16 17

  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
J
James Ketrenos 已提交
18
  more details.
19

J
James Ketrenos 已提交
20
  You should have received a copy of the GNU General Public License along with
21
  this program; if not, write to the Free Software Foundation, Inc., 59
J
James Ketrenos 已提交
22
  Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23

J
James Ketrenos 已提交
24 25
  The full GNU General Public License is included in this distribution in the
  file called LICENSE.
26

J
James Ketrenos 已提交
27 28 29 30 31 32 33 34
  Contact Information:
  James P. Ketrenos <ipw2100-admin@linux.intel.com>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

******************************************************************************/

#include "ipw2200.h"

35
#define IPW2200_VERSION "1.0.5"
J
James Ketrenos 已提交
36
#define DRV_DESCRIPTION	"Intel(R) PRO/Wireless 2200/2915 Network Driver"
37
#define DRV_COPYRIGHT	"Copyright(c) 2003-2005 Intel Corporation"
J
James Ketrenos 已提交
38 39
#define DRV_VERSION     IPW2200_VERSION

40 41
#define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)

J
James Ketrenos 已提交
42 43 44 45 46
MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_VERSION(DRV_VERSION);
MODULE_AUTHOR(DRV_COPYRIGHT);
MODULE_LICENSE("GPL");

47
static int cmdlog = 0;
J
James Ketrenos 已提交
48 49 50 51 52 53 54
static int debug = 0;
static int channel = 0;
static int mode = 0;

static u32 ipw_debug_level;
static int associate = 1;
static int auto_create = 1;
55
static int led = 0;
J
James Ketrenos 已提交
56
static int disable = 0;
57
static int hwcrypto = 1;
J
James Ketrenos 已提交
58 59 60 61
static const char ipw_modes[] = {
	'a', 'b', 'g', '?'
};

62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
#ifdef CONFIG_IPW_QOS
static int qos_enable = 0;
static int qos_burst_enable = 0;
static int qos_no_ack_mask = 0;
static int burst_duration_CCK = 0;
static int burst_duration_OFDM = 0;

static struct ieee80211_qos_parameters def_qos_parameters_OFDM = {
	{QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
	 QOS_TX3_CW_MIN_OFDM},
	{QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
	 QOS_TX3_CW_MAX_OFDM},
	{QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
	{QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
	{QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
	 QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
};

static struct ieee80211_qos_parameters def_qos_parameters_CCK = {
	{QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
	 QOS_TX3_CW_MIN_CCK},
	{QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
	 QOS_TX3_CW_MAX_CCK},
	{QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
	{QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
	{QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
	 QOS_TX3_TXOP_LIMIT_CCK}
};

static struct ieee80211_qos_parameters def_parameters_OFDM = {
	{DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
	 DEF_TX3_CW_MIN_OFDM},
	{DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
	 DEF_TX3_CW_MAX_OFDM},
	{DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
	{DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
	{DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
	 DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
};

static struct ieee80211_qos_parameters def_parameters_CCK = {
	{DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
	 DEF_TX3_CW_MIN_CCK},
	{DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
	 DEF_TX3_CW_MAX_CCK},
	{DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
	{DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
	{DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
	 DEF_TX3_TXOP_LIMIT_CCK}
};

static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };

static int from_priority_to_tx_queue[] = {
	IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
	IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
};

static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);

static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
				       *qos_param);
static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
				     *qos_param);
#endif				/* CONFIG_IPW_QOS */

static void ipw_remove_current_network(struct ipw_priv *priv);
J
James Ketrenos 已提交
129
static void ipw_rx(struct ipw_priv *priv);
130
static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
J
James Ketrenos 已提交
131 132 133 134 135 136 137 138 139 140 141 142
				struct clx2_tx_queue *txq, int qindex);
static int ipw_queue_reset(struct ipw_priv *priv);

static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
			     int len, int sync);

static void ipw_tx_queue_free(struct ipw_priv *);

static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
static void ipw_rx_queue_replenish(void *);
static int ipw_up(struct ipw_priv *);
143
static void ipw_bg_up(void *);
J
James Ketrenos 已提交
144
static void ipw_down(struct ipw_priv *);
145
static void ipw_bg_down(void *);
J
James Ketrenos 已提交
146
static int ipw_config(struct ipw_priv *);
147 148
static int init_supported_rates(struct ipw_priv *priv,
				struct ipw_supported_rates *prates);
149 150
static void ipw_set_hwcrypto_keys(struct ipw_priv *);
static void ipw_send_wep_keys(struct ipw_priv *, int);
J
James Ketrenos 已提交
151

152 153 154 155 156 157
static int ipw_is_valid_channel(struct ieee80211_device *, u8);
static int ipw_channel_to_index(struct ieee80211_device *, u8);
static u8 ipw_freq_to_channel(struct ieee80211_device *, u32);
static int ipw_set_geo(struct ieee80211_device *, const struct ieee80211_geo *);
static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *);

158 159
static int snprint_line(char *buf, size_t count,
			const u8 * data, u32 len, u32 ofs)
J
James Ketrenos 已提交
160 161 162
{
	int out, i, j, l;
	char c;
163

J
James Ketrenos 已提交
164 165 166 167
	out = snprintf(buf, count, "%08X", ofs);

	for (l = 0, i = 0; i < 2; i++) {
		out += snprintf(buf + out, count - out, " ");
168 169
		for (j = 0; j < 8 && l < len; j++, l++)
			out += snprintf(buf + out, count - out, "%02X ",
J
James Ketrenos 已提交
170 171 172 173
					data[(i * 8 + j)]);
		for (; j < 8; j++)
			out += snprintf(buf + out, count - out, "   ");
	}
174

J
James Ketrenos 已提交
175 176 177 178 179 180 181
	out += snprintf(buf + out, count - out, " ");
	for (l = 0, i = 0; i < 2; i++) {
		out += snprintf(buf + out, count - out, " ");
		for (j = 0; j < 8 && l < len; j++, l++) {
			c = data[(i * 8 + j)];
			if (!isascii(c) || !isprint(c))
				c = '.';
182

J
James Ketrenos 已提交
183 184 185 186 187 188
			out += snprintf(buf + out, count - out, "%c", c);
		}

		for (; j < 8; j++)
			out += snprintf(buf + out, count - out, " ");
	}
189

190
	return out;
J
James Ketrenos 已提交
191 192
}

193
static void printk_buf(int level, const u8 * data, u32 len)
J
James Ketrenos 已提交
194 195 196 197 198 199 200
{
	char line[81];
	u32 ofs = 0;
	if (!(ipw_debug_level & level))
		return;

	while (len) {
201 202 203
		snprint_line(line, sizeof(line), &data[ofs],
			     min(len, 16U), ofs);
		printk(KERN_DEBUG "%s\n", line);
J
James Ketrenos 已提交
204 205 206 207 208
		ofs += 16;
		len -= min(len, 16U);
	}
}

209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
{
	size_t out = size;
	u32 ofs = 0;
	int total = 0;

	while (size && len) {
		out = snprint_line(output, size, &data[ofs],
				   min_t(size_t, len, 16U), ofs);

		ofs += 16;
		output += out;
		size -= out;
		len -= min_t(size_t, len, 16U);
		total += out;
	}
	return total;
}

J
James Ketrenos 已提交
228 229 230 231 232 233 234 235 236
static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
#define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)

static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
#define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)

static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
{
237 238
	IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
		     __LINE__, (u32) (b), (u32) (c));
J
James Ketrenos 已提交
239 240 241 242 243 244
	_ipw_write_reg8(a, b, c);
}

static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
{
245 246
	IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
		     __LINE__, (u32) (b), (u32) (c));
J
James Ketrenos 已提交
247 248 249 250 251 252
	_ipw_write_reg16(a, b, c);
}

static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
{
253 254
	IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
		     __LINE__, (u32) (b), (u32) (c));
J
James Ketrenos 已提交
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
	_ipw_write_reg32(a, b, c);
}

#define _ipw_write8(ipw, ofs, val) writeb((val), (ipw)->hw_base + (ofs))
#define ipw_write8(ipw, ofs, val) \
 IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
 _ipw_write8(ipw, ofs, val)

#define _ipw_write16(ipw, ofs, val) writew((val), (ipw)->hw_base + (ofs))
#define ipw_write16(ipw, ofs, val) \
 IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
 _ipw_write16(ipw, ofs, val)

#define _ipw_write32(ipw, ofs, val) writel((val), (ipw)->hw_base + (ofs))
#define ipw_write32(ipw, ofs, val) \
 IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, __LINE__, (u32)(ofs), (u32)(val)); \
 _ipw_write32(ipw, ofs, val)

#define _ipw_read8(ipw, ofs) readb((ipw)->hw_base + (ofs))
274 275 276
static inline u8 __ipw_read8(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
{
	IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", f, l, (u32) (ofs));
J
James Ketrenos 已提交
277 278
	return _ipw_read8(ipw, ofs);
}
279

J
James Ketrenos 已提交
280 281 282
#define ipw_read8(ipw, ofs) __ipw_read8(__FILE__, __LINE__, ipw, ofs)

#define _ipw_read16(ipw, ofs) readw((ipw)->hw_base + (ofs))
283 284 285
static inline u16 __ipw_read16(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
{
	IPW_DEBUG_IO("%s %d: read_direct16(0x%08X)\n", f, l, (u32) (ofs));
J
James Ketrenos 已提交
286 287
	return _ipw_read16(ipw, ofs);
}
288

J
James Ketrenos 已提交
289 290 291
#define ipw_read16(ipw, ofs) __ipw_read16(__FILE__, __LINE__, ipw, ofs)

#define _ipw_read32(ipw, ofs) readl((ipw)->hw_base + (ofs))
292 293 294
static inline u32 __ipw_read32(char *f, u32 l, struct ipw_priv *ipw, u32 ofs)
{
	IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", f, l, (u32) (ofs));
J
James Ketrenos 已提交
295 296
	return _ipw_read32(ipw, ofs);
}
297

J
James Ketrenos 已提交
298 299 300
#define ipw_read32(ipw, ofs) __ipw_read32(__FILE__, __LINE__, ipw, ofs)

static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
301 302 303 304 305 306 307 308 309
static inline void __ipw_read_indirect(const char *f, int l,
				       struct ipw_priv *a, u32 b, u8 * c, int d)
{
	IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %d bytes\n", f, l, (u32) (b),
		     d);
	_ipw_read_indirect(a, b, c, d);
}

#define ipw_read_indirect(a, b, c, d) __ipw_read_indirect(__FILE__, __LINE__, a, b, c, d)
J
James Ketrenos 已提交
310

311 312
static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
				int num);
J
James Ketrenos 已提交
313 314
#define ipw_write_indirect(a, b, c, d) \
	IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %d bytes\n", __FILE__, __LINE__, (u32)(b), d); \
315
	_ipw_write_indirect(a, b, c, d)
J
James Ketrenos 已提交
316 317

/* indirect write s */
318
static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
J
James Ketrenos 已提交
319
{
320
	IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
321 322
	_ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
	_ipw_write32(priv, IPW_INDIRECT_DATA, value);
J
James Ketrenos 已提交
323 324 325 326 327
}

static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
{
	IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
328 329
	_ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
	_ipw_write8(priv, IPW_INDIRECT_DATA, value);
J
James Ketrenos 已提交
330 331
}

332
static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
J
James Ketrenos 已提交
333 334
{
	IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
335 336
	_ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
	_ipw_write16(priv, IPW_INDIRECT_DATA, value);
J
James Ketrenos 已提交
337 338 339 340 341 342 343
}

/* indirect read s */

static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
{
	u32 word;
344
	_ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
J
James Ketrenos 已提交
345
	IPW_DEBUG_IO(" reg = 0x%8X : \n", reg);
346
	word = _ipw_read32(priv, IPW_INDIRECT_DATA);
347
	return (word >> ((reg & 0x3) * 8)) & 0xff;
J
James Ketrenos 已提交
348 349 350 351 352 353 354 355
}

static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
{
	u32 value;

	IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);

356 357
	_ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
	value = _ipw_read32(priv, IPW_INDIRECT_DATA);
J
James Ketrenos 已提交
358 359 360 361 362 363 364 365
	IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x \n", reg, value);
	return value;
}

/* iterative/auto-increment 32 bit reads and writes */
static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
			       int num)
{
366
	u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
J
James Ketrenos 已提交
367 368
	u32 dif_len = addr - aligned_addr;
	u32 i;
369

J
James Ketrenos 已提交
370 371
	IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);

372 373 374 375
	if (num <= 0) {
		return;
	}

J
James Ketrenos 已提交
376 377
	/* Read the first nibble byte by byte */
	if (unlikely(dif_len)) {
378
		_ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
379 380
		/* Start reading at aligned_addr + dif_len */
		for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
381
			*buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
J
James Ketrenos 已提交
382 383 384
		aligned_addr += 4;
	}

385
	_ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
386
	for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
387
		*(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
388

J
James Ketrenos 已提交
389
	/* Copy the last nibble */
390
	if (unlikely(num)) {
391
		_ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
392
		for (i = 0; num > 0; i++, num--)
393
			*buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
394
	}
J
James Ketrenos 已提交
395 396
}

397
static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
J
James Ketrenos 已提交
398 399
				int num)
{
400
	u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;
J
James Ketrenos 已提交
401 402
	u32 dif_len = addr - aligned_addr;
	u32 i;
403

J
James Ketrenos 已提交
404
	IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
405

406 407 408 409
	if (num <= 0) {
		return;
	}

J
James Ketrenos 已提交
410 411
	/* Write the first nibble byte by byte */
	if (unlikely(dif_len)) {
412
		_ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
413 414
		/* Start reading at aligned_addr + dif_len */
		for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
415
			_ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
J
James Ketrenos 已提交
416 417
		aligned_addr += 4;
	}
418

419
	_ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
420
	for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
421
		_ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
422

J
James Ketrenos 已提交
423
	/* Copy the last nibble */
424
	if (unlikely(num)) {
425
		_ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
426
		for (i = 0; num > 0; i++, num--, buf++)
427
			_ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
428
	}
J
James Ketrenos 已提交
429 430
}

431
static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
J
James Ketrenos 已提交
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
			     int num)
{
	memcpy_toio((priv->hw_base + addr), buf, num);
}

static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
{
	ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
}

static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
{
	ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
}

static inline void ipw_enable_interrupts(struct ipw_priv *priv)
{
	if (priv->status & STATUS_INT_ENABLED)
		return;
	priv->status |= STATUS_INT_ENABLED;
452
	ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
J
James Ketrenos 已提交
453 454 455 456 457 458 459
}

static inline void ipw_disable_interrupts(struct ipw_priv *priv)
{
	if (!(priv->status & STATUS_INT_ENABLED))
		return;
	priv->status &= ~STATUS_INT_ENABLED;
460
	ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
J
James Ketrenos 已提交
461 462
}

463
#ifdef CONFIG_IPW_DEBUG
J
James Ketrenos 已提交
464 465 466
static char *ipw_error_desc(u32 val)
{
	switch (val) {
467
	case IPW_FW_ERROR_OK:
J
James Ketrenos 已提交
468
		return "ERROR_OK";
469
	case IPW_FW_ERROR_FAIL:
J
James Ketrenos 已提交
470
		return "ERROR_FAIL";
471
	case IPW_FW_ERROR_MEMORY_UNDERFLOW:
J
James Ketrenos 已提交
472
		return "MEMORY_UNDERFLOW";
473
	case IPW_FW_ERROR_MEMORY_OVERFLOW:
J
James Ketrenos 已提交
474
		return "MEMORY_OVERFLOW";
475
	case IPW_FW_ERROR_BAD_PARAM:
476
		return "BAD_PARAM";
477
	case IPW_FW_ERROR_BAD_CHECKSUM:
478
		return "BAD_CHECKSUM";
479
	case IPW_FW_ERROR_NMI_INTERRUPT:
480
		return "NMI_INTERRUPT";
481
	case IPW_FW_ERROR_BAD_DATABASE:
482
		return "BAD_DATABASE";
483
	case IPW_FW_ERROR_ALLOC_FAIL:
484
		return "ALLOC_FAIL";
485
	case IPW_FW_ERROR_DMA_UNDERRUN:
486
		return "DMA_UNDERRUN";
487
	case IPW_FW_ERROR_DMA_STATUS:
488 489 490 491 492
		return "DMA_STATUS";
	case IPW_FW_ERROR_DINO_ERROR:
		return "DINO_ERROR";
	case IPW_FW_ERROR_EEPROM_ERROR:
		return "EEPROM_ERROR";
493
	case IPW_FW_ERROR_SYSASSERT:
494
		return "SYSASSERT";
495
	case IPW_FW_ERROR_FATAL_ERROR:
496
		return "FATAL_ERROR";
497
	default:
498
		return "UNKNOWN_ERROR";
J
James Ketrenos 已提交
499 500 501
	}
}

502 503
static void ipw_dump_error_log(struct ipw_priv *priv,
			       struct ipw_fw_error *error)
J
James Ketrenos 已提交
504
{
505
	u32 i;
506

507 508 509 510
	if (!error) {
		IPW_ERROR("Error allocating and capturing error log.  "
			  "Nothing to dump.\n");
		return;
J
James Ketrenos 已提交
511 512
	}

513 514 515
	IPW_ERROR("Start IPW Error Log Dump:\n");
	IPW_ERROR("Status: 0x%08X, Config: %08X\n",
		  error->status, error->config);
J
James Ketrenos 已提交
516

517
	for (i = 0; i < error->elem_len; i++)
518
		IPW_ERROR("%s %i 0x%08x  0x%08x  0x%08x  0x%08x  0x%08x\n",
519 520 521 522 523 524 525 526 527 528
			  ipw_error_desc(error->elem[i].desc),
			  error->elem[i].time,
			  error->elem[i].blink1,
			  error->elem[i].blink2,
			  error->elem[i].link1,
			  error->elem[i].link2, error->elem[i].data);
	for (i = 0; i < error->log_len; i++)
		IPW_ERROR("%i\t0x%08x\t%i\n",
			  error->log[i].time,
			  error->log[i].event, error->log[i].data);
J
James Ketrenos 已提交
529 530 531
}
#endif

532 533 534 535 536
static inline int ipw_is_init(struct ipw_priv *priv)
{
	return (priv->status & STATUS_INIT) ? 1 : 0;
}

537
static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
J
James Ketrenos 已提交
538 539 540 541 542 543 544 545 546
{
	u32 addr, field_info, field_len, field_count, total_len;

	IPW_DEBUG_ORD("ordinal = %i\n", ord);

	if (!priv || !val || !len) {
		IPW_DEBUG_ORD("Invalid argument\n");
		return -EINVAL;
	}
547

J
James Ketrenos 已提交
548 549 550 551 552 553 554 555 556 557 558
	/* verify device ordinal tables have been initialized */
	if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
		IPW_DEBUG_ORD("Access ordinals before initialization\n");
		return -EINVAL;
	}

	switch (IPW_ORD_TABLE_ID_MASK & ord) {
	case IPW_ORD_TABLE_0_MASK:
		/*
		 * TABLE 0: Direct access to a table of 32 bit values
		 *
559
		 * This is a very simple table with the data directly
J
James Ketrenos 已提交
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
		 * read from the table
		 */

		/* remove the table id from the ordinal */
		ord &= IPW_ORD_TABLE_VALUE_MASK;

		/* boundary check */
		if (ord > priv->table0_len) {
			IPW_DEBUG_ORD("ordinal value (%i) longer then "
				      "max (%i)\n", ord, priv->table0_len);
			return -EINVAL;
		}

		/* verify we have enough room to store the value */
		if (*len < sizeof(u32)) {
			IPW_DEBUG_ORD("ordinal buffer length too small, "
576
				      "need %zd\n", sizeof(u32));
J
James Ketrenos 已提交
577 578 579 580
			return -EINVAL;
		}

		IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
581
			      ord, priv->table0_addr + (ord << 2));
J
James Ketrenos 已提交
582 583 584

		*len = sizeof(u32);
		ord <<= 2;
585
		*((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
J
James Ketrenos 已提交
586 587 588 589 590
		break;

	case IPW_ORD_TABLE_1_MASK:
		/*
		 * TABLE 1: Indirect access to a table of 32 bit values
591 592
		 *
		 * This is a fairly large table of u32 values each
J
James Ketrenos 已提交
593 594 595 596 597 598
		 * representing starting addr for the data (which is
		 * also a u32)
		 */

		/* remove the table id from the ordinal */
		ord &= IPW_ORD_TABLE_VALUE_MASK;
599

J
James Ketrenos 已提交
600 601 602 603 604 605 606 607 608
		/* boundary check */
		if (ord > priv->table1_len) {
			IPW_DEBUG_ORD("ordinal value too long\n");
			return -EINVAL;
		}

		/* verify we have enough room to store the value */
		if (*len < sizeof(u32)) {
			IPW_DEBUG_ORD("ordinal buffer length too small, "
609
				      "need %zd\n", sizeof(u32));
J
James Ketrenos 已提交
610 611 612
			return -EINVAL;
		}

613 614
		*((u32 *) val) =
		    ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
J
James Ketrenos 已提交
615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
		*len = sizeof(u32);
		break;

	case IPW_ORD_TABLE_2_MASK:
		/*
		 * TABLE 2: Indirect access to a table of variable sized values
		 *
		 * This table consist of six values, each containing
		 *     - dword containing the starting offset of the data
		 *     - dword containing the lengh in the first 16bits
		 *       and the count in the second 16bits
		 */

		/* remove the table id from the ordinal */
		ord &= IPW_ORD_TABLE_VALUE_MASK;

		/* boundary check */
		if (ord > priv->table2_len) {
			IPW_DEBUG_ORD("ordinal value too long\n");
			return -EINVAL;
		}

		/* get the address of statistic */
		addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
639 640

		/* get the second DW of statistics ;
J
James Ketrenos 已提交
641
		 * two 16-bit words - first is length, second is count */
642 643 644 645
		field_info =
		    ipw_read_reg32(priv,
				   priv->table2_addr + (ord << 3) +
				   sizeof(u32));
646

J
James Ketrenos 已提交
647
		/* get each entry length */
648
		field_len = *((u16 *) & field_info);
649

J
James Ketrenos 已提交
650
		/* get number of entries */
651
		field_count = *(((u16 *) & field_info) + 1);
652

J
James Ketrenos 已提交
653 654 655 656 657 658
		/* abort if not enought memory */
		total_len = field_len * field_count;
		if (total_len > *len) {
			*len = total_len;
			return -EINVAL;
		}
659

J
James Ketrenos 已提交
660 661 662 663 664
		*len = total_len;
		if (!total_len)
			return 0;

		IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
665
			      "field_info = 0x%08x\n",
J
James Ketrenos 已提交
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
			      addr, total_len, field_info);
		ipw_read_indirect(priv, addr, val, total_len);
		break;

	default:
		IPW_DEBUG_ORD("Invalid ordinal!\n");
		return -EINVAL;

	}

	return 0;
}

static void ipw_init_ordinals(struct ipw_priv *priv)
{
	priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
682
	priv->table0_len = ipw_read32(priv, priv->table0_addr);
J
James Ketrenos 已提交
683 684 685 686 687 688 689 690 691 692 693 694

	IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
		      priv->table0_addr, priv->table0_len);

	priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
	priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);

	IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
		      priv->table1_addr, priv->table1_len);

	priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
	priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
695
	priv->table2_len &= 0x0000ffff;	/* use first two bytes */
J
James Ketrenos 已提交
696 697 698 699 700 701

	IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
		      priv->table2_addr, priv->table2_len);

}

702 703
u32 ipw_register_toggle(u32 reg)
{
704 705 706 707 708 709 710
	reg &= ~IPW_START_STANDBY;
	if (reg & IPW_GATE_ODMA)
		reg &= ~IPW_GATE_ODMA;
	if (reg & IPW_GATE_IDMA)
		reg &= ~IPW_GATE_IDMA;
	if (reg & IPW_GATE_ADMA)
		reg &= ~IPW_GATE_ADMA;
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
	return reg;
}

/*
 * LED behavior:
 * - On radio ON, turn on any LEDs that require to be on during start
 * - On initialization, start unassociated blink
 * - On association, disable unassociated blink
 * - On disassociation, start unassociated blink
 * - On radio OFF, turn off any LEDs started during radio on
 *
 */
#define LD_TIME_LINK_ON 300
#define LD_TIME_LINK_OFF 2700
#define LD_TIME_ACT_ON 250

void ipw_led_link_on(struct ipw_priv *priv)
{
	unsigned long flags;
	u32 led;

	/* If configured to not use LEDs, or nic_type is 1,
	 * then we don't toggle a LINK led */
	if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
		return;

	spin_lock_irqsave(&priv->lock, flags);

	if (!(priv->status & STATUS_RF_KILL_MASK) &&
	    !(priv->status & STATUS_LED_LINK_ON)) {
		IPW_DEBUG_LED("Link LED On\n");
742
		led = ipw_read_reg32(priv, IPW_EVENT_REG);
743 744 745 746 747
		led |= priv->led_association_on;

		led = ipw_register_toggle(led);

		IPW_DEBUG_LED("Reg: 0x%08X\n", led);
748
		ipw_write_reg32(priv, IPW_EVENT_REG, led);
749 750 751 752 753 754 755 756 757 758 759 760 761

		priv->status |= STATUS_LED_LINK_ON;

		/* If we aren't associated, schedule turning the LED off */
		if (!(priv->status & STATUS_ASSOCIATED))
			queue_delayed_work(priv->workqueue,
					   &priv->led_link_off,
					   LD_TIME_LINK_ON);
	}

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

762 763 764 765 766 767 768 769
static void ipw_bg_led_link_on(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_led_link_on(data);
	up(&priv->sem);
}

770 771 772 773 774 775 776 777 778 779 780 781 782
void ipw_led_link_off(struct ipw_priv *priv)
{
	unsigned long flags;
	u32 led;

	/* If configured not to use LEDs, or nic type is 1,
	 * then we don't goggle the LINK led. */
	if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
		return;

	spin_lock_irqsave(&priv->lock, flags);

	if (priv->status & STATUS_LED_LINK_ON) {
783
		led = ipw_read_reg32(priv, IPW_EVENT_REG);
784 785 786 787
		led &= priv->led_association_off;
		led = ipw_register_toggle(led);

		IPW_DEBUG_LED("Reg: 0x%08X\n", led);
788
		ipw_write_reg32(priv, IPW_EVENT_REG, led);
789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805

		IPW_DEBUG_LED("Link LED Off\n");

		priv->status &= ~STATUS_LED_LINK_ON;

		/* If we aren't associated and the radio is on, schedule
		 * turning the LED on (blink while unassociated) */
		if (!(priv->status & STATUS_RF_KILL_MASK) &&
		    !(priv->status & STATUS_ASSOCIATED))
			queue_delayed_work(priv->workqueue, &priv->led_link_on,
					   LD_TIME_LINK_OFF);

	}

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

806 807 808 809 810 811 812 813
static void ipw_bg_led_link_off(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_led_link_off(data);
	up(&priv->sem);
}

814
static inline void __ipw_led_activity_on(struct ipw_priv *priv)
815 816 817 818 819 820
{
	u32 led;

	if (priv->config & CFG_NO_LED)
		return;

821
	if (priv->status & STATUS_RF_KILL_MASK)
822 823 824
		return;

	if (!(priv->status & STATUS_LED_ACT_ON)) {
825
		led = ipw_read_reg32(priv, IPW_EVENT_REG);
826 827 828 829 830
		led |= priv->led_activity_on;

		led = ipw_register_toggle(led);

		IPW_DEBUG_LED("Reg: 0x%08X\n", led);
831
		ipw_write_reg32(priv, IPW_EVENT_REG, led);
832 833 834 835 836

		IPW_DEBUG_LED("Activity LED On\n");

		priv->status |= STATUS_LED_ACT_ON;

837
		cancel_delayed_work(&priv->led_act_off);
838 839 840 841 842 843 844 845
		queue_delayed_work(priv->workqueue, &priv->led_act_off,
				   LD_TIME_ACT_ON);
	} else {
		/* Reschedule LED off for full time period */
		cancel_delayed_work(&priv->led_act_off);
		queue_delayed_work(priv->workqueue, &priv->led_act_off,
				   LD_TIME_ACT_ON);
	}
846
}
847

848 849 850 851 852
void ipw_led_activity_on(struct ipw_priv *priv)
{
	unsigned long flags;
	spin_lock_irqsave(&priv->lock, flags);
	__ipw_led_activity_on(priv);
853 854 855 856 857 858 859 860 861 862 863 864 865 866
	spin_unlock_irqrestore(&priv->lock, flags);
}

void ipw_led_activity_off(struct ipw_priv *priv)
{
	unsigned long flags;
	u32 led;

	if (priv->config & CFG_NO_LED)
		return;

	spin_lock_irqsave(&priv->lock, flags);

	if (priv->status & STATUS_LED_ACT_ON) {
867
		led = ipw_read_reg32(priv, IPW_EVENT_REG);
868 869 870 871 872
		led &= priv->led_activity_off;

		led = ipw_register_toggle(led);

		IPW_DEBUG_LED("Reg: 0x%08X\n", led);
873
		ipw_write_reg32(priv, IPW_EVENT_REG, led);
874 875 876 877 878 879 880 881 882

		IPW_DEBUG_LED("Activity LED Off\n");

		priv->status &= ~STATUS_LED_ACT_ON;
	}

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

883 884 885 886 887 888 889 890
static void ipw_bg_led_activity_off(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_led_activity_off(data);
	up(&priv->sem);
}

891 892 893 894 895 896
void ipw_led_band_on(struct ipw_priv *priv)
{
	unsigned long flags;
	u32 led;

	/* Only nic type 1 supports mode LEDs */
897 898
	if (priv->config & CFG_NO_LED ||
	    priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
899 900 901 902
		return;

	spin_lock_irqsave(&priv->lock, flags);

903
	led = ipw_read_reg32(priv, IPW_EVENT_REG);
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920
	if (priv->assoc_network->mode == IEEE_A) {
		led |= priv->led_ofdm_on;
		led &= priv->led_association_off;
		IPW_DEBUG_LED("Mode LED On: 802.11a\n");
	} else if (priv->assoc_network->mode == IEEE_G) {
		led |= priv->led_ofdm_on;
		led |= priv->led_association_on;
		IPW_DEBUG_LED("Mode LED On: 802.11g\n");
	} else {
		led &= priv->led_ofdm_off;
		led |= priv->led_association_on;
		IPW_DEBUG_LED("Mode LED On: 802.11b\n");
	}

	led = ipw_register_toggle(led);

	IPW_DEBUG_LED("Reg: 0x%08X\n", led);
921
	ipw_write_reg32(priv, IPW_EVENT_REG, led);
922 923 924 925 926 927 928 929 930 931 932 933 934 935 936

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

void ipw_led_band_off(struct ipw_priv *priv)
{
	unsigned long flags;
	u32 led;

	/* Only nic type 1 supports mode LEDs */
	if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
		return;

	spin_lock_irqsave(&priv->lock, flags);

937
	led = ipw_read_reg32(priv, IPW_EVENT_REG);
938 939 940 941 942 943
	led &= priv->led_ofdm_off;
	led &= priv->led_association_off;

	led = ipw_register_toggle(led);

	IPW_DEBUG_LED("Reg: 0x%08X\n", led);
944
	ipw_write_reg32(priv, IPW_EVENT_REG, led);
945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979

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

void ipw_led_radio_on(struct ipw_priv *priv)
{
	ipw_led_link_on(priv);
}

void ipw_led_radio_off(struct ipw_priv *priv)
{
	ipw_led_activity_off(priv);
	ipw_led_link_off(priv);
}

void ipw_led_link_up(struct ipw_priv *priv)
{
	/* Set the Link Led on for all nic types */
	ipw_led_link_on(priv);
}

void ipw_led_link_down(struct ipw_priv *priv)
{
	ipw_led_activity_off(priv);
	ipw_led_link_off(priv);

	if (priv->status & STATUS_RF_KILL_MASK)
		ipw_led_radio_off(priv);
}

void ipw_led_init(struct ipw_priv *priv)
{
	priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];

	/* Set the default PINs for the link and activity leds */
980 981
	priv->led_activity_on = IPW_ACTIVITY_LED;
	priv->led_activity_off = ~(IPW_ACTIVITY_LED);
982

983 984
	priv->led_association_on = IPW_ASSOCIATED_LED;
	priv->led_association_off = ~(IPW_ASSOCIATED_LED);
985 986

	/* Set the default PINs for the OFDM leds */
987 988
	priv->led_ofdm_on = IPW_OFDM_LED;
	priv->led_ofdm_off = ~(IPW_OFDM_LED);
989 990 991 992

	switch (priv->nic_type) {
	case EEPROM_NIC_TYPE_1:
		/* In this NIC type, the LEDs are reversed.... */
993 994 995 996
		priv->led_activity_on = IPW_ASSOCIATED_LED;
		priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
		priv->led_association_on = IPW_ACTIVITY_LED;
		priv->led_association_off = ~(IPW_ACTIVITY_LED);
997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030

		if (!(priv->config & CFG_NO_LED))
			ipw_led_band_on(priv);

		/* And we don't blink link LEDs for this nic, so
		 * just return here */
		return;

	case EEPROM_NIC_TYPE_3:
	case EEPROM_NIC_TYPE_2:
	case EEPROM_NIC_TYPE_4:
	case EEPROM_NIC_TYPE_0:
		break;

	default:
		IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
			       priv->nic_type);
		priv->nic_type = EEPROM_NIC_TYPE_0;
		break;
	}

	if (!(priv->config & CFG_NO_LED)) {
		if (priv->status & STATUS_ASSOCIATED)
			ipw_led_link_on(priv);
		else
			ipw_led_link_off(priv);
	}
}

void ipw_led_shutdown(struct ipw_priv *priv)
{
	ipw_led_activity_off(priv);
	ipw_led_link_off(priv);
	ipw_led_band_off(priv);
1031 1032 1033
	cancel_delayed_work(&priv->led_link_on);
	cancel_delayed_work(&priv->led_link_off);
	cancel_delayed_work(&priv->led_act_off);
1034 1035
}

J
James Ketrenos 已提交
1036 1037 1038 1039
/*
 * The following adds a new attribute to the sysfs representation
 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
 * used for controling the debug level.
1040
 *
J
James Ketrenos 已提交
1041 1042 1043 1044 1045 1046
 * See the level definitions in ipw for details.
 */
static ssize_t show_debug_level(struct device_driver *d, char *buf)
{
	return sprintf(buf, "0x%08X\n", ipw_debug_level);
}
1047 1048 1049

static ssize_t store_debug_level(struct device_driver *d, const char *buf,
				 size_t count)
J
James Ketrenos 已提交
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
{
	char *p = (char *)buf;
	u32 val;

	if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
		p++;
		if (p[0] == 'x' || p[0] == 'X')
			p++;
		val = simple_strtoul(p, &p, 16);
	} else
		val = simple_strtoul(p, &p, 10);
1061 1062
	if (p == buf)
		printk(KERN_INFO DRV_NAME
J
James Ketrenos 已提交
1063 1064 1065 1066 1067 1068 1069
		       ": %s is not in hex or decimal form.\n", buf);
	else
		ipw_debug_level = val;

	return strnlen(buf, count);
}

1070
static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
J
James Ketrenos 已提交
1071 1072
		   show_debug_level, store_debug_level);

1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
{
	return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
}

static void ipw_capture_event_log(struct ipw_priv *priv,
				  u32 log_len, struct ipw_event *log)
{
	u32 base;

	if (log_len) {
		base = ipw_read32(priv, IPW_EVENT_LOG);
		ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
				  (u8 *) log, sizeof(*log) * log_len);
	}
}

static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
{
	struct ipw_fw_error *error;
	u32 log_len = ipw_get_event_log_len(priv);
	u32 base = ipw_read32(priv, IPW_ERROR_LOG);
	u32 elem_len = ipw_read_reg32(priv, base);

	error = kmalloc(sizeof(*error) +
			sizeof(*error->elem) * elem_len +
			sizeof(*error->log) * log_len, GFP_ATOMIC);
	if (!error) {
		IPW_ERROR("Memory allocation for firmware error log "
			  "failed.\n");
		return NULL;
	}
1105
	error->jiffies = jiffies;
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
	error->status = priv->status;
	error->config = priv->config;
	error->elem_len = elem_len;
	error->log_len = log_len;
	error->elem = (struct ipw_error_elem *)error->payload;
	error->log = (struct ipw_event *)(error->elem +
					  (sizeof(*error->elem) * elem_len));

	ipw_capture_event_log(priv, log_len, error->log);

	if (elem_len)
		ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
				  sizeof(*error->elem) * elem_len);

	return error;
}

static void ipw_free_error_log(struct ipw_fw_error *error)
{
	if (error)
		kfree(error);
}

static ssize_t show_event_log(struct device *d,
			      struct device_attribute *attr, char *buf)
{
	struct ipw_priv *priv = dev_get_drvdata(d);
	u32 log_len = ipw_get_event_log_len(priv);
	struct ipw_event log[log_len];
	u32 len = 0, i;

	ipw_capture_event_log(priv, log_len, log);

	len += snprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
	for (i = 0; i < log_len; i++)
		len += snprintf(buf + len, PAGE_SIZE - len,
				"\n%08X%08X%08X",
				log[i].time, log[i].event, log[i].data);
	len += snprintf(buf + len, PAGE_SIZE - len, "\n");
	return len;
}

static DEVICE_ATTR(event_log, S_IRUGO, show_event_log, NULL);

static ssize_t show_error(struct device *d,
			  struct device_attribute *attr, char *buf)
{
	struct ipw_priv *priv = dev_get_drvdata(d);
	u32 len = 0, i;
	if (!priv->error)
		return 0;
	len += snprintf(buf + len, PAGE_SIZE - len,
1158 1159
			"%08lX%08X%08X%08X",
			priv->error->jiffies,
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
			priv->error->status,
			priv->error->config, priv->error->elem_len);
	for (i = 0; i < priv->error->elem_len; i++)
		len += snprintf(buf + len, PAGE_SIZE - len,
				"\n%08X%08X%08X%08X%08X%08X%08X",
				priv->error->elem[i].time,
				priv->error->elem[i].desc,
				priv->error->elem[i].blink1,
				priv->error->elem[i].blink2,
				priv->error->elem[i].link1,
				priv->error->elem[i].link2,
				priv->error->elem[i].data);

	len += snprintf(buf + len, PAGE_SIZE - len,
			"\n%08X", priv->error->log_len);
	for (i = 0; i < priv->error->log_len; i++)
		len += snprintf(buf + len, PAGE_SIZE - len,
				"\n%08X%08X%08X",
				priv->error->log[i].time,
				priv->error->log[i].event,
				priv->error->log[i].data);
	len += snprintf(buf + len, PAGE_SIZE - len, "\n");
	return len;
}

static ssize_t clear_error(struct device *d,
			   struct device_attribute *attr,
			   const char *buf, size_t count)
{
	struct ipw_priv *priv = dev_get_drvdata(d);
	if (priv->error) {
		ipw_free_error_log(priv->error);
		priv->error = NULL;
	}
	return count;
}

static DEVICE_ATTR(error, S_IRUGO | S_IWUSR, show_error, clear_error);

1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
static ssize_t show_cmd_log(struct device *d,
			    struct device_attribute *attr, char *buf)
{
	struct ipw_priv *priv = dev_get_drvdata(d);
	u32 len = 0, i;
	if (!priv->cmdlog)
		return 0;
	for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
	     (i != priv->cmdlog_pos) && (PAGE_SIZE - len);
	     i = (i + 1) % priv->cmdlog_len) {
		len +=
		    snprintf(buf + len, PAGE_SIZE - len,
			     "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
			     priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
			     priv->cmdlog[i].cmd.len);
		len +=
		    snprintk_buf(buf + len, PAGE_SIZE - len,
				 (u8 *) priv->cmdlog[i].cmd.param,
				 priv->cmdlog[i].cmd.len);
		len += snprintf(buf + len, PAGE_SIZE - len, "\n");
	}
	len += snprintf(buf + len, PAGE_SIZE - len, "\n");
	return len;
}

static DEVICE_ATTR(cmd_log, S_IRUGO, show_cmd_log, NULL);

1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
			     char *buf)
{
	struct ipw_priv *priv = dev_get_drvdata(d);
	return sprintf(buf, "%d\n", priv->ieee->scan_age);
}

static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
			      const char *buf, size_t count)
{
	struct ipw_priv *priv = dev_get_drvdata(d);
1237
#ifdef CONFIG_IPW_DEBUG
1238
	struct net_device *dev = priv->net_dev;
1239
#endif
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
	char buffer[] = "00000000";
	unsigned long len =
	    (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
	unsigned long val;
	char *p = buffer;

	IPW_DEBUG_INFO("enter\n");

	strncpy(buffer, buf, len);
	buffer[len] = 0;

	if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
		p++;
		if (p[0] == 'x' || p[0] == 'X')
			p++;
		val = simple_strtoul(p, &p, 16);
	} else
		val = simple_strtoul(p, &p, 10);
	if (p == buffer) {
		IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
	} else {
		priv->ieee->scan_age = val;
		IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
	}

	IPW_DEBUG_INFO("exit\n");
	return len;
}

static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);

static ssize_t show_led(struct device *d, struct device_attribute *attr,
			char *buf)
{
	struct ipw_priv *priv = dev_get_drvdata(d);
	return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
}

static ssize_t store_led(struct device *d, struct device_attribute *attr,
			 const char *buf, size_t count)
{
	struct ipw_priv *priv = dev_get_drvdata(d);

	IPW_DEBUG_INFO("enter\n");

	if (count == 0)
		return 0;

	if (*buf == 0) {
		IPW_DEBUG_LED("Disabling LED control.\n");
		priv->config |= CFG_NO_LED;
		ipw_led_shutdown(priv);
	} else {
		IPW_DEBUG_LED("Enabling LED control.\n");
		priv->config &= ~CFG_NO_LED;
		ipw_led_init(priv);
	}

	IPW_DEBUG_INFO("exit\n");
	return count;
}

static DEVICE_ATTR(led, S_IWUSR | S_IRUGO, show_led, store_led);

1304
static ssize_t show_status(struct device *d,
1305
			   struct device_attribute *attr, char *buf)
J
James Ketrenos 已提交
1306
{
1307
	struct ipw_priv *p = d->driver_data;
J
James Ketrenos 已提交
1308 1309
	return sprintf(buf, "0x%08x\n", (int)p->status);
}
1310

J
James Ketrenos 已提交
1311 1312
static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);

1313 1314
static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
			char *buf)
J
James Ketrenos 已提交
1315
{
1316
	struct ipw_priv *p = d->driver_data;
J
James Ketrenos 已提交
1317 1318
	return sprintf(buf, "0x%08x\n", (int)p->config);
}
1319

J
James Ketrenos 已提交
1320 1321
static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);

1322
static ssize_t show_nic_type(struct device *d,
1323
			     struct device_attribute *attr, char *buf)
J
James Ketrenos 已提交
1324
{
1325 1326
	struct ipw_priv *priv = d->driver_data;
	return sprintf(buf, "TYPE: %d\n", priv->nic_type);
J
James Ketrenos 已提交
1327
}
1328

J
James Ketrenos 已提交
1329 1330
static DEVICE_ATTR(nic_type, S_IRUGO, show_nic_type, NULL);

1331
static ssize_t show_ucode_version(struct device *d,
1332
				  struct device_attribute *attr, char *buf)
J
James Ketrenos 已提交
1333 1334
{
	u32 len = sizeof(u32), tmp = 0;
1335
	struct ipw_priv *p = d->driver_data;
J
James Ketrenos 已提交
1336

1337
	if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
J
James Ketrenos 已提交
1338 1339 1340 1341
		return 0;

	return sprintf(buf, "0x%08x\n", tmp);
}
1342 1343

static DEVICE_ATTR(ucode_version, S_IWUSR | S_IRUGO, show_ucode_version, NULL);
J
James Ketrenos 已提交
1344

1345 1346
static ssize_t show_rtc(struct device *d, struct device_attribute *attr,
			char *buf)
J
James Ketrenos 已提交
1347 1348
{
	u32 len = sizeof(u32), tmp = 0;
1349
	struct ipw_priv *p = d->driver_data;
J
James Ketrenos 已提交
1350

1351
	if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
J
James Ketrenos 已提交
1352 1353 1354 1355
		return 0;

	return sprintf(buf, "0x%08x\n", tmp);
}
1356 1357

static DEVICE_ATTR(rtc, S_IWUSR | S_IRUGO, show_rtc, NULL);
J
James Ketrenos 已提交
1358 1359 1360 1361 1362

/*
 * Add a device attribute to view/control the delay between eeprom
 * operations.
 */
1363
static ssize_t show_eeprom_delay(struct device *d,
1364
				 struct device_attribute *attr, char *buf)
J
James Ketrenos 已提交
1365
{
1366
	int n = ((struct ipw_priv *)d->driver_data)->eeprom_delay;
J
James Ketrenos 已提交
1367 1368
	return sprintf(buf, "%i\n", n);
}
1369
static ssize_t store_eeprom_delay(struct device *d,
1370 1371
				  struct device_attribute *attr,
				  const char *buf, size_t count)
J
James Ketrenos 已提交
1372
{
1373
	struct ipw_priv *p = d->driver_data;
J
James Ketrenos 已提交
1374 1375 1376
	sscanf(buf, "%i", &p->eeprom_delay);
	return strnlen(buf, count);
}
1377 1378 1379

static DEVICE_ATTR(eeprom_delay, S_IWUSR | S_IRUGO,
		   show_eeprom_delay, store_eeprom_delay);
J
James Ketrenos 已提交
1380

1381
static ssize_t show_command_event_reg(struct device *d,
1382
				      struct device_attribute *attr, char *buf)
J
James Ketrenos 已提交
1383 1384
{
	u32 reg = 0;
1385
	struct ipw_priv *p = d->driver_data;
J
James Ketrenos 已提交
1386

1387
	reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
J
James Ketrenos 已提交
1388 1389
	return sprintf(buf, "0x%08x\n", reg);
}
1390
static ssize_t store_command_event_reg(struct device *d,
1391 1392
				       struct device_attribute *attr,
				       const char *buf, size_t count)
J
James Ketrenos 已提交
1393 1394
{
	u32 reg;
1395
	struct ipw_priv *p = d->driver_data;
J
James Ketrenos 已提交
1396 1397

	sscanf(buf, "%x", &reg);
1398
	ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
J
James Ketrenos 已提交
1399 1400
	return strnlen(buf, count);
}
1401 1402 1403

static DEVICE_ATTR(command_event_reg, S_IWUSR | S_IRUGO,
		   show_command_event_reg, store_command_event_reg);
J
James Ketrenos 已提交
1404

1405
static ssize_t show_mem_gpio_reg(struct device *d,
1406
				 struct device_attribute *attr, char *buf)
J
James Ketrenos 已提交
1407 1408
{
	u32 reg = 0;
1409
	struct ipw_priv *p = d->driver_data;
J
James Ketrenos 已提交
1410 1411 1412 1413

	reg = ipw_read_reg32(p, 0x301100);
	return sprintf(buf, "0x%08x\n", reg);
}
1414
static ssize_t store_mem_gpio_reg(struct device *d,
1415 1416
				  struct device_attribute *attr,
				  const char *buf, size_t count)
J
James Ketrenos 已提交
1417 1418
{
	u32 reg;
1419
	struct ipw_priv *p = d->driver_data;
J
James Ketrenos 已提交
1420 1421 1422 1423 1424

	sscanf(buf, "%x", &reg);
	ipw_write_reg32(p, 0x301100, reg);
	return strnlen(buf, count);
}
1425 1426 1427

static DEVICE_ATTR(mem_gpio_reg, S_IWUSR | S_IRUGO,
		   show_mem_gpio_reg, store_mem_gpio_reg);
J
James Ketrenos 已提交
1428

1429
static ssize_t show_indirect_dword(struct device *d,
1430
				   struct device_attribute *attr, char *buf)
J
James Ketrenos 已提交
1431 1432
{
	u32 reg = 0;
1433
	struct ipw_priv *priv = d->driver_data;
1434

1435
	if (priv->status & STATUS_INDIRECT_DWORD)
J
James Ketrenos 已提交
1436
		reg = ipw_read_reg32(priv, priv->indirect_dword);
1437
	else
J
James Ketrenos 已提交
1438
		reg = 0;
1439

J
James Ketrenos 已提交
1440 1441
	return sprintf(buf, "0x%08x\n", reg);
}
1442
static ssize_t store_indirect_dword(struct device *d,
1443 1444
				    struct device_attribute *attr,
				    const char *buf, size_t count)
J
James Ketrenos 已提交
1445
{
1446
	struct ipw_priv *priv = d->driver_data;
J
James Ketrenos 已提交
1447 1448 1449 1450 1451

	sscanf(buf, "%x", &priv->indirect_dword);
	priv->status |= STATUS_INDIRECT_DWORD;
	return strnlen(buf, count);
}
1452 1453 1454

static DEVICE_ATTR(indirect_dword, S_IWUSR | S_IRUGO,
		   show_indirect_dword, store_indirect_dword);
J
James Ketrenos 已提交
1455

1456
static ssize_t show_indirect_byte(struct device *d,
1457
				  struct device_attribute *attr, char *buf)
J
James Ketrenos 已提交
1458 1459
{
	u8 reg = 0;
1460
	struct ipw_priv *priv = d->driver_data;
1461

1462
	if (priv->status & STATUS_INDIRECT_BYTE)
J
James Ketrenos 已提交
1463
		reg = ipw_read_reg8(priv, priv->indirect_byte);
1464
	else
J
James Ketrenos 已提交
1465 1466 1467 1468
		reg = 0;

	return sprintf(buf, "0x%02x\n", reg);
}
1469
static ssize_t store_indirect_byte(struct device *d,
1470 1471
				   struct device_attribute *attr,
				   const char *buf, size_t count)
J
James Ketrenos 已提交
1472
{
1473
	struct ipw_priv *priv = d->driver_data;
J
James Ketrenos 已提交
1474 1475 1476 1477 1478

	sscanf(buf, "%x", &priv->indirect_byte);
	priv->status |= STATUS_INDIRECT_BYTE;
	return strnlen(buf, count);
}
1479 1480

static DEVICE_ATTR(indirect_byte, S_IWUSR | S_IRUGO,
J
James Ketrenos 已提交
1481 1482
		   show_indirect_byte, store_indirect_byte);

1483
static ssize_t show_direct_dword(struct device *d,
1484
				 struct device_attribute *attr, char *buf)
J
James Ketrenos 已提交
1485 1486
{
	u32 reg = 0;
1487
	struct ipw_priv *priv = d->driver_data;
J
James Ketrenos 已提交
1488

1489
	if (priv->status & STATUS_DIRECT_DWORD)
J
James Ketrenos 已提交
1490
		reg = ipw_read32(priv, priv->direct_dword);
1491
	else
J
James Ketrenos 已提交
1492 1493 1494 1495
		reg = 0;

	return sprintf(buf, "0x%08x\n", reg);
}
1496
static ssize_t store_direct_dword(struct device *d,
1497 1498
				  struct device_attribute *attr,
				  const char *buf, size_t count)
J
James Ketrenos 已提交
1499
{
1500
	struct ipw_priv *priv = d->driver_data;
J
James Ketrenos 已提交
1501 1502 1503 1504 1505 1506

	sscanf(buf, "%x", &priv->direct_dword);
	priv->status |= STATUS_DIRECT_DWORD;
	return strnlen(buf, count);
}

1507 1508
static DEVICE_ATTR(direct_dword, S_IWUSR | S_IRUGO,
		   show_direct_dword, store_direct_dword);
J
James Ketrenos 已提交
1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519

static inline int rf_kill_active(struct ipw_priv *priv)
{
	if (0 == (ipw_read32(priv, 0x30) & 0x10000))
		priv->status |= STATUS_RF_KILL_HW;
	else
		priv->status &= ~STATUS_RF_KILL_HW;

	return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
}

1520
static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
1521
			    char *buf)
J
James Ketrenos 已提交
1522 1523
{
	/* 0 - RF kill not enabled
1524
	   1 - SW based RF kill active (sysfs)
J
James Ketrenos 已提交
1525 1526
	   2 - HW based RF kill active
	   3 - Both HW and SW baed RF kill active */
1527
	struct ipw_priv *priv = d->driver_data;
J
James Ketrenos 已提交
1528
	int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
1529
	    (rf_kill_active(priv) ? 0x2 : 0x0);
J
James Ketrenos 已提交
1530 1531 1532 1533 1534
	return sprintf(buf, "%i\n", val);
}

static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
{
1535
	if ((disable_radio ? 1 : 0) ==
1536
	    ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
1537
		return 0;
J
James Ketrenos 已提交
1538 1539 1540 1541 1542 1543 1544

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

	if (disable_radio) {
		priv->status |= STATUS_RF_KILL_SW;

1545
		if (priv->workqueue)
J
James Ketrenos 已提交
1546 1547 1548 1549 1550 1551 1552 1553 1554
			cancel_delayed_work(&priv->request_scan);
		queue_work(priv->workqueue, &priv->down);
	} else {
		priv->status &= ~STATUS_RF_KILL_SW;
		if (rf_kill_active(priv)) {
			IPW_DEBUG_RF_KILL("Can not turn radio back on - "
					  "disabled by HW switch\n");
			/* Make sure the RF_KILL check timer is running */
			cancel_delayed_work(&priv->rf_kill);
1555
			queue_delayed_work(priv->workqueue, &priv->rf_kill,
J
James Ketrenos 已提交
1556
					   2 * HZ);
1557
		} else
J
James Ketrenos 已提交
1558 1559 1560 1561 1562 1563
			queue_work(priv->workqueue, &priv->up);
	}

	return 1;
}

1564 1565
static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
			     const char *buf, size_t count)
J
James Ketrenos 已提交
1566
{
1567
	struct ipw_priv *priv = d->driver_data;
1568

J
James Ketrenos 已提交
1569 1570 1571 1572
	ipw_radio_kill_sw(priv, buf[0] == '1');

	return count;
}
1573 1574

static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
J
James Ketrenos 已提交
1575

1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604
static ssize_t show_speed_scan(struct device *d, struct device_attribute *attr,
			       char *buf)
{
	struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
	int pos = 0, len = 0;
	if (priv->config & CFG_SPEED_SCAN) {
		while (priv->speed_scan[pos] != 0)
			len += sprintf(&buf[len], "%d ",
				       priv->speed_scan[pos++]);
		return len + sprintf(&buf[len], "\n");
	}

	return sprintf(buf, "0\n");
}

static ssize_t store_speed_scan(struct device *d, struct device_attribute *attr,
				const char *buf, size_t count)
{
	struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
	int channel, pos = 0;
	const char *p = buf;

	/* list of space separated channels to scan, optionally ending with 0 */
	while ((channel = simple_strtol(p, NULL, 0))) {
		if (pos == MAX_SPEED_SCAN - 1) {
			priv->speed_scan[pos] = 0;
			break;
		}

1605
		if (ipw_is_valid_channel(priv->ieee, channel))
1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648
			priv->speed_scan[pos++] = channel;
		else
			IPW_WARNING("Skipping invalid channel request: %d\n",
				    channel);
		p = strchr(p, ' ');
		if (!p)
			break;
		while (*p == ' ' || *p == '\t')
			p++;
	}

	if (pos == 0)
		priv->config &= ~CFG_SPEED_SCAN;
	else {
		priv->speed_scan_pos = 0;
		priv->config |= CFG_SPEED_SCAN;
	}

	return count;
}

static DEVICE_ATTR(speed_scan, S_IWUSR | S_IRUGO, show_speed_scan,
		   store_speed_scan);

static ssize_t show_net_stats(struct device *d, struct device_attribute *attr,
			      char *buf)
{
	struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
	return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
}

static ssize_t store_net_stats(struct device *d, struct device_attribute *attr,
			       const char *buf, size_t count)
{
	struct ipw_priv *priv = (struct ipw_priv *)d->driver_data;
	if (buf[0] == '1')
		priv->config |= CFG_NET_STATS;
	else
		priv->config &= ~CFG_NET_STATS;

	return count;
}

1649 1650
static DEVICE_ATTR(net_stats, S_IWUSR | S_IRUGO,
		   show_net_stats, store_net_stats);
1651

1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662
static void notify_wx_assoc_event(struct ipw_priv *priv)
{
	union iwreq_data wrqu;
	wrqu.ap_addr.sa_family = ARPHRD_ETHER;
	if (priv->status & STATUS_ASSOCIATED)
		memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
	else
		memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
	wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
}

J
James Ketrenos 已提交
1663 1664 1665 1666 1667 1668 1669 1670
static void ipw_irq_tasklet(struct ipw_priv *priv)
{
	u32 inta, inta_mask, handled = 0;
	unsigned long flags;
	int rc = 0;

	spin_lock_irqsave(&priv->lock, flags);

1671 1672 1673
	inta = ipw_read32(priv, IPW_INTA_RW);
	inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
	inta &= (IPW_INTA_MASK_ALL & inta_mask);
J
James Ketrenos 已提交
1674 1675 1676 1677 1678

	/* Add any cached INTA values that need to be handled */
	inta |= priv->isr_inta;

	/* handle all the justifications for the interrupt */
1679
	if (inta & IPW_INTA_BIT_RX_TRANSFER) {
J
James Ketrenos 已提交
1680
		ipw_rx(priv);
1681
		handled |= IPW_INTA_BIT_RX_TRANSFER;
J
James Ketrenos 已提交
1682 1683
	}

1684
	if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
J
James Ketrenos 已提交
1685
		IPW_DEBUG_HC("Command completed.\n");
1686
		rc = ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
J
James Ketrenos 已提交
1687 1688
		priv->status &= ~STATUS_HCMD_ACTIVE;
		wake_up_interruptible(&priv->wait_command_queue);
1689
		handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
J
James Ketrenos 已提交
1690 1691
	}

1692
	if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
J
James Ketrenos 已提交
1693
		IPW_DEBUG_TX("TX_QUEUE_1\n");
1694
		rc = ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
1695
		handled |= IPW_INTA_BIT_TX_QUEUE_1;
J
James Ketrenos 已提交
1696 1697
	}

1698
	if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
J
James Ketrenos 已提交
1699
		IPW_DEBUG_TX("TX_QUEUE_2\n");
1700
		rc = ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
1701
		handled |= IPW_INTA_BIT_TX_QUEUE_2;
J
James Ketrenos 已提交
1702 1703
	}

1704
	if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
J
James Ketrenos 已提交
1705
		IPW_DEBUG_TX("TX_QUEUE_3\n");
1706
		rc = ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
1707
		handled |= IPW_INTA_BIT_TX_QUEUE_3;
J
James Ketrenos 已提交
1708 1709
	}

1710
	if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
J
James Ketrenos 已提交
1711
		IPW_DEBUG_TX("TX_QUEUE_4\n");
1712
		rc = ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
1713
		handled |= IPW_INTA_BIT_TX_QUEUE_4;
J
James Ketrenos 已提交
1714 1715
	}

1716
	if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
J
James Ketrenos 已提交
1717
		IPW_WARNING("STATUS_CHANGE\n");
1718
		handled |= IPW_INTA_BIT_STATUS_CHANGE;
J
James Ketrenos 已提交
1719 1720
	}

1721
	if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
J
James Ketrenos 已提交
1722
		IPW_WARNING("TX_PERIOD_EXPIRED\n");
1723
		handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
J
James Ketrenos 已提交
1724 1725
	}

1726
	if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
J
James Ketrenos 已提交
1727
		IPW_WARNING("HOST_CMD_DONE\n");
1728
		handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
J
James Ketrenos 已提交
1729 1730
	}

1731
	if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
J
James Ketrenos 已提交
1732
		IPW_WARNING("FW_INITIALIZATION_DONE\n");
1733
		handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
J
James Ketrenos 已提交
1734 1735
	}

1736
	if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
J
James Ketrenos 已提交
1737
		IPW_WARNING("PHY_OFF_DONE\n");
1738
		handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
J
James Ketrenos 已提交
1739 1740
	}

1741
	if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
J
James Ketrenos 已提交
1742 1743 1744
		IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
		priv->status |= STATUS_RF_KILL_HW;
		wake_up_interruptible(&priv->wait_command_queue);
1745
		priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
J
James Ketrenos 已提交
1746
		cancel_delayed_work(&priv->request_scan);
1747
		schedule_work(&priv->link_down);
J
James Ketrenos 已提交
1748
		queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
1749
		handled |= IPW_INTA_BIT_RF_KILL_DONE;
J
James Ketrenos 已提交
1750
	}
1751

1752
	if (inta & IPW_INTA_BIT_FATAL_ERROR) {
J
James Ketrenos 已提交
1753
		IPW_ERROR("Firmware error detected.  Restarting.\n");
1754 1755
		if (priv->error) {
			IPW_ERROR("Sysfs 'error' log already exists.\n");
J
James Ketrenos 已提交
1756
#ifdef CONFIG_IPW_DEBUG
1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774
			if (ipw_debug_level & IPW_DL_FW_ERRORS) {
				struct ipw_fw_error *error =
				    ipw_alloc_error_log(priv);
				ipw_dump_error_log(priv, error);
				if (error)
					ipw_free_error_log(error);
			}
#endif
		} else {
			priv->error = ipw_alloc_error_log(priv);
			if (priv->error)
				IPW_ERROR("Sysfs 'error' log captured.\n");
			else
				IPW_ERROR("Error allocating sysfs 'error' "
					  "log.\n");
#ifdef CONFIG_IPW_DEBUG
			if (ipw_debug_level & IPW_DL_FW_ERRORS)
				ipw_dump_error_log(priv, priv->error);
J
James Ketrenos 已提交
1775
#endif
1776 1777
		}

1778 1779 1780 1781 1782 1783 1784 1785 1786 1787
		/* XXX: If hardware encryption is for WPA/WPA2,
		 * we have to notify the supplicant. */
		if (priv->ieee->sec.encrypt) {
			priv->status &= ~STATUS_ASSOCIATED;
			notify_wx_assoc_event(priv);
		}

		/* Keep the restart process from trying to send host
		 * commands by clearing the INIT status bit */
		priv->status &= ~STATUS_INIT;
1788 1789 1790 1791 1792

		/* Cancel currently queued command. */
		priv->status &= ~STATUS_HCMD_ACTIVE;
		wake_up_interruptible(&priv->wait_command_queue);

J
James Ketrenos 已提交
1793
		queue_work(priv->workqueue, &priv->adapter_restart);
1794
		handled |= IPW_INTA_BIT_FATAL_ERROR;
J
James Ketrenos 已提交
1795 1796
	}

1797
	if (inta & IPW_INTA_BIT_PARITY_ERROR) {
J
James Ketrenos 已提交
1798
		IPW_ERROR("Parity error\n");
1799
		handled |= IPW_INTA_BIT_PARITY_ERROR;
J
James Ketrenos 已提交
1800 1801 1802
	}

	if (handled != inta) {
1803
		IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
J
James Ketrenos 已提交
1804 1805 1806 1807 1808 1809 1810
	}

	/* enable all interrupts */
	ipw_enable_interrupts(priv);

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

J
James Ketrenos 已提交
1812 1813 1814 1815 1816 1817
#ifdef CONFIG_IPW_DEBUG
#define IPW_CMD(x) case IPW_CMD_ ## x : return #x
static char *get_cmd_string(u8 cmd)
{
	switch (cmd) {
		IPW_CMD(HOST_COMPLETE);
1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867
		IPW_CMD(POWER_DOWN);
		IPW_CMD(SYSTEM_CONFIG);
		IPW_CMD(MULTICAST_ADDRESS);
		IPW_CMD(SSID);
		IPW_CMD(ADAPTER_ADDRESS);
		IPW_CMD(PORT_TYPE);
		IPW_CMD(RTS_THRESHOLD);
		IPW_CMD(FRAG_THRESHOLD);
		IPW_CMD(POWER_MODE);
		IPW_CMD(WEP_KEY);
		IPW_CMD(TGI_TX_KEY);
		IPW_CMD(SCAN_REQUEST);
		IPW_CMD(SCAN_REQUEST_EXT);
		IPW_CMD(ASSOCIATE);
		IPW_CMD(SUPPORTED_RATES);
		IPW_CMD(SCAN_ABORT);
		IPW_CMD(TX_FLUSH);
		IPW_CMD(QOS_PARAMETERS);
		IPW_CMD(DINO_CONFIG);
		IPW_CMD(RSN_CAPABILITIES);
		IPW_CMD(RX_KEY);
		IPW_CMD(CARD_DISABLE);
		IPW_CMD(SEED_NUMBER);
		IPW_CMD(TX_POWER);
		IPW_CMD(COUNTRY_INFO);
		IPW_CMD(AIRONET_INFO);
		IPW_CMD(AP_TX_POWER);
		IPW_CMD(CCKM_INFO);
		IPW_CMD(CCX_VER_INFO);
		IPW_CMD(SET_CALIBRATION);
		IPW_CMD(SENSITIVITY_CALIB);
		IPW_CMD(RETRY_LIMIT);
		IPW_CMD(IPW_PRE_POWER_DOWN);
		IPW_CMD(VAP_BEACON_TEMPLATE);
		IPW_CMD(VAP_DTIM_PERIOD);
		IPW_CMD(EXT_SUPPORTED_RATES);
		IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
		IPW_CMD(VAP_QUIET_INTERVALS);
		IPW_CMD(VAP_CHANNEL_SWITCH);
		IPW_CMD(VAP_MANDATORY_CHANNELS);
		IPW_CMD(VAP_CELL_PWR_LIMIT);
		IPW_CMD(VAP_CF_PARAM_SET);
		IPW_CMD(VAP_SET_BEACONING_STATE);
		IPW_CMD(MEASUREMENT);
		IPW_CMD(POWER_CAPABILITY);
		IPW_CMD(SUPPORTED_CHANNELS);
		IPW_CMD(TPC_REPORT);
		IPW_CMD(WME_INFO);
		IPW_CMD(PRODUCTION_COMMAND);
	default:
J
James Ketrenos 已提交
1868 1869 1870
		return "UNKNOWN";
	}
}
1871
#endif
J
James Ketrenos 已提交
1872 1873 1874 1875 1876

#define HOST_COMPLETE_TIMEOUT HZ
static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
{
	int rc = 0;
1877
	unsigned long flags;
J
James Ketrenos 已提交
1878

1879
	spin_lock_irqsave(&priv->lock, flags);
J
James Ketrenos 已提交
1880
	if (priv->status & STATUS_HCMD_ACTIVE) {
1881 1882
		IPW_ERROR("Failed to send %s: Already sending a command.\n",
			  get_cmd_string(cmd->cmd));
1883
		spin_unlock_irqrestore(&priv->lock, flags);
1884
		return -EAGAIN;
J
James Ketrenos 已提交
1885 1886
	}

1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898
	if (priv->status & STATUS_ASSOCIATING) {
		IPW_DEBUG_HC("abandon a command while associating\n");
		spin_unlock_irqrestore(&priv->lock, flags);
		return -1;
	}

	if (priv->status & STATUS_DISASSOCIATING) {
		IPW_DEBUG_HC("abandon a command while disassociating\n");
		spin_unlock_irqrestore(&priv->lock, flags);
		return -1;
	}

J
James Ketrenos 已提交
1899
	priv->status |= STATUS_HCMD_ACTIVE;
1900

1901 1902 1903 1904 1905 1906 1907 1908 1909
	if (priv->cmdlog) {
		priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
		priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
		priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
		memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
		       cmd->len);
		priv->cmdlog[priv->cmdlog_pos].retcode = -1;
	}

1910 1911 1912
	IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
		     get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
		     priv->status);
1913
	printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
J
James Ketrenos 已提交
1914 1915

	rc = ipw_queue_tx_hcmd(priv, cmd->cmd, &cmd->param, cmd->len, 0);
1916 1917
	if (rc) {
		priv->status &= ~STATUS_HCMD_ACTIVE;
1918 1919
		IPW_ERROR("Failed to send %s: Reason %d\n",
			  get_cmd_string(cmd->cmd), rc);
1920
		spin_unlock_irqrestore(&priv->lock, flags);
1921
		goto exit;
1922 1923
	}
	spin_unlock_irqrestore(&priv->lock, flags);
J
James Ketrenos 已提交
1924

1925 1926 1927 1928
	rc = wait_event_interruptible_timeout(priv->wait_command_queue,
					      !(priv->
						status & STATUS_HCMD_ACTIVE),
					      HOST_COMPLETE_TIMEOUT);
J
James Ketrenos 已提交
1929
	if (rc == 0) {
1930 1931
		spin_lock_irqsave(&priv->lock, flags);
		if (priv->status & STATUS_HCMD_ACTIVE) {
1932 1933
			IPW_ERROR("Failed to send %s: Command timed out.\n",
				  get_cmd_string(cmd->cmd));
1934 1935
			priv->status &= ~STATUS_HCMD_ACTIVE;
			spin_unlock_irqrestore(&priv->lock, flags);
1936 1937
			rc = -EIO;
			goto exit;
1938 1939
		}
		spin_unlock_irqrestore(&priv->lock, flags);
1940 1941
	} else
		rc = 0;
1942

1943
	if (priv->status & STATUS_RF_KILL_HW) {
1944 1945
		IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
			  get_cmd_string(cmd->cmd));
1946 1947
		rc = -EIO;
		goto exit;
J
James Ketrenos 已提交
1948 1949
	}

1950 1951 1952 1953 1954 1955
      exit:
	if (priv->cmdlog) {
		priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
		priv->cmdlog_pos %= priv->cmdlog_len;
	}
	return rc;
J
James Ketrenos 已提交
1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
}

static int ipw_send_host_complete(struct ipw_priv *priv)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_HOST_COMPLETE,
		.len = 0
	};

	if (!priv) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

1970
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
1971 1972
}

1973
static int ipw_send_system_config(struct ipw_priv *priv,
J
James Ketrenos 已提交
1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985
				  struct ipw_sys_config *config)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_SYSTEM_CONFIG,
		.len = sizeof(*config)
	};

	if (!priv || !config) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

1986
	memcpy(cmd.param, config, sizeof(*config));
1987
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
1988 1989
}

1990
static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
J
James Ketrenos 已提交
1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_SSID,
		.len = min(len, IW_ESSID_MAX_SIZE)
	};

	if (!priv || !ssid) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

2002
	memcpy(cmd.param, ssid, cmd.len);
2003
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2004 2005
}

2006
static int ipw_send_adapter_address(struct ipw_priv *priv, u8 * mac)
J
James Ketrenos 已提交
2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_ADAPTER_ADDRESS,
		.len = ETH_ALEN
	};

	if (!priv || !mac) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

	IPW_DEBUG_INFO("%s: Setting MAC to " MAC_FMT "\n",
		       priv->net_dev->name, MAC_ARG(mac));

2021
	memcpy(cmd.param, mac, ETH_ALEN);
2022
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2023 2024
}

2025 2026 2027 2028 2029
/*
 * NOTE: This must be executed from our workqueue as it results in udelay
 * being called which may corrupt the keyboard if executed on default
 * workqueue
 */
J
James Ketrenos 已提交
2030 2031 2032 2033 2034 2035 2036 2037
static void ipw_adapter_restart(void *adapter)
{
	struct ipw_priv *priv = adapter;

	if (priv->status & STATUS_RF_KILL_MASK)
		return;

	ipw_down(priv);
2038 2039 2040 2041 2042

	if (priv->assoc_network &&
	    (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
		ipw_remove_current_network(priv);

J
James Ketrenos 已提交
2043 2044 2045 2046 2047 2048
	if (ipw_up(priv)) {
		IPW_ERROR("Failed to up device\n");
		return;
	}
}

2049 2050 2051 2052 2053 2054 2055 2056
static void ipw_bg_adapter_restart(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_adapter_restart(data);
	up(&priv->sem);
}

J
James Ketrenos 已提交
2057 2058 2059 2060 2061 2062 2063
#define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)

static void ipw_scan_check(void *data)
{
	struct ipw_priv *priv = data;
	if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
		IPW_DEBUG_SCAN("Scan completion watchdog resetting "
2064
			       "adapter (%dms).\n",
J
James Ketrenos 已提交
2065
			       IPW_SCAN_CHECK_WATCHDOG / 100);
2066
		queue_work(priv->workqueue, &priv->adapter_restart);
J
James Ketrenos 已提交
2067 2068 2069
	}
}

2070 2071 2072 2073 2074 2075 2076 2077
static void ipw_bg_scan_check(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_scan_check(data);
	up(&priv->sem);
}

J
James Ketrenos 已提交
2078 2079 2080 2081 2082 2083 2084 2085
static int ipw_send_scan_request_ext(struct ipw_priv *priv,
				     struct ipw_scan_request_ext *request)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_SCAN_REQUEST_EXT,
		.len = sizeof(*request)
	};

2086
	memcpy(cmd.param, request, sizeof(*request));
2087
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101
}

static int ipw_send_scan_abort(struct ipw_priv *priv)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_SCAN_ABORT,
		.len = 0
	};

	if (!priv) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

2102
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2103 2104 2105 2106 2107 2108 2109 2110 2111
}

static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_SENSITIVITY_CALIB,
		.len = sizeof(struct ipw_sensitivity_calib)
	};
	struct ipw_sensitivity_calib *calib = (struct ipw_sensitivity_calib *)
2112
	    &cmd.param;
J
James Ketrenos 已提交
2113
	calib->beacon_rssi_raw = sens;
2114
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2115 2116 2117 2118 2119 2120 2121 2122 2123 2124
}

static int ipw_send_associate(struct ipw_priv *priv,
			      struct ipw_associate *associate)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_ASSOCIATE,
		.len = sizeof(*associate)
	};

2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137
	struct ipw_associate tmp_associate;
	memcpy(&tmp_associate, associate, sizeof(*associate));
	tmp_associate.policy_support =
	    cpu_to_le16(tmp_associate.policy_support);
	tmp_associate.assoc_tsf_msw = cpu_to_le32(tmp_associate.assoc_tsf_msw);
	tmp_associate.assoc_tsf_lsw = cpu_to_le32(tmp_associate.assoc_tsf_lsw);
	tmp_associate.capability = cpu_to_le16(tmp_associate.capability);
	tmp_associate.listen_interval =
	    cpu_to_le16(tmp_associate.listen_interval);
	tmp_associate.beacon_interval =
	    cpu_to_le16(tmp_associate.beacon_interval);
	tmp_associate.atim_window = cpu_to_le16(tmp_associate.atim_window);

J
James Ketrenos 已提交
2138 2139 2140 2141 2142
	if (!priv || !associate) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

2143
	memcpy(cmd.param, &tmp_associate, sizeof(*associate));
2144
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159
}

static int ipw_send_supported_rates(struct ipw_priv *priv,
				    struct ipw_supported_rates *rates)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_SUPPORTED_RATES,
		.len = sizeof(*rates)
	};

	if (!priv || !rates) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

2160
	memcpy(cmd.param, rates, sizeof(*rates));
2161
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177
}

static int ipw_set_random_seed(struct ipw_priv *priv)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_SEED_NUMBER,
		.len = sizeof(u32)
	};

	if (!priv) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

	get_random_bytes(&cmd.param, sizeof(u32));

2178
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192
}

static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_CARD_DISABLE,
		.len = sizeof(u32)
	};

	if (!priv) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

2193
	*((u32 *) & cmd.param) = phy_off;
J
James Ketrenos 已提交
2194

2195
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2196 2197
}

2198
static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
J
James Ketrenos 已提交
2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_TX_POWER,
		.len = sizeof(*power)
	};

	if (!priv || !power) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

2210
	memcpy(cmd.param, power, sizeof(*power));
2211
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2212 2213
}

Z
Zhu Yi 已提交
2214 2215
static int ipw_set_tx_power(struct ipw_priv *priv)
{
2216
	const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
Z
Zhu Yi 已提交
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257
	struct ipw_tx_power tx_power;
	s8 max_power;
	int i;

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

	/* configure device for 'G' band */
	tx_power.ieee_mode = IPW_G_MODE;
	tx_power.num_channels = geo->bg_channels;
	for (i = 0; i < geo->bg_channels; i++) {
		max_power = geo->bg[i].max_power;
		tx_power.channels_tx_power[i].channel_number =
		    geo->bg[i].channel;
		tx_power.channels_tx_power[i].tx_power = max_power ?
		    min(max_power, priv->tx_power) : priv->tx_power;
	}
	if (ipw_send_tx_power(priv, &tx_power))
		return -EIO;

	/* configure device to also handle 'B' band */
	tx_power.ieee_mode = IPW_B_MODE;
	if (ipw_send_tx_power(priv, &tx_power))
		return -EIO;

	/* configure device to also handle 'A' band */
	if (priv->ieee->abg_true) {
		tx_power.ieee_mode = IPW_A_MODE;
		tx_power.num_channels = geo->a_channels;
		for (i = 0; i < tx_power.num_channels; i++) {
			max_power = geo->a[i].max_power;
			tx_power.channels_tx_power[i].channel_number =
			    geo->a[i].channel;
			tx_power.channels_tx_power[i].tx_power = max_power ?
			    min(max_power, priv->tx_power) : priv->tx_power;
		}
		if (ipw_send_tx_power(priv, &tx_power))
			return -EIO;
	}
	return 0;
}

J
James Ketrenos 已提交
2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272
static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
{
	struct ipw_rts_threshold rts_threshold = {
		.rts_threshold = rts,
	};
	struct host_cmd cmd = {
		.cmd = IPW_CMD_RTS_THRESHOLD,
		.len = sizeof(rts_threshold)
	};

	if (!priv) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

2273
	memcpy(cmd.param, &rts_threshold, sizeof(rts_threshold));
2274
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291
}

static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
{
	struct ipw_frag_threshold frag_threshold = {
		.frag_threshold = frag,
	};
	struct host_cmd cmd = {
		.cmd = IPW_CMD_FRAG_THRESHOLD,
		.len = sizeof(frag_threshold)
	};

	if (!priv) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

2292
	memcpy(cmd.param, &frag_threshold, sizeof(frag_threshold));
2293
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2294 2295 2296 2297 2298 2299 2300 2301
}

static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_POWER_MODE,
		.len = sizeof(u32)
	};
2302
	u32 *param = (u32 *) (&cmd.param);
J
James Ketrenos 已提交
2303 2304 2305 2306 2307

	if (!priv) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}
2308

J
James Ketrenos 已提交
2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322
	/* If on battery, set to 3, if AC set to CAM, else user
	 * level */
	switch (mode) {
	case IPW_POWER_BATTERY:
		*param = IPW_POWER_INDEX_3;
		break;
	case IPW_POWER_AC:
		*param = IPW_POWER_MODE_CAM;
		break;
	default:
		*param = mode;
		break;
	}

2323
	return ipw_send_cmd(priv, &cmd);
J
James Ketrenos 已提交
2324 2325
}

2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342
static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
{
	struct ipw_retry_limit retry_limit = {
		.short_retry_limit = slimit,
		.long_retry_limit = llimit
	};
	struct host_cmd cmd = {
		.cmd = IPW_CMD_RETRY_LIMIT,
		.len = sizeof(retry_limit)
	};

	if (!priv) {
		IPW_ERROR("Invalid args\n");
		return -1;
	}

	memcpy(cmd.param, &retry_limit, sizeof(retry_limit));
2343
	return ipw_send_cmd(priv, &cmd);
2344 2345
}

J
James Ketrenos 已提交
2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366
/*
 * The IPW device contains a Microwire compatible EEPROM that stores
 * various data like the MAC address.  Usually the firmware has exclusive
 * access to the eeprom, but during device initialization (before the
 * device driver has sent the HostComplete command to the firmware) the
 * device driver has read access to the EEPROM by way of indirect addressing
 * through a couple of memory mapped registers.
 *
 * The following is a simplified implementation for pulling data out of the
 * the eeprom, along with some helper functions to find information in
 * the per device private data's copy of the eeprom.
 *
 * NOTE: To better understand how these functions work (i.e what is a chip
 *       select and why do have to keep driving the eeprom clock?), read
 *       just about any data sheet for a Microwire compatible EEPROM.
 */

/* write a 32 bit value into the indirect accessor register */
static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
{
	ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2367

J
James Ketrenos 已提交
2368 2369 2370 2371 2372 2373 2374
	/* the eeprom requires some time to complete the operation */
	udelay(p->eeprom_delay);

	return;
}

/* perform a chip select operation */
2375
static inline void eeprom_cs(struct ipw_priv *priv)
J
James Ketrenos 已提交
2376
{
2377 2378 2379 2380
	eeprom_write_reg(priv, 0);
	eeprom_write_reg(priv, EEPROM_BIT_CS);
	eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
	eeprom_write_reg(priv, EEPROM_BIT_CS);
J
James Ketrenos 已提交
2381 2382 2383
}

/* perform a chip select operation */
2384
static inline void eeprom_disable_cs(struct ipw_priv *priv)
J
James Ketrenos 已提交
2385
{
2386 2387 2388
	eeprom_write_reg(priv, EEPROM_BIT_CS);
	eeprom_write_reg(priv, 0);
	eeprom_write_reg(priv, EEPROM_BIT_SK);
J
James Ketrenos 已提交
2389 2390 2391
}

/* push a single bit down to the eeprom */
2392
static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
J
James Ketrenos 已提交
2393
{
2394 2395 2396
	int d = (bit ? EEPROM_BIT_DI : 0);
	eeprom_write_reg(p, EEPROM_BIT_CS | d);
	eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
J
James Ketrenos 已提交
2397 2398 2399
}

/* push an opcode followed by an address down to the eeprom */
2400
static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
J
James Ketrenos 已提交
2401 2402 2403 2404
{
	int i;

	eeprom_cs(priv);
2405 2406 2407 2408 2409
	eeprom_write_bit(priv, 1);
	eeprom_write_bit(priv, op & 2);
	eeprom_write_bit(priv, op & 1);
	for (i = 7; i >= 0; i--) {
		eeprom_write_bit(priv, addr & (1 << i));
J
James Ketrenos 已提交
2410 2411 2412 2413
	}
}

/* pull 16 bits off the eeprom, one bit at a time */
2414
static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
J
James Ketrenos 已提交
2415 2416
{
	int i;
2417
	u16 r = 0;
2418

J
James Ketrenos 已提交
2419
	/* Send READ Opcode */
2420
	eeprom_op(priv, EEPROM_CMD_READ, addr);
J
James Ketrenos 已提交
2421 2422

	/* Send dummy bit */
2423
	eeprom_write_reg(priv, EEPROM_BIT_CS);
J
James Ketrenos 已提交
2424 2425

	/* Read the byte off the eeprom one bit at a time */
2426
	for (i = 0; i < 16; i++) {
J
James Ketrenos 已提交
2427
		u32 data = 0;
2428 2429 2430 2431
		eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
		eeprom_write_reg(priv, EEPROM_BIT_CS);
		data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
		r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
J
James Ketrenos 已提交
2432
	}
2433

J
James Ketrenos 已提交
2434
	/* Send another dummy bit */
2435
	eeprom_write_reg(priv, 0);
J
James Ketrenos 已提交
2436
	eeprom_disable_cs(priv);
2437

J
James Ketrenos 已提交
2438 2439 2440 2441 2442
	return r;
}

/* helper function for pulling the mac address out of the private */
/* data's copy of the eeprom data                                 */
2443
static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
J
James Ketrenos 已提交
2444
{
2445
	memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], 6);
J
James Ketrenos 已提交
2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458
}

/*
 * Either the device driver (i.e. the host) or the firmware can
 * load eeprom data into the designated region in SRAM.  If neither
 * happens then the FW will shutdown with a fatal error.
 *
 * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
 * bit needs region of shared SRAM needs to be non-zero.
 */
static void ipw_eeprom_init_sram(struct ipw_priv *priv)
{
	int i;
2459
	u16 *eeprom = (u16 *) priv->eeprom;
2460

J
James Ketrenos 已提交
2461 2462 2463
	IPW_DEBUG_TRACE(">>\n");

	/* read entire contents of eeprom into private buffer */
2464
	for (i = 0; i < 128; i++)
2465
		eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
J
James Ketrenos 已提交
2466

2467 2468
	/*
	   If the data looks correct, then copy it to our private
J
James Ketrenos 已提交
2469 2470
	   copy.  Otherwise let the firmware know to perform the operation
	   on it's own
2471
	 */
J
James Ketrenos 已提交
2472 2473 2474 2475
	if ((priv->eeprom + EEPROM_VERSION) != 0) {
		IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");

		/* write the eeprom data to sram */
2476
		for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
2477
			ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
J
James Ketrenos 已提交
2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493

		/* Do not load eeprom data on fatal error or suspend */
		ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
	} else {
		IPW_DEBUG_INFO("Enabling FW initializationg of SRAM\n");

		/* Load eeprom data on fatal error or suspend */
		ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
	}

	IPW_DEBUG_TRACE("<<\n");
}

static inline void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
{
	count >>= 2;
2494 2495
	if (!count)
		return;
2496
	_ipw_write32(priv, IPW_AUTOINC_ADDR, start);
2497
	while (count--)
2498
		_ipw_write32(priv, IPW_AUTOINC_DATA, 0);
J
James Ketrenos 已提交
2499 2500 2501 2502
}

static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
{
2503
	ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
2504
			CB_NUMBER_OF_ELEMENTS_SMALL *
J
James Ketrenos 已提交
2505 2506 2507 2508
			sizeof(struct command_block));
}

static int ipw_fw_dma_enable(struct ipw_priv *priv)
2509
{				/* start dma engine but no transfers yet */
J
James Ketrenos 已提交
2510 2511

	IPW_DEBUG_FW(">> : \n");
2512

J
James Ketrenos 已提交
2513 2514
	/* Start the dma */
	ipw_fw_dma_reset_command_blocks(priv);
2515

J
James Ketrenos 已提交
2516
	/* Write CB base address */
2517
	ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
J
James Ketrenos 已提交
2518 2519 2520 2521 2522 2523 2524 2525 2526 2527

	IPW_DEBUG_FW("<< : \n");
	return 0;
}

static void ipw_fw_dma_abort(struct ipw_priv *priv)
{
	u32 control = 0;

	IPW_DEBUG_FW(">> :\n");
2528 2529

	//set the Stop and Abort bit
J
James Ketrenos 已提交
2530
	control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
2531
	ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
J
James Ketrenos 已提交
2532
	priv->sram_desc.last_cb_index = 0;
2533

J
James Ketrenos 已提交
2534 2535 2536
	IPW_DEBUG_FW("<< \n");
}

2537 2538
static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
					  struct command_block *cb)
J
James Ketrenos 已提交
2539
{
2540
	u32 address =
2541
	    IPW_SHARED_SRAM_DMA_CONTROL +
2542
	    (sizeof(struct command_block) * index);
J
James Ketrenos 已提交
2543 2544
	IPW_DEBUG_FW(">> :\n");

2545 2546
	ipw_write_indirect(priv, address, (u8 *) cb,
			   (int)sizeof(struct command_block));
J
James Ketrenos 已提交
2547 2548 2549 2550 2551 2552 2553 2554 2555

	IPW_DEBUG_FW("<< :\n");
	return 0;

}

static int ipw_fw_dma_kick(struct ipw_priv *priv)
{
	u32 control = 0;
2556
	u32 index = 0;
J
James Ketrenos 已提交
2557 2558

	IPW_DEBUG_FW(">> :\n");
2559

J
James Ketrenos 已提交
2560
	for (index = 0; index < priv->sram_desc.last_cb_index; index++)
2561 2562
		ipw_fw_dma_write_command_block(priv, index,
					       &priv->sram_desc.cb_list[index]);
J
James Ketrenos 已提交
2563 2564

	/* Enable the DMA in the CSR register */
2565 2566 2567
	ipw_clear_bit(priv, IPW_RESET_REG,
		      IPW_RESET_REG_MASTER_DISABLED |
		      IPW_RESET_REG_STOP_MASTER);
2568

2569
	/* Set the Start bit. */
J
James Ketrenos 已提交
2570
	control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
2571
	ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
J
James Ketrenos 已提交
2572 2573 2574 2575 2576 2577 2578 2579

	IPW_DEBUG_FW("<< :\n");
	return 0;
}

static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
{
	u32 address;
2580 2581
	u32 register_value = 0;
	u32 cb_fields_address = 0;
J
James Ketrenos 已提交
2582 2583

	IPW_DEBUG_FW(">> :\n");
2584
	address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2585
	IPW_DEBUG_FW_INFO("Current CB is 0x%x \n", address);
J
James Ketrenos 已提交
2586 2587

	/* Read the DMA Controlor register */
2588 2589
	register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
	IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x \n", register_value);
J
James Ketrenos 已提交
2590

2591
	/* Print the CB values */
J
James Ketrenos 已提交
2592 2593
	cb_fields_address = address;
	register_value = ipw_read_reg32(priv, cb_fields_address);
2594
	IPW_DEBUG_FW_INFO("Current CB ControlField is 0x%x \n", register_value);
J
James Ketrenos 已提交
2595 2596 2597

	cb_fields_address += sizeof(u32);
	register_value = ipw_read_reg32(priv, cb_fields_address);
2598
	IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x \n", register_value);
J
James Ketrenos 已提交
2599 2600 2601 2602 2603 2604 2605 2606

	cb_fields_address += sizeof(u32);
	register_value = ipw_read_reg32(priv, cb_fields_address);
	IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x \n",
			  register_value);

	cb_fields_address += sizeof(u32);
	register_value = ipw_read_reg32(priv, cb_fields_address);
2607
	IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x \n", register_value);
J
James Ketrenos 已提交
2608 2609 2610 2611 2612 2613 2614 2615 2616 2617

	IPW_DEBUG_FW(">> :\n");
}

static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
{
	u32 current_cb_address = 0;
	u32 current_cb_index = 0;

	IPW_DEBUG_FW("<< :\n");
2618
	current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2619

2620
	current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
2621
	    sizeof(struct command_block);
2622

J
James Ketrenos 已提交
2623
	IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X \n",
2624
			  current_cb_index, current_cb_address);
J
James Ketrenos 已提交
2625 2626 2627 2628 2629 2630 2631 2632 2633 2634

	IPW_DEBUG_FW(">> :\n");
	return current_cb_index;

}

static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
					u32 src_address,
					u32 dest_address,
					u32 length,
2635
					int interrupt_enabled, int is_last)
J
James Ketrenos 已提交
2636 2637
{

2638
	u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
2639 2640
	    CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
	    CB_DEST_SIZE_LONG;
J
James Ketrenos 已提交
2641
	struct command_block *cb;
2642
	u32 last_cb_element = 0;
J
James Ketrenos 已提交
2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654

	IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
			  src_address, dest_address, length);

	if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
		return -1;

	last_cb_element = priv->sram_desc.last_cb_index;
	cb = &priv->sram_desc.cb_list[last_cb_element];
	priv->sram_desc.last_cb_index++;

	/* Calculate the new CB control word */
2655
	if (interrupt_enabled)
J
James Ketrenos 已提交
2656 2657 2658 2659
		control |= CB_INT_ENABLED;

	if (is_last)
		control |= CB_LAST_VALID;
2660

J
James Ketrenos 已提交
2661 2662 2663
	control |= length;

	/* Calculate the CB Element's checksum value */
2664
	cb->status = control ^ src_address ^ dest_address;
J
James Ketrenos 已提交
2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676

	/* Copy the Source and Destination addresses */
	cb->dest_addr = dest_address;
	cb->source_addr = src_address;

	/* Copy the Control Word last */
	cb->control = control;

	return 0;
}

static int ipw_fw_dma_add_buffer(struct ipw_priv *priv,
2677
				 u32 src_phys, u32 dest_address, u32 length)
J
James Ketrenos 已提交
2678 2679
{
	u32 bytes_left = length;
2680 2681
	u32 src_offset = 0;
	u32 dest_offset = 0;
J
James Ketrenos 已提交
2682 2683 2684 2685 2686
	int status = 0;
	IPW_DEBUG_FW(">> \n");
	IPW_DEBUG_FW_INFO("src_phys=0x%x dest_address=0x%x length=0x%x\n",
			  src_phys, dest_address, length);
	while (bytes_left > CB_MAX_LENGTH) {
2687 2688 2689 2690 2691
		status = ipw_fw_dma_add_command_block(priv,
						      src_phys + src_offset,
						      dest_address +
						      dest_offset,
						      CB_MAX_LENGTH, 0, 0);
J
James Ketrenos 已提交
2692 2693 2694
		if (status) {
			IPW_DEBUG_FW_INFO(": Failed\n");
			return -1;
2695
		} else
J
James Ketrenos 已提交
2696 2697 2698 2699 2700 2701 2702 2703 2704
			IPW_DEBUG_FW_INFO(": Added new cb\n");

		src_offset += CB_MAX_LENGTH;
		dest_offset += CB_MAX_LENGTH;
		bytes_left -= CB_MAX_LENGTH;
	}

	/* add the buffer tail */
	if (bytes_left > 0) {
2705 2706 2707 2708
		status =
		    ipw_fw_dma_add_command_block(priv, src_phys + src_offset,
						 dest_address + dest_offset,
						 bytes_left, 0, 0);
J
James Ketrenos 已提交
2709 2710 2711
		if (status) {
			IPW_DEBUG_FW_INFO(": Failed on the buffer tail\n");
			return -1;
2712
		} else
2713 2714
			IPW_DEBUG_FW_INFO
			    (": Adding new cb - the buffer tail\n");
J
James Ketrenos 已提交
2715
	}
2716

J
James Ketrenos 已提交
2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728
	IPW_DEBUG_FW("<< \n");
	return 0;
}

static int ipw_fw_dma_wait(struct ipw_priv *priv)
{
	u32 current_index = 0;
	u32 watchdog = 0;

	IPW_DEBUG_FW(">> : \n");

	current_index = ipw_fw_dma_command_block_index(priv);
2729
	IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%8X\n",
2730
			  (int)priv->sram_desc.last_cb_index);
J
James Ketrenos 已提交
2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747

	while (current_index < priv->sram_desc.last_cb_index) {
		udelay(50);
		current_index = ipw_fw_dma_command_block_index(priv);

		watchdog++;

		if (watchdog > 400) {
			IPW_DEBUG_FW_INFO("Timeout\n");
			ipw_fw_dma_dump_command_block(priv);
			ipw_fw_dma_abort(priv);
			return -1;
		}
	}

	ipw_fw_dma_abort(priv);

2748
	/*Disable the DMA in the CSR register */
2749 2750
	ipw_set_bit(priv, IPW_RESET_REG,
		    IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
J
James Ketrenos 已提交
2751 2752 2753 2754 2755

	IPW_DEBUG_FW("<< dmaWaitSync \n");
	return 0;
}

2756
static void ipw_remove_current_network(struct ipw_priv *priv)
J
James Ketrenos 已提交
2757 2758
{
	struct list_head *element, *safe;
2759
	struct ieee80211_network *network = NULL;
2760 2761 2762
	unsigned long flags;

	spin_lock_irqsave(&priv->ieee->lock, flags);
J
James Ketrenos 已提交
2763 2764 2765 2766
	list_for_each_safe(element, safe, &priv->ieee->network_list) {
		network = list_entry(element, struct ieee80211_network, list);
		if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
			list_del(element);
2767
			list_add_tail(&network->list,
J
James Ketrenos 已提交
2768 2769 2770
				      &priv->ieee->network_free_list);
		}
	}
2771
	spin_unlock_irqrestore(&priv->ieee->lock, flags);
J
James Ketrenos 已提交
2772 2773 2774
}

/**
2775
 * Check that card is still alive.
J
James Ketrenos 已提交
2776 2777 2778
 * Reads debug register from domain0.
 * If card is present, pre-defined value should
 * be found there.
2779
 *
J
James Ketrenos 已提交
2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793
 * @param priv
 * @return 1 if card is present, 0 otherwise
 */
static inline int ipw_alive(struct ipw_priv *priv)
{
	return ipw_read32(priv, 0x90) == 0xd55555d5;
}

static inline int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
			       int timeout)
{
	int i = 0;

	do {
2794
		if ((ipw_read32(priv, addr) & mask) == mask)
J
James Ketrenos 已提交
2795 2796 2797 2798
			return i;
		mdelay(10);
		i += 10;
	} while (i < timeout);
2799

J
James Ketrenos 已提交
2800 2801 2802
	return -ETIME;
}

2803
/* These functions load the firmware and micro code for the operation of
J
James Ketrenos 已提交
2804 2805 2806 2807
 * the ipw hardware.  It assumes the buffer has all the bits for the
 * image and the caller is handling the memory allocation and clean up.
 */

2808
static int ipw_stop_master(struct ipw_priv *priv)
J
James Ketrenos 已提交
2809 2810
{
	int rc;
2811

J
James Ketrenos 已提交
2812 2813
	IPW_DEBUG_TRACE(">> \n");
	/* stop master. typical delay - 0 */
2814
	ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
J
James Ketrenos 已提交
2815

2816 2817
	rc = ipw_poll_bit(priv, IPW_RESET_REG,
			  IPW_RESET_REG_MASTER_DISABLED, 100);
J
James Ketrenos 已提交
2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832
	if (rc < 0) {
		IPW_ERROR("stop master failed in 10ms\n");
		return -1;
	}

	IPW_DEBUG_INFO("stop master %dms\n", rc);

	return rc;
}

static void ipw_arc_release(struct ipw_priv *priv)
{
	IPW_DEBUG_TRACE(">> \n");
	mdelay(5);

2833
	ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
J
James Ketrenos 已提交
2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849

	/* no one knows timing, for safety add some delay */
	mdelay(5);
}

struct fw_header {
	u32 version;
	u32 mode;
};

struct fw_chunk {
	u32 address;
	u32 length;
};

#define IPW_FW_MAJOR_VERSION 2
2850
#define IPW_FW_MINOR_VERSION 3
J
James Ketrenos 已提交
2851 2852 2853 2854

#define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
#define IPW_FW_MAJOR(x) (x & 0xff)

2855
#define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
J
James Ketrenos 已提交
2856 2857 2858 2859 2860 2861 2862 2863 2864 2865

#define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
"." __stringify(IPW_FW_MINOR_VERSION) "-"

#if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
#define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
#else
#define IPW_FW_NAME(x) "ipw2200_" x ".fw"
#endif

2866
static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
J
James Ketrenos 已提交
2867 2868 2869 2870 2871
{
	int rc = 0, i, addr;
	u8 cr = 0;
	u16 *image;

2872
	image = (u16 *) data;
2873

J
James Ketrenos 已提交
2874 2875 2876 2877 2878 2879
	IPW_DEBUG_TRACE(">> \n");

	rc = ipw_stop_master(priv);

	if (rc < 0)
		return rc;
2880

2881
//      spin_lock_irqsave(&priv->lock, flags);
2882

2883 2884
	for (addr = IPW_SHARED_LOWER_BOUND;
	     addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
J
James Ketrenos 已提交
2885 2886 2887 2888 2889 2890 2891 2892
		ipw_write32(priv, addr, 0);
	}

	/* no ucode (yet) */
	memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
	/* destroy DMA queues */
	/* reset sequence */

2893
	ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
J
James Ketrenos 已提交
2894
	ipw_arc_release(priv);
2895
	ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
J
James Ketrenos 已提交
2896 2897 2898
	mdelay(1);

	/* reset PHY */
2899
	ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
J
James Ketrenos 已提交
2900
	mdelay(1);
2901

2902
	ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
J
James Ketrenos 已提交
2903
	mdelay(1);
2904

J
James Ketrenos 已提交
2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919
	/* enable ucode store */
	ipw_write_reg8(priv, DINO_CONTROL_REG, 0x0);
	ipw_write_reg8(priv, DINO_CONTROL_REG, DINO_ENABLE_CS);
	mdelay(1);

	/* write ucode */
	/**
	 * @bug
	 * Do NOT set indirect address register once and then
	 * store data to indirect data register in the loop.
	 * It seems very reasonable, but in this case DINO do not
	 * accept ucode. It is essential to set address each time.
	 */
	/* load new ipw uCode */
	for (i = 0; i < len / 2; i++)
2920
		ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
2921
				cpu_to_le16(image[i]));
J
James Ketrenos 已提交
2922 2923

	/* enable DINO */
2924 2925
	ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
	ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
J
James Ketrenos 已提交
2926

2927
	/* this is where the igx / win driver deveates from the VAP driver. */
J
James Ketrenos 已提交
2928 2929 2930 2931

	/* wait for alive response */
	for (i = 0; i < 100; i++) {
		/* poll for incoming data */
2932
		cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
J
James Ketrenos 已提交
2933 2934 2935 2936 2937 2938 2939 2940
		if (cr & DINO_RXFIFO_DATA)
			break;
		mdelay(1);
	}

	if (cr & DINO_RXFIFO_DATA) {
		/* alive_command_responce size is NOT multiple of 4 */
		u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
2941 2942

		for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
J
James Ketrenos 已提交
2943
			response_buffer[i] =
2944
			    le32_to_cpu(ipw_read_reg32(priv,
2945
						       IPW_BASEBAND_RX_FIFO_READ));
J
James Ketrenos 已提交
2946 2947 2948 2949 2950
		memcpy(&priv->dino_alive, response_buffer,
		       sizeof(priv->dino_alive));
		if (priv->dino_alive.alive_command == 1
		    && priv->dino_alive.ucode_valid == 1) {
			rc = 0;
2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962
			IPW_DEBUG_INFO
			    ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
			     "of %02d/%02d/%02d %02d:%02d\n",
			     priv->dino_alive.software_revision,
			     priv->dino_alive.software_revision,
			     priv->dino_alive.device_identifier,
			     priv->dino_alive.device_identifier,
			     priv->dino_alive.time_stamp[0],
			     priv->dino_alive.time_stamp[1],
			     priv->dino_alive.time_stamp[2],
			     priv->dino_alive.time_stamp[3],
			     priv->dino_alive.time_stamp[4]);
J
James Ketrenos 已提交
2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973
		} else {
			IPW_DEBUG_INFO("Microcode is not alive\n");
			rc = -EINVAL;
		}
	} else {
		IPW_DEBUG_INFO("No alive response from DINO\n");
		rc = -ETIME;
	}

	/* disable DINO, otherwise for some reason
	   firmware have problem getting alive resp. */
2974
	ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
J
James Ketrenos 已提交
2975

2976
//      spin_unlock_irqrestore(&priv->lock, flags);
J
James Ketrenos 已提交
2977 2978 2979 2980

	return rc;
}

2981
static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
J
James Ketrenos 已提交
2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009
{
	int rc = -1;
	int offset = 0;
	struct fw_chunk *chunk;
	dma_addr_t shared_phys;
	u8 *shared_virt;

	IPW_DEBUG_TRACE("<< : \n");
	shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);

	if (!shared_virt)
		return -ENOMEM;

	memmove(shared_virt, data, len);

	/* Start the Dma */
	rc = ipw_fw_dma_enable(priv);

	if (priv->sram_desc.last_cb_index > 0) {
		/* the DMA is already ready this would be a bug. */
		BUG();
		goto out;
	}

	do {
		chunk = (struct fw_chunk *)(data + offset);
		offset += sizeof(struct fw_chunk);
		/* build DMA packet and queue up for sending */
3010
		/* dma to chunk->address, the chunk->length bytes from data +
J
James Ketrenos 已提交
3011 3012 3013
		 * offeset*/
		/* Dma loading */
		rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
3014 3015
					   le32_to_cpu(chunk->address),
					   le32_to_cpu(chunk->length));
J
James Ketrenos 已提交
3016 3017 3018 3019
		if (rc) {
			IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
			goto out;
		}
3020

3021
		offset += le32_to_cpu(chunk->length);
J
James Ketrenos 已提交
3022 3023
	} while (offset < len);

3024
	/* Run the DMA and wait for the answer */
J
James Ketrenos 已提交
3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035
	rc = ipw_fw_dma_kick(priv);
	if (rc) {
		IPW_ERROR("dmaKick Failed\n");
		goto out;
	}

	rc = ipw_fw_dma_wait(priv);
	if (rc) {
		IPW_ERROR("dmaWaitSync Failed\n");
		goto out;
	}
3036 3037
      out:
	pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
J
James Ketrenos 已提交
3038 3039 3040 3041 3042 3043 3044 3045
	return rc;
}

/* stop nic */
static int ipw_stop_nic(struct ipw_priv *priv)
{
	int rc = 0;

3046
	/* stop */
3047
	ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3048

3049 3050
	rc = ipw_poll_bit(priv, IPW_RESET_REG,
			  IPW_RESET_REG_MASTER_DISABLED, 500);
J
James Ketrenos 已提交
3051 3052 3053
	if (rc < 0) {
		IPW_ERROR("wait for reg master disabled failed\n");
		return rc;
3054
	}
J
James Ketrenos 已提交
3055

3056
	ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3057

J
James Ketrenos 已提交
3058 3059 3060 3061 3062 3063 3064
	return rc;
}

static void ipw_start_nic(struct ipw_priv *priv)
{
	IPW_DEBUG_TRACE(">>\n");

3065
	/* prvHwStartNic  release ARC */
3066 3067 3068
	ipw_clear_bit(priv, IPW_RESET_REG,
		      IPW_RESET_REG_MASTER_DISABLED |
		      IPW_RESET_REG_STOP_MASTER |
J
James Ketrenos 已提交
3069
		      CBD_RESET_REG_PRINCETON_RESET);
3070

J
James Ketrenos 已提交
3071
	/* enable power management */
3072 3073
	ipw_set_bit(priv, IPW_GP_CNTRL_RW,
		    IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
J
James Ketrenos 已提交
3074 3075 3076

	IPW_DEBUG_TRACE("<<\n");
}
3077

J
James Ketrenos 已提交
3078 3079 3080 3081 3082
static int ipw_init_nic(struct ipw_priv *priv)
{
	int rc;

	IPW_DEBUG_TRACE(">>\n");
3083
	/* reset */
J
James Ketrenos 已提交
3084 3085
	/*prvHwInitNic */
	/* set "initialization complete" bit to move adapter to D0 state */
3086
	ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
J
James Ketrenos 已提交
3087 3088

	/* low-level PLL activation */
3089 3090
	ipw_write32(priv, IPW_READ_INT_REGISTER,
		    IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
J
James Ketrenos 已提交
3091 3092

	/* wait for clock stabilization */
3093 3094
	rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
			  IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3095
	if (rc < 0)
J
James Ketrenos 已提交
3096 3097 3098
		IPW_DEBUG_INFO("FAILED wait for clock stablization\n");

	/* assert SW reset */
3099
	ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
J
James Ketrenos 已提交
3100 3101 3102 3103

	udelay(10);

	/* set "initialization complete" bit to move adapter to D0 state */
3104
	ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
J
James Ketrenos 已提交
3105 3106 3107 3108 3109

	IPW_DEBUG_TRACE(">>\n");
	return 0;
}

3110
/* Call this function from process context, it will sleep in request_firmware.
J
James Ketrenos 已提交
3111 3112 3113 3114 3115
 * Probe is an ok place to call this from.
 */
static int ipw_reset_nic(struct ipw_priv *priv)
{
	int rc = 0;
3116
	unsigned long flags;
J
James Ketrenos 已提交
3117 3118

	IPW_DEBUG_TRACE(">>\n");
3119

J
James Ketrenos 已提交
3120
	rc = ipw_init_nic(priv);
3121

3122
	spin_lock_irqsave(&priv->lock, flags);
J
James Ketrenos 已提交
3123 3124 3125
	/* Clear the 'host command active' bit... */
	priv->status &= ~STATUS_HCMD_ACTIVE;
	wake_up_interruptible(&priv->wait_command_queue);
3126 3127
	priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
	wake_up_interruptible(&priv->wait_state);
3128
	spin_unlock_irqrestore(&priv->lock, flags);
J
James Ketrenos 已提交
3129 3130 3131

	IPW_DEBUG_TRACE("<<\n");
	return rc;
3132
}
J
James Ketrenos 已提交
3133

3134
static int ipw_get_fw(struct ipw_priv *priv,
J
James Ketrenos 已提交
3135 3136 3137 3138 3139 3140 3141 3142 3143 3144
		      const struct firmware **fw, const char *name)
{
	struct fw_header *header;
	int rc;

	/* ask firmware_class module to get the boot firmware off disk */
	rc = request_firmware(fw, name, &priv->pci_dev->dev);
	if (rc < 0) {
		IPW_ERROR("%s load failed: Reason %d\n", name, rc);
		return rc;
3145
	}
J
James Ketrenos 已提交
3146 3147

	header = (struct fw_header *)(*fw)->data;
3148
	if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
J
James Ketrenos 已提交
3149 3150
		IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
			  name,
3151 3152
			  IPW_FW_MAJOR(le32_to_cpu(header->version)),
			  IPW_FW_MAJOR_VERSION);
J
James Ketrenos 已提交
3153 3154 3155
		return -EINVAL;
	}

3156
	IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
J
James Ketrenos 已提交
3157
		       name,
3158 3159
		       IPW_FW_MAJOR(le32_to_cpu(header->version)),
		       IPW_FW_MINOR(le32_to_cpu(header->version)),
J
James Ketrenos 已提交
3160 3161 3162 3163
		       (*fw)->size - sizeof(struct fw_header));
	return 0;
}

3164
#define IPW_RX_BUF_SIZE (3000)
J
James Ketrenos 已提交
3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182

static inline void ipw_rx_queue_reset(struct ipw_priv *priv,
				      struct ipw_rx_queue *rxq)
{
	unsigned long flags;
	int i;

	spin_lock_irqsave(&rxq->lock, flags);

	INIT_LIST_HEAD(&rxq->rx_free);
	INIT_LIST_HEAD(&rxq->rx_used);

	/* Fill the rx_used queue with _all_ of the Rx buffers */
	for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
		/* In the reset function, these buffers may have been allocated
		 * to an SKB, so we need to unmap and free potential storage */
		if (rxq->pool[i].skb != NULL) {
			pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
3183
					 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
J
James Ketrenos 已提交
3184
			dev_kfree_skb(rxq->pool[i].skb);
3185
			rxq->pool[i].skb = NULL;
J
James Ketrenos 已提交
3186 3187 3188
		}
		list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
	}
3189

J
James Ketrenos 已提交
3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202
	/* Set us so that we have processed and used all buffers, but have
	 * not restocked the Rx queue with fresh buffers */
	rxq->read = rxq->write = 0;
	rxq->processed = RX_QUEUE_SIZE - 1;
	rxq->free_count = 0;
	spin_unlock_irqrestore(&rxq->lock, flags);
}

#ifdef CONFIG_PM
static int fw_loaded = 0;
static const struct firmware *bootfw = NULL;
static const struct firmware *firmware = NULL;
static const struct firmware *ucode = NULL;
3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215

static void free_firmware(void)
{
	if (fw_loaded) {
		release_firmware(bootfw);
		release_firmware(ucode);
		release_firmware(firmware);
		bootfw = ucode = firmware = NULL;
		fw_loaded = 0;
	}
}
#else
#define free_firmware() do {} while (0)
J
James Ketrenos 已提交
3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230
#endif

static int ipw_load(struct ipw_priv *priv)
{
#ifndef CONFIG_PM
	const struct firmware *bootfw = NULL;
	const struct firmware *firmware = NULL;
	const struct firmware *ucode = NULL;
#endif
	int rc = 0, retries = 3;

#ifdef CONFIG_PM
	if (!fw_loaded) {
#endif
		rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
3231
		if (rc)
J
James Ketrenos 已提交
3232
			goto error;
3233

J
James Ketrenos 已提交
3234 3235
		switch (priv->ieee->iw_mode) {
		case IW_MODE_ADHOC:
3236
			rc = ipw_get_fw(priv, &ucode,
J
James Ketrenos 已提交
3237
					IPW_FW_NAME("ibss_ucode"));
3238
			if (rc)
J
James Ketrenos 已提交
3239
				goto error;
3240

J
James Ketrenos 已提交
3241 3242
			rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss"));
			break;
3243

3244
#ifdef CONFIG_IPW2200_MONITOR
J
James Ketrenos 已提交
3245
		case IW_MODE_MONITOR:
3246
			rc = ipw_get_fw(priv, &ucode,
3247
					IPW_FW_NAME("sniffer_ucode"));
3248
			if (rc)
J
James Ketrenos 已提交
3249
				goto error;
3250

3251 3252
			rc = ipw_get_fw(priv, &firmware,
					IPW_FW_NAME("sniffer"));
J
James Ketrenos 已提交
3253 3254 3255
			break;
#endif
		case IW_MODE_INFRA:
3256
			rc = ipw_get_fw(priv, &ucode, IPW_FW_NAME("bss_ucode"));
3257
			if (rc)
J
James Ketrenos 已提交
3258
				goto error;
3259

J
James Ketrenos 已提交
3260 3261
			rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("bss"));
			break;
3262

J
James Ketrenos 已提交
3263 3264 3265 3266
		default:
			rc = -EINVAL;
		}

3267
		if (rc)
J
James Ketrenos 已提交
3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283
			goto error;

#ifdef CONFIG_PM
		fw_loaded = 1;
	}
#endif

	if (!priv->rxq)
		priv->rxq = ipw_rx_queue_alloc(priv);
	else
		ipw_rx_queue_reset(priv, priv->rxq);
	if (!priv->rxq) {
		IPW_ERROR("Unable to initialize Rx queue\n");
		goto error;
	}

3284
      retry:
J
James Ketrenos 已提交
3285
	/* Ensure interrupts are disabled */
3286
	ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
J
James Ketrenos 已提交
3287 3288 3289
	priv->status &= ~STATUS_INT_ENABLED;

	/* ack pending interrupts */
3290
	ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3291

J
James Ketrenos 已提交
3292 3293 3294 3295 3296 3297 3298 3299
	ipw_stop_nic(priv);

	rc = ipw_reset_nic(priv);
	if (rc) {
		IPW_ERROR("Unable to reset NIC\n");
		goto error;
	}

3300 3301
	ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
			IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
J
James Ketrenos 已提交
3302 3303

	/* DMA the initial boot firmware into the device */
3304
	rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
J
James Ketrenos 已提交
3305 3306
			       bootfw->size - sizeof(struct fw_header));
	if (rc < 0) {
3307
		IPW_ERROR("Unable to load boot firmware: %d\n", rc);
J
James Ketrenos 已提交
3308 3309 3310 3311 3312 3313 3314
		goto error;
	}

	/* kick start the device */
	ipw_start_nic(priv);

	/* wait for the device to finish it's initial startup sequence */
3315 3316
	rc = ipw_poll_bit(priv, IPW_INTA_RW,
			  IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
J
James Ketrenos 已提交
3317 3318 3319 3320 3321 3322
	if (rc < 0) {
		IPW_ERROR("device failed to boot initial fw image\n");
		goto error;
	}
	IPW_DEBUG_INFO("initial device response after %dms\n", rc);

3323
	/* ack fw init done interrupt */
3324
	ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
J
James Ketrenos 已提交
3325 3326

	/* DMA the ucode into the device */
3327
	rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
J
James Ketrenos 已提交
3328 3329
			    ucode->size - sizeof(struct fw_header));
	if (rc < 0) {
3330
		IPW_ERROR("Unable to load ucode: %d\n", rc);
J
James Ketrenos 已提交
3331 3332
		goto error;
	}
3333

J
James Ketrenos 已提交
3334 3335 3336 3337
	/* stop nic */
	ipw_stop_nic(priv);

	/* DMA bss firmware into the device */
3338 3339
	rc = ipw_load_firmware(priv, firmware->data +
			       sizeof(struct fw_header),
J
James Ketrenos 已提交
3340
			       firmware->size - sizeof(struct fw_header));
3341
	if (rc < 0) {
3342
		IPW_ERROR("Unable to load firmware: %d\n", rc);
J
James Ketrenos 已提交
3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354
		goto error;
	}

	ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);

	rc = ipw_queue_reset(priv);
	if (rc) {
		IPW_ERROR("Unable to initialize queues\n");
		goto error;
	}

	/* Ensure interrupts are disabled */
3355
	ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3356
	/* ack pending interrupts */
3357
	ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3358

J
James Ketrenos 已提交
3359 3360 3361
	/* kick start the device */
	ipw_start_nic(priv);

3362
	if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
J
James Ketrenos 已提交
3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374
		if (retries > 0) {
			IPW_WARNING("Parity error.  Retrying init.\n");
			retries--;
			goto retry;
		}

		IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
		rc = -EIO;
		goto error;
	}

	/* wait for the device */
3375 3376
	rc = ipw_poll_bit(priv, IPW_INTA_RW,
			  IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
J
James Ketrenos 已提交
3377 3378 3379 3380 3381 3382 3383
	if (rc < 0) {
		IPW_ERROR("device failed to start after 500ms\n");
		goto error;
	}
	IPW_DEBUG_INFO("device response after %dms\n", rc);

	/* ack fw init done interrupt */
3384
	ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
J
James Ketrenos 已提交
3385 3386 3387

	/* read eeprom data and initialize the eeprom region of sram */
	priv->eeprom_delay = 1;
3388
	ipw_eeprom_init_sram(priv);
J
James Ketrenos 已提交
3389 3390 3391 3392 3393 3394 3395

	/* enable interrupts */
	ipw_enable_interrupts(priv);

	/* Ensure our queue has valid packets */
	ipw_rx_queue_replenish(priv);

3396
	ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
J
James Ketrenos 已提交
3397 3398

	/* ack pending interrupts */
3399
	ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
J
James Ketrenos 已提交
3400 3401 3402 3403 3404 3405 3406 3407

#ifndef CONFIG_PM
	release_firmware(bootfw);
	release_firmware(ucode);
	release_firmware(firmware);
#endif
	return 0;

3408
      error:
J
James Ketrenos 已提交
3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427
	if (priv->rxq) {
		ipw_rx_queue_free(priv, priv->rxq);
		priv->rxq = NULL;
	}
	ipw_tx_queue_free(priv);
	if (bootfw)
		release_firmware(bootfw);
	if (ucode)
		release_firmware(ucode);
	if (firmware)
		release_firmware(firmware);
#ifdef CONFIG_PM
	fw_loaded = 0;
	bootfw = ucode = firmware = NULL;
#endif

	return rc;
}

3428
/**
J
James Ketrenos 已提交
3429 3430 3431 3432 3433 3434 3435 3436
 * DMA services
 *
 * Theory of operation
 *
 * A queue is a circular buffers with 'Read' and 'Write' pointers.
 * 2 empty entries always kept in the buffer to protect from overflow.
 *
 * For Tx queue, there are low mark and high mark limits. If, after queuing
3437 3438
 * the packet for Tx, free space become < low mark, Tx queue stopped. When
 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
J
James Ketrenos 已提交
3439 3440 3441 3442
 * Tx queue resumed.
 *
 * The IPW operates with six queues, one receive queue in the device's
 * sram, one transmit queue for sending commands to the device firmware,
3443
 * and four transmit queues for data.
J
James Ketrenos 已提交
3444
 *
3445
 * The four transmit queues allow for performing quality of service (qos)
J
James Ketrenos 已提交
3446
 * transmissions as per the 802.11 protocol.  Currently Linux does not
3447
 * provide a mechanism to the user for utilizing prioritized queues, so
J
James Ketrenos 已提交
3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472
 * we only utilize the first data transmit queue (queue1).
 */

/**
 * Driver allocates buffers of this size for Rx
 */

static inline int ipw_queue_space(const struct clx2_queue *q)
{
	int s = q->last_used - q->first_empty;
	if (s <= 0)
		s += q->n_bd;
	s -= 2;			/* keep some reserve to not confuse empty and full situations */
	if (s < 0)
		s = 0;
	return s;
}

static inline int ipw_queue_inc_wrap(int index, int n_bd)
{
	return (++index == n_bd) ? 0 : index;
}

/**
 * Initialize common DMA queue structure
3473
 *
J
James Ketrenos 已提交
3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484
 * @param q                queue to init
 * @param count            Number of BD's to allocate. Should be power of 2
 * @param read_register    Address for 'read' register
 *                         (not offset within BAR, full address)
 * @param write_register   Address for 'write' register
 *                         (not offset within BAR, full address)
 * @param base_register    Address for 'base' register
 *                         (not offset within BAR, full address)
 * @param size             Address for 'size' register
 *                         (not offset within BAR, full address)
 */
3485
static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3486
			   int count, u32 read, u32 write, u32 base, u32 size)
J
James Ketrenos 已提交
3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509
{
	q->n_bd = count;

	q->low_mark = q->n_bd / 4;
	if (q->low_mark < 4)
		q->low_mark = 4;

	q->high_mark = q->n_bd / 8;
	if (q->high_mark < 2)
		q->high_mark = 2;

	q->first_empty = q->last_used = 0;
	q->reg_r = read;
	q->reg_w = write;

	ipw_write32(priv, base, q->dma_addr);
	ipw_write32(priv, size, count);
	ipw_write32(priv, read, 0);
	ipw_write32(priv, write, 0);

	_ipw_read32(priv, 0x90);
}

3510
static int ipw_queue_tx_init(struct ipw_priv *priv,
J
James Ketrenos 已提交
3511
			     struct clx2_tx_queue *q,
3512
			     int count, u32 read, u32 write, u32 base, u32 size)
J
James Ketrenos 已提交
3513 3514 3515 3516 3517 3518 3519 3520 3521
{
	struct pci_dev *dev = priv->pci_dev;

	q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
	if (!q->txb) {
		IPW_ERROR("vmalloc for auxilary BD structures failed\n");
		return -ENOMEM;
	}

3522 3523
	q->bd =
	    pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
J
James Ketrenos 已提交
3524
	if (!q->bd) {
3525
		IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
3526
			  sizeof(q->bd[0]) * count);
J
James Ketrenos 已提交
3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538
		kfree(q->txb);
		q->txb = NULL;
		return -ENOMEM;
	}

	ipw_queue_init(priv, &q->q, count, read, write, base, size);
	return 0;
}

/**
 * Free one TFD, those at index [txq->q.last_used].
 * Do NOT advance any indexes
3539
 *
J
James Ketrenos 已提交
3540 3541 3542 3543 3544 3545 3546 3547 3548
 * @param dev
 * @param txq
 */
static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
				  struct clx2_tx_queue *txq)
{
	struct tfd_frame *bd = &txq->bd[txq->q.last_used];
	struct pci_dev *dev = priv->pci_dev;
	int i;
3549

J
James Ketrenos 已提交
3550 3551 3552 3553 3554 3555
	/* classify bd */
	if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
		/* nothing to cleanup after for host commands */
		return;

	/* sanity check */
3556 3557 3558
	if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
		IPW_ERROR("Too many chunks: %i\n",
			  le32_to_cpu(bd->u.data.num_chunks));
J
James Ketrenos 已提交
3559 3560 3561 3562 3563
		/** @todo issue fatal error, it is quite serious situation */
		return;
	}

	/* unmap chunks if any */
3564 3565 3566 3567
	for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
		pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
				 le16_to_cpu(bd->u.data.chunk_len[i]),
				 PCI_DMA_TODEVICE);
J
James Ketrenos 已提交
3568 3569 3570 3571 3572 3573 3574 3575 3576
		if (txq->txb[txq->q.last_used]) {
			ieee80211_txb_free(txq->txb[txq->q.last_used]);
			txq->txb[txq->q.last_used] = NULL;
		}
	}
}

/**
 * Deallocate DMA queue.
3577
 *
J
James Ketrenos 已提交
3578 3579
 * Empty queue by removing and destroying all BD's.
 * Free all buffers.
3580
 *
J
James Ketrenos 已提交
3581 3582 3583
 * @param dev
 * @param q
 */
3584
static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
J
James Ketrenos 已提交
3585 3586 3587 3588
{
	struct clx2_queue *q = &txq->q;
	struct pci_dev *dev = priv->pci_dev;

3589 3590
	if (q->n_bd == 0)
		return;
J
James Ketrenos 已提交
3591 3592 3593 3594 3595 3596

	/* first, empty all BD's */
	for (; q->first_empty != q->last_used;
	     q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
		ipw_queue_tx_free_tfd(priv, txq);
	}
3597

J
James Ketrenos 已提交
3598
	/* free buffers belonging to queue itself */
3599
	pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
J
James Ketrenos 已提交
3600 3601 3602 3603 3604 3605 3606 3607 3608
			    q->dma_addr);
	kfree(txq->txb);

	/* 0 fill whole structure */
	memset(txq, 0, sizeof(*txq));
}

/**
 * Destroy all DMA queues and structures
3609
 *
J
James Ketrenos 已提交
3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623
 * @param priv
 */
static void ipw_tx_queue_free(struct ipw_priv *priv)
{
	/* Tx CMD queue */
	ipw_queue_tx_free(priv, &priv->txq_cmd);

	/* Tx queues */
	ipw_queue_tx_free(priv, &priv->txq[0]);
	ipw_queue_tx_free(priv, &priv->txq[1]);
	ipw_queue_tx_free(priv, &priv->txq[2]);
	ipw_queue_tx_free(priv, &priv->txq[3]);
}

3624
static inline void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
J
James Ketrenos 已提交
3625 3626 3627 3628 3629 3630 3631
{
	/* First 3 bytes are manufacturer */
	bssid[0] = priv->mac_addr[0];
	bssid[1] = priv->mac_addr[1];
	bssid[2] = priv->mac_addr[2];

	/* Last bytes are random */
3632
	get_random_bytes(&bssid[3], ETH_ALEN - 3);
J
James Ketrenos 已提交
3633

3634 3635
	bssid[0] &= 0xfe;	/* clear multicast bit */
	bssid[0] |= 0x02;	/* set local assignment bit (IEEE802) */
J
James Ketrenos 已提交
3636 3637
}

3638
static inline u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
J
James Ketrenos 已提交
3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664
{
	struct ipw_station_entry entry;
	int i;

	for (i = 0; i < priv->num_stations; i++) {
		if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
			/* Another node is active in network */
			priv->missed_adhoc_beacons = 0;
			if (!(priv->config & CFG_STATIC_CHANNEL))
				/* when other nodes drop out, we drop out */
				priv->config &= ~CFG_ADHOC_PERSIST;

			return i;
		}
	}

	if (i == MAX_STATIONS)
		return IPW_INVALID_STATION;

	IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));

	entry.reserved = 0;
	entry.support_mode = 0;
	memcpy(entry.mac_addr, bssid, ETH_ALEN);
	memcpy(priv->stations[i], bssid, ETH_ALEN);
	ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3665
			 &entry, sizeof(entry));
J
James Ketrenos 已提交
3666 3667 3668 3669 3670
	priv->num_stations++;

	return i;
}

3671
static inline u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
J
James Ketrenos 已提交
3672 3673 3674
{
	int i;

3675 3676
	for (i = 0; i < priv->num_stations; i++)
		if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
J
James Ketrenos 已提交
3677 3678 3679 3680 3681 3682 3683 3684 3685
			return i;

	return IPW_INVALID_STATION;
}

static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
{
	int err;

3686 3687 3688 3689 3690 3691 3692
	if (priv->status & STATUS_ASSOCIATING) {
		IPW_DEBUG_ASSOC("Disassociating while associating.\n");
		queue_work(priv->workqueue, &priv->disassociate);
		return;
	}

	if (!(priv->status & STATUS_ASSOCIATED)) {
J
James Ketrenos 已提交
3693 3694 3695 3696 3697 3698
		IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
		return;
	}

	IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
			"on channel %d.\n",
3699
			MAC_ARG(priv->assoc_request.bssid),
J
James Ketrenos 已提交
3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712
			priv->assoc_request.channel);

	if (quiet)
		priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
	else
		priv->assoc_request.assoc_type = HC_DISASSOCIATE;
	err = ipw_send_associate(priv, &priv->assoc_request);
	if (err) {
		IPW_DEBUG_HC("Attempt to send [dis]associate command "
			     "failed.\n");
		return;
	}

3713 3714 3715
	priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
	priv->status |= STATUS_DISASSOCIATING;

J
James Ketrenos 已提交
3716 3717
}

3718
static int ipw_disassociate(void *data)
J
James Ketrenos 已提交
3719
{
3720 3721 3722
	struct ipw_priv *priv = data;
	if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
		return 0;
J
James Ketrenos 已提交
3723
	ipw_send_disassociate(data, 0);
3724 3725 3726 3727 3728 3729 3730 3731 3732
	return 1;
}

static void ipw_bg_disassociate(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_disassociate(data);
	up(&priv->sem);
J
James Ketrenos 已提交
3733 3734
}

3735 3736 3737 3738 3739 3740
static void ipw_system_config(void *data)
{
	struct ipw_priv *priv = data;
	ipw_send_system_config(priv, &priv->sys_config);
}

J
James Ketrenos 已提交
3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754
struct ipw_status_code {
	u16 status;
	const char *reason;
};

static const struct ipw_status_code ipw_status_codes[] = {
	{0x00, "Successful"},
	{0x01, "Unspecified failure"},
	{0x0A, "Cannot support all requested capabilities in the "
	 "Capability information field"},
	{0x0B, "Reassociation denied due to inability to confirm that "
	 "association exists"},
	{0x0C, "Association denied due to reason outside the scope of this "
	 "standard"},
3755 3756
	{0x0D,
	 "Responding station does not support the specified authentication "
J
James Ketrenos 已提交
3757
	 "algorithm"},
3758 3759
	{0x0E,
	 "Received an Authentication frame with authentication sequence "
J
James Ketrenos 已提交
3760 3761 3762 3763 3764 3765
	 "transaction sequence number out of expected sequence"},
	{0x0F, "Authentication rejected because of challenge failure"},
	{0x10, "Authentication rejected due to timeout waiting for next "
	 "frame in sequence"},
	{0x11, "Association denied because AP is unable to handle additional "
	 "associated stations"},
3766 3767
	{0x12,
	 "Association denied due to requesting station not supporting all "
J
James Ketrenos 已提交
3768
	 "of the datarates in the BSSBasicServiceSet Parameter"},
3769 3770
	{0x13,
	 "Association denied due to requesting station not supporting "
J
James Ketrenos 已提交
3771
	 "short preamble operation"},
3772 3773
	{0x14,
	 "Association denied due to requesting station not supporting "
J
James Ketrenos 已提交
3774
	 "PBCC encoding"},
3775 3776
	{0x15,
	 "Association denied due to requesting station not supporting "
J
James Ketrenos 已提交
3777
	 "channel agility"},
3778 3779
	{0x19,
	 "Association denied due to requesting station not supporting "
J
James Ketrenos 已提交
3780
	 "short slot operation"},
3781 3782
	{0x1A,
	 "Association denied due to requesting station not supporting "
J
James Ketrenos 已提交
3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793
	 "DSSS-OFDM operation"},
	{0x28, "Invalid Information Element"},
	{0x29, "Group Cipher is not valid"},
	{0x2A, "Pairwise Cipher is not valid"},
	{0x2B, "AKMP is not valid"},
	{0x2C, "Unsupported RSN IE version"},
	{0x2D, "Invalid RSN IE Capabilities"},
	{0x2E, "Cipher suite is rejected per security policy"},
};

#ifdef CONFIG_IPW_DEBUG
3794
static const char *ipw_get_status_code(u16 status)
J
James Ketrenos 已提交
3795 3796
{
	int i;
3797
	for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
3798
		if (ipw_status_codes[i].status == (status & 0xff))
J
James Ketrenos 已提交
3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845
			return ipw_status_codes[i].reason;
	return "Unknown status value.";
}
#endif

static void inline average_init(struct average *avg)
{
	memset(avg, 0, sizeof(*avg));
}

static void inline average_add(struct average *avg, s16 val)
{
	avg->sum -= avg->entries[avg->pos];
	avg->sum += val;
	avg->entries[avg->pos++] = val;
	if (unlikely(avg->pos == AVG_ENTRIES)) {
		avg->init = 1;
		avg->pos = 0;
	}
}

static s16 inline average_value(struct average *avg)
{
	if (!unlikely(avg->init)) {
		if (avg->pos)
			return avg->sum / avg->pos;
		return 0;
	}

	return avg->sum / AVG_ENTRIES;
}

static void ipw_reset_stats(struct ipw_priv *priv)
{
	u32 len = sizeof(u32);

	priv->quality = 0;

	average_init(&priv->average_missed_beacons);
	average_init(&priv->average_rssi);
	average_init(&priv->average_noise);

	priv->last_rate = 0;
	priv->last_missed_beacons = 0;
	priv->last_rx_packets = 0;
	priv->last_tx_packets = 0;
	priv->last_tx_failures = 0;
3846

J
James Ketrenos 已提交
3847 3848
	/* Firmware managed, reset only when NIC is restarted, so we have to
	 * normalize on the current value */
3849
	ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
J
James Ketrenos 已提交
3850
			&priv->last_rx_err, &len);
3851
	ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
J
James Ketrenos 已提交
3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873
			&priv->last_tx_failures, &len);

	/* Driver managed, reset with each association */
	priv->missed_adhoc_beacons = 0;
	priv->missed_beacons = 0;
	priv->tx_packets = 0;
	priv->rx_packets = 0;

}

static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
{
	u32 i = 0x80000000;
	u32 mask = priv->rates_mask;
	/* If currently associated in B mode, restrict the maximum
	 * rate match to B rates */
	if (priv->assoc_request.ieee_mode == IPW_B_MODE)
		mask &= IEEE80211_CCK_RATES_MASK;

	/* TODO: Verify that the rate is supported by the current rates
	 * list. */

3874 3875
	while (i && !(mask & i))
		i >>= 1;
J
James Ketrenos 已提交
3876
	switch (i) {
3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900
	case IEEE80211_CCK_RATE_1MB_MASK:
		return 1000000;
	case IEEE80211_CCK_RATE_2MB_MASK:
		return 2000000;
	case IEEE80211_CCK_RATE_5MB_MASK:
		return 5500000;
	case IEEE80211_OFDM_RATE_6MB_MASK:
		return 6000000;
	case IEEE80211_OFDM_RATE_9MB_MASK:
		return 9000000;
	case IEEE80211_CCK_RATE_11MB_MASK:
		return 11000000;
	case IEEE80211_OFDM_RATE_12MB_MASK:
		return 12000000;
	case IEEE80211_OFDM_RATE_18MB_MASK:
		return 18000000;
	case IEEE80211_OFDM_RATE_24MB_MASK:
		return 24000000;
	case IEEE80211_OFDM_RATE_36MB_MASK:
		return 36000000;
	case IEEE80211_OFDM_RATE_48MB_MASK:
		return 48000000;
	case IEEE80211_OFDM_RATE_54MB_MASK:
		return 54000000;
J
James Ketrenos 已提交
3901 3902
	}

3903
	if (priv->ieee->mode == IEEE_B)
J
James Ketrenos 已提交
3904 3905 3906 3907 3908 3909 3910 3911 3912 3913
		return 11000000;
	else
		return 54000000;
}

static u32 ipw_get_current_rate(struct ipw_priv *priv)
{
	u32 rate, len = sizeof(rate);
	int err;

3914
	if (!(priv->status & STATUS_ASSOCIATED))
J
James Ketrenos 已提交
3915 3916 3917
		return 0;

	if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
3918
		err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
J
James Ketrenos 已提交
3919 3920 3921 3922 3923
				      &len);
		if (err) {
			IPW_DEBUG_INFO("failed querying ordinals.\n");
			return 0;
		}
3924
	} else
J
James Ketrenos 已提交
3925 3926 3927
		return ipw_get_max_rate(priv);

	switch (rate) {
3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951
	case IPW_TX_RATE_1MB:
		return 1000000;
	case IPW_TX_RATE_2MB:
		return 2000000;
	case IPW_TX_RATE_5MB:
		return 5500000;
	case IPW_TX_RATE_6MB:
		return 6000000;
	case IPW_TX_RATE_9MB:
		return 9000000;
	case IPW_TX_RATE_11MB:
		return 11000000;
	case IPW_TX_RATE_12MB:
		return 12000000;
	case IPW_TX_RATE_18MB:
		return 18000000;
	case IPW_TX_RATE_24MB:
		return 24000000;
	case IPW_TX_RATE_36MB:
		return 36000000;
	case IPW_TX_RATE_48MB:
		return 48000000;
	case IPW_TX_RATE_54MB:
		return 54000000;
J
James Ketrenos 已提交
3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965
	}

	return 0;
}

#define IPW_STATS_INTERVAL (2 * HZ)
static void ipw_gather_stats(struct ipw_priv *priv)
{
	u32 rx_err, rx_err_delta, rx_packets_delta;
	u32 tx_failures, tx_failures_delta, tx_packets_delta;
	u32 missed_beacons_percent, missed_beacons_delta;
	u32 quality = 0;
	u32 len = sizeof(u32);
	s16 rssi;
3966
	u32 beacon_quality, signal_quality, tx_quality, rx_quality,
3967
	    rate_quality;
3968
	u32 max_rate;
J
James Ketrenos 已提交
3969 3970 3971 3972 3973 3974 3975

	if (!(priv->status & STATUS_ASSOCIATED)) {
		priv->quality = 0;
		return;
	}

	/* Update the statistics */
3976
	ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
J
James Ketrenos 已提交
3977
			&priv->missed_beacons, &len);
3978
	missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
J
James Ketrenos 已提交
3979 3980 3981
	priv->last_missed_beacons = priv->missed_beacons;
	if (priv->assoc_request.beacon_interval) {
		missed_beacons_percent = missed_beacons_delta *
3982 3983
		    (HZ * priv->assoc_request.beacon_interval) /
		    (IPW_STATS_INTERVAL * 10);
J
James Ketrenos 已提交
3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003
	} else {
		missed_beacons_percent = 0;
	}
	average_add(&priv->average_missed_beacons, missed_beacons_percent);

	ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
	rx_err_delta = rx_err - priv->last_rx_err;
	priv->last_rx_err = rx_err;

	ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
	tx_failures_delta = tx_failures - priv->last_tx_failures;
	priv->last_tx_failures = tx_failures;

	rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
	priv->last_rx_packets = priv->rx_packets;

	tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
	priv->last_tx_packets = priv->tx_packets;

	/* Calculate quality based on the following:
4004
	 *
J
James Ketrenos 已提交
4005 4006 4007 4008 4009
	 * Missed beacon: 100% = 0, 0% = 70% missed
	 * Rate: 60% = 1Mbs, 100% = Max
	 * Rx and Tx errors represent a straight % of total Rx/Tx
	 * RSSI: 100% = > -50,  0% = < -80
	 * Rx errors: 100% = 0, 0% = 50% missed
4010
	 *
J
James Ketrenos 已提交
4011 4012 4013 4014 4015 4016 4017 4018
	 * The lowest computed quality is used.
	 *
	 */
#define BEACON_THRESHOLD 5
	beacon_quality = 100 - missed_beacons_percent;
	if (beacon_quality < BEACON_THRESHOLD)
		beacon_quality = 0;
	else
4019
		beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4020
		    (100 - BEACON_THRESHOLD);
4021
	IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
J
James Ketrenos 已提交
4022
			beacon_quality, missed_beacons_percent);
4023

J
James Ketrenos 已提交
4024
	priv->last_rate = ipw_get_current_rate(priv);
4025 4026
	max_rate = ipw_get_max_rate(priv);
	rate_quality = priv->last_rate * 40 / max_rate + 60;
J
James Ketrenos 已提交
4027 4028
	IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
			rate_quality, priv->last_rate / 1000000);
4029

4030
	if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4031
		rx_quality = 100 - (rx_err_delta * 100) /
4032
		    (rx_packets_delta + rx_err_delta);
J
James Ketrenos 已提交
4033 4034 4035 4036
	else
		rx_quality = 100;
	IPW_DEBUG_STATS("Rx quality   : %3d%% (%u errors, %u packets)\n",
			rx_quality, rx_err_delta, rx_packets_delta);
4037

4038
	if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4039
		tx_quality = 100 - (tx_failures_delta * 100) /
4040
		    (tx_packets_delta + tx_failures_delta);
J
James Ketrenos 已提交
4041 4042 4043 4044
	else
		tx_quality = 100;
	IPW_DEBUG_STATS("Tx quality   : %3d%% (%u errors, %u packets)\n",
			tx_quality, tx_failures_delta, tx_packets_delta);
4045

J
James Ketrenos 已提交
4046
	rssi = average_value(&priv->average_rssi);
4047 4048 4049 4050 4051 4052 4053 4054 4055 4056
	signal_quality =
	    (100 *
	     (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
	     (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
	     (priv->ieee->perfect_rssi - rssi) *
	     (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
	      62 * (priv->ieee->perfect_rssi - rssi))) /
	    ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
	     (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
	if (signal_quality > 100)
J
James Ketrenos 已提交
4057
		signal_quality = 100;
4058
	else if (signal_quality < 1)
J
James Ketrenos 已提交
4059
		signal_quality = 0;
4060

J
James Ketrenos 已提交
4061 4062
	IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
			signal_quality, rssi);
4063 4064

	quality = min(beacon_quality,
J
James Ketrenos 已提交
4065 4066 4067
		      min(rate_quality,
			  min(tx_quality, min(rx_quality, signal_quality))));
	if (quality == beacon_quality)
4068 4069
		IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
				quality);
J
James Ketrenos 已提交
4070
	if (quality == rate_quality)
4071 4072
		IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
				quality);
J
James Ketrenos 已提交
4073
	if (quality == tx_quality)
4074 4075
		IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
				quality);
J
James Ketrenos 已提交
4076
	if (quality == rx_quality)
4077 4078
		IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
				quality);
J
James Ketrenos 已提交
4079
	if (quality == signal_quality)
4080 4081
		IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
				quality);
J
James Ketrenos 已提交
4082 4083

	priv->quality = quality;
4084 4085

	queue_delayed_work(priv->workqueue, &priv->gather_stats,
J
James Ketrenos 已提交
4086 4087 4088
			   IPW_STATS_INTERVAL);
}

4089 4090 4091 4092 4093 4094 4095 4096
static void ipw_bg_gather_stats(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_gather_stats(data);
	up(&priv->sem);
}

4097 4098 4099 4100 4101
static inline void ipw_handle_missed_beacon(struct ipw_priv *priv,
					    int missed_count)
{
	priv->notif_missed_beacons = missed_count;

4102
	if (missed_count > priv->disassociate_threshold &&
4103 4104 4105 4106 4107
	    priv->status & STATUS_ASSOCIATED) {
		/* If associated and we've hit the missed
		 * beacon threshold, disassociate, turn
		 * off roaming, and abort any active scans */
		IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4108
			  IPW_DL_STATE | IPW_DL_ASSOC,
4109 4110
			  "Missed beacon: %d - disassociate\n", missed_count);
		priv->status &= ~STATUS_ROAMING;
4111 4112 4113 4114
		if (priv->status & STATUS_SCANNING) {
			IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
				  IPW_DL_STATE,
				  "Aborting scan with missed beacon.\n");
4115
			queue_work(priv->workqueue, &priv->abort_scan);
4116 4117
		}

4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150
		queue_work(priv->workqueue, &priv->disassociate);
		return;
	}

	if (priv->status & STATUS_ROAMING) {
		/* If we are currently roaming, then just
		 * print a debug statement... */
		IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
			  "Missed beacon: %d - roam in progress\n",
			  missed_count);
		return;
	}

	if (missed_count > priv->roaming_threshold) {
		/* If we are not already roaming, set the ROAM
		 * bit in the status and kick off a scan */
		IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
			  "Missed beacon: %d - initiate "
			  "roaming\n", missed_count);
		if (!(priv->status & STATUS_ROAMING)) {
			priv->status |= STATUS_ROAMING;
			if (!(priv->status & STATUS_SCANNING))
				queue_work(priv->workqueue,
					   &priv->request_scan);
		}
		return;
	}

	if (priv->status & STATUS_SCANNING) {
		/* Stop scan to keep fw from getting
		 * stuck (only if we aren't roaming --
		 * otherwise we'll never scan more than 2 or 3
		 * channels..) */
4151 4152
		IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
			  "Aborting scan with missed beacon.\n");
4153 4154 4155 4156 4157 4158 4159
		queue_work(priv->workqueue, &priv->abort_scan);
	}

	IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);

}

J
James Ketrenos 已提交
4160 4161 4162 4163
/**
 * Handle host notification packet.
 * Called from interrupt routine
 */
4164
static inline void ipw_rx_notification(struct ipw_priv *priv,
J
James Ketrenos 已提交
4165 4166
				       struct ipw_rx_notification *notif)
{
4167 4168
	notif->size = le16_to_cpu(notif->size);

4169
	IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
4170

J
James Ketrenos 已提交
4171
	switch (notif->subtype) {
4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211
	case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
			struct notif_association *assoc = &notif->u.assoc;

			switch (assoc->state) {
			case CMAS_ASSOCIATED:{
					IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
						  IPW_DL_ASSOC,
						  "associated: '%s' " MAC_FMT
						  " \n",
						  escape_essid(priv->essid,
							       priv->essid_len),
						  MAC_ARG(priv->bssid));

					switch (priv->ieee->iw_mode) {
					case IW_MODE_INFRA:
						memcpy(priv->ieee->bssid,
						       priv->bssid, ETH_ALEN);
						break;

					case IW_MODE_ADHOC:
						memcpy(priv->ieee->bssid,
						       priv->bssid, ETH_ALEN);

						/* clear out the station table */
						priv->num_stations = 0;

						IPW_DEBUG_ASSOC
						    ("queueing adhoc check\n");
						queue_delayed_work(priv->
								   workqueue,
								   &priv->
								   adhoc_check,
								   priv->
								   assoc_request.
								   beacon_interval);
						break;
					}

					priv->status &= ~STATUS_ASSOCIATING;
					priv->status |= STATUS_ASSOCIATED;
4212 4213
					queue_work(priv->workqueue,
						   &priv->system_config);
4214

4215
#ifdef CONFIG_IPW_QOS
4216 4217 4218 4219 4220
#define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
			 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
					if ((priv->status & STATUS_AUTH) &&
					    (IPW_GET_PACKET_STYPE(&notif->u.raw)
					     == IEEE80211_STYPE_ASSOC_RESP)) {
4221 4222
						if ((sizeof
						     (struct
4223
						      ieee80211_assoc_response)
4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240
						     <= notif->size)
						    && (notif->size <= 2314)) {
							struct
							ieee80211_rx_stats
							    stats = {
								.len =
								    notif->
								    size - 1,
							};

							IPW_DEBUG_QOS
							    ("QoS Associate "
							     "size %d\n",
							     notif->size);
							ieee80211_rx_mgt(priv->
									 ieee,
									 (struct
4241
									  ieee80211_hdr_4addr
4242 4243 4244 4245 4246 4247
									  *)
									 &notif->u.raw, &stats);
						}
					}
#endif

4248
					schedule_work(&priv->link_up);
4249 4250 4251

					break;
				}
4252

4253 4254 4255 4256
			case CMAS_AUTHENTICATED:{
					if (priv->
					    status & (STATUS_ASSOCIATED |
						      STATUS_AUTH)) {
J
James Ketrenos 已提交
4257
#ifdef CONFIG_IPW_DEBUG
4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274
						struct notif_authenticate *auth
						    = &notif->u.auth;
						IPW_DEBUG(IPW_DL_NOTIF |
							  IPW_DL_STATE |
							  IPW_DL_ASSOC,
							  "deauthenticated: '%s' "
							  MAC_FMT
							  ": (0x%04X) - %s \n",
							  escape_essid(priv->
								       essid,
								       priv->
								       essid_len),
							  MAC_ARG(priv->bssid),
							  ntohs(auth->status),
							  ipw_get_status_code
							  (ntohs
							   (auth->status)));
J
James Ketrenos 已提交
4275 4276
#endif

4277 4278 4279 4280 4281
						priv->status &=
						    ~(STATUS_ASSOCIATING |
						      STATUS_AUTH |
						      STATUS_ASSOCIATED);

4282
						schedule_work(&priv->link_down);
4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296
						break;
					}

					IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
						  IPW_DL_ASSOC,
						  "authenticated: '%s' " MAC_FMT
						  "\n",
						  escape_essid(priv->essid,
							       priv->essid_len),
						  MAC_ARG(priv->bssid));
					break;
				}

			case CMAS_INIT:{
4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314
					if (priv->status & STATUS_AUTH) {
						struct
						    ieee80211_assoc_response
						*resp;
						resp =
						    (struct
						     ieee80211_assoc_response
						     *)&notif->u.raw;
						IPW_DEBUG(IPW_DL_NOTIF |
							  IPW_DL_STATE |
							  IPW_DL_ASSOC,
							  "association failed (0x%04X): %s\n",
							  ntohs(resp->status),
							  ipw_get_status_code
							  (ntohs
							   (resp->status)));
					}

4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326
					IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
						  IPW_DL_ASSOC,
						  "disassociated: '%s' " MAC_FMT
						  " \n",
						  escape_essid(priv->essid,
							       priv->essid_len),
						  MAC_ARG(priv->bssid));

					priv->status &=
					    ~(STATUS_DISASSOCIATING |
					      STATUS_ASSOCIATING |
					      STATUS_ASSOCIATED | STATUS_AUTH);
4327 4328 4329 4330 4331 4332
					if (priv->assoc_network
					    && (priv->assoc_network->
						capability &
						WLAN_CAPABILITY_IBSS))
						ipw_remove_current_network
						    (priv);
4333

4334
					schedule_work(&priv->link_down);
4335 4336 4337

					break;
				}
J
James Ketrenos 已提交
4338

4339 4340 4341
			case CMAS_RX_ASSOC_RESP:
				break;

4342 4343 4344
			default:
				IPW_ERROR("assoc: unknown (%d)\n",
					  assoc->state);
J
James Ketrenos 已提交
4345
				break;
4346
			}
J
James Ketrenos 已提交
4347 4348 4349

			break;
		}
4350

4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361
	case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
			struct notif_authenticate *auth = &notif->u.auth;
			switch (auth->state) {
			case CMAS_AUTHENTICATED:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
					  "authenticated: '%s' " MAC_FMT " \n",
					  escape_essid(priv->essid,
						       priv->essid_len),
					  MAC_ARG(priv->bssid));
				priv->status |= STATUS_AUTH;
				break;
J
James Ketrenos 已提交
4362

4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378
			case CMAS_INIT:
				if (priv->status & STATUS_AUTH) {
					IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
						  IPW_DL_ASSOC,
						  "authentication failed (0x%04X): %s\n",
						  ntohs(auth->status),
						  ipw_get_status_code(ntohs
								      (auth->
								       status)));
				}
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC,
					  "deauthenticated: '%s' " MAC_FMT "\n",
					  escape_essid(priv->essid,
						       priv->essid_len),
					  MAC_ARG(priv->bssid));
4379

4380 4381 4382
				priv->status &= ~(STATUS_ASSOCIATING |
						  STATUS_AUTH |
						  STATUS_ASSOCIATED);
J
James Ketrenos 已提交
4383

4384
				schedule_work(&priv->link_down);
4385
				break;
J
James Ketrenos 已提交
4386

4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425
			case CMAS_TX_AUTH_SEQ_1:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC, "AUTH_SEQ_1\n");
				break;
			case CMAS_RX_AUTH_SEQ_2:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC, "AUTH_SEQ_2\n");
				break;
			case CMAS_AUTH_SEQ_1_PASS:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
				break;
			case CMAS_AUTH_SEQ_1_FAIL:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
				break;
			case CMAS_TX_AUTH_SEQ_3:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC, "AUTH_SEQ_3\n");
				break;
			case CMAS_RX_AUTH_SEQ_4:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
				break;
			case CMAS_AUTH_SEQ_2_PASS:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
				break;
			case CMAS_AUTH_SEQ_2_FAIL:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
				break;
			case CMAS_TX_ASSOC:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC, "TX_ASSOC\n");
				break;
			case CMAS_RX_ASSOC_RESP:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4426

4427 4428 4429 4430 4431 4432 4433 4434 4435
				break;
			case CMAS_ASSOCIATED:
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
					  IPW_DL_ASSOC, "ASSOCIATED\n");
				break;
			default:
				IPW_DEBUG_NOTIF("auth: failure - %d\n",
						auth->state);
				break;
J
James Ketrenos 已提交
4436 4437 4438 4439
			}
			break;
		}

4440 4441 4442
	case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
			struct notif_channel_result *x =
			    &notif->u.channel_result;
J
James Ketrenos 已提交
4443

4444 4445 4446 4447 4448 4449 4450
			if (notif->size == sizeof(*x)) {
				IPW_DEBUG_SCAN("Scan result for channel %d\n",
					       x->channel_num);
			} else {
				IPW_DEBUG_SCAN("Scan result of wrong size %d "
					       "(should be %zd)\n",
					       notif->size, sizeof(*x));
4451
			}
J
James Ketrenos 已提交
4452 4453 4454
			break;
		}

4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466
	case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
			struct notif_scan_complete *x = &notif->u.scan_complete;
			if (notif->size == sizeof(*x)) {
				IPW_DEBUG_SCAN
				    ("Scan completed: type %d, %d channels, "
				     "%d status\n", x->scan_type,
				     x->num_channels, x->status);
			} else {
				IPW_ERROR("Scan completed of wrong size %d "
					  "(should be %zd)\n",
					  notif->size, sizeof(*x));
			}
J
James Ketrenos 已提交
4467

4468 4469 4470
			priv->status &=
			    ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);

4471
			wake_up_interruptible(&priv->wait_state);
4472 4473
			cancel_delayed_work(&priv->scan_check);

4474 4475 4476 4477 4478 4479 4480
			if (priv->status & STATUS_EXIT_PENDING)
				break;

			priv->ieee->scans++;

#ifdef CONFIG_IPW2200_MONITOR
			if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4481
				priv->status |= STATUS_SCAN_FORCED;
4482 4483 4484 4485
				queue_work(priv->workqueue,
					   &priv->request_scan);
				break;
			}
4486
			priv->status &= ~STATUS_SCAN_FORCED;
4487 4488
#endif				/* CONFIG_IPW2200_MONITOR */

4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502
			if (!(priv->status & (STATUS_ASSOCIATED |
					      STATUS_ASSOCIATING |
					      STATUS_ROAMING |
					      STATUS_DISASSOCIATING)))
				queue_work(priv->workqueue, &priv->associate);
			else if (priv->status & STATUS_ROAMING) {
				/* If a scan completed and we are in roam mode, then
				 * the scan that completed was the one requested as a
				 * result of entering roam... so, schedule the
				 * roam work */
				queue_work(priv->workqueue, &priv->roam);
			} else if (priv->status & STATUS_SCAN_PENDING)
				queue_work(priv->workqueue,
					   &priv->request_scan);
4503 4504 4505 4506
			else if (priv->config & CFG_BACKGROUND_SCAN
				 && priv->status & STATUS_ASSOCIATED)
				queue_delayed_work(priv->workqueue,
						   &priv->request_scan, HZ);
4507
			break;
J
James Ketrenos 已提交
4508 4509
		}

4510 4511
	case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
			struct notif_frag_length *x = &notif->u.frag_len;
J
James Ketrenos 已提交
4512

4513 4514 4515 4516
			if (notif->size == sizeof(*x))
				IPW_ERROR("Frag length: %d\n",
					  le16_to_cpu(x->frag_length));
			else
4517 4518 4519 4520
				IPW_ERROR("Frag length of wrong size %d "
					  "(should be %zd)\n",
					  notif->size, sizeof(*x));
			break;
J
James Ketrenos 已提交
4521 4522
		}

4523 4524 4525
	case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
			struct notif_link_deterioration *x =
			    &notif->u.link_deterioration;
4526

4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539
			if (notif->size == sizeof(*x)) {
				IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
					  "link deterioration: '%s' " MAC_FMT
					  " \n", escape_essid(priv->essid,
							      priv->essid_len),
					  MAC_ARG(priv->bssid));
				memcpy(&priv->last_link_deterioration, x,
				       sizeof(*x));
			} else {
				IPW_ERROR("Link Deterioration of wrong size %d "
					  "(should be %zd)\n",
					  notif->size, sizeof(*x));
			}
J
James Ketrenos 已提交
4540 4541 4542
			break;
		}

4543 4544 4545
	case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
			IPW_ERROR("Dino config\n");
			if (priv->hcmd
4546
			    && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4547
				IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4548

4549 4550
			break;
		}
J
James Ketrenos 已提交
4551

4552 4553 4554 4555 4556 4557 4558
	case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
			struct notif_beacon_state *x = &notif->u.beacon_state;
			if (notif->size != sizeof(*x)) {
				IPW_ERROR
				    ("Beacon state of wrong size %d (should "
				     "be %zd)\n", notif->size, sizeof(*x));
				break;
J
James Ketrenos 已提交
4559 4560
			}

4561 4562 4563 4564 4565
			if (le32_to_cpu(x->state) ==
			    HOST_NOTIFICATION_STATUS_BEACON_MISSING)
				ipw_handle_missed_beacon(priv,
							 le32_to_cpu(x->
								     number));
J
James Ketrenos 已提交
4566

4567 4568
			break;
		}
J
James Ketrenos 已提交
4569

4570 4571 4572 4573 4574 4575 4576 4577 4578
	case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
			struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
			if (notif->size == sizeof(*x)) {
				IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
					  "0x%02x station %d\n",
					  x->key_state, x->security_type,
					  x->station_index);
				break;
			}
J
James Ketrenos 已提交
4579

4580 4581 4582
			IPW_ERROR
			    ("TGi Tx Key of wrong size %d (should be %zd)\n",
			     notif->size, sizeof(*x));
J
James Ketrenos 已提交
4583
			break;
4584
		}
J
James Ketrenos 已提交
4585

4586 4587
	case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
			struct notif_calibration *x = &notif->u.calibration;
J
James Ketrenos 已提交
4588

4589 4590 4591 4592 4593
			if (notif->size == sizeof(*x)) {
				memcpy(&priv->calib, x, sizeof(*x));
				IPW_DEBUG_INFO("TODO: Calibration\n");
				break;
			}
J
James Ketrenos 已提交
4594

4595 4596 4597
			IPW_ERROR
			    ("Calibration of wrong size %d (should be %zd)\n",
			     notif->size, sizeof(*x));
J
James Ketrenos 已提交
4598
			break;
4599 4600
		}

4601 4602 4603
	case HOST_NOTIFICATION_NOISE_STATS:{
			if (notif->size == sizeof(u32)) {
				priv->last_noise =
4604 4605
				    (u8) (le32_to_cpu(notif->u.noise.value) &
					  0xff);
4606 4607 4608 4609
				average_add(&priv->average_noise,
					    priv->last_noise);
				break;
			}
J
James Ketrenos 已提交
4610

4611 4612 4613
			IPW_ERROR
			    ("Noise stat is wrong size %d (should be %zd)\n",
			     notif->size, sizeof(u32));
J
James Ketrenos 已提交
4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625
			break;
		}

	default:
		IPW_ERROR("Unknown notification: "
			  "subtype=%d,flags=0x%2x,size=%d\n",
			  notif->subtype, notif->flags, notif->size);
	}
}

/**
 * Destroys all DMA structures and initialise them again
4626
 *
J
James Ketrenos 已提交
4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637
 * @param priv
 * @return error code
 */
static int ipw_queue_reset(struct ipw_priv *priv)
{
	int rc = 0;
	/** @todo customize queue sizes */
	int nTx = 64, nTxCmd = 8;
	ipw_tx_queue_free(priv);
	/* Tx CMD queue */
	rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4638 4639 4640 4641
			       IPW_TX_CMD_QUEUE_READ_INDEX,
			       IPW_TX_CMD_QUEUE_WRITE_INDEX,
			       IPW_TX_CMD_QUEUE_BD_BASE,
			       IPW_TX_CMD_QUEUE_BD_SIZE);
J
James Ketrenos 已提交
4642 4643 4644 4645 4646 4647
	if (rc) {
		IPW_ERROR("Tx Cmd queue init failed\n");
		goto error;
	}
	/* Tx queue(s) */
	rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4648 4649 4650
			       IPW_TX_QUEUE_0_READ_INDEX,
			       IPW_TX_QUEUE_0_WRITE_INDEX,
			       IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
J
James Ketrenos 已提交
4651 4652 4653 4654 4655
	if (rc) {
		IPW_ERROR("Tx 0 queue init failed\n");
		goto error;
	}
	rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4656 4657 4658
			       IPW_TX_QUEUE_1_READ_INDEX,
			       IPW_TX_QUEUE_1_WRITE_INDEX,
			       IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
J
James Ketrenos 已提交
4659 4660 4661 4662 4663
	if (rc) {
		IPW_ERROR("Tx 1 queue init failed\n");
		goto error;
	}
	rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4664 4665 4666
			       IPW_TX_QUEUE_2_READ_INDEX,
			       IPW_TX_QUEUE_2_WRITE_INDEX,
			       IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
J
James Ketrenos 已提交
4667 4668 4669 4670 4671
	if (rc) {
		IPW_ERROR("Tx 2 queue init failed\n");
		goto error;
	}
	rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4672 4673 4674
			       IPW_TX_QUEUE_3_READ_INDEX,
			       IPW_TX_QUEUE_3_WRITE_INDEX,
			       IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
J
James Ketrenos 已提交
4675 4676 4677 4678 4679 4680 4681 4682 4683
	if (rc) {
		IPW_ERROR("Tx 3 queue init failed\n");
		goto error;
	}
	/* statistics */
	priv->rx_bufs_min = 0;
	priv->rx_pend_max = 0;
	return rc;

4684
      error:
J
James Ketrenos 已提交
4685 4686 4687 4688 4689 4690
	ipw_tx_queue_free(priv);
	return rc;
}

/**
 * Reclaim Tx queue entries no more used by NIC.
4691
 *
J
James Ketrenos 已提交
4692 4693 4694
 * When FW adwances 'R' index, all entries between old and
 * new 'R' index need to be reclaimed. As result, some free space
 * forms. If there is enough free space (> low mark), wake Tx queue.
4695
 *
J
James Ketrenos 已提交
4696 4697 4698 4699 4700 4701
 * @note Need to protect against garbage in 'R' index
 * @param priv
 * @param txq
 * @param qindex
 * @return Number of used entries remains in the queue
 */
4702
static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
J
James Ketrenos 已提交
4703 4704 4705 4706 4707 4708 4709 4710 4711
				struct clx2_tx_queue *txq, int qindex)
{
	u32 hw_tail;
	int used;
	struct clx2_queue *q = &txq->q;

	hw_tail = ipw_read32(priv, q->reg_r);
	if (hw_tail >= q->n_bd) {
		IPW_ERROR
4712 4713
		    ("Read index for DMA queue (%d) is out of range [0-%d)\n",
		     hw_tail, q->n_bd);
J
James Ketrenos 已提交
4714 4715 4716 4717 4718 4719 4720
		goto done;
	}
	for (; q->last_used != hw_tail;
	     q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
		ipw_queue_tx_free_tfd(priv, txq);
		priv->tx_packets++;
	}
4721
      done:
4722 4723 4724 4725
	if ((ipw_queue_space(q) > q->low_mark) &&
	    (qindex >= 0) &&
	    (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
		netif_wake_queue(priv->net_dev);
J
James Ketrenos 已提交
4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761
	used = q->first_empty - q->last_used;
	if (used < 0)
		used += q->n_bd;

	return used;
}

static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
			     int len, int sync)
{
	struct clx2_tx_queue *txq = &priv->txq_cmd;
	struct clx2_queue *q = &txq->q;
	struct tfd_frame *tfd;

	if (ipw_queue_space(q) < (sync ? 1 : 2)) {
		IPW_ERROR("No space for Tx\n");
		return -EBUSY;
	}

	tfd = &txq->bd[q->first_empty];
	txq->txb[q->first_empty] = NULL;

	memset(tfd, 0, sizeof(*tfd));
	tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
	tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
	priv->hcmd_seq++;
	tfd->u.cmd.index = hcmd;
	tfd->u.cmd.length = len;
	memcpy(tfd->u.cmd.payload, buf, len);
	q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
	ipw_write32(priv, q->reg_w, q->first_empty);
	_ipw_read32(priv, 0x90);

	return 0;
}

4762
/*
J
James Ketrenos 已提交
4763 4764 4765
 * Rx theory of operation
 *
 * The host allocates 32 DMA target addresses and passes the host address
4766
 * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
J
James Ketrenos 已提交
4767 4768 4769 4770 4771
 * 0 to 31
 *
 * Rx Queue Indexes
 * The host/firmware share two index registers for managing the Rx buffers.
 *
4772 4773 4774
 * 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.
J
James Ketrenos 已提交
4775 4776 4777 4778 4779 4780
 * 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
4781
 * WRITE = READ.
J
James Ketrenos 已提交
4782
 *
4783
 * During initialization the host sets up the READ queue position to the first
J
James Ketrenos 已提交
4784 4785 4786 4787 4788 4789
 * INDEX position, and WRITE to the last (READ - 1 wrapped)
 *
 * When the firmware places a packet in a buffer it will advance the READ index
 * 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.
4790
 *
J
James Ketrenos 已提交
4791
 * The management in the driver is as follows:
4792
 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free.  When
J
James Ketrenos 已提交
4793
 *   ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
4794
 *   to replensish the ipw->rxq->rx_free.
J
James Ketrenos 已提交
4795 4796 4797 4798 4799 4800
 * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
 *   ipw->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 ipw->rxq.  The driver 'processed' index is updated.
 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
4801 4802
 *   list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
 *   INDEX is not incremented and ipw->status(RX_STALLED) is set.  If there
J
James Ketrenos 已提交
4803 4804 4805 4806 4807
 *   were enough free buffers and RX_STALLED is set it is cleared.
 *
 *
 * Driver sequence:
 *
4808
 * ipw_rx_queue_alloc()       Allocates rx_free
J
James Ketrenos 已提交
4809 4810 4811 4812 4813 4814 4815 4816 4817
 * ipw_rx_queue_replenish()   Replenishes rx_free list from rx_used, and calls
 *                            ipw_rx_queue_restock
 * ipw_rx_queue_restock()     Moves available buffers from rx_free into Rx
 *                            queue, updates firmware pointers, and updates
 *                            the WRITE index.  If insufficient rx_free buffers
 *                            are available, schedules ipw_rx_queue_replenish
 *
 * -- enable interrupts --
 * ISR - ipw_rx()             Detach ipw_rx_mem_buffers from pool up to the
4818
 *                            READ INDEX, detaching the SKB from the pool.
J
James Ketrenos 已提交
4819 4820 4821 4822 4823 4824 4825
 *                            Moves the packet buffer from queue to rx_used.
 *                            Calls ipw_rx_queue_restock to refill any empty
 *                            slots.
 * ...
 *
 */

4826
/*
J
James Ketrenos 已提交
4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849
 * If there are slots in the RX queue that  need to be restocked,
 * and we have free pre-allocated buffers, fill the ranks as much
 * as we can pulling from rx_free.
 *
 * 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.
 */
static void ipw_rx_queue_restock(struct ipw_priv *priv)
{
	struct ipw_rx_queue *rxq = priv->rxq;
	struct list_head *element;
	struct ipw_rx_mem_buffer *rxb;
	unsigned long flags;
	int write;

	spin_lock_irqsave(&rxq->lock, flags);
	write = rxq->write;
	while ((rxq->write != rxq->processed) && (rxq->free_count)) {
		element = rxq->rx_free.next;
		rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
		list_del(element);

4850
		ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
J
James Ketrenos 已提交
4851 4852 4853 4854 4855 4856 4857
			    rxb->dma_addr);
		rxq->queue[rxq->write] = rxb;
		rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
		rxq->free_count--;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);

4858
	/* If the pre-allocated buffer pool is dropping low, schedule to
J
James Ketrenos 已提交
4859 4860 4861 4862 4863
	 * refill it */
	if (rxq->free_count <= RX_LOW_WATERMARK)
		queue_work(priv->workqueue, &priv->rx_replenish);

	/* If we've added more space for the firmware to place data, tell it */
4864
	if (write != rxq->write)
4865
		ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
J
James Ketrenos 已提交
4866 4867 4868 4869
}

/*
 * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
4870 4871
 * Also restock the Rx queue via ipw_rx_queue_restock.
 *
J
James Ketrenos 已提交
4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885
 * This is called as a scheduled work item (except for during intialization)
 */
static void ipw_rx_queue_replenish(void *data)
{
	struct ipw_priv *priv = data;
	struct ipw_rx_queue *rxq = priv->rxq;
	struct list_head *element;
	struct ipw_rx_mem_buffer *rxb;
	unsigned long flags;

	spin_lock_irqsave(&rxq->lock, flags);
	while (!list_empty(&rxq->rx_used)) {
		element = rxq->rx_used.next;
		rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4886
		rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
J
James Ketrenos 已提交
4887 4888 4889 4890 4891 4892 4893 4894 4895
		if (!rxb->skb) {
			printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
			       priv->net_dev->name);
			/* 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;
		}
		list_del(element);
4896

J
James Ketrenos 已提交
4897
		rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
4898 4899
		rxb->dma_addr =
		    pci_map_single(priv->pci_dev, rxb->skb->data,
4900
				   IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4901

J
James Ketrenos 已提交
4902 4903 4904 4905 4906 4907 4908 4909
		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);

	ipw_rx_queue_restock(priv);
}

4910 4911 4912 4913 4914 4915 4916 4917
static void ipw_bg_rx_queue_replenish(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_rx_queue_replenish(data);
	up(&priv->sem);
}

J
James Ketrenos 已提交
4918 4919
/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
 * If an SKB has been detached, the POOL needs to have it's SKB set to NULL
4920
 * This free routine walks the list of POOL entries and if SKB is set to
J
James Ketrenos 已提交
4921 4922
 * non NULL it is unmapped and freed
 */
4923
static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
J
James Ketrenos 已提交
4924 4925 4926 4927 4928
{
	int i;

	if (!rxq)
		return;
4929

J
James Ketrenos 已提交
4930 4931 4932
	for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
		if (rxq->pool[i].skb != NULL) {
			pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
4933
					 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
J
James Ketrenos 已提交
4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946
			dev_kfree_skb(rxq->pool[i].skb);
		}
	}

	kfree(rxq);
}

static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
{
	struct ipw_rx_queue *rxq;
	int i;

	rxq = (struct ipw_rx_queue *)kmalloc(sizeof(*rxq), GFP_KERNEL);
4947 4948 4949 4950
	if (unlikely(!rxq)) {
		IPW_ERROR("memory allocation failed\n");
		return NULL;
	}
J
James Ketrenos 已提交
4951 4952 4953 4954 4955 4956
	memset(rxq, 0, sizeof(*rxq));
	spin_lock_init(&rxq->lock);
	INIT_LIST_HEAD(&rxq->rx_free);
	INIT_LIST_HEAD(&rxq->rx_used);

	/* Fill the rx_used queue with _all_ of the Rx buffers */
4957
	for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
J
James Ketrenos 已提交
4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973
		list_add_tail(&rxq->pool[i].list, &rxq->rx_used);

	/* Set us so that we have processed and used all buffers, but have
	 * not restocked the Rx queue with fresh buffers */
	rxq->read = rxq->write = 0;
	rxq->processed = RX_QUEUE_SIZE - 1;
	rxq->free_count = 0;

	return rxq;
}

static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
{
	rate &= ~IEEE80211_BASIC_RATE_MASK;
	if (ieee_mode == IEEE_A) {
		switch (rate) {
4974 4975
		case IEEE80211_OFDM_RATE_6MB:
			return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
4976
			    1 : 0;
4977 4978
		case IEEE80211_OFDM_RATE_9MB:
			return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
4979
			    1 : 0;
4980
		case IEEE80211_OFDM_RATE_12MB:
4981 4982
			return priv->
			    rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
4983
		case IEEE80211_OFDM_RATE_18MB:
4984 4985
			return priv->
			    rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
4986
		case IEEE80211_OFDM_RATE_24MB:
4987 4988
			return priv->
			    rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
4989
		case IEEE80211_OFDM_RATE_36MB:
4990 4991
			return priv->
			    rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
4992
		case IEEE80211_OFDM_RATE_48MB:
4993 4994
			return priv->
			    rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
4995
		case IEEE80211_OFDM_RATE_54MB:
4996 4997
			return priv->
			    rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
J
James Ketrenos 已提交
4998 4999 5000 5001
		default:
			return 0;
		}
	}
5002

J
James Ketrenos 已提交
5003 5004
	/* B and G mixed */
	switch (rate) {
5005
	case IEEE80211_CCK_RATE_1MB:
J
James Ketrenos 已提交
5006
		return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
5007
	case IEEE80211_CCK_RATE_2MB:
J
James Ketrenos 已提交
5008
		return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
5009
	case IEEE80211_CCK_RATE_5MB:
J
James Ketrenos 已提交
5010
		return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
5011
	case IEEE80211_CCK_RATE_11MB:
J
James Ketrenos 已提交
5012 5013 5014 5015 5016 5017 5018 5019 5020
		return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
	}

	/* If we are limited to B modulations, bail at this point */
	if (ieee_mode == IEEE_B)
		return 0;

	/* G */
	switch (rate) {
5021
	case IEEE80211_OFDM_RATE_6MB:
J
James Ketrenos 已提交
5022
		return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
5023
	case IEEE80211_OFDM_RATE_9MB:
J
James Ketrenos 已提交
5024
		return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
5025
	case IEEE80211_OFDM_RATE_12MB:
J
James Ketrenos 已提交
5026
		return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
5027
	case IEEE80211_OFDM_RATE_18MB:
J
James Ketrenos 已提交
5028
		return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5029
	case IEEE80211_OFDM_RATE_24MB:
J
James Ketrenos 已提交
5030
		return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5031
	case IEEE80211_OFDM_RATE_36MB:
J
James Ketrenos 已提交
5032
		return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5033
	case IEEE80211_OFDM_RATE_48MB:
J
James Ketrenos 已提交
5034
		return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5035
	case IEEE80211_OFDM_RATE_54MB:
J
James Ketrenos 已提交
5036 5037 5038 5039 5040 5041
		return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
	}

	return 0;
}

5042
static int ipw_compatible_rates(struct ipw_priv *priv,
J
James Ketrenos 已提交
5043 5044 5045 5046 5047 5048
				const struct ieee80211_network *network,
				struct ipw_supported_rates *rates)
{
	int num_rates, i;

	memset(rates, 0, sizeof(*rates));
5049
	num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
J
James Ketrenos 已提交
5050 5051
	rates->num_rates = 0;
	for (i = 0; i < num_rates; i++) {
5052 5053 5054
		if (!ipw_is_rate_in_mask(priv, network->mode,
					 network->rates[i])) {

5055
			if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
5056 5057 5058 5059 5060 5061
				IPW_DEBUG_SCAN("Adding masked mandatory "
					       "rate %02X\n",
					       network->rates[i]);
				rates->supported_rates[rates->num_rates++] =
				    network->rates[i];
				continue;
5062 5063
			}

J
James Ketrenos 已提交
5064 5065 5066 5067
			IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
				       network->rates[i], priv->rates_mask);
			continue;
		}
5068

J
James Ketrenos 已提交
5069 5070 5071
		rates->supported_rates[rates->num_rates++] = network->rates[i];
	}

5072 5073
	num_rates = min(network->rates_ex_len,
			(u8) (IPW_MAX_RATES - num_rates));
J
James Ketrenos 已提交
5074
	for (i = 0; i < num_rates; i++) {
5075 5076
		if (!ipw_is_rate_in_mask(priv, network->mode,
					 network->rates_ex[i])) {
5077
			if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
5078 5079 5080 5081 5082 5083
				IPW_DEBUG_SCAN("Adding masked mandatory "
					       "rate %02X\n",
					       network->rates_ex[i]);
				rates->supported_rates[rates->num_rates++] =
				    network->rates[i];
				continue;
5084 5085
			}

J
James Ketrenos 已提交
5086 5087 5088 5089
			IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
				       network->rates_ex[i], priv->rates_mask);
			continue;
		}
5090

5091 5092
		rates->supported_rates[rates->num_rates++] =
		    network->rates_ex[i];
J
James Ketrenos 已提交
5093 5094
	}

5095
	return 1;
J
James Ketrenos 已提交
5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110
}

static inline void ipw_copy_rates(struct ipw_supported_rates *dest,
				  const struct ipw_supported_rates *src)
{
	u8 i;
	for (i = 0; i < src->num_rates; i++)
		dest->supported_rates[i] = src->supported_rates[i];
	dest->num_rates = src->num_rates;
}

/* TODO: Look at sniffed packets in the air to determine if the basic rate
 * mask should ever be used -- right now all callers to add the scan rates are
 * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5111
				   u8 modulation, u32 rate_mask)
J
James Ketrenos 已提交
5112
{
5113
	u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5114
	    IEEE80211_BASIC_RATE_MASK : 0;
5115

J
James Ketrenos 已提交
5116
	if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
5117
		rates->supported_rates[rates->num_rates++] =
5118
		    IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
J
James Ketrenos 已提交
5119 5120

	if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
5121
		rates->supported_rates[rates->num_rates++] =
5122
		    IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
J
James Ketrenos 已提交
5123 5124

	if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
5125
		rates->supported_rates[rates->num_rates++] = basic_mask |
5126
		    IEEE80211_CCK_RATE_5MB;
J
James Ketrenos 已提交
5127 5128

	if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
5129
		rates->supported_rates[rates->num_rates++] = basic_mask |
5130
		    IEEE80211_CCK_RATE_11MB;
J
James Ketrenos 已提交
5131 5132 5133
}

static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5134
				    u8 modulation, u32 rate_mask)
J
James Ketrenos 已提交
5135
{
5136
	u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5137
	    IEEE80211_BASIC_RATE_MASK : 0;
J
James Ketrenos 已提交
5138 5139

	if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
5140
		rates->supported_rates[rates->num_rates++] = basic_mask |
5141
		    IEEE80211_OFDM_RATE_6MB;
J
James Ketrenos 已提交
5142 5143

	if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
5144
		rates->supported_rates[rates->num_rates++] =
5145
		    IEEE80211_OFDM_RATE_9MB;
J
James Ketrenos 已提交
5146 5147

	if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
5148
		rates->supported_rates[rates->num_rates++] = basic_mask |
5149
		    IEEE80211_OFDM_RATE_12MB;
J
James Ketrenos 已提交
5150 5151

	if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
5152
		rates->supported_rates[rates->num_rates++] =
5153
		    IEEE80211_OFDM_RATE_18MB;
J
James Ketrenos 已提交
5154 5155

	if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
5156
		rates->supported_rates[rates->num_rates++] = basic_mask |
5157
		    IEEE80211_OFDM_RATE_24MB;
J
James Ketrenos 已提交
5158 5159

	if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
5160
		rates->supported_rates[rates->num_rates++] =
5161
		    IEEE80211_OFDM_RATE_36MB;
J
James Ketrenos 已提交
5162 5163

	if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
5164
		rates->supported_rates[rates->num_rates++] =
5165
		    IEEE80211_OFDM_RATE_48MB;
J
James Ketrenos 已提交
5166 5167

	if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
5168
		rates->supported_rates[rates->num_rates++] =
5169
		    IEEE80211_OFDM_RATE_54MB;
J
James Ketrenos 已提交
5170 5171 5172 5173 5174 5175 5176
}

struct ipw_network_match {
	struct ieee80211_network *network;
	struct ipw_supported_rates rates;
};

5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225
static int ipw_find_adhoc_network(struct ipw_priv *priv,
				  struct ipw_network_match *match,
				  struct ieee80211_network *network,
				  int roaming)
{
	struct ipw_supported_rates rates;

	/* Verify that this network's capability is compatible with the
	 * current mode (AdHoc or Infrastructure) */
	if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
	     !(network->capability & WLAN_CAPABILITY_IBSS))) {
		IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
				"capability mismatch.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid));
		return 0;
	}

	/* If we do not have an ESSID for this AP, we can not associate with
	 * it */
	if (network->flags & NETWORK_EMPTY_ESSID) {
		IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
				"because of hidden ESSID.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid));
		return 0;
	}

	if (unlikely(roaming)) {
		/* If we are roaming, then ensure check if this is a valid
		 * network to try and roam to */
		if ((network->ssid_len != match->network->ssid_len) ||
		    memcmp(network->ssid, match->network->ssid,
			   network->ssid_len)) {
			IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
					"because of non-network ESSID.\n",
					escape_essid(network->ssid,
						     network->ssid_len),
					MAC_ARG(network->bssid));
			return 0;
		}
	} else {
		/* If an ESSID has been configured then compare the broadcast
		 * ESSID to ours */
		if ((priv->config & CFG_STATIC_ESSID) &&
		    ((network->ssid_len != priv->essid_len) ||
		     memcmp(network->ssid, priv->essid,
			    min(network->ssid_len, priv->essid_len)))) {
			char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5226

5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242
			strncpy(escaped,
				escape_essid(network->ssid, network->ssid_len),
				sizeof(escaped));
			IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
					"because of ESSID mismatch: '%s'.\n",
					escaped, MAC_ARG(network->bssid),
					escape_essid(priv->essid,
						     priv->essid_len));
			return 0;
		}
	}

	/* If the old network rate is better than this one, don't bother
	 * testing everything else. */

	if (network->time_stamp[0] < match->network->time_stamp[0]) {
5243 5244 5245 5246
		IPW_DEBUG_MERGE("Network '%s excluded because newer than "
				"current network.\n",
				escape_essid(match->network->ssid,
					     match->network->ssid_len));
5247 5248
		return 0;
	} else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5249 5250 5251 5252
		IPW_DEBUG_MERGE("Network '%s excluded because newer than "
				"current network.\n",
				escape_essid(match->network->ssid,
					     match->network->ssid_len));
5253 5254 5255 5256 5257 5258 5259 5260 5261 5262
		return 0;
	}

	/* Now go through and see if the requested network is valid... */
	if (priv->ieee->scan_age != 0 &&
	    time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
		IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
				"because of age: %lums.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid),
5263
				1000 * (jiffies - network->last_scanned) / HZ);
5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283
		return 0;
	}

	if ((priv->config & CFG_STATIC_CHANNEL) &&
	    (network->channel != priv->channel)) {
		IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
				"because of channel mismatch: %d != %d.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid),
				network->channel, priv->channel);
		return 0;
	}

	/* Verify privacy compatability */
	if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
	    ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
		IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
				"because of privacy mismatch: %s != %s.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid),
5284 5285 5286 5287 5288
				priv->
				capability & CAP_PRIVACY_ON ? "on" : "off",
				network->
				capability & WLAN_CAPABILITY_PRIVACY ? "on" :
				"off");
5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351
		return 0;
	}

	if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
		IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
				"because of the same BSSID match: " MAC_FMT
				".\n", escape_essid(network->ssid,
						    network->ssid_len),
				MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
		return 0;
	}

	/* Filter out any incompatible freq / mode combinations */
	if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
		IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
				"because of invalid frequency/mode "
				"combination.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid));
		return 0;
	}

	/* Ensure that the rates supported by the driver are compatible with
	 * this AP, including verification of basic rates (mandatory) */
	if (!ipw_compatible_rates(priv, network, &rates)) {
		IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
				"because configured rate mask excludes "
				"AP mandatory rate.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid));
		return 0;
	}

	if (rates.num_rates == 0) {
		IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
				"because of no compatible rates.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid));
		return 0;
	}

	/* TODO: Perform any further minimal comparititive tests.  We do not
	 * want to put too much policy logic here; intelligent scan selection
	 * should occur within a generic IEEE 802.11 user space tool.  */

	/* Set up 'new' AP to this network */
	ipw_copy_rates(&match->rates, &rates);
	match->network = network;
	IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
			escape_essid(network->ssid, network->ssid_len),
			MAC_ARG(network->bssid));

	return 1;
}

static void ipw_merge_adhoc_network(void *data)
{
	struct ipw_priv *priv = data;
	struct ieee80211_network *network = NULL;
	struct ipw_network_match match = {
		.network = priv->assoc_network
	};

5352 5353
	if ((priv->status & STATUS_ASSOCIATED) &&
	    (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386
		/* First pass through ROAM process -- look for a better
		 * network */
		unsigned long flags;

		spin_lock_irqsave(&priv->ieee->lock, flags);
		list_for_each_entry(network, &priv->ieee->network_list, list) {
			if (network != priv->assoc_network)
				ipw_find_adhoc_network(priv, &match, network,
						       1);
		}
		spin_unlock_irqrestore(&priv->ieee->lock, flags);

		if (match.network == priv->assoc_network) {
			IPW_DEBUG_MERGE("No better ADHOC in this network to "
					"merge to.\n");
			return;
		}

		down(&priv->sem);
		if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
			IPW_DEBUG_MERGE("remove network %s\n",
					escape_essid(priv->essid,
						     priv->essid_len));
			ipw_remove_current_network(priv);
		}

		ipw_disassociate(priv);
		priv->assoc_network = match.network;
		up(&priv->sem);
		return;
	}
}

5387 5388 5389
static int ipw_best_network(struct ipw_priv *priv,
			    struct ipw_network_match *match,
			    struct ieee80211_network *network, int roaming)
J
James Ketrenos 已提交
5390 5391 5392 5393 5394 5395
{
	struct ipw_supported_rates rates;

	/* Verify that this network's capability is compatible with the
	 * current mode (AdHoc or Infrastructure) */
	if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5396
	     !(network->capability & WLAN_CAPABILITY_ESS)) ||
J
James Ketrenos 已提交
5397 5398 5399
	    (priv->ieee->iw_mode == IW_MODE_ADHOC &&
	     !(network->capability & WLAN_CAPABILITY_IBSS))) {
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
5400
				"capability mismatch.\n",
J
James Ketrenos 已提交
5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid));
		return 0;
	}

	/* If we do not have an ESSID for this AP, we can not associate with
	 * it */
	if (network->flags & NETWORK_EMPTY_ESSID) {
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
				"because of hidden ESSID.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid));
		return 0;
	}
5415

J
James Ketrenos 已提交
5416 5417 5418 5419
	if (unlikely(roaming)) {
		/* If we are roaming, then ensure check if this is a valid
		 * network to try and roam to */
		if ((network->ssid_len != match->network->ssid_len) ||
5420
		    memcmp(network->ssid, match->network->ssid,
J
James Ketrenos 已提交
5421 5422 5423
			   network->ssid_len)) {
			IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
					"because of non-network ESSID.\n",
5424
					escape_essid(network->ssid,
J
James Ketrenos 已提交
5425 5426 5427 5428 5429
						     network->ssid_len),
					MAC_ARG(network->bssid));
			return 0;
		}
	} else {
5430 5431 5432
		/* If an ESSID has been configured then compare the broadcast
		 * ESSID to ours */
		if ((priv->config & CFG_STATIC_ESSID) &&
J
James Ketrenos 已提交
5433
		    ((network->ssid_len != priv->essid_len) ||
5434
		     memcmp(network->ssid, priv->essid,
J
James Ketrenos 已提交
5435 5436
			    min(network->ssid_len, priv->essid_len)))) {
			char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5437 5438
			strncpy(escaped,
				escape_essid(network->ssid, network->ssid_len),
J
James Ketrenos 已提交
5439 5440
				sizeof(escaped));
			IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5441
					"because of ESSID mismatch: '%s'.\n",
J
James Ketrenos 已提交
5442
					escaped, MAC_ARG(network->bssid),
5443 5444
					escape_essid(priv->essid,
						     priv->essid_len));
J
James Ketrenos 已提交
5445 5446 5447 5448 5449 5450
			return 0;
		}
	}

	/* If the old network rate is better than this one, don't bother
	 * testing everything else. */
5451
	if (match->network && match->network->stats.rssi > network->stats.rssi) {
J
James Ketrenos 已提交
5452
		char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5453 5454
		strncpy(escaped,
			escape_essid(network->ssid, network->ssid_len),
J
James Ketrenos 已提交
5455 5456 5457 5458 5459 5460 5461 5462 5463
			sizeof(escaped));
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
				"'%s (" MAC_FMT ")' has a stronger signal.\n",
				escaped, MAC_ARG(network->bssid),
				escape_essid(match->network->ssid,
					     match->network->ssid_len),
				MAC_ARG(match->network->bssid));
		return 0;
	}
5464

J
James Ketrenos 已提交
5465 5466 5467
	/* If this network has already had an association attempt within the
	 * last 3 seconds, do not try and associate again... */
	if (network->last_associate &&
5468
	    time_after(network->last_associate + (HZ * 3UL), jiffies)) {
J
James Ketrenos 已提交
5469
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5470
				"because of storming (%lus since last "
J
James Ketrenos 已提交
5471 5472 5473 5474 5475 5476 5477 5478
				"assoc attempt).\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid),
				(jiffies - network->last_associate) / HZ);
		return 0;
	}

	/* Now go through and see if the requested network is valid... */
5479
	if (priv->ieee->scan_age != 0 &&
5480
	    time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
J
James Ketrenos 已提交
5481 5482 5483 5484
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
				"because of age: %lums.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid),
5485
				1000 * (jiffies - network->last_scanned) / HZ);
J
James Ketrenos 已提交
5486
		return 0;
5487
	}
J
James Ketrenos 已提交
5488

5489
	if ((priv->config & CFG_STATIC_CHANNEL) &&
J
James Ketrenos 已提交
5490 5491 5492 5493 5494 5495 5496 5497
	    (network->channel != priv->channel)) {
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
				"because of channel mismatch: %d != %d.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid),
				network->channel, priv->channel);
		return 0;
	}
5498

J
James Ketrenos 已提交
5499
	/* Verify privacy compatability */
5500
	if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
J
James Ketrenos 已提交
5501 5502 5503 5504 5505
	    ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
				"because of privacy mismatch: %s != %s.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid),
5506
				priv->capability & CAP_PRIVACY_ON ? "on" :
J
James Ketrenos 已提交
5507
				"off",
5508
				network->capability &
5509
				WLAN_CAPABILITY_PRIVACY ? "on" : "off");
J
James Ketrenos 已提交
5510 5511
		return 0;
	}
5512 5513

	if ((priv->config & CFG_STATIC_BSSID) &&
J
James Ketrenos 已提交
5514 5515 5516 5517
	    memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
				"because of BSSID mismatch: " MAC_FMT ".\n",
				escape_essid(network->ssid, network->ssid_len),
5518
				MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
J
James Ketrenos 已提交
5519 5520
		return 0;
	}
5521

J
James Ketrenos 已提交
5522 5523 5524 5525 5526 5527 5528 5529 5530
	/* Filter out any incompatible freq / mode combinations */
	if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
				"because of invalid frequency/mode "
				"combination.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid));
		return 0;
	}
5531

5532 5533 5534 5535 5536 5537 5538 5539 5540
	/* Filter out invalid channel in current GEO */
	if (!ipw_is_valid_channel(priv->ieee, network->channel)) {
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
				"because of invalid channel in current GEO\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid));
		return 0;
	}

5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551
	/* Ensure that the rates supported by the driver are compatible with
	 * this AP, including verification of basic rates (mandatory) */
	if (!ipw_compatible_rates(priv, network, &rates)) {
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
				"because configured rate mask excludes "
				"AP mandatory rate.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid));
		return 0;
	}

J
James Ketrenos 已提交
5552 5553 5554 5555 5556 5557 5558
	if (rates.num_rates == 0) {
		IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
				"because of no compatible rates.\n",
				escape_essid(network->ssid, network->ssid_len),
				MAC_ARG(network->bssid));
		return 0;
	}
5559

J
James Ketrenos 已提交
5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574
	/* TODO: Perform any further minimal comparititive tests.  We do not
	 * want to put too much policy logic here; intelligent scan selection
	 * should occur within a generic IEEE 802.11 user space tool.  */

	/* Set up 'new' AP to this network */
	ipw_copy_rates(&match->rates, &rates);
	match->network = network;

	IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
			escape_essid(network->ssid, network->ssid_len),
			MAC_ARG(network->bssid));

	return 1;
}

5575
static void ipw_adhoc_create(struct ipw_priv *priv,
5576
			     struct ieee80211_network *network)
J
James Ketrenos 已提交
5577
{
5578
	const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
5579 5580
	int i;

J
James Ketrenos 已提交
5581 5582 5583 5584 5585 5586
	/*
	 * For the purposes of scanning, we can set our wireless mode
	 * to trigger scans across combinations of bands, but when it
	 * comes to creating a new ad-hoc network, we have tell the FW
	 * exactly which band to use.
	 *
5587
	 * We also have the possibility of an invalid channel for the
J
James Ketrenos 已提交
5588 5589 5590
	 * chossen band.  Attempting to create a new ad-hoc network
	 * with an invalid channel for wireless mode will trigger a
	 * FW fatal error.
5591
	 *
J
James Ketrenos 已提交
5592
	 */
5593
	switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
5594 5595
	case IEEE80211_52GHZ_BAND:
		network->mode = IEEE_A;
5596
		i = ipw_channel_to_index(priv->ieee, priv->channel);
5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609
		if (i == -1)
			BUG();
		if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
			IPW_WARNING("Overriding invalid channel\n");
			priv->channel = geo->a[0].channel;
		}
		break;

	case IEEE80211_24GHZ_BAND:
		if (priv->ieee->mode & IEEE_G)
			network->mode = IEEE_G;
		else
			network->mode = IEEE_B;
5610 5611 5612 5613 5614 5615 5616
		i = ipw_channel_to_index(priv->ieee, priv->channel);
		if (i == -1)
			BUG();
		if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
			IPW_WARNING("Overriding invalid channel\n");
			priv->channel = geo->bg[0].channel;
		}
5617 5618 5619
		break;

	default:
J
James Ketrenos 已提交
5620 5621 5622
		IPW_WARNING("Overriding invalid channel\n");
		if (priv->ieee->mode & IEEE_A) {
			network->mode = IEEE_A;
5623
			priv->channel = geo->a[0].channel;
J
James Ketrenos 已提交
5624 5625
		} else if (priv->ieee->mode & IEEE_G) {
			network->mode = IEEE_G;
5626
			priv->channel = geo->bg[0].channel;
J
James Ketrenos 已提交
5627 5628
		} else {
			network->mode = IEEE_B;
5629
			priv->channel = geo->bg[0].channel;
J
James Ketrenos 已提交
5630
		}
5631 5632
		break;
	}
J
James Ketrenos 已提交
5633 5634 5635 5636 5637 5638 5639 5640

	network->channel = priv->channel;
	priv->config |= CFG_ADHOC_PERSIST;
	ipw_create_bssid(priv, network->bssid);
	network->ssid_len = priv->essid_len;
	memcpy(network->ssid, priv->essid, priv->essid_len);
	memset(&network->stats, 0, sizeof(network->stats));
	network->capability = WLAN_CAPABILITY_IBSS;
5641 5642
	if (!(priv->config & CFG_PREAMBLE_LONG))
		network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
J
James Ketrenos 已提交
5643 5644 5645
	if (priv->capability & CAP_PRIVACY_ON)
		network->capability |= WLAN_CAPABILITY_PRIVACY;
	network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5646
	memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
J
James Ketrenos 已提交
5647
	network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5648
	memcpy(network->rates_ex,
J
James Ketrenos 已提交
5649 5650 5651 5652 5653 5654 5655
	       &priv->rates.supported_rates[network->rates_len],
	       network->rates_ex_len);
	network->last_scanned = 0;
	network->flags = 0;
	network->last_associate = 0;
	network->time_stamp[0] = 0;
	network->time_stamp[1] = 0;
5656 5657 5658
	network->beacon_interval = 100;	/* Default */
	network->listen_interval = 10;	/* Default */
	network->atim_window = 0;	/* Default */
J
James Ketrenos 已提交
5659 5660 5661 5662
	network->wpa_ie_len = 0;
	network->rsn_ie_len = 0;
}

5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683
static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
{
	struct ipw_tgi_tx_key *key;
	struct host_cmd cmd = {
		.cmd = IPW_CMD_TGI_TX_KEY,
		.len = sizeof(*key)
	};

	if (!(priv->ieee->sec.flags & (1 << index)))
		return;

	key = (struct ipw_tgi_tx_key *)&cmd.param;
	key->key_id = index;
	memcpy(key->key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
	key->security_type = type;
	key->station_index = 0;	/* always 0 for BSS */
	key->flags = 0;
	/* 0 for new key; previous value of counter (after fatal error) */
	key->tx_counter[0] = 0;
	key->tx_counter[1] = 0;

5684
	ipw_send_cmd(priv, &cmd);
5685 5686 5687
}

static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
J
James Ketrenos 已提交
5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699
{
	struct ipw_wep_key *key;
	int i;
	struct host_cmd cmd = {
		.cmd = IPW_CMD_WEP_KEY,
		.len = sizeof(*key)
	};

	key = (struct ipw_wep_key *)&cmd.param;
	key->cmd_id = DINO_CMD_WEP_KEY;
	key->seq_num = 0;

5700 5701
	/* Note: AES keys cannot be set for multiple times.
	 * Only set it at the first time. */
5702
	for (i = 0; i < 4; i++) {
5703 5704
		key->key_index = i | type;
		if (!(priv->ieee->sec.flags & (1 << i))) {
J
James Ketrenos 已提交
5705
			key->key_size = 0;
5706
			continue;
J
James Ketrenos 已提交
5707 5708
		}

5709 5710 5711
		key->key_size = priv->ieee->sec.key_sizes[i];
		memcpy(key->key, priv->ieee->sec.keys[i], key->key_size);

5712
		ipw_send_cmd(priv, &cmd);
5713
	}
J
James Ketrenos 已提交
5714 5715
}

5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764
static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
{
	if (priv->ieee->host_encrypt)
		return;

	switch (level) {
	case SEC_LEVEL_3:
		priv->sys_config.disable_unicast_decryption = 0;
		priv->ieee->host_decrypt = 0;
		break;
	case SEC_LEVEL_2:
		priv->sys_config.disable_unicast_decryption = 1;
		priv->ieee->host_decrypt = 1;
		break;
	case SEC_LEVEL_1:
		priv->sys_config.disable_unicast_decryption = 0;
		priv->ieee->host_decrypt = 0;
		break;
	case SEC_LEVEL_0:
		priv->sys_config.disable_unicast_decryption = 1;
		break;
	default:
		break;
	}
}

static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
{
	if (priv->ieee->host_encrypt)
		return;

	switch (level) {
	case SEC_LEVEL_3:
		priv->sys_config.disable_multicast_decryption = 0;
		break;
	case SEC_LEVEL_2:
		priv->sys_config.disable_multicast_decryption = 1;
		break;
	case SEC_LEVEL_1:
		priv->sys_config.disable_multicast_decryption = 0;
		break;
	case SEC_LEVEL_0:
		priv->sys_config.disable_multicast_decryption = 1;
		break;
	default:
		break;
	}
}

5765 5766 5767 5768
static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
{
	switch (priv->ieee->sec.level) {
	case SEC_LEVEL_3:
5769 5770 5771 5772
		if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
			ipw_send_tgi_tx_key(priv,
					    DCT_FLAG_EXT_SECURITY_CCM,
					    priv->ieee->sec.active_key);
5773

H
Hong Liu 已提交
5774 5775
		if (!priv->ieee->host_mc_decrypt)
			ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5776 5777
		break;
	case SEC_LEVEL_2:
5778 5779 5780 5781
		if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
			ipw_send_tgi_tx_key(priv,
					    DCT_FLAG_EXT_SECURITY_TKIP,
					    priv->ieee->sec.active_key);
5782 5783 5784 5785 5786 5787 5788 5789 5790 5791
		break;
	case SEC_LEVEL_1:
		ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
		break;
	case SEC_LEVEL_0:
	default:
		break;
	}
}

J
James Ketrenos 已提交
5792 5793 5794
static void ipw_adhoc_check(void *data)
{
	struct ipw_priv *priv = data;
5795

5796
	if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
J
James Ketrenos 已提交
5797
	    !(priv->config & CFG_ADHOC_PERSIST)) {
5798 5799 5800 5801
		IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
			  IPW_DL_STATE | IPW_DL_ASSOC,
			  "Missed beacon: %d - disassociate\n",
			  priv->missed_adhoc_beacons);
J
James Ketrenos 已提交
5802 5803 5804 5805 5806
		ipw_remove_current_network(priv);
		ipw_disassociate(priv);
		return;
	}

5807
	queue_delayed_work(priv->workqueue, &priv->adhoc_check,
J
James Ketrenos 已提交
5808 5809 5810
			   priv->assoc_request.beacon_interval);
}

5811 5812 5813 5814 5815 5816 5817 5818
static void ipw_bg_adhoc_check(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_adhoc_check(data);
	up(&priv->sem);
}

J
James Ketrenos 已提交
5819 5820 5821 5822 5823 5824
#ifdef CONFIG_IPW_DEBUG
static void ipw_debug_config(struct ipw_priv *priv)
{
	IPW_DEBUG_INFO("Scan completed, no valid APs matched "
		       "[CFG 0x%08X]\n", priv->config);
	if (priv->config & CFG_STATIC_CHANNEL)
5825
		IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
J
James Ketrenos 已提交
5826 5827 5828
	else
		IPW_DEBUG_INFO("Channel unlocked.\n");
	if (priv->config & CFG_STATIC_ESSID)
5829
		IPW_DEBUG_INFO("ESSID locked to '%s'\n",
5830
			       escape_essid(priv->essid, priv->essid_len));
J
James Ketrenos 已提交
5831 5832 5833
	else
		IPW_DEBUG_INFO("ESSID unlocked.\n");
	if (priv->config & CFG_STATIC_BSSID)
5834 5835
		IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
			       MAC_ARG(priv->bssid));
J
James Ketrenos 已提交
5836 5837 5838 5839 5840 5841 5842 5843 5844
	else
		IPW_DEBUG_INFO("BSSID unlocked.\n");
	if (priv->capability & CAP_PRIVACY_ON)
		IPW_DEBUG_INFO("PRIVACY on\n");
	else
		IPW_DEBUG_INFO("PRIVACY off\n");
	IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
}
#else
J
Jiri Benc 已提交
5845
#define ipw_debug_config(x) do {} while (0)
J
James Ketrenos 已提交
5846 5847
#endif

5848
static inline void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
J
James Ketrenos 已提交
5849 5850 5851 5852 5853 5854 5855 5856
{
	/* TODO: Verify that this works... */
	struct ipw_fixed_rate fr = {
		.tx_rates = priv->rates_mask
	};
	u32 reg;
	u16 mask = 0;

5857
	/* Identify 'current FW band' and match it with the fixed
J
James Ketrenos 已提交
5858
	 * Tx rates */
5859

J
James Ketrenos 已提交
5860
	switch (priv->ieee->freq_band) {
5861
	case IEEE80211_52GHZ_BAND:	/* A only */
J
James Ketrenos 已提交
5862 5863 5864
		/* IEEE_A */
		if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
			/* Invalid fixed rate mask */
5865 5866
			IPW_DEBUG_WX
			    ("invalid fixed rate mask in ipw_set_fixed_rate\n");
J
James Ketrenos 已提交
5867 5868 5869
			fr.tx_rates = 0;
			break;
		}
5870

J
James Ketrenos 已提交
5871 5872 5873
		fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
		break;

5874
	default:		/* 2.4Ghz or Mixed */
J
James Ketrenos 已提交
5875
		/* IEEE_B */
5876
		if (mode == IEEE_B) {
J
James Ketrenos 已提交
5877 5878
			if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
				/* Invalid fixed rate mask */
5879 5880
				IPW_DEBUG_WX
				    ("invalid fixed rate mask in ipw_set_fixed_rate\n");
J
James Ketrenos 已提交
5881 5882 5883
				fr.tx_rates = 0;
			}
			break;
5884
		}
J
James Ketrenos 已提交
5885 5886 5887 5888 5889

		/* IEEE_G */
		if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
				    IEEE80211_OFDM_RATES_MASK)) {
			/* Invalid fixed rate mask */
5890 5891
			IPW_DEBUG_WX
			    ("invalid fixed rate mask in ipw_set_fixed_rate\n");
J
James Ketrenos 已提交
5892 5893 5894 5895 5896 5897 5898 5899
			fr.tx_rates = 0;
			break;
		}

		if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
			mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
			fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
		}
5900

J
James Ketrenos 已提交
5901 5902 5903 5904
		if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
			mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
			fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
		}
5905

J
James Ketrenos 已提交
5906 5907 5908 5909
		if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
			mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
			fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
		}
5910

J
James Ketrenos 已提交
5911 5912 5913 5914 5915
		fr.tx_rates |= mask;
		break;
	}

	reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
5916
	ipw_write_reg32(priv, reg, *(u32 *) & fr);
J
James Ketrenos 已提交
5917 5918
}

5919
static void ipw_abort_scan(struct ipw_priv *priv)
J
James Ketrenos 已提交
5920 5921 5922
{
	int err;

5923 5924 5925 5926 5927
	if (priv->status & STATUS_SCAN_ABORTING) {
		IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
		return;
	}
	priv->status |= STATUS_SCAN_ABORTING;
J
James Ketrenos 已提交
5928

5929 5930 5931 5932 5933
	err = ipw_send_scan_abort(priv);
	if (err)
		IPW_DEBUG_HC("Request to abort scan failed.\n");
}

5934 5935 5936
static void ipw_add_scan_channels(struct ipw_priv *priv,
				  struct ipw_scan_request_ext *scan,
				  int scan_type)
5937 5938
{
	int channel_index = 0;
5939
	const struct ieee80211_geo *geo;
5940
	int i;
5941

5942
	geo = ipw_get_geo(priv->ieee);
J
James Ketrenos 已提交
5943

5944 5945 5946 5947 5948 5949 5950 5951
	if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
		int start = channel_index;
		for (i = 0; i < geo->a_channels; i++) {
			if ((priv->status & STATUS_ASSOCIATED) &&
			    geo->a[i].channel == priv->channel)
				continue;
			channel_index++;
			scan->channels_list[channel_index] = geo->a[i].channel;
5952 5953 5954 5955 5956
			ipw_set_scan_type(scan, channel_index,
					  geo->a[i].
					  flags & IEEE80211_CH_PASSIVE_ONLY ?
					  IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
					  scan_type);
5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968
		}

		if (start != channel_index) {
			scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
			    (channel_index - start);
			channel_index++;
		}
	}

	if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
		int start = channel_index;
		if (priv->config & CFG_SPEED_SCAN) {
5969
			int index;
5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000
			u8 channels[IEEE80211_24GHZ_CHANNELS] = {
				/* nop out the list */
				[0] = 0
			};

			u8 channel;
			while (channel_index < IPW_SCAN_CHANNELS) {
				channel =
				    priv->speed_scan[priv->speed_scan_pos];
				if (channel == 0) {
					priv->speed_scan_pos = 0;
					channel = priv->speed_scan[0];
				}
				if ((priv->status & STATUS_ASSOCIATED) &&
				    channel == priv->channel) {
					priv->speed_scan_pos++;
					continue;
				}

				/* If this channel has already been
				 * added in scan, break from loop
				 * and this will be the first channel
				 * in the next scan.
				 */
				if (channels[channel - 1] != 0)
					break;

				channels[channel - 1] = 1;
				priv->speed_scan_pos++;
				channel_index++;
				scan->channels_list[channel_index] = channel;
6001 6002
				index =
				    ipw_channel_to_index(priv->ieee, channel);
6003
				ipw_set_scan_type(scan, channel_index,
6004 6005 6006 6007 6008
						  geo->bg[index].
						  flags &
						  IEEE80211_CH_PASSIVE_ONLY ?
						  IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
						  : scan_type);
6009 6010 6011 6012 6013 6014 6015 6016 6017 6018
			}
		} else {
			for (i = 0; i < geo->bg_channels; i++) {
				if ((priv->status & STATUS_ASSOCIATED) &&
				    geo->bg[i].channel == priv->channel)
					continue;
				channel_index++;
				scan->channels_list[channel_index] =
				    geo->bg[i].channel;
				ipw_set_scan_type(scan, channel_index,
6019 6020 6021 6022 6023
						  geo->bg[i].
						  flags &
						  IEEE80211_CH_PASSIVE_ONLY ?
						  IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
						  : scan_type);
6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044
			}
		}

		if (start != channel_index) {
			scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
			    (channel_index - start);
		}
	}
}

static int ipw_request_scan(struct ipw_priv *priv)
{
	struct ipw_scan_request_ext scan;
	int err = 0, scan_type;

	if (!(priv->status & STATUS_INIT) ||
	    (priv->status & STATUS_EXIT_PENDING))
		return 0;

	down(&priv->sem);

6045
	if (priv->status & STATUS_SCANNING) {
6046
		IPW_DEBUG_HC("Concurrent scan requested.  Ignoring.\n");
6047
		priv->status |= STATUS_SCAN_PENDING;
6048
		goto done;
6049
	}
J
James Ketrenos 已提交
6050

6051 6052
	if (!(priv->status & STATUS_SCAN_FORCED) &&
	    priv->status & STATUS_SCAN_ABORTING) {
6053 6054
		IPW_DEBUG_HC("Scan request while abort pending.  Queuing.\n");
		priv->status |= STATUS_SCAN_PENDING;
6055
		goto done;
J
James Ketrenos 已提交
6056 6057
	}

6058 6059 6060
	if (priv->status & STATUS_RF_KILL_MASK) {
		IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
		priv->status |= STATUS_SCAN_PENDING;
6061
		goto done;
6062
	}
J
James Ketrenos 已提交
6063

6064
	memset(&scan, 0, sizeof(scan));
J
James Ketrenos 已提交
6065

6066 6067 6068 6069 6070 6071 6072
	if (priv->config & CFG_SPEED_SCAN)
		scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
		    cpu_to_le16(30);
	else
		scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
		    cpu_to_le16(20);

6073 6074
	scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
	    cpu_to_le16(20);
6075
	scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
J
James Ketrenos 已提交
6076

6077
	scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
J
James Ketrenos 已提交
6078

6079
#ifdef CONFIG_IPW2200_MONITOR
6080
	if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6081
		u8 channel;
6082
		u8 band = 0;
J
James Ketrenos 已提交
6083

6084
		switch (ipw_is_valid_channel(priv->ieee, priv->channel)) {
6085
		case IEEE80211_52GHZ_BAND:
6086
			band = (u8) (IPW_A_MODE << 6) | 1;
6087 6088
			channel = priv->channel;
			break;
6089

6090
		case IEEE80211_24GHZ_BAND:
6091
			band = (u8) (IPW_B_MODE << 6) | 1;
6092 6093
			channel = priv->channel;
			break;
6094

6095
		default:
6096 6097
			band = (u8) (IPW_B_MODE << 6) | 1;
			channel = 9;
6098
			break;
6099 6100
		}

6101 6102 6103
		scan.channels_list[0] = band;
		scan.channels_list[1] = channel;
		ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6104

6105 6106 6107 6108 6109 6110 6111 6112
		/* NOTE:  The card will sit on this channel for this time
		 * period.  Scan aborts are timing sensitive and frequently
		 * result in firmware restarts.  As such, it is best to
		 * set a small dwell_time here and just keep re-issuing
		 * scans.  Otherwise fast channel hopping will not actually
		 * hop channels.
		 *
		 * TODO: Move SPEED SCAN support to all modes and bands */
6113 6114
		scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
		    cpu_to_le16(2000);
J
James Ketrenos 已提交
6115
	} else {
6116 6117 6118 6119 6120 6121 6122 6123
#endif				/* CONFIG_IPW2200_MONITOR */
		/* If we are roaming, then make this a directed scan for the
		 * current network.  Otherwise, ensure that every other scan
		 * is a fast channel hop scan */
		if ((priv->status & STATUS_ROAMING)
		    || (!(priv->status & STATUS_ASSOCIATED)
			&& (priv->config & CFG_STATIC_ESSID)
			&& (le32_to_cpu(scan.full_scan_index) % 2))) {
6124 6125
			err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
			if (err) {
6126 6127 6128
				IPW_DEBUG_HC("Attempt to send SSID command "
					     "failed.\n");
				goto done;
6129
			}
J
James Ketrenos 已提交
6130

6131
			scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6132
		} else
6133 6134
			scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;

6135
		ipw_add_scan_channels(priv, &scan, scan_type);
6136
#ifdef CONFIG_IPW2200_MONITOR
J
James Ketrenos 已提交
6137
	}
6138
#endif
6139

6140
	err = ipw_send_scan_request_ext(priv, &scan);
J
James Ketrenos 已提交
6141
	if (err) {
6142
		IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6143
		goto done;
J
James Ketrenos 已提交
6144 6145
	}

6146 6147
	priv->status |= STATUS_SCANNING;
	priv->status &= ~STATUS_SCAN_PENDING;
6148 6149
	queue_delayed_work(priv->workqueue, &priv->scan_check,
			   IPW_SCAN_CHECK_WATCHDOG);
6150
      done:
6151
	up(&priv->sem);
6152
	return err;
6153 6154 6155 6156 6157 6158 6159 6160 6161 6162
}

static void ipw_bg_abort_scan(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_abort_scan(data);
	up(&priv->sem);
}

6163 6164
#if WIRELESS_EXT < 18
/* Support for wpa_supplicant before WE-18, deprecated. */
6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203

/* following definitions must match definitions in driver_ipw.c */

#define IPW_IOCTL_WPA_SUPPLICANT		SIOCIWFIRSTPRIV+30

#define IPW_CMD_SET_WPA_PARAM			1
#define	IPW_CMD_SET_WPA_IE			2
#define IPW_CMD_SET_ENCRYPTION			3
#define IPW_CMD_MLME				4

#define IPW_PARAM_WPA_ENABLED			1
#define IPW_PARAM_TKIP_COUNTERMEASURES		2
#define IPW_PARAM_DROP_UNENCRYPTED		3
#define IPW_PARAM_PRIVACY_INVOKED		4
#define IPW_PARAM_AUTH_ALGS			5
#define IPW_PARAM_IEEE_802_1X			6

#define IPW_MLME_STA_DEAUTH			1
#define IPW_MLME_STA_DISASSOC			2

#define IPW_CRYPT_ERR_UNKNOWN_ALG		2
#define IPW_CRYPT_ERR_UNKNOWN_ADDR		3
#define IPW_CRYPT_ERR_CRYPT_INIT_FAILED		4
#define IPW_CRYPT_ERR_KEY_SET_FAILED		5
#define IPW_CRYPT_ERR_TX_KEY_SET_FAILED		6
#define IPW_CRYPT_ERR_CARD_CONF_FAILED		7

#define	IPW_CRYPT_ALG_NAME_LEN			16

struct ipw_param {
	u32 cmd;
	u8 sta_addr[ETH_ALEN];
	union {
		struct {
			u8 name;
			u32 value;
		} wpa_param;
		struct {
			u32 len;
6204 6205
			u8 reserved[32];
			u8 data[0];
6206 6207
		} wpa_ie;
		struct {
6208 6209
			u32 command;
			u32 reason_code;
6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224
		} mlme;
		struct {
			u8 alg[IPW_CRYPT_ALG_NAME_LEN];
			u8 set_tx;
			u32 err;
			u8 idx;
			u8 seq[8];	/* sequence counter (set: RX, get: TX) */
			u16 key_len;
			u8 key[0];
		} crypt;

	} u;
};

/* end of driver_ipw.c code */
6225
#endif
6226 6227 6228

static int ipw_wpa_enable(struct ipw_priv *priv, int value)
{
6229 6230 6231
	/* This is called when wpa_supplicant loads and closes the driver
	 * interface. */
	return 0;
6232 6233
}

6234 6235 6236 6237
#if WIRELESS_EXT < 18
#define IW_AUTH_ALG_OPEN_SYSTEM			0x1
#define IW_AUTH_ALG_SHARED_KEY			0x2
#endif
6238 6239 6240 6241 6242 6243 6244 6245 6246

static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
{
	struct ieee80211_device *ieee = priv->ieee;
	struct ieee80211_security sec = {
		.flags = SEC_AUTH_MODE,
	};
	int ret = 0;

6247
	if (value & IW_AUTH_ALG_SHARED_KEY) {
6248 6249
		sec.auth_mode = WLAN_AUTH_SHARED_KEY;
		ieee->open_wep = 0;
6250
	} else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6251 6252
		sec.auth_mode = WLAN_AUTH_OPEN;
		ieee->open_wep = 1;
6253 6254
	} else
		return -EINVAL;
6255 6256 6257 6258 6259 6260 6261 6262 6263

	if (ieee->set_security)
		ieee->set_security(ieee->dev, &sec);
	else
		ret = -EOPNOTSUPP;

	return ret;
}

6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282
void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie, int wpa_ie_len)
{
	/* make sure WPA is enabled */
	ipw_wpa_enable(priv, 1);

	ipw_disassociate(priv);
}

static int ipw_set_rsn_capa(struct ipw_priv *priv,
			    char *capabilities, int length)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_RSN_CAPABILITIES,
		.len = length,
	};

	IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");

	memcpy(cmd.param, capabilities, length);
6283
	return ipw_send_cmd(priv, &cmd);
6284 6285 6286
}

#if WIRELESS_EXT < 18
6287 6288 6289
static int ipw_wpa_set_param(struct net_device *dev, u8 name, u32 value)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
6290 6291
	struct ieee80211_crypt_data *crypt;
	unsigned long flags;
6292 6293 6294 6295 6296 6297 6298 6299
	int ret = 0;

	switch (name) {
	case IPW_PARAM_WPA_ENABLED:
		ret = ipw_wpa_enable(priv, value);
		break;

	case IPW_PARAM_TKIP_COUNTERMEASURES:
6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315
		crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
		if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags) {
			IPW_WARNING("Can't set TKIP countermeasures: "
				    "crypt not set!\n");
			break;
		}

		flags = crypt->ops->get_flags(crypt->priv);

		if (value)
			flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
		else
			flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;

		crypt->ops->set_flags(flags, crypt->priv);

6316 6317
		break;

6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348
	case IPW_PARAM_DROP_UNENCRYPTED:{
			/* HACK:
			 *
			 * wpa_supplicant calls set_wpa_enabled when the driver
			 * is loaded and unloaded, regardless of if WPA is being
			 * used.  No other calls are made which can be used to
			 * determine if encryption will be used or not prior to
			 * association being expected.  If encryption is not being
			 * used, drop_unencrypted is set to false, else true -- we
			 * can use this to determine if the CAP_PRIVACY_ON bit should
			 * be set.
			 */
			struct ieee80211_security sec = {
				.flags = SEC_ENABLED,
				.enabled = value,
			};
			priv->ieee->drop_unencrypted = value;
			/* We only change SEC_LEVEL for open mode. Others
			 * are set by ipw_wpa_set_encryption.
			 */
			if (!value) {
				sec.flags |= SEC_LEVEL;
				sec.level = SEC_LEVEL_0;
			} else {
				sec.flags |= SEC_LEVEL;
				sec.level = SEC_LEVEL_1;
			}
			if (priv->ieee->set_security)
				priv->ieee->set_security(priv->ieee->dev, &sec);
			break;
		}
6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391

	case IPW_PARAM_PRIVACY_INVOKED:
		priv->ieee->privacy_invoked = value;
		break;

	case IPW_PARAM_AUTH_ALGS:
		ret = ipw_wpa_set_auth_algs(priv, value);
		break;

	case IPW_PARAM_IEEE_802_1X:
		priv->ieee->ieee802_1x = value;
		break;

	default:
		IPW_ERROR("%s: Unknown WPA param: %d\n", dev->name, name);
		ret = -EOPNOTSUPP;
	}

	return ret;
}

static int ipw_wpa_mlme(struct net_device *dev, int command, int reason)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	int ret = 0;

	switch (command) {
	case IPW_MLME_STA_DEAUTH:
		// silently ignore
		break;

	case IPW_MLME_STA_DISASSOC:
		ipw_disassociate(priv);
		break;

	default:
		IPW_ERROR("%s: Unknown MLME request: %d\n", dev->name, command);
		ret = -EOPNOTSUPP;
	}

	return ret;
}

6392 6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408
static int ipw_wpa_ie_cipher2level(u8 cipher)
{
	switch (cipher) {
	case 4:		/* CCMP */
		return SEC_LEVEL_3;
	case 2:		/* TKIP */
		return SEC_LEVEL_2;
	case 5:		/* WEP104 */
	case 1:		/* WEP40 */
		return SEC_LEVEL_1;
	case 0:		/* NONE */
		return SEC_LEVEL_0;
	default:
		return -1;
	}
}

6409 6410 6411 6412 6413 6414
static int ipw_wpa_set_wpa_ie(struct net_device *dev,
			      struct ipw_param *param, int plen)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	struct ieee80211_device *ieee = priv->ieee;
	u8 *buf;
6415 6416
	u8 *ptk, *gtk;
	int level;
6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434

	if (param->u.wpa_ie.len > MAX_WPA_IE_LEN ||
	    (param->u.wpa_ie.len && param->u.wpa_ie.data == NULL))
		return -EINVAL;

	if (param->u.wpa_ie.len) {
		buf = kmalloc(param->u.wpa_ie.len, GFP_KERNEL);
		if (buf == NULL)
			return -ENOMEM;

		memcpy(buf, param->u.wpa_ie.data, param->u.wpa_ie.len);
		kfree(ieee->wpa_ie);
		ieee->wpa_ie = buf;
		ieee->wpa_ie_len = param->u.wpa_ie.len;
	} else {
		kfree(ieee->wpa_ie);
		ieee->wpa_ie = NULL;
		ieee->wpa_ie_len = 0;
6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451
		goto done;
	}

	if (priv->ieee->host_encrypt)
		goto done;

	/* HACK: Parse wpa_ie here to get pairwise suite, otherwise
	 * we need to change driver_ipw.c from wpa_supplicant. This
	 * is OK since -Dipw is deprecated. The -Dwext driver has a
	 * clean way to handle this. */
	gtk = ptk = (u8 *) ieee->wpa_ie;
	if (ieee->wpa_ie[0] == 0x30) {	/* RSN IE */
		gtk += 4 + 3;
		ptk += 4 + 4 + 2 + 3;
	} else {		/* WPA IE */
		gtk += 8 + 3;
		ptk += 8 + 4 + 2 + 3;
6452 6453
	}

6454 6455 6456 6457 6458 6459 6460 6461 6462 6463
	if (ptk - (u8 *) ieee->wpa_ie > ieee->wpa_ie_len)
		return -EINVAL;

	level = ipw_wpa_ie_cipher2level(*gtk);
	ipw_set_hw_decrypt_multicast(priv, level);

	level = ipw_wpa_ie_cipher2level(*ptk);
	ipw_set_hw_decrypt_unicast(priv, level);

      done:
6464 6465 6466 6467 6468 6469 6470 6471 6472 6473
	ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
	return 0;
}

/* implementation borrowed from hostap driver */

static int ipw_wpa_set_encryption(struct net_device *dev,
				  struct ipw_param *param, int param_len)
{
	int ret = 0;
H
Hong Liu 已提交
6474
	int group_key = 0;
6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503
	struct ipw_priv *priv = ieee80211_priv(dev);
	struct ieee80211_device *ieee = priv->ieee;
	struct ieee80211_crypto_ops *ops;
	struct ieee80211_crypt_data **crypt;

	struct ieee80211_security sec = {
		.flags = 0,
	};

	param->u.crypt.err = 0;
	param->u.crypt.alg[IPW_CRYPT_ALG_NAME_LEN - 1] = '\0';

	if (param_len !=
	    (int)((char *)param->u.crypt.key - (char *)param) +
	    param->u.crypt.key_len) {
		IPW_DEBUG_INFO("Len mismatch %d, %d\n", param_len,
			       param->u.crypt.key_len);
		return -EINVAL;
	}
	if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
	    param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
	    param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
		if (param->u.crypt.idx >= WEP_KEYS)
			return -EINVAL;
		crypt = &ieee->crypt[param->u.crypt.idx];
	} else {
		return -EINVAL;
	}

H
Hong Liu 已提交
6504 6505 6506
	if (param->u.crypt.idx != 0)
		group_key = 1;

6507
	sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
6508 6509 6510
	if (strcmp(param->u.crypt.alg, "none") == 0) {
		if (crypt) {
			sec.enabled = 0;
6511
			sec.encrypt = 0;
6512
			sec.level = SEC_LEVEL_0;
6513
			sec.flags |= SEC_LEVEL;
6514 6515 6516 6517 6518
			ieee80211_crypt_delayed_deinit(ieee, crypt);
		}
		goto done;
	}
	sec.enabled = 1;
6519
	sec.encrypt = 1;
6520

6521
	/* IPW HW cannot build TKIP MIC, host decryption still needed. */
H
Hong Liu 已提交
6522 6523 6524 6525 6526 6527
	if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
		if (group_key)
			ieee->host_mc_decrypt = 1;
		else
			ieee->host_encrypt_msdu = 1;
	}
6528

H
Hong Liu 已提交
6529 6530 6531 6532 6533 6534
	/*if (!(ieee->host_encrypt || ieee->host_encrypt_msdu ||
	   ieee->host_decrypt))
	   goto skip_host_crypt; */
	if (group_key ? !ieee->host_mc_decrypt :
	    !(ieee->host_encrypt || ieee->host_decrypt ||
	      ieee->host_encrypt_msdu))
6535 6536
		goto skip_host_crypt;

6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592
	ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
	if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) {
		request_module("ieee80211_crypt_wep");
		ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
	} else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) {
		request_module("ieee80211_crypt_tkip");
		ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
	} else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) {
		request_module("ieee80211_crypt_ccmp");
		ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
	}
	if (ops == NULL) {
		IPW_DEBUG_INFO("%s: unknown crypto alg '%s'\n",
			       dev->name, param->u.crypt.alg);
		param->u.crypt.err = IPW_CRYPT_ERR_UNKNOWN_ALG;
		ret = -EINVAL;
		goto done;
	}

	if (*crypt == NULL || (*crypt)->ops != ops) {
		struct ieee80211_crypt_data *new_crypt;

		ieee80211_crypt_delayed_deinit(ieee, crypt);

		new_crypt = (struct ieee80211_crypt_data *)
		    kmalloc(sizeof(*new_crypt), GFP_KERNEL);
		if (new_crypt == NULL) {
			ret = -ENOMEM;
			goto done;
		}
		memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
		new_crypt->ops = ops;
		if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
			new_crypt->priv =
			    new_crypt->ops->init(param->u.crypt.idx);

		if (new_crypt->priv == NULL) {
			kfree(new_crypt);
			param->u.crypt.err = IPW_CRYPT_ERR_CRYPT_INIT_FAILED;
			ret = -EINVAL;
			goto done;
		}

		*crypt = new_crypt;
	}

	if (param->u.crypt.key_len > 0 && (*crypt)->ops->set_key &&
	    (*crypt)->ops->set_key(param->u.crypt.key,
				   param->u.crypt.key_len, param->u.crypt.seq,
				   (*crypt)->priv) < 0) {
		IPW_DEBUG_INFO("%s: key setting failed\n", dev->name);
		param->u.crypt.err = IPW_CRYPT_ERR_KEY_SET_FAILED;
		ret = -EINVAL;
		goto done;
	}

6593
      skip_host_crypt:
6594 6595 6596 6597
	if (param->u.crypt.set_tx) {
		ieee->tx_keyidx = param->u.crypt.idx;
		sec.active_key = param->u.crypt.idx;
		sec.flags |= SEC_ACTIVE_KEY;
6598 6599
	} else
		sec.flags &= ~SEC_ACTIVE_KEY;
6600

6601 6602 6603 6604 6605 6606 6607
	if (param->u.crypt.alg != NULL) {
		memcpy(sec.keys[param->u.crypt.idx],
		       param->u.crypt.key, param->u.crypt.key_len);
		sec.key_sizes[param->u.crypt.idx] = param->u.crypt.key_len;
		sec.flags |= (1 << param->u.crypt.idx);

		if (strcmp(param->u.crypt.alg, "WEP") == 0) {
6608 6609
			sec.flags |= SEC_LEVEL;
			sec.level = SEC_LEVEL_1;
6610
		} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
6611 6612
			sec.flags |= SEC_LEVEL;
			sec.level = SEC_LEVEL_2;
6613
		} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
6614 6615 6616
			sec.flags |= SEC_LEVEL;
			sec.level = SEC_LEVEL_3;
		}
H
Hong Liu 已提交
6617 6618 6619
		/* Don't set sec level for group keys. */
		if (group_key)
			sec.flags &= ~SEC_LEVEL;
6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643
	}
      done:
	if (ieee->set_security)
		ieee->set_security(ieee->dev, &sec);

	/* Do not reset port if card is in Managed mode since resetting will
	 * generate new IEEE 802.11 authentication which may end up in looping
	 * with IEEE 802.1X.  If your hardware requires a reset after WEP
	 * configuration (for example... Prism2), implement the reset_port in
	 * the callbacks structures used to initialize the 802.11 stack. */
	if (ieee->reset_on_keychange &&
	    ieee->iw_mode != IW_MODE_INFRA &&
	    ieee->reset_port && ieee->reset_port(dev)) {
		IPW_DEBUG_INFO("%s: reset_port failed\n", dev->name);
		param->u.crypt.err = IPW_CRYPT_ERR_CARD_CONF_FAILED;
		return -EINVAL;
	}

	return ret;
}

static int ipw_wpa_supplicant(struct net_device *dev, struct iw_point *p)
{
	struct ipw_param *param;
6644
	struct ipw_priv *priv = ieee80211_priv(dev);
6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660
	int ret = 0;

	IPW_DEBUG_INFO("wpa_supplicant: len=%d\n", p->length);

	if (p->length < sizeof(struct ipw_param) || !p->pointer)
		return -EINVAL;

	param = (struct ipw_param *)kmalloc(p->length, GFP_KERNEL);
	if (param == NULL)
		return -ENOMEM;

	if (copy_from_user(param, p->pointer, p->length)) {
		kfree(param);
		return -EFAULT;
	}

6661
	down(&priv->sem);
6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687
	switch (param->cmd) {

	case IPW_CMD_SET_WPA_PARAM:
		ret = ipw_wpa_set_param(dev, param->u.wpa_param.name,
					param->u.wpa_param.value);
		break;

	case IPW_CMD_SET_WPA_IE:
		ret = ipw_wpa_set_wpa_ie(dev, param, p->length);
		break;

	case IPW_CMD_SET_ENCRYPTION:
		ret = ipw_wpa_set_encryption(dev, param, p->length);
		break;

	case IPW_CMD_MLME:
		ret = ipw_wpa_mlme(dev, param->u.mlme.command,
				   param->u.mlme.reason_code);
		break;

	default:
		IPW_ERROR("%s: Unknown WPA supplicant request: %d\n",
			  dev->name, param->cmd);
		ret = -EOPNOTSUPP;
	}

6688
	up(&priv->sem);
6689 6690 6691 6692 6693 6694
	if (ret == 0 && copy_to_user(p->pointer, param, p->length))
		ret = -EFAULT;

	kfree(param);
	return ret;
}
6695
#else
6696
/*
6697 6698 6699 6700 6701 6702 6703
 * WE-18 support
 */

/* SIOCSIWGENIE */
static int ipw_wx_set_genie(struct net_device *dev,
			    struct iw_request_info *info,
			    union iwreq_data *wrqu, char *extra)
6704
{
6705 6706 6707 6708
	struct ipw_priv *priv = ieee80211_priv(dev);
	struct ieee80211_device *ieee = priv->ieee;
	u8 *buf;
	int err = 0;
6709

6710 6711 6712
	if (wrqu->data.length > MAX_WPA_IE_LEN ||
	    (wrqu->data.length && extra == NULL))
		return -EINVAL;
6713

6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731
	//down(&priv->sem);

	//if (!ieee->wpa_enabled) {
	//      err = -EOPNOTSUPP;
	//      goto out;
	//}

	if (wrqu->data.length) {
		buf = kmalloc(wrqu->data.length, GFP_KERNEL);
		if (buf == NULL) {
			err = -ENOMEM;
			goto out;
		}

		memcpy(buf, extra, wrqu->data.length);
		kfree(ieee->wpa_ie);
		ieee->wpa_ie = buf;
		ieee->wpa_ie_len = wrqu->data.length;
6732
	} else {
6733 6734 6735
		kfree(ieee->wpa_ie);
		ieee->wpa_ie = NULL;
		ieee->wpa_ie_len = 0;
6736
	}
6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777

	ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
      out:
	//up(&priv->sem);
	return err;
}

/* SIOCGIWGENIE */
static int ipw_wx_get_genie(struct net_device *dev,
			    struct iw_request_info *info,
			    union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	struct ieee80211_device *ieee = priv->ieee;
	int err = 0;

	//down(&priv->sem);

	//if (!ieee->wpa_enabled) {
	//      err = -EOPNOTSUPP;
	//      goto out;
	//}

	if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
		wrqu->data.length = 0;
		goto out;
	}

	if (wrqu->data.length < ieee->wpa_ie_len) {
		err = -E2BIG;
		goto out;
	}

	wrqu->data.length = ieee->wpa_ie_len;
	memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);

      out:
	//up(&priv->sem);
	return err;
}

6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794
static int wext_cipher2level(int cipher)
{
	switch (cipher) {
	case IW_AUTH_CIPHER_NONE:
		return SEC_LEVEL_0;
	case IW_AUTH_CIPHER_WEP40:
	case IW_AUTH_CIPHER_WEP104:
		return SEC_LEVEL_1;
	case IW_AUTH_CIPHER_TKIP:
		return SEC_LEVEL_2;
	case IW_AUTH_CIPHER_CCMP:
		return SEC_LEVEL_3;
	default:
		return -1;
	}
}

6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805 6806 6807 6808
/* SIOCSIWAUTH */
static int ipw_wx_set_auth(struct net_device *dev,
			   struct iw_request_info *info,
			   union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	struct ieee80211_device *ieee = priv->ieee;
	struct iw_param *param = &wrqu->param;
	struct ieee80211_crypt_data *crypt;
	unsigned long flags;
	int ret = 0;

	switch (param->flags & IW_AUTH_INDEX) {
	case IW_AUTH_WPA_VERSION:
6809
		break;
6810
	case IW_AUTH_CIPHER_PAIRWISE:
6811 6812 6813
		ipw_set_hw_decrypt_unicast(priv,
					   wext_cipher2level(param->value));
		break;
6814
	case IW_AUTH_CIPHER_GROUP:
6815 6816 6817
		ipw_set_hw_decrypt_multicast(priv,
					     wext_cipher2level(param->value));
		break;
6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968 6969
	case IW_AUTH_KEY_MGMT:
		/*
		 * ipw2200 does not use these parameters
		 */
		break;

	case IW_AUTH_TKIP_COUNTERMEASURES:
		crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
		if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags) {
			IPW_WARNING("Can't set TKIP countermeasures: "
				    "crypt not set!\n");
			break;
		}

		flags = crypt->ops->get_flags(crypt->priv);

		if (param->value)
			flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
		else
			flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;

		crypt->ops->set_flags(flags, crypt->priv);

		break;

	case IW_AUTH_DROP_UNENCRYPTED:{
			/* HACK:
			 *
			 * wpa_supplicant calls set_wpa_enabled when the driver
			 * is loaded and unloaded, regardless of if WPA is being
			 * used.  No other calls are made which can be used to
			 * determine if encryption will be used or not prior to
			 * association being expected.  If encryption is not being
			 * used, drop_unencrypted is set to false, else true -- we
			 * can use this to determine if the CAP_PRIVACY_ON bit should
			 * be set.
			 */
			struct ieee80211_security sec = {
				.flags = SEC_ENABLED,
				.enabled = param->value,
			};
			priv->ieee->drop_unencrypted = param->value;
			/* We only change SEC_LEVEL for open mode. Others
			 * are set by ipw_wpa_set_encryption.
			 */
			if (!param->value) {
				sec.flags |= SEC_LEVEL;
				sec.level = SEC_LEVEL_0;
			} else {
				sec.flags |= SEC_LEVEL;
				sec.level = SEC_LEVEL_1;
			}
			if (priv->ieee->set_security)
				priv->ieee->set_security(priv->ieee->dev, &sec);
			break;
		}

	case IW_AUTH_80211_AUTH_ALG:
		ret = ipw_wpa_set_auth_algs(priv, param->value);
		break;

	case IW_AUTH_WPA_ENABLED:
		ret = ipw_wpa_enable(priv, param->value);
		break;

	case IW_AUTH_RX_UNENCRYPTED_EAPOL:
		ieee->ieee802_1x = param->value;
		break;

		//case IW_AUTH_ROAMING_CONTROL:
	case IW_AUTH_PRIVACY_INVOKED:
		ieee->privacy_invoked = param->value;
		break;

	default:
		return -EOPNOTSUPP;
	}
	return ret;
}

/* SIOCGIWAUTH */
static int ipw_wx_get_auth(struct net_device *dev,
			   struct iw_request_info *info,
			   union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	struct ieee80211_device *ieee = priv->ieee;
	struct ieee80211_crypt_data *crypt;
	struct iw_param *param = &wrqu->param;
	int ret = 0;

	switch (param->flags & IW_AUTH_INDEX) {
	case IW_AUTH_WPA_VERSION:
	case IW_AUTH_CIPHER_PAIRWISE:
	case IW_AUTH_CIPHER_GROUP:
	case IW_AUTH_KEY_MGMT:
		/*
		 * wpa_supplicant will control these internally
		 */
		ret = -EOPNOTSUPP;
		break;

	case IW_AUTH_TKIP_COUNTERMEASURES:
		crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
		if (!crypt || !crypt->ops->get_flags) {
			IPW_WARNING("Can't get TKIP countermeasures: "
				    "crypt not set!\n");
			break;
		}

		param->value = (crypt->ops->get_flags(crypt->priv) &
				IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;

		break;

	case IW_AUTH_DROP_UNENCRYPTED:
		param->value = ieee->drop_unencrypted;
		break;

	case IW_AUTH_80211_AUTH_ALG:
		param->value = ieee->sec.auth_mode;
		break;

	case IW_AUTH_WPA_ENABLED:
		param->value = ieee->wpa_enabled;
		break;

	case IW_AUTH_RX_UNENCRYPTED_EAPOL:
		param->value = ieee->ieee802_1x;
		break;

	case IW_AUTH_ROAMING_CONTROL:
	case IW_AUTH_PRIVACY_INVOKED:
		param->value = ieee->privacy_invoked;
		break;

	default:
		return -EOPNOTSUPP;
	}
	return 0;
}

/* SIOCSIWENCODEEXT */
static int ipw_wx_set_encodeext(struct net_device *dev,
				struct iw_request_info *info,
				union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;

	if (hwcrypto) {
		if (ext->alg == IW_ENCODE_ALG_TKIP) {
H
Hong Liu 已提交
6970 6971 6972 6973 6974 6975 6976 6977 6978
			/* IPW HW can't build TKIP MIC,
			   host decryption still needed */
			if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
				priv->ieee->host_mc_decrypt = 1;
			else {
				priv->ieee->host_encrypt = 0;
				priv->ieee->host_encrypt_msdu = 1;
				priv->ieee->host_decrypt = 1;
			}
6979 6980 6981 6982
		} else {
			priv->ieee->host_encrypt = 0;
			priv->ieee->host_encrypt_msdu = 0;
			priv->ieee->host_decrypt = 0;
H
Hong Liu 已提交
6983
			priv->ieee->host_mc_decrypt = 0;
6984 6985 6986 6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047
		}
	}

	return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
}

/* SIOCGIWENCODEEXT */
static int ipw_wx_get_encodeext(struct net_device *dev,
				struct iw_request_info *info,
				union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
}

/* SIOCSIWMLME */
static int ipw_wx_set_mlme(struct net_device *dev,
			   struct iw_request_info *info,
			   union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	struct iw_mlme *mlme = (struct iw_mlme *)extra;
	u16 reason;

	reason = cpu_to_le16(mlme->reason_code);

	switch (mlme->cmd) {
	case IW_MLME_DEAUTH:
		// silently ignore
		break;

	case IW_MLME_DISASSOC:
		ipw_disassociate(priv);
		break;

	default:
		return -EOPNOTSUPP;
	}
	return 0;
}
#endif

#ifdef CONFIG_IPW_QOS

/* QoS */
/*
* get the modulation type of the current network or
* the card current mode
*/
u8 ipw_qos_current_mode(struct ipw_priv * priv)
{
	u8 mode = 0;

	if (priv->status & STATUS_ASSOCIATED) {
		unsigned long flags;

		spin_lock_irqsave(&priv->ieee->lock, flags);
		mode = priv->assoc_network->mode;
		spin_unlock_irqrestore(&priv->ieee->lock, flags);
	} else {
		mode = priv->ieee->mode;
	}
	IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
	return mode;
7048
}
7049

7050 7051 7052
/*
* Handle management frame beacon and probe response
*/
7053 7054 7055
static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
					 int active_network,
					 struct ieee80211_network *network)
7056 7057 7058
{
	u32 size = sizeof(struct ieee80211_qos_parameters);

7059
	if (network->capability & WLAN_CAPABILITY_IBSS)
7060 7061 7062
		network->qos_data.active = network->qos_data.supported;

	if (network->flags & NETWORK_HAS_QOS_MASK) {
7063 7064
		if (active_network &&
		    (network->flags & NETWORK_HAS_QOS_PARAMETERS))
7065 7066 7067 7068 7069 7070 7071 7072 7073
			network->qos_data.active = network->qos_data.supported;

		if ((network->qos_data.active == 1) && (active_network == 1) &&
		    (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
		    (network->qos_data.old_param_count !=
		     network->qos_data.param_count)) {
			network->qos_data.old_param_count =
			    network->qos_data.param_count;
			schedule_work(&priv->qos_activate);
7074 7075
			IPW_DEBUG_QOS("QoS parameters change call "
				      "qos_activate\n");
7076
		}
7077
	} else {
7078 7079
		if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
			memcpy(&network->qos_data.parameters,
7080
			       &def_parameters_CCK, size);
7081 7082
		else
			memcpy(&network->qos_data.parameters,
7083
			       &def_parameters_OFDM, size);
7084

7085 7086 7087 7088 7089 7090 7091
		if ((network->qos_data.active == 1) && (active_network == 1)) {
			IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
			schedule_work(&priv->qos_activate);
		}

		network->qos_data.active = 0;
		network->qos_data.supported = 0;
7092
	}
7093 7094 7095 7096 7097
	if ((priv->status & STATUS_ASSOCIATED) &&
	    (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
		if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
			if ((network->capability & WLAN_CAPABILITY_IBSS) &&
			    !(network->flags & NETWORK_EMPTY_ESSID))
7098
				if ((network->ssid_len ==
7099 7100 7101 7102
				     priv->assoc_network->ssid_len) &&
				    !memcmp(network->ssid,
					    priv->assoc_network->ssid,
					    network->ssid_len)) {
7103 7104 7105 7106
					queue_work(priv->workqueue,
						   &priv->merge_networks);
				}
	}
7107

7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139
	return 0;
}

/*
* This function set up the firmware to support QoS. It sends
* IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
*/
static int ipw_qos_activate(struct ipw_priv *priv,
			    struct ieee80211_qos_data *qos_network_data)
{
	int err;
	struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
	struct ieee80211_qos_parameters *active_one = NULL;
	u32 size = sizeof(struct ieee80211_qos_parameters);
	u32 burst_duration;
	int i;
	u8 type;

	type = ipw_qos_current_mode(priv);

	active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
	memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
	active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
	memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);

	if (qos_network_data == NULL) {
		if (type == IEEE_B) {
			IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
			active_one = &def_parameters_CCK;
		} else
			active_one = &def_parameters_OFDM;

7140
		memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7141 7142
		burst_duration = ipw_qos_get_burst_duration(priv);
		for (i = 0; i < QOS_QUEUE_NUM; i++)
7143 7144 7145
			qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
			    (u16) burst_duration;
	} else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158
		if (type == IEEE_B) {
			IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
				      type);
			if (priv->qos_data.qos_enable == 0)
				active_one = &def_parameters_CCK;
			else
				active_one = priv->qos_data.def_qos_parm_CCK;
		} else {
			if (priv->qos_data.qos_enable == 0)
				active_one = &def_parameters_OFDM;
			else
				active_one = priv->qos_data.def_qos_parm_OFDM;
		}
7159
		memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7160 7161 7162 7163 7164 7165 7166 7167
	} else {
		unsigned long flags;
		int active;

		spin_lock_irqsave(&priv->ieee->lock, flags);
		active_one = &(qos_network_data->parameters);
		qos_network_data->old_param_count =
		    qos_network_data->param_count;
7168
		memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180
		active = qos_network_data->supported;
		spin_unlock_irqrestore(&priv->ieee->lock, flags);

		if (active == 0) {
			burst_duration = ipw_qos_get_burst_duration(priv);
			for (i = 0; i < QOS_QUEUE_NUM; i++)
				qos_parameters[QOS_PARAM_SET_ACTIVE].
				    tx_op_limit[i] = (u16) burst_duration;
		}
	}

	IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
7181 7182 7183
	err = ipw_send_qos_params_command(priv,
					  (struct ieee80211_qos_parameters *)
					  &(qos_parameters[0]));
7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259 7260 7261 7262 7263 7264 7265 7266 7267 7268 7269 7270 7271 7272 7273 7274 7275
	if (err)
		IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");

	return err;
}

/*
* send IPW_CMD_WME_INFO to the firmware
*/
static int ipw_qos_set_info_element(struct ipw_priv *priv)
{
	int ret = 0;
	struct ieee80211_qos_information_element qos_info;

	if (priv == NULL)
		return -1;

	qos_info.elementID = QOS_ELEMENT_ID;
	qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;

	qos_info.version = QOS_VERSION_1;
	qos_info.ac_info = 0;

	memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
	qos_info.qui_type = QOS_OUI_TYPE;
	qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;

	ret = ipw_send_qos_info_command(priv, &qos_info);
	if (ret != 0) {
		IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
	}
	return ret;
}

/*
* Set the QoS parameter with the association request structure
*/
static int ipw_qos_association(struct ipw_priv *priv,
			       struct ieee80211_network *network)
{
	int err = 0;
	struct ieee80211_qos_data *qos_data = NULL;
	struct ieee80211_qos_data ibss_data = {
		.supported = 1,
		.active = 1,
	};

	switch (priv->ieee->iw_mode) {
	case IW_MODE_ADHOC:
		if (!(network->capability & WLAN_CAPABILITY_IBSS))
			BUG();

		qos_data = &ibss_data;
		break;

	case IW_MODE_INFRA:
		qos_data = &network->qos_data;
		break;

	default:
		BUG();
		break;
	}

	err = ipw_qos_activate(priv, qos_data);
	if (err) {
		priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
		return err;
	}

	if (priv->qos_data.qos_enable && qos_data->supported) {
		IPW_DEBUG_QOS("QoS will be enabled for this association\n");
		priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
		return ipw_qos_set_info_element(priv);
	}

	return 0;
}

/*
* handling the beaconing responces. if we get different QoS setting
* of the network from the the associated setting adjust the QoS
* setting
*/
static int ipw_qos_association_resp(struct ipw_priv *priv,
				    struct ieee80211_network *network)
{
	int ret = 0;
	unsigned long flags;
	u32 size = sizeof(struct ieee80211_qos_parameters);
	int set_qos_param = 0;

7276 7277
	if ((priv == NULL) || (network == NULL) ||
	    (priv->assoc_network == NULL))
7278 7279 7280 7281 7282
		return ret;

	if (!(priv->status & STATUS_ASSOCIATED))
		return ret;

7283
	if ((priv->ieee->iw_mode != IW_MODE_INFRA))
7284 7285 7286 7287
		return ret;

	spin_lock_irqsave(&priv->ieee->lock, flags);
	if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
7288
		memcpy(&priv->assoc_network->qos_data, &network->qos_data,
7289 7290 7291 7292 7293 7294 7295 7296 7297 7298
		       sizeof(struct ieee80211_qos_data));
		priv->assoc_network->qos_data.active = 1;
		if ((network->qos_data.old_param_count !=
		     network->qos_data.param_count)) {
			set_qos_param = 1;
			network->qos_data.old_param_count =
			    network->qos_data.param_count;
		}

	} else {
7299 7300
		if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
			memcpy(&priv->assoc_network->qos_data.parameters,
7301
			       &def_parameters_CCK, size);
7302 7303
		else
			memcpy(&priv->assoc_network->qos_data.parameters,
7304 7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324
			       &def_parameters_OFDM, size);
		priv->assoc_network->qos_data.active = 0;
		priv->assoc_network->qos_data.supported = 0;
		set_qos_param = 1;
	}

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

	if (set_qos_param == 1)
		schedule_work(&priv->qos_activate);

	return ret;
}

static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
{
	u32 ret = 0;

	if ((priv == NULL))
		return 0;

7325
	if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
7326
		ret = priv->qos_data.burst_duration_CCK;
7327
	else
7328
		ret = priv->qos_data.burst_duration_OFDM;
7329

7330 7331 7332 7333 7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381 7382 7383 7384 7385 7386 7387 7388 7389 7390 7391 7392 7393 7394 7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405
	return ret;
}

/*
* Initialize the setting of QoS global
*/
static void ipw_qos_init(struct ipw_priv *priv, int enable,
			 int burst_enable, u32 burst_duration_CCK,
			 u32 burst_duration_OFDM)
{
	priv->qos_data.qos_enable = enable;

	if (priv->qos_data.qos_enable) {
		priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
		priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
		IPW_DEBUG_QOS("QoS is enabled\n");
	} else {
		priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
		priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
		IPW_DEBUG_QOS("QoS is not enabled\n");
	}

	priv->qos_data.burst_enable = burst_enable;

	if (burst_enable) {
		priv->qos_data.burst_duration_CCK = burst_duration_CCK;
		priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
	} else {
		priv->qos_data.burst_duration_CCK = 0;
		priv->qos_data.burst_duration_OFDM = 0;
	}
}

/*
* map the packet priority to the right TX Queue
*/
static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
{
	if (priority > 7 || !priv->qos_data.qos_enable)
		priority = 0;

	return from_priority_to_tx_queue[priority] - 1;
}

/*
* add QoS parameter to the TX command
*/
static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
					u16 priority,
					struct tfd_data *tfd, u8 unicast)
{
	int ret = 0;
	int tx_queue_id = 0;
	struct ieee80211_qos_data *qos_data = NULL;
	int active, supported;
	unsigned long flags;

	if (!(priv->status & STATUS_ASSOCIATED))
		return 0;

	qos_data = &priv->assoc_network->qos_data;

	spin_lock_irqsave(&priv->ieee->lock, flags);

	if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
		if (unicast == 0)
			qos_data->active = 0;
		else
			qos_data->active = qos_data->supported;
	}

	active = qos_data->active;
	supported = qos_data->supported;

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

7406 7407 7408
	IPW_DEBUG_QOS("QoS  %d network is QoS active %d  supported %d  "
		      "unicast %d\n",
		      priv->qos_data.qos_enable, active, supported, unicast);
7409 7410 7411 7412 7413 7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448
	if (active && priv->qos_data.qos_enable) {
		ret = from_priority_to_tx_queue[priority];
		tx_queue_id = ret - 1;
		IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
		if (priority <= 7) {
			tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
			tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
			tfd->tfd.tfd_26.mchdr.frame_ctl |=
			    IEEE80211_STYPE_QOS_DATA;

			if (priv->qos_data.qos_no_ack_mask &
			    (1UL << tx_queue_id)) {
				tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
				tfd->tfd.tfd_26.mchdr.qos_ctrl |=
				    CTRL_QOS_NO_ACK;
			}
		}
	}

	return ret;
}

/*
* background support to run QoS activate functionality
*/
static void ipw_bg_qos_activate(void *data)
{
	struct ipw_priv *priv = data;

	if (priv == NULL)
		return;

	down(&priv->sem);

	if (priv->status & STATUS_ASSOCIATED)
		ipw_qos_activate(priv, &(priv->assoc_network->qos_data));

	up(&priv->sem);
}

7449 7450 7451
static int ipw_handle_probe_response(struct net_device *dev,
				     struct ieee80211_probe_response *resp,
				     struct ieee80211_network *network)
7452 7453
{
	struct ipw_priv *priv = ieee80211_priv(dev);
7454 7455
	int active_network = ((priv->status & STATUS_ASSOCIATED) &&
			      (network == priv->assoc_network));
7456

7457
	ipw_qos_handle_probe_response(priv, active_network, network);
7458

7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470
	return 0;
}

static int ipw_handle_beacon(struct net_device *dev,
			     struct ieee80211_beacon *resp,
			     struct ieee80211_network *network)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	int active_network = ((priv->status & STATUS_ASSOCIATED) &&
			      (network == priv->assoc_network));

	ipw_qos_handle_probe_response(priv, active_network, network);
7471 7472 7473 7474

	return 0;
}

7475 7476 7477 7478 7479 7480 7481 7482 7483
static int ipw_handle_assoc_response(struct net_device *dev,
				     struct ieee80211_assoc_response *resp,
				     struct ieee80211_network *network)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	ipw_qos_association_resp(priv, network);
	return 0;
}

7484 7485 7486 7487 7488 7489 7490 7491
static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
				       *qos_param)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_QOS_PARAMETERS,
		.len = (sizeof(struct ieee80211_qos_parameters) * 3)
	};

7492
	memcpy(cmd.param, qos_param, sizeof(*qos_param) * 3);
7493
	return ipw_send_cmd(priv, &cmd);
7494 7495 7496 7497 7498 7499 7500 7501 7502 7503
}

static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
				     *qos_param)
{
	struct host_cmd cmd = {
		.cmd = IPW_CMD_WME_INFO,
		.len = sizeof(*qos_param)
	};

7504
	memcpy(cmd.param, qos_param, sizeof(*qos_param));
7505
	return ipw_send_cmd(priv, &cmd);
7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535 7536 7537 7538 7539 7540 7541 7542 7543
}

#endif				/* CONFIG_IPW_QOS */

static int ipw_associate_network(struct ipw_priv *priv,
				 struct ieee80211_network *network,
				 struct ipw_supported_rates *rates, int roaming)
{
	int err;

	if (priv->config & CFG_FIXED_RATE)
		ipw_set_fixed_rate(priv, network->mode);

	if (!(priv->config & CFG_STATIC_ESSID)) {
		priv->essid_len = min(network->ssid_len,
				      (u8) IW_ESSID_MAX_SIZE);
		memcpy(priv->essid, network->ssid, priv->essid_len);
	}

	network->last_associate = jiffies;

	memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
	priv->assoc_request.channel = network->channel;
	if ((priv->capability & CAP_PRIVACY_ON) &&
	    (priv->capability & CAP_SHARED_KEY)) {
		priv->assoc_request.auth_type = AUTH_SHARED_KEY;
		priv->assoc_request.auth_key = priv->ieee->sec.active_key;

		if ((priv->capability & CAP_PRIVACY_ON) &&
		    (priv->ieee->sec.level == SEC_LEVEL_1) &&
		    !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
			ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
	} else {
		priv->assoc_request.auth_type = AUTH_OPEN;
		priv->assoc_request.auth_key = 0;
	}

	if (priv->ieee->wpa_ie_len) {
7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572
		priv->assoc_request.policy_support = 0x02;	/* RSN active */
		ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
				 priv->ieee->wpa_ie_len);
	}

	/*
	 * It is valid for our ieee device to support multiple modes, but
	 * when it comes to associating to a given network we have to choose
	 * just one mode.
	 */
	if (network->mode & priv->ieee->mode & IEEE_A)
		priv->assoc_request.ieee_mode = IPW_A_MODE;
	else if (network->mode & priv->ieee->mode & IEEE_G)
		priv->assoc_request.ieee_mode = IPW_G_MODE;
	else if (network->mode & priv->ieee->mode & IEEE_B)
		priv->assoc_request.ieee_mode = IPW_B_MODE;

	priv->assoc_request.capability = network->capability;
	if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
	    && !(priv->config & CFG_PREAMBLE_LONG)) {
		priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
	} else {
		priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;

		/* Clear the short preamble if we won't be supporting it */
		priv->assoc_request.capability &=
		    ~WLAN_CAPABILITY_SHORT_PREAMBLE;
	}

7573 7574 7575 7576 7577
	/* Clear capability bits that aren't used in Ad Hoc */
	if (priv->ieee->iw_mode == IW_MODE_ADHOC)
		priv->assoc_request.capability &=
		    ~WLAN_CAPABILITY_SHORT_SLOT_TIME;

7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594
	IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
			"802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
			roaming ? "Rea" : "A",
			escape_essid(priv->essid, priv->essid_len),
			network->channel,
			ipw_modes[priv->assoc_request.ieee_mode],
			rates->num_rates,
			(priv->assoc_request.preamble_length ==
			 DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
			network->capability &
			WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
			priv->capability & CAP_PRIVACY_ON ? "on " : "off",
			priv->capability & CAP_PRIVACY_ON ?
			(priv->capability & CAP_SHARED_KEY ? "(shared)" :
			 "(open)") : "",
			priv->capability & CAP_PRIVACY_ON ? " key=" : "",
			priv->capability & CAP_PRIVACY_ON ?
7595
			'1' + priv->ieee->sec.active_key : '.',
7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612
			priv->capability & CAP_PRIVACY_ON ? '.' : ' ');

	priv->assoc_request.beacon_interval = network->beacon_interval;
	if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
	    (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
		priv->assoc_request.assoc_type = HC_IBSS_START;
		priv->assoc_request.assoc_tsf_msw = 0;
		priv->assoc_request.assoc_tsf_lsw = 0;
	} else {
		if (unlikely(roaming))
			priv->assoc_request.assoc_type = HC_REASSOCIATE;
		else
			priv->assoc_request.assoc_type = HC_ASSOCIATE;
		priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
		priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
	}

7613
	memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7614 7615 7616 7617 7618

	if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
		memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
		priv->assoc_request.atim_window = network->atim_window;
	} else {
7619
		memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638
		priv->assoc_request.atim_window = 0;
	}

	priv->assoc_request.listen_interval = network->listen_interval;

	err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
	if (err) {
		IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
		return err;
	}

	rates->ieee_mode = priv->assoc_request.ieee_mode;
	rates->purpose = IPW_RATE_CONNECT;
	ipw_send_supported_rates(priv, rates);

	if (priv->assoc_request.ieee_mode == IPW_G_MODE)
		priv->sys_config.dot11g_auto_detection = 1;
	else
		priv->sys_config.dot11g_auto_detection = 0;
7639 7640 7641 7642 7643 7644

	if (priv->ieee->iw_mode == IW_MODE_ADHOC)
		priv->sys_config.answer_broadcast_ssid_probe = 1;
	else
		priv->sys_config.answer_broadcast_ssid_probe = 0;

7645 7646 7647 7648 7649 7650 7651 7652 7653 7654 7655 7656 7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667
	err = ipw_send_system_config(priv, &priv->sys_config);
	if (err) {
		IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
		return err;
	}

	IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
	err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
	if (err) {
		IPW_DEBUG_HC("Attempt to send associate command failed.\n");
		return err;
	}

	/*
	 * If preemption is enabled, it is possible for the association
	 * to complete before we return from ipw_send_associate.  Therefore
	 * we have to be sure and update our priviate data first.
	 */
	priv->channel = network->channel;
	memcpy(priv->bssid, network->bssid, ETH_ALEN);

	priv->assoc_network = network;

7668 7669 7670 7671
#ifdef CONFIG_IPW_QOS
	ipw_qos_association(priv, network);
#endif

7672 7673
	err = ipw_send_associate(priv, &priv->assoc_request);
	if (err) {
J
James Ketrenos 已提交
7674 7675 7676
		IPW_DEBUG_HC("Attempt to send associate command failed.\n");
		return err;
	}
7677

7678 7679 7680
	priv->status |= STATUS_ASSOCIATING;
	priv->status &= ~STATUS_SECURITY_UPDATED;

7681
	IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
J
James Ketrenos 已提交
7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696
		  escape_essid(priv->essid, priv->essid_len),
		  MAC_ARG(priv->bssid));

	return 0;
}

static void ipw_roam(void *data)
{
	struct ipw_priv *priv = data;
	struct ieee80211_network *network = NULL;
	struct ipw_network_match match = {
		.network = priv->assoc_network
	};

	/* The roaming process is as follows:
7697 7698
	 *
	 * 1.  Missed beacon threshold triggers the roaming process by
J
James Ketrenos 已提交
7699 7700 7701 7702 7703 7704 7705 7706 7707 7708
	 *     setting the status ROAM bit and requesting a scan.
	 * 2.  When the scan completes, it schedules the ROAM work
	 * 3.  The ROAM work looks at all of the known networks for one that
	 *     is a better network than the currently associated.  If none
	 *     found, the ROAM process is over (ROAM bit cleared)
	 * 4.  If a better network is found, a disassociation request is
	 *     sent.
	 * 5.  When the disassociation completes, the roam work is again
	 *     scheduled.  The second time through, the driver is no longer
	 *     associated, and the newly selected network is sent an
7709
	 *     association request.
J
James Ketrenos 已提交
7710 7711 7712 7713 7714 7715 7716 7717
	 * 6.  At this point ,the roaming process is complete and the ROAM
	 *     status bit is cleared.
	 */

	/* If we are no longer associated, and the roaming bit is no longer
	 * set, then we are not actively roaming, so just return */
	if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
		return;
7718

J
James Ketrenos 已提交
7719
	if (priv->status & STATUS_ASSOCIATED) {
7720
		/* First pass through ROAM process -- look for a better
J
James Ketrenos 已提交
7721
		 * network */
7722
		unsigned long flags;
J
James Ketrenos 已提交
7723 7724
		u8 rssi = priv->assoc_network->stats.rssi;
		priv->assoc_network->stats.rssi = -128;
7725
		spin_lock_irqsave(&priv->ieee->lock, flags);
J
James Ketrenos 已提交
7726 7727 7728 7729
		list_for_each_entry(network, &priv->ieee->network_list, list) {
			if (network != priv->assoc_network)
				ipw_best_network(priv, &match, network, 1);
		}
7730
		spin_unlock_irqrestore(&priv->ieee->lock, flags);
J
James Ketrenos 已提交
7731
		priv->assoc_network->stats.rssi = rssi;
7732

J
James Ketrenos 已提交
7733 7734 7735 7736 7737 7738 7739
		if (match.network == priv->assoc_network) {
			IPW_DEBUG_ASSOC("No better APs in this network to "
					"roam to.\n");
			priv->status &= ~STATUS_ROAMING;
			ipw_debug_config(priv);
			return;
		}
7740

J
James Ketrenos 已提交
7741 7742 7743 7744
		ipw_send_disassociate(priv, 1);
		priv->assoc_network = match.network;

		return;
7745
	}
J
James Ketrenos 已提交
7746 7747 7748 7749 7750 7751 7752

	/* Second pass through ROAM process -- request association */
	ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
	ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
	priv->status &= ~STATUS_ROAMING;
}

7753 7754 7755 7756 7757 7758 7759 7760 7761
static void ipw_bg_roam(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_roam(data);
	up(&priv->sem);
}

static int ipw_associate(void *data)
J
James Ketrenos 已提交
7762 7763 7764 7765 7766 7767 7768 7769 7770
{
	struct ipw_priv *priv = data;

	struct ieee80211_network *network = NULL;
	struct ipw_network_match match = {
		.network = NULL
	};
	struct ipw_supported_rates *rates;
	struct list_head *element;
7771
	unsigned long flags;
J
James Ketrenos 已提交
7772

7773 7774 7775 7776 7777
	if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
		IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
		return 0;
	}

7778
	if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7779 7780
		IPW_DEBUG_ASSOC("Not attempting association (already in "
				"progress)\n");
7781 7782 7783 7784
		return 0;
	}

	if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7785 7786
		IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
				"initialized)\n");
7787 7788 7789
		return 0;
	}

J
James Ketrenos 已提交
7790 7791
	if (!(priv->config & CFG_ASSOCIATE) &&
	    !(priv->config & (CFG_STATIC_ESSID |
7792
			      CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
J
James Ketrenos 已提交
7793
		IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7794
		return 0;
J
James Ketrenos 已提交
7795 7796
	}

7797 7798
	/* Protect our use of the network_list */
	spin_lock_irqsave(&priv->ieee->lock, flags);
7799
	list_for_each_entry(network, &priv->ieee->network_list, list)
7800
	    ipw_best_network(priv, &match, network, 0);
J
James Ketrenos 已提交
7801 7802 7803 7804 7805 7806 7807 7808

	network = match.network;
	rates = &match.rates;

	if (network == NULL &&
	    priv->ieee->iw_mode == IW_MODE_ADHOC &&
	    priv->config & CFG_ADHOC_CREATE &&
	    priv->config & CFG_STATIC_ESSID &&
7809
	    priv->config & CFG_STATIC_CHANNEL &&
J
James Ketrenos 已提交
7810 7811
	    !list_empty(&priv->ieee->network_free_list)) {
		element = priv->ieee->network_free_list.next;
7812
		network = list_entry(element, struct ieee80211_network, list);
J
James Ketrenos 已提交
7813 7814 7815 7816 7817
		ipw_adhoc_create(priv, network);
		rates = &priv->rates;
		list_del(element);
		list_add_tail(&network->list, &priv->ieee->network_list);
	}
7818
	spin_unlock_irqrestore(&priv->ieee->lock, flags);
7819

J
James Ketrenos 已提交
7820 7821 7822 7823 7824
	/* If we reached the end of the list, then we don't have any valid
	 * matching APs */
	if (!network) {
		ipw_debug_config(priv);

7825 7826 7827 7828 7829 7830 7831 7832 7833
		if (!(priv->status & STATUS_SCANNING)) {
			if (!(priv->config & CFG_SPEED_SCAN))
				queue_delayed_work(priv->workqueue,
						   &priv->request_scan,
						   SCAN_INTERVAL);
			else
				queue_work(priv->workqueue,
					   &priv->request_scan);
		}
7834

7835
		return 0;
J
James Ketrenos 已提交
7836 7837 7838
	}

	ipw_associate_network(priv, network, rates, 0);
7839 7840 7841 7842 7843 7844 7845 7846 7847 7848

	return 1;
}

static void ipw_bg_associate(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_associate(data);
	up(&priv->sem);
J
James Ketrenos 已提交
7849
}
7850

7851 7852 7853 7854 7855 7856 7857 7858 7859 7860 7861 7862 7863 7864 7865 7866 7867 7868 7869
static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
				      struct sk_buff *skb)
{
	struct ieee80211_hdr *hdr;
	u16 fc;

	hdr = (struct ieee80211_hdr *)skb->data;
	fc = le16_to_cpu(hdr->frame_ctl);
	if (!(fc & IEEE80211_FCTL_PROTECTED))
		return;

	fc &= ~IEEE80211_FCTL_PROTECTED;
	hdr->frame_ctl = cpu_to_le16(fc);
	switch (priv->ieee->sec.level) {
	case SEC_LEVEL_3:
		/* Remove CCMP HDR */
		memmove(skb->data + IEEE80211_3ADDR_LEN,
			skb->data + IEEE80211_3ADDR_LEN + 8,
			skb->len - IEEE80211_3ADDR_LEN - 8);
7870 7871 7872 7873
		if (fc & IEEE80211_FCTL_MOREFRAGS)
			skb_trim(skb, skb->len - 16);	/* 2*MIC */
		else
			skb_trim(skb, skb->len - 8);	/* MIC */
7874 7875 7876 7877 7878 7879 7880 7881
		break;
	case SEC_LEVEL_2:
		break;
	case SEC_LEVEL_1:
		/* Remove IV */
		memmove(skb->data + IEEE80211_3ADDR_LEN,
			skb->data + IEEE80211_3ADDR_LEN + 4,
			skb->len - IEEE80211_3ADDR_LEN - 4);
7882 7883 7884 7885
		if (fc & IEEE80211_FCTL_MOREFRAGS)
			skb_trim(skb, skb->len - 8);	/* 2*ICV */
		else
			skb_trim(skb, skb->len - 4);	/* ICV */
7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898
		break;
	case SEC_LEVEL_0:
		break;
	default:
		printk(KERN_ERR "Unknow security level %d\n",
		       priv->ieee->sec.level);
		break;
	}
}

static void ipw_handle_data_packet(struct ipw_priv *priv,
				   struct ipw_rx_mem_buffer *rxb,
				   struct ieee80211_rx_stats *stats)
J
James Ketrenos 已提交
7899
{
H
Hong Liu 已提交
7900
	struct ieee80211_hdr_4addr *hdr;
J
James Ketrenos 已提交
7901 7902 7903 7904 7905
	struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;

	/* We received data from the HW, so stop the watchdog */
	priv->net_dev->trans_start = jiffies;

7906
	/* We only process data packets if the
J
James Ketrenos 已提交
7907
	 * interface is open */
7908
	if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
J
James Ketrenos 已提交
7909 7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921
		     skb_tailroom(rxb->skb))) {
		priv->ieee->stats.rx_errors++;
		priv->wstats.discard.misc++;
		IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
		return;
	} else if (unlikely(!netif_running(priv->net_dev))) {
		priv->ieee->stats.rx_dropped++;
		priv->wstats.discard.misc++;
		IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
		return;
	}

	/* Advance skb->data to the start of the actual payload */
7922
	skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
J
James Ketrenos 已提交
7923 7924

	/* Set the size of the skb to the size of the frame */
7925
	skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
J
James Ketrenos 已提交
7926 7927 7928

	IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);

7929
	/* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
H
Hong Liu 已提交
7930 7931 7932 7933
	hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
	if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
	    (is_multicast_ether_addr(hdr->addr1) ?
	     !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7934 7935
		ipw_rebuild_decrypted_skb(priv, rxb->skb);

7936
	if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
J
James Ketrenos 已提交
7937
		priv->ieee->stats.rx_errors++;
7938
	else {			/* ieee80211_rx succeeded, so it now owns the SKB */
J
James Ketrenos 已提交
7939
		rxb->skb = NULL;
7940
		__ipw_led_activity_on(priv);
7941
	}
J
James Ketrenos 已提交
7942 7943
}

7944 7945 7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997 7998 7999 8000 8001 8002 8003 8004 8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015 8016 8017 8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050 8051 8052 8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074 8075 8076 8077 8078 8079 8080 8081 8082 8083 8084 8085 8086 8087 8088 8089 8090 8091 8092 8093 8094 8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110
#ifdef CONFIG_IEEE80211_RADIOTAP
static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
					   struct ipw_rx_mem_buffer *rxb,
					   struct ieee80211_rx_stats *stats)
{
	struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
	struct ipw_rx_frame *frame = &pkt->u.frame;

	/* initial pull of some data */
	u16 received_channel = frame->received_channel;
	u8 antennaAndPhy = frame->antennaAndPhy;
	s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM;	/* call it signed anyhow */
	u16 pktrate = frame->rate;

	/* Magic struct that slots into the radiotap header -- no reason
	 * to build this manually element by element, we can write it much
	 * more efficiently than we can parse it. ORDER MATTERS HERE */
	struct ipw_rt_hdr {
		struct ieee80211_radiotap_header rt_hdr;
		u8 rt_flags;	/* radiotap packet flags */
		u8 rt_rate;	/* rate in 500kb/s */
		u16 rt_channel;	/* channel in mhz */
		u16 rt_chbitmask;	/* channel bitfield */
		s8 rt_dbmsignal;	/* signal in dbM, kluged to signed */
		u8 rt_antenna;	/* antenna number */
	} *ipw_rt;

	short len = le16_to_cpu(pkt->u.frame.length);

	/* We received data from the HW, so stop the watchdog */
	priv->net_dev->trans_start = jiffies;

	/* We only process data packets if the
	 * interface is open */
	if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
		     skb_tailroom(rxb->skb))) {
		priv->ieee->stats.rx_errors++;
		priv->wstats.discard.misc++;
		IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
		return;
	} else if (unlikely(!netif_running(priv->net_dev))) {
		priv->ieee->stats.rx_dropped++;
		priv->wstats.discard.misc++;
		IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
		return;
	}

	/* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
	 * that now */
	if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
		/* FIXME: Should alloc bigger skb instead */
		priv->ieee->stats.rx_dropped++;
		priv->wstats.discard.misc++;
		IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
		return;
	}

	/* copy the frame itself */
	memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
		rxb->skb->data + IPW_RX_FRAME_SIZE, len);

	/* Zero the radiotap static buffer  ...  We only need to zero the bytes NOT
	 * part of our real header, saves a little time.
	 *
	 * No longer necessary since we fill in all our data.  Purge before merging
	 * patch officially.
	 * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
	 *        IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
	 */

	ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;

	ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
	ipw_rt->rt_hdr.it_pad = 0;	/* always good to zero */
	ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr);	/* total header+data */

	/* Big bitfield of all the fields we provide in radiotap */
	ipw_rt->rt_hdr.it_present =
	    ((1 << IEEE80211_RADIOTAP_FLAGS) |
	     (1 << IEEE80211_RADIOTAP_RATE) |
	     (1 << IEEE80211_RADIOTAP_CHANNEL) |
	     (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
	     (1 << IEEE80211_RADIOTAP_ANTENNA));

	/* Zero the flags, we'll add to them as we go */
	ipw_rt->rt_flags = 0;

	/* Convert signal to DBM */
	ipw_rt->rt_dbmsignal = antsignal;

	/* Convert the channel data and set the flags */
	ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
	if (received_channel > 14) {	/* 802.11a */
		ipw_rt->rt_chbitmask =
		    cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
	} else if (antennaAndPhy & 32) {	/* 802.11b */
		ipw_rt->rt_chbitmask =
		    cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
	} else {		/* 802.11g */
		ipw_rt->rt_chbitmask =
		    (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
	}

	/* set the rate in multiples of 500k/s */
	switch (pktrate) {
	case IPW_TX_RATE_1MB:
		ipw_rt->rt_rate = 2;
		break;
	case IPW_TX_RATE_2MB:
		ipw_rt->rt_rate = 4;
		break;
	case IPW_TX_RATE_5MB:
		ipw_rt->rt_rate = 10;
		break;
	case IPW_TX_RATE_6MB:
		ipw_rt->rt_rate = 12;
		break;
	case IPW_TX_RATE_9MB:
		ipw_rt->rt_rate = 18;
		break;
	case IPW_TX_RATE_11MB:
		ipw_rt->rt_rate = 22;
		break;
	case IPW_TX_RATE_12MB:
		ipw_rt->rt_rate = 24;
		break;
	case IPW_TX_RATE_18MB:
		ipw_rt->rt_rate = 36;
		break;
	case IPW_TX_RATE_24MB:
		ipw_rt->rt_rate = 48;
		break;
	case IPW_TX_RATE_36MB:
		ipw_rt->rt_rate = 72;
		break;
	case IPW_TX_RATE_48MB:
		ipw_rt->rt_rate = 96;
		break;
	case IPW_TX_RATE_54MB:
		ipw_rt->rt_rate = 108;
		break;
	default:
		ipw_rt->rt_rate = 0;
		break;
	}

	/* antenna number */
	ipw_rt->rt_antenna = (antennaAndPhy & 3);	/* Is this right? */

	/* set the preamble flag if we have it */
	if ((antennaAndPhy & 64))
		ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;

	/* Set the size of the skb to the size of the frame */
	skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));

	IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);

	if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
		priv->ieee->stats.rx_errors++;
	else {			/* ieee80211_rx succeeded, so it now owns the SKB */
		rxb->skb = NULL;
		/* no LED during capture */
	}
}
#endif

8111 8112 8113 8114 8115 8116
static inline int is_network_packet(struct ipw_priv *priv,
				    struct ieee80211_hdr_4addr *header)
{
	/* Filter incoming packets to determine if they are targetted toward
	 * this network, discarding packets coming from ourselves */
	switch (priv->ieee->iw_mode) {
8117
	case IW_MODE_ADHOC:	/* Header: Dest. | Source    | BSSID */
8118 8119 8120 8121
		/* packets from our adapter are dropped (echo) */
		if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
			return 0;

8122 8123 8124
		/* {broad,multi}cast packets to our BSSID go through */
		if (is_multicast_ether_addr(header->addr1) ||
		    is_broadcast_ether_addr(header->addr1))
8125
			return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
8126 8127 8128 8129 8130

		/* packets to our adapter go through */
		return !memcmp(header->addr1, priv->net_dev->dev_addr,
			       ETH_ALEN);

8131
	case IW_MODE_INFRA:	/* Header: Dest. | BSSID | Source */
8132 8133 8134 8135
		/* packets from our adapter are dropped (echo) */
		if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
			return 0;

8136 8137 8138
		/* {broad,multi}cast packets to our BSS go through */
		if (is_multicast_ether_addr(header->addr1) ||
		    is_broadcast_ether_addr(header->addr1))
8139 8140 8141 8142 8143
			return !memcmp(header->addr2, priv->bssid, ETH_ALEN);

		/* packets to our adapter go through */
		return !memcmp(header->addr1, priv->net_dev->dev_addr,
			       ETH_ALEN);
8144
	}
8145

8146 8147 8148
	return 1;
}

8149 8150 8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170 8171 8172 8173 8174 8175 8176 8177 8178 8179 8180 8181 8182 8183 8184 8185 8186 8187 8188 8189 8190 8191 8192 8193 8194 8195 8196 8197 8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208 8209 8210 8211
#define IPW_PACKET_RETRY_TIME HZ

static inline int is_duplicate_packet(struct ipw_priv *priv,
				      struct ieee80211_hdr_4addr *header)
{
	u16 sc = le16_to_cpu(header->seq_ctl);
	u16 seq = WLAN_GET_SEQ_SEQ(sc);
	u16 frag = WLAN_GET_SEQ_FRAG(sc);
	u16 *last_seq, *last_frag;
	unsigned long *last_time;

	switch (priv->ieee->iw_mode) {
	case IW_MODE_ADHOC:
		{
			struct list_head *p;
			struct ipw_ibss_seq *entry = NULL;
			u8 *mac = header->addr2;
			int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;

			__list_for_each(p, &priv->ibss_mac_hash[index]) {
				entry =
				    list_entry(p, struct ipw_ibss_seq, list);
				if (!memcmp(entry->mac, mac, ETH_ALEN))
					break;
			}
			if (p == &priv->ibss_mac_hash[index]) {
				entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
				if (!entry) {
					IPW_ERROR
					    ("Cannot malloc new mac entry\n");
					return 0;
				}
				memcpy(entry->mac, mac, ETH_ALEN);
				entry->seq_num = seq;
				entry->frag_num = frag;
				entry->packet_time = jiffies;
				list_add(&entry->list,
					 &priv->ibss_mac_hash[index]);
				return 0;
			}
			last_seq = &entry->seq_num;
			last_frag = &entry->frag_num;
			last_time = &entry->packet_time;
			break;
		}
	case IW_MODE_INFRA:
		last_seq = &priv->last_seq_num;
		last_frag = &priv->last_frag_num;
		last_time = &priv->last_packet_time;
		break;
	default:
		return 0;
	}
	if ((*last_seq == seq) &&
	    time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
		if (*last_frag == frag)
			goto drop;
		if (*last_frag + 1 != frag)
			/* out-of-order fragment */
			goto drop;
	} else
		*last_seq = seq;

8212
	*last_frag = frag;
8213 8214 8215 8216
	*last_time = jiffies;
	return 0;

      drop:
8217 8218 8219 8220
	/* Comment this line now since we observed the card receives
	 * duplicate packets but the FCTL_RETRY bit is not set in the
	 * IBSS mode with fragmentation enabled.
	 BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
8221 8222 8223
	return 1;
}

8224 8225 8226 8227 8228 8229 8230 8231 8232 8233 8234 8235 8236 8237 8238 8239 8240 8241 8242 8243 8244 8245 8246 8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258 8259 8260 8261 8262 8263 8264 8265 8266 8267 8268 8269 8270
static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
				   struct ipw_rx_mem_buffer *rxb,
				   struct ieee80211_rx_stats *stats)
{
	struct sk_buff *skb = rxb->skb;
	struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
	struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
	    (skb->data + IPW_RX_FRAME_SIZE);

	ieee80211_rx_mgt(priv->ieee, header, stats);

	if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
	    ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
	      IEEE80211_STYPE_PROBE_RESP) ||
	     (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
	      IEEE80211_STYPE_BEACON))) {
		if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
			ipw_add_station(priv, header->addr2);
	}

	if (priv->config & CFG_NET_STATS) {
		IPW_DEBUG_HC("sending stat packet\n");

		/* Set the size of the skb to the size of the full
		 * ipw header and 802.11 frame */
		skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
			IPW_RX_FRAME_SIZE);

		/* Advance past the ipw packet header to the 802.11 frame */
		skb_pull(skb, IPW_RX_FRAME_SIZE);

		/* Push the ieee80211_rx_stats before the 802.11 frame */
		memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));

		skb->dev = priv->ieee->dev;

		/* Point raw at the ieee80211_stats */
		skb->mac.raw = skb->data;

		skb->pkt_type = PACKET_OTHERHOST;
		skb->protocol = __constant_htons(ETH_P_80211_STATS);
		memset(skb->cb, 0, sizeof(rxb->skb->cb));
		netif_rx(skb);
		rxb->skb = NULL;
	}
}

J
James Ketrenos 已提交
8271 8272 8273 8274 8275 8276 8277 8278 8279
/*
 * Main entry function for recieving a packet with 80211 headers.  This
 * should be called when ever the FW has notified us that there is a new
 * skb in the recieve queue.
 */
static void ipw_rx(struct ipw_priv *priv)
{
	struct ipw_rx_mem_buffer *rxb;
	struct ipw_rx_packet *pkt;
8280
	struct ieee80211_hdr_4addr *header;
J
James Ketrenos 已提交
8281 8282 8283
	u32 r, w, i;
	u8 network_packet;

8284 8285
	r = ipw_read32(priv, IPW_RX_READ_INDEX);
	w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
J
James Ketrenos 已提交
8286 8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298
	i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;

	while (i != r) {
		rxb = priv->rxq->queue[i];
#ifdef CONFIG_IPW_DEBUG
		if (unlikely(rxb == NULL)) {
			printk(KERN_CRIT "Queue not allocated!\n");
			break;
		}
#endif
		priv->rxq->queue[i] = NULL;

		pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
8299
					    IPW_RX_BUF_SIZE,
J
James Ketrenos 已提交
8300 8301 8302 8303 8304
					    PCI_DMA_FROMDEVICE);

		pkt = (struct ipw_rx_packet *)rxb->skb->data;
		IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
			     pkt->header.message_type,
8305
			     pkt->header.rx_seq_num, pkt->header.control_bits);
J
James Ketrenos 已提交
8306 8307

		switch (pkt->header.message_type) {
8308 8309
		case RX_FRAME_TYPE:	/* 802.11 frame */  {
				struct ieee80211_rx_stats stats = {
8310 8311
					.rssi =
					    le16_to_cpu(pkt->u.frame.rssi_dbm) -
8312
					    IPW_RSSI_TO_DBM,
8313 8314 8315 8316
					.signal =
					    le16_to_cpu(pkt->u.frame.signal),
					.noise =
					    le16_to_cpu(pkt->u.frame.noise),
8317 8318 8319 8320 8321 8322 8323 8324 8325
					.rate = pkt->u.frame.rate,
					.mac_time = jiffies,
					.received_channel =
					    pkt->u.frame.received_channel,
					.freq =
					    (pkt->u.frame.
					     control & (1 << 0)) ?
					    IEEE80211_24GHZ_BAND :
					    IEEE80211_52GHZ_BAND,
8326
					.len = le16_to_cpu(pkt->u.frame.length),
8327 8328 8329 8330 8331 8332
				};

				if (stats.rssi != 0)
					stats.mask |= IEEE80211_STATMASK_RSSI;
				if (stats.signal != 0)
					stats.mask |= IEEE80211_STATMASK_SIGNAL;
8333 8334
				if (stats.noise != 0)
					stats.mask |= IEEE80211_STATMASK_NOISE;
8335 8336 8337 8338
				if (stats.rate != 0)
					stats.mask |= IEEE80211_STATMASK_RATE;

				priv->rx_packets++;
J
James Ketrenos 已提交
8339

8340
#ifdef CONFIG_IPW2200_MONITOR
8341
				if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8342 8343 8344 8345 8346
#ifdef CONFIG_IEEE80211_RADIOTAP
					ipw_handle_data_packet_monitor(priv,
								       rxb,
								       &stats);
#else
8347 8348
					ipw_handle_data_packet(priv, rxb,
							       &stats);
8349
#endif
8350 8351
					break;
				}
J
James Ketrenos 已提交
8352
#endif
8353

8354
				header =
8355 8356 8357
				    (struct ieee80211_hdr_4addr *)(rxb->skb->
								   data +
								   IPW_RX_FRAME_SIZE);
J
James Ketrenos 已提交
8358 8359
				/* TODO: Check Ad-Hoc dest/source and make sure
				 * that we are actually parsing these packets
8360
				 * correctly -- we should probably use the
J
James Ketrenos 已提交
8361 8362
				 * frame control of the packet and disregard
				 * the current iw_mode */
8363

8364 8365
				network_packet =
				    is_network_packet(priv, header);
8366 8367 8368 8369 8370 8371 8372 8373 8374
				if (network_packet && priv->assoc_network) {
					priv->assoc_network->stats.rssi =
					    stats.rssi;
					average_add(&priv->average_rssi,
						    stats.rssi);
					priv->last_rx_rssi = stats.rssi;
				}

				IPW_DEBUG_RX("Frame: len=%u\n",
8375
					     le16_to_cpu(pkt->u.frame.length));
8376

8377 8378
				if (le16_to_cpu(pkt->u.frame.length) <
				    frame_hdr_len(header)) {
8379 8380 8381 8382 8383 8384 8385 8386
					IPW_DEBUG_DROP
					    ("Received packet is too small. "
					     "Dropping.\n");
					priv->ieee->stats.rx_errors++;
					priv->wstats.discard.misc++;
					break;
				}

8387 8388
				switch (WLAN_FC_GET_TYPE
					(le16_to_cpu(header->frame_ctl))) {
8389

8390
				case IEEE80211_FTYPE_MGMT:
8391 8392
					ipw_handle_mgmt_packet(priv, rxb,
							       &stats);
8393 8394 8395 8396 8397 8398
					break;

				case IEEE80211_FTYPE_CTL:
					break;

				case IEEE80211_FTYPE_DATA:
8399 8400 8401 8402
					if (unlikely(!network_packet ||
						     is_duplicate_packet(priv,
									 header)))
					{
8403 8404 8405 8406 8407 8408 8409 8410 8411 8412
						IPW_DEBUG_DROP("Dropping: "
							       MAC_FMT ", "
							       MAC_FMT ", "
							       MAC_FMT "\n",
							       MAC_ARG(header->
								       addr1),
							       MAC_ARG(header->
								       addr2),
							       MAC_ARG(header->
								       addr3));
8413 8414 8415 8416 8417 8418
						break;
					}

					ipw_handle_data_packet(priv, rxb,
							       &stats);

8419 8420
					break;
				}
J
James Ketrenos 已提交
8421 8422
				break;
			}
8423

8424 8425 8426
		case RX_HOST_NOTIFICATION_TYPE:{
				IPW_DEBUG_RX
				    ("Notification: subtype=%02X flags=%02X size=%d\n",
J
James Ketrenos 已提交
8427 8428 8429
				     pkt->u.notification.subtype,
				     pkt->u.notification.flags,
				     pkt->u.notification.size);
8430 8431 8432
				ipw_rx_notification(priv, &pkt->u.notification);
				break;
			}
J
James Ketrenos 已提交
8433 8434 8435 8436 8437 8438

		default:
			IPW_DEBUG_RX("Bad Rx packet of type %d\n",
				     pkt->header.message_type);
			break;
		}
8439 8440 8441

		/* For now we just don't re-use anything.  We can tweak this
		 * later to try and re-use notification packets and SKBs that
J
James Ketrenos 已提交
8442 8443 8444 8445 8446
		 * fail to Rx correctly */
		if (rxb->skb != NULL) {
			dev_kfree_skb_any(rxb->skb);
			rxb->skb = NULL;
		}
8447

J
James Ketrenos 已提交
8448
		pci_unmap_single(priv->pci_dev, rxb->dma_addr,
8449
				 IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
J
James Ketrenos 已提交
8450
		list_add_tail(&rxb->list, &priv->rxq->rx_used);
8451

J
James Ketrenos 已提交
8452 8453 8454 8455 8456 8457
		i = (i + 1) % RX_QUEUE_SIZE;
	}

	/* Backtrack one entry */
	priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;

8458 8459 8460 8461 8462 8463 8464 8465 8466 8467 8468 8469 8470 8471 8472 8473 8474 8475 8476 8477 8478 8479 8480 8481 8482 8483 8484 8485 8486 8487 8488 8489 8490 8491 8492 8493 8494 8495 8496 8497 8498 8499 8500 8501 8502 8503 8504 8505 8506 8507 8508 8509 8510 8511 8512 8513 8514 8515
	ipw_rx_queue_restock(priv);
}

#define DEFAULT_RTS_THRESHOLD     2304U
#define MIN_RTS_THRESHOLD         1U
#define MAX_RTS_THRESHOLD         2304U
#define DEFAULT_BEACON_INTERVAL   100U
#define	DEFAULT_SHORT_RETRY_LIMIT 7U
#define	DEFAULT_LONG_RETRY_LIMIT  4U

static int ipw_sw_reset(struct ipw_priv *priv, int init)
{
	int band, modulation;
	int old_mode = priv->ieee->iw_mode;

	/* Initialize module parameter values here */
	priv->config = 0;

	/* We default to disabling the LED code as right now it causes
	 * too many systems to lock up... */
	if (!led)
		priv->config |= CFG_NO_LED;

	if (associate)
		priv->config |= CFG_ASSOCIATE;
	else
		IPW_DEBUG_INFO("Auto associate disabled.\n");

	if (auto_create)
		priv->config |= CFG_ADHOC_CREATE;
	else
		IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");

	if (disable) {
		priv->status |= STATUS_RF_KILL_SW;
		IPW_DEBUG_INFO("Radio disabled.\n");
	}

	if (channel != 0) {
		priv->config |= CFG_STATIC_CHANNEL;
		priv->channel = channel;
		IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
		/* TODO: Validate that provided channel is in range */
	}
#ifdef CONFIG_IPW_QOS
	ipw_qos_init(priv, qos_enable, qos_burst_enable,
		     burst_duration_CCK, burst_duration_OFDM);
#endif				/* CONFIG_IPW_QOS */

	switch (mode) {
	case 1:
		priv->ieee->iw_mode = IW_MODE_ADHOC;
		priv->net_dev->type = ARPHRD_ETHER;

		break;
#ifdef CONFIG_IPW2200_MONITOR
	case 2:
		priv->ieee->iw_mode = IW_MODE_MONITOR;
8516 8517 8518
#ifdef CONFIG_IEEE80211_RADIOTAP
		priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
#else
8519
		priv->net_dev->type = ARPHRD_IEEE80211;
8520
#endif
8521 8522 8523 8524 8525 8526 8527 8528 8529 8530 8531 8532 8533
		break;
#endif
	default:
	case 0:
		priv->net_dev->type = ARPHRD_ETHER;
		priv->ieee->iw_mode = IW_MODE_INFRA;
		break;
	}

	if (hwcrypto) {
		priv->ieee->host_encrypt = 0;
		priv->ieee->host_encrypt_msdu = 0;
		priv->ieee->host_decrypt = 0;
H
Hong Liu 已提交
8534
		priv->ieee->host_mc_decrypt = 0;
8535 8536 8537
	}
	IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");

8538 8539 8540
	/* IPW2200/2915 is abled to do hardware fragmentation. */
	priv->ieee->host_open_frag = 0;

8541 8542 8543 8544 8545 8546 8547 8548 8549 8550 8551 8552 8553 8554 8555 8556 8557 8558 8559 8560 8561 8562 8563 8564 8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580 8581 8582
	if ((priv->pci_dev->device == 0x4223) ||
	    (priv->pci_dev->device == 0x4224)) {
		if (init)
			printk(KERN_INFO DRV_NAME
			       ": Detected Intel PRO/Wireless 2915ABG Network "
			       "Connection\n");
		priv->ieee->abg_true = 1;
		band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
		modulation = IEEE80211_OFDM_MODULATION |
		    IEEE80211_CCK_MODULATION;
		priv->adapter = IPW_2915ABG;
		priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
	} else {
		if (init)
			printk(KERN_INFO DRV_NAME
			       ": Detected Intel PRO/Wireless 2200BG Network "
			       "Connection\n");

		priv->ieee->abg_true = 0;
		band = IEEE80211_24GHZ_BAND;
		modulation = IEEE80211_OFDM_MODULATION |
		    IEEE80211_CCK_MODULATION;
		priv->adapter = IPW_2200BG;
		priv->ieee->mode = IEEE_G | IEEE_B;
	}

	priv->ieee->freq_band = band;
	priv->ieee->modulation = modulation;

	priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;

	priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
	priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;

	priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
	priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
	priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;

	/* If power management is turned on, default to AC mode */
	priv->power_mode = IPW_POWER_AC;
	priv->tx_power = IPW_TX_POWER_DEFAULT;

8583
	return old_mode == priv->ieee->iw_mode;
J
James Ketrenos 已提交
8584 8585 8586 8587 8588 8589
}

/*
 * This file defines the Wireless Extension handlers.  It does not
 * define any methods of hardware manipulation and relies on the
 * functions defined in ipw_main to provide the HW interaction.
8590 8591
 *
 * The exception to this is the use of the ipw_get_ordinal()
J
James Ketrenos 已提交
8592 8593 8594 8595
 * function used to poll the hardware vs. making unecessary calls.
 *
 */

8596 8597
static int ipw_wx_get_name(struct net_device *dev,
			   struct iw_request_info *info,
J
James Ketrenos 已提交
8598 8599 8600
			   union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
8601 8602
	down(&priv->sem);
	if (priv->status & STATUS_RF_KILL_MASK)
8603
		strcpy(wrqu->name, "radio off");
8604
	else if (!(priv->status & STATUS_ASSOCIATED))
J
James Ketrenos 已提交
8605
		strcpy(wrqu->name, "unassociated");
8606
	else
J
James Ketrenos 已提交
8607 8608 8609
		snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
			 ipw_modes[priv->assoc_request.ieee_mode]);
	IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8610
	up(&priv->sem);
J
James Ketrenos 已提交
8611 8612 8613 8614 8615 8616 8617 8618
	return 0;
}

static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
{
	if (channel == 0) {
		IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
		priv->config &= ~CFG_STATIC_CHANNEL;
8619 8620 8621
		IPW_DEBUG_ASSOC("Attempting to associate with new "
				"parameters.\n");
		ipw_associate(priv);
J
James Ketrenos 已提交
8622 8623 8624 8625 8626 8627
		return 0;
	}

	priv->config |= CFG_STATIC_CHANNEL;

	if (priv->channel == channel) {
8628 8629
		IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
			       channel);
J
James Ketrenos 已提交
8630 8631 8632 8633 8634 8635
		return 0;
	}

	IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
	priv->channel = channel;

8636 8637
#ifdef CONFIG_IPW2200_MONITOR
	if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8638
		int i;
8639
		if (priv->status & STATUS_SCANNING) {
8640
			IPW_DEBUG_SCAN("Scan abort triggered due to "
8641
				       "channel change.\n");
8642
			ipw_abort_scan(priv);
8643 8644 8645 8646 8647 8648 8649 8650 8651 8652 8653 8654 8655 8656 8657
		}

		for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
			udelay(10);

		if (priv->status & STATUS_SCANNING)
			IPW_DEBUG_SCAN("Still scanning...\n");
		else
			IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
				       1000 - i);

		return 0;
	}
#endif				/* CONFIG_IPW2200_MONITOR */

8658 8659 8660
	/* Network configuration changed -- force [re]association */
	IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
	if (!ipw_disassociate(priv))
J
James Ketrenos 已提交
8661 8662 8663 8664 8665
		ipw_associate(priv);

	return 0;
}

8666 8667 8668
static int ipw_wx_set_freq(struct net_device *dev,
			   struct iw_request_info *info,
			   union iwreq_data *wrqu, char *extra)
J
James Ketrenos 已提交
8669 8670
{
	struct ipw_priv *priv = ieee80211_priv(dev);
8671
	const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
J
James Ketrenos 已提交
8672
	struct iw_freq *fwrq = &wrqu->freq;
8673
	int ret = 0, i;
8674 8675
	u8 channel, flags;
	int band;
8676 8677 8678 8679 8680 8681 8682 8683

	if (fwrq->m == 0) {
		IPW_DEBUG_WX("SET Freq/Channel -> any\n");
		down(&priv->sem);
		ret = ipw_set_channel(priv, 0);
		up(&priv->sem);
		return ret;
	}
J
James Ketrenos 已提交
8684 8685
	/* if setting by freq convert to channel */
	if (fwrq->e == 1) {
8686
		channel = ipw_freq_to_channel(priv->ieee, fwrq->m);
8687 8688 8689 8690
		if (channel == 0)
			return -EINVAL;
	} else
		channel = fwrq->m;
8691

8692
	if (!(band = ipw_is_valid_channel(priv->ieee, channel)))
8693
		return -EINVAL;
J
James Ketrenos 已提交
8694

8695 8696
	if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
		i = ipw_channel_to_index(priv->ieee, channel);
8697 8698
		if (i == -1)
			return -EINVAL;
8699 8700 8701 8702

		flags = (band == IEEE80211_24GHZ_BAND) ?
		    geo->bg[i].flags : geo->a[i].flags;
		if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8703 8704 8705 8706 8707
			IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
			return -EINVAL;
		}
	}

J
James Ketrenos 已提交
8708
	IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
8709
	down(&priv->sem);
8710
	ret = ipw_set_channel(priv, channel);
8711 8712
	up(&priv->sem);
	return ret;
J
James Ketrenos 已提交
8713 8714
}

8715 8716
static int ipw_wx_get_freq(struct net_device *dev,
			   struct iw_request_info *info,
J
James Ketrenos 已提交
8717 8718 8719 8720 8721 8722 8723 8724
			   union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);

	wrqu->freq.e = 0;

	/* If we are associated, trying to associate, or have a statically
	 * configured CHANNEL then return that; otherwise return ANY */
8725
	down(&priv->sem);
J
James Ketrenos 已提交
8726 8727 8728
	if (priv->config & CFG_STATIC_CHANNEL ||
	    priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
		wrqu->freq.m = priv->channel;
8729
	else
J
James Ketrenos 已提交
8730 8731
		wrqu->freq.m = 0;

8732
	up(&priv->sem);
J
James Ketrenos 已提交
8733 8734 8735 8736
	IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
	return 0;
}

8737 8738
static int ipw_wx_set_mode(struct net_device *dev,
			   struct iw_request_info *info,
J
James Ketrenos 已提交
8739 8740 8741 8742 8743 8744 8745 8746
			   union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	int err = 0;

	IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);

	switch (wrqu->mode) {
8747
#ifdef CONFIG_IPW2200_MONITOR
J
James Ketrenos 已提交
8748 8749 8750 8751 8752 8753 8754 8755 8756 8757 8758
	case IW_MODE_MONITOR:
#endif
	case IW_MODE_ADHOC:
	case IW_MODE_INFRA:
		break;
	case IW_MODE_AUTO:
		wrqu->mode = IW_MODE_INFRA;
		break;
	default:
		return -EINVAL;
	}
8759 8760
	if (wrqu->mode == priv->ieee->iw_mode)
		return 0;
J
James Ketrenos 已提交
8761

8762
	down(&priv->sem);
8763 8764 8765

	ipw_sw_reset(priv, 0);

8766
#ifdef CONFIG_IPW2200_MONITOR
8767
	if (priv->ieee->iw_mode == IW_MODE_MONITOR)
J
James Ketrenos 已提交
8768
		priv->net_dev->type = ARPHRD_ETHER;
8769 8770

	if (wrqu->mode == IW_MODE_MONITOR)
8771 8772 8773
#ifdef CONFIG_IEEE80211_RADIOTAP
		priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
#else
J
James Ketrenos 已提交
8774
		priv->net_dev->type = ARPHRD_IEEE80211;
8775
#endif
8776
#endif				/* CONFIG_IPW2200_MONITOR */
8777 8778

	/* Free the existing firmware and reset the fw_loaded
J
James Ketrenos 已提交
8779
	 * flag so ipw_load() will bring in the new firmawre */
8780
	free_firmware();
J
James Ketrenos 已提交
8781 8782

	priv->ieee->iw_mode = wrqu->mode;
8783

8784 8785
	queue_work(priv->workqueue, &priv->adapter_restart);
	up(&priv->sem);
8786
	return err;
J
James Ketrenos 已提交
8787 8788
}

8789
static int ipw_wx_get_mode(struct net_device *dev,
8790 8791
			   struct iw_request_info *info,
			   union iwreq_data *wrqu, char *extra)
J
James Ketrenos 已提交
8792 8793
{
	struct ipw_priv *priv = ieee80211_priv(dev);
8794
	down(&priv->sem);
J
James Ketrenos 已提交
8795 8796
	wrqu->mode = priv->ieee->iw_mode;
	IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8797
	up(&priv->sem);
J
James Ketrenos 已提交
8798 8799 8800 8801 8802 8803 8804 8805 8806 8807 8808 8809 8810 8811 8812 8813 8814 8815 8816 8817
	return 0;
}

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

static const s32 period_duration[] = {
	400000,
	700000,
	1000000,
	1000000,
	1000000
};

8818 8819
static int ipw_wx_get_range(struct net_device *dev,
			    struct iw_request_info *info,
J
James Ketrenos 已提交
8820 8821 8822 8823
			    union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	struct iw_range *range = (struct iw_range *)extra;
8824
	const struct ieee80211_geo *geo = ipw_get_geo(priv->ieee);
8825
	int i = 0, j;
J
James Ketrenos 已提交
8826 8827 8828 8829 8830

	wrqu->data.length = sizeof(*range);
	memset(range, 0, sizeof(*range));

	/* 54Mbs == ~27 Mb/s real (802.11g) */
8831
	range->throughput = 27 * 1000 * 1000;
J
James Ketrenos 已提交
8832 8833 8834 8835

	range->max_qual.qual = 100;
	/* TODO: Find real max RSSI and stick here */
	range->max_qual.level = 0;
8836
	range->max_qual.noise = priv->ieee->worst_rssi + 0x100;
8837
	range->max_qual.updated = 7;	/* Updated all three */
J
James Ketrenos 已提交
8838 8839 8840

	range->avg_qual.qual = 70;
	/* TODO: Find real 'good' to 'bad' threshol value for RSSI */
8841
	range->avg_qual.level = 0;	/* FIXME to real average level */
J
James Ketrenos 已提交
8842
	range->avg_qual.noise = 0;
8843
	range->avg_qual.updated = 7;	/* Updated all three */
8844
	down(&priv->sem);
8845
	range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
J
James Ketrenos 已提交
8846

8847 8848
	for (i = 0; i < range->num_bitrates; i++)
		range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8849
		    500000;
8850

J
James Ketrenos 已提交
8851 8852 8853 8854 8855
	range->max_rts = DEFAULT_RTS_THRESHOLD;
	range->min_frag = MIN_FRAG_THRESHOLD;
	range->max_frag = MAX_FRAG_THRESHOLD;

	range->encoding_size[0] = 5;
8856
	range->encoding_size[1] = 13;
J
James Ketrenos 已提交
8857 8858 8859 8860 8861 8862 8863
	range->num_encoding_sizes = 2;
	range->max_encoding_tokens = WEP_KEYS;

	/* Set the Wireless Extension versions */
	range->we_version_compiled = WIRELESS_EXT;
	range->we_version_source = 16;

8864 8865 8866 8867 8868 8869 8870 8871 8872
	i = 0;
	if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
		for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES;
		     i++, j++) {
			range->freq[i].i = geo->bg[j].channel;
			range->freq[i].m = geo->bg[j].freq * 100000;
			range->freq[i].e = 1;
		}
	}
J
James Ketrenos 已提交
8873

8874 8875 8876 8877 8878 8879 8880
	if (priv->ieee->mode & IEEE_A) {
		for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES;
		     i++, j++) {
			range->freq[i].i = geo->a[j].channel;
			range->freq[i].m = geo->a[j].freq * 100000;
			range->freq[i].e = 1;
		}
J
James Ketrenos 已提交
8881
	}
8882 8883 8884 8885

	range->num_channels = i;
	range->num_frequency = i;

8886
	up(&priv->sem);
J
James Ketrenos 已提交
8887 8888 8889 8890
	IPW_DEBUG_WX("GET Range\n");
	return 0;
}

8891 8892
static int ipw_wx_set_wap(struct net_device *dev,
			  struct iw_request_info *info,
J
James Ketrenos 已提交
8893 8894 8895 8896 8897 8898 8899 8900 8901 8902 8903
			  union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);

	static const unsigned char any[] = {
		0xff, 0xff, 0xff, 0xff, 0xff, 0xff
	};
	static const unsigned char off[] = {
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	};

8904
	if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
J
James Ketrenos 已提交
8905
		return -EINVAL;
8906
	down(&priv->sem);
J
James Ketrenos 已提交
8907 8908 8909 8910 8911
	if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
	    !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
		/* we disable mandatory BSSID association */
		IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
		priv->config &= ~CFG_STATIC_BSSID;
8912 8913 8914 8915
		IPW_DEBUG_ASSOC("Attempting to associate with new "
				"parameters.\n");
		ipw_associate(priv);
		up(&priv->sem);
J
James Ketrenos 已提交
8916 8917 8918 8919 8920 8921
		return 0;
	}

	priv->config |= CFG_STATIC_BSSID;
	if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
		IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8922
		up(&priv->sem);
J
James Ketrenos 已提交
8923 8924 8925 8926 8927 8928 8929 8930
		return 0;
	}

	IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
		     MAC_ARG(wrqu->ap_addr.sa_data));

	memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);

8931 8932 8933
	/* Network configuration changed -- force [re]association */
	IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
	if (!ipw_disassociate(priv))
J
James Ketrenos 已提交
8934 8935
		ipw_associate(priv);

8936
	up(&priv->sem);
J
James Ketrenos 已提交
8937 8938 8939
	return 0;
}

8940 8941
static int ipw_wx_get_wap(struct net_device *dev,
			  struct iw_request_info *info,
J
James Ketrenos 已提交
8942 8943 8944 8945 8946
			  union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	/* If we are associated, trying to associate, or have a statically
	 * configured BSSID then return that; otherwise return ANY */
8947
	down(&priv->sem);
8948
	if (priv->config & CFG_STATIC_BSSID ||
J
James Ketrenos 已提交
8949 8950
	    priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
		wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8951
		memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
J
James Ketrenos 已提交
8952 8953 8954 8955 8956
	} else
		memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);

	IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
		     MAC_ARG(wrqu->ap_addr.sa_data));
8957
	up(&priv->sem);
J
James Ketrenos 已提交
8958 8959 8960
	return 0;
}

8961 8962
static int ipw_wx_set_essid(struct net_device *dev,
			    struct iw_request_info *info,
J
James Ketrenos 已提交
8963 8964 8965
			    union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
8966
	char *essid = "";	/* ANY */
J
James Ketrenos 已提交
8967
	int length = 0;
8968
	down(&priv->sem);
J
James Ketrenos 已提交
8969 8970 8971 8972 8973 8974
	if (wrqu->essid.flags && wrqu->essid.length) {
		length = wrqu->essid.length - 1;
		essid = extra;
	}
	if (length == 0) {
		IPW_DEBUG_WX("Setting ESSID to ANY\n");
8975 8976 8977
		if ((priv->config & CFG_STATIC_ESSID) &&
		    !(priv->status & (STATUS_ASSOCIATED |
				      STATUS_ASSOCIATING))) {
J
James Ketrenos 已提交
8978 8979
			IPW_DEBUG_ASSOC("Attempting to associate with new "
					"parameters.\n");
8980
			priv->config &= ~CFG_STATIC_ESSID;
J
James Ketrenos 已提交
8981 8982
			ipw_associate(priv);
		}
8983
		up(&priv->sem);
J
James Ketrenos 已提交
8984 8985 8986 8987 8988 8989 8990 8991 8992
		return 0;
	}

	length = min(length, IW_ESSID_MAX_SIZE);

	priv->config |= CFG_STATIC_ESSID;

	if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
		IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8993
		up(&priv->sem);
J
James Ketrenos 已提交
8994 8995 8996 8997 8998 8999 9000 9001
		return 0;
	}

	IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
		     length);

	priv->essid_len = length;
	memcpy(priv->essid, essid, priv->essid_len);
9002

9003 9004 9005
	/* Network configuration changed -- force [re]association */
	IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
	if (!ipw_disassociate(priv))
J
James Ketrenos 已提交
9006 9007
		ipw_associate(priv);

9008
	up(&priv->sem);
J
James Ketrenos 已提交
9009 9010 9011
	return 0;
}

9012 9013
static int ipw_wx_get_essid(struct net_device *dev,
			    struct iw_request_info *info,
J
James Ketrenos 已提交
9014 9015 9016 9017 9018 9019
			    union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);

	/* If we are associated, trying to associate, or have a statically
	 * configured ESSID then return that; otherwise return ANY */
9020
	down(&priv->sem);
J
James Ketrenos 已提交
9021
	if (priv->config & CFG_STATIC_ESSID ||
9022 9023
	    priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
		IPW_DEBUG_WX("Getting essid: '%s'\n",
J
James Ketrenos 已提交
9024
			     escape_essid(priv->essid, priv->essid_len));
9025
		memcpy(extra, priv->essid, priv->essid_len);
J
James Ketrenos 已提交
9026
		wrqu->essid.length = priv->essid_len;
9027
		wrqu->essid.flags = 1;	/* active */
J
James Ketrenos 已提交
9028 9029 9030
	} else {
		IPW_DEBUG_WX("Getting essid: ANY\n");
		wrqu->essid.length = 0;
9031
		wrqu->essid.flags = 0;	/* active */
J
James Ketrenos 已提交
9032
	}
9033
	up(&priv->sem);
J
James Ketrenos 已提交
9034 9035 9036
	return 0;
}

9037 9038
static int ipw_wx_set_nick(struct net_device *dev,
			   struct iw_request_info *info,
J
James Ketrenos 已提交
9039
			   union iwreq_data *wrqu, char *extra)
9040
{
J
James Ketrenos 已提交
9041 9042 9043 9044 9045
	struct ipw_priv *priv = ieee80211_priv(dev);

	IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
	if (wrqu->data.length > IW_ESSID_MAX_SIZE)
		return -E2BIG;
9046
	down(&priv->sem);
9047
	wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
J
James Ketrenos 已提交
9048
	memset(priv->nick, 0, sizeof(priv->nick));
9049
	memcpy(priv->nick, extra, wrqu->data.length);
J
James Ketrenos 已提交
9050
	IPW_DEBUG_TRACE("<<\n");
9051
	up(&priv->sem);
J
James Ketrenos 已提交
9052 9053 9054 9055
	return 0;

}

9056 9057
static int ipw_wx_get_nick(struct net_device *dev,
			   struct iw_request_info *info,
J
James Ketrenos 已提交
9058
			   union iwreq_data *wrqu, char *extra)
9059
{
J
James Ketrenos 已提交
9060 9061
	struct ipw_priv *priv = ieee80211_priv(dev);
	IPW_DEBUG_WX("Getting nick\n");
9062
	down(&priv->sem);
J
James Ketrenos 已提交
9063 9064
	wrqu->data.length = strlen(priv->nick) + 1;
	memcpy(extra, priv->nick, wrqu->data.length);
9065
	wrqu->data.flags = 1;	/* active */
9066
	up(&priv->sem);
J
James Ketrenos 已提交
9067 9068 9069 9070 9071 9072
	return 0;
}

static int ipw_wx_set_rate(struct net_device *dev,
			   struct iw_request_info *info,
			   union iwreq_data *wrqu, char *extra)
9073
{
9074 9075 9076 9077 9078 9079 9080 9081 9082 9083 9084 9085 9086 9087 9088 9089 9090 9091 9092 9093 9094 9095 9096 9097 9098 9099 9100 9101 9102 9103 9104 9105 9106 9107 9108 9109 9110 9111 9112 9113 9114 9115 9116 9117 9118 9119 9120 9121 9122 9123 9124 9125 9126 9127 9128 9129 9130 9131 9132 9133 9134 9135 9136 9137 9138 9139 9140 9141 9142 9143 9144 9145 9146 9147 9148 9149 9150 9151 9152 9153 9154 9155 9156 9157 9158
	/* TODO: We should use semaphores or locks for access to priv */
	struct ipw_priv *priv = ieee80211_priv(dev);
	u32 target_rate = wrqu->bitrate.value;
	u32 fixed, mask;

	/* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
	/* value = X, fixed = 1 means only rate X */
	/* value = X, fixed = 0 means all rates lower equal X */

	if (target_rate == -1) {
		fixed = 0;
		mask = IEEE80211_DEFAULT_RATES_MASK;
		/* Now we should reassociate */
		goto apply;
	}

	mask = 0;
	fixed = wrqu->bitrate.fixed;

	if (target_rate == 1000000 || !fixed)
		mask |= IEEE80211_CCK_RATE_1MB_MASK;
	if (target_rate == 1000000)
		goto apply;

	if (target_rate == 2000000 || !fixed)
		mask |= IEEE80211_CCK_RATE_2MB_MASK;
	if (target_rate == 2000000)
		goto apply;

	if (target_rate == 5500000 || !fixed)
		mask |= IEEE80211_CCK_RATE_5MB_MASK;
	if (target_rate == 5500000)
		goto apply;

	if (target_rate == 6000000 || !fixed)
		mask |= IEEE80211_OFDM_RATE_6MB_MASK;
	if (target_rate == 6000000)
		goto apply;

	if (target_rate == 9000000 || !fixed)
		mask |= IEEE80211_OFDM_RATE_9MB_MASK;
	if (target_rate == 9000000)
		goto apply;

	if (target_rate == 11000000 || !fixed)
		mask |= IEEE80211_CCK_RATE_11MB_MASK;
	if (target_rate == 11000000)
		goto apply;

	if (target_rate == 12000000 || !fixed)
		mask |= IEEE80211_OFDM_RATE_12MB_MASK;
	if (target_rate == 12000000)
		goto apply;

	if (target_rate == 18000000 || !fixed)
		mask |= IEEE80211_OFDM_RATE_18MB_MASK;
	if (target_rate == 18000000)
		goto apply;

	if (target_rate == 24000000 || !fixed)
		mask |= IEEE80211_OFDM_RATE_24MB_MASK;
	if (target_rate == 24000000)
		goto apply;

	if (target_rate == 36000000 || !fixed)
		mask |= IEEE80211_OFDM_RATE_36MB_MASK;
	if (target_rate == 36000000)
		goto apply;

	if (target_rate == 48000000 || !fixed)
		mask |= IEEE80211_OFDM_RATE_48MB_MASK;
	if (target_rate == 48000000)
		goto apply;

	if (target_rate == 54000000 || !fixed)
		mask |= IEEE80211_OFDM_RATE_54MB_MASK;
	if (target_rate == 54000000)
		goto apply;

	IPW_DEBUG_WX("invalid rate specified, returning error\n");
	return -EINVAL;

      apply:
	IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
		     mask, fixed ? "fixed" : "sub-rates");
9159
	down(&priv->sem);
9160
	if (mask == IEEE80211_DEFAULT_RATES_MASK) {
9161
		priv->config &= ~CFG_FIXED_RATE;
9162 9163
		ipw_set_fixed_rate(priv, priv->ieee->mode);
	} else
9164 9165
		priv->config |= CFG_FIXED_RATE;

9166 9167 9168 9169
	if (priv->rates_mask == mask) {
		IPW_DEBUG_WX("Mask set to current mask.\n");
		up(&priv->sem);
		return 0;
9170 9171
	}

9172 9173 9174 9175 9176 9177 9178 9179
	priv->rates_mask = mask;

	/* Network configuration changed -- force [re]association */
	IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
	if (!ipw_disassociate(priv))
		ipw_associate(priv);

	up(&priv->sem);
9180
	return 0;
J
James Ketrenos 已提交
9181 9182
}

9183 9184
static int ipw_wx_get_rate(struct net_device *dev,
			   struct iw_request_info *info,
J
James Ketrenos 已提交
9185
			   union iwreq_data *wrqu, char *extra)
9186
{
9187
	struct ipw_priv *priv = ieee80211_priv(dev);
9188
	down(&priv->sem);
J
James Ketrenos 已提交
9189
	wrqu->bitrate.value = priv->last_rate;
9190
	up(&priv->sem);
J
James Ketrenos 已提交
9191 9192 9193 9194
	IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
	return 0;
}

9195 9196
static int ipw_wx_set_rts(struct net_device *dev,
			  struct iw_request_info *info,
J
James Ketrenos 已提交
9197
			  union iwreq_data *wrqu, char *extra)
9198
{
J
James Ketrenos 已提交
9199
	struct ipw_priv *priv = ieee80211_priv(dev);
9200
	down(&priv->sem);
J
James Ketrenos 已提交
9201 9202 9203 9204
	if (wrqu->rts.disabled)
		priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
	else {
		if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
9205 9206
		    wrqu->rts.value > MAX_RTS_THRESHOLD) {
			up(&priv->sem);
J
James Ketrenos 已提交
9207
			return -EINVAL;
9208
		}
J
James Ketrenos 已提交
9209 9210 9211 9212
		priv->rts_threshold = wrqu->rts.value;
	}

	ipw_send_rts_threshold(priv, priv->rts_threshold);
9213
	up(&priv->sem);
J
James Ketrenos 已提交
9214 9215 9216 9217
	IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
	return 0;
}

9218 9219
static int ipw_wx_get_rts(struct net_device *dev,
			  struct iw_request_info *info,
J
James Ketrenos 已提交
9220
			  union iwreq_data *wrqu, char *extra)
9221
{
J
James Ketrenos 已提交
9222
	struct ipw_priv *priv = ieee80211_priv(dev);
9223
	down(&priv->sem);
J
James Ketrenos 已提交
9224 9225
	wrqu->rts.value = priv->rts_threshold;
	wrqu->rts.fixed = 0;	/* no auto select */
9226
	wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
9227
	up(&priv->sem);
J
James Ketrenos 已提交
9228 9229 9230 9231
	IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
	return 0;
}

9232 9233
static int ipw_wx_set_txpow(struct net_device *dev,
			    struct iw_request_info *info,
J
James Ketrenos 已提交
9234
			    union iwreq_data *wrqu, char *extra)
9235
{
J
James Ketrenos 已提交
9236
	struct ipw_priv *priv = ieee80211_priv(dev);
Z
Zhu Yi 已提交
9237
	int err = 0;
9238

9239 9240
	down(&priv->sem);
	if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
Z
Zhu Yi 已提交
9241 9242
		err = -EINPROGRESS;
		goto out;
9243
	}
J
James Ketrenos 已提交
9244

9245 9246 9247
	if (!wrqu->power.fixed)
		wrqu->power.value = IPW_TX_POWER_DEFAULT;

9248
	if (wrqu->power.flags != IW_TXPOW_DBM) {
Z
Zhu Yi 已提交
9249 9250
		err = -EINVAL;
		goto out;
9251
	}
J
James Ketrenos 已提交
9252

9253
	if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
9254
	    (wrqu->power.value < IPW_TX_POWER_MIN)) {
Z
Zhu Yi 已提交
9255 9256
		err = -EINVAL;
		goto out;
9257
	}
J
James Ketrenos 已提交
9258 9259

	priv->tx_power = wrqu->power.value;
Z
Zhu Yi 已提交
9260 9261
	err = ipw_set_tx_power(priv);
      out:
9262
	up(&priv->sem);
Z
Zhu Yi 已提交
9263
	return err;
J
James Ketrenos 已提交
9264 9265
}

9266 9267
static int ipw_wx_get_txpow(struct net_device *dev,
			    struct iw_request_info *info,
J
James Ketrenos 已提交
9268
			    union iwreq_data *wrqu, char *extra)
9269
{
J
James Ketrenos 已提交
9270
	struct ipw_priv *priv = ieee80211_priv(dev);
9271
	down(&priv->sem);
J
James Ketrenos 已提交
9272 9273 9274 9275
	wrqu->power.value = priv->tx_power;
	wrqu->power.fixed = 1;
	wrqu->power.flags = IW_TXPOW_DBM;
	wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
9276
	up(&priv->sem);
J
James Ketrenos 已提交
9277

9278
	IPW_DEBUG_WX("GET TX Power -> %s %d \n",
9279
		     wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
J
James Ketrenos 已提交
9280 9281 9282 9283

	return 0;
}

9284
static int ipw_wx_set_frag(struct net_device *dev,
9285 9286
			   struct iw_request_info *info,
			   union iwreq_data *wrqu, char *extra)
J
James Ketrenos 已提交
9287 9288
{
	struct ipw_priv *priv = ieee80211_priv(dev);
9289
	down(&priv->sem);
J
James Ketrenos 已提交
9290 9291 9292 9293
	if (wrqu->frag.disabled)
		priv->ieee->fts = DEFAULT_FTS;
	else {
		if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
9294 9295
		    wrqu->frag.value > MAX_FRAG_THRESHOLD) {
			up(&priv->sem);
J
James Ketrenos 已提交
9296
			return -EINVAL;
9297
		}
9298

J
James Ketrenos 已提交
9299 9300 9301 9302
		priv->ieee->fts = wrqu->frag.value & ~0x1;
	}

	ipw_send_frag_threshold(priv, wrqu->frag.value);
9303
	up(&priv->sem);
J
James Ketrenos 已提交
9304 9305 9306 9307
	IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
	return 0;
}

9308
static int ipw_wx_get_frag(struct net_device *dev,
9309 9310
			   struct iw_request_info *info,
			   union iwreq_data *wrqu, char *extra)
J
James Ketrenos 已提交
9311 9312
{
	struct ipw_priv *priv = ieee80211_priv(dev);
9313
	down(&priv->sem);
J
James Ketrenos 已提交
9314 9315
	wrqu->frag.value = priv->ieee->fts;
	wrqu->frag.fixed = 0;	/* no auto select */
9316
	wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
9317
	up(&priv->sem);
J
James Ketrenos 已提交
9318 9319 9320 9321 9322
	IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);

	return 0;
}

9323 9324
static int ipw_wx_set_retry(struct net_device *dev,
			    struct iw_request_info *info,
J
James Ketrenos 已提交
9325
			    union iwreq_data *wrqu, char *extra)
9326
{
9327 9328 9329 9330 9331 9332 9333 9334 9335 9336 9337 9338 9339 9340 9341 9342 9343 9344 9345 9346 9347 9348 9349 9350 9351 9352 9353
	struct ipw_priv *priv = ieee80211_priv(dev);

	if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
		return -EINVAL;

	if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
		return 0;

	if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
		return -EINVAL;

	down(&priv->sem);
	if (wrqu->retry.flags & IW_RETRY_MIN)
		priv->short_retry_limit = (u8) wrqu->retry.value;
	else if (wrqu->retry.flags & IW_RETRY_MAX)
		priv->long_retry_limit = (u8) wrqu->retry.value;
	else {
		priv->short_retry_limit = (u8) wrqu->retry.value;
		priv->long_retry_limit = (u8) wrqu->retry.value;
	}

	ipw_send_retry_limit(priv, priv->short_retry_limit,
			     priv->long_retry_limit);
	up(&priv->sem);
	IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
		     priv->short_retry_limit, priv->long_retry_limit);
	return 0;
J
James Ketrenos 已提交
9354 9355
}

9356 9357
static int ipw_wx_get_retry(struct net_device *dev,
			    struct iw_request_info *info,
J
James Ketrenos 已提交
9358
			    union iwreq_data *wrqu, char *extra)
9359
{
9360 9361 9362 9363 9364 9365 9366 9367 9368 9369 9370 9371 9372 9373 9374 9375 9376 9377 9378 9379 9380 9381 9382 9383 9384 9385 9386 9387 9388 9389 9390 9391 9392 9393 9394 9395 9396 9397 9398 9399 9400 9401 9402 9403 9404 9405 9406 9407 9408 9409 9410 9411 9412 9413 9414 9415 9416 9417 9418 9419 9420 9421 9422 9423 9424
	struct ipw_priv *priv = ieee80211_priv(dev);

	down(&priv->sem);
	wrqu->retry.disabled = 0;

	if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
		up(&priv->sem);
		return -EINVAL;
	}

	if (wrqu->retry.flags & IW_RETRY_MAX) {
		wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
		wrqu->retry.value = priv->long_retry_limit;
	} else if (wrqu->retry.flags & IW_RETRY_MIN) {
		wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
		wrqu->retry.value = priv->short_retry_limit;
	} else {
		wrqu->retry.flags = IW_RETRY_LIMIT;
		wrqu->retry.value = priv->short_retry_limit;
	}
	up(&priv->sem);

	IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);

	return 0;
}

#if WIRELESS_EXT > 17
static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
				   int essid_len)
{
	struct ipw_scan_request_ext scan;
	int err = 0, scan_type;

	down(&priv->sem);

	if (priv->status & STATUS_RF_KILL_MASK) {
		IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
		priv->status |= STATUS_SCAN_PENDING;
		goto done;
	}

	IPW_DEBUG_HC("starting request direct scan!\n");

	if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
		err = wait_event_interruptible(priv->wait_state,
					       !(priv->
						 status & (STATUS_SCANNING |
							   STATUS_SCAN_ABORTING)));
		if (err) {
			IPW_DEBUG_HC("aborting direct scan");
			goto done;
		}
	}
	memset(&scan, 0, sizeof(scan));

	if (priv->config & CFG_SPEED_SCAN)
		scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
		    cpu_to_le16(30);
	else
		scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
		    cpu_to_le16(20);

	scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
	    cpu_to_le16(20);
9425
	scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
9426 9427 9428 9429 9430 9431 9432 9433 9434 9435 9436 9437 9438 9439 9440 9441 9442 9443 9444 9445 9446 9447 9448 9449
	scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);

	scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));

	err = ipw_send_ssid(priv, essid, essid_len);
	if (err) {
		IPW_DEBUG_HC("Attempt to send SSID command failed\n");
		goto done;
	}
	scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;

	ipw_add_scan_channels(priv, &scan, scan_type);

	err = ipw_send_scan_request_ext(priv, &scan);
	if (err) {
		IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
		goto done;
	}

	priv->status |= STATUS_SCANNING;

      done:
	up(&priv->sem);
	return err;
J
James Ketrenos 已提交
9450
}
9451
#endif				/* WIRELESS_EXT > 17 */
J
James Ketrenos 已提交
9452

9453 9454
static int ipw_wx_set_scan(struct net_device *dev,
			   struct iw_request_info *info,
J
James Ketrenos 已提交
9455 9456 9457
			   union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
9458 9459 9460 9461 9462 9463 9464 9465 9466 9467 9468 9469
#if WIRELESS_EXT > 17
	struct iw_scan_req *req = NULL;
	if (wrqu->data.length
	    && wrqu->data.length == sizeof(struct iw_scan_req)) {
		req = (struct iw_scan_req *)extra;
		if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
			ipw_request_direct_scan(priv, req->essid,
						req->essid_len);
			return 0;
		}
	}
#endif
J
James Ketrenos 已提交
9470
	IPW_DEBUG_WX("Start scan\n");
9471 9472 9473

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

J
James Ketrenos 已提交
9474 9475 9476
	return 0;
}

9477 9478
static int ipw_wx_get_scan(struct net_device *dev,
			   struct iw_request_info *info,
J
James Ketrenos 已提交
9479
			   union iwreq_data *wrqu, char *extra)
9480
{
J
James Ketrenos 已提交
9481 9482 9483 9484
	struct ipw_priv *priv = ieee80211_priv(dev);
	return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
}

9485
static int ipw_wx_set_encode(struct net_device *dev,
9486 9487
			     struct iw_request_info *info,
			     union iwreq_data *wrqu, char *key)
J
James Ketrenos 已提交
9488 9489
{
	struct ipw_priv *priv = ieee80211_priv(dev);
9490
	int ret;
9491
	u32 cap = priv->capability;
9492 9493 9494 9495

	down(&priv->sem);
	ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);

9496 9497 9498 9499 9500 9501 9502 9503
	/* In IBSS mode, we need to notify the firmware to update
	 * the beacon info after we changed the capability. */
	if (cap != priv->capability &&
	    priv->ieee->iw_mode == IW_MODE_ADHOC &&
	    priv->status & STATUS_ASSOCIATED)
		ipw_disassociate(priv);

	up(&priv->sem);
9504
	return ret;
J
James Ketrenos 已提交
9505 9506
}

9507
static int ipw_wx_get_encode(struct net_device *dev,
9508 9509
			     struct iw_request_info *info,
			     union iwreq_data *wrqu, char *key)
J
James Ketrenos 已提交
9510 9511 9512 9513 9514
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
}

9515
static int ipw_wx_set_power(struct net_device *dev,
9516 9517
			    struct iw_request_info *info,
			    union iwreq_data *wrqu, char *extra)
J
James Ketrenos 已提交
9518 9519 9520
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	int err;
9521
	down(&priv->sem);
J
James Ketrenos 已提交
9522 9523 9524 9525 9526
	if (wrqu->power.disabled) {
		priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
		err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
		if (err) {
			IPW_DEBUG_WX("failed setting power mode.\n");
9527
			up(&priv->sem);
J
James Ketrenos 已提交
9528 9529 9530
			return err;
		}
		IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9531
		up(&priv->sem);
J
James Ketrenos 已提交
9532
		return 0;
9533
	}
J
James Ketrenos 已提交
9534 9535

	switch (wrqu->power.flags & IW_POWER_MODE) {
9536 9537 9538
	case IW_POWER_ON:	/* If not specified */
	case IW_POWER_MODE:	/* If set all mask */
	case IW_POWER_ALL_R:	/* If explicitely state all */
J
James Ketrenos 已提交
9539
		break;
9540
	default:		/* Otherwise we don't support it */
J
James Ketrenos 已提交
9541 9542
		IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
			     wrqu->power.flags);
9543
		up(&priv->sem);
9544
		return -EOPNOTSUPP;
J
James Ketrenos 已提交
9545
	}
9546

J
James Ketrenos 已提交
9547 9548
	/* If the user hasn't specified a power management mode yet, default
	 * to BATTERY */
9549
	if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
J
James Ketrenos 已提交
9550
		priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9551
	else
J
James Ketrenos 已提交
9552 9553 9554 9555
		priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
	err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
	if (err) {
		IPW_DEBUG_WX("failed setting power mode.\n");
9556
		up(&priv->sem);
J
James Ketrenos 已提交
9557 9558 9559
		return err;
	}

9560
	IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9561
	up(&priv->sem);
J
James Ketrenos 已提交
9562 9563 9564
	return 0;
}

9565
static int ipw_wx_get_power(struct net_device *dev,
9566 9567
			    struct iw_request_info *info,
			    union iwreq_data *wrqu, char *extra)
J
James Ketrenos 已提交
9568 9569
{
	struct ipw_priv *priv = ieee80211_priv(dev);
9570
	down(&priv->sem);
9571
	if (!(priv->power_mode & IPW_POWER_ENABLED))
J
James Ketrenos 已提交
9572
		wrqu->power.disabled = 1;
9573
	else
J
James Ketrenos 已提交
9574 9575
		wrqu->power.disabled = 0;

9576
	up(&priv->sem);
J
James Ketrenos 已提交
9577
	IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9578

J
James Ketrenos 已提交
9579 9580 9581
	return 0;
}

9582
static int ipw_wx_set_powermode(struct net_device *dev,
9583 9584
				struct iw_request_info *info,
				union iwreq_data *wrqu, char *extra)
J
James Ketrenos 已提交
9585 9586 9587 9588
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	int mode = *(int *)extra;
	int err;
9589
	down(&priv->sem);
J
James Ketrenos 已提交
9590 9591 9592 9593 9594 9595
	if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
		mode = IPW_POWER_AC;
		priv->power_mode = mode;
	} else {
		priv->power_mode = IPW_POWER_ENABLED | mode;
	}
9596

J
James Ketrenos 已提交
9597 9598
	if (priv->power_mode != mode) {
		err = ipw_send_power_mode(priv, mode);
9599

J
James Ketrenos 已提交
9600 9601
		if (err) {
			IPW_DEBUG_WX("failed setting power mode.\n");
9602
			up(&priv->sem);
J
James Ketrenos 已提交
9603 9604 9605
			return err;
		}
	}
9606
	up(&priv->sem);
J
James Ketrenos 已提交
9607 9608 9609 9610
	return 0;
}

#define MAX_WX_STRING 80
9611
static int ipw_wx_get_powermode(struct net_device *dev,
9612 9613
				struct iw_request_info *info,
				union iwreq_data *wrqu, char *extra)
J
James Ketrenos 已提交
9614 9615 9616 9617 9618 9619 9620 9621 9622 9623 9624 9625 9626 9627 9628 9629
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	int level = IPW_POWER_LEVEL(priv->power_mode);
	char *p = extra;

	p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);

	switch (level) {
	case IPW_POWER_AC:
		p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
		break;
	case IPW_POWER_BATTERY:
		p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
		break;
	default:
		p += snprintf(p, MAX_WX_STRING - (p - extra),
9630
			      "(Timeout %dms, Period %dms)",
J
James Ketrenos 已提交
9631 9632 9633 9634 9635
			      timeout_duration[level - 1] / 1000,
			      period_duration[level - 1] / 1000);
	}

	if (!(priv->power_mode & IPW_POWER_ENABLED))
9636
		p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
J
James Ketrenos 已提交
9637 9638 9639 9640 9641 9642 9643

	wrqu->data.length = p - extra + 1;

	return 0;
}

static int ipw_wx_set_wireless_mode(struct net_device *dev,
9644 9645
				    struct iw_request_info *info,
				    union iwreq_data *wrqu, char *extra)
J
James Ketrenos 已提交
9646
{
9647
	struct ipw_priv *priv = ieee80211_priv(dev);
J
James Ketrenos 已提交
9648 9649 9650 9651
	int mode = *(int *)extra;
	u8 band = 0, modulation = 0;

	if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9652
		IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
J
James Ketrenos 已提交
9653 9654
		return -EINVAL;
	}
9655
	down(&priv->sem);
J
James Ketrenos 已提交
9656
	if (priv->adapter == IPW_2915ABG) {
9657
		priv->ieee->abg_true = 1;
J
James Ketrenos 已提交
9658 9659 9660 9661
		if (mode & IEEE_A) {
			band |= IEEE80211_52GHZ_BAND;
			modulation |= IEEE80211_OFDM_MODULATION;
		} else
9662
			priv->ieee->abg_true = 0;
J
James Ketrenos 已提交
9663 9664 9665 9666
	} else {
		if (mode & IEEE_A) {
			IPW_WARNING("Attempt to set 2200BG into "
				    "802.11a mode\n");
9667
			up(&priv->sem);
J
James Ketrenos 已提交
9668 9669 9670
			return -EINVAL;
		}

9671
		priv->ieee->abg_true = 0;
J
James Ketrenos 已提交
9672 9673 9674 9675 9676 9677
	}

	if (mode & IEEE_B) {
		band |= IEEE80211_24GHZ_BAND;
		modulation |= IEEE80211_CCK_MODULATION;
	} else
9678
		priv->ieee->abg_true = 0;
9679

J
James Ketrenos 已提交
9680 9681 9682 9683
	if (mode & IEEE_G) {
		band |= IEEE80211_24GHZ_BAND;
		modulation |= IEEE80211_OFDM_MODULATION;
	} else
9684
		priv->ieee->abg_true = 0;
J
James Ketrenos 已提交
9685 9686 9687 9688

	priv->ieee->mode = mode;
	priv->ieee->freq_band = band;
	priv->ieee->modulation = modulation;
9689
	init_supported_rates(priv, &priv->rates);
J
James Ketrenos 已提交
9690

9691 9692 9693
	/* Network configuration changed -- force [re]association */
	IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
	if (!ipw_disassociate(priv)) {
J
James Ketrenos 已提交
9694
		ipw_send_supported_rates(priv, &priv->rates);
9695 9696
		ipw_associate(priv);
	}
J
James Ketrenos 已提交
9697

9698 9699 9700
	/* Update the band LEDs */
	ipw_led_band_on(priv);

9701
	IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
J
James Ketrenos 已提交
9702
		     mode & IEEE_A ? 'a' : '.',
9703
		     mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9704
	up(&priv->sem);
J
James Ketrenos 已提交
9705 9706 9707 9708
	return 0;
}

static int ipw_wx_get_wireless_mode(struct net_device *dev,
9709 9710
				    struct iw_request_info *info,
				    union iwreq_data *wrqu, char *extra)
J
James Ketrenos 已提交
9711
{
9712
	struct ipw_priv *priv = ieee80211_priv(dev);
9713
	down(&priv->sem);
9714 9715
	switch (priv->ieee->mode) {
	case IEEE_A:
J
James Ketrenos 已提交
9716 9717
		strncpy(extra, "802.11a (1)", MAX_WX_STRING);
		break;
9718 9719 9720 9721 9722 9723 9724 9725 9726 9727 9728 9729 9730 9731 9732 9733 9734 9735 9736 9737
	case IEEE_B:
		strncpy(extra, "802.11b (2)", MAX_WX_STRING);
		break;
	case IEEE_A | IEEE_B:
		strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
		break;
	case IEEE_G:
		strncpy(extra, "802.11g (4)", MAX_WX_STRING);
		break;
	case IEEE_A | IEEE_G:
		strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
		break;
	case IEEE_B | IEEE_G:
		strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
		break;
	case IEEE_A | IEEE_B | IEEE_G:
		strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
		break;
	default:
		strncpy(extra, "unknown", MAX_WX_STRING);
J
James Ketrenos 已提交
9738
		break;
9739 9740
	}

9741 9742 9743 9744 9745 9746 9747 9748 9749 9750 9751 9752 9753 9754 9755 9756 9757 9758 9759 9760 9761 9762 9763 9764 9765 9766 9767 9768 9769 9770 9771 9772 9773 9774 9775 9776 9777 9778 9779 9780 9781 9782 9783 9784 9785 9786 9787 9788 9789 9790 9791 9792 9793 9794 9795 9796 9797 9798 9799 9800 9801 9802 9803 9804 9805 9806 9807
	IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);

	wrqu->data.length = strlen(extra) + 1;
	up(&priv->sem);

	return 0;
}

static int ipw_wx_set_preamble(struct net_device *dev,
			       struct iw_request_info *info,
			       union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	int mode = *(int *)extra;
	down(&priv->sem);
	/* Switching from SHORT -> LONG requires a disassociation */
	if (mode == 1) {
		if (!(priv->config & CFG_PREAMBLE_LONG)) {
			priv->config |= CFG_PREAMBLE_LONG;

			/* Network configuration changed -- force [re]association */
			IPW_DEBUG_ASSOC
			    ("[re]association triggered due to preamble change.\n");
			if (!ipw_disassociate(priv))
				ipw_associate(priv);
		}
		goto done;
	}

	if (mode == 0) {
		priv->config &= ~CFG_PREAMBLE_LONG;
		goto done;
	}
	up(&priv->sem);
	return -EINVAL;

      done:
	up(&priv->sem);
	return 0;
}

static int ipw_wx_get_preamble(struct net_device *dev,
			       struct iw_request_info *info,
			       union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	down(&priv->sem);
	if (priv->config & CFG_PREAMBLE_LONG)
		snprintf(wrqu->name, IFNAMSIZ, "long (1)");
	else
		snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
	up(&priv->sem);
	return 0;
}

#ifdef CONFIG_IPW2200_MONITOR
static int ipw_wx_set_monitor(struct net_device *dev,
			      struct iw_request_info *info,
			      union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	int *parms = (int *)extra;
	int enable = (parms[0] > 0);
	down(&priv->sem);
	IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
	if (enable) {
		if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9808 9809 9810
#ifdef CONFIG_IEEE80211_RADIOTAP
			priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
#else
9811
			priv->net_dev->type = ARPHRD_IEEE80211;
9812
#endif
9813 9814 9815 9816 9817 9818 9819 9820 9821 9822 9823 9824 9825 9826 9827 9828 9829 9830 9831 9832 9833 9834 9835 9836 9837 9838 9839 9840 9841 9842 9843
			queue_work(priv->workqueue, &priv->adapter_restart);
		}

		ipw_set_channel(priv, parms[1]);
	} else {
		if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
			up(&priv->sem);
			return 0;
		}
		priv->net_dev->type = ARPHRD_ETHER;
		queue_work(priv->workqueue, &priv->adapter_restart);
	}
	up(&priv->sem);
	return 0;
}

#endif				// CONFIG_IPW2200_MONITOR

static int ipw_wx_reset(struct net_device *dev,
			struct iw_request_info *info,
			union iwreq_data *wrqu, char *extra)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	IPW_DEBUG_WX("RESET\n");
	queue_work(priv->workqueue, &priv->adapter_restart);
	return 0;
}

static int ipw_wx_sw_reset(struct net_device *dev,
			   struct iw_request_info *info,
			   union iwreq_data *wrqu, char *extra)
9844 9845
{
	struct ipw_priv *priv = ieee80211_priv(dev);
9846 9847 9848 9849 9850
	union iwreq_data wrqu_sec = {
		.encoding = {
			     .flags = IW_ENCODE_DISABLED,
			     },
	};
9851
	int ret;
9852

9853
	IPW_DEBUG_WX("SW_RESET\n");
9854

9855
	down(&priv->sem);
9856

9857 9858 9859 9860 9861
	ret = ipw_sw_reset(priv, 0);
	if (!ret) {
		free_firmware();
		ipw_adapter_restart(priv);
	}
9862

9863 9864 9865
	/* The SW reset bit might have been toggled on by the 'disable'
	 * module parameter, so take appropriate action */
	ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9866

9867 9868
	up(&priv->sem);
	ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9869
	down(&priv->sem);
9870

9871 9872 9873 9874 9875 9876
	if (!(priv->status & STATUS_RF_KILL_MASK)) {
		/* Configuration likely changed -- force [re]association */
		IPW_DEBUG_ASSOC("[re]association triggered due to sw "
				"reset.\n");
		if (!ipw_disassociate(priv))
			ipw_associate(priv);
J
James Ketrenos 已提交
9877
	}
9878

9879
	up(&priv->sem);
J
James Ketrenos 已提交
9880 9881 9882 9883 9884 9885

	return 0;
}

/* Rebase the WE IOCTLs to zero for the handler array */
#define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9886
static iw_handler ipw_wx_handlers[] = {
9887 9888 9889 9890 9891 9892 9893 9894 9895 9896 9897 9898 9899 9900 9901 9902 9903 9904 9905 9906 9907 9908 9909 9910 9911 9912 9913 9914
	IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
	IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
	IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
	IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
	IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
	IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
	IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
	IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
	IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
	IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
	IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
	IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
	IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
	IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
	IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
	IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
	IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
	IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
	IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
	IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
	IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
	IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
	IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
	IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
	IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
	IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
	IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
	IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9915 9916 9917 9918
	IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
	IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
	IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
	IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9919 9920 9921 9922 9923 9924 9925 9926 9927
#if WIRELESS_EXT > 17
	IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
	IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
	IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
	IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
	IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
	IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
	IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
#endif
J
James Ketrenos 已提交
9928 9929
};

9930 9931 9932 9933 9934 9935 9936 9937 9938 9939 9940 9941 9942
enum {
	IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
	IPW_PRIV_GET_POWER,
	IPW_PRIV_SET_MODE,
	IPW_PRIV_GET_MODE,
	IPW_PRIV_SET_PREAMBLE,
	IPW_PRIV_GET_PREAMBLE,
	IPW_PRIV_RESET,
	IPW_PRIV_SW_RESET,
#ifdef CONFIG_IPW2200_MONITOR
	IPW_PRIV_SET_MONITOR,
#endif
};
J
James Ketrenos 已提交
9943

9944
static struct iw_priv_args ipw_priv_args[] = {
J
James Ketrenos 已提交
9945
	{
9946 9947 9948
	 .cmd = IPW_PRIV_SET_POWER,
	 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
	 .name = "set_power"},
J
James Ketrenos 已提交
9949
	{
9950 9951 9952
	 .cmd = IPW_PRIV_GET_POWER,
	 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
	 .name = "get_power"},
J
James Ketrenos 已提交
9953
	{
9954 9955 9956
	 .cmd = IPW_PRIV_SET_MODE,
	 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
	 .name = "set_mode"},
J
James Ketrenos 已提交
9957
	{
9958 9959 9960
	 .cmd = IPW_PRIV_GET_MODE,
	 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
	 .name = "get_mode"},
J
James Ketrenos 已提交
9961
	{
9962 9963 9964 9965 9966 9967 9968
	 .cmd = IPW_PRIV_SET_PREAMBLE,
	 .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
	 .name = "set_preamble"},
	{
	 .cmd = IPW_PRIV_GET_PREAMBLE,
	 .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
	 .name = "get_preamble"},
J
James Ketrenos 已提交
9969
	{
9970 9971
	 IPW_PRIV_RESET,
	 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9972 9973 9974 9975 9976 9977 9978 9979
	{
	 IPW_PRIV_SW_RESET,
	 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
#ifdef CONFIG_IPW2200_MONITOR
	{
	 IPW_PRIV_SET_MONITOR,
	 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
#endif				/* CONFIG_IPW2200_MONITOR */
J
James Ketrenos 已提交
9980 9981 9982 9983 9984 9985 9986
};

static iw_handler ipw_priv_handler[] = {
	ipw_wx_set_powermode,
	ipw_wx_get_powermode,
	ipw_wx_set_wireless_mode,
	ipw_wx_get_wireless_mode,
9987 9988
	ipw_wx_set_preamble,
	ipw_wx_get_preamble,
9989
	ipw_wx_reset,
9990 9991 9992
	ipw_wx_sw_reset,
#ifdef CONFIG_IPW2200_MONITOR
	ipw_wx_set_monitor,
J
James Ketrenos 已提交
9993 9994 9995
#endif
};

9996
static struct iw_handler_def ipw_wx_handler_def = {
9997 9998 9999 10000 10001 10002
	.standard = ipw_wx_handlers,
	.num_standard = ARRAY_SIZE(ipw_wx_handlers),
	.num_private = ARRAY_SIZE(ipw_priv_handler),
	.num_private_args = ARRAY_SIZE(ipw_priv_args),
	.private = ipw_priv_handler,
	.private_args = ipw_priv_args,
J
James Ketrenos 已提交
10003 10004
};

10005 10006
static struct iw_public_data ipw_wx_data;

J
James Ketrenos 已提交
10007 10008 10009 10010 10011
/*
 * Get wireless statistics.
 * Called by /proc/net/wireless
 * Also called by SIOCGIWSTATS
 */
10012
static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
J
James Ketrenos 已提交
10013 10014 10015
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	struct iw_statistics *wstats;
10016

J
James Ketrenos 已提交
10017 10018
	wstats = &priv->wstats;

10019
	/* if hw is disabled, then ipw_get_ordinal() can't be called.
10020
	 * netdev->get_wireless_stats seems to be called before fw is
J
James Ketrenos 已提交
10021 10022 10023 10024 10025 10026 10027 10028 10029 10030 10031
	 * initialized.  STATUS_ASSOCIATED will only be set if the hw is up
	 * and associated; if not associcated, the values are all meaningless
	 * anyway, so set them all to NULL and INVALID */
	if (!(priv->status & STATUS_ASSOCIATED)) {
		wstats->miss.beacon = 0;
		wstats->discard.retries = 0;
		wstats->qual.qual = 0;
		wstats->qual.level = 0;
		wstats->qual.noise = 0;
		wstats->qual.updated = 7;
		wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
10032
		    IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
J
James Ketrenos 已提交
10033
		return wstats;
10034
	}
J
James Ketrenos 已提交
10035 10036 10037 10038 10039

	wstats->qual.qual = priv->quality;
	wstats->qual.level = average_value(&priv->average_rssi);
	wstats->qual.noise = average_value(&priv->average_noise);
	wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
10040
	    IW_QUAL_NOISE_UPDATED;
J
James Ketrenos 已提交
10041 10042 10043 10044

	wstats->miss.beacon = average_value(&priv->average_missed_beacons);
	wstats->discard.retries = priv->last_tx_failures;
	wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
10045

J
James Ketrenos 已提交
10046 10047 10048
/*	if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
	goto fail_get_ordinal;
	wstats->discard.retries += tx_retry; */
10049

J
James Ketrenos 已提交
10050 10051 10052 10053 10054 10055 10056
	return wstats;
}

/* net device stuff */

static inline void init_sys_config(struct ipw_sys_config *sys_config)
{
10057 10058
	memset(sys_config, 0, sizeof(struct ipw_sys_config));
	sys_config->bt_coexistence = 1;	/* We may need to look into prvStaBtConfig */
J
James Ketrenos 已提交
10059 10060 10061 10062 10063 10064 10065 10066
	sys_config->answer_broadcast_ssid_probe = 0;
	sys_config->accept_all_data_frames = 0;
	sys_config->accept_non_directed_frames = 1;
	sys_config->exclude_unicast_unencrypted = 0;
	sys_config->disable_unicast_decryption = 1;
	sys_config->exclude_multicast_unencrypted = 0;
	sys_config->disable_multicast_decryption = 1;
	sys_config->antenna_diversity = CFG_SYS_ANTENNA_BOTH;
10067
	sys_config->pass_crc_to_host = 0;	/* TODO: See if 1 gives us FCS */
J
James Ketrenos 已提交
10068
	sys_config->dot11g_auto_detection = 0;
10069
	sys_config->enable_cts_to_self = 0;
J
James Ketrenos 已提交
10070
	sys_config->bt_coexist_collision_thr = 0;
10071
	sys_config->pass_noise_stats_to_host = 1;	//1 -- fix for 256
J
James Ketrenos 已提交
10072 10073 10074 10075 10076 10077 10078
}

static int ipw_net_open(struct net_device *dev)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	IPW_DEBUG_INFO("dev->open\n");
	/* we should be verifying the device is ready to be opened */
10079
	down(&priv->sem);
10080 10081
	if (!(priv->status & STATUS_RF_KILL_MASK) &&
	    (priv->status & STATUS_ASSOCIATED))
J
James Ketrenos 已提交
10082
		netif_start_queue(dev);
10083
	up(&priv->sem);
J
James Ketrenos 已提交
10084 10085 10086 10087 10088 10089 10090 10091 10092 10093 10094 10095 10096 10097 10098 10099 10100
	return 0;
}

static int ipw_net_stop(struct net_device *dev)
{
	IPW_DEBUG_INFO("dev->close\n");
	netif_stop_queue(dev);
	return 0;
}

/*
todo:

modify to send one tfd per fragment instead of using chunking.  otherwise
we need to heavily modify the ieee80211_skb_to_txb.
*/

10101 10102
static inline int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
			     int pri)
J
James Ketrenos 已提交
10103
{
10104
	struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
10105
	    txb->fragments[0]->data;
J
James Ketrenos 已提交
10106 10107
	int i = 0;
	struct tfd_frame *tfd;
10108 10109 10110 10111
#ifdef CONFIG_IPW_QOS
	int tx_id = ipw_get_tx_queue_number(priv, pri);
	struct clx2_tx_queue *txq = &priv->txq[tx_id];
#else
J
James Ketrenos 已提交
10112
	struct clx2_tx_queue *txq = &priv->txq[0];
10113
#endif
J
James Ketrenos 已提交
10114 10115 10116
	struct clx2_queue *q = &txq->q;
	u8 id, hdr_len, unicast;
	u16 remaining_bytes;
10117
	int fc;
J
James Ketrenos 已提交
10118

10119 10120 10121 10122 10123
	/* If there isn't room in the queue, we return busy and let the
	 * network stack requeue the packet for us */
	if (ipw_queue_space(q) < q->high_mark)
		return NETDEV_TX_BUSY;

J
James Ketrenos 已提交
10124 10125 10126
	switch (priv->ieee->iw_mode) {
	case IW_MODE_ADHOC:
		hdr_len = IEEE80211_3ADDR_LEN;
10127
		unicast = !is_multicast_ether_addr(hdr->addr1);
J
James Ketrenos 已提交
10128 10129 10130 10131 10132
		id = ipw_find_station(priv, hdr->addr1);
		if (id == IPW_INVALID_STATION) {
			id = ipw_add_station(priv, hdr->addr1);
			if (id == IPW_INVALID_STATION) {
				IPW_WARNING("Attempt to send data to "
10133
					    "invalid cell: " MAC_FMT "\n",
J
James Ketrenos 已提交
10134 10135 10136 10137 10138 10139 10140 10141
					    MAC_ARG(hdr->addr1));
				goto drop;
			}
		}
		break;

	case IW_MODE_INFRA:
	default:
10142
		unicast = !is_multicast_ether_addr(hdr->addr3);
J
James Ketrenos 已提交
10143 10144 10145 10146 10147 10148 10149 10150 10151 10152 10153 10154 10155 10156
		hdr_len = IEEE80211_3ADDR_LEN;
		id = 0;
		break;
	}

	tfd = &txq->bd[q->first_empty];
	txq->txb[q->first_empty] = txb;
	memset(tfd, 0, sizeof(*tfd));
	tfd->u.data.station_number = id;

	tfd->control_flags.message_type = TX_FRAME_TYPE;
	tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;

	tfd->u.data.cmd_id = DINO_CMD_TX;
10157
	tfd->u.data.len = cpu_to_le16(txb->payload_size);
J
James Ketrenos 已提交
10158
	remaining_bytes = txb->payload_size;
10159

J
James Ketrenos 已提交
10160
	if (priv->assoc_request.ieee_mode == IPW_B_MODE)
10161
		tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
J
James Ketrenos 已提交
10162
	else
10163
		tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
J
James Ketrenos 已提交
10164

10165 10166
	if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
		tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
J
James Ketrenos 已提交
10167

10168 10169 10170
	fc = le16_to_cpu(hdr->frame_ctl);
	hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);

J
James Ketrenos 已提交
10171 10172
	memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);

10173 10174 10175 10176 10177 10178 10179 10180 10181 10182 10183 10184 10185 10186 10187 10188 10189 10190 10191 10192 10193 10194 10195 10196 10197 10198 10199 10200 10201 10202 10203 10204 10205 10206 10207 10208 10209 10210 10211 10212 10213 10214 10215 10216 10217 10218 10219 10220 10221 10222 10223 10224
	if (likely(unicast))
		tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;

	if (txb->encrypted && !priv->ieee->host_encrypt) {
		switch (priv->ieee->sec.level) {
		case SEC_LEVEL_3:
			tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
			    IEEE80211_FCTL_PROTECTED;
			/* XXX: ACK flag must be set for CCMP even if it
			 * is a multicast/broadcast packet, because CCMP
			 * group communication encrypted by GTK is
			 * actually done by the AP. */
			if (!unicast)
				tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;

			tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
			tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
			tfd->u.data.key_index = 0;
			tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
			break;
		case SEC_LEVEL_2:
			tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
			    IEEE80211_FCTL_PROTECTED;
			tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
			tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
			tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
			break;
		case SEC_LEVEL_1:
			tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
			    IEEE80211_FCTL_PROTECTED;
			tfd->u.data.key_index = priv->ieee->tx_keyidx;
			if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
			    40)
				tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
			else
				tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
			break;
		case SEC_LEVEL_0:
			break;
		default:
			printk(KERN_ERR "Unknow security level %d\n",
			       priv->ieee->sec.level);
			break;
		}
	} else
		/* No hardware encryption */
		tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;

#ifdef CONFIG_IPW_QOS
	ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
#endif				/* CONFIG_IPW_QOS */

J
James Ketrenos 已提交
10225
	/* payload */
10226 10227 10228 10229 10230 10231 10232 10233
	tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
						 txb->nr_frags));
	IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
		       txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
	for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
		IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
			       i, le32_to_cpu(tfd->u.data.num_chunks),
			       txb->fragments[i]->len - hdr_len);
10234
		IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
J
James Ketrenos 已提交
10235 10236
			     i, tfd->u.data.num_chunks,
			     txb->fragments[i]->len - hdr_len);
10237
		printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
J
James Ketrenos 已提交
10238 10239
			   txb->fragments[i]->len - hdr_len);

10240
		tfd->u.data.chunk_ptr[i] =
10241 10242 10243 10244 10245 10246 10247
		    cpu_to_le32(pci_map_single
				(priv->pci_dev,
				 txb->fragments[i]->data + hdr_len,
				 txb->fragments[i]->len - hdr_len,
				 PCI_DMA_TODEVICE));
		tfd->u.data.chunk_len[i] =
		    cpu_to_le16(txb->fragments[i]->len - hdr_len);
J
James Ketrenos 已提交
10248 10249 10250 10251 10252 10253 10254 10255 10256 10257 10258 10259 10260 10261
	}

	if (i != txb->nr_frags) {
		struct sk_buff *skb;
		u16 remaining_bytes = 0;
		int j;

		for (j = i; j < txb->nr_frags; j++)
			remaining_bytes += txb->fragments[j]->len - hdr_len;

		printk(KERN_INFO "Trying to reallocate for %d bytes\n",
		       remaining_bytes);
		skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
		if (skb != NULL) {
10262
			tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
J
James Ketrenos 已提交
10263 10264
			for (j = i; j < txb->nr_frags; j++) {
				int size = txb->fragments[j]->len - hdr_len;
10265

J
James Ketrenos 已提交
10266
				printk(KERN_INFO "Adding frag %d %d...\n",
10267
				       j, size);
J
James Ketrenos 已提交
10268
				memcpy(skb_put(skb, size),
10269
				       txb->fragments[j]->data + hdr_len, size);
J
James Ketrenos 已提交
10270 10271 10272
			}
			dev_kfree_skb_any(txb->fragments[i]);
			txb->fragments[i] = skb;
10273
			tfd->u.data.chunk_ptr[i] =
10274 10275 10276 10277 10278 10279 10280 10281
			    cpu_to_le32(pci_map_single
					(priv->pci_dev, skb->data,
					 tfd->u.data.chunk_len[i],
					 PCI_DMA_TODEVICE));

			tfd->u.data.num_chunks =
			    cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
					1);
10282
		}
J
James Ketrenos 已提交
10283 10284 10285 10286 10287 10288
	}

	/* kick DMA */
	q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
	ipw_write32(priv, q->reg_w, q->first_empty);

10289
	return NETDEV_TX_OK;
J
James Ketrenos 已提交
10290

10291
      drop:
J
James Ketrenos 已提交
10292 10293
	IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
	ieee80211_txb_free(txb);
10294 10295 10296 10297 10298 10299 10300 10301 10302 10303 10304 10305 10306 10307 10308 10309 10310
	return NETDEV_TX_OK;
}

static int ipw_net_is_queue_full(struct net_device *dev, int pri)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
#ifdef CONFIG_IPW_QOS
	int tx_id = ipw_get_tx_queue_number(priv, pri);
	struct clx2_tx_queue *txq = &priv->txq[tx_id];
#else
	struct clx2_tx_queue *txq = &priv->txq[0];
#endif				/* CONFIG_IPW_QOS */

	if (ipw_queue_space(&txq->q) < txq->q.high_mark)
		return 1;

	return 0;
J
James Ketrenos 已提交
10311 10312 10313
}

static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
10314
				   struct net_device *dev, int pri)
J
James Ketrenos 已提交
10315 10316 10317
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	unsigned long flags;
10318
	int ret;
J
James Ketrenos 已提交
10319 10320 10321 10322 10323 10324 10325 10326 10327 10328 10329

	IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
	spin_lock_irqsave(&priv->lock, flags);

	if (!(priv->status & STATUS_ASSOCIATED)) {
		IPW_DEBUG_INFO("Tx attempt while not associated.\n");
		priv->ieee->stats.tx_carrier_errors++;
		netif_stop_queue(dev);
		goto fail_unlock;
	}

10330 10331 10332
	ret = ipw_tx_skb(priv, txb, pri);
	if (ret == NETDEV_TX_OK)
		__ipw_led_activity_on(priv);
10333
	spin_unlock_irqrestore(&priv->lock, flags);
J
James Ketrenos 已提交
10334

10335
	return ret;
J
James Ketrenos 已提交
10336

10337
      fail_unlock:
J
James Ketrenos 已提交
10338 10339 10340 10341 10342 10343 10344
	spin_unlock_irqrestore(&priv->lock, flags);
	return 1;
}

static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
10345

J
James Ketrenos 已提交
10346 10347 10348 10349 10350 10351 10352 10353 10354 10355 10356 10357 10358 10359 10360 10361
	priv->ieee->stats.tx_packets = priv->tx_packets;
	priv->ieee->stats.rx_packets = priv->rx_packets;
	return &priv->ieee->stats;
}

static void ipw_net_set_multicast_list(struct net_device *dev)
{

}

static int ipw_net_set_mac_address(struct net_device *dev, void *p)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	struct sockaddr *addr = p;
	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;
10362
	down(&priv->sem);
J
James Ketrenos 已提交
10363 10364 10365 10366
	priv->config |= CFG_CUSTOM_MAC;
	memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
	printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
	       priv->net_dev->name, MAC_ARG(priv->mac_addr));
10367
	queue_work(priv->workqueue, &priv->adapter_restart);
10368
	up(&priv->sem);
J
James Ketrenos 已提交
10369 10370 10371
	return 0;
}

10372
static void ipw_ethtool_get_drvinfo(struct net_device *dev,
J
James Ketrenos 已提交
10373 10374 10375 10376 10377 10378 10379 10380 10381 10382 10383 10384 10385 10386 10387
				    struct ethtool_drvinfo *info)
{
	struct ipw_priv *p = ieee80211_priv(dev);
	char vers[64];
	char date[32];
	u32 len;

	strcpy(info->driver, DRV_NAME);
	strcpy(info->version, DRV_VERSION);

	len = sizeof(vers);
	ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
	len = sizeof(date);
	ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);

10388
	snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
J
James Ketrenos 已提交
10389 10390
		 vers, date);
	strcpy(info->bus_info, pci_name(p->pci_dev));
10391
	info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
J
James Ketrenos 已提交
10392 10393 10394 10395 10396 10397 10398 10399 10400 10401
}

static u32 ipw_ethtool_get_link(struct net_device *dev)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	return (priv->status & STATUS_ASSOCIATED) != 0;
}

static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
{
10402
	return IPW_EEPROM_IMAGE_SIZE;
J
James Ketrenos 已提交
10403 10404 10405
}

static int ipw_ethtool_get_eeprom(struct net_device *dev,
10406
				  struct ethtool_eeprom *eeprom, u8 * bytes)
J
James Ketrenos 已提交
10407 10408 10409
{
	struct ipw_priv *p = ieee80211_priv(dev);

10410
	if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
J
James Ketrenos 已提交
10411
		return -EINVAL;
10412
	down(&p->sem);
10413
	memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
10414
	up(&p->sem);
J
James Ketrenos 已提交
10415 10416 10417 10418
	return 0;
}

static int ipw_ethtool_set_eeprom(struct net_device *dev,
10419
				  struct ethtool_eeprom *eeprom, u8 * bytes)
J
James Ketrenos 已提交
10420 10421 10422 10423
{
	struct ipw_priv *p = ieee80211_priv(dev);
	int i;

10424
	if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
J
James Ketrenos 已提交
10425
		return -EINVAL;
10426
	down(&p->sem);
10427
	memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
10428
	for (i = IPW_EEPROM_DATA;
10429
	     i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
J
James Ketrenos 已提交
10430
		ipw_write8(p, i, p->eeprom[i]);
10431
	up(&p->sem);
J
James Ketrenos 已提交
10432 10433 10434 10435
	return 0;
}

static struct ethtool_ops ipw_ethtool_ops = {
10436 10437 10438 10439 10440
	.get_link = ipw_ethtool_get_link,
	.get_drvinfo = ipw_ethtool_get_drvinfo,
	.get_eeprom_len = ipw_ethtool_get_eeprom_len,
	.get_eeprom = ipw_ethtool_get_eeprom,
	.set_eeprom = ipw_ethtool_set_eeprom,
J
James Ketrenos 已提交
10441 10442 10443 10444 10445 10446
};

static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
{
	struct ipw_priv *priv = data;
	u32 inta, inta_mask;
10447

J
James Ketrenos 已提交
10448 10449 10450 10451 10452 10453 10454 10455 10456 10457
	if (!priv)
		return IRQ_NONE;

	spin_lock(&priv->lock);

	if (!(priv->status & STATUS_INT_ENABLED)) {
		/* Shared IRQ */
		goto none;
	}

10458 10459
	inta = ipw_read32(priv, IPW_INTA_RW);
	inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
10460

J
James Ketrenos 已提交
10461 10462 10463 10464 10465 10466
	if (inta == 0xFFFFFFFF) {
		/* Hardware disappeared */
		IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
		goto none;
	}

10467
	if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
J
James Ketrenos 已提交
10468 10469 10470 10471 10472 10473
		/* Shared interrupt */
		goto none;
	}

	/* tell the device to stop sending interrupts */
	ipw_disable_interrupts(priv);
10474

J
James Ketrenos 已提交
10475
	/* ack current interrupts */
10476 10477
	inta &= (IPW_INTA_MASK_ALL & inta_mask);
	ipw_write32(priv, IPW_INTA_RW, inta);
10478

J
James Ketrenos 已提交
10479 10480 10481 10482 10483
	/* Cache INTA value for our tasklet */
	priv->isr_inta = inta;

	tasklet_schedule(&priv->irq_tasklet);

10484
	spin_unlock(&priv->lock);
J
James Ketrenos 已提交
10485 10486

	return IRQ_HANDLED;
10487
      none:
J
James Ketrenos 已提交
10488 10489 10490 10491 10492 10493 10494 10495
	spin_unlock(&priv->lock);
	return IRQ_NONE;
}

static void ipw_rf_kill(void *adapter)
{
	struct ipw_priv *priv = adapter;
	unsigned long flags;
10496

J
James Ketrenos 已提交
10497 10498 10499 10500 10501 10502 10503 10504 10505 10506 10507 10508 10509 10510 10511 10512 10513 10514
	spin_lock_irqsave(&priv->lock, flags);

	if (rf_kill_active(priv)) {
		IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
		if (priv->workqueue)
			queue_delayed_work(priv->workqueue,
					   &priv->rf_kill, 2 * HZ);
		goto exit_unlock;
	}

	/* RF Kill is now disabled, so bring the device back up */

	if (!(priv->status & STATUS_RF_KILL_MASK)) {
		IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
				  "device\n");

		/* we can not do an adapter restart while inside an irq lock */
		queue_work(priv->workqueue, &priv->adapter_restart);
10515
	} else
J
James Ketrenos 已提交
10516 10517 10518
		IPW_DEBUG_RF_KILL("HW RF Kill deactivated.  SW RF Kill still "
				  "enabled\n");

10519
      exit_unlock:
J
James Ketrenos 已提交
10520 10521 10522
	spin_unlock_irqrestore(&priv->lock, flags);
}

10523 10524 10525 10526 10527 10528 10529 10530
static void ipw_bg_rf_kill(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_rf_kill(data);
	up(&priv->sem);
}

10531 10532
void ipw_link_up(struct ipw_priv *priv)
{
10533 10534 10535 10536
	priv->last_seq_num = -1;
	priv->last_frag_num = -1;
	priv->last_packet_time = 0;

10537 10538 10539 10540 10541 10542 10543 10544 10545
	netif_carrier_on(priv->net_dev);
	if (netif_queue_stopped(priv->net_dev)) {
		IPW_DEBUG_NOTIF("waking queue\n");
		netif_wake_queue(priv->net_dev);
	} else {
		IPW_DEBUG_NOTIF("starting queue\n");
		netif_start_queue(priv->net_dev);
	}

10546
	cancel_delayed_work(&priv->request_scan);
10547 10548 10549 10550 10551 10552 10553 10554 10555 10556 10557
	ipw_reset_stats(priv);
	/* Ensure the rate is updated immediately */
	priv->last_rate = ipw_get_current_rate(priv);
	ipw_gather_stats(priv);
	ipw_led_link_up(priv);
	notify_wx_assoc_event(priv);

	if (priv->config & CFG_BACKGROUND_SCAN)
		queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
}

10558 10559 10560 10561 10562 10563 10564 10565
static void ipw_bg_link_up(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_link_up(data);
	up(&priv->sem);
}

10566 10567 10568 10569 10570 10571 10572 10573 10574 10575 10576 10577 10578 10579
void ipw_link_down(struct ipw_priv *priv)
{
	ipw_led_link_down(priv);
	netif_carrier_off(priv->net_dev);
	netif_stop_queue(priv->net_dev);
	notify_wx_assoc_event(priv);

	/* Cancel any queued work ... */
	cancel_delayed_work(&priv->request_scan);
	cancel_delayed_work(&priv->adhoc_check);
	cancel_delayed_work(&priv->gather_stats);

	ipw_reset_stats(priv);

10580 10581 10582 10583
	if (!(priv->status & STATUS_EXIT_PENDING)) {
		/* Queue up another scan... */
		queue_work(priv->workqueue, &priv->request_scan);
	}
10584 10585
}

10586 10587 10588 10589 10590 10591 10592 10593
static void ipw_bg_link_down(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_link_down(data);
	up(&priv->sem);
}

J
James Ketrenos 已提交
10594 10595 10596 10597 10598 10599
static int ipw_setup_deferred_work(struct ipw_priv *priv)
{
	int ret = 0;

	priv->workqueue = create_workqueue(DRV_NAME);
	init_waitqueue_head(&priv->wait_command_queue);
10600
	init_waitqueue_head(&priv->wait_state);
J
James Ketrenos 已提交
10601

10602 10603 10604
	INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
	INIT_WORK(&priv->associate, ipw_bg_associate, priv);
	INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10605
	INIT_WORK(&priv->system_config, ipw_system_config, priv);
10606 10607 10608 10609 10610
	INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
	INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
	INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
	INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
	INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10611
	INIT_WORK(&priv->request_scan,
10612
		  (void (*)(void *))ipw_request_scan, priv);
10613
	INIT_WORK(&priv->gather_stats,
10614 10615 10616 10617 10618 10619 10620 10621 10622
		  (void (*)(void *))ipw_bg_gather_stats, priv);
	INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
	INIT_WORK(&priv->roam, ipw_bg_roam, priv);
	INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
	INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
	INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
	INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
		  priv);
	INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10623
		  priv);
10624
	INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10625
		  priv);
10626 10627
	INIT_WORK(&priv->merge_networks,
		  (void (*)(void *))ipw_merge_adhoc_network, priv);
J
James Ketrenos 已提交
10628

10629 10630 10631 10632 10633
#ifdef CONFIG_IPW_QOS
	INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
		  priv);
#endif				/* CONFIG_IPW_QOS */

J
James Ketrenos 已提交
10634 10635 10636 10637 10638 10639 10640 10641 10642 10643 10644
	tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
		     ipw_irq_tasklet, (unsigned long)priv);

	return ret;
}

static void shim__set_security(struct net_device *dev,
			       struct ieee80211_security *sec)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
	int i;
10645
	for (i = 0; i < 4; i++) {
J
James Ketrenos 已提交
10646
		if (sec->flags & (1 << i)) {
10647
			priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10648
			priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
J
James Ketrenos 已提交
10649
			if (sec->key_sizes[i] == 0)
10650 10651 10652
				priv->ieee->sec.flags &= ~(1 << i);
			else {
				memcpy(priv->ieee->sec.keys[i], sec->keys[i],
J
James Ketrenos 已提交
10653
				       sec->key_sizes[i]);
10654 10655
				priv->ieee->sec.flags |= (1 << i);
			}
J
James Ketrenos 已提交
10656
			priv->status |= STATUS_SECURITY_UPDATED;
10657 10658
		} else if (sec->level != SEC_LEVEL_1)
			priv->ieee->sec.flags &= ~(1 << i);
J
James Ketrenos 已提交
10659 10660
	}

10661
	if (sec->flags & SEC_ACTIVE_KEY) {
J
James Ketrenos 已提交
10662
		if (sec->active_key <= 3) {
10663 10664
			priv->ieee->sec.active_key = sec->active_key;
			priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10665
		} else
10666
			priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
J
James Ketrenos 已提交
10667
		priv->status |= STATUS_SECURITY_UPDATED;
10668 10669
	} else
		priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
J
James Ketrenos 已提交
10670 10671

	if ((sec->flags & SEC_AUTH_MODE) &&
10672 10673 10674
	    (priv->ieee->sec.auth_mode != sec->auth_mode)) {
		priv->ieee->sec.auth_mode = sec->auth_mode;
		priv->ieee->sec.flags |= SEC_AUTH_MODE;
J
James Ketrenos 已提交
10675 10676 10677 10678 10679 10680
		if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
			priv->capability |= CAP_SHARED_KEY;
		else
			priv->capability &= ~CAP_SHARED_KEY;
		priv->status |= STATUS_SECURITY_UPDATED;
	}
10681

10682 10683 10684
	if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
		priv->ieee->sec.flags |= SEC_ENABLED;
		priv->ieee->sec.enabled = sec->enabled;
J
James Ketrenos 已提交
10685
		priv->status |= STATUS_SECURITY_UPDATED;
10686
		if (sec->enabled)
J
James Ketrenos 已提交
10687 10688 10689 10690
			priv->capability |= CAP_PRIVACY_ON;
		else
			priv->capability &= ~CAP_PRIVACY_ON;
	}
10691 10692 10693

	if (sec->flags & SEC_ENCRYPT)
		priv->ieee->sec.encrypt = sec->encrypt;
10694

10695 10696 10697
	if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
		priv->ieee->sec.level = sec->level;
		priv->ieee->sec.flags |= SEC_LEVEL;
J
James Ketrenos 已提交
10698
		priv->status |= STATUS_SECURITY_UPDATED;
10699
	}
10700

10701 10702 10703
	if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
		ipw_set_hwcrypto_keys(priv);

10704 10705
	/* To match current functionality of ipw2100 (which works well w/
	 * various supplicants, we don't force a disassociate if the
J
James Ketrenos 已提交
10706 10707 10708
	 * privacy capability changes ... */
#if 0
	if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10709
	    (((priv->assoc_request.capability &
J
James Ketrenos 已提交
10710
	       WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10711
	     (!(priv->assoc_request.capability &
10712
		WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
J
James Ketrenos 已提交
10713 10714 10715 10716 10717 10718 10719
		IPW_DEBUG_ASSOC("Disassociating due to capability "
				"change.\n");
		ipw_disassociate(priv);
	}
#endif
}

10720
static int init_supported_rates(struct ipw_priv *priv,
J
James Ketrenos 已提交
10721 10722 10723 10724 10725
				struct ipw_supported_rates *rates)
{
	/* TODO: Mask out rates based on priv->rates_mask */

	memset(rates, 0, sizeof(*rates));
10726
	/* configure supported rates */
J
James Ketrenos 已提交
10727 10728 10729 10730 10731 10732 10733 10734
	switch (priv->ieee->freq_band) {
	case IEEE80211_52GHZ_BAND:
		rates->ieee_mode = IPW_A_MODE;
		rates->purpose = IPW_RATE_CAPABILITIES;
		ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
					IEEE80211_OFDM_DEFAULT_RATES_MASK);
		break;

10735
	default:		/* Mixed or 2.4Ghz */
J
James Ketrenos 已提交
10736 10737 10738 10739 10740 10741 10742 10743 10744 10745 10746 10747 10748 10749
		rates->ieee_mode = IPW_G_MODE;
		rates->purpose = IPW_RATE_CAPABILITIES;
		ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
				       IEEE80211_CCK_DEFAULT_RATES_MASK);
		if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
			ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
						IEEE80211_OFDM_DEFAULT_RATES_MASK);
		}
		break;
	}

	return 0;
}

10750
static int ipw_config(struct ipw_priv *priv)
J
James Ketrenos 已提交
10751 10752 10753 10754
{
	/* This is only called from ipw_up, which resets/reloads the firmware
	   so, we don't need to first disable the card before we configure
	   it */
Z
Zhu Yi 已提交
10755
	if (ipw_set_tx_power(priv))
J
James Ketrenos 已提交
10756 10757 10758 10759 10760 10761 10762 10763
		goto error;

	/* initialize adapter address */
	if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
		goto error;

	/* set basic system config settings */
	init_sys_config(&priv->sys_config);
10764 10765 10766 10767 10768
	if (priv->ieee->iw_mode == IW_MODE_ADHOC)
		priv->sys_config.answer_broadcast_ssid_probe = 1;
	else
		priv->sys_config.answer_broadcast_ssid_probe = 0;

J
James Ketrenos 已提交
10769 10770 10771
	if (ipw_send_system_config(priv, &priv->sys_config))
		goto error;

10772 10773
	init_supported_rates(priv, &priv->rates);
	if (ipw_send_supported_rates(priv, &priv->rates))
J
James Ketrenos 已提交
10774 10775 10776 10777 10778 10779 10780
		goto error;

	/* Set request-to-send threshold */
	if (priv->rts_threshold) {
		if (ipw_send_rts_threshold(priv, priv->rts_threshold))
			goto error;
	}
10781 10782 10783 10784
#ifdef CONFIG_IPW_QOS
	IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
	ipw_qos_activate(priv, NULL);
#endif				/* CONFIG_IPW_QOS */
J
James Ketrenos 已提交
10785 10786 10787

	if (ipw_set_random_seed(priv))
		goto error;
10788

J
James Ketrenos 已提交
10789 10790 10791 10792
	/* final state transition to the RUN state */
	if (ipw_send_host_complete(priv))
		goto error;

10793 10794 10795 10796 10797 10798 10799 10800 10801 10802 10803
	priv->status |= STATUS_INIT;

	ipw_led_init(priv);
	ipw_led_radio_on(priv);
	priv->notif_missed_beacons = 0;

	/* Set hardware WEP key if it is configured. */
	if ((priv->capability & CAP_PRIVACY_ON) &&
	    (priv->ieee->sec.level == SEC_LEVEL_1) &&
	    !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
		ipw_set_hwcrypto_keys(priv);
J
James Ketrenos 已提交
10804 10805

	return 0;
10806

10807
      error:
J
James Ketrenos 已提交
10808 10809 10810
	return -EIO;
}

10811 10812 10813 10814 10815 10816 10817 10818 10819 10820 10821 10822 10823 10824 10825 10826 10827 10828 10829 10830 10831 10832 10833 10834 10835 10836 10837 10838 10839 10840 10841 10842 10843 10844 10845 10846 10847 10848 10849 10850 10851 10852 10853 10854 10855 10856 10857 10858 10859 10860 10861 10862 10863 10864 10865 10866 10867 10868 10869 10870 10871 10872 10873 10874 10875 10876 10877 10878 10879 10880 10881 10882 10883 10884 10885 10886 10887 10888 10889 10890 10891 10892 10893 10894 10895 10896 10897 10898 10899 10900 10901 10902 10903 10904 10905 10906 10907 10908 10909 10910 10911 10912 10913 10914 10915 10916 10917 10918 10919 10920 10921 10922 10923 10924 10925 10926 10927 10928 10929 10930 10931 10932 10933 10934 10935 10936 10937 10938 10939 10940 10941 10942 10943 10944 10945 10946 10947 10948 10949 10950 10951 10952 10953 10954 10955 10956 10957 10958 10959 10960 10961 10962 10963 10964 10965 10966 10967 10968 10969 10970 10971 10972 10973 10974 10975 10976 10977 10978 10979 10980 10981 10982 10983 10984 10985 10986 10987 10988 10989 10990 10991 10992 10993 10994 10995 10996 10997 10998 10999 11000 11001 11002 11003 11004 11005 11006 11007 11008 11009 11010 11011 11012 11013 11014 11015 11016 11017 11018 11019 11020 11021 11022 11023 11024 11025 11026 11027 11028 11029 11030 11031 11032 11033 11034 11035 11036 11037 11038 11039 11040 11041 11042 11043 11044 11045 11046 11047 11048 11049 11050 11051 11052 11053 11054
/*
 * NOTE:
 *
 * These tables have been tested in conjunction with the
 * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
 *
 * Altering this values, using it on other hardware, or in geographies
 * not intended for resale of the above mentioned Intel adapters has
 * not been tested.
 *
 */
static const struct ieee80211_geo ipw_geos[] = {
	{			/* Restricted */
	 "---",
	 .bg_channels = 11,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11}},
	 },

	{			/* Custom US/Canada */
	 "ZZF",
	 .bg_channels = 11,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11}},
	 .a_channels = 8,
	 .a = {{5180, 36},
	       {5200, 40},
	       {5220, 44},
	       {5240, 48},
	       {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
	       {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
	       {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
	       {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
	 },

	{			/* Rest of World */
	 "ZZD",
	 .bg_channels = 13,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11}, {2467, 12},
		{2472, 13}},
	 },

	{			/* Custom USA & Europe & High */
	 "ZZA",
	 .bg_channels = 11,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11}},
	 .a_channels = 13,
	 .a = {{5180, 36},
	       {5200, 40},
	       {5220, 44},
	       {5240, 48},
	       {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
	       {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
	       {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
	       {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
	       {5745, 149},
	       {5765, 153},
	       {5785, 157},
	       {5805, 161},
	       {5825, 165}},
	 },

	{			/* Custom NA & Europe */
	 "ZZB",
	 .bg_channels = 11,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11}},
	 .a_channels = 13,
	 .a = {{5180, 36},
	       {5200, 40},
	       {5220, 44},
	       {5240, 48},
	       {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
	       {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
	       {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
	       {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
	       {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
	       {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
	       {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
	       {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
	       {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
	 },

	{			/* Custom Japan */
	 "ZZC",
	 .bg_channels = 11,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11}},
	 .a_channels = 4,
	 .a = {{5170, 34}, {5190, 38},
	       {5210, 42}, {5230, 46}},
	 },

	{			/* Custom */
	 "ZZM",
	 .bg_channels = 11,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11}},
	 },

	{			/* Europe */
	 "ZZE",
	 .bg_channels = 13,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11}, {2467, 12},
		{2472, 13}},
	 .a_channels = 19,
	 .a = {{5180, 36},
	       {5200, 40},
	       {5220, 44},
	       {5240, 48},
	       {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
	       {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
	       {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
	       {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
	       {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
	       {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
	       {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
	       {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
	       {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
	       {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
	       {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
	       {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
	       {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
	       {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
	       {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
	 },

	{			/* Custom Japan */
	 "ZZJ",
	 .bg_channels = 14,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11}, {2467, 12},
		{2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
	 .a_channels = 4,
	 .a = {{5170, 34}, {5190, 38},
	       {5210, 42}, {5230, 46}},
	 },

	{			/* High Band */
	 "ZZH",
	 .bg_channels = 13,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11},
		{2467, 12, IEEE80211_CH_PASSIVE_ONLY},
		{2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
	 .a_channels = 4,
	 .a = {{5745, 149}, {5765, 153},
	       {5785, 157}, {5805, 161}},
	 },

	{			/* Custom Europe */
	 "ZZG",
	 .bg_channels = 13,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11},
		{2467, 12}, {2472, 13}},
	 .a_channels = 4,
	 .a = {{5180, 36}, {5200, 40},
	       {5220, 44}, {5240, 48}},
	 },

	{			/* Europe */
	 "ZZK",
	 .bg_channels = 13,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11},
		{2467, 12, IEEE80211_CH_PASSIVE_ONLY},
		{2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
	 .a_channels = 24,
	 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
	       {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
	       {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
	       {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
	       {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
	       {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
	       {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
	       {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
	       {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
	       {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
	       {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
	       {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
	       {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
	       {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
	       {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
	       {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
	       {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
	       {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
	       {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
	       {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
	       {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
	       {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
	       {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
	       {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
	 },

	{			/* Europe */
	 "ZZL",
	 .bg_channels = 11,
	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
		{2427, 4}, {2432, 5}, {2437, 6},
		{2442, 7}, {2447, 8}, {2452, 9},
		{2457, 10}, {2462, 11}},
	 .a_channels = 13,
	 .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
	       {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
	       {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
	       {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
	       {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
	       {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
	       {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
	       {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
	       {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
	       {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
	       {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
	       {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
	       {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
	 }
11055 11056
};

11057 11058 11059 11060 11061 11062 11063 11064 11065 11066 11067 11068 11069 11070 11071 11072 11073 11074 11075 11076 11077 11078 11079 11080 11081 11082 11083 11084 11085 11086 11087 11088 11089 11090 11091 11092 11093 11094 11095 11096 11097 11098 11099 11100 11101 11102 11103 11104 11105 11106 11107 11108 11109 11110 11111 11112 11113 11114 11115 11116 11117 11118 11119 11120 11121 11122 11123 11124 11125 11126 11127 11128 11129 11130 11131 11132 11133 11134 11135 11136 11137 11138 11139 11140 11141 11142 11143 11144 11145 11146
/* GEO code borrowed from ieee80211_geo.c */
static int ipw_is_valid_channel(struct ieee80211_device *ieee, u8 channel)
{
	int i;

	/* Driver needs to initialize the geography map before using
	 * these helper functions */
	BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);

	if (ieee->freq_band & IEEE80211_24GHZ_BAND)
		for (i = 0; i < ieee->geo.bg_channels; i++)
			/* NOTE: If G mode is currently supported but
			 * this is a B only channel, we don't see it
			 * as valid. */
			if ((ieee->geo.bg[i].channel == channel) &&
			    (!(ieee->mode & IEEE_G) ||
			     !(ieee->geo.bg[i].flags & IEEE80211_CH_B_ONLY)))
				return IEEE80211_24GHZ_BAND;

	if (ieee->freq_band & IEEE80211_52GHZ_BAND)
		for (i = 0; i < ieee->geo.a_channels; i++)
			if (ieee->geo.a[i].channel == channel)
				return IEEE80211_52GHZ_BAND;

	return 0;
}

static int ipw_channel_to_index(struct ieee80211_device *ieee, u8 channel)
{
	int i;

	/* Driver needs to initialize the geography map before using
	 * these helper functions */
	BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);

	if (ieee->freq_band & IEEE80211_24GHZ_BAND)
		for (i = 0; i < ieee->geo.bg_channels; i++)
			if (ieee->geo.bg[i].channel == channel)
				return i;

	if (ieee->freq_band & IEEE80211_52GHZ_BAND)
		for (i = 0; i < ieee->geo.a_channels; i++)
			if (ieee->geo.a[i].channel == channel)
				return i;

	return -1;
}

static u8 ipw_freq_to_channel(struct ieee80211_device *ieee, u32 freq)
{
	int i;

	/* Driver needs to initialize the geography map before using
	 * these helper functions */
	BUG_ON(ieee->geo.bg_channels == 0 && ieee->geo.a_channels == 0);

	freq /= 100000;

	if (ieee->freq_band & IEEE80211_24GHZ_BAND)
		for (i = 0; i < ieee->geo.bg_channels; i++)
			if (ieee->geo.bg[i].freq == freq)
				return ieee->geo.bg[i].channel;

	if (ieee->freq_band & IEEE80211_52GHZ_BAND)
		for (i = 0; i < ieee->geo.a_channels; i++)
			if (ieee->geo.a[i].freq == freq)
				return ieee->geo.a[i].channel;

	return 0;
}

static int ipw_set_geo(struct ieee80211_device *ieee,
		       const struct ieee80211_geo *geo)
{
	memcpy(ieee->geo.name, geo->name, 3);
	ieee->geo.name[3] = '\0';
	ieee->geo.bg_channels = geo->bg_channels;
	ieee->geo.a_channels = geo->a_channels;
	memcpy(ieee->geo.bg, geo->bg, geo->bg_channels *
	       sizeof(struct ieee80211_channel));
	memcpy(ieee->geo.a, geo->a, ieee->geo.a_channels *
	       sizeof(struct ieee80211_channel));
	return 0;
}

static const struct ieee80211_geo *ipw_get_geo(struct ieee80211_device *ieee)
{
	return &ieee->geo;
}

J
James Ketrenos 已提交
11147 11148 11149
#define MAX_HW_RESTARTS 5
static int ipw_up(struct ipw_priv *priv)
{
11150
	int rc, i, j;
J
James Ketrenos 已提交
11151 11152 11153 11154

	if (priv->status & STATUS_EXIT_PENDING)
		return -EIO;

11155 11156 11157 11158 11159 11160 11161 11162 11163 11164 11165 11166
	if (cmdlog && !priv->cmdlog) {
		priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
				       GFP_KERNEL);
		if (priv->cmdlog == NULL) {
			IPW_ERROR("Error allocating %d command log entries.\n",
				  cmdlog);
		} else {
			memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
			priv->cmdlog_len = cmdlog;
		}
	}

11167
	for (i = 0; i < MAX_HW_RESTARTS; i++) {
11168
		/* Load the microcode, firmware, and eeprom.
J
James Ketrenos 已提交
11169 11170 11171
		 * Also start the clocks. */
		rc = ipw_load(priv);
		if (rc) {
11172
			IPW_ERROR("Unable to load firmware: %d\n", rc);
J
James Ketrenos 已提交
11173 11174 11175 11176 11177 11178 11179 11180
			return rc;
		}

		ipw_init_ordinals(priv);
		if (!(priv->config & CFG_CUSTOM_MAC))
			eeprom_parse_mac(priv, priv->mac_addr);
		memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);

11181 11182 11183 11184 11185 11186 11187
		for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
			if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
				    ipw_geos[j].name, 3))
				break;
		}
		if (j == ARRAY_SIZE(ipw_geos))
			j = 0;
11188
		if (ipw_set_geo(priv->ieee, &ipw_geos[j])) {
11189 11190 11191 11192 11193 11194
			IPW_WARNING("Could not set geography.");
			return 0;
		}

		IPW_DEBUG_INFO("Geography %03d [%s] detected.\n",
			       j, priv->ieee->geo.name);
11195

11196 11197 11198 11199 11200 11201 11202 11203 11204
		if (priv->status & STATUS_RF_KILL_SW) {
			IPW_WARNING("Radio disabled by module parameter.\n");
			return 0;
		} else if (rf_kill_active(priv)) {
			IPW_WARNING("Radio Frequency Kill Switch is On:\n"
				    "Kill switch must be turned off for "
				    "wireless networking to work.\n");
			queue_delayed_work(priv->workqueue, &priv->rf_kill,
					   2 * HZ);
J
James Ketrenos 已提交
11205
			return 0;
11206
		}
J
James Ketrenos 已提交
11207 11208 11209 11210

		rc = ipw_config(priv);
		if (!rc) {
			IPW_DEBUG_INFO("Configured device on count %i\n", i);
11211 11212 11213 11214

			/* If configure to try and auto-associate, kick
			 * off a scan. */
			queue_work(priv->workqueue, &priv->request_scan);
11215

J
James Ketrenos 已提交
11216 11217
			return 0;
		}
11218

11219
		IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
J
James Ketrenos 已提交
11220 11221 11222 11223 11224 11225 11226 11227
		IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
			       i, MAX_HW_RESTARTS);

		/* We had an error bringing up the hardware, so take it
		 * all the way back down so we can try again */
		ipw_down(priv);
	}

11228
	/* tried to restart and config the device for as long as our
J
James Ketrenos 已提交
11229
	 * patience could withstand */
11230
	IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
11231

J
James Ketrenos 已提交
11232 11233 11234
	return -EIO;
}

11235 11236 11237 11238 11239 11240 11241 11242
static void ipw_bg_up(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_up(data);
	up(&priv->sem);
}

11243
static void ipw_deinit(struct ipw_priv *priv)
J
James Ketrenos 已提交
11244
{
11245 11246 11247 11248 11249 11250 11251 11252 11253 11254 11255 11256 11257 11258 11259 11260 11261 11262 11263 11264 11265 11266 11267 11268 11269 11270 11271 11272
	int i;

	if (priv->status & STATUS_SCANNING) {
		IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
		ipw_abort_scan(priv);
	}

	if (priv->status & STATUS_ASSOCIATED) {
		IPW_DEBUG_INFO("Disassociating during shutdown.\n");
		ipw_disassociate(priv);
	}

	ipw_led_shutdown(priv);

	/* Wait up to 1s for status to change to not scanning and not
	 * associated (disassociation can take a while for a ful 802.11
	 * exchange */
	for (i = 1000; i && (priv->status &
			     (STATUS_DISASSOCIATING |
			      STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
		udelay(10);

	if (priv->status & (STATUS_DISASSOCIATING |
			    STATUS_ASSOCIATED | STATUS_SCANNING))
		IPW_DEBUG_INFO("Still associated or scanning...\n");
	else
		IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);

11273
	/* Attempt to disable the card */
J
James Ketrenos 已提交
11274
	ipw_send_card_disable(priv, 0);
11275 11276 11277 11278 11279 11280 11281 11282 11283 11284 11285 11286 11287 11288 11289 11290 11291

	priv->status &= ~STATUS_INIT;
}

static void ipw_down(struct ipw_priv *priv)
{
	int exit_pending = priv->status & STATUS_EXIT_PENDING;

	priv->status |= STATUS_EXIT_PENDING;

	if (ipw_is_init(priv))
		ipw_deinit(priv);

	/* Wipe out the EXIT_PENDING status bit if we are not actually
	 * exiting the module */
	if (!exit_pending)
		priv->status &= ~STATUS_EXIT_PENDING;
J
James Ketrenos 已提交
11292 11293 11294 11295 11296

	/* tell the device to stop sending interrupts */
	ipw_disable_interrupts(priv);

	/* Clear all bits but the RF Kill */
11297
	priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
J
James Ketrenos 已提交
11298 11299 11300 11301
	netif_carrier_off(priv->net_dev);
	netif_stop_queue(priv->net_dev);

	ipw_stop_nic(priv);
11302 11303

	ipw_led_radio_off(priv);
J
James Ketrenos 已提交
11304 11305
}

11306 11307 11308 11309 11310 11311 11312 11313
static void ipw_bg_down(void *data)
{
	struct ipw_priv *priv = data;
	down(&priv->sem);
	ipw_down(data);
	up(&priv->sem);
}

11314
#if WIRELESS_EXT < 18
11315 11316 11317 11318 11319 11320 11321 11322 11323 11324 11325 11326 11327 11328 11329
static int ipw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
	struct iwreq *wrq = (struct iwreq *)rq;
	int ret = -1;
	switch (cmd) {
	case IPW_IOCTL_WPA_SUPPLICANT:
		ret = ipw_wpa_supplicant(dev, &wrq->u.data);
		return ret;

	default:
		return -EOPNOTSUPP;
	}

	return -EOPNOTSUPP;
}
11330
#endif
11331

J
James Ketrenos 已提交
11332 11333 11334 11335
/* Called by register_netdev() */
static int ipw_net_init(struct net_device *dev)
{
	struct ipw_priv *priv = ieee80211_priv(dev);
11336
	down(&priv->sem);
J
James Ketrenos 已提交
11337

11338 11339
	if (ipw_up(priv)) {
		up(&priv->sem);
J
James Ketrenos 已提交
11340
		return -EIO;
11341
	}
J
James Ketrenos 已提交
11342

11343
	up(&priv->sem);
J
James Ketrenos 已提交
11344 11345 11346 11347 11348 11349 11350 11351 11352 11353 11354 11355 11356 11357 11358 11359 11360 11361 11362 11363 11364 11365 11366
	return 0;
}

/* PCI driver stuff */
static struct pci_device_id card_ids[] = {
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
	{PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
11367
	{PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},	/* BG */
11368
	{PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},	/* BG */
11369 11370
	{PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},	/* ABG */
	{PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},	/* ABG */
11371

J
James Ketrenos 已提交
11372 11373 11374 11375 11376 11377 11378 11379 11380 11381 11382 11383 11384 11385 11386 11387
	/* required last entry */
	{0,}
};

MODULE_DEVICE_TABLE(pci, card_ids);

static struct attribute *ipw_sysfs_entries[] = {
	&dev_attr_rf_kill.attr,
	&dev_attr_direct_dword.attr,
	&dev_attr_indirect_byte.attr,
	&dev_attr_indirect_dword.attr,
	&dev_attr_mem_gpio_reg.attr,
	&dev_attr_command_event_reg.attr,
	&dev_attr_nic_type.attr,
	&dev_attr_status.attr,
	&dev_attr_cfg.attr,
11388 11389
	&dev_attr_error.attr,
	&dev_attr_event_log.attr,
11390
	&dev_attr_cmd_log.attr,
J
James Ketrenos 已提交
11391 11392 11393
	&dev_attr_eeprom_delay.attr,
	&dev_attr_ucode_version.attr,
	&dev_attr_rtc.attr,
11394 11395
	&dev_attr_scan_age.attr,
	&dev_attr_led.attr,
11396 11397
	&dev_attr_speed_scan.attr,
	&dev_attr_net_stats.attr,
J
James Ketrenos 已提交
11398 11399 11400 11401 11402
	NULL
};

static struct attribute_group ipw_attribute_group = {
	.name = NULL,		/* put in device directory */
11403
	.attrs = ipw_sysfs_entries,
J
James Ketrenos 已提交
11404 11405
};

11406
static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
J
James Ketrenos 已提交
11407 11408 11409 11410 11411 11412
{
	int err = 0;
	struct net_device *net_dev;
	void __iomem *base;
	u32 length, val;
	struct ipw_priv *priv;
11413
	int i;
J
James Ketrenos 已提交
11414 11415 11416 11417 11418 11419 11420 11421 11422

	net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
	if (net_dev == NULL) {
		err = -ENOMEM;
		goto out;
	}

	priv = ieee80211_priv(net_dev);
	priv->ieee = netdev_priv(net_dev);
11423

J
James Ketrenos 已提交
11424 11425 11426 11427 11428 11429
	priv->net_dev = net_dev;
	priv->pci_dev = pdev;
#ifdef CONFIG_IPW_DEBUG
	ipw_debug_level = debug;
#endif
	spin_lock_init(&priv->lock);
11430 11431
	for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
		INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
J
James Ketrenos 已提交
11432

11433
	init_MUTEX(&priv->sem);
J
James Ketrenos 已提交
11434 11435 11436 11437 11438 11439 11440
	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_free_ieee80211;
	}

	pci_set_master(pdev);

11441
	err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
11442
	if (!err)
11443
		err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
J
James Ketrenos 已提交
11444 11445 11446 11447 11448 11449 11450 11451
	if (err) {
		printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
		goto out_pci_disable_device;
	}

	pci_set_drvdata(pdev, priv);

	err = pci_request_regions(pdev, DRV_NAME);
11452
	if (err)
J
James Ketrenos 已提交
11453 11454
		goto out_pci_disable_device;

11455
	/* We disable the RETRY_TIMEOUT register (0x41) to keep
J
James Ketrenos 已提交
11456
	 * PCI Tx retries from interfering with C3 CPU state */
11457 11458
	pci_read_config_dword(pdev, 0x40, &val);
	if ((val & 0x0000ff00) != 0)
J
James Ketrenos 已提交
11459
		pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11460

J
James Ketrenos 已提交
11461 11462
	length = pci_resource_len(pdev, 0);
	priv->hw_len = length;
11463

J
James Ketrenos 已提交
11464 11465 11466 11467 11468 11469 11470 11471 11472 11473 11474 11475 11476 11477 11478 11479
	base = ioremap_nocache(pci_resource_start(pdev, 0), length);
	if (!base) {
		err = -ENODEV;
		goto out_pci_release_regions;
	}

	priv->hw_base = base;
	IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
	IPW_DEBUG_INFO("pci_resource_base = %p\n", base);

	err = ipw_setup_deferred_work(priv);
	if (err) {
		IPW_ERROR("Unable to setup deferred work\n");
		goto out_iounmap;
	}

11480
	ipw_sw_reset(priv, 1);
J
James Ketrenos 已提交
11481

11482
	err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
J
James Ketrenos 已提交
11483 11484 11485 11486 11487 11488 11489 11490
	if (err) {
		IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
		goto out_destroy_workqueue;
	}

	SET_MODULE_OWNER(net_dev);
	SET_NETDEV_DEV(net_dev, &pdev->dev);

11491 11492 11493
	ipw_wx_data.spy_data = &priv->ieee->spy_data;
	ipw_wx_data.ieee80211 = priv->ieee;

11494 11495
	down(&priv->sem);

J
James Ketrenos 已提交
11496 11497
	priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
	priv->ieee->set_security = shim__set_security;
11498
	priv->ieee->is_queue_full = ipw_net_is_queue_full;
J
James Ketrenos 已提交
11499

11500
#ifdef CONFIG_IPW_QOS
11501 11502 11503
	priv->ieee->handle_probe_response = ipw_handle_beacon;
	priv->ieee->handle_beacon = ipw_handle_probe_response;
	priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11504 11505
#endif				/* CONFIG_IPW_QOS */

11506 11507 11508
	priv->ieee->perfect_rssi = -20;
	priv->ieee->worst_rssi = -85;

J
James Ketrenos 已提交
11509 11510 11511
	net_dev->open = ipw_net_open;
	net_dev->stop = ipw_net_stop;
	net_dev->init = ipw_net_init;
11512
#if WIRELESS_EXT < 18
11513
	net_dev->do_ioctl = ipw_ioctl;
11514
#endif
J
James Ketrenos 已提交
11515 11516 11517 11518
	net_dev->get_stats = ipw_net_get_stats;
	net_dev->set_multicast_list = ipw_net_set_multicast_list;
	net_dev->set_mac_address = ipw_net_set_mac_address;
	net_dev->get_wireless_stats = ipw_get_wireless_stats;
11519
	net_dev->wireless_data = &ipw_wx_data;
J
James Ketrenos 已提交
11520 11521 11522
	net_dev->wireless_handlers = &ipw_wx_handler_def;
	net_dev->ethtool_ops = &ipw_ethtool_ops;
	net_dev->irq = pdev->irq;
11523
	net_dev->base_addr = (unsigned long)priv->hw_base;
J
James Ketrenos 已提交
11524 11525 11526 11527 11528 11529
	net_dev->mem_start = pci_resource_start(pdev, 0);
	net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;

	err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
	if (err) {
		IPW_ERROR("failed to create sysfs device attributes\n");
11530
		up(&priv->sem);
J
James Ketrenos 已提交
11531 11532 11533
		goto out_release_irq;
	}

11534
	up(&priv->sem);
J
James Ketrenos 已提交
11535 11536 11537
	err = register_netdev(net_dev);
	if (err) {
		IPW_ERROR("failed to register network device\n");
11538
		goto out_remove_sysfs;
J
James Ketrenos 已提交
11539 11540 11541
	}
	return 0;

11542
      out_remove_sysfs:
J
James Ketrenos 已提交
11543
	sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11544
      out_release_irq:
J
James Ketrenos 已提交
11545
	free_irq(pdev->irq, priv);
11546
      out_destroy_workqueue:
J
James Ketrenos 已提交
11547 11548
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
11549
      out_iounmap:
J
James Ketrenos 已提交
11550
	iounmap(priv->hw_base);
11551
      out_pci_release_regions:
J
James Ketrenos 已提交
11552
	pci_release_regions(pdev);
11553
      out_pci_disable_device:
J
James Ketrenos 已提交
11554 11555
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);
11556
      out_free_ieee80211:
J
James Ketrenos 已提交
11557
	free_ieee80211(priv->net_dev);
11558
      out:
J
James Ketrenos 已提交
11559 11560 11561 11562 11563 11564
	return err;
}

static void ipw_pci_remove(struct pci_dev *pdev)
{
	struct ipw_priv *priv = pci_get_drvdata(pdev);
11565 11566
	struct list_head *p, *q;
	int i;
11567

J
James Ketrenos 已提交
11568 11569 11570
	if (!priv)
		return;

11571
	down(&priv->sem);
11572 11573

	priv->status |= STATUS_EXIT_PENDING;
J
James Ketrenos 已提交
11574
	ipw_down(priv);
11575
	sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11576

11577
	up(&priv->sem);
J
James Ketrenos 已提交
11578 11579 11580 11581 11582 11583 11584 11585 11586

	unregister_netdev(priv->net_dev);

	if (priv->rxq) {
		ipw_rx_queue_free(priv, priv->rxq);
		priv->rxq = NULL;
	}
	ipw_tx_queue_free(priv);

11587 11588 11589 11590
	if (priv->cmdlog) {
		kfree(priv->cmdlog);
		priv->cmdlog = NULL;
	}
J
James Ketrenos 已提交
11591 11592
	/* ipw_down will ensure that there is no more pending work
	 * in the workqueue's, so we can safely remove them now. */
11593 11594 11595 11596 11597 11598 11599
	cancel_delayed_work(&priv->adhoc_check);
	cancel_delayed_work(&priv->gather_stats);
	cancel_delayed_work(&priv->request_scan);
	cancel_delayed_work(&priv->rf_kill);
	cancel_delayed_work(&priv->scan_check);
	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;
J
James Ketrenos 已提交
11600

11601 11602 11603 11604 11605 11606 11607 11608
	/* Free MAC hash list for ADHOC */
	for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
		list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
			kfree(list_entry(p, struct ipw_ibss_seq, list));
			list_del(p);
		}
	}

11609 11610 11611 11612 11613
	if (priv->error) {
		ipw_free_error_log(priv->error);
		priv->error = NULL;
	}

J
James Ketrenos 已提交
11614 11615 11616 11617 11618 11619
	free_irq(pdev->irq, priv);
	iounmap(priv->hw_base);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);
	free_ieee80211(priv->net_dev);
11620
	free_firmware();
J
James Ketrenos 已提交
11621 11622 11623
}

#ifdef CONFIG_PM
11624
static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
J
James Ketrenos 已提交
11625 11626 11627 11628 11629 11630
{
	struct ipw_priv *priv = pci_get_drvdata(pdev);
	struct net_device *dev = priv->net_dev;

	printk(KERN_INFO "%s: Going into suspend...\n", dev->name);

11631
	/* Take down the device; powers it off, etc. */
J
James Ketrenos 已提交
11632 11633 11634 11635 11636 11637 11638
	ipw_down(priv);

	/* Remove the PRESENT state of the device */
	netif_device_detach(dev);

	pci_save_state(pdev);
	pci_disable_device(pdev);
11639
	pci_set_power_state(pdev, pci_choose_state(pdev, state));
11640

J
James Ketrenos 已提交
11641 11642 11643 11644 11645 11646 11647 11648
	return 0;
}

static int ipw_pci_resume(struct pci_dev *pdev)
{
	struct ipw_priv *priv = pci_get_drvdata(pdev);
	struct net_device *dev = priv->net_dev;
	u32 val;
11649

J
James Ketrenos 已提交
11650 11651
	printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);

11652
	pci_set_power_state(pdev, PCI_D0);
J
James Ketrenos 已提交
11653 11654
	pci_enable_device(pdev);
	pci_restore_state(pdev);
11655

J
James Ketrenos 已提交
11656 11657 11658 11659 11660 11661
	/*
	 * Suspend/Resume resets the PCI configuration space, so we have to
	 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
	 * from interfering with C3 CPU state. pci_restore_state won't help
	 * here since it only restores the first 64 bytes pci config header.
	 */
11662 11663
	pci_read_config_dword(pdev, 0x40, &val);
	if ((val & 0x0000ff00) != 0)
J
James Ketrenos 已提交
11664 11665 11666 11667 11668 11669 11670 11671
		pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);

	/* Set the device back into the PRESENT state; this will also wake
	 * the queue of needed */
	netif_device_attach(dev);

	/* Bring the device back up */
	queue_work(priv->workqueue, &priv->up);
11672

J
James Ketrenos 已提交
11673 11674 11675 11676 11677 11678 11679 11680 11681 11682 11683 11684 11685 11686 11687 11688 11689 11690 11691 11692 11693 11694 11695 11696 11697 11698 11699 11700 11701
	return 0;
}
#endif

/* driver initialization stuff */
static struct pci_driver ipw_driver = {
	.name = DRV_NAME,
	.id_table = card_ids,
	.probe = ipw_pci_probe,
	.remove = __devexit_p(ipw_pci_remove),
#ifdef CONFIG_PM
	.suspend = ipw_pci_suspend,
	.resume = ipw_pci_resume,
#endif
};

static int __init ipw_init(void)
{
	int ret;

	printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
	printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");

	ret = pci_module_init(&ipw_driver);
	if (ret) {
		IPW_ERROR("Unable to initialize PCI module\n");
		return ret;
	}

11702
	ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
J
James Ketrenos 已提交
11703 11704 11705 11706 11707 11708 11709 11710 11711 11712 11713 11714 11715 11716 11717 11718 11719 11720 11721 11722 11723 11724 11725 11726
	if (ret) {
		IPW_ERROR("Unable to create driver sysfs file\n");
		pci_unregister_driver(&ipw_driver);
		return ret;
	}

	return ret;
}

static void __exit ipw_exit(void)
{
	driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
	pci_unregister_driver(&ipw_driver);
}

module_param(disable, int, 0444);
MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");

module_param(associate, int, 0444);
MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");

module_param(auto_create, int, 0444);
MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");

11727
module_param(led, int, 0444);
11728
MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11729

J
James Ketrenos 已提交
11730 11731 11732 11733
module_param(debug, int, 0444);
MODULE_PARM_DESC(debug, "debug output mask");

module_param(channel, int, 0444);
11734
MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
J
James Ketrenos 已提交
11735

11736 11737 11738 11739 11740 11741 11742 11743 11744 11745 11746 11747 11748 11749 11750 11751 11752 11753
#ifdef CONFIG_IPW_QOS
module_param(qos_enable, int, 0444);
MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");

module_param(qos_burst_enable, int, 0444);
MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");

module_param(qos_no_ack_mask, int, 0444);
MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");

module_param(burst_duration_CCK, int, 0444);
MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");

module_param(burst_duration_OFDM, int, 0444);
MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
#endif				/* CONFIG_IPW_QOS */

#ifdef CONFIG_IPW2200_MONITOR
J
James Ketrenos 已提交
11754 11755 11756 11757 11758 11759 11760
module_param(mode, int, 0444);
MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
#else
module_param(mode, int, 0444);
MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
#endif

11761 11762 11763
module_param(hwcrypto, int, 0444);
MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default on)");

11764 11765 11766 11767
module_param(cmdlog, int, 0444);
MODULE_PARM_DESC(cmdlog,
		 "allocate a ring buffer for logging firmware commands");

J
James Ketrenos 已提交
11768 11769
module_exit(ipw_exit);
module_init(ipw_init);