1 /******************************************************************************
2 
3   Copyright(c) 2003 - 2006 Intel Corporation. All rights reserved.
4 
5   This program is free software; you can redistribute it and/or modify it
6   under the terms of version 2 of the GNU General Public License as
7   published by the Free Software Foundation.
8 
9   This program is distributed in the hope that it will be useful, but WITHOUT
10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12   more details.
13 
14   You should have received a copy of the GNU General Public License along with
15   this program; if not, write to the Free Software Foundation, Inc., 59
16   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17 
18   The full GNU General Public License is included in this distribution in the
19   file called LICENSE.
20 
21   Contact Information:
22   Intel Linux Wireless <ilw@linux.intel.com>
23   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
24 
25   Portions of this file are based on the sample_* files provided by Wireless
26   Extensions 0.26 package and copyright (c) 1997-2003 Jean Tourrilhes
27   <jt@hpl.hp.com>
28 
29   Portions of this file are based on the Host AP project,
30   Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
31     <j@w1.fi>
32   Copyright (c) 2002-2003, Jouni Malinen <j@w1.fi>
33 
34   Portions of ipw2100_mod_firmware_load, ipw2100_do_mod_firmware_load, and
35   ipw2100_fw_load are loosely based on drivers/sound/sound_firmware.c
36   available in the 2.4.25 kernel sources, and are copyright (c) Alan Cox
37 
38 ******************************************************************************/
39 /*
40 
41  Initial driver on which this is based was developed by Janusz Gorycki,
42  Maciej Urbaniak, and Maciej Sosnowski.
43 
44  Promiscuous mode support added by Jacek Wysoczynski and Maciej Urbaniak.
45 
46 Theory of Operation
47 
48 Tx - Commands and Data
49 
50 Firmware and host share a circular queue of Transmit Buffer Descriptors (TBDs)
51 Each TBD contains a pointer to the physical (dma_addr_t) address of data being
52 sent to the firmware as well as the length of the data.
53 
54 The host writes to the TBD queue at the WRITE index.  The WRITE index points
55 to the _next_ packet to be written and is advanced when after the TBD has been
56 filled.
57 
58 The firmware pulls from the TBD queue at the READ index.  The READ index points
59 to the currently being read entry, and is advanced once the firmware is
60 done with a packet.
61 
62 When data is sent to the firmware, the first TBD is used to indicate to the
63 firmware if a Command or Data is being sent.  If it is Command, all of the
64 command information is contained within the physical address referred to by the
65 TBD.  If it is Data, the first TBD indicates the type of data packet, number
66 of fragments, etc.  The next TBD then refers to the actual packet location.
67 
68 The Tx flow cycle is as follows:
69 
70 1) ipw2100_tx() is called by kernel with SKB to transmit
71 2) Packet is move from the tx_free_list and appended to the transmit pending
72    list (tx_pend_list)
73 3) work is scheduled to move pending packets into the shared circular queue.
74 4) when placing packet in the circular queue, the incoming SKB is DMA mapped
75    to a physical address.  That address is entered into a TBD.  Two TBDs are
76    filled out.  The first indicating a data packet, the second referring to the
77    actual payload data.
78 5) the packet is removed from tx_pend_list and placed on the end of the
79    firmware pending list (fw_pend_list)
80 6) firmware is notified that the WRITE index has
81 7) Once the firmware has processed the TBD, INTA is triggered.
82 8) For each Tx interrupt received from the firmware, the READ index is checked
83    to see which TBDs are done being processed.
84 9) For each TBD that has been processed, the ISR pulls the oldest packet
85    from the fw_pend_list.
86 10)The packet structure contained in the fw_pend_list is then used
87    to unmap the DMA address and to free the SKB originally passed to the driver
88    from the kernel.
89 11)The packet structure is placed onto the tx_free_list
90 
91 The above steps are the same for commands, only the msg_free_list/msg_pend_list
92 are used instead of tx_free_list/tx_pend_list
93 
94 ...
95 
96 Critical Sections / Locking :
97 
98 There are two locks utilized.  The first is the low level lock (priv->low_lock)
99 that protects the following:
100 
101 - Access to the Tx/Rx queue lists via priv->low_lock. The lists are as follows:
102 
103   tx_free_list : Holds pre-allocated Tx buffers.
104     TAIL modified in __ipw2100_tx_process()
105     HEAD modified in ipw2100_tx()
106 
107   tx_pend_list : Holds used Tx buffers waiting to go into the TBD ring
108     TAIL modified ipw2100_tx()
109     HEAD modified by ipw2100_tx_send_data()
110 
111   msg_free_list : Holds pre-allocated Msg (Command) buffers
112     TAIL modified in __ipw2100_tx_process()
113     HEAD modified in ipw2100_hw_send_command()
114 
115   msg_pend_list : Holds used Msg buffers waiting to go into the TBD ring
116     TAIL modified in ipw2100_hw_send_command()
117     HEAD modified in ipw2100_tx_send_commands()
118 
119   The flow of data on the TX side is as follows:
120 
121   MSG_FREE_LIST + COMMAND => MSG_PEND_LIST => TBD => MSG_FREE_LIST
122   TX_FREE_LIST + DATA => TX_PEND_LIST => TBD => TX_FREE_LIST
123 
124   The methods that work on the TBD ring are protected via priv->low_lock.
125 
126 - The internal data state of the device itself
127 - Access to the firmware read/write indexes for the BD queues
128   and associated logic
129 
130 All external entry functions are locked with the priv->action_lock to ensure
131 that only one external action is invoked at a time.
132 
133 
134 */
135 
136 #include <linux/compiler.h>
137 #include <linux/errno.h>
138 #include <linux/if_arp.h>
139 #include <linux/in6.h>
140 #include <linux/in.h>
141 #include <linux/ip.h>
142 #include <linux/kernel.h>
143 #include <linux/kmod.h>
144 #include <linux/module.h>
145 #include <linux/netdevice.h>
146 #include <linux/ethtool.h>
147 #include <linux/pci.h>
148 #include <linux/dma-mapping.h>
149 #include <linux/proc_fs.h>
150 #include <linux/skbuff.h>
151 #include <linux/uaccess.h>
152 #include <asm/io.h>
153 #include <linux/fs.h>
154 #include <linux/mm.h>
155 #include <linux/slab.h>
156 #include <linux/unistd.h>
157 #include <linux/stringify.h>
158 #include <linux/tcp.h>
159 #include <linux/types.h>
160 #include <linux/time.h>
161 #include <linux/firmware.h>
162 #include <linux/acpi.h>
163 #include <linux/ctype.h>
164 #include <linux/pm_qos.h>
165 
166 #include <net/lib80211.h>
167 
168 #include "ipw2100.h"
169 #include "ipw.h"
170 
171 #define IPW2100_VERSION "git-1.2.2"
172 
173 #define DRV_NAME	"ipw2100"
174 #define DRV_VERSION	IPW2100_VERSION
175 #define DRV_DESCRIPTION	"Intel(R) PRO/Wireless 2100 Network Driver"
176 #define DRV_COPYRIGHT	"Copyright(c) 2003-2006 Intel Corporation"
177 
178 static struct pm_qos_request ipw2100_pm_qos_req;
179 
180 /* Debugging stuff */
181 #ifdef CONFIG_IPW2100_DEBUG
182 #define IPW2100_RX_DEBUG	/* Reception debugging */
183 #endif
184 
185 MODULE_DESCRIPTION(DRV_DESCRIPTION);
186 MODULE_VERSION(DRV_VERSION);
187 MODULE_AUTHOR(DRV_COPYRIGHT);
188 MODULE_LICENSE("GPL");
189 
190 static int debug = 0;
191 static int network_mode = 0;
192 static int channel = 0;
193 static int associate = 0;
194 static int disable = 0;
195 #ifdef CONFIG_PM
196 static struct ipw2100_fw ipw2100_firmware;
197 #endif
198 
199 #include <linux/moduleparam.h>
200 module_param(debug, int, 0444);
201 module_param_named(mode, network_mode, int, 0444);
202 module_param(channel, int, 0444);
203 module_param(associate, int, 0444);
204 module_param(disable, int, 0444);
205 
206 MODULE_PARM_DESC(debug, "debug level");
207 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
208 MODULE_PARM_DESC(channel, "channel");
209 MODULE_PARM_DESC(associate, "auto associate when scanning (default off)");
210 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
211 
212 static u32 ipw2100_debug_level = IPW_DL_NONE;
213 
214 #ifdef CONFIG_IPW2100_DEBUG
215 #define IPW_DEBUG(level, message...) \
216 do { \
217 	if (ipw2100_debug_level & (level)) { \
218 		printk(KERN_DEBUG "ipw2100: %c %s ", \
219                        in_interrupt() ? 'I' : 'U',  __func__); \
220 		printk(message); \
221 	} \
222 } while (0)
223 #else
224 #define IPW_DEBUG(level, message...) do {} while (0)
225 #endif				/* CONFIG_IPW2100_DEBUG */
226 
227 #ifdef CONFIG_IPW2100_DEBUG
228 static const char *command_types[] = {
229 	"undefined",
230 	"unused",		/* HOST_ATTENTION */
231 	"HOST_COMPLETE",
232 	"unused",		/* SLEEP */
233 	"unused",		/* HOST_POWER_DOWN */
234 	"unused",
235 	"SYSTEM_CONFIG",
236 	"unused",		/* SET_IMR */
237 	"SSID",
238 	"MANDATORY_BSSID",
239 	"AUTHENTICATION_TYPE",
240 	"ADAPTER_ADDRESS",
241 	"PORT_TYPE",
242 	"INTERNATIONAL_MODE",
243 	"CHANNEL",
244 	"RTS_THRESHOLD",
245 	"FRAG_THRESHOLD",
246 	"POWER_MODE",
247 	"TX_RATES",
248 	"BASIC_TX_RATES",
249 	"WEP_KEY_INFO",
250 	"unused",
251 	"unused",
252 	"unused",
253 	"unused",
254 	"WEP_KEY_INDEX",
255 	"WEP_FLAGS",
256 	"ADD_MULTICAST",
257 	"CLEAR_ALL_MULTICAST",
258 	"BEACON_INTERVAL",
259 	"ATIM_WINDOW",
260 	"CLEAR_STATISTICS",
261 	"undefined",
262 	"undefined",
263 	"undefined",
264 	"undefined",
265 	"TX_POWER_INDEX",
266 	"undefined",
267 	"undefined",
268 	"undefined",
269 	"undefined",
270 	"undefined",
271 	"undefined",
272 	"BROADCAST_SCAN",
273 	"CARD_DISABLE",
274 	"PREFERRED_BSSID",
275 	"SET_SCAN_OPTIONS",
276 	"SCAN_DWELL_TIME",
277 	"SWEEP_TABLE",
278 	"AP_OR_STATION_TABLE",
279 	"GROUP_ORDINALS",
280 	"SHORT_RETRY_LIMIT",
281 	"LONG_RETRY_LIMIT",
282 	"unused",		/* SAVE_CALIBRATION */
283 	"unused",		/* RESTORE_CALIBRATION */
284 	"undefined",
285 	"undefined",
286 	"undefined",
287 	"HOST_PRE_POWER_DOWN",
288 	"unused",		/* HOST_INTERRUPT_COALESCING */
289 	"undefined",
290 	"CARD_DISABLE_PHY_OFF",
291 	"MSDU_TX_RATES",
292 	"undefined",
293 	"SET_STATION_STAT_BITS",
294 	"CLEAR_STATIONS_STAT_BITS",
295 	"LEAP_ROGUE_MODE",
296 	"SET_SECURITY_INFORMATION",
297 	"DISASSOCIATION_BSSID",
298 	"SET_WPA_ASS_IE"
299 };
300 #endif
301 
302 static const long ipw2100_frequencies[] = {
303 	2412, 2417, 2422, 2427,
304 	2432, 2437, 2442, 2447,
305 	2452, 2457, 2462, 2467,
306 	2472, 2484
307 };
308 
309 #define FREQ_COUNT	ARRAY_SIZE(ipw2100_frequencies)
310 
311 static struct ieee80211_rate ipw2100_bg_rates[] = {
312 	{ .bitrate = 10 },
313 	{ .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
314 	{ .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
315 	{ .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
316 };
317 
318 #define RATE_COUNT ARRAY_SIZE(ipw2100_bg_rates)
319 
320 /* Pre-decl until we get the code solid and then we can clean it up */
321 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv);
322 static void ipw2100_tx_send_data(struct ipw2100_priv *priv);
323 static int ipw2100_adapter_setup(struct ipw2100_priv *priv);
324 
325 static void ipw2100_queues_initialize(struct ipw2100_priv *priv);
326 static void ipw2100_queues_free(struct ipw2100_priv *priv);
327 static int ipw2100_queues_allocate(struct ipw2100_priv *priv);
328 
329 static int ipw2100_fw_download(struct ipw2100_priv *priv,
330 			       struct ipw2100_fw *fw);
331 static int ipw2100_get_firmware(struct ipw2100_priv *priv,
332 				struct ipw2100_fw *fw);
333 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf,
334 				 size_t max);
335 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf,
336 				    size_t max);
337 static void ipw2100_release_firmware(struct ipw2100_priv *priv,
338 				     struct ipw2100_fw *fw);
339 static int ipw2100_ucode_download(struct ipw2100_priv *priv,
340 				  struct ipw2100_fw *fw);
341 static void ipw2100_wx_event_work(struct work_struct *work);
342 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev);
343 static struct iw_handler_def ipw2100_wx_handler_def;
344 
345 static inline void read_register(struct net_device *dev, u32 reg, u32 * val)
346 {
347 	struct ipw2100_priv *priv = libipw_priv(dev);
348 
349 	*val = ioread32(priv->ioaddr + reg);
350 	IPW_DEBUG_IO("r: 0x%08X => 0x%08X\n", reg, *val);
351 }
352 
353 static inline void write_register(struct net_device *dev, u32 reg, u32 val)
354 {
355 	struct ipw2100_priv *priv = libipw_priv(dev);
356 
357 	iowrite32(val, priv->ioaddr + reg);
358 	IPW_DEBUG_IO("w: 0x%08X <= 0x%08X\n", reg, val);
359 }
360 
361 static inline void read_register_word(struct net_device *dev, u32 reg,
362 				      u16 * val)
363 {
364 	struct ipw2100_priv *priv = libipw_priv(dev);
365 
366 	*val = ioread16(priv->ioaddr + reg);
367 	IPW_DEBUG_IO("r: 0x%08X => %04X\n", reg, *val);
368 }
369 
370 static inline void read_register_byte(struct net_device *dev, u32 reg, u8 * val)
371 {
372 	struct ipw2100_priv *priv = libipw_priv(dev);
373 
374 	*val = ioread8(priv->ioaddr + reg);
375 	IPW_DEBUG_IO("r: 0x%08X => %02X\n", reg, *val);
376 }
377 
378 static inline void write_register_word(struct net_device *dev, u32 reg, u16 val)
379 {
380 	struct ipw2100_priv *priv = libipw_priv(dev);
381 
382 	iowrite16(val, priv->ioaddr + reg);
383 	IPW_DEBUG_IO("w: 0x%08X <= %04X\n", reg, val);
384 }
385 
386 static inline void write_register_byte(struct net_device *dev, u32 reg, u8 val)
387 {
388 	struct ipw2100_priv *priv = libipw_priv(dev);
389 
390 	iowrite8(val, priv->ioaddr + reg);
391 	IPW_DEBUG_IO("w: 0x%08X =< %02X\n", reg, val);
392 }
393 
394 static inline void read_nic_dword(struct net_device *dev, u32 addr, u32 * val)
395 {
396 	write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
397 		       addr & IPW_REG_INDIRECT_ADDR_MASK);
398 	read_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
399 }
400 
401 static inline void write_nic_dword(struct net_device *dev, u32 addr, u32 val)
402 {
403 	write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
404 		       addr & IPW_REG_INDIRECT_ADDR_MASK);
405 	write_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
406 }
407 
408 static inline void read_nic_word(struct net_device *dev, u32 addr, u16 * val)
409 {
410 	write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
411 		       addr & IPW_REG_INDIRECT_ADDR_MASK);
412 	read_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
413 }
414 
415 static inline void write_nic_word(struct net_device *dev, u32 addr, u16 val)
416 {
417 	write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
418 		       addr & IPW_REG_INDIRECT_ADDR_MASK);
419 	write_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
420 }
421 
422 static inline void read_nic_byte(struct net_device *dev, u32 addr, u8 * val)
423 {
424 	write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
425 		       addr & IPW_REG_INDIRECT_ADDR_MASK);
426 	read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
427 }
428 
429 static inline void write_nic_byte(struct net_device *dev, u32 addr, u8 val)
430 {
431 	write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
432 		       addr & IPW_REG_INDIRECT_ADDR_MASK);
433 	write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
434 }
435 
436 static inline void write_nic_auto_inc_address(struct net_device *dev, u32 addr)
437 {
438 	write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS,
439 		       addr & IPW_REG_INDIRECT_ADDR_MASK);
440 }
441 
442 static inline void write_nic_dword_auto_inc(struct net_device *dev, u32 val)
443 {
444 	write_register(dev, IPW_REG_AUTOINCREMENT_DATA, val);
445 }
446 
447 static void write_nic_memory(struct net_device *dev, u32 addr, u32 len,
448 				    const u8 * buf)
449 {
450 	u32 aligned_addr;
451 	u32 aligned_len;
452 	u32 dif_len;
453 	u32 i;
454 
455 	/* read first nibble byte by byte */
456 	aligned_addr = addr & (~0x3);
457 	dif_len = addr - aligned_addr;
458 	if (dif_len) {
459 		/* Start reading at aligned_addr + dif_len */
460 		write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
461 			       aligned_addr);
462 		for (i = dif_len; i < 4; i++, buf++)
463 			write_register_byte(dev,
464 					    IPW_REG_INDIRECT_ACCESS_DATA + i,
465 					    *buf);
466 
467 		len -= dif_len;
468 		aligned_addr += 4;
469 	}
470 
471 	/* read DWs through autoincrement registers */
472 	write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr);
473 	aligned_len = len & (~0x3);
474 	for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
475 		write_register(dev, IPW_REG_AUTOINCREMENT_DATA, *(u32 *) buf);
476 
477 	/* copy the last nibble */
478 	dif_len = len - aligned_len;
479 	write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr);
480 	for (i = 0; i < dif_len; i++, buf++)
481 		write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i,
482 				    *buf);
483 }
484 
485 static void read_nic_memory(struct net_device *dev, u32 addr, u32 len,
486 				   u8 * buf)
487 {
488 	u32 aligned_addr;
489 	u32 aligned_len;
490 	u32 dif_len;
491 	u32 i;
492 
493 	/* read first nibble byte by byte */
494 	aligned_addr = addr & (~0x3);
495 	dif_len = addr - aligned_addr;
496 	if (dif_len) {
497 		/* Start reading at aligned_addr + dif_len */
498 		write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
499 			       aligned_addr);
500 		for (i = dif_len; i < 4; i++, buf++)
501 			read_register_byte(dev,
502 					   IPW_REG_INDIRECT_ACCESS_DATA + i,
503 					   buf);
504 
505 		len -= dif_len;
506 		aligned_addr += 4;
507 	}
508 
509 	/* read DWs through autoincrement registers */
510 	write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr);
511 	aligned_len = len & (~0x3);
512 	for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
513 		read_register(dev, IPW_REG_AUTOINCREMENT_DATA, (u32 *) buf);
514 
515 	/* copy the last nibble */
516 	dif_len = len - aligned_len;
517 	write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr);
518 	for (i = 0; i < dif_len; i++, buf++)
519 		read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i, buf);
520 }
521 
522 static bool ipw2100_hw_is_adapter_in_system(struct net_device *dev)
523 {
524 	u32 dbg;
525 
526 	read_register(dev, IPW_REG_DOA_DEBUG_AREA_START, &dbg);
527 
528 	return dbg == IPW_DATA_DOA_DEBUG_VALUE;
529 }
530 
531 static int ipw2100_get_ordinal(struct ipw2100_priv *priv, u32 ord,
532 			       void *val, u32 * len)
533 {
534 	struct ipw2100_ordinals *ordinals = &priv->ordinals;
535 	u32 addr;
536 	u32 field_info;
537 	u16 field_len;
538 	u16 field_count;
539 	u32 total_length;
540 
541 	if (ordinals->table1_addr == 0) {
542 		printk(KERN_WARNING DRV_NAME ": attempt to use fw ordinals "
543 		       "before they have been loaded.\n");
544 		return -EINVAL;
545 	}
546 
547 	if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) {
548 		if (*len < IPW_ORD_TAB_1_ENTRY_SIZE) {
549 			*len = IPW_ORD_TAB_1_ENTRY_SIZE;
550 
551 			printk(KERN_WARNING DRV_NAME
552 			       ": ordinal buffer length too small, need %zd\n",
553 			       IPW_ORD_TAB_1_ENTRY_SIZE);
554 
555 			return -EINVAL;
556 		}
557 
558 		read_nic_dword(priv->net_dev,
559 			       ordinals->table1_addr + (ord << 2), &addr);
560 		read_nic_dword(priv->net_dev, addr, val);
561 
562 		*len = IPW_ORD_TAB_1_ENTRY_SIZE;
563 
564 		return 0;
565 	}
566 
567 	if (IS_ORDINAL_TABLE_TWO(ordinals, ord)) {
568 
569 		ord -= IPW_START_ORD_TAB_2;
570 
571 		/* get the address of statistic */
572 		read_nic_dword(priv->net_dev,
573 			       ordinals->table2_addr + (ord << 3), &addr);
574 
575 		/* get the second DW of statistics ;
576 		 * two 16-bit words - first is length, second is count */
577 		read_nic_dword(priv->net_dev,
578 			       ordinals->table2_addr + (ord << 3) + sizeof(u32),
579 			       &field_info);
580 
581 		/* get each entry length */
582 		field_len = *((u16 *) & field_info);
583 
584 		/* get number of entries */
585 		field_count = *(((u16 *) & field_info) + 1);
586 
587 		/* abort if no enough memory */
588 		total_length = field_len * field_count;
589 		if (total_length > *len) {
590 			*len = total_length;
591 			return -EINVAL;
592 		}
593 
594 		*len = total_length;
595 		if (!total_length)
596 			return 0;
597 
598 		/* read the ordinal data from the SRAM */
599 		read_nic_memory(priv->net_dev, addr, total_length, val);
600 
601 		return 0;
602 	}
603 
604 	printk(KERN_WARNING DRV_NAME ": ordinal %d neither in table 1 nor "
605 	       "in table 2\n", ord);
606 
607 	return -EINVAL;
608 }
609 
610 static int ipw2100_set_ordinal(struct ipw2100_priv *priv, u32 ord, u32 * val,
611 			       u32 * len)
612 {
613 	struct ipw2100_ordinals *ordinals = &priv->ordinals;
614 	u32 addr;
615 
616 	if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) {
617 		if (*len != IPW_ORD_TAB_1_ENTRY_SIZE) {
618 			*len = IPW_ORD_TAB_1_ENTRY_SIZE;
619 			IPW_DEBUG_INFO("wrong size\n");
620 			return -EINVAL;
621 		}
622 
623 		read_nic_dword(priv->net_dev,
624 			       ordinals->table1_addr + (ord << 2), &addr);
625 
626 		write_nic_dword(priv->net_dev, addr, *val);
627 
628 		*len = IPW_ORD_TAB_1_ENTRY_SIZE;
629 
630 		return 0;
631 	}
632 
633 	IPW_DEBUG_INFO("wrong table\n");
634 	if (IS_ORDINAL_TABLE_TWO(ordinals, ord))
635 		return -EINVAL;
636 
637 	return -EINVAL;
638 }
639 
640 static char *snprint_line(char *buf, size_t count,
641 			  const u8 * data, u32 len, u32 ofs)
642 {
643 	int out, i, j, l;
644 	char c;
645 
646 	out = snprintf(buf, count, "%08X", ofs);
647 
648 	for (l = 0, i = 0; i < 2; i++) {
649 		out += snprintf(buf + out, count - out, " ");
650 		for (j = 0; j < 8 && l < len; j++, l++)
651 			out += snprintf(buf + out, count - out, "%02X ",
652 					data[(i * 8 + j)]);
653 		for (; j < 8; j++)
654 			out += snprintf(buf + out, count - out, "   ");
655 	}
656 
657 	out += snprintf(buf + out, count - out, " ");
658 	for (l = 0, i = 0; i < 2; i++) {
659 		out += snprintf(buf + out, count - out, " ");
660 		for (j = 0; j < 8 && l < len; j++, l++) {
661 			c = data[(i * 8 + j)];
662 			if (!isascii(c) || !isprint(c))
663 				c = '.';
664 
665 			out += snprintf(buf + out, count - out, "%c", c);
666 		}
667 
668 		for (; j < 8; j++)
669 			out += snprintf(buf + out, count - out, " ");
670 	}
671 
672 	return buf;
673 }
674 
675 static void printk_buf(int level, const u8 * data, u32 len)
676 {
677 	char line[81];
678 	u32 ofs = 0;
679 	if (!(ipw2100_debug_level & level))
680 		return;
681 
682 	while (len) {
683 		printk(KERN_DEBUG "%s\n",
684 		       snprint_line(line, sizeof(line), &data[ofs],
685 				    min(len, 16U), ofs));
686 		ofs += 16;
687 		len -= min(len, 16U);
688 	}
689 }
690 
691 #define MAX_RESET_BACKOFF 10
692 
693 static void schedule_reset(struct ipw2100_priv *priv)
694 {
695 	unsigned long now = get_seconds();
696 
697 	/* If we haven't received a reset request within the backoff period,
698 	 * then we can reset the backoff interval so this reset occurs
699 	 * immediately */
700 	if (priv->reset_backoff &&
701 	    (now - priv->last_reset > priv->reset_backoff))
702 		priv->reset_backoff = 0;
703 
704 	priv->last_reset = get_seconds();
705 
706 	if (!(priv->status & STATUS_RESET_PENDING)) {
707 		IPW_DEBUG_INFO("%s: Scheduling firmware restart (%ds).\n",
708 			       priv->net_dev->name, priv->reset_backoff);
709 		netif_carrier_off(priv->net_dev);
710 		netif_stop_queue(priv->net_dev);
711 		priv->status |= STATUS_RESET_PENDING;
712 		if (priv->reset_backoff)
713 			schedule_delayed_work(&priv->reset_work,
714 					      priv->reset_backoff * HZ);
715 		else
716 			schedule_delayed_work(&priv->reset_work, 0);
717 
718 		if (priv->reset_backoff < MAX_RESET_BACKOFF)
719 			priv->reset_backoff++;
720 
721 		wake_up_interruptible(&priv->wait_command_queue);
722 	} else
723 		IPW_DEBUG_INFO("%s: Firmware restart already in progress.\n",
724 			       priv->net_dev->name);
725 
726 }
727 
728 #define HOST_COMPLETE_TIMEOUT (2 * HZ)
729 static int ipw2100_hw_send_command(struct ipw2100_priv *priv,
730 				   struct host_command *cmd)
731 {
732 	struct list_head *element;
733 	struct ipw2100_tx_packet *packet;
734 	unsigned long flags;
735 	int err = 0;
736 
737 	IPW_DEBUG_HC("Sending %s command (#%d), %d bytes\n",
738 		     command_types[cmd->host_command], cmd->host_command,
739 		     cmd->host_command_length);
740 	printk_buf(IPW_DL_HC, (u8 *) cmd->host_command_parameters,
741 		   cmd->host_command_length);
742 
743 	spin_lock_irqsave(&priv->low_lock, flags);
744 
745 	if (priv->fatal_error) {
746 		IPW_DEBUG_INFO
747 		    ("Attempt to send command while hardware in fatal error condition.\n");
748 		err = -EIO;
749 		goto fail_unlock;
750 	}
751 
752 	if (!(priv->status & STATUS_RUNNING)) {
753 		IPW_DEBUG_INFO
754 		    ("Attempt to send command while hardware is not running.\n");
755 		err = -EIO;
756 		goto fail_unlock;
757 	}
758 
759 	if (priv->status & STATUS_CMD_ACTIVE) {
760 		IPW_DEBUG_INFO
761 		    ("Attempt to send command while another command is pending.\n");
762 		err = -EBUSY;
763 		goto fail_unlock;
764 	}
765 
766 	if (list_empty(&priv->msg_free_list)) {
767 		IPW_DEBUG_INFO("no available msg buffers\n");
768 		goto fail_unlock;
769 	}
770 
771 	priv->status |= STATUS_CMD_ACTIVE;
772 	priv->messages_sent++;
773 
774 	element = priv->msg_free_list.next;
775 
776 	packet = list_entry(element, struct ipw2100_tx_packet, list);
777 	packet->jiffy_start = jiffies;
778 
779 	/* initialize the firmware command packet */
780 	packet->info.c_struct.cmd->host_command_reg = cmd->host_command;
781 	packet->info.c_struct.cmd->host_command_reg1 = cmd->host_command1;
782 	packet->info.c_struct.cmd->host_command_len_reg =
783 	    cmd->host_command_length;
784 	packet->info.c_struct.cmd->sequence = cmd->host_command_sequence;
785 
786 	memcpy(packet->info.c_struct.cmd->host_command_params_reg,
787 	       cmd->host_command_parameters,
788 	       sizeof(packet->info.c_struct.cmd->host_command_params_reg));
789 
790 	list_del(element);
791 	DEC_STAT(&priv->msg_free_stat);
792 
793 	list_add_tail(element, &priv->msg_pend_list);
794 	INC_STAT(&priv->msg_pend_stat);
795 
796 	ipw2100_tx_send_commands(priv);
797 	ipw2100_tx_send_data(priv);
798 
799 	spin_unlock_irqrestore(&priv->low_lock, flags);
800 
801 	/*
802 	 * We must wait for this command to complete before another
803 	 * command can be sent...  but if we wait more than 3 seconds
804 	 * then there is a problem.
805 	 */
806 
807 	err =
808 	    wait_event_interruptible_timeout(priv->wait_command_queue,
809 					     !(priv->
810 					       status & STATUS_CMD_ACTIVE),
811 					     HOST_COMPLETE_TIMEOUT);
812 
813 	if (err == 0) {
814 		IPW_DEBUG_INFO("Command completion failed out after %dms.\n",
815 			       1000 * (HOST_COMPLETE_TIMEOUT / HZ));
816 		priv->fatal_error = IPW2100_ERR_MSG_TIMEOUT;
817 		priv->status &= ~STATUS_CMD_ACTIVE;
818 		schedule_reset(priv);
819 		return -EIO;
820 	}
821 
822 	if (priv->fatal_error) {
823 		printk(KERN_WARNING DRV_NAME ": %s: firmware fatal error\n",
824 		       priv->net_dev->name);
825 		return -EIO;
826 	}
827 
828 	/* !!!!! HACK TEST !!!!!
829 	 * When lots of debug trace statements are enabled, the driver
830 	 * doesn't seem to have as many firmware restart cycles...
831 	 *
832 	 * As a test, we're sticking in a 1/100s delay here */
833 	schedule_timeout_uninterruptible(msecs_to_jiffies(10));
834 
835 	return 0;
836 
837       fail_unlock:
838 	spin_unlock_irqrestore(&priv->low_lock, flags);
839 
840 	return err;
841 }
842 
843 /*
844  * Verify the values and data access of the hardware
845  * No locks needed or used.  No functions called.
846  */
847 static int ipw2100_verify(struct ipw2100_priv *priv)
848 {
849 	u32 data1, data2;
850 	u32 address;
851 
852 	u32 val1 = 0x76543210;
853 	u32 val2 = 0xFEDCBA98;
854 
855 	/* Domain 0 check - all values should be DOA_DEBUG */
856 	for (address = IPW_REG_DOA_DEBUG_AREA_START;
857 	     address < IPW_REG_DOA_DEBUG_AREA_END; address += sizeof(u32)) {
858 		read_register(priv->net_dev, address, &data1);
859 		if (data1 != IPW_DATA_DOA_DEBUG_VALUE)
860 			return -EIO;
861 	}
862 
863 	/* Domain 1 check - use arbitrary read/write compare  */
864 	for (address = 0; address < 5; address++) {
865 		/* The memory area is not used now */
866 		write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32,
867 			       val1);
868 		write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36,
869 			       val2);
870 		read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32,
871 			      &data1);
872 		read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36,
873 			      &data2);
874 		if (val1 == data1 && val2 == data2)
875 			return 0;
876 	}
877 
878 	return -EIO;
879 }
880 
881 /*
882  *
883  * Loop until the CARD_DISABLED bit is the same value as the
884  * supplied parameter
885  *
886  * TODO: See if it would be more efficient to do a wait/wake
887  *       cycle and have the completion event trigger the wakeup
888  *
889  */
890 #define IPW_CARD_DISABLE_COMPLETE_WAIT		    100	// 100 milli
891 static int ipw2100_wait_for_card_state(struct ipw2100_priv *priv, int state)
892 {
893 	int i;
894 	u32 card_state;
895 	u32 len = sizeof(card_state);
896 	int err;
897 
898 	for (i = 0; i <= IPW_CARD_DISABLE_COMPLETE_WAIT * 1000; i += 50) {
899 		err = ipw2100_get_ordinal(priv, IPW_ORD_CARD_DISABLED,
900 					  &card_state, &len);
901 		if (err) {
902 			IPW_DEBUG_INFO("Query of CARD_DISABLED ordinal "
903 				       "failed.\n");
904 			return 0;
905 		}
906 
907 		/* We'll break out if either the HW state says it is
908 		 * in the state we want, or if HOST_COMPLETE command
909 		 * finishes */
910 		if ((card_state == state) ||
911 		    ((priv->status & STATUS_ENABLED) ?
912 		     IPW_HW_STATE_ENABLED : IPW_HW_STATE_DISABLED) == state) {
913 			if (state == IPW_HW_STATE_ENABLED)
914 				priv->status |= STATUS_ENABLED;
915 			else
916 				priv->status &= ~STATUS_ENABLED;
917 
918 			return 0;
919 		}
920 
921 		udelay(50);
922 	}
923 
924 	IPW_DEBUG_INFO("ipw2100_wait_for_card_state to %s state timed out\n",
925 		       state ? "DISABLED" : "ENABLED");
926 	return -EIO;
927 }
928 
929 /*********************************************************************
930     Procedure   :   sw_reset_and_clock
931     Purpose     :   Asserts s/w reset, asserts clock initialization
932                     and waits for clock stabilization
933  ********************************************************************/
934 static int sw_reset_and_clock(struct ipw2100_priv *priv)
935 {
936 	int i;
937 	u32 r;
938 
939 	// assert s/w reset
940 	write_register(priv->net_dev, IPW_REG_RESET_REG,
941 		       IPW_AUX_HOST_RESET_REG_SW_RESET);
942 
943 	// wait for clock stabilization
944 	for (i = 0; i < 1000; i++) {
945 		udelay(IPW_WAIT_RESET_ARC_COMPLETE_DELAY);
946 
947 		// check clock ready bit
948 		read_register(priv->net_dev, IPW_REG_RESET_REG, &r);
949 		if (r & IPW_AUX_HOST_RESET_REG_PRINCETON_RESET)
950 			break;
951 	}
952 
953 	if (i == 1000)
954 		return -EIO;	// TODO: better error value
955 
956 	/* set "initialization complete" bit to move adapter to
957 	 * D0 state */
958 	write_register(priv->net_dev, IPW_REG_GP_CNTRL,
959 		       IPW_AUX_HOST_GP_CNTRL_BIT_INIT_DONE);
960 
961 	/* wait for clock stabilization */
962 	for (i = 0; i < 10000; i++) {
963 		udelay(IPW_WAIT_CLOCK_STABILIZATION_DELAY * 4);
964 
965 		/* check clock ready bit */
966 		read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r);
967 		if (r & IPW_AUX_HOST_GP_CNTRL_BIT_CLOCK_READY)
968 			break;
969 	}
970 
971 	if (i == 10000)
972 		return -EIO;	/* TODO: better error value */
973 
974 	/* set D0 standby bit */
975 	read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r);
976 	write_register(priv->net_dev, IPW_REG_GP_CNTRL,
977 		       r | IPW_AUX_HOST_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
978 
979 	return 0;
980 }
981 
982 /*********************************************************************
983     Procedure   :   ipw2100_download_firmware
984     Purpose     :   Initiaze adapter after power on.
985                     The sequence is:
986                     1. assert s/w reset first!
987                     2. awake clocks & wait for clock stabilization
988                     3. hold ARC (don't ask me why...)
989                     4. load Dino ucode and reset/clock init again
990                     5. zero-out shared mem
991                     6. download f/w
992  *******************************************************************/
993 static int ipw2100_download_firmware(struct ipw2100_priv *priv)
994 {
995 	u32 address;
996 	int err;
997 
998 #ifndef CONFIG_PM
999 	/* Fetch the firmware and microcode */
1000 	struct ipw2100_fw ipw2100_firmware;
1001 #endif
1002 
1003 	if (priv->fatal_error) {
1004 		IPW_DEBUG_ERROR("%s: ipw2100_download_firmware called after "
1005 				"fatal error %d.  Interface must be brought down.\n",
1006 				priv->net_dev->name, priv->fatal_error);
1007 		return -EINVAL;
1008 	}
1009 #ifdef CONFIG_PM
1010 	if (!ipw2100_firmware.version) {
1011 		err = ipw2100_get_firmware(priv, &ipw2100_firmware);
1012 		if (err) {
1013 			IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n",
1014 					priv->net_dev->name, err);
1015 			priv->fatal_error = IPW2100_ERR_FW_LOAD;
1016 			goto fail;
1017 		}
1018 	}
1019 #else
1020 	err = ipw2100_get_firmware(priv, &ipw2100_firmware);
1021 	if (err) {
1022 		IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n",
1023 				priv->net_dev->name, err);
1024 		priv->fatal_error = IPW2100_ERR_FW_LOAD;
1025 		goto fail;
1026 	}
1027 #endif
1028 	priv->firmware_version = ipw2100_firmware.version;
1029 
1030 	/* s/w reset and clock stabilization */
1031 	err = sw_reset_and_clock(priv);
1032 	if (err) {
1033 		IPW_DEBUG_ERROR("%s: sw_reset_and_clock failed: %d\n",
1034 				priv->net_dev->name, err);
1035 		goto fail;
1036 	}
1037 
1038 	err = ipw2100_verify(priv);
1039 	if (err) {
1040 		IPW_DEBUG_ERROR("%s: ipw2100_verify failed: %d\n",
1041 				priv->net_dev->name, err);
1042 		goto fail;
1043 	}
1044 
1045 	/* Hold ARC */
1046 	write_nic_dword(priv->net_dev,
1047 			IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x80000000);
1048 
1049 	/* allow ARC to run */
1050 	write_register(priv->net_dev, IPW_REG_RESET_REG, 0);
1051 
1052 	/* load microcode */
1053 	err = ipw2100_ucode_download(priv, &ipw2100_firmware);
1054 	if (err) {
1055 		printk(KERN_ERR DRV_NAME ": %s: Error loading microcode: %d\n",
1056 		       priv->net_dev->name, err);
1057 		goto fail;
1058 	}
1059 
1060 	/* release ARC */
1061 	write_nic_dword(priv->net_dev,
1062 			IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x00000000);
1063 
1064 	/* s/w reset and clock stabilization (again!!!) */
1065 	err = sw_reset_and_clock(priv);
1066 	if (err) {
1067 		printk(KERN_ERR DRV_NAME
1068 		       ": %s: sw_reset_and_clock failed: %d\n",
1069 		       priv->net_dev->name, err);
1070 		goto fail;
1071 	}
1072 
1073 	/* load f/w */
1074 	err = ipw2100_fw_download(priv, &ipw2100_firmware);
1075 	if (err) {
1076 		IPW_DEBUG_ERROR("%s: Error loading firmware: %d\n",
1077 				priv->net_dev->name, err);
1078 		goto fail;
1079 	}
1080 #ifndef CONFIG_PM
1081 	/*
1082 	 * When the .resume method of the driver is called, the other
1083 	 * part of the system, i.e. the ide driver could still stay in
1084 	 * the suspend stage. This prevents us from loading the firmware
1085 	 * from the disk.  --YZ
1086 	 */
1087 
1088 	/* free any storage allocated for firmware image */
1089 	ipw2100_release_firmware(priv, &ipw2100_firmware);
1090 #endif
1091 
1092 	/* zero out Domain 1 area indirectly (Si requirement) */
1093 	for (address = IPW_HOST_FW_SHARED_AREA0;
1094 	     address < IPW_HOST_FW_SHARED_AREA0_END; address += 4)
1095 		write_nic_dword(priv->net_dev, address, 0);
1096 	for (address = IPW_HOST_FW_SHARED_AREA1;
1097 	     address < IPW_HOST_FW_SHARED_AREA1_END; address += 4)
1098 		write_nic_dword(priv->net_dev, address, 0);
1099 	for (address = IPW_HOST_FW_SHARED_AREA2;
1100 	     address < IPW_HOST_FW_SHARED_AREA2_END; address += 4)
1101 		write_nic_dword(priv->net_dev, address, 0);
1102 	for (address = IPW_HOST_FW_SHARED_AREA3;
1103 	     address < IPW_HOST_FW_SHARED_AREA3_END; address += 4)
1104 		write_nic_dword(priv->net_dev, address, 0);
1105 	for (address = IPW_HOST_FW_INTERRUPT_AREA;
1106 	     address < IPW_HOST_FW_INTERRUPT_AREA_END; address += 4)
1107 		write_nic_dword(priv->net_dev, address, 0);
1108 
1109 	return 0;
1110 
1111       fail:
1112 	ipw2100_release_firmware(priv, &ipw2100_firmware);
1113 	return err;
1114 }
1115 
1116 static inline void ipw2100_enable_interrupts(struct ipw2100_priv *priv)
1117 {
1118 	if (priv->status & STATUS_INT_ENABLED)
1119 		return;
1120 	priv->status |= STATUS_INT_ENABLED;
1121 	write_register(priv->net_dev, IPW_REG_INTA_MASK, IPW_INTERRUPT_MASK);
1122 }
1123 
1124 static inline void ipw2100_disable_interrupts(struct ipw2100_priv *priv)
1125 {
1126 	if (!(priv->status & STATUS_INT_ENABLED))
1127 		return;
1128 	priv->status &= ~STATUS_INT_ENABLED;
1129 	write_register(priv->net_dev, IPW_REG_INTA_MASK, 0x0);
1130 }
1131 
1132 static void ipw2100_initialize_ordinals(struct ipw2100_priv *priv)
1133 {
1134 	struct ipw2100_ordinals *ord = &priv->ordinals;
1135 
1136 	IPW_DEBUG_INFO("enter\n");
1137 
1138 	read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_1,
1139 		      &ord->table1_addr);
1140 
1141 	read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_2,
1142 		      &ord->table2_addr);
1143 
1144 	read_nic_dword(priv->net_dev, ord->table1_addr, &ord->table1_size);
1145 	read_nic_dword(priv->net_dev, ord->table2_addr, &ord->table2_size);
1146 
1147 	ord->table2_size &= 0x0000FFFF;
1148 
1149 	IPW_DEBUG_INFO("table 1 size: %d\n", ord->table1_size);
1150 	IPW_DEBUG_INFO("table 2 size: %d\n", ord->table2_size);
1151 	IPW_DEBUG_INFO("exit\n");
1152 }
1153 
1154 static inline void ipw2100_hw_set_gpio(struct ipw2100_priv *priv)
1155 {
1156 	u32 reg = 0;
1157 	/*
1158 	 * Set GPIO 3 writable by FW; GPIO 1 writable
1159 	 * by driver and enable clock
1160 	 */
1161 	reg = (IPW_BIT_GPIO_GPIO3_MASK | IPW_BIT_GPIO_GPIO1_ENABLE |
1162 	       IPW_BIT_GPIO_LED_OFF);
1163 	write_register(priv->net_dev, IPW_REG_GPIO, reg);
1164 }
1165 
1166 static int rf_kill_active(struct ipw2100_priv *priv)
1167 {
1168 #define MAX_RF_KILL_CHECKS 5
1169 #define RF_KILL_CHECK_DELAY 40
1170 
1171 	unsigned short value = 0;
1172 	u32 reg = 0;
1173 	int i;
1174 
1175 	if (!(priv->hw_features & HW_FEATURE_RFKILL)) {
1176 		wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
1177 		priv->status &= ~STATUS_RF_KILL_HW;
1178 		return 0;
1179 	}
1180 
1181 	for (i = 0; i < MAX_RF_KILL_CHECKS; i++) {
1182 		udelay(RF_KILL_CHECK_DELAY);
1183 		read_register(priv->net_dev, IPW_REG_GPIO, &reg);
1184 		value = (value << 1) | ((reg & IPW_BIT_GPIO_RF_KILL) ? 0 : 1);
1185 	}
1186 
1187 	if (value == 0) {
1188 		wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
1189 		priv->status |= STATUS_RF_KILL_HW;
1190 	} else {
1191 		wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
1192 		priv->status &= ~STATUS_RF_KILL_HW;
1193 	}
1194 
1195 	return (value == 0);
1196 }
1197 
1198 static int ipw2100_get_hw_features(struct ipw2100_priv *priv)
1199 {
1200 	u32 addr, len;
1201 	u32 val;
1202 
1203 	/*
1204 	 * EEPROM_SRAM_DB_START_ADDRESS using ordinal in ordinal table 1
1205 	 */
1206 	len = sizeof(addr);
1207 	if (ipw2100_get_ordinal
1208 	    (priv, IPW_ORD_EEPROM_SRAM_DB_BLOCK_START_ADDRESS, &addr, &len)) {
1209 		IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1210 			       __LINE__);
1211 		return -EIO;
1212 	}
1213 
1214 	IPW_DEBUG_INFO("EEPROM address: %08X\n", addr);
1215 
1216 	/*
1217 	 * EEPROM version is the byte at offset 0xfd in firmware
1218 	 * We read 4 bytes, then shift out the byte we actually want */
1219 	read_nic_dword(priv->net_dev, addr + 0xFC, &val);
1220 	priv->eeprom_version = (val >> 24) & 0xFF;
1221 	IPW_DEBUG_INFO("EEPROM version: %d\n", priv->eeprom_version);
1222 
1223 	/*
1224 	 *  HW RF Kill enable is bit 0 in byte at offset 0x21 in firmware
1225 	 *
1226 	 *  notice that the EEPROM bit is reverse polarity, i.e.
1227 	 *     bit = 0  signifies HW RF kill switch is supported
1228 	 *     bit = 1  signifies HW RF kill switch is NOT supported
1229 	 */
1230 	read_nic_dword(priv->net_dev, addr + 0x20, &val);
1231 	if (!((val >> 24) & 0x01))
1232 		priv->hw_features |= HW_FEATURE_RFKILL;
1233 
1234 	IPW_DEBUG_INFO("HW RF Kill: %ssupported.\n",
1235 		       (priv->hw_features & HW_FEATURE_RFKILL) ? "" : "not ");
1236 
1237 	return 0;
1238 }
1239 
1240 /*
1241  * Start firmware execution after power on and initialization
1242  * The sequence is:
1243  *  1. Release ARC
1244  *  2. Wait for f/w initialization completes;
1245  */
1246 static int ipw2100_start_adapter(struct ipw2100_priv *priv)
1247 {
1248 	int i;
1249 	u32 inta, inta_mask, gpio;
1250 
1251 	IPW_DEBUG_INFO("enter\n");
1252 
1253 	if (priv->status & STATUS_RUNNING)
1254 		return 0;
1255 
1256 	/*
1257 	 * Initialize the hw - drive adapter to DO state by setting
1258 	 * init_done bit. Wait for clk_ready bit and Download
1259 	 * fw & dino ucode
1260 	 */
1261 	if (ipw2100_download_firmware(priv)) {
1262 		printk(KERN_ERR DRV_NAME
1263 		       ": %s: Failed to power on the adapter.\n",
1264 		       priv->net_dev->name);
1265 		return -EIO;
1266 	}
1267 
1268 	/* Clear the Tx, Rx and Msg queues and the r/w indexes
1269 	 * in the firmware RBD and TBD ring queue */
1270 	ipw2100_queues_initialize(priv);
1271 
1272 	ipw2100_hw_set_gpio(priv);
1273 
1274 	/* TODO -- Look at disabling interrupts here to make sure none
1275 	 * get fired during FW initialization */
1276 
1277 	/* Release ARC - clear reset bit */
1278 	write_register(priv->net_dev, IPW_REG_RESET_REG, 0);
1279 
1280 	/* wait for f/w initialization complete */
1281 	IPW_DEBUG_FW("Waiting for f/w initialization to complete...\n");
1282 	i = 5000;
1283 	do {
1284 		schedule_timeout_uninterruptible(msecs_to_jiffies(40));
1285 		/* Todo... wait for sync command ... */
1286 
1287 		read_register(priv->net_dev, IPW_REG_INTA, &inta);
1288 
1289 		/* check "init done" bit */
1290 		if (inta & IPW2100_INTA_FW_INIT_DONE) {
1291 			/* reset "init done" bit */
1292 			write_register(priv->net_dev, IPW_REG_INTA,
1293 				       IPW2100_INTA_FW_INIT_DONE);
1294 			break;
1295 		}
1296 
1297 		/* check error conditions : we check these after the firmware
1298 		 * check so that if there is an error, the interrupt handler
1299 		 * will see it and the adapter will be reset */
1300 		if (inta &
1301 		    (IPW2100_INTA_FATAL_ERROR | IPW2100_INTA_PARITY_ERROR)) {
1302 			/* clear error conditions */
1303 			write_register(priv->net_dev, IPW_REG_INTA,
1304 				       IPW2100_INTA_FATAL_ERROR |
1305 				       IPW2100_INTA_PARITY_ERROR);
1306 		}
1307 	} while (--i);
1308 
1309 	/* Clear out any pending INTAs since we aren't supposed to have
1310 	 * interrupts enabled at this point... */
1311 	read_register(priv->net_dev, IPW_REG_INTA, &inta);
1312 	read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask);
1313 	inta &= IPW_INTERRUPT_MASK;
1314 	/* Clear out any pending interrupts */
1315 	if (inta & inta_mask)
1316 		write_register(priv->net_dev, IPW_REG_INTA, inta);
1317 
1318 	IPW_DEBUG_FW("f/w initialization complete: %s\n",
1319 		     i ? "SUCCESS" : "FAILED");
1320 
1321 	if (!i) {
1322 		printk(KERN_WARNING DRV_NAME
1323 		       ": %s: Firmware did not initialize.\n",
1324 		       priv->net_dev->name);
1325 		return -EIO;
1326 	}
1327 
1328 	/* allow firmware to write to GPIO1 & GPIO3 */
1329 	read_register(priv->net_dev, IPW_REG_GPIO, &gpio);
1330 
1331 	gpio |= (IPW_BIT_GPIO_GPIO1_MASK | IPW_BIT_GPIO_GPIO3_MASK);
1332 
1333 	write_register(priv->net_dev, IPW_REG_GPIO, gpio);
1334 
1335 	/* Ready to receive commands */
1336 	priv->status |= STATUS_RUNNING;
1337 
1338 	/* The adapter has been reset; we are not associated */
1339 	priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
1340 
1341 	IPW_DEBUG_INFO("exit\n");
1342 
1343 	return 0;
1344 }
1345 
1346 static inline void ipw2100_reset_fatalerror(struct ipw2100_priv *priv)
1347 {
1348 	if (!priv->fatal_error)
1349 		return;
1350 
1351 	priv->fatal_errors[priv->fatal_index++] = priv->fatal_error;
1352 	priv->fatal_index %= IPW2100_ERROR_QUEUE;
1353 	priv->fatal_error = 0;
1354 }
1355 
1356 /* NOTE: Our interrupt is disabled when this method is called */
1357 static int ipw2100_power_cycle_adapter(struct ipw2100_priv *priv)
1358 {
1359 	u32 reg;
1360 	int i;
1361 
1362 	IPW_DEBUG_INFO("Power cycling the hardware.\n");
1363 
1364 	ipw2100_hw_set_gpio(priv);
1365 
1366 	/* Step 1. Stop Master Assert */
1367 	write_register(priv->net_dev, IPW_REG_RESET_REG,
1368 		       IPW_AUX_HOST_RESET_REG_STOP_MASTER);
1369 
1370 	/* Step 2. Wait for stop Master Assert
1371 	 *         (not more than 50us, otherwise ret error */
1372 	i = 5;
1373 	do {
1374 		udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY);
1375 		read_register(priv->net_dev, IPW_REG_RESET_REG, &reg);
1376 
1377 		if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
1378 			break;
1379 	} while (--i);
1380 
1381 	priv->status &= ~STATUS_RESET_PENDING;
1382 
1383 	if (!i) {
1384 		IPW_DEBUG_INFO
1385 		    ("exit - waited too long for master assert stop\n");
1386 		return -EIO;
1387 	}
1388 
1389 	write_register(priv->net_dev, IPW_REG_RESET_REG,
1390 		       IPW_AUX_HOST_RESET_REG_SW_RESET);
1391 
1392 	/* Reset any fatal_error conditions */
1393 	ipw2100_reset_fatalerror(priv);
1394 
1395 	/* At this point, the adapter is now stopped and disabled */
1396 	priv->status &= ~(STATUS_RUNNING | STATUS_ASSOCIATING |
1397 			  STATUS_ASSOCIATED | STATUS_ENABLED);
1398 
1399 	return 0;
1400 }
1401 
1402 /*
1403  * Send the CARD_DISABLE_PHY_OFF command to the card to disable it
1404  *
1405  * After disabling, if the card was associated, a STATUS_ASSN_LOST will be sent.
1406  *
1407  * STATUS_CARD_DISABLE_NOTIFICATION will be sent regardless of
1408  * if STATUS_ASSN_LOST is sent.
1409  */
1410 static int ipw2100_hw_phy_off(struct ipw2100_priv *priv)
1411 {
1412 
1413 #define HW_PHY_OFF_LOOP_DELAY (msecs_to_jiffies(50))
1414 
1415 	struct host_command cmd = {
1416 		.host_command = CARD_DISABLE_PHY_OFF,
1417 		.host_command_sequence = 0,
1418 		.host_command_length = 0,
1419 	};
1420 	int err, i;
1421 	u32 val1, val2;
1422 
1423 	IPW_DEBUG_HC("CARD_DISABLE_PHY_OFF\n");
1424 
1425 	/* Turn off the radio */
1426 	err = ipw2100_hw_send_command(priv, &cmd);
1427 	if (err)
1428 		return err;
1429 
1430 	for (i = 0; i < 2500; i++) {
1431 		read_nic_dword(priv->net_dev, IPW2100_CONTROL_REG, &val1);
1432 		read_nic_dword(priv->net_dev, IPW2100_COMMAND, &val2);
1433 
1434 		if ((val1 & IPW2100_CONTROL_PHY_OFF) &&
1435 		    (val2 & IPW2100_COMMAND_PHY_OFF))
1436 			return 0;
1437 
1438 		schedule_timeout_uninterruptible(HW_PHY_OFF_LOOP_DELAY);
1439 	}
1440 
1441 	return -EIO;
1442 }
1443 
1444 static int ipw2100_enable_adapter(struct ipw2100_priv *priv)
1445 {
1446 	struct host_command cmd = {
1447 		.host_command = HOST_COMPLETE,
1448 		.host_command_sequence = 0,
1449 		.host_command_length = 0
1450 	};
1451 	int err = 0;
1452 
1453 	IPW_DEBUG_HC("HOST_COMPLETE\n");
1454 
1455 	if (priv->status & STATUS_ENABLED)
1456 		return 0;
1457 
1458 	mutex_lock(&priv->adapter_mutex);
1459 
1460 	if (rf_kill_active(priv)) {
1461 		IPW_DEBUG_HC("Command aborted due to RF kill active.\n");
1462 		goto fail_up;
1463 	}
1464 
1465 	err = ipw2100_hw_send_command(priv, &cmd);
1466 	if (err) {
1467 		IPW_DEBUG_INFO("Failed to send HOST_COMPLETE command\n");
1468 		goto fail_up;
1469 	}
1470 
1471 	err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_ENABLED);
1472 	if (err) {
1473 		IPW_DEBUG_INFO("%s: card not responding to init command.\n",
1474 			       priv->net_dev->name);
1475 		goto fail_up;
1476 	}
1477 
1478 	if (priv->stop_hang_check) {
1479 		priv->stop_hang_check = 0;
1480 		schedule_delayed_work(&priv->hang_check, HZ / 2);
1481 	}
1482 
1483       fail_up:
1484 	mutex_unlock(&priv->adapter_mutex);
1485 	return err;
1486 }
1487 
1488 static int ipw2100_hw_stop_adapter(struct ipw2100_priv *priv)
1489 {
1490 #define HW_POWER_DOWN_DELAY (msecs_to_jiffies(100))
1491 
1492 	struct host_command cmd = {
1493 		.host_command = HOST_PRE_POWER_DOWN,
1494 		.host_command_sequence = 0,
1495 		.host_command_length = 0,
1496 	};
1497 	int err, i;
1498 	u32 reg;
1499 
1500 	if (!(priv->status & STATUS_RUNNING))
1501 		return 0;
1502 
1503 	priv->status |= STATUS_STOPPING;
1504 
1505 	/* We can only shut down the card if the firmware is operational.  So,
1506 	 * if we haven't reset since a fatal_error, then we can not send the
1507 	 * shutdown commands. */
1508 	if (!priv->fatal_error) {
1509 		/* First, make sure the adapter is enabled so that the PHY_OFF
1510 		 * command can shut it down */
1511 		ipw2100_enable_adapter(priv);
1512 
1513 		err = ipw2100_hw_phy_off(priv);
1514 		if (err)
1515 			printk(KERN_WARNING DRV_NAME
1516 			       ": Error disabling radio %d\n", err);
1517 
1518 		/*
1519 		 * If in D0-standby mode going directly to D3 may cause a
1520 		 * PCI bus violation.  Therefore we must change out of the D0
1521 		 * state.
1522 		 *
1523 		 * Sending the PREPARE_FOR_POWER_DOWN will restrict the
1524 		 * hardware from going into standby mode and will transition
1525 		 * out of D0-standby if it is already in that state.
1526 		 *
1527 		 * STATUS_PREPARE_POWER_DOWN_COMPLETE will be sent by the
1528 		 * driver upon completion.  Once received, the driver can
1529 		 * proceed to the D3 state.
1530 		 *
1531 		 * Prepare for power down command to fw.  This command would
1532 		 * take HW out of D0-standby and prepare it for D3 state.
1533 		 *
1534 		 * Currently FW does not support event notification for this
1535 		 * event. Therefore, skip waiting for it.  Just wait a fixed
1536 		 * 100ms
1537 		 */
1538 		IPW_DEBUG_HC("HOST_PRE_POWER_DOWN\n");
1539 
1540 		err = ipw2100_hw_send_command(priv, &cmd);
1541 		if (err)
1542 			printk(KERN_WARNING DRV_NAME ": "
1543 			       "%s: Power down command failed: Error %d\n",
1544 			       priv->net_dev->name, err);
1545 		else
1546 			schedule_timeout_uninterruptible(HW_POWER_DOWN_DELAY);
1547 	}
1548 
1549 	priv->status &= ~STATUS_ENABLED;
1550 
1551 	/*
1552 	 * Set GPIO 3 writable by FW; GPIO 1 writable
1553 	 * by driver and enable clock
1554 	 */
1555 	ipw2100_hw_set_gpio(priv);
1556 
1557 	/*
1558 	 * Power down adapter.  Sequence:
1559 	 * 1. Stop master assert (RESET_REG[9]=1)
1560 	 * 2. Wait for stop master (RESET_REG[8]==1)
1561 	 * 3. S/w reset assert (RESET_REG[7] = 1)
1562 	 */
1563 
1564 	/* Stop master assert */
1565 	write_register(priv->net_dev, IPW_REG_RESET_REG,
1566 		       IPW_AUX_HOST_RESET_REG_STOP_MASTER);
1567 
1568 	/* wait stop master not more than 50 usec.
1569 	 * Otherwise return error. */
1570 	for (i = 5; i > 0; i--) {
1571 		udelay(10);
1572 
1573 		/* Check master stop bit */
1574 		read_register(priv->net_dev, IPW_REG_RESET_REG, &reg);
1575 
1576 		if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
1577 			break;
1578 	}
1579 
1580 	if (i == 0)
1581 		printk(KERN_WARNING DRV_NAME
1582 		       ": %s: Could now power down adapter.\n",
1583 		       priv->net_dev->name);
1584 
1585 	/* assert s/w reset */
1586 	write_register(priv->net_dev, IPW_REG_RESET_REG,
1587 		       IPW_AUX_HOST_RESET_REG_SW_RESET);
1588 
1589 	priv->status &= ~(STATUS_RUNNING | STATUS_STOPPING);
1590 
1591 	return 0;
1592 }
1593 
1594 static int ipw2100_disable_adapter(struct ipw2100_priv *priv)
1595 {
1596 	struct host_command cmd = {
1597 		.host_command = CARD_DISABLE,
1598 		.host_command_sequence = 0,
1599 		.host_command_length = 0
1600 	};
1601 	int err = 0;
1602 
1603 	IPW_DEBUG_HC("CARD_DISABLE\n");
1604 
1605 	if (!(priv->status & STATUS_ENABLED))
1606 		return 0;
1607 
1608 	/* Make sure we clear the associated state */
1609 	priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1610 
1611 	if (!priv->stop_hang_check) {
1612 		priv->stop_hang_check = 1;
1613 		cancel_delayed_work(&priv->hang_check);
1614 	}
1615 
1616 	mutex_lock(&priv->adapter_mutex);
1617 
1618 	err = ipw2100_hw_send_command(priv, &cmd);
1619 	if (err) {
1620 		printk(KERN_WARNING DRV_NAME
1621 		       ": exit - failed to send CARD_DISABLE command\n");
1622 		goto fail_up;
1623 	}
1624 
1625 	err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_DISABLED);
1626 	if (err) {
1627 		printk(KERN_WARNING DRV_NAME
1628 		       ": exit - card failed to change to DISABLED\n");
1629 		goto fail_up;
1630 	}
1631 
1632 	IPW_DEBUG_INFO("TODO: implement scan state machine\n");
1633 
1634       fail_up:
1635 	mutex_unlock(&priv->adapter_mutex);
1636 	return err;
1637 }
1638 
1639 static int ipw2100_set_scan_options(struct ipw2100_priv *priv)
1640 {
1641 	struct host_command cmd = {
1642 		.host_command = SET_SCAN_OPTIONS,
1643 		.host_command_sequence = 0,
1644 		.host_command_length = 8
1645 	};
1646 	int err;
1647 
1648 	IPW_DEBUG_INFO("enter\n");
1649 
1650 	IPW_DEBUG_SCAN("setting scan options\n");
1651 
1652 	cmd.host_command_parameters[0] = 0;
1653 
1654 	if (!(priv->config & CFG_ASSOCIATE))
1655 		cmd.host_command_parameters[0] |= IPW_SCAN_NOASSOCIATE;
1656 	if ((priv->ieee->sec.flags & SEC_ENABLED) && priv->ieee->sec.enabled)
1657 		cmd.host_command_parameters[0] |= IPW_SCAN_MIXED_CELL;
1658 	if (priv->config & CFG_PASSIVE_SCAN)
1659 		cmd.host_command_parameters[0] |= IPW_SCAN_PASSIVE;
1660 
1661 	cmd.host_command_parameters[1] = priv->channel_mask;
1662 
1663 	err = ipw2100_hw_send_command(priv, &cmd);
1664 
1665 	IPW_DEBUG_HC("SET_SCAN_OPTIONS 0x%04X\n",
1666 		     cmd.host_command_parameters[0]);
1667 
1668 	return err;
1669 }
1670 
1671 static int ipw2100_start_scan(struct ipw2100_priv *priv)
1672 {
1673 	struct host_command cmd = {
1674 		.host_command = BROADCAST_SCAN,
1675 		.host_command_sequence = 0,
1676 		.host_command_length = 4
1677 	};
1678 	int err;
1679 
1680 	IPW_DEBUG_HC("START_SCAN\n");
1681 
1682 	cmd.host_command_parameters[0] = 0;
1683 
1684 	/* No scanning if in monitor mode */
1685 	if (priv->ieee->iw_mode == IW_MODE_MONITOR)
1686 		return 1;
1687 
1688 	if (priv->status & STATUS_SCANNING) {
1689 		IPW_DEBUG_SCAN("Scan requested while already in scan...\n");
1690 		return 0;
1691 	}
1692 
1693 	IPW_DEBUG_INFO("enter\n");
1694 
1695 	/* Not clearing here; doing so makes iwlist always return nothing...
1696 	 *
1697 	 * We should modify the table logic to use aging tables vs. clearing
1698 	 * the table on each scan start.
1699 	 */
1700 	IPW_DEBUG_SCAN("starting scan\n");
1701 
1702 	priv->status |= STATUS_SCANNING;
1703 	err = ipw2100_hw_send_command(priv, &cmd);
1704 	if (err)
1705 		priv->status &= ~STATUS_SCANNING;
1706 
1707 	IPW_DEBUG_INFO("exit\n");
1708 
1709 	return err;
1710 }
1711 
1712 static const struct libipw_geo ipw_geos[] = {
1713 	{			/* Restricted */
1714 	 "---",
1715 	 .bg_channels = 14,
1716 	 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
1717 		{2427, 4}, {2432, 5}, {2437, 6},
1718 		{2442, 7}, {2447, 8}, {2452, 9},
1719 		{2457, 10}, {2462, 11}, {2467, 12},
1720 		{2472, 13}, {2484, 14}},
1721 	 },
1722 };
1723 
1724 static int ipw2100_up(struct ipw2100_priv *priv, int deferred)
1725 {
1726 	unsigned long flags;
1727 	int rc = 0;
1728 	u32 lock;
1729 	u32 ord_len = sizeof(lock);
1730 
1731 	/* Age scan list entries found before suspend */
1732 	if (priv->suspend_time) {
1733 		libipw_networks_age(priv->ieee, priv->suspend_time);
1734 		priv->suspend_time = 0;
1735 	}
1736 
1737 	/* Quiet if manually disabled. */
1738 	if (priv->status & STATUS_RF_KILL_SW) {
1739 		IPW_DEBUG_INFO("%s: Radio is disabled by Manual Disable "
1740 			       "switch\n", priv->net_dev->name);
1741 		return 0;
1742 	}
1743 
1744 	/* the ipw2100 hardware really doesn't want power management delays
1745 	 * longer than 175usec
1746 	 */
1747 	pm_qos_update_request(&ipw2100_pm_qos_req, 175);
1748 
1749 	/* If the interrupt is enabled, turn it off... */
1750 	spin_lock_irqsave(&priv->low_lock, flags);
1751 	ipw2100_disable_interrupts(priv);
1752 
1753 	/* Reset any fatal_error conditions */
1754 	ipw2100_reset_fatalerror(priv);
1755 	spin_unlock_irqrestore(&priv->low_lock, flags);
1756 
1757 	if (priv->status & STATUS_POWERED ||
1758 	    (priv->status & STATUS_RESET_PENDING)) {
1759 		/* Power cycle the card ... */
1760 		if (ipw2100_power_cycle_adapter(priv)) {
1761 			printk(KERN_WARNING DRV_NAME
1762 			       ": %s: Could not cycle adapter.\n",
1763 			       priv->net_dev->name);
1764 			rc = 1;
1765 			goto exit;
1766 		}
1767 	} else
1768 		priv->status |= STATUS_POWERED;
1769 
1770 	/* Load the firmware, start the clocks, etc. */
1771 	if (ipw2100_start_adapter(priv)) {
1772 		printk(KERN_ERR DRV_NAME
1773 		       ": %s: Failed to start the firmware.\n",
1774 		       priv->net_dev->name);
1775 		rc = 1;
1776 		goto exit;
1777 	}
1778 
1779 	ipw2100_initialize_ordinals(priv);
1780 
1781 	/* Determine capabilities of this particular HW configuration */
1782 	if (ipw2100_get_hw_features(priv)) {
1783 		printk(KERN_ERR DRV_NAME
1784 		       ": %s: Failed to determine HW features.\n",
1785 		       priv->net_dev->name);
1786 		rc = 1;
1787 		goto exit;
1788 	}
1789 
1790 	/* Initialize the geo */
1791 	libipw_set_geo(priv->ieee, &ipw_geos[0]);
1792 	priv->ieee->freq_band = LIBIPW_24GHZ_BAND;
1793 
1794 	lock = LOCK_NONE;
1795 	if (ipw2100_set_ordinal(priv, IPW_ORD_PERS_DB_LOCK, &lock, &ord_len)) {
1796 		printk(KERN_ERR DRV_NAME
1797 		       ": %s: Failed to clear ordinal lock.\n",
1798 		       priv->net_dev->name);
1799 		rc = 1;
1800 		goto exit;
1801 	}
1802 
1803 	priv->status &= ~STATUS_SCANNING;
1804 
1805 	if (rf_kill_active(priv)) {
1806 		printk(KERN_INFO "%s: Radio is disabled by RF switch.\n",
1807 		       priv->net_dev->name);
1808 
1809 		if (priv->stop_rf_kill) {
1810 			priv->stop_rf_kill = 0;
1811 			schedule_delayed_work(&priv->rf_kill,
1812 					      round_jiffies_relative(HZ));
1813 		}
1814 
1815 		deferred = 1;
1816 	}
1817 
1818 	/* Turn on the interrupt so that commands can be processed */
1819 	ipw2100_enable_interrupts(priv);
1820 
1821 	/* Send all of the commands that must be sent prior to
1822 	 * HOST_COMPLETE */
1823 	if (ipw2100_adapter_setup(priv)) {
1824 		printk(KERN_ERR DRV_NAME ": %s: Failed to start the card.\n",
1825 		       priv->net_dev->name);
1826 		rc = 1;
1827 		goto exit;
1828 	}
1829 
1830 	if (!deferred) {
1831 		/* Enable the adapter - sends HOST_COMPLETE */
1832 		if (ipw2100_enable_adapter(priv)) {
1833 			printk(KERN_ERR DRV_NAME ": "
1834 			       "%s: failed in call to enable adapter.\n",
1835 			       priv->net_dev->name);
1836 			ipw2100_hw_stop_adapter(priv);
1837 			rc = 1;
1838 			goto exit;
1839 		}
1840 
1841 		/* Start a scan . . . */
1842 		ipw2100_set_scan_options(priv);
1843 		ipw2100_start_scan(priv);
1844 	}
1845 
1846       exit:
1847 	return rc;
1848 }
1849 
1850 static void ipw2100_down(struct ipw2100_priv *priv)
1851 {
1852 	unsigned long flags;
1853 	union iwreq_data wrqu = {
1854 		.ap_addr = {
1855 			    .sa_family = ARPHRD_ETHER}
1856 	};
1857 	int associated = priv->status & STATUS_ASSOCIATED;
1858 
1859 	/* Kill the RF switch timer */
1860 	if (!priv->stop_rf_kill) {
1861 		priv->stop_rf_kill = 1;
1862 		cancel_delayed_work(&priv->rf_kill);
1863 	}
1864 
1865 	/* Kill the firmware hang check timer */
1866 	if (!priv->stop_hang_check) {
1867 		priv->stop_hang_check = 1;
1868 		cancel_delayed_work(&priv->hang_check);
1869 	}
1870 
1871 	/* Kill any pending resets */
1872 	if (priv->status & STATUS_RESET_PENDING)
1873 		cancel_delayed_work(&priv->reset_work);
1874 
1875 	/* Make sure the interrupt is on so that FW commands will be
1876 	 * processed correctly */
1877 	spin_lock_irqsave(&priv->low_lock, flags);
1878 	ipw2100_enable_interrupts(priv);
1879 	spin_unlock_irqrestore(&priv->low_lock, flags);
1880 
1881 	if (ipw2100_hw_stop_adapter(priv))
1882 		printk(KERN_ERR DRV_NAME ": %s: Error stopping adapter.\n",
1883 		       priv->net_dev->name);
1884 
1885 	/* Do not disable the interrupt until _after_ we disable
1886 	 * the adaptor.  Otherwise the CARD_DISABLE command will never
1887 	 * be ack'd by the firmware */
1888 	spin_lock_irqsave(&priv->low_lock, flags);
1889 	ipw2100_disable_interrupts(priv);
1890 	spin_unlock_irqrestore(&priv->low_lock, flags);
1891 
1892 	pm_qos_update_request(&ipw2100_pm_qos_req, PM_QOS_DEFAULT_VALUE);
1893 
1894 	/* We have to signal any supplicant if we are disassociating */
1895 	if (associated)
1896 		wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1897 
1898 	priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1899 	netif_carrier_off(priv->net_dev);
1900 	netif_stop_queue(priv->net_dev);
1901 }
1902 
1903 static int ipw2100_wdev_init(struct net_device *dev)
1904 {
1905 	struct ipw2100_priv *priv = libipw_priv(dev);
1906 	const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
1907 	struct wireless_dev *wdev = &priv->ieee->wdev;
1908 	int i;
1909 
1910 	memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN);
1911 
1912 	/* fill-out priv->ieee->bg_band */
1913 	if (geo->bg_channels) {
1914 		struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band;
1915 
1916 		bg_band->band = NL80211_BAND_2GHZ;
1917 		bg_band->n_channels = geo->bg_channels;
1918 		bg_band->channels = kcalloc(geo->bg_channels,
1919 					    sizeof(struct ieee80211_channel),
1920 					    GFP_KERNEL);
1921 		if (!bg_band->channels) {
1922 			ipw2100_down(priv);
1923 			return -ENOMEM;
1924 		}
1925 		/* translate geo->bg to bg_band.channels */
1926 		for (i = 0; i < geo->bg_channels; i++) {
1927 			bg_band->channels[i].band = NL80211_BAND_2GHZ;
1928 			bg_band->channels[i].center_freq = geo->bg[i].freq;
1929 			bg_band->channels[i].hw_value = geo->bg[i].channel;
1930 			bg_band->channels[i].max_power = geo->bg[i].max_power;
1931 			if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY)
1932 				bg_band->channels[i].flags |=
1933 					IEEE80211_CHAN_NO_IR;
1934 			if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS)
1935 				bg_band->channels[i].flags |=
1936 					IEEE80211_CHAN_NO_IR;
1937 			if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)
1938 				bg_band->channels[i].flags |=
1939 					IEEE80211_CHAN_RADAR;
1940 			/* No equivalent for LIBIPW_CH_80211H_RULES,
1941 			   LIBIPW_CH_UNIFORM_SPREADING, or
1942 			   LIBIPW_CH_B_ONLY... */
1943 		}
1944 		/* point at bitrate info */
1945 		bg_band->bitrates = ipw2100_bg_rates;
1946 		bg_band->n_bitrates = RATE_COUNT;
1947 
1948 		wdev->wiphy->bands[NL80211_BAND_2GHZ] = bg_band;
1949 	}
1950 
1951 	wdev->wiphy->cipher_suites = ipw_cipher_suites;
1952 	wdev->wiphy->n_cipher_suites = ARRAY_SIZE(ipw_cipher_suites);
1953 
1954 	set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev);
1955 	if (wiphy_register(wdev->wiphy))
1956 		return -EIO;
1957 	return 0;
1958 }
1959 
1960 static void ipw2100_reset_adapter(struct work_struct *work)
1961 {
1962 	struct ipw2100_priv *priv =
1963 		container_of(work, struct ipw2100_priv, reset_work.work);
1964 	unsigned long flags;
1965 	union iwreq_data wrqu = {
1966 		.ap_addr = {
1967 			    .sa_family = ARPHRD_ETHER}
1968 	};
1969 	int associated = priv->status & STATUS_ASSOCIATED;
1970 
1971 	spin_lock_irqsave(&priv->low_lock, flags);
1972 	IPW_DEBUG_INFO(": %s: Restarting adapter.\n", priv->net_dev->name);
1973 	priv->resets++;
1974 	priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1975 	priv->status |= STATUS_SECURITY_UPDATED;
1976 
1977 	/* Force a power cycle even if interface hasn't been opened
1978 	 * yet */
1979 	cancel_delayed_work(&priv->reset_work);
1980 	priv->status |= STATUS_RESET_PENDING;
1981 	spin_unlock_irqrestore(&priv->low_lock, flags);
1982 
1983 	mutex_lock(&priv->action_mutex);
1984 	/* stop timed checks so that they don't interfere with reset */
1985 	priv->stop_hang_check = 1;
1986 	cancel_delayed_work(&priv->hang_check);
1987 
1988 	/* We have to signal any supplicant if we are disassociating */
1989 	if (associated)
1990 		wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1991 
1992 	ipw2100_up(priv, 0);
1993 	mutex_unlock(&priv->action_mutex);
1994 
1995 }
1996 
1997 static void isr_indicate_associated(struct ipw2100_priv *priv, u32 status)
1998 {
1999 
2000 #define MAC_ASSOCIATION_READ_DELAY (HZ)
2001 	int ret;
2002 	unsigned int len, essid_len;
2003 	char essid[IW_ESSID_MAX_SIZE];
2004 	u32 txrate;
2005 	u32 chan;
2006 	char *txratename;
2007 	u8 bssid[ETH_ALEN];
2008 
2009 	/*
2010 	 * TBD: BSSID is usually 00:00:00:00:00:00 here and not
2011 	 *      an actual MAC of the AP. Seems like FW sets this
2012 	 *      address too late. Read it later and expose through
2013 	 *      /proc or schedule a later task to query and update
2014 	 */
2015 
2016 	essid_len = IW_ESSID_MAX_SIZE;
2017 	ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID,
2018 				  essid, &essid_len);
2019 	if (ret) {
2020 		IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
2021 			       __LINE__);
2022 		return;
2023 	}
2024 
2025 	len = sizeof(u32);
2026 	ret = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &txrate, &len);
2027 	if (ret) {
2028 		IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
2029 			       __LINE__);
2030 		return;
2031 	}
2032 
2033 	len = sizeof(u32);
2034 	ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &len);
2035 	if (ret) {
2036 		IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
2037 			       __LINE__);
2038 		return;
2039 	}
2040 	len = ETH_ALEN;
2041 	ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, bssid,
2042 				  &len);
2043 	if (ret) {
2044 		IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
2045 			       __LINE__);
2046 		return;
2047 	}
2048 	memcpy(priv->ieee->bssid, bssid, ETH_ALEN);
2049 
2050 	switch (txrate) {
2051 	case TX_RATE_1_MBIT:
2052 		txratename = "1Mbps";
2053 		break;
2054 	case TX_RATE_2_MBIT:
2055 		txratename = "2Mbsp";
2056 		break;
2057 	case TX_RATE_5_5_MBIT:
2058 		txratename = "5.5Mbps";
2059 		break;
2060 	case TX_RATE_11_MBIT:
2061 		txratename = "11Mbps";
2062 		break;
2063 	default:
2064 		IPW_DEBUG_INFO("Unknown rate: %d\n", txrate);
2065 		txratename = "unknown rate";
2066 		break;
2067 	}
2068 
2069 	IPW_DEBUG_INFO("%s: Associated with '%*pE' at %s, channel %d (BSSID=%pM)\n",
2070 		       priv->net_dev->name, essid_len, essid,
2071 		       txratename, chan, bssid);
2072 
2073 	/* now we copy read ssid into dev */
2074 	if (!(priv->config & CFG_STATIC_ESSID)) {
2075 		priv->essid_len = min((u8) essid_len, (u8) IW_ESSID_MAX_SIZE);
2076 		memcpy(priv->essid, essid, priv->essid_len);
2077 	}
2078 	priv->channel = chan;
2079 	memcpy(priv->bssid, bssid, ETH_ALEN);
2080 
2081 	priv->status |= STATUS_ASSOCIATING;
2082 	priv->connect_start = get_seconds();
2083 
2084 	schedule_delayed_work(&priv->wx_event_work, HZ / 10);
2085 }
2086 
2087 static int ipw2100_set_essid(struct ipw2100_priv *priv, char *essid,
2088 			     int length, int batch_mode)
2089 {
2090 	int ssid_len = min(length, IW_ESSID_MAX_SIZE);
2091 	struct host_command cmd = {
2092 		.host_command = SSID,
2093 		.host_command_sequence = 0,
2094 		.host_command_length = ssid_len
2095 	};
2096 	int err;
2097 
2098 	IPW_DEBUG_HC("SSID: '%*pE'\n", ssid_len, essid);
2099 
2100 	if (ssid_len)
2101 		memcpy(cmd.host_command_parameters, essid, ssid_len);
2102 
2103 	if (!batch_mode) {
2104 		err = ipw2100_disable_adapter(priv);
2105 		if (err)
2106 			return err;
2107 	}
2108 
2109 	/* Bug in FW currently doesn't honor bit 0 in SET_SCAN_OPTIONS to
2110 	 * disable auto association -- so we cheat by setting a bogus SSID */
2111 	if (!ssid_len && !(priv->config & CFG_ASSOCIATE)) {
2112 		int i;
2113 		u8 *bogus = (u8 *) cmd.host_command_parameters;
2114 		for (i = 0; i < IW_ESSID_MAX_SIZE; i++)
2115 			bogus[i] = 0x18 + i;
2116 		cmd.host_command_length = IW_ESSID_MAX_SIZE;
2117 	}
2118 
2119 	/* NOTE:  We always send the SSID command even if the provided ESSID is
2120 	 * the same as what we currently think is set. */
2121 
2122 	err = ipw2100_hw_send_command(priv, &cmd);
2123 	if (!err) {
2124 		memset(priv->essid + ssid_len, 0, IW_ESSID_MAX_SIZE - ssid_len);
2125 		memcpy(priv->essid, essid, ssid_len);
2126 		priv->essid_len = ssid_len;
2127 	}
2128 
2129 	if (!batch_mode) {
2130 		if (ipw2100_enable_adapter(priv))
2131 			err = -EIO;
2132 	}
2133 
2134 	return err;
2135 }
2136 
2137 static void isr_indicate_association_lost(struct ipw2100_priv *priv, u32 status)
2138 {
2139 	IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
2140 		  "disassociated: '%*pE' %pM\n", priv->essid_len, priv->essid,
2141 		  priv->bssid);
2142 
2143 	priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
2144 
2145 	if (priv->status & STATUS_STOPPING) {
2146 		IPW_DEBUG_INFO("Card is stopping itself, discard ASSN_LOST.\n");
2147 		return;
2148 	}
2149 
2150 	eth_zero_addr(priv->bssid);
2151 	eth_zero_addr(priv->ieee->bssid);
2152 
2153 	netif_carrier_off(priv->net_dev);
2154 	netif_stop_queue(priv->net_dev);
2155 
2156 	if (!(priv->status & STATUS_RUNNING))
2157 		return;
2158 
2159 	if (priv->status & STATUS_SECURITY_UPDATED)
2160 		schedule_delayed_work(&priv->security_work, 0);
2161 
2162 	schedule_delayed_work(&priv->wx_event_work, 0);
2163 }
2164 
2165 static void isr_indicate_rf_kill(struct ipw2100_priv *priv, u32 status)
2166 {
2167 	IPW_DEBUG_INFO("%s: RF Kill state changed to radio OFF.\n",
2168 		       priv->net_dev->name);
2169 
2170 	/* RF_KILL is now enabled (else we wouldn't be here) */
2171 	wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
2172 	priv->status |= STATUS_RF_KILL_HW;
2173 
2174 	/* Make sure the RF Kill check timer is running */
2175 	priv->stop_rf_kill = 0;
2176 	mod_delayed_work(system_wq, &priv->rf_kill, round_jiffies_relative(HZ));
2177 }
2178 
2179 static void ipw2100_scan_event(struct work_struct *work)
2180 {
2181 	struct ipw2100_priv *priv = container_of(work, struct ipw2100_priv,
2182 						 scan_event.work);
2183 	union iwreq_data wrqu;
2184 
2185 	wrqu.data.length = 0;
2186 	wrqu.data.flags = 0;
2187 	wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
2188 }
2189 
2190 static void isr_scan_complete(struct ipw2100_priv *priv, u32 status)
2191 {
2192 	IPW_DEBUG_SCAN("scan complete\n");
2193 	/* Age the scan results... */
2194 	priv->ieee->scans++;
2195 	priv->status &= ~STATUS_SCANNING;
2196 
2197 	/* Only userspace-requested scan completion events go out immediately */
2198 	if (!priv->user_requested_scan) {
2199 		schedule_delayed_work(&priv->scan_event,
2200 				      round_jiffies_relative(msecs_to_jiffies(4000)));
2201 	} else {
2202 		priv->user_requested_scan = 0;
2203 		mod_delayed_work(system_wq, &priv->scan_event, 0);
2204 	}
2205 }
2206 
2207 #ifdef CONFIG_IPW2100_DEBUG
2208 #define IPW2100_HANDLER(v, f) { v, f, # v }
2209 struct ipw2100_status_indicator {
2210 	int status;
2211 	void (*cb) (struct ipw2100_priv * priv, u32 status);
2212 	char *name;
2213 };
2214 #else
2215 #define IPW2100_HANDLER(v, f) { v, f }
2216 struct ipw2100_status_indicator {
2217 	int status;
2218 	void (*cb) (struct ipw2100_priv * priv, u32 status);
2219 };
2220 #endif				/* CONFIG_IPW2100_DEBUG */
2221 
2222 static void isr_indicate_scanning(struct ipw2100_priv *priv, u32 status)
2223 {
2224 	IPW_DEBUG_SCAN("Scanning...\n");
2225 	priv->status |= STATUS_SCANNING;
2226 }
2227 
2228 static const struct ipw2100_status_indicator status_handlers[] = {
2229 	IPW2100_HANDLER(IPW_STATE_INITIALIZED, NULL),
2230 	IPW2100_HANDLER(IPW_STATE_COUNTRY_FOUND, NULL),
2231 	IPW2100_HANDLER(IPW_STATE_ASSOCIATED, isr_indicate_associated),
2232 	IPW2100_HANDLER(IPW_STATE_ASSN_LOST, isr_indicate_association_lost),
2233 	IPW2100_HANDLER(IPW_STATE_ASSN_CHANGED, NULL),
2234 	IPW2100_HANDLER(IPW_STATE_SCAN_COMPLETE, isr_scan_complete),
2235 	IPW2100_HANDLER(IPW_STATE_ENTERED_PSP, NULL),
2236 	IPW2100_HANDLER(IPW_STATE_LEFT_PSP, NULL),
2237 	IPW2100_HANDLER(IPW_STATE_RF_KILL, isr_indicate_rf_kill),
2238 	IPW2100_HANDLER(IPW_STATE_DISABLED, NULL),
2239 	IPW2100_HANDLER(IPW_STATE_POWER_DOWN, NULL),
2240 	IPW2100_HANDLER(IPW_STATE_SCANNING, isr_indicate_scanning),
2241 	IPW2100_HANDLER(-1, NULL)
2242 };
2243 
2244 static void isr_status_change(struct ipw2100_priv *priv, int status)
2245 {
2246 	int i;
2247 
2248 	if (status == IPW_STATE_SCANNING &&
2249 	    priv->status & STATUS_ASSOCIATED &&
2250 	    !(priv->status & STATUS_SCANNING)) {
2251 		IPW_DEBUG_INFO("Scan detected while associated, with "
2252 			       "no scan request.  Restarting firmware.\n");
2253 
2254 		/* Wake up any sleeping jobs */
2255 		schedule_reset(priv);
2256 	}
2257 
2258 	for (i = 0; status_handlers[i].status != -1; i++) {
2259 		if (status == status_handlers[i].status) {
2260 			IPW_DEBUG_NOTIF("Status change: %s\n",
2261 					status_handlers[i].name);
2262 			if (status_handlers[i].cb)
2263 				status_handlers[i].cb(priv, status);
2264 			priv->wstats.status = status;
2265 			return;
2266 		}
2267 	}
2268 
2269 	IPW_DEBUG_NOTIF("unknown status received: %04x\n", status);
2270 }
2271 
2272 static void isr_rx_complete_command(struct ipw2100_priv *priv,
2273 				    struct ipw2100_cmd_header *cmd)
2274 {
2275 #ifdef CONFIG_IPW2100_DEBUG
2276 	if (cmd->host_command_reg < ARRAY_SIZE(command_types)) {
2277 		IPW_DEBUG_HC("Command completed '%s (%d)'\n",
2278 			     command_types[cmd->host_command_reg],
2279 			     cmd->host_command_reg);
2280 	}
2281 #endif
2282 	if (cmd->host_command_reg == HOST_COMPLETE)
2283 		priv->status |= STATUS_ENABLED;
2284 
2285 	if (cmd->host_command_reg == CARD_DISABLE)
2286 		priv->status &= ~STATUS_ENABLED;
2287 
2288 	priv->status &= ~STATUS_CMD_ACTIVE;
2289 
2290 	wake_up_interruptible(&priv->wait_command_queue);
2291 }
2292 
2293 #ifdef CONFIG_IPW2100_DEBUG
2294 static const char *frame_types[] = {
2295 	"COMMAND_STATUS_VAL",
2296 	"STATUS_CHANGE_VAL",
2297 	"P80211_DATA_VAL",
2298 	"P8023_DATA_VAL",
2299 	"HOST_NOTIFICATION_VAL"
2300 };
2301 #endif
2302 
2303 static int ipw2100_alloc_skb(struct ipw2100_priv *priv,
2304 				    struct ipw2100_rx_packet *packet)
2305 {
2306 	packet->skb = dev_alloc_skb(sizeof(struct ipw2100_rx));
2307 	if (!packet->skb)
2308 		return -ENOMEM;
2309 
2310 	packet->rxp = (struct ipw2100_rx *)packet->skb->data;
2311 	packet->dma_addr = pci_map_single(priv->pci_dev, packet->skb->data,
2312 					  sizeof(struct ipw2100_rx),
2313 					  PCI_DMA_FROMDEVICE);
2314 	if (pci_dma_mapping_error(priv->pci_dev, packet->dma_addr)) {
2315 		dev_kfree_skb(packet->skb);
2316 		return -ENOMEM;
2317 	}
2318 
2319 	return 0;
2320 }
2321 
2322 #define SEARCH_ERROR   0xffffffff
2323 #define SEARCH_FAIL    0xfffffffe
2324 #define SEARCH_SUCCESS 0xfffffff0
2325 #define SEARCH_DISCARD 0
2326 #define SEARCH_SNAPSHOT 1
2327 
2328 #define SNAPSHOT_ADDR(ofs) (priv->snapshot[((ofs) >> 12) & 0xff] + ((ofs) & 0xfff))
2329 static void ipw2100_snapshot_free(struct ipw2100_priv *priv)
2330 {
2331 	int i;
2332 	if (!priv->snapshot[0])
2333 		return;
2334 	for (i = 0; i < 0x30; i++)
2335 		kfree(priv->snapshot[i]);
2336 	priv->snapshot[0] = NULL;
2337 }
2338 
2339 #ifdef IPW2100_DEBUG_C3
2340 static int ipw2100_snapshot_alloc(struct ipw2100_priv *priv)
2341 {
2342 	int i;
2343 	if (priv->snapshot[0])
2344 		return 1;
2345 	for (i = 0; i < 0x30; i++) {
2346 		priv->snapshot[i] = kmalloc(0x1000, GFP_ATOMIC);
2347 		if (!priv->snapshot[i]) {
2348 			IPW_DEBUG_INFO("%s: Error allocating snapshot "
2349 				       "buffer %d\n", priv->net_dev->name, i);
2350 			while (i > 0)
2351 				kfree(priv->snapshot[--i]);
2352 			priv->snapshot[0] = NULL;
2353 			return 0;
2354 		}
2355 	}
2356 
2357 	return 1;
2358 }
2359 
2360 static u32 ipw2100_match_buf(struct ipw2100_priv *priv, u8 * in_buf,
2361 				    size_t len, int mode)
2362 {
2363 	u32 i, j;
2364 	u32 tmp;
2365 	u8 *s, *d;
2366 	u32 ret;
2367 
2368 	s = in_buf;
2369 	if (mode == SEARCH_SNAPSHOT) {
2370 		if (!ipw2100_snapshot_alloc(priv))
2371 			mode = SEARCH_DISCARD;
2372 	}
2373 
2374 	for (ret = SEARCH_FAIL, i = 0; i < 0x30000; i += 4) {
2375 		read_nic_dword(priv->net_dev, i, &tmp);
2376 		if (mode == SEARCH_SNAPSHOT)
2377 			*(u32 *) SNAPSHOT_ADDR(i) = tmp;
2378 		if (ret == SEARCH_FAIL) {
2379 			d = (u8 *) & tmp;
2380 			for (j = 0; j < 4; j++) {
2381 				if (*s != *d) {
2382 					s = in_buf;
2383 					continue;
2384 				}
2385 
2386 				s++;
2387 				d++;
2388 
2389 				if ((s - in_buf) == len)
2390 					ret = (i + j) - len + 1;
2391 			}
2392 		} else if (mode == SEARCH_DISCARD)
2393 			return ret;
2394 	}
2395 
2396 	return ret;
2397 }
2398 #endif
2399 
2400 /*
2401  *
2402  * 0) Disconnect the SKB from the firmware (just unmap)
2403  * 1) Pack the ETH header into the SKB
2404  * 2) Pass the SKB to the network stack
2405  *
2406  * When packet is provided by the firmware, it contains the following:
2407  *
2408  * .  libipw_hdr
2409  * .  libipw_snap_hdr
2410  *
2411  * The size of the constructed ethernet
2412  *
2413  */
2414 #ifdef IPW2100_RX_DEBUG
2415 static u8 packet_data[IPW_RX_NIC_BUFFER_LENGTH];
2416 #endif
2417 
2418 static void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i)
2419 {
2420 #ifdef IPW2100_DEBUG_C3
2421 	struct ipw2100_status *status = &priv->status_queue.drv[i];
2422 	u32 match, reg;
2423 	int j;
2424 #endif
2425 
2426 	IPW_DEBUG_INFO(": PCI latency error detected at 0x%04zX.\n",
2427 		       i * sizeof(struct ipw2100_status));
2428 
2429 #ifdef IPW2100_DEBUG_C3
2430 	/* Halt the firmware so we can get a good image */
2431 	write_register(priv->net_dev, IPW_REG_RESET_REG,
2432 		       IPW_AUX_HOST_RESET_REG_STOP_MASTER);
2433 	j = 5;
2434 	do {
2435 		udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY);
2436 		read_register(priv->net_dev, IPW_REG_RESET_REG, &reg);
2437 
2438 		if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
2439 			break;
2440 	} while (j--);
2441 
2442 	match = ipw2100_match_buf(priv, (u8 *) status,
2443 				  sizeof(struct ipw2100_status),
2444 				  SEARCH_SNAPSHOT);
2445 	if (match < SEARCH_SUCCESS)
2446 		IPW_DEBUG_INFO("%s: DMA status match in Firmware at "
2447 			       "offset 0x%06X, length %d:\n",
2448 			       priv->net_dev->name, match,
2449 			       sizeof(struct ipw2100_status));
2450 	else
2451 		IPW_DEBUG_INFO("%s: No DMA status match in "
2452 			       "Firmware.\n", priv->net_dev->name);
2453 
2454 	printk_buf((u8 *) priv->status_queue.drv,
2455 		   sizeof(struct ipw2100_status) * RX_QUEUE_LENGTH);
2456 #endif
2457 
2458 	priv->fatal_error = IPW2100_ERR_C3_CORRUPTION;
2459 	priv->net_dev->stats.rx_errors++;
2460 	schedule_reset(priv);
2461 }
2462 
2463 static void isr_rx(struct ipw2100_priv *priv, int i,
2464 			  struct libipw_rx_stats *stats)
2465 {
2466 	struct net_device *dev = priv->net_dev;
2467 	struct ipw2100_status *status = &priv->status_queue.drv[i];
2468 	struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
2469 
2470 	IPW_DEBUG_RX("Handler...\n");
2471 
2472 	if (unlikely(status->frame_size > skb_tailroom(packet->skb))) {
2473 		IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!"
2474 			       "  Dropping.\n",
2475 			       dev->name,
2476 			       status->frame_size, skb_tailroom(packet->skb));
2477 		dev->stats.rx_errors++;
2478 		return;
2479 	}
2480 
2481 	if (unlikely(!netif_running(dev))) {
2482 		dev->stats.rx_errors++;
2483 		priv->wstats.discard.misc++;
2484 		IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
2485 		return;
2486 	}
2487 
2488 	if (unlikely(priv->ieee->iw_mode != IW_MODE_MONITOR &&
2489 		     !(priv->status & STATUS_ASSOCIATED))) {
2490 		IPW_DEBUG_DROP("Dropping packet while not associated.\n");
2491 		priv->wstats.discard.misc++;
2492 		return;
2493 	}
2494 
2495 	pci_unmap_single(priv->pci_dev,
2496 			 packet->dma_addr,
2497 			 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE);
2498 
2499 	skb_put(packet->skb, status->frame_size);
2500 
2501 #ifdef IPW2100_RX_DEBUG
2502 	/* Make a copy of the frame so we can dump it to the logs if
2503 	 * libipw_rx fails */
2504 	skb_copy_from_linear_data(packet->skb, packet_data,
2505 				  min_t(u32, status->frame_size,
2506 					     IPW_RX_NIC_BUFFER_LENGTH));
2507 #endif
2508 
2509 	if (!libipw_rx(priv->ieee, packet->skb, stats)) {
2510 #ifdef IPW2100_RX_DEBUG
2511 		IPW_DEBUG_DROP("%s: Non consumed packet:\n",
2512 			       dev->name);
2513 		printk_buf(IPW_DL_DROP, packet_data, status->frame_size);
2514 #endif
2515 		dev->stats.rx_errors++;
2516 
2517 		/* libipw_rx failed, so it didn't free the SKB */
2518 		dev_kfree_skb_any(packet->skb);
2519 		packet->skb = NULL;
2520 	}
2521 
2522 	/* We need to allocate a new SKB and attach it to the RDB. */
2523 	if (unlikely(ipw2100_alloc_skb(priv, packet))) {
2524 		printk(KERN_WARNING DRV_NAME ": "
2525 		       "%s: Unable to allocate SKB onto RBD ring - disabling "
2526 		       "adapter.\n", dev->name);
2527 		/* TODO: schedule adapter shutdown */
2528 		IPW_DEBUG_INFO("TODO: Shutdown adapter...\n");
2529 	}
2530 
2531 	/* Update the RDB entry */
2532 	priv->rx_queue.drv[i].host_addr = packet->dma_addr;
2533 }
2534 
2535 #ifdef CONFIG_IPW2100_MONITOR
2536 
2537 static void isr_rx_monitor(struct ipw2100_priv *priv, int i,
2538 		   struct libipw_rx_stats *stats)
2539 {
2540 	struct net_device *dev = priv->net_dev;
2541 	struct ipw2100_status *status = &priv->status_queue.drv[i];
2542 	struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
2543 
2544 	/* Magic struct that slots into the radiotap header -- no reason
2545 	 * to build this manually element by element, we can write it much
2546 	 * more efficiently than we can parse it. ORDER MATTERS HERE */
2547 	struct ipw_rt_hdr {
2548 		struct ieee80211_radiotap_header rt_hdr;
2549 		s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
2550 	} *ipw_rt;
2551 
2552 	IPW_DEBUG_RX("Handler...\n");
2553 
2554 	if (unlikely(status->frame_size > skb_tailroom(packet->skb) -
2555 				sizeof(struct ipw_rt_hdr))) {
2556 		IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!"
2557 			       "  Dropping.\n",
2558 			       dev->name,
2559 			       status->frame_size,
2560 			       skb_tailroom(packet->skb));
2561 		dev->stats.rx_errors++;
2562 		return;
2563 	}
2564 
2565 	if (unlikely(!netif_running(dev))) {
2566 		dev->stats.rx_errors++;
2567 		priv->wstats.discard.misc++;
2568 		IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
2569 		return;
2570 	}
2571 
2572 	if (unlikely(priv->config & CFG_CRC_CHECK &&
2573 		     status->flags & IPW_STATUS_FLAG_CRC_ERROR)) {
2574 		IPW_DEBUG_RX("CRC error in packet.  Dropping.\n");
2575 		dev->stats.rx_errors++;
2576 		return;
2577 	}
2578 
2579 	pci_unmap_single(priv->pci_dev, packet->dma_addr,
2580 			 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE);
2581 	memmove(packet->skb->data + sizeof(struct ipw_rt_hdr),
2582 		packet->skb->data, status->frame_size);
2583 
2584 	ipw_rt = (struct ipw_rt_hdr *) packet->skb->data;
2585 
2586 	ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
2587 	ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
2588 	ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total hdr+data */
2589 
2590 	ipw_rt->rt_hdr.it_present = cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL);
2591 
2592 	ipw_rt->rt_dbmsignal = status->rssi + IPW2100_RSSI_TO_DBM;
2593 
2594 	skb_put(packet->skb, status->frame_size + sizeof(struct ipw_rt_hdr));
2595 
2596 	if (!libipw_rx(priv->ieee, packet->skb, stats)) {
2597 		dev->stats.rx_errors++;
2598 
2599 		/* libipw_rx failed, so it didn't free the SKB */
2600 		dev_kfree_skb_any(packet->skb);
2601 		packet->skb = NULL;
2602 	}
2603 
2604 	/* We need to allocate a new SKB and attach it to the RDB. */
2605 	if (unlikely(ipw2100_alloc_skb(priv, packet))) {
2606 		IPW_DEBUG_WARNING(
2607 			"%s: Unable to allocate SKB onto RBD ring - disabling "
2608 			"adapter.\n", dev->name);
2609 		/* TODO: schedule adapter shutdown */
2610 		IPW_DEBUG_INFO("TODO: Shutdown adapter...\n");
2611 	}
2612 
2613 	/* Update the RDB entry */
2614 	priv->rx_queue.drv[i].host_addr = packet->dma_addr;
2615 }
2616 
2617 #endif
2618 
2619 static int ipw2100_corruption_check(struct ipw2100_priv *priv, int i)
2620 {
2621 	struct ipw2100_status *status = &priv->status_queue.drv[i];
2622 	struct ipw2100_rx *u = priv->rx_buffers[i].rxp;
2623 	u16 frame_type = status->status_fields & STATUS_TYPE_MASK;
2624 
2625 	switch (frame_type) {
2626 	case COMMAND_STATUS_VAL:
2627 		return (status->frame_size != sizeof(u->rx_data.command));
2628 	case STATUS_CHANGE_VAL:
2629 		return (status->frame_size != sizeof(u->rx_data.status));
2630 	case HOST_NOTIFICATION_VAL:
2631 		return (status->frame_size < sizeof(u->rx_data.notification));
2632 	case P80211_DATA_VAL:
2633 	case P8023_DATA_VAL:
2634 #ifdef CONFIG_IPW2100_MONITOR
2635 		return 0;
2636 #else
2637 		switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) {
2638 		case IEEE80211_FTYPE_MGMT:
2639 		case IEEE80211_FTYPE_CTL:
2640 			return 0;
2641 		case IEEE80211_FTYPE_DATA:
2642 			return (status->frame_size >
2643 				IPW_MAX_802_11_PAYLOAD_LENGTH);
2644 		}
2645 #endif
2646 	}
2647 
2648 	return 1;
2649 }
2650 
2651 /*
2652  * ipw2100 interrupts are disabled at this point, and the ISR
2653  * is the only code that calls this method.  So, we do not need
2654  * to play with any locks.
2655  *
2656  * RX Queue works as follows:
2657  *
2658  * Read index - firmware places packet in entry identified by the
2659  *              Read index and advances Read index.  In this manner,
2660  *              Read index will always point to the next packet to
2661  *              be filled--but not yet valid.
2662  *
2663  * Write index - driver fills this entry with an unused RBD entry.
2664  *               This entry has not filled by the firmware yet.
2665  *
2666  * In between the W and R indexes are the RBDs that have been received
2667  * but not yet processed.
2668  *
2669  * The process of handling packets will start at WRITE + 1 and advance
2670  * until it reaches the READ index.
2671  *
2672  * The WRITE index is cached in the variable 'priv->rx_queue.next'.
2673  *
2674  */
2675 static void __ipw2100_rx_process(struct ipw2100_priv *priv)
2676 {
2677 	struct ipw2100_bd_queue *rxq = &priv->rx_queue;
2678 	struct ipw2100_status_queue *sq = &priv->status_queue;
2679 	struct ipw2100_rx_packet *packet;
2680 	u16 frame_type;
2681 	u32 r, w, i, s;
2682 	struct ipw2100_rx *u;
2683 	struct libipw_rx_stats stats = {
2684 		.mac_time = jiffies,
2685 	};
2686 
2687 	read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_READ_INDEX, &r);
2688 	read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, &w);
2689 
2690 	if (r >= rxq->entries) {
2691 		IPW_DEBUG_RX("exit - bad read index\n");
2692 		return;
2693 	}
2694 
2695 	i = (rxq->next + 1) % rxq->entries;
2696 	s = i;
2697 	while (i != r) {
2698 		/* IPW_DEBUG_RX("r = %d : w = %d : processing = %d\n",
2699 		   r, rxq->next, i); */
2700 
2701 		packet = &priv->rx_buffers[i];
2702 
2703 		/* Sync the DMA for the RX buffer so CPU is sure to get
2704 		 * the correct values */
2705 		pci_dma_sync_single_for_cpu(priv->pci_dev, packet->dma_addr,
2706 					    sizeof(struct ipw2100_rx),
2707 					    PCI_DMA_FROMDEVICE);
2708 
2709 		if (unlikely(ipw2100_corruption_check(priv, i))) {
2710 			ipw2100_corruption_detected(priv, i);
2711 			goto increment;
2712 		}
2713 
2714 		u = packet->rxp;
2715 		frame_type = sq->drv[i].status_fields & STATUS_TYPE_MASK;
2716 		stats.rssi = sq->drv[i].rssi + IPW2100_RSSI_TO_DBM;
2717 		stats.len = sq->drv[i].frame_size;
2718 
2719 		stats.mask = 0;
2720 		if (stats.rssi != 0)
2721 			stats.mask |= LIBIPW_STATMASK_RSSI;
2722 		stats.freq = LIBIPW_24GHZ_BAND;
2723 
2724 		IPW_DEBUG_RX("%s: '%s' frame type received (%d).\n",
2725 			     priv->net_dev->name, frame_types[frame_type],
2726 			     stats.len);
2727 
2728 		switch (frame_type) {
2729 		case COMMAND_STATUS_VAL:
2730 			/* Reset Rx watchdog */
2731 			isr_rx_complete_command(priv, &u->rx_data.command);
2732 			break;
2733 
2734 		case STATUS_CHANGE_VAL:
2735 			isr_status_change(priv, u->rx_data.status);
2736 			break;
2737 
2738 		case P80211_DATA_VAL:
2739 		case P8023_DATA_VAL:
2740 #ifdef CONFIG_IPW2100_MONITOR
2741 			if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
2742 				isr_rx_monitor(priv, i, &stats);
2743 				break;
2744 			}
2745 #endif
2746 			if (stats.len < sizeof(struct libipw_hdr_3addr))
2747 				break;
2748 			switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) {
2749 			case IEEE80211_FTYPE_MGMT:
2750 				libipw_rx_mgt(priv->ieee,
2751 						 &u->rx_data.header, &stats);
2752 				break;
2753 
2754 			case IEEE80211_FTYPE_CTL:
2755 				break;
2756 
2757 			case IEEE80211_FTYPE_DATA:
2758 				isr_rx(priv, i, &stats);
2759 				break;
2760 
2761 			}
2762 			break;
2763 		}
2764 
2765 	      increment:
2766 		/* clear status field associated with this RBD */
2767 		rxq->drv[i].status.info.field = 0;
2768 
2769 		i = (i + 1) % rxq->entries;
2770 	}
2771 
2772 	if (i != s) {
2773 		/* backtrack one entry, wrapping to end if at 0 */
2774 		rxq->next = (i ? i : rxq->entries) - 1;
2775 
2776 		write_register(priv->net_dev,
2777 			       IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, rxq->next);
2778 	}
2779 }
2780 
2781 /*
2782  * __ipw2100_tx_process
2783  *
2784  * This routine will determine whether the next packet on
2785  * the fw_pend_list has been processed by the firmware yet.
2786  *
2787  * If not, then it does nothing and returns.
2788  *
2789  * If so, then it removes the item from the fw_pend_list, frees
2790  * any associated storage, and places the item back on the
2791  * free list of its source (either msg_free_list or tx_free_list)
2792  *
2793  * TX Queue works as follows:
2794  *
2795  * Read index - points to the next TBD that the firmware will
2796  *              process.  The firmware will read the data, and once
2797  *              done processing, it will advance the Read index.
2798  *
2799  * Write index - driver fills this entry with an constructed TBD
2800  *               entry.  The Write index is not advanced until the
2801  *               packet has been configured.
2802  *
2803  * In between the W and R indexes are the TBDs that have NOT been
2804  * processed.  Lagging behind the R index are packets that have
2805  * been processed but have not been freed by the driver.
2806  *
2807  * In order to free old storage, an internal index will be maintained
2808  * that points to the next packet to be freed.  When all used
2809  * packets have been freed, the oldest index will be the same as the
2810  * firmware's read index.
2811  *
2812  * The OLDEST index is cached in the variable 'priv->tx_queue.oldest'
2813  *
2814  * Because the TBD structure can not contain arbitrary data, the
2815  * driver must keep an internal queue of cached allocations such that
2816  * it can put that data back into the tx_free_list and msg_free_list
2817  * for use by future command and data packets.
2818  *
2819  */
2820 static int __ipw2100_tx_process(struct ipw2100_priv *priv)
2821 {
2822 	struct ipw2100_bd_queue *txq = &priv->tx_queue;
2823 	struct ipw2100_bd *tbd;
2824 	struct list_head *element;
2825 	struct ipw2100_tx_packet *packet;
2826 	int descriptors_used;
2827 	int e, i;
2828 	u32 r, w, frag_num = 0;
2829 
2830 	if (list_empty(&priv->fw_pend_list))
2831 		return 0;
2832 
2833 	element = priv->fw_pend_list.next;
2834 
2835 	packet = list_entry(element, struct ipw2100_tx_packet, list);
2836 	tbd = &txq->drv[packet->index];
2837 
2838 	/* Determine how many TBD entries must be finished... */
2839 	switch (packet->type) {
2840 	case COMMAND:
2841 		/* COMMAND uses only one slot; don't advance */
2842 		descriptors_used = 1;
2843 		e = txq->oldest;
2844 		break;
2845 
2846 	case DATA:
2847 		/* DATA uses two slots; advance and loop position. */
2848 		descriptors_used = tbd->num_fragments;
2849 		frag_num = tbd->num_fragments - 1;
2850 		e = txq->oldest + frag_num;
2851 		e %= txq->entries;
2852 		break;
2853 
2854 	default:
2855 		printk(KERN_WARNING DRV_NAME ": %s: Bad fw_pend_list entry!\n",
2856 		       priv->net_dev->name);
2857 		return 0;
2858 	}
2859 
2860 	/* if the last TBD is not done by NIC yet, then packet is
2861 	 * not ready to be released.
2862 	 *
2863 	 */
2864 	read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX,
2865 		      &r);
2866 	read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
2867 		      &w);
2868 	if (w != txq->next)
2869 		printk(KERN_WARNING DRV_NAME ": %s: write index mismatch\n",
2870 		       priv->net_dev->name);
2871 
2872 	/*
2873 	 * txq->next is the index of the last packet written txq->oldest is
2874 	 * the index of the r is the index of the next packet to be read by
2875 	 * firmware
2876 	 */
2877 
2878 	/*
2879 	 * Quick graphic to help you visualize the following
2880 	 * if / else statement
2881 	 *
2882 	 * ===>|                     s---->|===============
2883 	 *                               e>|
2884 	 * | a | b | c | d | e | f | g | h | i | j | k | l
2885 	 *       r---->|
2886 	 *               w
2887 	 *
2888 	 * w - updated by driver
2889 	 * r - updated by firmware
2890 	 * s - start of oldest BD entry (txq->oldest)
2891 	 * e - end of oldest BD entry
2892 	 *
2893 	 */
2894 	if (!((r <= w && (e < r || e >= w)) || (e < r && e >= w))) {
2895 		IPW_DEBUG_TX("exit - no processed packets ready to release.\n");
2896 		return 0;
2897 	}
2898 
2899 	list_del(element);
2900 	DEC_STAT(&priv->fw_pend_stat);
2901 
2902 #ifdef CONFIG_IPW2100_DEBUG
2903 	{
2904 		i = txq->oldest;
2905 		IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i,
2906 			     &txq->drv[i],
2907 			     (u32) (txq->nic + i * sizeof(struct ipw2100_bd)),
2908 			     txq->drv[i].host_addr, txq->drv[i].buf_length);
2909 
2910 		if (packet->type == DATA) {
2911 			i = (i + 1) % txq->entries;
2912 
2913 			IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i,
2914 				     &txq->drv[i],
2915 				     (u32) (txq->nic + i *
2916 					    sizeof(struct ipw2100_bd)),
2917 				     (u32) txq->drv[i].host_addr,
2918 				     txq->drv[i].buf_length);
2919 		}
2920 	}
2921 #endif
2922 
2923 	switch (packet->type) {
2924 	case DATA:
2925 		if (txq->drv[txq->oldest].status.info.fields.txType != 0)
2926 			printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch.  "
2927 			       "Expecting DATA TBD but pulled "
2928 			       "something else: ids %d=%d.\n",
2929 			       priv->net_dev->name, txq->oldest, packet->index);
2930 
2931 		/* DATA packet; we have to unmap and free the SKB */
2932 		for (i = 0; i < frag_num; i++) {
2933 			tbd = &txq->drv[(packet->index + 1 + i) % txq->entries];
2934 
2935 			IPW_DEBUG_TX("TX%d P=%08x L=%d\n",
2936 				     (packet->index + 1 + i) % txq->entries,
2937 				     tbd->host_addr, tbd->buf_length);
2938 
2939 			pci_unmap_single(priv->pci_dev,
2940 					 tbd->host_addr,
2941 					 tbd->buf_length, PCI_DMA_TODEVICE);
2942 		}
2943 
2944 		libipw_txb_free(packet->info.d_struct.txb);
2945 		packet->info.d_struct.txb = NULL;
2946 
2947 		list_add_tail(element, &priv->tx_free_list);
2948 		INC_STAT(&priv->tx_free_stat);
2949 
2950 		/* We have a free slot in the Tx queue, so wake up the
2951 		 * transmit layer if it is stopped. */
2952 		if (priv->status & STATUS_ASSOCIATED)
2953 			netif_wake_queue(priv->net_dev);
2954 
2955 		/* A packet was processed by the hardware, so update the
2956 		 * watchdog */
2957 		netif_trans_update(priv->net_dev);
2958 
2959 		break;
2960 
2961 	case COMMAND:
2962 		if (txq->drv[txq->oldest].status.info.fields.txType != 1)
2963 			printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch.  "
2964 			       "Expecting COMMAND TBD but pulled "
2965 			       "something else: ids %d=%d.\n",
2966 			       priv->net_dev->name, txq->oldest, packet->index);
2967 
2968 #ifdef CONFIG_IPW2100_DEBUG
2969 		if (packet->info.c_struct.cmd->host_command_reg <
2970 		    ARRAY_SIZE(command_types))
2971 			IPW_DEBUG_TX("Command '%s (%d)' processed: %d.\n",
2972 				     command_types[packet->info.c_struct.cmd->
2973 						   host_command_reg],
2974 				     packet->info.c_struct.cmd->
2975 				     host_command_reg,
2976 				     packet->info.c_struct.cmd->cmd_status_reg);
2977 #endif
2978 
2979 		list_add_tail(element, &priv->msg_free_list);
2980 		INC_STAT(&priv->msg_free_stat);
2981 		break;
2982 	}
2983 
2984 	/* advance oldest used TBD pointer to start of next entry */
2985 	txq->oldest = (e + 1) % txq->entries;
2986 	/* increase available TBDs number */
2987 	txq->available += descriptors_used;
2988 	SET_STAT(&priv->txq_stat, txq->available);
2989 
2990 	IPW_DEBUG_TX("packet latency (send to process)  %ld jiffies\n",
2991 		     jiffies - packet->jiffy_start);
2992 
2993 	return (!list_empty(&priv->fw_pend_list));
2994 }
2995 
2996 static inline void __ipw2100_tx_complete(struct ipw2100_priv *priv)
2997 {
2998 	int i = 0;
2999 
3000 	while (__ipw2100_tx_process(priv) && i < 200)
3001 		i++;
3002 
3003 	if (i == 200) {
3004 		printk(KERN_WARNING DRV_NAME ": "
3005 		       "%s: Driver is running slow (%d iters).\n",
3006 		       priv->net_dev->name, i);
3007 	}
3008 }
3009 
3010 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv)
3011 {
3012 	struct list_head *element;
3013 	struct ipw2100_tx_packet *packet;
3014 	struct ipw2100_bd_queue *txq = &priv->tx_queue;
3015 	struct ipw2100_bd *tbd;
3016 	int next = txq->next;
3017 
3018 	while (!list_empty(&priv->msg_pend_list)) {
3019 		/* if there isn't enough space in TBD queue, then
3020 		 * don't stuff a new one in.
3021 		 * NOTE: 3 are needed as a command will take one,
3022 		 *       and there is a minimum of 2 that must be
3023 		 *       maintained between the r and w indexes
3024 		 */
3025 		if (txq->available <= 3) {
3026 			IPW_DEBUG_TX("no room in tx_queue\n");
3027 			break;
3028 		}
3029 
3030 		element = priv->msg_pend_list.next;
3031 		list_del(element);
3032 		DEC_STAT(&priv->msg_pend_stat);
3033 
3034 		packet = list_entry(element, struct ipw2100_tx_packet, list);
3035 
3036 		IPW_DEBUG_TX("using TBD at virt=%p, phys=%04X\n",
3037 			     &txq->drv[txq->next],
3038 			     (u32) (txq->nic + txq->next *
3039 				      sizeof(struct ipw2100_bd)));
3040 
3041 		packet->index = txq->next;
3042 
3043 		tbd = &txq->drv[txq->next];
3044 
3045 		/* initialize TBD */
3046 		tbd->host_addr = packet->info.c_struct.cmd_phys;
3047 		tbd->buf_length = sizeof(struct ipw2100_cmd_header);
3048 		/* not marking number of fragments causes problems
3049 		 * with f/w debug version */
3050 		tbd->num_fragments = 1;
3051 		tbd->status.info.field =
3052 		    IPW_BD_STATUS_TX_FRAME_COMMAND |
3053 		    IPW_BD_STATUS_TX_INTERRUPT_ENABLE;
3054 
3055 		/* update TBD queue counters */
3056 		txq->next++;
3057 		txq->next %= txq->entries;
3058 		txq->available--;
3059 		DEC_STAT(&priv->txq_stat);
3060 
3061 		list_add_tail(element, &priv->fw_pend_list);
3062 		INC_STAT(&priv->fw_pend_stat);
3063 	}
3064 
3065 	if (txq->next != next) {
3066 		/* kick off the DMA by notifying firmware the
3067 		 * write index has moved; make sure TBD stores are sync'd */
3068 		wmb();
3069 		write_register(priv->net_dev,
3070 			       IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
3071 			       txq->next);
3072 	}
3073 }
3074 
3075 /*
3076  * ipw2100_tx_send_data
3077  *
3078  */
3079 static void ipw2100_tx_send_data(struct ipw2100_priv *priv)
3080 {
3081 	struct list_head *element;
3082 	struct ipw2100_tx_packet *packet;
3083 	struct ipw2100_bd_queue *txq = &priv->tx_queue;
3084 	struct ipw2100_bd *tbd;
3085 	int next = txq->next;
3086 	int i = 0;
3087 	struct ipw2100_data_header *ipw_hdr;
3088 	struct libipw_hdr_3addr *hdr;
3089 
3090 	while (!list_empty(&priv->tx_pend_list)) {
3091 		/* if there isn't enough space in TBD queue, then
3092 		 * don't stuff a new one in.
3093 		 * NOTE: 4 are needed as a data will take two,
3094 		 *       and there is a minimum of 2 that must be
3095 		 *       maintained between the r and w indexes
3096 		 */
3097 		element = priv->tx_pend_list.next;
3098 		packet = list_entry(element, struct ipw2100_tx_packet, list);
3099 
3100 		if (unlikely(1 + packet->info.d_struct.txb->nr_frags >
3101 			     IPW_MAX_BDS)) {
3102 			/* TODO: Support merging buffers if more than
3103 			 * IPW_MAX_BDS are used */
3104 			IPW_DEBUG_INFO("%s: Maximum BD threshold exceeded.  "
3105 				       "Increase fragmentation level.\n",
3106 				       priv->net_dev->name);
3107 		}
3108 
3109 		if (txq->available <= 3 + packet->info.d_struct.txb->nr_frags) {
3110 			IPW_DEBUG_TX("no room in tx_queue\n");
3111 			break;
3112 		}
3113 
3114 		list_del(element);
3115 		DEC_STAT(&priv->tx_pend_stat);
3116 
3117 		tbd = &txq->drv[txq->next];
3118 
3119 		packet->index = txq->next;
3120 
3121 		ipw_hdr = packet->info.d_struct.data;
3122 		hdr = (struct libipw_hdr_3addr *)packet->info.d_struct.txb->
3123 		    fragments[0]->data;
3124 
3125 		if (priv->ieee->iw_mode == IW_MODE_INFRA) {
3126 			/* To DS: Addr1 = BSSID, Addr2 = SA,
3127 			   Addr3 = DA */
3128 			memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN);
3129 			memcpy(ipw_hdr->dst_addr, hdr->addr3, ETH_ALEN);
3130 		} else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
3131 			/* not From/To DS: Addr1 = DA, Addr2 = SA,
3132 			   Addr3 = BSSID */
3133 			memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN);
3134 			memcpy(ipw_hdr->dst_addr, hdr->addr1, ETH_ALEN);
3135 		}
3136 
3137 		ipw_hdr->host_command_reg = SEND;
3138 		ipw_hdr->host_command_reg1 = 0;
3139 
3140 		/* For now we only support host based encryption */
3141 		ipw_hdr->needs_encryption = 0;
3142 		ipw_hdr->encrypted = packet->info.d_struct.txb->encrypted;
3143 		if (packet->info.d_struct.txb->nr_frags > 1)
3144 			ipw_hdr->fragment_size =
3145 			    packet->info.d_struct.txb->frag_size -
3146 			    LIBIPW_3ADDR_LEN;
3147 		else
3148 			ipw_hdr->fragment_size = 0;
3149 
3150 		tbd->host_addr = packet->info.d_struct.data_phys;
3151 		tbd->buf_length = sizeof(struct ipw2100_data_header);
3152 		tbd->num_fragments = 1 + packet->info.d_struct.txb->nr_frags;
3153 		tbd->status.info.field =
3154 		    IPW_BD_STATUS_TX_FRAME_802_3 |
3155 		    IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT;
3156 		txq->next++;
3157 		txq->next %= txq->entries;
3158 
3159 		IPW_DEBUG_TX("data header tbd TX%d P=%08x L=%d\n",
3160 			     packet->index, tbd->host_addr, tbd->buf_length);
3161 #ifdef CONFIG_IPW2100_DEBUG
3162 		if (packet->info.d_struct.txb->nr_frags > 1)
3163 			IPW_DEBUG_FRAG("fragment Tx: %d frames\n",
3164 				       packet->info.d_struct.txb->nr_frags);
3165 #endif
3166 
3167 		for (i = 0; i < packet->info.d_struct.txb->nr_frags; i++) {
3168 			tbd = &txq->drv[txq->next];
3169 			if (i == packet->info.d_struct.txb->nr_frags - 1)
3170 				tbd->status.info.field =
3171 				    IPW_BD_STATUS_TX_FRAME_802_3 |
3172 				    IPW_BD_STATUS_TX_INTERRUPT_ENABLE;
3173 			else
3174 				tbd->status.info.field =
3175 				    IPW_BD_STATUS_TX_FRAME_802_3 |
3176 				    IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT;
3177 
3178 			tbd->buf_length = packet->info.d_struct.txb->
3179 			    fragments[i]->len - LIBIPW_3ADDR_LEN;
3180 
3181 			tbd->host_addr = pci_map_single(priv->pci_dev,
3182 							packet->info.d_struct.
3183 							txb->fragments[i]->
3184 							data +
3185 							LIBIPW_3ADDR_LEN,
3186 							tbd->buf_length,
3187 							PCI_DMA_TODEVICE);
3188 			if (pci_dma_mapping_error(priv->pci_dev,
3189 						  tbd->host_addr)) {
3190 				IPW_DEBUG_TX("dma mapping error\n");
3191 				break;
3192 			}
3193 
3194 			IPW_DEBUG_TX("data frag tbd TX%d P=%08x L=%d\n",
3195 				     txq->next, tbd->host_addr,
3196 				     tbd->buf_length);
3197 
3198 			pci_dma_sync_single_for_device(priv->pci_dev,
3199 						       tbd->host_addr,
3200 						       tbd->buf_length,
3201 						       PCI_DMA_TODEVICE);
3202 
3203 			txq->next++;
3204 			txq->next %= txq->entries;
3205 		}
3206 
3207 		txq->available -= 1 + packet->info.d_struct.txb->nr_frags;
3208 		SET_STAT(&priv->txq_stat, txq->available);
3209 
3210 		list_add_tail(element, &priv->fw_pend_list);
3211 		INC_STAT(&priv->fw_pend_stat);
3212 	}
3213 
3214 	if (txq->next != next) {
3215 		/* kick off the DMA by notifying firmware the
3216 		 * write index has moved; make sure TBD stores are sync'd */
3217 		write_register(priv->net_dev,
3218 			       IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
3219 			       txq->next);
3220 	}
3221 }
3222 
3223 static void ipw2100_irq_tasklet(struct ipw2100_priv *priv)
3224 {
3225 	struct net_device *dev = priv->net_dev;
3226 	unsigned long flags;
3227 	u32 inta, tmp;
3228 
3229 	spin_lock_irqsave(&priv->low_lock, flags);
3230 	ipw2100_disable_interrupts(priv);
3231 
3232 	read_register(dev, IPW_REG_INTA, &inta);
3233 
3234 	IPW_DEBUG_ISR("enter - INTA: 0x%08lX\n",
3235 		      (unsigned long)inta & IPW_INTERRUPT_MASK);
3236 
3237 	priv->in_isr++;
3238 	priv->interrupts++;
3239 
3240 	/* We do not loop and keep polling for more interrupts as this
3241 	 * is frowned upon and doesn't play nicely with other potentially
3242 	 * chained IRQs */
3243 	IPW_DEBUG_ISR("INTA: 0x%08lX\n",
3244 		      (unsigned long)inta & IPW_INTERRUPT_MASK);
3245 
3246 	if (inta & IPW2100_INTA_FATAL_ERROR) {
3247 		printk(KERN_WARNING DRV_NAME
3248 		       ": Fatal interrupt. Scheduling firmware restart.\n");
3249 		priv->inta_other++;
3250 		write_register(dev, IPW_REG_INTA, IPW2100_INTA_FATAL_ERROR);
3251 
3252 		read_nic_dword(dev, IPW_NIC_FATAL_ERROR, &priv->fatal_error);
3253 		IPW_DEBUG_INFO("%s: Fatal error value: 0x%08X\n",
3254 			       priv->net_dev->name, priv->fatal_error);
3255 
3256 		read_nic_dword(dev, IPW_ERROR_ADDR(priv->fatal_error), &tmp);
3257 		IPW_DEBUG_INFO("%s: Fatal error address value: 0x%08X\n",
3258 			       priv->net_dev->name, tmp);
3259 
3260 		/* Wake up any sleeping jobs */
3261 		schedule_reset(priv);
3262 	}
3263 
3264 	if (inta & IPW2100_INTA_PARITY_ERROR) {
3265 		printk(KERN_ERR DRV_NAME
3266 		       ": ***** PARITY ERROR INTERRUPT !!!!\n");
3267 		priv->inta_other++;
3268 		write_register(dev, IPW_REG_INTA, IPW2100_INTA_PARITY_ERROR);
3269 	}
3270 
3271 	if (inta & IPW2100_INTA_RX_TRANSFER) {
3272 		IPW_DEBUG_ISR("RX interrupt\n");
3273 
3274 		priv->rx_interrupts++;
3275 
3276 		write_register(dev, IPW_REG_INTA, IPW2100_INTA_RX_TRANSFER);
3277 
3278 		__ipw2100_rx_process(priv);
3279 		__ipw2100_tx_complete(priv);
3280 	}
3281 
3282 	if (inta & IPW2100_INTA_TX_TRANSFER) {
3283 		IPW_DEBUG_ISR("TX interrupt\n");
3284 
3285 		priv->tx_interrupts++;
3286 
3287 		write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_TRANSFER);
3288 
3289 		__ipw2100_tx_complete(priv);
3290 		ipw2100_tx_send_commands(priv);
3291 		ipw2100_tx_send_data(priv);
3292 	}
3293 
3294 	if (inta & IPW2100_INTA_TX_COMPLETE) {
3295 		IPW_DEBUG_ISR("TX complete\n");
3296 		priv->inta_other++;
3297 		write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_COMPLETE);
3298 
3299 		__ipw2100_tx_complete(priv);
3300 	}
3301 
3302 	if (inta & IPW2100_INTA_EVENT_INTERRUPT) {
3303 		/* ipw2100_handle_event(dev); */
3304 		priv->inta_other++;
3305 		write_register(dev, IPW_REG_INTA, IPW2100_INTA_EVENT_INTERRUPT);
3306 	}
3307 
3308 	if (inta & IPW2100_INTA_FW_INIT_DONE) {
3309 		IPW_DEBUG_ISR("FW init done interrupt\n");
3310 		priv->inta_other++;
3311 
3312 		read_register(dev, IPW_REG_INTA, &tmp);
3313 		if (tmp & (IPW2100_INTA_FATAL_ERROR |
3314 			   IPW2100_INTA_PARITY_ERROR)) {
3315 			write_register(dev, IPW_REG_INTA,
3316 				       IPW2100_INTA_FATAL_ERROR |
3317 				       IPW2100_INTA_PARITY_ERROR);
3318 		}
3319 
3320 		write_register(dev, IPW_REG_INTA, IPW2100_INTA_FW_INIT_DONE);
3321 	}
3322 
3323 	if (inta & IPW2100_INTA_STATUS_CHANGE) {
3324 		IPW_DEBUG_ISR("Status change interrupt\n");
3325 		priv->inta_other++;
3326 		write_register(dev, IPW_REG_INTA, IPW2100_INTA_STATUS_CHANGE);
3327 	}
3328 
3329 	if (inta & IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE) {
3330 		IPW_DEBUG_ISR("slave host mode interrupt\n");
3331 		priv->inta_other++;
3332 		write_register(dev, IPW_REG_INTA,
3333 			       IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE);
3334 	}
3335 
3336 	priv->in_isr--;
3337 	ipw2100_enable_interrupts(priv);
3338 
3339 	spin_unlock_irqrestore(&priv->low_lock, flags);
3340 
3341 	IPW_DEBUG_ISR("exit\n");
3342 }
3343 
3344 static irqreturn_t ipw2100_interrupt(int irq, void *data)
3345 {
3346 	struct ipw2100_priv *priv = data;
3347 	u32 inta, inta_mask;
3348 
3349 	if (!data)
3350 		return IRQ_NONE;
3351 
3352 	spin_lock(&priv->low_lock);
3353 
3354 	/* We check to see if we should be ignoring interrupts before
3355 	 * we touch the hardware.  During ucode load if we try and handle
3356 	 * an interrupt we can cause keyboard problems as well as cause
3357 	 * the ucode to fail to initialize */
3358 	if (!(priv->status & STATUS_INT_ENABLED)) {
3359 		/* Shared IRQ */
3360 		goto none;
3361 	}
3362 
3363 	read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask);
3364 	read_register(priv->net_dev, IPW_REG_INTA, &inta);
3365 
3366 	if (inta == 0xFFFFFFFF) {
3367 		/* Hardware disappeared */
3368 		printk(KERN_WARNING DRV_NAME ": IRQ INTA == 0xFFFFFFFF\n");
3369 		goto none;
3370 	}
3371 
3372 	inta &= IPW_INTERRUPT_MASK;
3373 
3374 	if (!(inta & inta_mask)) {
3375 		/* Shared interrupt */
3376 		goto none;
3377 	}
3378 
3379 	/* We disable the hardware interrupt here just to prevent unneeded
3380 	 * calls to be made.  We disable this again within the actual
3381 	 * work tasklet, so if another part of the code re-enables the
3382 	 * interrupt, that is fine */
3383 	ipw2100_disable_interrupts(priv);
3384 
3385 	tasklet_schedule(&priv->irq_tasklet);
3386 	spin_unlock(&priv->low_lock);
3387 
3388 	return IRQ_HANDLED;
3389       none:
3390 	spin_unlock(&priv->low_lock);
3391 	return IRQ_NONE;
3392 }
3393 
3394 static netdev_tx_t ipw2100_tx(struct libipw_txb *txb,
3395 			      struct net_device *dev, int pri)
3396 {
3397 	struct ipw2100_priv *priv = libipw_priv(dev);
3398 	struct list_head *element;
3399 	struct ipw2100_tx_packet *packet;
3400 	unsigned long flags;
3401 
3402 	spin_lock_irqsave(&priv->low_lock, flags);
3403 
3404 	if (!(priv->status & STATUS_ASSOCIATED)) {
3405 		IPW_DEBUG_INFO("Can not transmit when not connected.\n");
3406 		priv->net_dev->stats.tx_carrier_errors++;
3407 		netif_stop_queue(dev);
3408 		goto fail_unlock;
3409 	}
3410 
3411 	if (list_empty(&priv->tx_free_list))
3412 		goto fail_unlock;
3413 
3414 	element = priv->tx_free_list.next;
3415 	packet = list_entry(element, struct ipw2100_tx_packet, list);
3416 
3417 	packet->info.d_struct.txb = txb;
3418 
3419 	IPW_DEBUG_TX("Sending fragment (%d bytes):\n", txb->fragments[0]->len);
3420 	printk_buf(IPW_DL_TX, txb->fragments[0]->data, txb->fragments[0]->len);
3421 
3422 	packet->jiffy_start = jiffies;
3423 
3424 	list_del(element);
3425 	DEC_STAT(&priv->tx_free_stat);
3426 
3427 	list_add_tail(element, &priv->tx_pend_list);
3428 	INC_STAT(&priv->tx_pend_stat);
3429 
3430 	ipw2100_tx_send_data(priv);
3431 
3432 	spin_unlock_irqrestore(&priv->low_lock, flags);
3433 	return NETDEV_TX_OK;
3434 
3435 fail_unlock:
3436 	netif_stop_queue(dev);
3437 	spin_unlock_irqrestore(&priv->low_lock, flags);
3438 	return NETDEV_TX_BUSY;
3439 }
3440 
3441 static int ipw2100_msg_allocate(struct ipw2100_priv *priv)
3442 {
3443 	int i, j, err = -EINVAL;
3444 	void *v;
3445 	dma_addr_t p;
3446 
3447 	priv->msg_buffers =
3448 	    kmalloc(IPW_COMMAND_POOL_SIZE * sizeof(struct ipw2100_tx_packet),
3449 		    GFP_KERNEL);
3450 	if (!priv->msg_buffers)
3451 		return -ENOMEM;
3452 
3453 	for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) {
3454 		v = pci_zalloc_consistent(priv->pci_dev,
3455 					  sizeof(struct ipw2100_cmd_header),
3456 					  &p);
3457 		if (!v) {
3458 			printk(KERN_ERR DRV_NAME ": "
3459 			       "%s: PCI alloc failed for msg "
3460 			       "buffers.\n", priv->net_dev->name);
3461 			err = -ENOMEM;
3462 			break;
3463 		}
3464 
3465 		priv->msg_buffers[i].type = COMMAND;
3466 		priv->msg_buffers[i].info.c_struct.cmd =
3467 		    (struct ipw2100_cmd_header *)v;
3468 		priv->msg_buffers[i].info.c_struct.cmd_phys = p;
3469 	}
3470 
3471 	if (i == IPW_COMMAND_POOL_SIZE)
3472 		return 0;
3473 
3474 	for (j = 0; j < i; j++) {
3475 		pci_free_consistent(priv->pci_dev,
3476 				    sizeof(struct ipw2100_cmd_header),
3477 				    priv->msg_buffers[j].info.c_struct.cmd,
3478 				    priv->msg_buffers[j].info.c_struct.
3479 				    cmd_phys);
3480 	}
3481 
3482 	kfree(priv->msg_buffers);
3483 	priv->msg_buffers = NULL;
3484 
3485 	return err;
3486 }
3487 
3488 static int ipw2100_msg_initialize(struct ipw2100_priv *priv)
3489 {
3490 	int i;
3491 
3492 	INIT_LIST_HEAD(&priv->msg_free_list);
3493 	INIT_LIST_HEAD(&priv->msg_pend_list);
3494 
3495 	for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++)
3496 		list_add_tail(&priv->msg_buffers[i].list, &priv->msg_free_list);
3497 	SET_STAT(&priv->msg_free_stat, i);
3498 
3499 	return 0;
3500 }
3501 
3502 static void ipw2100_msg_free(struct ipw2100_priv *priv)
3503 {
3504 	int i;
3505 
3506 	if (!priv->msg_buffers)
3507 		return;
3508 
3509 	for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) {
3510 		pci_free_consistent(priv->pci_dev,
3511 				    sizeof(struct ipw2100_cmd_header),
3512 				    priv->msg_buffers[i].info.c_struct.cmd,
3513 				    priv->msg_buffers[i].info.c_struct.
3514 				    cmd_phys);
3515 	}
3516 
3517 	kfree(priv->msg_buffers);
3518 	priv->msg_buffers = NULL;
3519 }
3520 
3521 static ssize_t show_pci(struct device *d, struct device_attribute *attr,
3522 			char *buf)
3523 {
3524 	struct pci_dev *pci_dev = to_pci_dev(d);
3525 	char *out = buf;
3526 	int i, j;
3527 	u32 val;
3528 
3529 	for (i = 0; i < 16; i++) {
3530 		out += sprintf(out, "[%08X] ", i * 16);
3531 		for (j = 0; j < 16; j += 4) {
3532 			pci_read_config_dword(pci_dev, i * 16 + j, &val);
3533 			out += sprintf(out, "%08X ", val);
3534 		}
3535 		out += sprintf(out, "\n");
3536 	}
3537 
3538 	return out - buf;
3539 }
3540 
3541 static DEVICE_ATTR(pci, S_IRUGO, show_pci, NULL);
3542 
3543 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
3544 			char *buf)
3545 {
3546 	struct ipw2100_priv *p = dev_get_drvdata(d);
3547 	return sprintf(buf, "0x%08x\n", (int)p->config);
3548 }
3549 
3550 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
3551 
3552 static ssize_t show_status(struct device *d, struct device_attribute *attr,
3553 			   char *buf)
3554 {
3555 	struct ipw2100_priv *p = dev_get_drvdata(d);
3556 	return sprintf(buf, "0x%08x\n", (int)p->status);
3557 }
3558 
3559 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
3560 
3561 static ssize_t show_capability(struct device *d, struct device_attribute *attr,
3562 			       char *buf)
3563 {
3564 	struct ipw2100_priv *p = dev_get_drvdata(d);
3565 	return sprintf(buf, "0x%08x\n", (int)p->capability);
3566 }
3567 
3568 static DEVICE_ATTR(capability, S_IRUGO, show_capability, NULL);
3569 
3570 #define IPW2100_REG(x) { IPW_ ##x, #x }
3571 static const struct {
3572 	u32 addr;
3573 	const char *name;
3574 } hw_data[] = {
3575 IPW2100_REG(REG_GP_CNTRL),
3576 	    IPW2100_REG(REG_GPIO),
3577 	    IPW2100_REG(REG_INTA),
3578 	    IPW2100_REG(REG_INTA_MASK), IPW2100_REG(REG_RESET_REG),};
3579 #define IPW2100_NIC(x, s) { x, #x, s }
3580 static const struct {
3581 	u32 addr;
3582 	const char *name;
3583 	size_t size;
3584 } nic_data[] = {
3585 IPW2100_NIC(IPW2100_CONTROL_REG, 2),
3586 	    IPW2100_NIC(0x210014, 1), IPW2100_NIC(0x210000, 1),};
3587 #define IPW2100_ORD(x, d) { IPW_ORD_ ##x, #x, d }
3588 static const struct {
3589 	u8 index;
3590 	const char *name;
3591 	const char *desc;
3592 } ord_data[] = {
3593 IPW2100_ORD(STAT_TX_HOST_REQUESTS, "requested Host Tx's (MSDU)"),
3594 	    IPW2100_ORD(STAT_TX_HOST_COMPLETE,
3595 				"successful Host Tx's (MSDU)"),
3596 	    IPW2100_ORD(STAT_TX_DIR_DATA,
3597 				"successful Directed Tx's (MSDU)"),
3598 	    IPW2100_ORD(STAT_TX_DIR_DATA1,
3599 				"successful Directed Tx's (MSDU) @ 1MB"),
3600 	    IPW2100_ORD(STAT_TX_DIR_DATA2,
3601 				"successful Directed Tx's (MSDU) @ 2MB"),
3602 	    IPW2100_ORD(STAT_TX_DIR_DATA5_5,
3603 				"successful Directed Tx's (MSDU) @ 5_5MB"),
3604 	    IPW2100_ORD(STAT_TX_DIR_DATA11,
3605 				"successful Directed Tx's (MSDU) @ 11MB"),
3606 	    IPW2100_ORD(STAT_TX_NODIR_DATA1,
3607 				"successful Non_Directed Tx's (MSDU) @ 1MB"),
3608 	    IPW2100_ORD(STAT_TX_NODIR_DATA2,
3609 				"successful Non_Directed Tx's (MSDU) @ 2MB"),
3610 	    IPW2100_ORD(STAT_TX_NODIR_DATA5_5,
3611 				"successful Non_Directed Tx's (MSDU) @ 5.5MB"),
3612 	    IPW2100_ORD(STAT_TX_NODIR_DATA11,
3613 				"successful Non_Directed Tx's (MSDU) @ 11MB"),
3614 	    IPW2100_ORD(STAT_NULL_DATA, "successful NULL data Tx's"),
3615 	    IPW2100_ORD(STAT_TX_RTS, "successful Tx RTS"),
3616 	    IPW2100_ORD(STAT_TX_CTS, "successful Tx CTS"),
3617 	    IPW2100_ORD(STAT_TX_ACK, "successful Tx ACK"),
3618 	    IPW2100_ORD(STAT_TX_ASSN, "successful Association Tx's"),
3619 	    IPW2100_ORD(STAT_TX_ASSN_RESP,
3620 				"successful Association response Tx's"),
3621 	    IPW2100_ORD(STAT_TX_REASSN,
3622 				"successful Reassociation Tx's"),
3623 	    IPW2100_ORD(STAT_TX_REASSN_RESP,
3624 				"successful Reassociation response Tx's"),
3625 	    IPW2100_ORD(STAT_TX_PROBE,
3626 				"probes successfully transmitted"),
3627 	    IPW2100_ORD(STAT_TX_PROBE_RESP,
3628 				"probe responses successfully transmitted"),
3629 	    IPW2100_ORD(STAT_TX_BEACON, "tx beacon"),
3630 	    IPW2100_ORD(STAT_TX_ATIM, "Tx ATIM"),
3631 	    IPW2100_ORD(STAT_TX_DISASSN,
3632 				"successful Disassociation TX"),
3633 	    IPW2100_ORD(STAT_TX_AUTH, "successful Authentication Tx"),
3634 	    IPW2100_ORD(STAT_TX_DEAUTH,
3635 				"successful Deauthentication TX"),
3636 	    IPW2100_ORD(STAT_TX_TOTAL_BYTES,
3637 				"Total successful Tx data bytes"),
3638 	    IPW2100_ORD(STAT_TX_RETRIES, "Tx retries"),
3639 	    IPW2100_ORD(STAT_TX_RETRY1, "Tx retries at 1MBPS"),
3640 	    IPW2100_ORD(STAT_TX_RETRY2, "Tx retries at 2MBPS"),
3641 	    IPW2100_ORD(STAT_TX_RETRY5_5, "Tx retries at 5.5MBPS"),
3642 	    IPW2100_ORD(STAT_TX_RETRY11, "Tx retries at 11MBPS"),
3643 	    IPW2100_ORD(STAT_TX_FAILURES, "Tx Failures"),
3644 	    IPW2100_ORD(STAT_TX_MAX_TRIES_IN_HOP,
3645 				"times max tries in a hop failed"),
3646 	    IPW2100_ORD(STAT_TX_DISASSN_FAIL,
3647 				"times disassociation failed"),
3648 	    IPW2100_ORD(STAT_TX_ERR_CTS, "missed/bad CTS frames"),
3649 	    IPW2100_ORD(STAT_TX_ERR_ACK, "tx err due to acks"),
3650 	    IPW2100_ORD(STAT_RX_HOST, "packets passed to host"),
3651 	    IPW2100_ORD(STAT_RX_DIR_DATA, "directed packets"),
3652 	    IPW2100_ORD(STAT_RX_DIR_DATA1, "directed packets at 1MB"),
3653 	    IPW2100_ORD(STAT_RX_DIR_DATA2, "directed packets at 2MB"),
3654 	    IPW2100_ORD(STAT_RX_DIR_DATA5_5,
3655 				"directed packets at 5.5MB"),
3656 	    IPW2100_ORD(STAT_RX_DIR_DATA11, "directed packets at 11MB"),
3657 	    IPW2100_ORD(STAT_RX_NODIR_DATA, "nondirected packets"),
3658 	    IPW2100_ORD(STAT_RX_NODIR_DATA1,
3659 				"nondirected packets at 1MB"),
3660 	    IPW2100_ORD(STAT_RX_NODIR_DATA2,
3661 				"nondirected packets at 2MB"),
3662 	    IPW2100_ORD(STAT_RX_NODIR_DATA5_5,
3663 				"nondirected packets at 5.5MB"),
3664 	    IPW2100_ORD(STAT_RX_NODIR_DATA11,
3665 				"nondirected packets at 11MB"),
3666 	    IPW2100_ORD(STAT_RX_NULL_DATA, "null data rx's"),
3667 	    IPW2100_ORD(STAT_RX_RTS, "Rx RTS"), IPW2100_ORD(STAT_RX_CTS,
3668 								    "Rx CTS"),
3669 	    IPW2100_ORD(STAT_RX_ACK, "Rx ACK"),
3670 	    IPW2100_ORD(STAT_RX_CFEND, "Rx CF End"),
3671 	    IPW2100_ORD(STAT_RX_CFEND_ACK, "Rx CF End + CF Ack"),
3672 	    IPW2100_ORD(STAT_RX_ASSN, "Association Rx's"),
3673 	    IPW2100_ORD(STAT_RX_ASSN_RESP, "Association response Rx's"),
3674 	    IPW2100_ORD(STAT_RX_REASSN, "Reassociation Rx's"),
3675 	    IPW2100_ORD(STAT_RX_REASSN_RESP,
3676 				"Reassociation response Rx's"),
3677 	    IPW2100_ORD(STAT_RX_PROBE, "probe Rx's"),
3678 	    IPW2100_ORD(STAT_RX_PROBE_RESP, "probe response Rx's"),
3679 	    IPW2100_ORD(STAT_RX_BEACON, "Rx beacon"),
3680 	    IPW2100_ORD(STAT_RX_ATIM, "Rx ATIM"),
3681 	    IPW2100_ORD(STAT_RX_DISASSN, "disassociation Rx"),
3682 	    IPW2100_ORD(STAT_RX_AUTH, "authentication Rx"),
3683 	    IPW2100_ORD(STAT_RX_DEAUTH, "deauthentication Rx"),
3684 	    IPW2100_ORD(STAT_RX_TOTAL_BYTES,
3685 				"Total rx data bytes received"),
3686 	    IPW2100_ORD(STAT_RX_ERR_CRC, "packets with Rx CRC error"),
3687 	    IPW2100_ORD(STAT_RX_ERR_CRC1, "Rx CRC errors at 1MB"),
3688 	    IPW2100_ORD(STAT_RX_ERR_CRC2, "Rx CRC errors at 2MB"),
3689 	    IPW2100_ORD(STAT_RX_ERR_CRC5_5, "Rx CRC errors at 5.5MB"),
3690 	    IPW2100_ORD(STAT_RX_ERR_CRC11, "Rx CRC errors at 11MB"),
3691 	    IPW2100_ORD(STAT_RX_DUPLICATE1,
3692 				"duplicate rx packets at 1MB"),
3693 	    IPW2100_ORD(STAT_RX_DUPLICATE2,
3694 				"duplicate rx packets at 2MB"),
3695 	    IPW2100_ORD(STAT_RX_DUPLICATE5_5,
3696 				"duplicate rx packets at 5.5MB"),
3697 	    IPW2100_ORD(STAT_RX_DUPLICATE11,
3698 				"duplicate rx packets at 11MB"),
3699 	    IPW2100_ORD(STAT_RX_DUPLICATE, "duplicate rx packets"),
3700 	    IPW2100_ORD(PERS_DB_LOCK, "locking fw permanent  db"),
3701 	    IPW2100_ORD(PERS_DB_SIZE, "size of fw permanent  db"),
3702 	    IPW2100_ORD(PERS_DB_ADDR, "address of fw permanent  db"),
3703 	    IPW2100_ORD(STAT_RX_INVALID_PROTOCOL,
3704 				"rx frames with invalid protocol"),
3705 	    IPW2100_ORD(SYS_BOOT_TIME, "Boot time"),
3706 	    IPW2100_ORD(STAT_RX_NO_BUFFER,
3707 				"rx frames rejected due to no buffer"),
3708 	    IPW2100_ORD(STAT_RX_MISSING_FRAG,
3709 				"rx frames dropped due to missing fragment"),
3710 	    IPW2100_ORD(STAT_RX_ORPHAN_FRAG,
3711 				"rx frames dropped due to non-sequential fragment"),
3712 	    IPW2100_ORD(STAT_RX_ORPHAN_FRAME,
3713 				"rx frames dropped due to unmatched 1st frame"),
3714 	    IPW2100_ORD(STAT_RX_FRAG_AGEOUT,
3715 				"rx frames dropped due to uncompleted frame"),
3716 	    IPW2100_ORD(STAT_RX_ICV_ERRORS,
3717 				"ICV errors during decryption"),
3718 	    IPW2100_ORD(STAT_PSP_SUSPENSION, "times adapter suspended"),
3719 	    IPW2100_ORD(STAT_PSP_BCN_TIMEOUT, "beacon timeout"),
3720 	    IPW2100_ORD(STAT_PSP_POLL_TIMEOUT,
3721 				"poll response timeouts"),
3722 	    IPW2100_ORD(STAT_PSP_NONDIR_TIMEOUT,
3723 				"timeouts waiting for last {broad,multi}cast pkt"),
3724 	    IPW2100_ORD(STAT_PSP_RX_DTIMS, "PSP DTIMs received"),
3725 	    IPW2100_ORD(STAT_PSP_RX_TIMS, "PSP TIMs received"),
3726 	    IPW2100_ORD(STAT_PSP_STATION_ID, "PSP Station ID"),
3727 	    IPW2100_ORD(LAST_ASSN_TIME, "RTC time of last association"),
3728 	    IPW2100_ORD(STAT_PERCENT_MISSED_BCNS,
3729 				"current calculation of % missed beacons"),
3730 	    IPW2100_ORD(STAT_PERCENT_RETRIES,
3731 				"current calculation of % missed tx retries"),
3732 	    IPW2100_ORD(ASSOCIATED_AP_PTR,
3733 				"0 if not associated, else pointer to AP table entry"),
3734 	    IPW2100_ORD(AVAILABLE_AP_CNT,
3735 				"AP's decsribed in the AP table"),
3736 	    IPW2100_ORD(AP_LIST_PTR, "Ptr to list of available APs"),
3737 	    IPW2100_ORD(STAT_AP_ASSNS, "associations"),
3738 	    IPW2100_ORD(STAT_ASSN_FAIL, "association failures"),
3739 	    IPW2100_ORD(STAT_ASSN_RESP_FAIL,
3740 				"failures due to response fail"),
3741 	    IPW2100_ORD(STAT_FULL_SCANS, "full scans"),
3742 	    IPW2100_ORD(CARD_DISABLED, "Card Disabled"),
3743 	    IPW2100_ORD(STAT_ROAM_INHIBIT,
3744 				"times roaming was inhibited due to activity"),
3745 	    IPW2100_ORD(RSSI_AT_ASSN,
3746 				"RSSI of associated AP at time of association"),
3747 	    IPW2100_ORD(STAT_ASSN_CAUSE1,
3748 				"reassociation: no probe response or TX on hop"),
3749 	    IPW2100_ORD(STAT_ASSN_CAUSE2,
3750 				"reassociation: poor tx/rx quality"),
3751 	    IPW2100_ORD(STAT_ASSN_CAUSE3,
3752 				"reassociation: tx/rx quality (excessive AP load"),
3753 	    IPW2100_ORD(STAT_ASSN_CAUSE4,
3754 				"reassociation: AP RSSI level"),
3755 	    IPW2100_ORD(STAT_ASSN_CAUSE5,
3756 				"reassociations due to load leveling"),
3757 	    IPW2100_ORD(STAT_AUTH_FAIL, "times authentication failed"),
3758 	    IPW2100_ORD(STAT_AUTH_RESP_FAIL,
3759 				"times authentication response failed"),
3760 	    IPW2100_ORD(STATION_TABLE_CNT,
3761 				"entries in association table"),
3762 	    IPW2100_ORD(RSSI_AVG_CURR, "Current avg RSSI"),
3763 	    IPW2100_ORD(POWER_MGMT_MODE, "Power mode - 0=CAM, 1=PSP"),
3764 	    IPW2100_ORD(COUNTRY_CODE,
3765 				"IEEE country code as recv'd from beacon"),
3766 	    IPW2100_ORD(COUNTRY_CHANNELS,
3767 				"channels supported by country"),
3768 	    IPW2100_ORD(RESET_CNT, "adapter resets (warm)"),
3769 	    IPW2100_ORD(BEACON_INTERVAL, "Beacon interval"),
3770 	    IPW2100_ORD(ANTENNA_DIVERSITY,
3771 				"TRUE if antenna diversity is disabled"),
3772 	    IPW2100_ORD(DTIM_PERIOD, "beacon intervals between DTIMs"),
3773 	    IPW2100_ORD(OUR_FREQ,
3774 				"current radio freq lower digits - channel ID"),
3775 	    IPW2100_ORD(RTC_TIME, "current RTC time"),
3776 	    IPW2100_ORD(PORT_TYPE, "operating mode"),
3777 	    IPW2100_ORD(CURRENT_TX_RATE, "current tx rate"),
3778 	    IPW2100_ORD(SUPPORTED_RATES, "supported tx rates"),
3779 	    IPW2100_ORD(ATIM_WINDOW, "current ATIM Window"),
3780 	    IPW2100_ORD(BASIC_RATES, "basic tx rates"),
3781 	    IPW2100_ORD(NIC_HIGHEST_RATE, "NIC highest tx rate"),
3782 	    IPW2100_ORD(AP_HIGHEST_RATE, "AP highest tx rate"),
3783 	    IPW2100_ORD(CAPABILITIES,
3784 				"Management frame capability field"),
3785 	    IPW2100_ORD(AUTH_TYPE, "Type of authentication"),
3786 	    IPW2100_ORD(RADIO_TYPE, "Adapter card platform type"),
3787 	    IPW2100_ORD(RTS_THRESHOLD,
3788 				"Min packet length for RTS handshaking"),
3789 	    IPW2100_ORD(INT_MODE, "International mode"),
3790 	    IPW2100_ORD(FRAGMENTATION_THRESHOLD,
3791 				"protocol frag threshold"),
3792 	    IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_START_ADDRESS,
3793 				"EEPROM offset in SRAM"),
3794 	    IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_SIZE,
3795 				"EEPROM size in SRAM"),
3796 	    IPW2100_ORD(EEPROM_SKU_CAPABILITY, "EEPROM SKU Capability"),
3797 	    IPW2100_ORD(EEPROM_IBSS_11B_CHANNELS,
3798 				"EEPROM IBSS 11b channel set"),
3799 	    IPW2100_ORD(MAC_VERSION, "MAC Version"),
3800 	    IPW2100_ORD(MAC_REVISION, "MAC Revision"),
3801 	    IPW2100_ORD(RADIO_VERSION, "Radio Version"),
3802 	    IPW2100_ORD(NIC_MANF_DATE_TIME, "MANF Date/Time STAMP"),
3803 	    IPW2100_ORD(UCODE_VERSION, "Ucode Version"),};
3804 
3805 static ssize_t show_registers(struct device *d, struct device_attribute *attr,
3806 			      char *buf)
3807 {
3808 	int i;
3809 	struct ipw2100_priv *priv = dev_get_drvdata(d);
3810 	struct net_device *dev = priv->net_dev;
3811 	char *out = buf;
3812 	u32 val = 0;
3813 
3814 	out += sprintf(out, "%30s [Address ] : Hex\n", "Register");
3815 
3816 	for (i = 0; i < ARRAY_SIZE(hw_data); i++) {
3817 		read_register(dev, hw_data[i].addr, &val);
3818 		out += sprintf(out, "%30s [%08X] : %08X\n",
3819 			       hw_data[i].name, hw_data[i].addr, val);
3820 	}
3821 
3822 	return out - buf;
3823 }
3824 
3825 static DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL);
3826 
3827 static ssize_t show_hardware(struct device *d, struct device_attribute *attr,
3828 			     char *buf)
3829 {
3830 	struct ipw2100_priv *priv = dev_get_drvdata(d);
3831 	struct net_device *dev = priv->net_dev;
3832 	char *out = buf;
3833 	int i;
3834 
3835 	out += sprintf(out, "%30s [Address ] : Hex\n", "NIC entry");
3836 
3837 	for (i = 0; i < ARRAY_SIZE(nic_data); i++) {
3838 		u8 tmp8;
3839 		u16 tmp16;
3840 		u32 tmp32;
3841 
3842 		switch (nic_data[i].size) {
3843 		case 1:
3844 			read_nic_byte(dev, nic_data[i].addr, &tmp8);
3845 			out += sprintf(out, "%30s [%08X] : %02X\n",
3846 				       nic_data[i].name, nic_data[i].addr,
3847 				       tmp8);
3848 			break;
3849 		case 2:
3850 			read_nic_word(dev, nic_data[i].addr, &tmp16);
3851 			out += sprintf(out, "%30s [%08X] : %04X\n",
3852 				       nic_data[i].name, nic_data[i].addr,
3853 				       tmp16);
3854 			break;
3855 		case 4:
3856 			read_nic_dword(dev, nic_data[i].addr, &tmp32);
3857 			out += sprintf(out, "%30s [%08X] : %08X\n",
3858 				       nic_data[i].name, nic_data[i].addr,
3859 				       tmp32);
3860 			break;
3861 		}
3862 	}
3863 	return out - buf;
3864 }
3865 
3866 static DEVICE_ATTR(hardware, S_IRUGO, show_hardware, NULL);
3867 
3868 static ssize_t show_memory(struct device *d, struct device_attribute *attr,
3869 			   char *buf)
3870 {
3871 	struct ipw2100_priv *priv = dev_get_drvdata(d);
3872 	struct net_device *dev = priv->net_dev;
3873 	static unsigned long loop = 0;
3874 	int len = 0;
3875 	u32 buffer[4];
3876 	int i;
3877 	char line[81];
3878 
3879 	if (loop >= 0x30000)
3880 		loop = 0;
3881 
3882 	/* sysfs provides us PAGE_SIZE buffer */
3883 	while (len < PAGE_SIZE - 128 && loop < 0x30000) {
3884 
3885 		if (priv->snapshot[0])
3886 			for (i = 0; i < 4; i++)
3887 				buffer[i] =
3888 				    *(u32 *) SNAPSHOT_ADDR(loop + i * 4);
3889 		else
3890 			for (i = 0; i < 4; i++)
3891 				read_nic_dword(dev, loop + i * 4, &buffer[i]);
3892 
3893 		if (priv->dump_raw)
3894 			len += sprintf(buf + len,
3895 				       "%c%c%c%c"
3896 				       "%c%c%c%c"
3897 				       "%c%c%c%c"
3898 				       "%c%c%c%c",
3899 				       ((u8 *) buffer)[0x0],
3900 				       ((u8 *) buffer)[0x1],
3901 				       ((u8 *) buffer)[0x2],
3902 				       ((u8 *) buffer)[0x3],
3903 				       ((u8 *) buffer)[0x4],
3904 				       ((u8 *) buffer)[0x5],
3905 				       ((u8 *) buffer)[0x6],
3906 				       ((u8 *) buffer)[0x7],
3907 				       ((u8 *) buffer)[0x8],
3908 				       ((u8 *) buffer)[0x9],
3909 				       ((u8 *) buffer)[0xa],
3910 				       ((u8 *) buffer)[0xb],
3911 				       ((u8 *) buffer)[0xc],
3912 				       ((u8 *) buffer)[0xd],
3913 				       ((u8 *) buffer)[0xe],
3914 				       ((u8 *) buffer)[0xf]);
3915 		else
3916 			len += sprintf(buf + len, "%s\n",
3917 				       snprint_line(line, sizeof(line),
3918 						    (u8 *) buffer, 16, loop));
3919 		loop += 16;
3920 	}
3921 
3922 	return len;
3923 }
3924 
3925 static ssize_t store_memory(struct device *d, struct device_attribute *attr,
3926 			    const char *buf, size_t count)
3927 {
3928 	struct ipw2100_priv *priv = dev_get_drvdata(d);
3929 	struct net_device *dev = priv->net_dev;
3930 	const char *p = buf;
3931 
3932 	(void)dev;		/* kill unused-var warning for debug-only code */
3933 
3934 	if (count < 1)
3935 		return count;
3936 
3937 	if (p[0] == '1' ||
3938 	    (count >= 2 && tolower(p[0]) == 'o' && tolower(p[1]) == 'n')) {
3939 		IPW_DEBUG_INFO("%s: Setting memory dump to RAW mode.\n",
3940 			       dev->name);
3941 		priv->dump_raw = 1;
3942 
3943 	} else if (p[0] == '0' || (count >= 2 && tolower(p[0]) == 'o' &&
3944 				   tolower(p[1]) == 'f')) {
3945 		IPW_DEBUG_INFO("%s: Setting memory dump to HEX mode.\n",
3946 			       dev->name);
3947 		priv->dump_raw = 0;
3948 
3949 	} else if (tolower(p[0]) == 'r') {
3950 		IPW_DEBUG_INFO("%s: Resetting firmware snapshot.\n", dev->name);
3951 		ipw2100_snapshot_free(priv);
3952 
3953 	} else
3954 		IPW_DEBUG_INFO("%s: Usage: 0|on = HEX, 1|off = RAW, "
3955 			       "reset = clear memory snapshot\n", dev->name);
3956 
3957 	return count;
3958 }
3959 
3960 static DEVICE_ATTR(memory, S_IWUSR | S_IRUGO, show_memory, store_memory);
3961 
3962 static ssize_t show_ordinals(struct device *d, struct device_attribute *attr,
3963 			     char *buf)
3964 {
3965 	struct ipw2100_priv *priv = dev_get_drvdata(d);
3966 	u32 val = 0;
3967 	int len = 0;
3968 	u32 val_len;
3969 	static int loop = 0;
3970 
3971 	if (priv->status & STATUS_RF_KILL_MASK)
3972 		return 0;
3973 
3974 	if (loop >= ARRAY_SIZE(ord_data))
3975 		loop = 0;
3976 
3977 	/* sysfs provides us PAGE_SIZE buffer */
3978 	while (len < PAGE_SIZE - 128 && loop < ARRAY_SIZE(ord_data)) {
3979 		val_len = sizeof(u32);
3980 
3981 		if (ipw2100_get_ordinal(priv, ord_data[loop].index, &val,
3982 					&val_len))
3983 			len += sprintf(buf + len, "[0x%02X] = ERROR    %s\n",
3984 				       ord_data[loop].index,
3985 				       ord_data[loop].desc);
3986 		else
3987 			len += sprintf(buf + len, "[0x%02X] = 0x%08X %s\n",
3988 				       ord_data[loop].index, val,
3989 				       ord_data[loop].desc);
3990 		loop++;
3991 	}
3992 
3993 	return len;
3994 }
3995 
3996 static DEVICE_ATTR(ordinals, S_IRUGO, show_ordinals, NULL);
3997 
3998 static ssize_t show_stats(struct device *d, struct device_attribute *attr,
3999 			  char *buf)
4000 {
4001 	struct ipw2100_priv *priv = dev_get_drvdata(d);
4002 	char *out = buf;
4003 
4004 	out += sprintf(out, "interrupts: %d {tx: %d, rx: %d, other: %d}\n",
4005 		       priv->interrupts, priv->tx_interrupts,
4006 		       priv->rx_interrupts, priv->inta_other);
4007 	out += sprintf(out, "firmware resets: %d\n", priv->resets);
4008 	out += sprintf(out, "firmware hangs: %d\n", priv->hangs);
4009 #ifdef CONFIG_IPW2100_DEBUG
4010 	out += sprintf(out, "packet mismatch image: %s\n",
4011 		       priv->snapshot[0] ? "YES" : "NO");
4012 #endif
4013 
4014 	return out - buf;
4015 }
4016 
4017 static DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL);
4018 
4019 static int ipw2100_switch_mode(struct ipw2100_priv *priv, u32 mode)
4020 {
4021 	int err;
4022 
4023 	if (mode == priv->ieee->iw_mode)
4024 		return 0;
4025 
4026 	err = ipw2100_disable_adapter(priv);
4027 	if (err) {
4028 		printk(KERN_ERR DRV_NAME ": %s: Could not disable adapter %d\n",
4029 		       priv->net_dev->name, err);
4030 		return err;
4031 	}
4032 
4033 	switch (mode) {
4034 	case IW_MODE_INFRA:
4035 		priv->net_dev->type = ARPHRD_ETHER;
4036 		break;
4037 	case IW_MODE_ADHOC:
4038 		priv->net_dev->type = ARPHRD_ETHER;
4039 		break;
4040 #ifdef CONFIG_IPW2100_MONITOR
4041 	case IW_MODE_MONITOR:
4042 		priv->last_mode = priv->ieee->iw_mode;
4043 		priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
4044 		break;
4045 #endif				/* CONFIG_IPW2100_MONITOR */
4046 	}
4047 
4048 	priv->ieee->iw_mode = mode;
4049 
4050 #ifdef CONFIG_PM
4051 	/* Indicate ipw2100_download_firmware download firmware
4052 	 * from disk instead of memory. */
4053 	ipw2100_firmware.version = 0;
4054 #endif
4055 
4056 	printk(KERN_INFO "%s: Resetting on mode change.\n", priv->net_dev->name);
4057 	priv->reset_backoff = 0;
4058 	schedule_reset(priv);
4059 
4060 	return 0;
4061 }
4062 
4063 static ssize_t show_internals(struct device *d, struct device_attribute *attr,
4064 			      char *buf)
4065 {
4066 	struct ipw2100_priv *priv = dev_get_drvdata(d);
4067 	int len = 0;
4068 
4069 #define DUMP_VAR(x,y) len += sprintf(buf + len, # x ": %" y "\n", priv-> x)
4070 
4071 	if (priv->status & STATUS_ASSOCIATED)
4072 		len += sprintf(buf + len, "connected: %lu\n",
4073 			       get_seconds() - priv->connect_start);
4074 	else
4075 		len += sprintf(buf + len, "not connected\n");
4076 
4077 	DUMP_VAR(ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx], "p");
4078 	DUMP_VAR(status, "08lx");
4079 	DUMP_VAR(config, "08lx");
4080 	DUMP_VAR(capability, "08lx");
4081 
4082 	len +=
4083 	    sprintf(buf + len, "last_rtc: %lu\n",
4084 		    (unsigned long)priv->last_rtc);
4085 
4086 	DUMP_VAR(fatal_error, "d");
4087 	DUMP_VAR(stop_hang_check, "d");
4088 	DUMP_VAR(stop_rf_kill, "d");
4089 	DUMP_VAR(messages_sent, "d");
4090 
4091 	DUMP_VAR(tx_pend_stat.value, "d");
4092 	DUMP_VAR(tx_pend_stat.hi, "d");
4093 
4094 	DUMP_VAR(tx_free_stat.value, "d");
4095 	DUMP_VAR(tx_free_stat.lo, "d");
4096 
4097 	DUMP_VAR(msg_free_stat.value, "d");
4098 	DUMP_VAR(msg_free_stat.lo, "d");
4099 
4100 	DUMP_VAR(msg_pend_stat.value, "d");
4101 	DUMP_VAR(msg_pend_stat.hi, "d");
4102 
4103 	DUMP_VAR(fw_pend_stat.value, "d");
4104 	DUMP_VAR(fw_pend_stat.hi, "d");
4105 
4106 	DUMP_VAR(txq_stat.value, "d");
4107 	DUMP_VAR(txq_stat.lo, "d");
4108 
4109 	DUMP_VAR(ieee->scans, "d");
4110 	DUMP_VAR(reset_backoff, "d");
4111 
4112 	return len;
4113 }
4114 
4115 static DEVICE_ATTR(internals, S_IRUGO, show_internals, NULL);
4116 
4117 static ssize_t show_bssinfo(struct device *d, struct device_attribute *attr,
4118 			    char *buf)
4119 {
4120 	struct ipw2100_priv *priv = dev_get_drvdata(d);
4121 	char essid[IW_ESSID_MAX_SIZE + 1];
4122 	u8 bssid[ETH_ALEN];
4123 	u32 chan = 0;
4124 	char *out = buf;
4125 	unsigned int length;
4126 	int ret;
4127 
4128 	if (priv->status & STATUS_RF_KILL_MASK)
4129 		return 0;
4130 
4131 	memset(essid, 0, sizeof(essid));
4132 	memset(bssid, 0, sizeof(bssid));
4133 
4134 	length = IW_ESSID_MAX_SIZE;
4135 	ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID, essid, &length);
4136 	if (ret)
4137 		IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4138 			       __LINE__);
4139 
4140 	length = sizeof(bssid);
4141 	ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID,
4142 				  bssid, &length);
4143 	if (ret)
4144 		IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4145 			       __LINE__);
4146 
4147 	length = sizeof(u32);
4148 	ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &length);
4149 	if (ret)
4150 		IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4151 			       __LINE__);
4152 
4153 	out += sprintf(out, "ESSID: %s\n", essid);
4154 	out += sprintf(out, "BSSID:   %pM\n", bssid);
4155 	out += sprintf(out, "Channel: %d\n", chan);
4156 
4157 	return out - buf;
4158 }
4159 
4160 static DEVICE_ATTR(bssinfo, S_IRUGO, show_bssinfo, NULL);
4161 
4162 #ifdef CONFIG_IPW2100_DEBUG
4163 static ssize_t debug_level_show(struct device_driver *d, char *buf)
4164 {
4165 	return sprintf(buf, "0x%08X\n", ipw2100_debug_level);
4166 }
4167 
4168 static ssize_t debug_level_store(struct device_driver *d,
4169 				 const char *buf, size_t count)
4170 {
4171 	u32 val;
4172 	int ret;
4173 
4174 	ret = kstrtou32(buf, 0, &val);
4175 	if (ret)
4176 		IPW_DEBUG_INFO(": %s is not in hex or decimal form.\n", buf);
4177 	else
4178 		ipw2100_debug_level = val;
4179 
4180 	return strnlen(buf, count);
4181 }
4182 static DRIVER_ATTR_RW(debug_level);
4183 #endif				/* CONFIG_IPW2100_DEBUG */
4184 
4185 static ssize_t show_fatal_error(struct device *d,
4186 				struct device_attribute *attr, char *buf)
4187 {
4188 	struct ipw2100_priv *priv = dev_get_drvdata(d);
4189 	char *out = buf;
4190 	int i;
4191 
4192 	if (priv->fatal_error)
4193 		out += sprintf(out, "0x%08X\n", priv->fatal_error);
4194 	else
4195 		out += sprintf(out, "0\n");
4196 
4197 	for (i = 1; i <= IPW2100_ERROR_QUEUE; i++) {
4198 		if (!priv->fatal_errors[(priv->fatal_index - i) %
4199 					IPW2100_ERROR_QUEUE])
4200 			continue;
4201 
4202 		out += sprintf(out, "%d. 0x%08X\n", i,
4203 			       priv->fatal_errors[(priv->fatal_index - i) %
4204 						  IPW2100_ERROR_QUEUE]);
4205 	}
4206 
4207 	return out - buf;
4208 }
4209 
4210 static ssize_t store_fatal_error(struct device *d,
4211 				 struct device_attribute *attr, const char *buf,
4212 				 size_t count)
4213 {
4214 	struct ipw2100_priv *priv = dev_get_drvdata(d);
4215 	schedule_reset(priv);
4216 	return count;
4217 }
4218 
4219 static DEVICE_ATTR(fatal_error, S_IWUSR | S_IRUGO, show_fatal_error,
4220 		   store_fatal_error);
4221 
4222 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
4223 			     char *buf)
4224 {
4225 	struct ipw2100_priv *priv = dev_get_drvdata(d);
4226 	return sprintf(buf, "%d\n", priv->ieee->scan_age);
4227 }
4228 
4229 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
4230 			      const char *buf, size_t count)
4231 {
4232 	struct ipw2100_priv *priv = dev_get_drvdata(d);
4233 	struct net_device *dev = priv->net_dev;
4234 	unsigned long val;
4235 	int ret;
4236 
4237 	(void)dev;		/* kill unused-var warning for debug-only code */
4238 
4239 	IPW_DEBUG_INFO("enter\n");
4240 
4241 	ret = kstrtoul(buf, 0, &val);
4242 	if (ret) {
4243 		IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
4244 	} else {
4245 		priv->ieee->scan_age = val;
4246 		IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
4247 	}
4248 
4249 	IPW_DEBUG_INFO("exit\n");
4250 	return strnlen(buf, count);
4251 }
4252 
4253 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
4254 
4255 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
4256 			    char *buf)
4257 {
4258 	/* 0 - RF kill not enabled
4259 	   1 - SW based RF kill active (sysfs)
4260 	   2 - HW based RF kill active
4261 	   3 - Both HW and SW baed RF kill active */
4262 	struct ipw2100_priv *priv = dev_get_drvdata(d);
4263 	int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
4264 	    (rf_kill_active(priv) ? 0x2 : 0x0);
4265 	return sprintf(buf, "%i\n", val);
4266 }
4267 
4268 static int ipw_radio_kill_sw(struct ipw2100_priv *priv, int disable_radio)
4269 {
4270 	if ((disable_radio ? 1 : 0) ==
4271 	    (priv->status & STATUS_RF_KILL_SW ? 1 : 0))
4272 		return 0;
4273 
4274 	IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO  %s\n",
4275 			  disable_radio ? "OFF" : "ON");
4276 
4277 	mutex_lock(&priv->action_mutex);
4278 
4279 	if (disable_radio) {
4280 		priv->status |= STATUS_RF_KILL_SW;
4281 		ipw2100_down(priv);
4282 	} else {
4283 		priv->status &= ~STATUS_RF_KILL_SW;
4284 		if (rf_kill_active(priv)) {
4285 			IPW_DEBUG_RF_KILL("Can not turn radio back on - "
4286 					  "disabled by HW switch\n");
4287 			/* Make sure the RF_KILL check timer is running */
4288 			priv->stop_rf_kill = 0;
4289 			mod_delayed_work(system_wq, &priv->rf_kill,
4290 					 round_jiffies_relative(HZ));
4291 		} else
4292 			schedule_reset(priv);
4293 	}
4294 
4295 	mutex_unlock(&priv->action_mutex);
4296 	return 1;
4297 }
4298 
4299 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
4300 			     const char *buf, size_t count)
4301 {
4302 	struct ipw2100_priv *priv = dev_get_drvdata(d);
4303 	ipw_radio_kill_sw(priv, buf[0] == '1');
4304 	return count;
4305 }
4306 
4307 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
4308 
4309 static struct attribute *ipw2100_sysfs_entries[] = {
4310 	&dev_attr_hardware.attr,
4311 	&dev_attr_registers.attr,
4312 	&dev_attr_ordinals.attr,
4313 	&dev_attr_pci.attr,
4314 	&dev_attr_stats.attr,
4315 	&dev_attr_internals.attr,
4316 	&dev_attr_bssinfo.attr,
4317 	&dev_attr_memory.attr,
4318 	&dev_attr_scan_age.attr,
4319 	&dev_attr_fatal_error.attr,
4320 	&dev_attr_rf_kill.attr,
4321 	&dev_attr_cfg.attr,
4322 	&dev_attr_status.attr,
4323 	&dev_attr_capability.attr,
4324 	NULL,
4325 };
4326 
4327 static struct attribute_group ipw2100_attribute_group = {
4328 	.attrs = ipw2100_sysfs_entries,
4329 };
4330 
4331 static int status_queue_allocate(struct ipw2100_priv *priv, int entries)
4332 {
4333 	struct ipw2100_status_queue *q = &priv->status_queue;
4334 
4335 	IPW_DEBUG_INFO("enter\n");
4336 
4337 	q->size = entries * sizeof(struct ipw2100_status);
4338 	q->drv = pci_zalloc_consistent(priv->pci_dev, q->size, &q->nic);
4339 	if (!q->drv) {
4340 		IPW_DEBUG_WARNING("Can not allocate status queue.\n");
4341 		return -ENOMEM;
4342 	}
4343 
4344 	IPW_DEBUG_INFO("exit\n");
4345 
4346 	return 0;
4347 }
4348 
4349 static void status_queue_free(struct ipw2100_priv *priv)
4350 {
4351 	IPW_DEBUG_INFO("enter\n");
4352 
4353 	if (priv->status_queue.drv) {
4354 		pci_free_consistent(priv->pci_dev, priv->status_queue.size,
4355 				    priv->status_queue.drv,
4356 				    priv->status_queue.nic);
4357 		priv->status_queue.drv = NULL;
4358 	}
4359 
4360 	IPW_DEBUG_INFO("exit\n");
4361 }
4362 
4363 static int bd_queue_allocate(struct ipw2100_priv *priv,
4364 			     struct ipw2100_bd_queue *q, int entries)
4365 {
4366 	IPW_DEBUG_INFO("enter\n");
4367 
4368 	memset(q, 0, sizeof(struct ipw2100_bd_queue));
4369 
4370 	q->entries = entries;
4371 	q->size = entries * sizeof(struct ipw2100_bd);
4372 	q->drv = pci_zalloc_consistent(priv->pci_dev, q->size, &q->nic);
4373 	if (!q->drv) {
4374 		IPW_DEBUG_INFO
4375 		    ("can't allocate shared memory for buffer descriptors\n");
4376 		return -ENOMEM;
4377 	}
4378 
4379 	IPW_DEBUG_INFO("exit\n");
4380 
4381 	return 0;
4382 }
4383 
4384 static void bd_queue_free(struct ipw2100_priv *priv, struct ipw2100_bd_queue *q)
4385 {
4386 	IPW_DEBUG_INFO("enter\n");
4387 
4388 	if (!q)
4389 		return;
4390 
4391 	if (q->drv) {
4392 		pci_free_consistent(priv->pci_dev, q->size, q->drv, q->nic);
4393 		q->drv = NULL;
4394 	}
4395 
4396 	IPW_DEBUG_INFO("exit\n");
4397 }
4398 
4399 static void bd_queue_initialize(struct ipw2100_priv *priv,
4400 				struct ipw2100_bd_queue *q, u32 base, u32 size,
4401 				u32 r, u32 w)
4402 {
4403 	IPW_DEBUG_INFO("enter\n");
4404 
4405 	IPW_DEBUG_INFO("initializing bd queue at virt=%p, phys=%08x\n", q->drv,
4406 		       (u32) q->nic);
4407 
4408 	write_register(priv->net_dev, base, q->nic);
4409 	write_register(priv->net_dev, size, q->entries);
4410 	write_register(priv->net_dev, r, q->oldest);
4411 	write_register(priv->net_dev, w, q->next);
4412 
4413 	IPW_DEBUG_INFO("exit\n");
4414 }
4415 
4416 static void ipw2100_kill_works(struct ipw2100_priv *priv)
4417 {
4418 	priv->stop_rf_kill = 1;
4419 	priv->stop_hang_check = 1;
4420 	cancel_delayed_work_sync(&priv->reset_work);
4421 	cancel_delayed_work_sync(&priv->security_work);
4422 	cancel_delayed_work_sync(&priv->wx_event_work);
4423 	cancel_delayed_work_sync(&priv->hang_check);
4424 	cancel_delayed_work_sync(&priv->rf_kill);
4425 	cancel_delayed_work_sync(&priv->scan_event);
4426 }
4427 
4428 static int ipw2100_tx_allocate(struct ipw2100_priv *priv)
4429 {
4430 	int i, j, err = -EINVAL;
4431 	void *v;
4432 	dma_addr_t p;
4433 
4434 	IPW_DEBUG_INFO("enter\n");
4435 
4436 	err = bd_queue_allocate(priv, &priv->tx_queue, TX_QUEUE_LENGTH);
4437 	if (err) {
4438 		IPW_DEBUG_ERROR("%s: failed bd_queue_allocate\n",
4439 				priv->net_dev->name);
4440 		return err;
4441 	}
4442 
4443 	priv->tx_buffers = kmalloc_array(TX_PENDED_QUEUE_LENGTH,
4444 					 sizeof(struct ipw2100_tx_packet),
4445 					 GFP_ATOMIC);
4446 	if (!priv->tx_buffers) {
4447 		bd_queue_free(priv, &priv->tx_queue);
4448 		return -ENOMEM;
4449 	}
4450 
4451 	for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4452 		v = pci_alloc_consistent(priv->pci_dev,
4453 					 sizeof(struct ipw2100_data_header),
4454 					 &p);
4455 		if (!v) {
4456 			printk(KERN_ERR DRV_NAME
4457 			       ": %s: PCI alloc failed for tx " "buffers.\n",
4458 			       priv->net_dev->name);
4459 			err = -ENOMEM;
4460 			break;
4461 		}
4462 
4463 		priv->tx_buffers[i].type = DATA;
4464 		priv->tx_buffers[i].info.d_struct.data =
4465 		    (struct ipw2100_data_header *)v;
4466 		priv->tx_buffers[i].info.d_struct.data_phys = p;
4467 		priv->tx_buffers[i].info.d_struct.txb = NULL;
4468 	}
4469 
4470 	if (i == TX_PENDED_QUEUE_LENGTH)
4471 		return 0;
4472 
4473 	for (j = 0; j < i; j++) {
4474 		pci_free_consistent(priv->pci_dev,
4475 				    sizeof(struct ipw2100_data_header),
4476 				    priv->tx_buffers[j].info.d_struct.data,
4477 				    priv->tx_buffers[j].info.d_struct.
4478 				    data_phys);
4479 	}
4480 
4481 	kfree(priv->tx_buffers);
4482 	priv->tx_buffers = NULL;
4483 
4484 	return err;
4485 }
4486 
4487 static void ipw2100_tx_initialize(struct ipw2100_priv *priv)
4488 {
4489 	int i;
4490 
4491 	IPW_DEBUG_INFO("enter\n");
4492 
4493 	/*
4494 	 * reinitialize packet info lists
4495 	 */
4496 	INIT_LIST_HEAD(&priv->fw_pend_list);
4497 	INIT_STAT(&priv->fw_pend_stat);
4498 
4499 	/*
4500 	 * reinitialize lists
4501 	 */
4502 	INIT_LIST_HEAD(&priv->tx_pend_list);
4503 	INIT_LIST_HEAD(&priv->tx_free_list);
4504 	INIT_STAT(&priv->tx_pend_stat);
4505 	INIT_STAT(&priv->tx_free_stat);
4506 
4507 	for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4508 		/* We simply drop any SKBs that have been queued for
4509 		 * transmit */
4510 		if (priv->tx_buffers[i].info.d_struct.txb) {
4511 			libipw_txb_free(priv->tx_buffers[i].info.d_struct.
4512 					   txb);
4513 			priv->tx_buffers[i].info.d_struct.txb = NULL;
4514 		}
4515 
4516 		list_add_tail(&priv->tx_buffers[i].list, &priv->tx_free_list);
4517 	}
4518 
4519 	SET_STAT(&priv->tx_free_stat, i);
4520 
4521 	priv->tx_queue.oldest = 0;
4522 	priv->tx_queue.available = priv->tx_queue.entries;
4523 	priv->tx_queue.next = 0;
4524 	INIT_STAT(&priv->txq_stat);
4525 	SET_STAT(&priv->txq_stat, priv->tx_queue.available);
4526 
4527 	bd_queue_initialize(priv, &priv->tx_queue,
4528 			    IPW_MEM_HOST_SHARED_TX_QUEUE_BD_BASE,
4529 			    IPW_MEM_HOST_SHARED_TX_QUEUE_BD_SIZE,
4530 			    IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX,
4531 			    IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX);
4532 
4533 	IPW_DEBUG_INFO("exit\n");
4534 
4535 }
4536 
4537 static void ipw2100_tx_free(struct ipw2100_priv *priv)
4538 {
4539 	int i;
4540 
4541 	IPW_DEBUG_INFO("enter\n");
4542 
4543 	bd_queue_free(priv, &priv->tx_queue);
4544 
4545 	if (!priv->tx_buffers)
4546 		return;
4547 
4548 	for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4549 		if (priv->tx_buffers[i].info.d_struct.txb) {
4550 			libipw_txb_free(priv->tx_buffers[i].info.d_struct.
4551 					   txb);
4552 			priv->tx_buffers[i].info.d_struct.txb = NULL;
4553 		}
4554 		if (priv->tx_buffers[i].info.d_struct.data)
4555 			pci_free_consistent(priv->pci_dev,
4556 					    sizeof(struct ipw2100_data_header),
4557 					    priv->tx_buffers[i].info.d_struct.
4558 					    data,
4559 					    priv->tx_buffers[i].info.d_struct.
4560 					    data_phys);
4561 	}
4562 
4563 	kfree(priv->tx_buffers);
4564 	priv->tx_buffers = NULL;
4565 
4566 	IPW_DEBUG_INFO("exit\n");
4567 }
4568 
4569 static int ipw2100_rx_allocate(struct ipw2100_priv *priv)
4570 {
4571 	int i, j, err = -EINVAL;
4572 
4573 	IPW_DEBUG_INFO("enter\n");
4574 
4575 	err = bd_queue_allocate(priv, &priv->rx_queue, RX_QUEUE_LENGTH);
4576 	if (err) {
4577 		IPW_DEBUG_INFO("failed bd_queue_allocate\n");
4578 		return err;
4579 	}
4580 
4581 	err = status_queue_allocate(priv, RX_QUEUE_LENGTH);
4582 	if (err) {
4583 		IPW_DEBUG_INFO("failed status_queue_allocate\n");
4584 		bd_queue_free(priv, &priv->rx_queue);
4585 		return err;
4586 	}
4587 
4588 	/*
4589 	 * allocate packets
4590 	 */
4591 	priv->rx_buffers = kmalloc(RX_QUEUE_LENGTH *
4592 				   sizeof(struct ipw2100_rx_packet),
4593 				   GFP_KERNEL);
4594 	if (!priv->rx_buffers) {
4595 		IPW_DEBUG_INFO("can't allocate rx packet buffer table\n");
4596 
4597 		bd_queue_free(priv, &priv->rx_queue);
4598 
4599 		status_queue_free(priv);
4600 
4601 		return -ENOMEM;
4602 	}
4603 
4604 	for (i = 0; i < RX_QUEUE_LENGTH; i++) {
4605 		struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
4606 
4607 		err = ipw2100_alloc_skb(priv, packet);
4608 		if (unlikely(err)) {
4609 			err = -ENOMEM;
4610 			break;
4611 		}
4612 
4613 		/* The BD holds the cache aligned address */
4614 		priv->rx_queue.drv[i].host_addr = packet->dma_addr;
4615 		priv->rx_queue.drv[i].buf_length = IPW_RX_NIC_BUFFER_LENGTH;
4616 		priv->status_queue.drv[i].status_fields = 0;
4617 	}
4618 
4619 	if (i == RX_QUEUE_LENGTH)
4620 		return 0;
4621 
4622 	for (j = 0; j < i; j++) {
4623 		pci_unmap_single(priv->pci_dev, priv->rx_buffers[j].dma_addr,
4624 				 sizeof(struct ipw2100_rx_packet),
4625 				 PCI_DMA_FROMDEVICE);
4626 		dev_kfree_skb(priv->rx_buffers[j].skb);
4627 	}
4628 
4629 	kfree(priv->rx_buffers);
4630 	priv->rx_buffers = NULL;
4631 
4632 	bd_queue_free(priv, &priv->rx_queue);
4633 
4634 	status_queue_free(priv);
4635 
4636 	return err;
4637 }
4638 
4639 static void ipw2100_rx_initialize(struct ipw2100_priv *priv)
4640 {
4641 	IPW_DEBUG_INFO("enter\n");
4642 
4643 	priv->rx_queue.oldest = 0;
4644 	priv->rx_queue.available = priv->rx_queue.entries - 1;
4645 	priv->rx_queue.next = priv->rx_queue.entries - 1;
4646 
4647 	INIT_STAT(&priv->rxq_stat);
4648 	SET_STAT(&priv->rxq_stat, priv->rx_queue.available);
4649 
4650 	bd_queue_initialize(priv, &priv->rx_queue,
4651 			    IPW_MEM_HOST_SHARED_RX_BD_BASE,
4652 			    IPW_MEM_HOST_SHARED_RX_BD_SIZE,
4653 			    IPW_MEM_HOST_SHARED_RX_READ_INDEX,
4654 			    IPW_MEM_HOST_SHARED_RX_WRITE_INDEX);
4655 
4656 	/* set up the status queue */
4657 	write_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_STATUS_BASE,
4658 		       priv->status_queue.nic);
4659 
4660 	IPW_DEBUG_INFO("exit\n");
4661 }
4662 
4663 static void ipw2100_rx_free(struct ipw2100_priv *priv)
4664 {
4665 	int i;
4666 
4667 	IPW_DEBUG_INFO("enter\n");
4668 
4669 	bd_queue_free(priv, &priv->rx_queue);
4670 	status_queue_free(priv);
4671 
4672 	if (!priv->rx_buffers)
4673 		return;
4674 
4675 	for (i = 0; i < RX_QUEUE_LENGTH; i++) {
4676 		if (priv->rx_buffers[i].rxp) {
4677 			pci_unmap_single(priv->pci_dev,
4678 					 priv->rx_buffers[i].dma_addr,
4679 					 sizeof(struct ipw2100_rx),
4680 					 PCI_DMA_FROMDEVICE);
4681 			dev_kfree_skb(priv->rx_buffers[i].skb);
4682 		}
4683 	}
4684 
4685 	kfree(priv->rx_buffers);
4686 	priv->rx_buffers = NULL;
4687 
4688 	IPW_DEBUG_INFO("exit\n");
4689 }
4690 
4691 static int ipw2100_read_mac_address(struct ipw2100_priv *priv)
4692 {
4693 	u32 length = ETH_ALEN;
4694 	u8 addr[ETH_ALEN];
4695 
4696 	int err;
4697 
4698 	err = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ADAPTER_MAC, addr, &length);
4699 	if (err) {
4700 		IPW_DEBUG_INFO("MAC address read failed\n");
4701 		return -EIO;
4702 	}
4703 
4704 	memcpy(priv->net_dev->dev_addr, addr, ETH_ALEN);
4705 	IPW_DEBUG_INFO("card MAC is %pM\n", priv->net_dev->dev_addr);
4706 
4707 	return 0;
4708 }
4709 
4710 /********************************************************************
4711  *
4712  * Firmware Commands
4713  *
4714  ********************************************************************/
4715 
4716 static int ipw2100_set_mac_address(struct ipw2100_priv *priv, int batch_mode)
4717 {
4718 	struct host_command cmd = {
4719 		.host_command = ADAPTER_ADDRESS,
4720 		.host_command_sequence = 0,
4721 		.host_command_length = ETH_ALEN
4722 	};
4723 	int err;
4724 
4725 	IPW_DEBUG_HC("SET_MAC_ADDRESS\n");
4726 
4727 	IPW_DEBUG_INFO("enter\n");
4728 
4729 	if (priv->config & CFG_CUSTOM_MAC) {
4730 		memcpy(cmd.host_command_parameters, priv->mac_addr, ETH_ALEN);
4731 		memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
4732 	} else
4733 		memcpy(cmd.host_command_parameters, priv->net_dev->dev_addr,
4734 		       ETH_ALEN);
4735 
4736 	err = ipw2100_hw_send_command(priv, &cmd);
4737 
4738 	IPW_DEBUG_INFO("exit\n");
4739 	return err;
4740 }
4741 
4742 static int ipw2100_set_port_type(struct ipw2100_priv *priv, u32 port_type,
4743 				 int batch_mode)
4744 {
4745 	struct host_command cmd = {
4746 		.host_command = PORT_TYPE,
4747 		.host_command_sequence = 0,
4748 		.host_command_length = sizeof(u32)
4749 	};
4750 	int err;
4751 
4752 	switch (port_type) {
4753 	case IW_MODE_INFRA:
4754 		cmd.host_command_parameters[0] = IPW_BSS;
4755 		break;
4756 	case IW_MODE_ADHOC:
4757 		cmd.host_command_parameters[0] = IPW_IBSS;
4758 		break;
4759 	}
4760 
4761 	IPW_DEBUG_HC("PORT_TYPE: %s\n",
4762 		     port_type == IPW_IBSS ? "Ad-Hoc" : "Managed");
4763 
4764 	if (!batch_mode) {
4765 		err = ipw2100_disable_adapter(priv);
4766 		if (err) {
4767 			printk(KERN_ERR DRV_NAME
4768 			       ": %s: Could not disable adapter %d\n",
4769 			       priv->net_dev->name, err);
4770 			return err;
4771 		}
4772 	}
4773 
4774 	/* send cmd to firmware */
4775 	err = ipw2100_hw_send_command(priv, &cmd);
4776 
4777 	if (!batch_mode)
4778 		ipw2100_enable_adapter(priv);
4779 
4780 	return err;
4781 }
4782 
4783 static int ipw2100_set_channel(struct ipw2100_priv *priv, u32 channel,
4784 			       int batch_mode)
4785 {
4786 	struct host_command cmd = {
4787 		.host_command = CHANNEL,
4788 		.host_command_sequence = 0,
4789 		.host_command_length = sizeof(u32)
4790 	};
4791 	int err;
4792 
4793 	cmd.host_command_parameters[0] = channel;
4794 
4795 	IPW_DEBUG_HC("CHANNEL: %d\n", channel);
4796 
4797 	/* If BSS then we don't support channel selection */
4798 	if (priv->ieee->iw_mode == IW_MODE_INFRA)
4799 		return 0;
4800 
4801 	if ((channel != 0) &&
4802 	    ((channel < REG_MIN_CHANNEL) || (channel > REG_MAX_CHANNEL)))
4803 		return -EINVAL;
4804 
4805 	if (!batch_mode) {
4806 		err = ipw2100_disable_adapter(priv);
4807 		if (err)
4808 			return err;
4809 	}
4810 
4811 	err = ipw2100_hw_send_command(priv, &cmd);
4812 	if (err) {
4813 		IPW_DEBUG_INFO("Failed to set channel to %d", channel);
4814 		return err;
4815 	}
4816 
4817 	if (channel)
4818 		priv->config |= CFG_STATIC_CHANNEL;
4819 	else
4820 		priv->config &= ~CFG_STATIC_CHANNEL;
4821 
4822 	priv->channel = channel;
4823 
4824 	if (!batch_mode) {
4825 		err = ipw2100_enable_adapter(priv);
4826 		if (err)
4827 			return err;
4828 	}
4829 
4830 	return 0;
4831 }
4832 
4833 static int ipw2100_system_config(struct ipw2100_priv *priv, int batch_mode)
4834 {
4835 	struct host_command cmd = {
4836 		.host_command = SYSTEM_CONFIG,
4837 		.host_command_sequence = 0,
4838 		.host_command_length = 12,
4839 	};
4840 	u32 ibss_mask, len = sizeof(u32);
4841 	int err;
4842 
4843 	/* Set system configuration */
4844 
4845 	if (!batch_mode) {
4846 		err = ipw2100_disable_adapter(priv);
4847 		if (err)
4848 			return err;
4849 	}
4850 
4851 	if (priv->ieee->iw_mode == IW_MODE_ADHOC)
4852 		cmd.host_command_parameters[0] |= IPW_CFG_IBSS_AUTO_START;
4853 
4854 	cmd.host_command_parameters[0] |= IPW_CFG_IBSS_MASK |
4855 	    IPW_CFG_BSS_MASK | IPW_CFG_802_1x_ENABLE;
4856 
4857 	if (!(priv->config & CFG_LONG_PREAMBLE))
4858 		cmd.host_command_parameters[0] |= IPW_CFG_PREAMBLE_AUTO;
4859 
4860 	err = ipw2100_get_ordinal(priv,
4861 				  IPW_ORD_EEPROM_IBSS_11B_CHANNELS,
4862 				  &ibss_mask, &len);
4863 	if (err)
4864 		ibss_mask = IPW_IBSS_11B_DEFAULT_MASK;
4865 
4866 	cmd.host_command_parameters[1] = REG_CHANNEL_MASK;
4867 	cmd.host_command_parameters[2] = REG_CHANNEL_MASK & ibss_mask;
4868 
4869 	/* 11b only */
4870 	/*cmd.host_command_parameters[0] |= DIVERSITY_ANTENNA_A; */
4871 
4872 	err = ipw2100_hw_send_command(priv, &cmd);
4873 	if (err)
4874 		return err;
4875 
4876 /* If IPv6 is configured in the kernel then we don't want to filter out all
4877  * of the multicast packets as IPv6 needs some. */
4878 #if !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE)
4879 	cmd.host_command = ADD_MULTICAST;
4880 	cmd.host_command_sequence = 0;
4881 	cmd.host_command_length = 0;
4882 
4883 	ipw2100_hw_send_command(priv, &cmd);
4884 #endif
4885 	if (!batch_mode) {
4886 		err = ipw2100_enable_adapter(priv);
4887 		if (err)
4888 			return err;
4889 	}
4890 
4891 	return 0;
4892 }
4893 
4894 static int ipw2100_set_tx_rates(struct ipw2100_priv *priv, u32 rate,
4895 				int batch_mode)
4896 {
4897 	struct host_command cmd = {
4898 		.host_command = BASIC_TX_RATES,
4899 		.host_command_sequence = 0,
4900 		.host_command_length = 4
4901 	};
4902 	int err;
4903 
4904 	cmd.host_command_parameters[0] = rate & TX_RATE_MASK;
4905 
4906 	if (!batch_mode) {
4907 		err = ipw2100_disable_adapter(priv);
4908 		if (err)
4909 			return err;
4910 	}
4911 
4912 	/* Set BASIC TX Rate first */
4913 	ipw2100_hw_send_command(priv, &cmd);
4914 
4915 	/* Set TX Rate */
4916 	cmd.host_command = TX_RATES;
4917 	ipw2100_hw_send_command(priv, &cmd);
4918 
4919 	/* Set MSDU TX Rate */
4920 	cmd.host_command = MSDU_TX_RATES;
4921 	ipw2100_hw_send_command(priv, &cmd);
4922 
4923 	if (!batch_mode) {
4924 		err = ipw2100_enable_adapter(priv);
4925 		if (err)
4926 			return err;
4927 	}
4928 
4929 	priv->tx_rates = rate;
4930 
4931 	return 0;
4932 }
4933 
4934 static int ipw2100_set_power_mode(struct ipw2100_priv *priv, int power_level)
4935 {
4936 	struct host_command cmd = {
4937 		.host_command = POWER_MODE,
4938 		.host_command_sequence = 0,
4939 		.host_command_length = 4
4940 	};
4941 	int err;
4942 
4943 	cmd.host_command_parameters[0] = power_level;
4944 
4945 	err = ipw2100_hw_send_command(priv, &cmd);
4946 	if (err)
4947 		return err;
4948 
4949 	if (power_level == IPW_POWER_MODE_CAM)
4950 		priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
4951 	else
4952 		priv->power_mode = IPW_POWER_ENABLED | power_level;
4953 
4954 #ifdef IPW2100_TX_POWER
4955 	if (priv->port_type == IBSS && priv->adhoc_power != DFTL_IBSS_TX_POWER) {
4956 		/* Set beacon interval */
4957 		cmd.host_command = TX_POWER_INDEX;
4958 		cmd.host_command_parameters[0] = (u32) priv->adhoc_power;
4959 
4960 		err = ipw2100_hw_send_command(priv, &cmd);
4961 		if (err)
4962 			return err;
4963 	}
4964 #endif
4965 
4966 	return 0;
4967 }
4968 
4969 static int ipw2100_set_rts_threshold(struct ipw2100_priv *priv, u32 threshold)
4970 {
4971 	struct host_command cmd = {
4972 		.host_command = RTS_THRESHOLD,
4973 		.host_command_sequence = 0,
4974 		.host_command_length = 4
4975 	};
4976 	int err;
4977 
4978 	if (threshold & RTS_DISABLED)
4979 		cmd.host_command_parameters[0] = MAX_RTS_THRESHOLD;
4980 	else
4981 		cmd.host_command_parameters[0] = threshold & ~RTS_DISABLED;
4982 
4983 	err = ipw2100_hw_send_command(priv, &cmd);
4984 	if (err)
4985 		return err;
4986 
4987 	priv->rts_threshold = threshold;
4988 
4989 	return 0;
4990 }
4991 
4992 #if 0
4993 int ipw2100_set_fragmentation_threshold(struct ipw2100_priv *priv,
4994 					u32 threshold, int batch_mode)
4995 {
4996 	struct host_command cmd = {
4997 		.host_command = FRAG_THRESHOLD,
4998 		.host_command_sequence = 0,
4999 		.host_command_length = 4,
5000 		.host_command_parameters[0] = 0,
5001 	};
5002 	int err;
5003 
5004 	if (!batch_mode) {
5005 		err = ipw2100_disable_adapter(priv);
5006 		if (err)
5007 			return err;
5008 	}
5009 
5010 	if (threshold == 0)
5011 		threshold = DEFAULT_FRAG_THRESHOLD;
5012 	else {
5013 		threshold = max(threshold, MIN_FRAG_THRESHOLD);
5014 		threshold = min(threshold, MAX_FRAG_THRESHOLD);
5015 	}
5016 
5017 	cmd.host_command_parameters[0] = threshold;
5018 
5019 	IPW_DEBUG_HC("FRAG_THRESHOLD: %u\n", threshold);
5020 
5021 	err = ipw2100_hw_send_command(priv, &cmd);
5022 
5023 	if (!batch_mode)
5024 		ipw2100_enable_adapter(priv);
5025 
5026 	if (!err)
5027 		priv->frag_threshold = threshold;
5028 
5029 	return err;
5030 }
5031 #endif
5032 
5033 static int ipw2100_set_short_retry(struct ipw2100_priv *priv, u32 retry)
5034 {
5035 	struct host_command cmd = {
5036 		.host_command = SHORT_RETRY_LIMIT,
5037 		.host_command_sequence = 0,
5038 		.host_command_length = 4
5039 	};
5040 	int err;
5041 
5042 	cmd.host_command_parameters[0] = retry;
5043 
5044 	err = ipw2100_hw_send_command(priv, &cmd);
5045 	if (err)
5046 		return err;
5047 
5048 	priv->short_retry_limit = retry;
5049 
5050 	return 0;
5051 }
5052 
5053 static int ipw2100_set_long_retry(struct ipw2100_priv *priv, u32 retry)
5054 {
5055 	struct host_command cmd = {
5056 		.host_command = LONG_RETRY_LIMIT,
5057 		.host_command_sequence = 0,
5058 		.host_command_length = 4
5059 	};
5060 	int err;
5061 
5062 	cmd.host_command_parameters[0] = retry;
5063 
5064 	err = ipw2100_hw_send_command(priv, &cmd);
5065 	if (err)
5066 		return err;
5067 
5068 	priv->long_retry_limit = retry;
5069 
5070 	return 0;
5071 }
5072 
5073 static int ipw2100_set_mandatory_bssid(struct ipw2100_priv *priv, u8 * bssid,
5074 				       int batch_mode)
5075 {
5076 	struct host_command cmd = {
5077 		.host_command = MANDATORY_BSSID,
5078 		.host_command_sequence = 0,
5079 		.host_command_length = (bssid == NULL) ? 0 : ETH_ALEN
5080 	};
5081 	int err;
5082 
5083 #ifdef CONFIG_IPW2100_DEBUG
5084 	if (bssid != NULL)
5085 		IPW_DEBUG_HC("MANDATORY_BSSID: %pM\n", bssid);
5086 	else
5087 		IPW_DEBUG_HC("MANDATORY_BSSID: <clear>\n");
5088 #endif
5089 	/* if BSSID is empty then we disable mandatory bssid mode */
5090 	if (bssid != NULL)
5091 		memcpy(cmd.host_command_parameters, bssid, ETH_ALEN);
5092 
5093 	if (!batch_mode) {
5094 		err = ipw2100_disable_adapter(priv);
5095 		if (err)
5096 			return err;
5097 	}
5098 
5099 	err = ipw2100_hw_send_command(priv, &cmd);
5100 
5101 	if (!batch_mode)
5102 		ipw2100_enable_adapter(priv);
5103 
5104 	return err;
5105 }
5106 
5107 static int ipw2100_disassociate_bssid(struct ipw2100_priv *priv)
5108 {
5109 	struct host_command cmd = {
5110 		.host_command = DISASSOCIATION_BSSID,
5111 		.host_command_sequence = 0,
5112 		.host_command_length = ETH_ALEN
5113 	};
5114 	int err;
5115 	int len;
5116 
5117 	IPW_DEBUG_HC("DISASSOCIATION_BSSID\n");
5118 
5119 	len = ETH_ALEN;
5120 	/* The Firmware currently ignores the BSSID and just disassociates from
5121 	 * the currently associated AP -- but in the off chance that a future
5122 	 * firmware does use the BSSID provided here, we go ahead and try and
5123 	 * set it to the currently associated AP's BSSID */
5124 	memcpy(cmd.host_command_parameters, priv->bssid, ETH_ALEN);
5125 
5126 	err = ipw2100_hw_send_command(priv, &cmd);
5127 
5128 	return err;
5129 }
5130 
5131 static int ipw2100_set_wpa_ie(struct ipw2100_priv *,
5132 			      struct ipw2100_wpa_assoc_frame *, int)
5133     __attribute__ ((unused));
5134 
5135 static int ipw2100_set_wpa_ie(struct ipw2100_priv *priv,
5136 			      struct ipw2100_wpa_assoc_frame *wpa_frame,
5137 			      int batch_mode)
5138 {
5139 	struct host_command cmd = {
5140 		.host_command = SET_WPA_IE,
5141 		.host_command_sequence = 0,
5142 		.host_command_length = sizeof(struct ipw2100_wpa_assoc_frame),
5143 	};
5144 	int err;
5145 
5146 	IPW_DEBUG_HC("SET_WPA_IE\n");
5147 
5148 	if (!batch_mode) {
5149 		err = ipw2100_disable_adapter(priv);
5150 		if (err)
5151 			return err;
5152 	}
5153 
5154 	memcpy(cmd.host_command_parameters, wpa_frame,
5155 	       sizeof(struct ipw2100_wpa_assoc_frame));
5156 
5157 	err = ipw2100_hw_send_command(priv, &cmd);
5158 
5159 	if (!batch_mode) {
5160 		if (ipw2100_enable_adapter(priv))
5161 			err = -EIO;
5162 	}
5163 
5164 	return err;
5165 }
5166 
5167 struct security_info_params {
5168 	u32 allowed_ciphers;
5169 	u16 version;
5170 	u8 auth_mode;
5171 	u8 replay_counters_number;
5172 	u8 unicast_using_group;
5173 } __packed;
5174 
5175 static int ipw2100_set_security_information(struct ipw2100_priv *priv,
5176 					    int auth_mode,
5177 					    int security_level,
5178 					    int unicast_using_group,
5179 					    int batch_mode)
5180 {
5181 	struct host_command cmd = {
5182 		.host_command = SET_SECURITY_INFORMATION,
5183 		.host_command_sequence = 0,
5184 		.host_command_length = sizeof(struct security_info_params)
5185 	};
5186 	struct security_info_params *security =
5187 	    (struct security_info_params *)&cmd.host_command_parameters;
5188 	int err;
5189 	memset(security, 0, sizeof(*security));
5190 
5191 	/* If shared key AP authentication is turned on, then we need to
5192 	 * configure the firmware to try and use it.
5193 	 *
5194 	 * Actual data encryption/decryption is handled by the host. */
5195 	security->auth_mode = auth_mode;
5196 	security->unicast_using_group = unicast_using_group;
5197 
5198 	switch (security_level) {
5199 	default:
5200 	case SEC_LEVEL_0:
5201 		security->allowed_ciphers = IPW_NONE_CIPHER;
5202 		break;
5203 	case SEC_LEVEL_1:
5204 		security->allowed_ciphers = IPW_WEP40_CIPHER |
5205 		    IPW_WEP104_CIPHER;
5206 		break;
5207 	case SEC_LEVEL_2:
5208 		security->allowed_ciphers = IPW_WEP40_CIPHER |
5209 		    IPW_WEP104_CIPHER | IPW_TKIP_CIPHER;
5210 		break;
5211 	case SEC_LEVEL_2_CKIP:
5212 		security->allowed_ciphers = IPW_WEP40_CIPHER |
5213 		    IPW_WEP104_CIPHER | IPW_CKIP_CIPHER;
5214 		break;
5215 	case SEC_LEVEL_3:
5216 		security->allowed_ciphers = IPW_WEP40_CIPHER |
5217 		    IPW_WEP104_CIPHER | IPW_TKIP_CIPHER | IPW_CCMP_CIPHER;
5218 		break;
5219 	}
5220 
5221 	IPW_DEBUG_HC
5222 	    ("SET_SECURITY_INFORMATION: auth:%d cipher:0x%02X (level %d)\n",
5223 	     security->auth_mode, security->allowed_ciphers, security_level);
5224 
5225 	security->replay_counters_number = 0;
5226 
5227 	if (!batch_mode) {
5228 		err = ipw2100_disable_adapter(priv);
5229 		if (err)
5230 			return err;
5231 	}
5232 
5233 	err = ipw2100_hw_send_command(priv, &cmd);
5234 
5235 	if (!batch_mode)
5236 		ipw2100_enable_adapter(priv);
5237 
5238 	return err;
5239 }
5240 
5241 static int ipw2100_set_tx_power(struct ipw2100_priv *priv, u32 tx_power)
5242 {
5243 	struct host_command cmd = {
5244 		.host_command = TX_POWER_INDEX,
5245 		.host_command_sequence = 0,
5246 		.host_command_length = 4
5247 	};
5248 	int err = 0;
5249 	u32 tmp = tx_power;
5250 
5251 	if (tx_power != IPW_TX_POWER_DEFAULT)
5252 		tmp = (tx_power - IPW_TX_POWER_MIN_DBM) * 16 /
5253 		      (IPW_TX_POWER_MAX_DBM - IPW_TX_POWER_MIN_DBM);
5254 
5255 	cmd.host_command_parameters[0] = tmp;
5256 
5257 	if (priv->ieee->iw_mode == IW_MODE_ADHOC)
5258 		err = ipw2100_hw_send_command(priv, &cmd);
5259 	if (!err)
5260 		priv->tx_power = tx_power;
5261 
5262 	return 0;
5263 }
5264 
5265 static int ipw2100_set_ibss_beacon_interval(struct ipw2100_priv *priv,
5266 					    u32 interval, int batch_mode)
5267 {
5268 	struct host_command cmd = {
5269 		.host_command = BEACON_INTERVAL,
5270 		.host_command_sequence = 0,
5271 		.host_command_length = 4
5272 	};
5273 	int err;
5274 
5275 	cmd.host_command_parameters[0] = interval;
5276 
5277 	IPW_DEBUG_INFO("enter\n");
5278 
5279 	if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5280 		if (!batch_mode) {
5281 			err = ipw2100_disable_adapter(priv);
5282 			if (err)
5283 				return err;
5284 		}
5285 
5286 		ipw2100_hw_send_command(priv, &cmd);
5287 
5288 		if (!batch_mode) {
5289 			err = ipw2100_enable_adapter(priv);
5290 			if (err)
5291 				return err;
5292 		}
5293 	}
5294 
5295 	IPW_DEBUG_INFO("exit\n");
5296 
5297 	return 0;
5298 }
5299 
5300 static void ipw2100_queues_initialize(struct ipw2100_priv *priv)
5301 {
5302 	ipw2100_tx_initialize(priv);
5303 	ipw2100_rx_initialize(priv);
5304 	ipw2100_msg_initialize(priv);
5305 }
5306 
5307 static void ipw2100_queues_free(struct ipw2100_priv *priv)
5308 {
5309 	ipw2100_tx_free(priv);
5310 	ipw2100_rx_free(priv);
5311 	ipw2100_msg_free(priv);
5312 }
5313 
5314 static int ipw2100_queues_allocate(struct ipw2100_priv *priv)
5315 {
5316 	if (ipw2100_tx_allocate(priv) ||
5317 	    ipw2100_rx_allocate(priv) || ipw2100_msg_allocate(priv))
5318 		goto fail;
5319 
5320 	return 0;
5321 
5322       fail:
5323 	ipw2100_tx_free(priv);
5324 	ipw2100_rx_free(priv);
5325 	ipw2100_msg_free(priv);
5326 	return -ENOMEM;
5327 }
5328 
5329 #define IPW_PRIVACY_CAPABLE 0x0008
5330 
5331 static int ipw2100_set_wep_flags(struct ipw2100_priv *priv, u32 flags,
5332 				 int batch_mode)
5333 {
5334 	struct host_command cmd = {
5335 		.host_command = WEP_FLAGS,
5336 		.host_command_sequence = 0,
5337 		.host_command_length = 4
5338 	};
5339 	int err;
5340 
5341 	cmd.host_command_parameters[0] = flags;
5342 
5343 	IPW_DEBUG_HC("WEP_FLAGS: flags = 0x%08X\n", flags);
5344 
5345 	if (!batch_mode) {
5346 		err = ipw2100_disable_adapter(priv);
5347 		if (err) {
5348 			printk(KERN_ERR DRV_NAME
5349 			       ": %s: Could not disable adapter %d\n",
5350 			       priv->net_dev->name, err);
5351 			return err;
5352 		}
5353 	}
5354 
5355 	/* send cmd to firmware */
5356 	err = ipw2100_hw_send_command(priv, &cmd);
5357 
5358 	if (!batch_mode)
5359 		ipw2100_enable_adapter(priv);
5360 
5361 	return err;
5362 }
5363 
5364 struct ipw2100_wep_key {
5365 	u8 idx;
5366 	u8 len;
5367 	u8 key[13];
5368 };
5369 
5370 /* Macros to ease up priting WEP keys */
5371 #define WEP_FMT_64  "%02X%02X%02X%02X-%02X"
5372 #define WEP_FMT_128 "%02X%02X%02X%02X-%02X%02X%02X%02X-%02X%02X%02X"
5373 #define WEP_STR_64(x) x[0],x[1],x[2],x[3],x[4]
5374 #define WEP_STR_128(x) x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],x[8],x[9],x[10]
5375 
5376 /**
5377  * Set a the wep key
5378  *
5379  * @priv: struct to work on
5380  * @idx: index of the key we want to set
5381  * @key: ptr to the key data to set
5382  * @len: length of the buffer at @key
5383  * @batch_mode: FIXME perform the operation in batch mode, not
5384  *              disabling the device.
5385  *
5386  * @returns 0 if OK, < 0 errno code on error.
5387  *
5388  * Fill out a command structure with the new wep key, length an
5389  * index and send it down the wire.
5390  */
5391 static int ipw2100_set_key(struct ipw2100_priv *priv,
5392 			   int idx, char *key, int len, int batch_mode)
5393 {
5394 	int keylen = len ? (len <= 5 ? 5 : 13) : 0;
5395 	struct host_command cmd = {
5396 		.host_command = WEP_KEY_INFO,
5397 		.host_command_sequence = 0,
5398 		.host_command_length = sizeof(struct ipw2100_wep_key),
5399 	};
5400 	struct ipw2100_wep_key *wep_key = (void *)cmd.host_command_parameters;
5401 	int err;
5402 
5403 	IPW_DEBUG_HC("WEP_KEY_INFO: index = %d, len = %d/%d\n",
5404 		     idx, keylen, len);
5405 
5406 	/* NOTE: We don't check cached values in case the firmware was reset
5407 	 * or some other problem is occurring.  If the user is setting the key,
5408 	 * then we push the change */
5409 
5410 	wep_key->idx = idx;
5411 	wep_key->len = keylen;
5412 
5413 	if (keylen) {
5414 		memcpy(wep_key->key, key, len);
5415 		memset(wep_key->key + len, 0, keylen - len);
5416 	}
5417 
5418 	/* Will be optimized out on debug not being configured in */
5419 	if (keylen == 0)
5420 		IPW_DEBUG_WEP("%s: Clearing key %d\n",
5421 			      priv->net_dev->name, wep_key->idx);
5422 	else if (keylen == 5)
5423 		IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_64 "\n",
5424 			      priv->net_dev->name, wep_key->idx, wep_key->len,
5425 			      WEP_STR_64(wep_key->key));
5426 	else
5427 		IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_128
5428 			      "\n",
5429 			      priv->net_dev->name, wep_key->idx, wep_key->len,
5430 			      WEP_STR_128(wep_key->key));
5431 
5432 	if (!batch_mode) {
5433 		err = ipw2100_disable_adapter(priv);
5434 		/* FIXME: IPG: shouldn't this prink be in _disable_adapter()? */
5435 		if (err) {
5436 			printk(KERN_ERR DRV_NAME
5437 			       ": %s: Could not disable adapter %d\n",
5438 			       priv->net_dev->name, err);
5439 			return err;
5440 		}
5441 	}
5442 
5443 	/* send cmd to firmware */
5444 	err = ipw2100_hw_send_command(priv, &cmd);
5445 
5446 	if (!batch_mode) {
5447 		int err2 = ipw2100_enable_adapter(priv);
5448 		if (err == 0)
5449 			err = err2;
5450 	}
5451 	return err;
5452 }
5453 
5454 static int ipw2100_set_key_index(struct ipw2100_priv *priv,
5455 				 int idx, int batch_mode)
5456 {
5457 	struct host_command cmd = {
5458 		.host_command = WEP_KEY_INDEX,
5459 		.host_command_sequence = 0,
5460 		.host_command_length = 4,
5461 		.host_command_parameters = {idx},
5462 	};
5463 	int err;
5464 
5465 	IPW_DEBUG_HC("WEP_KEY_INDEX: index = %d\n", idx);
5466 
5467 	if (idx < 0 || idx > 3)
5468 		return -EINVAL;
5469 
5470 	if (!batch_mode) {
5471 		err = ipw2100_disable_adapter(priv);
5472 		if (err) {
5473 			printk(KERN_ERR DRV_NAME
5474 			       ": %s: Could not disable adapter %d\n",
5475 			       priv->net_dev->name, err);
5476 			return err;
5477 		}
5478 	}
5479 
5480 	/* send cmd to firmware */
5481 	err = ipw2100_hw_send_command(priv, &cmd);
5482 
5483 	if (!batch_mode)
5484 		ipw2100_enable_adapter(priv);
5485 
5486 	return err;
5487 }
5488 
5489 static int ipw2100_configure_security(struct ipw2100_priv *priv, int batch_mode)
5490 {
5491 	int i, err, auth_mode, sec_level, use_group;
5492 
5493 	if (!(priv->status & STATUS_RUNNING))
5494 		return 0;
5495 
5496 	if (!batch_mode) {
5497 		err = ipw2100_disable_adapter(priv);
5498 		if (err)
5499 			return err;
5500 	}
5501 
5502 	if (!priv->ieee->sec.enabled) {
5503 		err =
5504 		    ipw2100_set_security_information(priv, IPW_AUTH_OPEN,
5505 						     SEC_LEVEL_0, 0, 1);
5506 	} else {
5507 		auth_mode = IPW_AUTH_OPEN;
5508 		if (priv->ieee->sec.flags & SEC_AUTH_MODE) {
5509 			if (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)
5510 				auth_mode = IPW_AUTH_SHARED;
5511 			else if (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP)
5512 				auth_mode = IPW_AUTH_LEAP_CISCO_ID;
5513 		}
5514 
5515 		sec_level = SEC_LEVEL_0;
5516 		if (priv->ieee->sec.flags & SEC_LEVEL)
5517 			sec_level = priv->ieee->sec.level;
5518 
5519 		use_group = 0;
5520 		if (priv->ieee->sec.flags & SEC_UNICAST_GROUP)
5521 			use_group = priv->ieee->sec.unicast_uses_group;
5522 
5523 		err =
5524 		    ipw2100_set_security_information(priv, auth_mode, sec_level,
5525 						     use_group, 1);
5526 	}
5527 
5528 	if (err)
5529 		goto exit;
5530 
5531 	if (priv->ieee->sec.enabled) {
5532 		for (i = 0; i < 4; i++) {
5533 			if (!(priv->ieee->sec.flags & (1 << i))) {
5534 				memset(priv->ieee->sec.keys[i], 0, WEP_KEY_LEN);
5535 				priv->ieee->sec.key_sizes[i] = 0;
5536 			} else {
5537 				err = ipw2100_set_key(priv, i,
5538 						      priv->ieee->sec.keys[i],
5539 						      priv->ieee->sec.
5540 						      key_sizes[i], 1);
5541 				if (err)
5542 					goto exit;
5543 			}
5544 		}
5545 
5546 		ipw2100_set_key_index(priv, priv->ieee->crypt_info.tx_keyidx, 1);
5547 	}
5548 
5549 	/* Always enable privacy so the Host can filter WEP packets if
5550 	 * encrypted data is sent up */
5551 	err =
5552 	    ipw2100_set_wep_flags(priv,
5553 				  priv->ieee->sec.
5554 				  enabled ? IPW_PRIVACY_CAPABLE : 0, 1);
5555 	if (err)
5556 		goto exit;
5557 
5558 	priv->status &= ~STATUS_SECURITY_UPDATED;
5559 
5560       exit:
5561 	if (!batch_mode)
5562 		ipw2100_enable_adapter(priv);
5563 
5564 	return err;
5565 }
5566 
5567 static void ipw2100_security_work(struct work_struct *work)
5568 {
5569 	struct ipw2100_priv *priv =
5570 		container_of(work, struct ipw2100_priv, security_work.work);
5571 
5572 	/* If we happen to have reconnected before we get a chance to
5573 	 * process this, then update the security settings--which causes
5574 	 * a disassociation to occur */
5575 	if (!(priv->status & STATUS_ASSOCIATED) &&
5576 	    priv->status & STATUS_SECURITY_UPDATED)
5577 		ipw2100_configure_security(priv, 0);
5578 }
5579 
5580 static void shim__set_security(struct net_device *dev,
5581 			       struct libipw_security *sec)
5582 {
5583 	struct ipw2100_priv *priv = libipw_priv(dev);
5584 	int i, force_update = 0;
5585 
5586 	mutex_lock(&priv->action_mutex);
5587 	if (!(priv->status & STATUS_INITIALIZED))
5588 		goto done;
5589 
5590 	for (i = 0; i < 4; i++) {
5591 		if (sec->flags & (1 << i)) {
5592 			priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
5593 			if (sec->key_sizes[i] == 0)
5594 				priv->ieee->sec.flags &= ~(1 << i);
5595 			else
5596 				memcpy(priv->ieee->sec.keys[i], sec->keys[i],
5597 				       sec->key_sizes[i]);
5598 			if (sec->level == SEC_LEVEL_1) {
5599 				priv->ieee->sec.flags |= (1 << i);
5600 				priv->status |= STATUS_SECURITY_UPDATED;
5601 			} else
5602 				priv->ieee->sec.flags &= ~(1 << i);
5603 		}
5604 	}
5605 
5606 	if ((sec->flags & SEC_ACTIVE_KEY) &&
5607 	    priv->ieee->sec.active_key != sec->active_key) {
5608 		if (sec->active_key <= 3) {
5609 			priv->ieee->sec.active_key = sec->active_key;
5610 			priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
5611 		} else
5612 			priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
5613 
5614 		priv->status |= STATUS_SECURITY_UPDATED;
5615 	}
5616 
5617 	if ((sec->flags & SEC_AUTH_MODE) &&
5618 	    (priv->ieee->sec.auth_mode != sec->auth_mode)) {
5619 		priv->ieee->sec.auth_mode = sec->auth_mode;
5620 		priv->ieee->sec.flags |= SEC_AUTH_MODE;
5621 		priv->status |= STATUS_SECURITY_UPDATED;
5622 	}
5623 
5624 	if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
5625 		priv->ieee->sec.flags |= SEC_ENABLED;
5626 		priv->ieee->sec.enabled = sec->enabled;
5627 		priv->status |= STATUS_SECURITY_UPDATED;
5628 		force_update = 1;
5629 	}
5630 
5631 	if (sec->flags & SEC_ENCRYPT)
5632 		priv->ieee->sec.encrypt = sec->encrypt;
5633 
5634 	if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
5635 		priv->ieee->sec.level = sec->level;
5636 		priv->ieee->sec.flags |= SEC_LEVEL;
5637 		priv->status |= STATUS_SECURITY_UPDATED;
5638 	}
5639 
5640 	IPW_DEBUG_WEP("Security flags: %c %c%c%c%c %c%c%c%c\n",
5641 		      priv->ieee->sec.flags & (1 << 8) ? '1' : '0',
5642 		      priv->ieee->sec.flags & (1 << 7) ? '1' : '0',
5643 		      priv->ieee->sec.flags & (1 << 6) ? '1' : '0',
5644 		      priv->ieee->sec.flags & (1 << 5) ? '1' : '0',
5645 		      priv->ieee->sec.flags & (1 << 4) ? '1' : '0',
5646 		      priv->ieee->sec.flags & (1 << 3) ? '1' : '0',
5647 		      priv->ieee->sec.flags & (1 << 2) ? '1' : '0',
5648 		      priv->ieee->sec.flags & (1 << 1) ? '1' : '0',
5649 		      priv->ieee->sec.flags & (1 << 0) ? '1' : '0');
5650 
5651 /* As a temporary work around to enable WPA until we figure out why
5652  * wpa_supplicant toggles the security capability of the driver, which
5653  * forces a disassociation with force_update...
5654  *
5655  *	if (force_update || !(priv->status & STATUS_ASSOCIATED))*/
5656 	if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
5657 		ipw2100_configure_security(priv, 0);
5658       done:
5659 	mutex_unlock(&priv->action_mutex);
5660 }
5661 
5662 static int ipw2100_adapter_setup(struct ipw2100_priv *priv)
5663 {
5664 	int err;
5665 	int batch_mode = 1;
5666 	u8 *bssid;
5667 
5668 	IPW_DEBUG_INFO("enter\n");
5669 
5670 	err = ipw2100_disable_adapter(priv);
5671 	if (err)
5672 		return err;
5673 #ifdef CONFIG_IPW2100_MONITOR
5674 	if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
5675 		err = ipw2100_set_channel(priv, priv->channel, batch_mode);
5676 		if (err)
5677 			return err;
5678 
5679 		IPW_DEBUG_INFO("exit\n");
5680 
5681 		return 0;
5682 	}
5683 #endif				/* CONFIG_IPW2100_MONITOR */
5684 
5685 	err = ipw2100_read_mac_address(priv);
5686 	if (err)
5687 		return -EIO;
5688 
5689 	err = ipw2100_set_mac_address(priv, batch_mode);
5690 	if (err)
5691 		return err;
5692 
5693 	err = ipw2100_set_port_type(priv, priv->ieee->iw_mode, batch_mode);
5694 	if (err)
5695 		return err;
5696 
5697 	if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5698 		err = ipw2100_set_channel(priv, priv->channel, batch_mode);
5699 		if (err)
5700 			return err;
5701 	}
5702 
5703 	err = ipw2100_system_config(priv, batch_mode);
5704 	if (err)
5705 		return err;
5706 
5707 	err = ipw2100_set_tx_rates(priv, priv->tx_rates, batch_mode);
5708 	if (err)
5709 		return err;
5710 
5711 	/* Default to power mode OFF */
5712 	err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM);
5713 	if (err)
5714 		return err;
5715 
5716 	err = ipw2100_set_rts_threshold(priv, priv->rts_threshold);
5717 	if (err)
5718 		return err;
5719 
5720 	if (priv->config & CFG_STATIC_BSSID)
5721 		bssid = priv->bssid;
5722 	else
5723 		bssid = NULL;
5724 	err = ipw2100_set_mandatory_bssid(priv, bssid, batch_mode);
5725 	if (err)
5726 		return err;
5727 
5728 	if (priv->config & CFG_STATIC_ESSID)
5729 		err = ipw2100_set_essid(priv, priv->essid, priv->essid_len,
5730 					batch_mode);
5731 	else
5732 		err = ipw2100_set_essid(priv, NULL, 0, batch_mode);
5733 	if (err)
5734 		return err;
5735 
5736 	err = ipw2100_configure_security(priv, batch_mode);
5737 	if (err)
5738 		return err;
5739 
5740 	if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5741 		err =
5742 		    ipw2100_set_ibss_beacon_interval(priv,
5743 						     priv->beacon_interval,
5744 						     batch_mode);
5745 		if (err)
5746 			return err;
5747 
5748 		err = ipw2100_set_tx_power(priv, priv->tx_power);
5749 		if (err)
5750 			return err;
5751 	}
5752 
5753 	/*
5754 	   err = ipw2100_set_fragmentation_threshold(
5755 	   priv, priv->frag_threshold, batch_mode);
5756 	   if (err)
5757 	   return err;
5758 	 */
5759 
5760 	IPW_DEBUG_INFO("exit\n");
5761 
5762 	return 0;
5763 }
5764 
5765 /*************************************************************************
5766  *
5767  * EXTERNALLY CALLED METHODS
5768  *
5769  *************************************************************************/
5770 
5771 /* This method is called by the network layer -- not to be confused with
5772  * ipw2100_set_mac_address() declared above called by this driver (and this
5773  * method as well) to talk to the firmware */
5774 static int ipw2100_set_address(struct net_device *dev, void *p)
5775 {
5776 	struct ipw2100_priv *priv = libipw_priv(dev);
5777 	struct sockaddr *addr = p;
5778 	int err = 0;
5779 
5780 	if (!is_valid_ether_addr(addr->sa_data))
5781 		return -EADDRNOTAVAIL;
5782 
5783 	mutex_lock(&priv->action_mutex);
5784 
5785 	priv->config |= CFG_CUSTOM_MAC;
5786 	memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
5787 
5788 	err = ipw2100_set_mac_address(priv, 0);
5789 	if (err)
5790 		goto done;
5791 
5792 	priv->reset_backoff = 0;
5793 	mutex_unlock(&priv->action_mutex);
5794 	ipw2100_reset_adapter(&priv->reset_work.work);
5795 	return 0;
5796 
5797       done:
5798 	mutex_unlock(&priv->action_mutex);
5799 	return err;
5800 }
5801 
5802 static int ipw2100_open(struct net_device *dev)
5803 {
5804 	struct ipw2100_priv *priv = libipw_priv(dev);
5805 	unsigned long flags;
5806 	IPW_DEBUG_INFO("dev->open\n");
5807 
5808 	spin_lock_irqsave(&priv->low_lock, flags);
5809 	if (priv->status & STATUS_ASSOCIATED) {
5810 		netif_carrier_on(dev);
5811 		netif_start_queue(dev);
5812 	}
5813 	spin_unlock_irqrestore(&priv->low_lock, flags);
5814 
5815 	return 0;
5816 }
5817 
5818 static int ipw2100_close(struct net_device *dev)
5819 {
5820 	struct ipw2100_priv *priv = libipw_priv(dev);
5821 	unsigned long flags;
5822 	struct list_head *element;
5823 	struct ipw2100_tx_packet *packet;
5824 
5825 	IPW_DEBUG_INFO("enter\n");
5826 
5827 	spin_lock_irqsave(&priv->low_lock, flags);
5828 
5829 	if (priv->status & STATUS_ASSOCIATED)
5830 		netif_carrier_off(dev);
5831 	netif_stop_queue(dev);
5832 
5833 	/* Flush the TX queue ... */
5834 	while (!list_empty(&priv->tx_pend_list)) {
5835 		element = priv->tx_pend_list.next;
5836 		packet = list_entry(element, struct ipw2100_tx_packet, list);
5837 
5838 		list_del(element);
5839 		DEC_STAT(&priv->tx_pend_stat);
5840 
5841 		libipw_txb_free(packet->info.d_struct.txb);
5842 		packet->info.d_struct.txb = NULL;
5843 
5844 		list_add_tail(element, &priv->tx_free_list);
5845 		INC_STAT(&priv->tx_free_stat);
5846 	}
5847 	spin_unlock_irqrestore(&priv->low_lock, flags);
5848 
5849 	IPW_DEBUG_INFO("exit\n");
5850 
5851 	return 0;
5852 }
5853 
5854 /*
5855  * TODO:  Fix this function... its just wrong
5856  */
5857 static void ipw2100_tx_timeout(struct net_device *dev)
5858 {
5859 	struct ipw2100_priv *priv = libipw_priv(dev);
5860 
5861 	dev->stats.tx_errors++;
5862 
5863 #ifdef CONFIG_IPW2100_MONITOR
5864 	if (priv->ieee->iw_mode == IW_MODE_MONITOR)
5865 		return;
5866 #endif
5867 
5868 	IPW_DEBUG_INFO("%s: TX timed out.  Scheduling firmware restart.\n",
5869 		       dev->name);
5870 	schedule_reset(priv);
5871 }
5872 
5873 static int ipw2100_wpa_enable(struct ipw2100_priv *priv, int value)
5874 {
5875 	/* This is called when wpa_supplicant loads and closes the driver
5876 	 * interface. */
5877 	priv->ieee->wpa_enabled = value;
5878 	return 0;
5879 }
5880 
5881 static int ipw2100_wpa_set_auth_algs(struct ipw2100_priv *priv, int value)
5882 {
5883 
5884 	struct libipw_device *ieee = priv->ieee;
5885 	struct libipw_security sec = {
5886 		.flags = SEC_AUTH_MODE,
5887 	};
5888 	int ret = 0;
5889 
5890 	if (value & IW_AUTH_ALG_SHARED_KEY) {
5891 		sec.auth_mode = WLAN_AUTH_SHARED_KEY;
5892 		ieee->open_wep = 0;
5893 	} else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
5894 		sec.auth_mode = WLAN_AUTH_OPEN;
5895 		ieee->open_wep = 1;
5896 	} else if (value & IW_AUTH_ALG_LEAP) {
5897 		sec.auth_mode = WLAN_AUTH_LEAP;
5898 		ieee->open_wep = 1;
5899 	} else
5900 		return -EINVAL;
5901 
5902 	if (ieee->set_security)
5903 		ieee->set_security(ieee->dev, &sec);
5904 	else
5905 		ret = -EOPNOTSUPP;
5906 
5907 	return ret;
5908 }
5909 
5910 static void ipw2100_wpa_assoc_frame(struct ipw2100_priv *priv,
5911 				    char *wpa_ie, int wpa_ie_len)
5912 {
5913 
5914 	struct ipw2100_wpa_assoc_frame frame;
5915 
5916 	frame.fixed_ie_mask = 0;
5917 
5918 	/* copy WPA IE */
5919 	memcpy(frame.var_ie, wpa_ie, wpa_ie_len);
5920 	frame.var_ie_len = wpa_ie_len;
5921 
5922 	/* make sure WPA is enabled */
5923 	ipw2100_wpa_enable(priv, 1);
5924 	ipw2100_set_wpa_ie(priv, &frame, 0);
5925 }
5926 
5927 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
5928 				    struct ethtool_drvinfo *info)
5929 {
5930 	struct ipw2100_priv *priv = libipw_priv(dev);
5931 	char fw_ver[64], ucode_ver[64];
5932 
5933 	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
5934 	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
5935 
5936 	ipw2100_get_fwversion(priv, fw_ver, sizeof(fw_ver));
5937 	ipw2100_get_ucodeversion(priv, ucode_ver, sizeof(ucode_ver));
5938 
5939 	snprintf(info->fw_version, sizeof(info->fw_version), "%s:%d:%s",
5940 		 fw_ver, priv->eeprom_version, ucode_ver);
5941 
5942 	strlcpy(info->bus_info, pci_name(priv->pci_dev),
5943 		sizeof(info->bus_info));
5944 }
5945 
5946 static u32 ipw2100_ethtool_get_link(struct net_device *dev)
5947 {
5948 	struct ipw2100_priv *priv = libipw_priv(dev);
5949 	return (priv->status & STATUS_ASSOCIATED) ? 1 : 0;
5950 }
5951 
5952 static const struct ethtool_ops ipw2100_ethtool_ops = {
5953 	.get_link = ipw2100_ethtool_get_link,
5954 	.get_drvinfo = ipw_ethtool_get_drvinfo,
5955 };
5956 
5957 static void ipw2100_hang_check(struct work_struct *work)
5958 {
5959 	struct ipw2100_priv *priv =
5960 		container_of(work, struct ipw2100_priv, hang_check.work);
5961 	unsigned long flags;
5962 	u32 rtc = 0xa5a5a5a5;
5963 	u32 len = sizeof(rtc);
5964 	int restart = 0;
5965 
5966 	spin_lock_irqsave(&priv->low_lock, flags);
5967 
5968 	if (priv->fatal_error != 0) {
5969 		/* If fatal_error is set then we need to restart */
5970 		IPW_DEBUG_INFO("%s: Hardware fatal error detected.\n",
5971 			       priv->net_dev->name);
5972 
5973 		restart = 1;
5974 	} else if (ipw2100_get_ordinal(priv, IPW_ORD_RTC_TIME, &rtc, &len) ||
5975 		   (rtc == priv->last_rtc)) {
5976 		/* Check if firmware is hung */
5977 		IPW_DEBUG_INFO("%s: Firmware RTC stalled.\n",
5978 			       priv->net_dev->name);
5979 
5980 		restart = 1;
5981 	}
5982 
5983 	if (restart) {
5984 		/* Kill timer */
5985 		priv->stop_hang_check = 1;
5986 		priv->hangs++;
5987 
5988 		/* Restart the NIC */
5989 		schedule_reset(priv);
5990 	}
5991 
5992 	priv->last_rtc = rtc;
5993 
5994 	if (!priv->stop_hang_check)
5995 		schedule_delayed_work(&priv->hang_check, HZ / 2);
5996 
5997 	spin_unlock_irqrestore(&priv->low_lock, flags);
5998 }
5999 
6000 static void ipw2100_rf_kill(struct work_struct *work)
6001 {
6002 	struct ipw2100_priv *priv =
6003 		container_of(work, struct ipw2100_priv, rf_kill.work);
6004 	unsigned long flags;
6005 
6006 	spin_lock_irqsave(&priv->low_lock, flags);
6007 
6008 	if (rf_kill_active(priv)) {
6009 		IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
6010 		if (!priv->stop_rf_kill)
6011 			schedule_delayed_work(&priv->rf_kill,
6012 					      round_jiffies_relative(HZ));
6013 		goto exit_unlock;
6014 	}
6015 
6016 	/* RF Kill is now disabled, so bring the device back up */
6017 
6018 	if (!(priv->status & STATUS_RF_KILL_MASK)) {
6019 		IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
6020 				  "device\n");
6021 		schedule_reset(priv);
6022 	} else
6023 		IPW_DEBUG_RF_KILL("HW RF Kill deactivated.  SW RF Kill still "
6024 				  "enabled\n");
6025 
6026       exit_unlock:
6027 	spin_unlock_irqrestore(&priv->low_lock, flags);
6028 }
6029 
6030 static void ipw2100_irq_tasklet(struct ipw2100_priv *priv);
6031 
6032 static const struct net_device_ops ipw2100_netdev_ops = {
6033 	.ndo_open		= ipw2100_open,
6034 	.ndo_stop		= ipw2100_close,
6035 	.ndo_start_xmit		= libipw_xmit,
6036 	.ndo_tx_timeout		= ipw2100_tx_timeout,
6037 	.ndo_set_mac_address	= ipw2100_set_address,
6038 	.ndo_validate_addr	= eth_validate_addr,
6039 };
6040 
6041 /* Look into using netdev destructor to shutdown libipw? */
6042 
6043 static struct net_device *ipw2100_alloc_device(struct pci_dev *pci_dev,
6044 					       void __iomem * ioaddr)
6045 {
6046 	struct ipw2100_priv *priv;
6047 	struct net_device *dev;
6048 
6049 	dev = alloc_libipw(sizeof(struct ipw2100_priv), 0);
6050 	if (!dev)
6051 		return NULL;
6052 	priv = libipw_priv(dev);
6053 	priv->ieee = netdev_priv(dev);
6054 	priv->pci_dev = pci_dev;
6055 	priv->net_dev = dev;
6056 	priv->ioaddr = ioaddr;
6057 
6058 	priv->ieee->hard_start_xmit = ipw2100_tx;
6059 	priv->ieee->set_security = shim__set_security;
6060 
6061 	priv->ieee->perfect_rssi = -20;
6062 	priv->ieee->worst_rssi = -85;
6063 
6064 	dev->netdev_ops = &ipw2100_netdev_ops;
6065 	dev->ethtool_ops = &ipw2100_ethtool_ops;
6066 	dev->wireless_handlers = &ipw2100_wx_handler_def;
6067 	priv->wireless_data.libipw = priv->ieee;
6068 	dev->wireless_data = &priv->wireless_data;
6069 	dev->watchdog_timeo = 3 * HZ;
6070 	dev->irq = 0;
6071 	dev->min_mtu = 68;
6072 	dev->max_mtu = LIBIPW_DATA_LEN;
6073 
6074 	/* NOTE: We don't use the wireless_handlers hook
6075 	 * in dev as the system will start throwing WX requests
6076 	 * to us before we're actually initialized and it just
6077 	 * ends up causing problems.  So, we just handle
6078 	 * the WX extensions through the ipw2100_ioctl interface */
6079 
6080 	/* memset() puts everything to 0, so we only have explicitly set
6081 	 * those values that need to be something else */
6082 
6083 	/* If power management is turned on, default to AUTO mode */
6084 	priv->power_mode = IPW_POWER_AUTO;
6085 
6086 #ifdef CONFIG_IPW2100_MONITOR
6087 	priv->config |= CFG_CRC_CHECK;
6088 #endif
6089 	priv->ieee->wpa_enabled = 0;
6090 	priv->ieee->drop_unencrypted = 0;
6091 	priv->ieee->privacy_invoked = 0;
6092 	priv->ieee->ieee802_1x = 1;
6093 
6094 	/* Set module parameters */
6095 	switch (network_mode) {
6096 	case 1:
6097 		priv->ieee->iw_mode = IW_MODE_ADHOC;
6098 		break;
6099 #ifdef CONFIG_IPW2100_MONITOR
6100 	case 2:
6101 		priv->ieee->iw_mode = IW_MODE_MONITOR;
6102 		break;
6103 #endif
6104 	default:
6105 	case 0:
6106 		priv->ieee->iw_mode = IW_MODE_INFRA;
6107 		break;
6108 	}
6109 
6110 	if (disable == 1)
6111 		priv->status |= STATUS_RF_KILL_SW;
6112 
6113 	if (channel != 0 &&
6114 	    ((channel >= REG_MIN_CHANNEL) && (channel <= REG_MAX_CHANNEL))) {
6115 		priv->config |= CFG_STATIC_CHANNEL;
6116 		priv->channel = channel;
6117 	}
6118 
6119 	if (associate)
6120 		priv->config |= CFG_ASSOCIATE;
6121 
6122 	priv->beacon_interval = DEFAULT_BEACON_INTERVAL;
6123 	priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
6124 	priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
6125 	priv->rts_threshold = DEFAULT_RTS_THRESHOLD | RTS_DISABLED;
6126 	priv->frag_threshold = DEFAULT_FTS | FRAG_DISABLED;
6127 	priv->tx_power = IPW_TX_POWER_DEFAULT;
6128 	priv->tx_rates = DEFAULT_TX_RATES;
6129 
6130 	strcpy(priv->nick, "ipw2100");
6131 
6132 	spin_lock_init(&priv->low_lock);
6133 	mutex_init(&priv->action_mutex);
6134 	mutex_init(&priv->adapter_mutex);
6135 
6136 	init_waitqueue_head(&priv->wait_command_queue);
6137 
6138 	netif_carrier_off(dev);
6139 
6140 	INIT_LIST_HEAD(&priv->msg_free_list);
6141 	INIT_LIST_HEAD(&priv->msg_pend_list);
6142 	INIT_STAT(&priv->msg_free_stat);
6143 	INIT_STAT(&priv->msg_pend_stat);
6144 
6145 	INIT_LIST_HEAD(&priv->tx_free_list);
6146 	INIT_LIST_HEAD(&priv->tx_pend_list);
6147 	INIT_STAT(&priv->tx_free_stat);
6148 	INIT_STAT(&priv->tx_pend_stat);
6149 
6150 	INIT_LIST_HEAD(&priv->fw_pend_list);
6151 	INIT_STAT(&priv->fw_pend_stat);
6152 
6153 	INIT_DELAYED_WORK(&priv->reset_work, ipw2100_reset_adapter);
6154 	INIT_DELAYED_WORK(&priv->security_work, ipw2100_security_work);
6155 	INIT_DELAYED_WORK(&priv->wx_event_work, ipw2100_wx_event_work);
6156 	INIT_DELAYED_WORK(&priv->hang_check, ipw2100_hang_check);
6157 	INIT_DELAYED_WORK(&priv->rf_kill, ipw2100_rf_kill);
6158 	INIT_DELAYED_WORK(&priv->scan_event, ipw2100_scan_event);
6159 
6160 	tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
6161 		     ipw2100_irq_tasklet, (unsigned long)priv);
6162 
6163 	/* NOTE:  We do not start the deferred work for status checks yet */
6164 	priv->stop_rf_kill = 1;
6165 	priv->stop_hang_check = 1;
6166 
6167 	return dev;
6168 }
6169 
6170 static int ipw2100_pci_init_one(struct pci_dev *pci_dev,
6171 				const struct pci_device_id *ent)
6172 {
6173 	void __iomem *ioaddr;
6174 	struct net_device *dev = NULL;
6175 	struct ipw2100_priv *priv = NULL;
6176 	int err = 0;
6177 	int registered = 0;
6178 	u32 val;
6179 
6180 	IPW_DEBUG_INFO("enter\n");
6181 
6182 	if (!(pci_resource_flags(pci_dev, 0) & IORESOURCE_MEM)) {
6183 		IPW_DEBUG_INFO("weird - resource type is not memory\n");
6184 		err = -ENODEV;
6185 		goto out;
6186 	}
6187 
6188 	ioaddr = pci_iomap(pci_dev, 0, 0);
6189 	if (!ioaddr) {
6190 		printk(KERN_WARNING DRV_NAME
6191 		       "Error calling ioremap_nocache.\n");
6192 		err = -EIO;
6193 		goto fail;
6194 	}
6195 
6196 	/* allocate and initialize our net_device */
6197 	dev = ipw2100_alloc_device(pci_dev, ioaddr);
6198 	if (!dev) {
6199 		printk(KERN_WARNING DRV_NAME
6200 		       "Error calling ipw2100_alloc_device.\n");
6201 		err = -ENOMEM;
6202 		goto fail;
6203 	}
6204 
6205 	/* set up PCI mappings for device */
6206 	err = pci_enable_device(pci_dev);
6207 	if (err) {
6208 		printk(KERN_WARNING DRV_NAME
6209 		       "Error calling pci_enable_device.\n");
6210 		return err;
6211 	}
6212 
6213 	priv = libipw_priv(dev);
6214 
6215 	pci_set_master(pci_dev);
6216 	pci_set_drvdata(pci_dev, priv);
6217 
6218 	err = pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32));
6219 	if (err) {
6220 		printk(KERN_WARNING DRV_NAME
6221 		       "Error calling pci_set_dma_mask.\n");
6222 		pci_disable_device(pci_dev);
6223 		return err;
6224 	}
6225 
6226 	err = pci_request_regions(pci_dev, DRV_NAME);
6227 	if (err) {
6228 		printk(KERN_WARNING DRV_NAME
6229 		       "Error calling pci_request_regions.\n");
6230 		pci_disable_device(pci_dev);
6231 		return err;
6232 	}
6233 
6234 	/* We disable the RETRY_TIMEOUT register (0x41) to keep
6235 	 * PCI Tx retries from interfering with C3 CPU state */
6236 	pci_read_config_dword(pci_dev, 0x40, &val);
6237 	if ((val & 0x0000ff00) != 0)
6238 		pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff);
6239 
6240 	if (!ipw2100_hw_is_adapter_in_system(dev)) {
6241 		printk(KERN_WARNING DRV_NAME
6242 		       "Device not found via register read.\n");
6243 		err = -ENODEV;
6244 		goto fail;
6245 	}
6246 
6247 	SET_NETDEV_DEV(dev, &pci_dev->dev);
6248 
6249 	/* Force interrupts to be shut off on the device */
6250 	priv->status |= STATUS_INT_ENABLED;
6251 	ipw2100_disable_interrupts(priv);
6252 
6253 	/* Allocate and initialize the Tx/Rx queues and lists */
6254 	if (ipw2100_queues_allocate(priv)) {
6255 		printk(KERN_WARNING DRV_NAME
6256 		       "Error calling ipw2100_queues_allocate.\n");
6257 		err = -ENOMEM;
6258 		goto fail;
6259 	}
6260 	ipw2100_queues_initialize(priv);
6261 
6262 	err = request_irq(pci_dev->irq,
6263 			  ipw2100_interrupt, IRQF_SHARED, dev->name, priv);
6264 	if (err) {
6265 		printk(KERN_WARNING DRV_NAME
6266 		       "Error calling request_irq: %d.\n", pci_dev->irq);
6267 		goto fail;
6268 	}
6269 	dev->irq = pci_dev->irq;
6270 
6271 	IPW_DEBUG_INFO("Attempting to register device...\n");
6272 
6273 	printk(KERN_INFO DRV_NAME
6274 	       ": Detected Intel PRO/Wireless 2100 Network Connection\n");
6275 
6276 	err = ipw2100_up(priv, 1);
6277 	if (err)
6278 		goto fail;
6279 
6280 	err = ipw2100_wdev_init(dev);
6281 	if (err)
6282 		goto fail;
6283 	registered = 1;
6284 
6285 	/* Bring up the interface.  Pre 0.46, after we registered the
6286 	 * network device we would call ipw2100_up.  This introduced a race
6287 	 * condition with newer hotplug configurations (network was coming
6288 	 * up and making calls before the device was initialized).
6289 	 */
6290 	err = register_netdev(dev);
6291 	if (err) {
6292 		printk(KERN_WARNING DRV_NAME
6293 		       "Error calling register_netdev.\n");
6294 		goto fail;
6295 	}
6296 	registered = 2;
6297 
6298 	mutex_lock(&priv->action_mutex);
6299 
6300 	IPW_DEBUG_INFO("%s: Bound to %s\n", dev->name, pci_name(pci_dev));
6301 
6302 	/* perform this after register_netdev so that dev->name is set */
6303 	err = sysfs_create_group(&pci_dev->dev.kobj, &ipw2100_attribute_group);
6304 	if (err)
6305 		goto fail_unlock;
6306 
6307 	/* If the RF Kill switch is disabled, go ahead and complete the
6308 	 * startup sequence */
6309 	if (!(priv->status & STATUS_RF_KILL_MASK)) {
6310 		/* Enable the adapter - sends HOST_COMPLETE */
6311 		if (ipw2100_enable_adapter(priv)) {
6312 			printk(KERN_WARNING DRV_NAME
6313 			       ": %s: failed in call to enable adapter.\n",
6314 			       priv->net_dev->name);
6315 			ipw2100_hw_stop_adapter(priv);
6316 			err = -EIO;
6317 			goto fail_unlock;
6318 		}
6319 
6320 		/* Start a scan . . . */
6321 		ipw2100_set_scan_options(priv);
6322 		ipw2100_start_scan(priv);
6323 	}
6324 
6325 	IPW_DEBUG_INFO("exit\n");
6326 
6327 	priv->status |= STATUS_INITIALIZED;
6328 
6329 	mutex_unlock(&priv->action_mutex);
6330 out:
6331 	return err;
6332 
6333       fail_unlock:
6334 	mutex_unlock(&priv->action_mutex);
6335       fail:
6336 	if (dev) {
6337 		if (registered >= 2)
6338 			unregister_netdev(dev);
6339 
6340 		if (registered) {
6341 			wiphy_unregister(priv->ieee->wdev.wiphy);
6342 			kfree(priv->ieee->bg_band.channels);
6343 		}
6344 
6345 		ipw2100_hw_stop_adapter(priv);
6346 
6347 		ipw2100_disable_interrupts(priv);
6348 
6349 		if (dev->irq)
6350 			free_irq(dev->irq, priv);
6351 
6352 		ipw2100_kill_works(priv);
6353 
6354 		/* These are safe to call even if they weren't allocated */
6355 		ipw2100_queues_free(priv);
6356 		sysfs_remove_group(&pci_dev->dev.kobj,
6357 				   &ipw2100_attribute_group);
6358 
6359 		free_libipw(dev, 0);
6360 	}
6361 
6362 	pci_iounmap(pci_dev, ioaddr);
6363 
6364 	pci_release_regions(pci_dev);
6365 	pci_disable_device(pci_dev);
6366 	goto out;
6367 }
6368 
6369 static void ipw2100_pci_remove_one(struct pci_dev *pci_dev)
6370 {
6371 	struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6372 	struct net_device *dev = priv->net_dev;
6373 
6374 	mutex_lock(&priv->action_mutex);
6375 
6376 	priv->status &= ~STATUS_INITIALIZED;
6377 
6378 	sysfs_remove_group(&pci_dev->dev.kobj, &ipw2100_attribute_group);
6379 
6380 #ifdef CONFIG_PM
6381 	if (ipw2100_firmware.version)
6382 		ipw2100_release_firmware(priv, &ipw2100_firmware);
6383 #endif
6384 	/* Take down the hardware */
6385 	ipw2100_down(priv);
6386 
6387 	/* Release the mutex so that the network subsystem can
6388 	 * complete any needed calls into the driver... */
6389 	mutex_unlock(&priv->action_mutex);
6390 
6391 	/* Unregister the device first - this results in close()
6392 	 * being called if the device is open.  If we free storage
6393 	 * first, then close() will crash.
6394 	 * FIXME: remove the comment above. */
6395 	unregister_netdev(dev);
6396 
6397 	ipw2100_kill_works(priv);
6398 
6399 	ipw2100_queues_free(priv);
6400 
6401 	/* Free potential debugging firmware snapshot */
6402 	ipw2100_snapshot_free(priv);
6403 
6404 	free_irq(dev->irq, priv);
6405 
6406 	pci_iounmap(pci_dev, priv->ioaddr);
6407 
6408 	/* wiphy_unregister needs to be here, before free_libipw */
6409 	wiphy_unregister(priv->ieee->wdev.wiphy);
6410 	kfree(priv->ieee->bg_band.channels);
6411 	free_libipw(dev, 0);
6412 
6413 	pci_release_regions(pci_dev);
6414 	pci_disable_device(pci_dev);
6415 
6416 	IPW_DEBUG_INFO("exit\n");
6417 }
6418 
6419 #ifdef CONFIG_PM
6420 static int ipw2100_suspend(struct pci_dev *pci_dev, pm_message_t state)
6421 {
6422 	struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6423 	struct net_device *dev = priv->net_dev;
6424 
6425 	IPW_DEBUG_INFO("%s: Going into suspend...\n", dev->name);
6426 
6427 	mutex_lock(&priv->action_mutex);
6428 	if (priv->status & STATUS_INITIALIZED) {
6429 		/* Take down the device; powers it off, etc. */
6430 		ipw2100_down(priv);
6431 	}
6432 
6433 	/* Remove the PRESENT state of the device */
6434 	netif_device_detach(dev);
6435 
6436 	pci_save_state(pci_dev);
6437 	pci_disable_device(pci_dev);
6438 	pci_set_power_state(pci_dev, PCI_D3hot);
6439 
6440 	priv->suspend_at = get_seconds();
6441 
6442 	mutex_unlock(&priv->action_mutex);
6443 
6444 	return 0;
6445 }
6446 
6447 static int ipw2100_resume(struct pci_dev *pci_dev)
6448 {
6449 	struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6450 	struct net_device *dev = priv->net_dev;
6451 	int err;
6452 	u32 val;
6453 
6454 	if (IPW2100_PM_DISABLED)
6455 		return 0;
6456 
6457 	mutex_lock(&priv->action_mutex);
6458 
6459 	IPW_DEBUG_INFO("%s: Coming out of suspend...\n", dev->name);
6460 
6461 	pci_set_power_state(pci_dev, PCI_D0);
6462 	err = pci_enable_device(pci_dev);
6463 	if (err) {
6464 		printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
6465 		       dev->name);
6466 		mutex_unlock(&priv->action_mutex);
6467 		return err;
6468 	}
6469 	pci_restore_state(pci_dev);
6470 
6471 	/*
6472 	 * Suspend/Resume resets the PCI configuration space, so we have to
6473 	 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
6474 	 * from interfering with C3 CPU state. pci_restore_state won't help
6475 	 * here since it only restores the first 64 bytes pci config header.
6476 	 */
6477 	pci_read_config_dword(pci_dev, 0x40, &val);
6478 	if ((val & 0x0000ff00) != 0)
6479 		pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff);
6480 
6481 	/* Set the device back into the PRESENT state; this will also wake
6482 	 * the queue of needed */
6483 	netif_device_attach(dev);
6484 
6485 	priv->suspend_time = get_seconds() - priv->suspend_at;
6486 
6487 	/* Bring the device back up */
6488 	if (!(priv->status & STATUS_RF_KILL_SW))
6489 		ipw2100_up(priv, 0);
6490 
6491 	mutex_unlock(&priv->action_mutex);
6492 
6493 	return 0;
6494 }
6495 #endif
6496 
6497 static void ipw2100_shutdown(struct pci_dev *pci_dev)
6498 {
6499 	struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6500 
6501 	/* Take down the device; powers it off, etc. */
6502 	ipw2100_down(priv);
6503 
6504 	pci_disable_device(pci_dev);
6505 }
6506 
6507 #define IPW2100_DEV_ID(x) { PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, x }
6508 
6509 static const struct pci_device_id ipw2100_pci_id_table[] = {
6510 	IPW2100_DEV_ID(0x2520),	/* IN 2100A mPCI 3A */
6511 	IPW2100_DEV_ID(0x2521),	/* IN 2100A mPCI 3B */
6512 	IPW2100_DEV_ID(0x2524),	/* IN 2100A mPCI 3B */
6513 	IPW2100_DEV_ID(0x2525),	/* IN 2100A mPCI 3B */
6514 	IPW2100_DEV_ID(0x2526),	/* IN 2100A mPCI Gen A3 */
6515 	IPW2100_DEV_ID(0x2522),	/* IN 2100 mPCI 3B */
6516 	IPW2100_DEV_ID(0x2523),	/* IN 2100 mPCI 3A */
6517 	IPW2100_DEV_ID(0x2527),	/* IN 2100 mPCI 3B */
6518 	IPW2100_DEV_ID(0x2528),	/* IN 2100 mPCI 3B */
6519 	IPW2100_DEV_ID(0x2529),	/* IN 2100 mPCI 3B */
6520 	IPW2100_DEV_ID(0x252B),	/* IN 2100 mPCI 3A */
6521 	IPW2100_DEV_ID(0x252C),	/* IN 2100 mPCI 3A */
6522 	IPW2100_DEV_ID(0x252D),	/* IN 2100 mPCI 3A */
6523 
6524 	IPW2100_DEV_ID(0x2550),	/* IB 2100A mPCI 3B */
6525 	IPW2100_DEV_ID(0x2551),	/* IB 2100 mPCI 3B */
6526 	IPW2100_DEV_ID(0x2553),	/* IB 2100 mPCI 3B */
6527 	IPW2100_DEV_ID(0x2554),	/* IB 2100 mPCI 3B */
6528 	IPW2100_DEV_ID(0x2555),	/* IB 2100 mPCI 3B */
6529 
6530 	IPW2100_DEV_ID(0x2560),	/* DE 2100A mPCI 3A */
6531 	IPW2100_DEV_ID(0x2562),	/* DE 2100A mPCI 3A */
6532 	IPW2100_DEV_ID(0x2563),	/* DE 2100A mPCI 3A */
6533 	IPW2100_DEV_ID(0x2561),	/* DE 2100 mPCI 3A */
6534 	IPW2100_DEV_ID(0x2565),	/* DE 2100 mPCI 3A */
6535 	IPW2100_DEV_ID(0x2566),	/* DE 2100 mPCI 3A */
6536 	IPW2100_DEV_ID(0x2567),	/* DE 2100 mPCI 3A */
6537 
6538 	IPW2100_DEV_ID(0x2570),	/* GA 2100 mPCI 3B */
6539 
6540 	IPW2100_DEV_ID(0x2580),	/* TO 2100A mPCI 3B */
6541 	IPW2100_DEV_ID(0x2582),	/* TO 2100A mPCI 3B */
6542 	IPW2100_DEV_ID(0x2583),	/* TO 2100A mPCI 3B */
6543 	IPW2100_DEV_ID(0x2581),	/* TO 2100 mPCI 3B */
6544 	IPW2100_DEV_ID(0x2585),	/* TO 2100 mPCI 3B */
6545 	IPW2100_DEV_ID(0x2586),	/* TO 2100 mPCI 3B */
6546 	IPW2100_DEV_ID(0x2587),	/* TO 2100 mPCI 3B */
6547 
6548 	IPW2100_DEV_ID(0x2590),	/* SO 2100A mPCI 3B */
6549 	IPW2100_DEV_ID(0x2592),	/* SO 2100A mPCI 3B */
6550 	IPW2100_DEV_ID(0x2591),	/* SO 2100 mPCI 3B */
6551 	IPW2100_DEV_ID(0x2593),	/* SO 2100 mPCI 3B */
6552 	IPW2100_DEV_ID(0x2596),	/* SO 2100 mPCI 3B */
6553 	IPW2100_DEV_ID(0x2598),	/* SO 2100 mPCI 3B */
6554 
6555 	IPW2100_DEV_ID(0x25A0),	/* HP 2100 mPCI 3B */
6556 	{0,},
6557 };
6558 
6559 MODULE_DEVICE_TABLE(pci, ipw2100_pci_id_table);
6560 
6561 static struct pci_driver ipw2100_pci_driver = {
6562 	.name = DRV_NAME,
6563 	.id_table = ipw2100_pci_id_table,
6564 	.probe = ipw2100_pci_init_one,
6565 	.remove = ipw2100_pci_remove_one,
6566 #ifdef CONFIG_PM
6567 	.suspend = ipw2100_suspend,
6568 	.resume = ipw2100_resume,
6569 #endif
6570 	.shutdown = ipw2100_shutdown,
6571 };
6572 
6573 /**
6574  * Initialize the ipw2100 driver/module
6575  *
6576  * @returns 0 if ok, < 0 errno node con error.
6577  *
6578  * Note: we cannot init the /proc stuff until the PCI driver is there,
6579  * or we risk an unlikely race condition on someone accessing
6580  * uninitialized data in the PCI dev struct through /proc.
6581  */
6582 static int __init ipw2100_init(void)
6583 {
6584 	int ret;
6585 
6586 	printk(KERN_INFO DRV_NAME ": %s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
6587 	printk(KERN_INFO DRV_NAME ": %s\n", DRV_COPYRIGHT);
6588 
6589 	pm_qos_add_request(&ipw2100_pm_qos_req, PM_QOS_CPU_DMA_LATENCY,
6590 			   PM_QOS_DEFAULT_VALUE);
6591 
6592 	ret = pci_register_driver(&ipw2100_pci_driver);
6593 	if (ret)
6594 		goto out;
6595 
6596 #ifdef CONFIG_IPW2100_DEBUG
6597 	ipw2100_debug_level = debug;
6598 	ret = driver_create_file(&ipw2100_pci_driver.driver,
6599 				 &driver_attr_debug_level);
6600 #endif
6601 
6602 out:
6603 	return ret;
6604 }
6605 
6606 /**
6607  * Cleanup ipw2100 driver registration
6608  */
6609 static void __exit ipw2100_exit(void)
6610 {
6611 	/* FIXME: IPG: check that we have no instances of the devices open */
6612 #ifdef CONFIG_IPW2100_DEBUG
6613 	driver_remove_file(&ipw2100_pci_driver.driver,
6614 			   &driver_attr_debug_level);
6615 #endif
6616 	pci_unregister_driver(&ipw2100_pci_driver);
6617 	pm_qos_remove_request(&ipw2100_pm_qos_req);
6618 }
6619 
6620 module_init(ipw2100_init);
6621 module_exit(ipw2100_exit);
6622 
6623 static int ipw2100_wx_get_name(struct net_device *dev,
6624 			       struct iw_request_info *info,
6625 			       union iwreq_data *wrqu, char *extra)
6626 {
6627 	/*
6628 	 * This can be called at any time.  No action lock required
6629 	 */
6630 
6631 	struct ipw2100_priv *priv = libipw_priv(dev);
6632 	if (!(priv->status & STATUS_ASSOCIATED))
6633 		strcpy(wrqu->name, "unassociated");
6634 	else
6635 		snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b");
6636 
6637 	IPW_DEBUG_WX("Name: %s\n", wrqu->name);
6638 	return 0;
6639 }
6640 
6641 static int ipw2100_wx_set_freq(struct net_device *dev,
6642 			       struct iw_request_info *info,
6643 			       union iwreq_data *wrqu, char *extra)
6644 {
6645 	struct ipw2100_priv *priv = libipw_priv(dev);
6646 	struct iw_freq *fwrq = &wrqu->freq;
6647 	int err = 0;
6648 
6649 	if (priv->ieee->iw_mode == IW_MODE_INFRA)
6650 		return -EOPNOTSUPP;
6651 
6652 	mutex_lock(&priv->action_mutex);
6653 	if (!(priv->status & STATUS_INITIALIZED)) {
6654 		err = -EIO;
6655 		goto done;
6656 	}
6657 
6658 	/* if setting by freq convert to channel */
6659 	if (fwrq->e == 1) {
6660 		if ((fwrq->m >= (int)2.412e8 && fwrq->m <= (int)2.487e8)) {
6661 			int f = fwrq->m / 100000;
6662 			int c = 0;
6663 
6664 			while ((c < REG_MAX_CHANNEL) &&
6665 			       (f != ipw2100_frequencies[c]))
6666 				c++;
6667 
6668 			/* hack to fall through */
6669 			fwrq->e = 0;
6670 			fwrq->m = c + 1;
6671 		}
6672 	}
6673 
6674 	if (fwrq->e > 0 || fwrq->m > 1000) {
6675 		err = -EOPNOTSUPP;
6676 		goto done;
6677 	} else {		/* Set the channel */
6678 		IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m);
6679 		err = ipw2100_set_channel(priv, fwrq->m, 0);
6680 	}
6681 
6682       done:
6683 	mutex_unlock(&priv->action_mutex);
6684 	return err;
6685 }
6686 
6687 static int ipw2100_wx_get_freq(struct net_device *dev,
6688 			       struct iw_request_info *info,
6689 			       union iwreq_data *wrqu, char *extra)
6690 {
6691 	/*
6692 	 * This can be called at any time.  No action lock required
6693 	 */
6694 
6695 	struct ipw2100_priv *priv = libipw_priv(dev);
6696 
6697 	wrqu->freq.e = 0;
6698 
6699 	/* If we are associated, trying to associate, or have a statically
6700 	 * configured CHANNEL then return that; otherwise return ANY */
6701 	if (priv->config & CFG_STATIC_CHANNEL ||
6702 	    priv->status & STATUS_ASSOCIATED)
6703 		wrqu->freq.m = priv->channel;
6704 	else
6705 		wrqu->freq.m = 0;
6706 
6707 	IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel);
6708 	return 0;
6709 
6710 }
6711 
6712 static int ipw2100_wx_set_mode(struct net_device *dev,
6713 			       struct iw_request_info *info,
6714 			       union iwreq_data *wrqu, char *extra)
6715 {
6716 	struct ipw2100_priv *priv = libipw_priv(dev);
6717 	int err = 0;
6718 
6719 	IPW_DEBUG_WX("SET Mode -> %d\n", wrqu->mode);
6720 
6721 	if (wrqu->mode == priv->ieee->iw_mode)
6722 		return 0;
6723 
6724 	mutex_lock(&priv->action_mutex);
6725 	if (!(priv->status & STATUS_INITIALIZED)) {
6726 		err = -EIO;
6727 		goto done;
6728 	}
6729 
6730 	switch (wrqu->mode) {
6731 #ifdef CONFIG_IPW2100_MONITOR
6732 	case IW_MODE_MONITOR:
6733 		err = ipw2100_switch_mode(priv, IW_MODE_MONITOR);
6734 		break;
6735 #endif				/* CONFIG_IPW2100_MONITOR */
6736 	case IW_MODE_ADHOC:
6737 		err = ipw2100_switch_mode(priv, IW_MODE_ADHOC);
6738 		break;
6739 	case IW_MODE_INFRA:
6740 	case IW_MODE_AUTO:
6741 	default:
6742 		err = ipw2100_switch_mode(priv, IW_MODE_INFRA);
6743 		break;
6744 	}
6745 
6746       done:
6747 	mutex_unlock(&priv->action_mutex);
6748 	return err;
6749 }
6750 
6751 static int ipw2100_wx_get_mode(struct net_device *dev,
6752 			       struct iw_request_info *info,
6753 			       union iwreq_data *wrqu, char *extra)
6754 {
6755 	/*
6756 	 * This can be called at any time.  No action lock required
6757 	 */
6758 
6759 	struct ipw2100_priv *priv = libipw_priv(dev);
6760 
6761 	wrqu->mode = priv->ieee->iw_mode;
6762 	IPW_DEBUG_WX("GET Mode -> %d\n", wrqu->mode);
6763 
6764 	return 0;
6765 }
6766 
6767 #define POWER_MODES 5
6768 
6769 /* Values are in microsecond */
6770 static const s32 timeout_duration[POWER_MODES] = {
6771 	350000,
6772 	250000,
6773 	75000,
6774 	37000,
6775 	25000,
6776 };
6777 
6778 static const s32 period_duration[POWER_MODES] = {
6779 	400000,
6780 	700000,
6781 	1000000,
6782 	1000000,
6783 	1000000
6784 };
6785 
6786 static int ipw2100_wx_get_range(struct net_device *dev,
6787 				struct iw_request_info *info,
6788 				union iwreq_data *wrqu, char *extra)
6789 {
6790 	/*
6791 	 * This can be called at any time.  No action lock required
6792 	 */
6793 
6794 	struct ipw2100_priv *priv = libipw_priv(dev);
6795 	struct iw_range *range = (struct iw_range *)extra;
6796 	u16 val;
6797 	int i, level;
6798 
6799 	wrqu->data.length = sizeof(*range);
6800 	memset(range, 0, sizeof(*range));
6801 
6802 	/* Let's try to keep this struct in the same order as in
6803 	 * linux/include/wireless.h
6804 	 */
6805 
6806 	/* TODO: See what values we can set, and remove the ones we can't
6807 	 * set, or fill them with some default data.
6808 	 */
6809 
6810 	/* ~5 Mb/s real (802.11b) */
6811 	range->throughput = 5 * 1000 * 1000;
6812 
6813 //      range->sensitivity;     /* signal level threshold range */
6814 
6815 	range->max_qual.qual = 100;
6816 	/* TODO: Find real max RSSI and stick here */
6817 	range->max_qual.level = 0;
6818 	range->max_qual.noise = 0;
6819 	range->max_qual.updated = 7;	/* Updated all three */
6820 
6821 	range->avg_qual.qual = 70;	/* > 8% missed beacons is 'bad' */
6822 	/* TODO: Find real 'good' to 'bad' threshold value for RSSI */
6823 	range->avg_qual.level = 20 + IPW2100_RSSI_TO_DBM;
6824 	range->avg_qual.noise = 0;
6825 	range->avg_qual.updated = 7;	/* Updated all three */
6826 
6827 	range->num_bitrates = RATE_COUNT;
6828 
6829 	for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) {
6830 		range->bitrate[i] = ipw2100_bg_rates[i].bitrate * 100 * 1000;
6831 	}
6832 
6833 	range->min_rts = MIN_RTS_THRESHOLD;
6834 	range->max_rts = MAX_RTS_THRESHOLD;
6835 	range->min_frag = MIN_FRAG_THRESHOLD;
6836 	range->max_frag = MAX_FRAG_THRESHOLD;
6837 
6838 	range->min_pmp = period_duration[0];	/* Minimal PM period */
6839 	range->max_pmp = period_duration[POWER_MODES - 1];	/* Maximal PM period */
6840 	range->min_pmt = timeout_duration[POWER_MODES - 1];	/* Minimal PM timeout */
6841 	range->max_pmt = timeout_duration[0];	/* Maximal PM timeout */
6842 
6843 	/* How to decode max/min PM period */
6844 	range->pmp_flags = IW_POWER_PERIOD;
6845 	/* How to decode max/min PM period */
6846 	range->pmt_flags = IW_POWER_TIMEOUT;
6847 	/* What PM options are supported */
6848 	range->pm_capa = IW_POWER_TIMEOUT | IW_POWER_PERIOD;
6849 
6850 	range->encoding_size[0] = 5;
6851 	range->encoding_size[1] = 13;	/* Different token sizes */
6852 	range->num_encoding_sizes = 2;	/* Number of entry in the list */
6853 	range->max_encoding_tokens = WEP_KEYS;	/* Max number of tokens */
6854 //      range->encoding_login_index;            /* token index for login token */
6855 
6856 	if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6857 		range->txpower_capa = IW_TXPOW_DBM;
6858 		range->num_txpower = IW_MAX_TXPOWER;
6859 		for (i = 0, level = (IPW_TX_POWER_MAX_DBM * 16);
6860 		     i < IW_MAX_TXPOWER;
6861 		     i++, level -=
6862 		     ((IPW_TX_POWER_MAX_DBM -
6863 		       IPW_TX_POWER_MIN_DBM) * 16) / (IW_MAX_TXPOWER - 1))
6864 			range->txpower[i] = level / 16;
6865 	} else {
6866 		range->txpower_capa = 0;
6867 		range->num_txpower = 0;
6868 	}
6869 
6870 	/* Set the Wireless Extension versions */
6871 	range->we_version_compiled = WIRELESS_EXT;
6872 	range->we_version_source = 18;
6873 
6874 //      range->retry_capa;      /* What retry options are supported */
6875 //      range->retry_flags;     /* How to decode max/min retry limit */
6876 //      range->r_time_flags;    /* How to decode max/min retry life */
6877 //      range->min_retry;       /* Minimal number of retries */
6878 //      range->max_retry;       /* Maximal number of retries */
6879 //      range->min_r_time;      /* Minimal retry lifetime */
6880 //      range->max_r_time;      /* Maximal retry lifetime */
6881 
6882 	range->num_channels = FREQ_COUNT;
6883 
6884 	val = 0;
6885 	for (i = 0; i < FREQ_COUNT; i++) {
6886 		// TODO: Include only legal frequencies for some countries
6887 //              if (local->channel_mask & (1 << i)) {
6888 		range->freq[val].i = i + 1;
6889 		range->freq[val].m = ipw2100_frequencies[i] * 100000;
6890 		range->freq[val].e = 1;
6891 		val++;
6892 //              }
6893 		if (val == IW_MAX_FREQUENCIES)
6894 			break;
6895 	}
6896 	range->num_frequency = val;
6897 
6898 	/* Event capability (kernel + driver) */
6899 	range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6900 				IW_EVENT_CAPA_MASK(SIOCGIWAP));
6901 	range->event_capa[1] = IW_EVENT_CAPA_K_1;
6902 
6903 	range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
6904 		IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
6905 
6906 	IPW_DEBUG_WX("GET Range\n");
6907 
6908 	return 0;
6909 }
6910 
6911 static int ipw2100_wx_set_wap(struct net_device *dev,
6912 			      struct iw_request_info *info,
6913 			      union iwreq_data *wrqu, char *extra)
6914 {
6915 	struct ipw2100_priv *priv = libipw_priv(dev);
6916 	int err = 0;
6917 
6918 	// sanity checks
6919 	if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
6920 		return -EINVAL;
6921 
6922 	mutex_lock(&priv->action_mutex);
6923 	if (!(priv->status & STATUS_INITIALIZED)) {
6924 		err = -EIO;
6925 		goto done;
6926 	}
6927 
6928 	if (is_broadcast_ether_addr(wrqu->ap_addr.sa_data) ||
6929 	    is_zero_ether_addr(wrqu->ap_addr.sa_data)) {
6930 		/* we disable mandatory BSSID association */
6931 		IPW_DEBUG_WX("exit - disable mandatory BSSID\n");
6932 		priv->config &= ~CFG_STATIC_BSSID;
6933 		err = ipw2100_set_mandatory_bssid(priv, NULL, 0);
6934 		goto done;
6935 	}
6936 
6937 	priv->config |= CFG_STATIC_BSSID;
6938 	memcpy(priv->mandatory_bssid_mac, wrqu->ap_addr.sa_data, ETH_ALEN);
6939 
6940 	err = ipw2100_set_mandatory_bssid(priv, wrqu->ap_addr.sa_data, 0);
6941 
6942 	IPW_DEBUG_WX("SET BSSID -> %pM\n", wrqu->ap_addr.sa_data);
6943 
6944       done:
6945 	mutex_unlock(&priv->action_mutex);
6946 	return err;
6947 }
6948 
6949 static int ipw2100_wx_get_wap(struct net_device *dev,
6950 			      struct iw_request_info *info,
6951 			      union iwreq_data *wrqu, char *extra)
6952 {
6953 	/*
6954 	 * This can be called at any time.  No action lock required
6955 	 */
6956 
6957 	struct ipw2100_priv *priv = libipw_priv(dev);
6958 
6959 	/* If we are associated, trying to associate, or have a statically
6960 	 * configured BSSID then return that; otherwise return ANY */
6961 	if (priv->config & CFG_STATIC_BSSID || priv->status & STATUS_ASSOCIATED) {
6962 		wrqu->ap_addr.sa_family = ARPHRD_ETHER;
6963 		memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
6964 	} else
6965 		eth_zero_addr(wrqu->ap_addr.sa_data);
6966 
6967 	IPW_DEBUG_WX("Getting WAP BSSID: %pM\n", wrqu->ap_addr.sa_data);
6968 	return 0;
6969 }
6970 
6971 static int ipw2100_wx_set_essid(struct net_device *dev,
6972 				struct iw_request_info *info,
6973 				union iwreq_data *wrqu, char *extra)
6974 {
6975 	struct ipw2100_priv *priv = libipw_priv(dev);
6976 	char *essid = "";	/* ANY */
6977 	int length = 0;
6978 	int err = 0;
6979 
6980 	mutex_lock(&priv->action_mutex);
6981 	if (!(priv->status & STATUS_INITIALIZED)) {
6982 		err = -EIO;
6983 		goto done;
6984 	}
6985 
6986 	if (wrqu->essid.flags && wrqu->essid.length) {
6987 		length = wrqu->essid.length;
6988 		essid = extra;
6989 	}
6990 
6991 	if (length == 0) {
6992 		IPW_DEBUG_WX("Setting ESSID to ANY\n");
6993 		priv->config &= ~CFG_STATIC_ESSID;
6994 		err = ipw2100_set_essid(priv, NULL, 0, 0);
6995 		goto done;
6996 	}
6997 
6998 	length = min(length, IW_ESSID_MAX_SIZE);
6999 
7000 	priv->config |= CFG_STATIC_ESSID;
7001 
7002 	if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
7003 		IPW_DEBUG_WX("ESSID set to current ESSID.\n");
7004 		err = 0;
7005 		goto done;
7006 	}
7007 
7008 	IPW_DEBUG_WX("Setting ESSID: '%*pE' (%d)\n", length, essid, length);
7009 
7010 	priv->essid_len = length;
7011 	memcpy(priv->essid, essid, priv->essid_len);
7012 
7013 	err = ipw2100_set_essid(priv, essid, length, 0);
7014 
7015       done:
7016 	mutex_unlock(&priv->action_mutex);
7017 	return err;
7018 }
7019 
7020 static int ipw2100_wx_get_essid(struct net_device *dev,
7021 				struct iw_request_info *info,
7022 				union iwreq_data *wrqu, char *extra)
7023 {
7024 	/*
7025 	 * This can be called at any time.  No action lock required
7026 	 */
7027 
7028 	struct ipw2100_priv *priv = libipw_priv(dev);
7029 
7030 	/* If we are associated, trying to associate, or have a statically
7031 	 * configured ESSID then return that; otherwise return ANY */
7032 	if (priv->config & CFG_STATIC_ESSID || priv->status & STATUS_ASSOCIATED) {
7033 		IPW_DEBUG_WX("Getting essid: '%*pE'\n",
7034 			     priv->essid_len, priv->essid);
7035 		memcpy(extra, priv->essid, priv->essid_len);
7036 		wrqu->essid.length = priv->essid_len;
7037 		wrqu->essid.flags = 1;	/* active */
7038 	} else {
7039 		IPW_DEBUG_WX("Getting essid: ANY\n");
7040 		wrqu->essid.length = 0;
7041 		wrqu->essid.flags = 0;	/* active */
7042 	}
7043 
7044 	return 0;
7045 }
7046 
7047 static int ipw2100_wx_set_nick(struct net_device *dev,
7048 			       struct iw_request_info *info,
7049 			       union iwreq_data *wrqu, char *extra)
7050 {
7051 	/*
7052 	 * This can be called at any time.  No action lock required
7053 	 */
7054 
7055 	struct ipw2100_priv *priv = libipw_priv(dev);
7056 
7057 	if (wrqu->data.length > IW_ESSID_MAX_SIZE)
7058 		return -E2BIG;
7059 
7060 	wrqu->data.length = min_t(size_t, wrqu->data.length, sizeof(priv->nick));
7061 	memset(priv->nick, 0, sizeof(priv->nick));
7062 	memcpy(priv->nick, extra, wrqu->data.length);
7063 
7064 	IPW_DEBUG_WX("SET Nickname -> %s\n", priv->nick);
7065 
7066 	return 0;
7067 }
7068 
7069 static int ipw2100_wx_get_nick(struct net_device *dev,
7070 			       struct iw_request_info *info,
7071 			       union iwreq_data *wrqu, char *extra)
7072 {
7073 	/*
7074 	 * This can be called at any time.  No action lock required
7075 	 */
7076 
7077 	struct ipw2100_priv *priv = libipw_priv(dev);
7078 
7079 	wrqu->data.length = strlen(priv->nick);
7080 	memcpy(extra, priv->nick, wrqu->data.length);
7081 	wrqu->data.flags = 1;	/* active */
7082 
7083 	IPW_DEBUG_WX("GET Nickname -> %s\n", extra);
7084 
7085 	return 0;
7086 }
7087 
7088 static int ipw2100_wx_set_rate(struct net_device *dev,
7089 			       struct iw_request_info *info,
7090 			       union iwreq_data *wrqu, char *extra)
7091 {
7092 	struct ipw2100_priv *priv = libipw_priv(dev);
7093 	u32 target_rate = wrqu->bitrate.value;
7094 	u32 rate;
7095 	int err = 0;
7096 
7097 	mutex_lock(&priv->action_mutex);
7098 	if (!(priv->status & STATUS_INITIALIZED)) {
7099 		err = -EIO;
7100 		goto done;
7101 	}
7102 
7103 	rate = 0;
7104 
7105 	if (target_rate == 1000000 ||
7106 	    (!wrqu->bitrate.fixed && target_rate > 1000000))
7107 		rate |= TX_RATE_1_MBIT;
7108 	if (target_rate == 2000000 ||
7109 	    (!wrqu->bitrate.fixed && target_rate > 2000000))
7110 		rate |= TX_RATE_2_MBIT;
7111 	if (target_rate == 5500000 ||
7112 	    (!wrqu->bitrate.fixed && target_rate > 5500000))
7113 		rate |= TX_RATE_5_5_MBIT;
7114 	if (target_rate == 11000000 ||
7115 	    (!wrqu->bitrate.fixed && target_rate > 11000000))
7116 		rate |= TX_RATE_11_MBIT;
7117 	if (rate == 0)
7118 		rate = DEFAULT_TX_RATES;
7119 
7120 	err = ipw2100_set_tx_rates(priv, rate, 0);
7121 
7122 	IPW_DEBUG_WX("SET Rate -> %04X\n", rate);
7123       done:
7124 	mutex_unlock(&priv->action_mutex);
7125 	return err;
7126 }
7127 
7128 static int ipw2100_wx_get_rate(struct net_device *dev,
7129 			       struct iw_request_info *info,
7130 			       union iwreq_data *wrqu, char *extra)
7131 {
7132 	struct ipw2100_priv *priv = libipw_priv(dev);
7133 	int val;
7134 	unsigned int len = sizeof(val);
7135 	int err = 0;
7136 
7137 	if (!(priv->status & STATUS_ENABLED) ||
7138 	    priv->status & STATUS_RF_KILL_MASK ||
7139 	    !(priv->status & STATUS_ASSOCIATED)) {
7140 		wrqu->bitrate.value = 0;
7141 		return 0;
7142 	}
7143 
7144 	mutex_lock(&priv->action_mutex);
7145 	if (!(priv->status & STATUS_INITIALIZED)) {
7146 		err = -EIO;
7147 		goto done;
7148 	}
7149 
7150 	err = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &val, &len);
7151 	if (err) {
7152 		IPW_DEBUG_WX("failed querying ordinals.\n");
7153 		goto done;
7154 	}
7155 
7156 	switch (val & TX_RATE_MASK) {
7157 	case TX_RATE_1_MBIT:
7158 		wrqu->bitrate.value = 1000000;
7159 		break;
7160 	case TX_RATE_2_MBIT:
7161 		wrqu->bitrate.value = 2000000;
7162 		break;
7163 	case TX_RATE_5_5_MBIT:
7164 		wrqu->bitrate.value = 5500000;
7165 		break;
7166 	case TX_RATE_11_MBIT:
7167 		wrqu->bitrate.value = 11000000;
7168 		break;
7169 	default:
7170 		wrqu->bitrate.value = 0;
7171 	}
7172 
7173 	IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value);
7174 
7175       done:
7176 	mutex_unlock(&priv->action_mutex);
7177 	return err;
7178 }
7179 
7180 static int ipw2100_wx_set_rts(struct net_device *dev,
7181 			      struct iw_request_info *info,
7182 			      union iwreq_data *wrqu, char *extra)
7183 {
7184 	struct ipw2100_priv *priv = libipw_priv(dev);
7185 	int value, err;
7186 
7187 	/* Auto RTS not yet supported */
7188 	if (wrqu->rts.fixed == 0)
7189 		return -EINVAL;
7190 
7191 	mutex_lock(&priv->action_mutex);
7192 	if (!(priv->status & STATUS_INITIALIZED)) {
7193 		err = -EIO;
7194 		goto done;
7195 	}
7196 
7197 	if (wrqu->rts.disabled)
7198 		value = priv->rts_threshold | RTS_DISABLED;
7199 	else {
7200 		if (wrqu->rts.value < 1 || wrqu->rts.value > 2304) {
7201 			err = -EINVAL;
7202 			goto done;
7203 		}
7204 		value = wrqu->rts.value;
7205 	}
7206 
7207 	err = ipw2100_set_rts_threshold(priv, value);
7208 
7209 	IPW_DEBUG_WX("SET RTS Threshold -> 0x%08X\n", value);
7210       done:
7211 	mutex_unlock(&priv->action_mutex);
7212 	return err;
7213 }
7214 
7215 static int ipw2100_wx_get_rts(struct net_device *dev,
7216 			      struct iw_request_info *info,
7217 			      union iwreq_data *wrqu, char *extra)
7218 {
7219 	/*
7220 	 * This can be called at any time.  No action lock required
7221 	 */
7222 
7223 	struct ipw2100_priv *priv = libipw_priv(dev);
7224 
7225 	wrqu->rts.value = priv->rts_threshold & ~RTS_DISABLED;
7226 	wrqu->rts.fixed = 1;	/* no auto select */
7227 
7228 	/* If RTS is set to the default value, then it is disabled */
7229 	wrqu->rts.disabled = (priv->rts_threshold & RTS_DISABLED) ? 1 : 0;
7230 
7231 	IPW_DEBUG_WX("GET RTS Threshold -> 0x%08X\n", wrqu->rts.value);
7232 
7233 	return 0;
7234 }
7235 
7236 static int ipw2100_wx_set_txpow(struct net_device *dev,
7237 				struct iw_request_info *info,
7238 				union iwreq_data *wrqu, char *extra)
7239 {
7240 	struct ipw2100_priv *priv = libipw_priv(dev);
7241 	int err = 0, value;
7242 
7243 	if (ipw_radio_kill_sw(priv, wrqu->txpower.disabled))
7244 		return -EINPROGRESS;
7245 
7246 	if (priv->ieee->iw_mode != IW_MODE_ADHOC)
7247 		return 0;
7248 
7249 	if ((wrqu->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)
7250 		return -EINVAL;
7251 
7252 	if (wrqu->txpower.fixed == 0)
7253 		value = IPW_TX_POWER_DEFAULT;
7254 	else {
7255 		if (wrqu->txpower.value < IPW_TX_POWER_MIN_DBM ||
7256 		    wrqu->txpower.value > IPW_TX_POWER_MAX_DBM)
7257 			return -EINVAL;
7258 
7259 		value = wrqu->txpower.value;
7260 	}
7261 
7262 	mutex_lock(&priv->action_mutex);
7263 	if (!(priv->status & STATUS_INITIALIZED)) {
7264 		err = -EIO;
7265 		goto done;
7266 	}
7267 
7268 	err = ipw2100_set_tx_power(priv, value);
7269 
7270 	IPW_DEBUG_WX("SET TX Power -> %d\n", value);
7271 
7272       done:
7273 	mutex_unlock(&priv->action_mutex);
7274 	return err;
7275 }
7276 
7277 static int ipw2100_wx_get_txpow(struct net_device *dev,
7278 				struct iw_request_info *info,
7279 				union iwreq_data *wrqu, char *extra)
7280 {
7281 	/*
7282 	 * This can be called at any time.  No action lock required
7283 	 */
7284 
7285 	struct ipw2100_priv *priv = libipw_priv(dev);
7286 
7287 	wrqu->txpower.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
7288 
7289 	if (priv->tx_power == IPW_TX_POWER_DEFAULT) {
7290 		wrqu->txpower.fixed = 0;
7291 		wrqu->txpower.value = IPW_TX_POWER_MAX_DBM;
7292 	} else {
7293 		wrqu->txpower.fixed = 1;
7294 		wrqu->txpower.value = priv->tx_power;
7295 	}
7296 
7297 	wrqu->txpower.flags = IW_TXPOW_DBM;
7298 
7299 	IPW_DEBUG_WX("GET TX Power -> %d\n", wrqu->txpower.value);
7300 
7301 	return 0;
7302 }
7303 
7304 static int ipw2100_wx_set_frag(struct net_device *dev,
7305 			       struct iw_request_info *info,
7306 			       union iwreq_data *wrqu, char *extra)
7307 {
7308 	/*
7309 	 * This can be called at any time.  No action lock required
7310 	 */
7311 
7312 	struct ipw2100_priv *priv = libipw_priv(dev);
7313 
7314 	if (!wrqu->frag.fixed)
7315 		return -EINVAL;
7316 
7317 	if (wrqu->frag.disabled) {
7318 		priv->frag_threshold |= FRAG_DISABLED;
7319 		priv->ieee->fts = DEFAULT_FTS;
7320 	} else {
7321 		if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
7322 		    wrqu->frag.value > MAX_FRAG_THRESHOLD)
7323 			return -EINVAL;
7324 
7325 		priv->ieee->fts = wrqu->frag.value & ~0x1;
7326 		priv->frag_threshold = priv->ieee->fts;
7327 	}
7328 
7329 	IPW_DEBUG_WX("SET Frag Threshold -> %d\n", priv->ieee->fts);
7330 
7331 	return 0;
7332 }
7333 
7334 static int ipw2100_wx_get_frag(struct net_device *dev,
7335 			       struct iw_request_info *info,
7336 			       union iwreq_data *wrqu, char *extra)
7337 {
7338 	/*
7339 	 * This can be called at any time.  No action lock required
7340 	 */
7341 
7342 	struct ipw2100_priv *priv = libipw_priv(dev);
7343 	wrqu->frag.value = priv->frag_threshold & ~FRAG_DISABLED;
7344 	wrqu->frag.fixed = 0;	/* no auto select */
7345 	wrqu->frag.disabled = (priv->frag_threshold & FRAG_DISABLED) ? 1 : 0;
7346 
7347 	IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value);
7348 
7349 	return 0;
7350 }
7351 
7352 static int ipw2100_wx_set_retry(struct net_device *dev,
7353 				struct iw_request_info *info,
7354 				union iwreq_data *wrqu, char *extra)
7355 {
7356 	struct ipw2100_priv *priv = libipw_priv(dev);
7357 	int err = 0;
7358 
7359 	if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
7360 		return -EINVAL;
7361 
7362 	if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
7363 		return 0;
7364 
7365 	mutex_lock(&priv->action_mutex);
7366 	if (!(priv->status & STATUS_INITIALIZED)) {
7367 		err = -EIO;
7368 		goto done;
7369 	}
7370 
7371 	if (wrqu->retry.flags & IW_RETRY_SHORT) {
7372 		err = ipw2100_set_short_retry(priv, wrqu->retry.value);
7373 		IPW_DEBUG_WX("SET Short Retry Limit -> %d\n",
7374 			     wrqu->retry.value);
7375 		goto done;
7376 	}
7377 
7378 	if (wrqu->retry.flags & IW_RETRY_LONG) {
7379 		err = ipw2100_set_long_retry(priv, wrqu->retry.value);
7380 		IPW_DEBUG_WX("SET Long Retry Limit -> %d\n",
7381 			     wrqu->retry.value);
7382 		goto done;
7383 	}
7384 
7385 	err = ipw2100_set_short_retry(priv, wrqu->retry.value);
7386 	if (!err)
7387 		err = ipw2100_set_long_retry(priv, wrqu->retry.value);
7388 
7389 	IPW_DEBUG_WX("SET Both Retry Limits -> %d\n", wrqu->retry.value);
7390 
7391       done:
7392 	mutex_unlock(&priv->action_mutex);
7393 	return err;
7394 }
7395 
7396 static int ipw2100_wx_get_retry(struct net_device *dev,
7397 				struct iw_request_info *info,
7398 				union iwreq_data *wrqu, char *extra)
7399 {
7400 	/*
7401 	 * This can be called at any time.  No action lock required
7402 	 */
7403 
7404 	struct ipw2100_priv *priv = libipw_priv(dev);
7405 
7406 	wrqu->retry.disabled = 0;	/* can't be disabled */
7407 
7408 	if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME)
7409 		return -EINVAL;
7410 
7411 	if (wrqu->retry.flags & IW_RETRY_LONG) {
7412 		wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
7413 		wrqu->retry.value = priv->long_retry_limit;
7414 	} else {
7415 		wrqu->retry.flags =
7416 		    (priv->short_retry_limit !=
7417 		     priv->long_retry_limit) ?
7418 		    IW_RETRY_LIMIT | IW_RETRY_SHORT : IW_RETRY_LIMIT;
7419 
7420 		wrqu->retry.value = priv->short_retry_limit;
7421 	}
7422 
7423 	IPW_DEBUG_WX("GET Retry -> %d\n", wrqu->retry.value);
7424 
7425 	return 0;
7426 }
7427 
7428 static int ipw2100_wx_set_scan(struct net_device *dev,
7429 			       struct iw_request_info *info,
7430 			       union iwreq_data *wrqu, char *extra)
7431 {
7432 	struct ipw2100_priv *priv = libipw_priv(dev);
7433 	int err = 0;
7434 
7435 	mutex_lock(&priv->action_mutex);
7436 	if (!(priv->status & STATUS_INITIALIZED)) {
7437 		err = -EIO;
7438 		goto done;
7439 	}
7440 
7441 	IPW_DEBUG_WX("Initiating scan...\n");
7442 
7443 	priv->user_requested_scan = 1;
7444 	if (ipw2100_set_scan_options(priv) || ipw2100_start_scan(priv)) {
7445 		IPW_DEBUG_WX("Start scan failed.\n");
7446 
7447 		/* TODO: Mark a scan as pending so when hardware initialized
7448 		 *       a scan starts */
7449 	}
7450 
7451       done:
7452 	mutex_unlock(&priv->action_mutex);
7453 	return err;
7454 }
7455 
7456 static int ipw2100_wx_get_scan(struct net_device *dev,
7457 			       struct iw_request_info *info,
7458 			       union iwreq_data *wrqu, char *extra)
7459 {
7460 	/*
7461 	 * This can be called at any time.  No action lock required
7462 	 */
7463 
7464 	struct ipw2100_priv *priv = libipw_priv(dev);
7465 	return libipw_wx_get_scan(priv->ieee, info, wrqu, extra);
7466 }
7467 
7468 /*
7469  * Implementation based on code in hostap-driver v0.1.3 hostap_ioctl.c
7470  */
7471 static int ipw2100_wx_set_encode(struct net_device *dev,
7472 				 struct iw_request_info *info,
7473 				 union iwreq_data *wrqu, char *key)
7474 {
7475 	/*
7476 	 * No check of STATUS_INITIALIZED required
7477 	 */
7478 
7479 	struct ipw2100_priv *priv = libipw_priv(dev);
7480 	return libipw_wx_set_encode(priv->ieee, info, wrqu, key);
7481 }
7482 
7483 static int ipw2100_wx_get_encode(struct net_device *dev,
7484 				 struct iw_request_info *info,
7485 				 union iwreq_data *wrqu, char *key)
7486 {
7487 	/*
7488 	 * This can be called at any time.  No action lock required
7489 	 */
7490 
7491 	struct ipw2100_priv *priv = libipw_priv(dev);
7492 	return libipw_wx_get_encode(priv->ieee, info, wrqu, key);
7493 }
7494 
7495 static int ipw2100_wx_set_power(struct net_device *dev,
7496 				struct iw_request_info *info,
7497 				union iwreq_data *wrqu, char *extra)
7498 {
7499 	struct ipw2100_priv *priv = libipw_priv(dev);
7500 	int err = 0;
7501 
7502 	mutex_lock(&priv->action_mutex);
7503 	if (!(priv->status & STATUS_INITIALIZED)) {
7504 		err = -EIO;
7505 		goto done;
7506 	}
7507 
7508 	if (wrqu->power.disabled) {
7509 		priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
7510 		err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM);
7511 		IPW_DEBUG_WX("SET Power Management Mode -> off\n");
7512 		goto done;
7513 	}
7514 
7515 	switch (wrqu->power.flags & IW_POWER_MODE) {
7516 	case IW_POWER_ON:	/* If not specified */
7517 	case IW_POWER_MODE:	/* If set all mask */
7518 	case IW_POWER_ALL_R:	/* If explicitly state all */
7519 		break;
7520 	default:		/* Otherwise we don't support it */
7521 		IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
7522 			     wrqu->power.flags);
7523 		err = -EOPNOTSUPP;
7524 		goto done;
7525 	}
7526 
7527 	/* If the user hasn't specified a power management mode yet, default
7528 	 * to BATTERY */
7529 	priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
7530 	err = ipw2100_set_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
7531 
7532 	IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
7533 
7534       done:
7535 	mutex_unlock(&priv->action_mutex);
7536 	return err;
7537 
7538 }
7539 
7540 static int ipw2100_wx_get_power(struct net_device *dev,
7541 				struct iw_request_info *info,
7542 				union iwreq_data *wrqu, char *extra)
7543 {
7544 	/*
7545 	 * This can be called at any time.  No action lock required
7546 	 */
7547 
7548 	struct ipw2100_priv *priv = libipw_priv(dev);
7549 
7550 	if (!(priv->power_mode & IPW_POWER_ENABLED))
7551 		wrqu->power.disabled = 1;
7552 	else {
7553 		wrqu->power.disabled = 0;
7554 		wrqu->power.flags = 0;
7555 	}
7556 
7557 	IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
7558 
7559 	return 0;
7560 }
7561 
7562 /*
7563  * WE-18 WPA support
7564  */
7565 
7566 /* SIOCSIWGENIE */
7567 static int ipw2100_wx_set_genie(struct net_device *dev,
7568 				struct iw_request_info *info,
7569 				union iwreq_data *wrqu, char *extra)
7570 {
7571 
7572 	struct ipw2100_priv *priv = libipw_priv(dev);
7573 	struct libipw_device *ieee = priv->ieee;
7574 	u8 *buf;
7575 
7576 	if (!ieee->wpa_enabled)
7577 		return -EOPNOTSUPP;
7578 
7579 	if (wrqu->data.length > MAX_WPA_IE_LEN ||
7580 	    (wrqu->data.length && extra == NULL))
7581 		return -EINVAL;
7582 
7583 	if (wrqu->data.length) {
7584 		buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
7585 		if (buf == NULL)
7586 			return -ENOMEM;
7587 
7588 		kfree(ieee->wpa_ie);
7589 		ieee->wpa_ie = buf;
7590 		ieee->wpa_ie_len = wrqu->data.length;
7591 	} else {
7592 		kfree(ieee->wpa_ie);
7593 		ieee->wpa_ie = NULL;
7594 		ieee->wpa_ie_len = 0;
7595 	}
7596 
7597 	ipw2100_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
7598 
7599 	return 0;
7600 }
7601 
7602 /* SIOCGIWGENIE */
7603 static int ipw2100_wx_get_genie(struct net_device *dev,
7604 				struct iw_request_info *info,
7605 				union iwreq_data *wrqu, char *extra)
7606 {
7607 	struct ipw2100_priv *priv = libipw_priv(dev);
7608 	struct libipw_device *ieee = priv->ieee;
7609 
7610 	if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
7611 		wrqu->data.length = 0;
7612 		return 0;
7613 	}
7614 
7615 	if (wrqu->data.length < ieee->wpa_ie_len)
7616 		return -E2BIG;
7617 
7618 	wrqu->data.length = ieee->wpa_ie_len;
7619 	memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
7620 
7621 	return 0;
7622 }
7623 
7624 /* SIOCSIWAUTH */
7625 static int ipw2100_wx_set_auth(struct net_device *dev,
7626 			       struct iw_request_info *info,
7627 			       union iwreq_data *wrqu, char *extra)
7628 {
7629 	struct ipw2100_priv *priv = libipw_priv(dev);
7630 	struct libipw_device *ieee = priv->ieee;
7631 	struct iw_param *param = &wrqu->param;
7632 	struct lib80211_crypt_data *crypt;
7633 	unsigned long flags;
7634 	int ret = 0;
7635 
7636 	switch (param->flags & IW_AUTH_INDEX) {
7637 	case IW_AUTH_WPA_VERSION:
7638 	case IW_AUTH_CIPHER_PAIRWISE:
7639 	case IW_AUTH_CIPHER_GROUP:
7640 	case IW_AUTH_KEY_MGMT:
7641 		/*
7642 		 * ipw2200 does not use these parameters
7643 		 */
7644 		break;
7645 
7646 	case IW_AUTH_TKIP_COUNTERMEASURES:
7647 		crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
7648 		if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
7649 			break;
7650 
7651 		flags = crypt->ops->get_flags(crypt->priv);
7652 
7653 		if (param->value)
7654 			flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
7655 		else
7656 			flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
7657 
7658 		crypt->ops->set_flags(flags, crypt->priv);
7659 
7660 		break;
7661 
7662 	case IW_AUTH_DROP_UNENCRYPTED:{
7663 			/* HACK:
7664 			 *
7665 			 * wpa_supplicant calls set_wpa_enabled when the driver
7666 			 * is loaded and unloaded, regardless of if WPA is being
7667 			 * used.  No other calls are made which can be used to
7668 			 * determine if encryption will be used or not prior to
7669 			 * association being expected.  If encryption is not being
7670 			 * used, drop_unencrypted is set to false, else true -- we
7671 			 * can use this to determine if the CAP_PRIVACY_ON bit should
7672 			 * be set.
7673 			 */
7674 			struct libipw_security sec = {
7675 				.flags = SEC_ENABLED,
7676 				.enabled = param->value,
7677 			};
7678 			priv->ieee->drop_unencrypted = param->value;
7679 			/* We only change SEC_LEVEL for open mode. Others
7680 			 * are set by ipw_wpa_set_encryption.
7681 			 */
7682 			if (!param->value) {
7683 				sec.flags |= SEC_LEVEL;
7684 				sec.level = SEC_LEVEL_0;
7685 			} else {
7686 				sec.flags |= SEC_LEVEL;
7687 				sec.level = SEC_LEVEL_1;
7688 			}
7689 			if (priv->ieee->set_security)
7690 				priv->ieee->set_security(priv->ieee->dev, &sec);
7691 			break;
7692 		}
7693 
7694 	case IW_AUTH_80211_AUTH_ALG:
7695 		ret = ipw2100_wpa_set_auth_algs(priv, param->value);
7696 		break;
7697 
7698 	case IW_AUTH_WPA_ENABLED:
7699 		ret = ipw2100_wpa_enable(priv, param->value);
7700 		break;
7701 
7702 	case IW_AUTH_RX_UNENCRYPTED_EAPOL:
7703 		ieee->ieee802_1x = param->value;
7704 		break;
7705 
7706 		//case IW_AUTH_ROAMING_CONTROL:
7707 	case IW_AUTH_PRIVACY_INVOKED:
7708 		ieee->privacy_invoked = param->value;
7709 		break;
7710 
7711 	default:
7712 		return -EOPNOTSUPP;
7713 	}
7714 	return ret;
7715 }
7716 
7717 /* SIOCGIWAUTH */
7718 static int ipw2100_wx_get_auth(struct net_device *dev,
7719 			       struct iw_request_info *info,
7720 			       union iwreq_data *wrqu, char *extra)
7721 {
7722 	struct ipw2100_priv *priv = libipw_priv(dev);
7723 	struct libipw_device *ieee = priv->ieee;
7724 	struct lib80211_crypt_data *crypt;
7725 	struct iw_param *param = &wrqu->param;
7726 	int ret = 0;
7727 
7728 	switch (param->flags & IW_AUTH_INDEX) {
7729 	case IW_AUTH_WPA_VERSION:
7730 	case IW_AUTH_CIPHER_PAIRWISE:
7731 	case IW_AUTH_CIPHER_GROUP:
7732 	case IW_AUTH_KEY_MGMT:
7733 		/*
7734 		 * wpa_supplicant will control these internally
7735 		 */
7736 		ret = -EOPNOTSUPP;
7737 		break;
7738 
7739 	case IW_AUTH_TKIP_COUNTERMEASURES:
7740 		crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
7741 		if (!crypt || !crypt->ops->get_flags) {
7742 			IPW_DEBUG_WARNING("Can't get TKIP countermeasures: "
7743 					  "crypt not set!\n");
7744 			break;
7745 		}
7746 
7747 		param->value = (crypt->ops->get_flags(crypt->priv) &
7748 				IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
7749 
7750 		break;
7751 
7752 	case IW_AUTH_DROP_UNENCRYPTED:
7753 		param->value = ieee->drop_unencrypted;
7754 		break;
7755 
7756 	case IW_AUTH_80211_AUTH_ALG:
7757 		param->value = priv->ieee->sec.auth_mode;
7758 		break;
7759 
7760 	case IW_AUTH_WPA_ENABLED:
7761 		param->value = ieee->wpa_enabled;
7762 		break;
7763 
7764 	case IW_AUTH_RX_UNENCRYPTED_EAPOL:
7765 		param->value = ieee->ieee802_1x;
7766 		break;
7767 
7768 	case IW_AUTH_ROAMING_CONTROL:
7769 	case IW_AUTH_PRIVACY_INVOKED:
7770 		param->value = ieee->privacy_invoked;
7771 		break;
7772 
7773 	default:
7774 		return -EOPNOTSUPP;
7775 	}
7776 	return 0;
7777 }
7778 
7779 /* SIOCSIWENCODEEXT */
7780 static int ipw2100_wx_set_encodeext(struct net_device *dev,
7781 				    struct iw_request_info *info,
7782 				    union iwreq_data *wrqu, char *extra)
7783 {
7784 	struct ipw2100_priv *priv = libipw_priv(dev);
7785 	return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra);
7786 }
7787 
7788 /* SIOCGIWENCODEEXT */
7789 static int ipw2100_wx_get_encodeext(struct net_device *dev,
7790 				    struct iw_request_info *info,
7791 				    union iwreq_data *wrqu, char *extra)
7792 {
7793 	struct ipw2100_priv *priv = libipw_priv(dev);
7794 	return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra);
7795 }
7796 
7797 /* SIOCSIWMLME */
7798 static int ipw2100_wx_set_mlme(struct net_device *dev,
7799 			       struct iw_request_info *info,
7800 			       union iwreq_data *wrqu, char *extra)
7801 {
7802 	struct ipw2100_priv *priv = libipw_priv(dev);
7803 	struct iw_mlme *mlme = (struct iw_mlme *)extra;
7804 	__le16 reason;
7805 
7806 	reason = cpu_to_le16(mlme->reason_code);
7807 
7808 	switch (mlme->cmd) {
7809 	case IW_MLME_DEAUTH:
7810 		// silently ignore
7811 		break;
7812 
7813 	case IW_MLME_DISASSOC:
7814 		ipw2100_disassociate_bssid(priv);
7815 		break;
7816 
7817 	default:
7818 		return -EOPNOTSUPP;
7819 	}
7820 	return 0;
7821 }
7822 
7823 /*
7824  *
7825  * IWPRIV handlers
7826  *
7827  */
7828 #ifdef CONFIG_IPW2100_MONITOR
7829 static int ipw2100_wx_set_promisc(struct net_device *dev,
7830 				  struct iw_request_info *info,
7831 				  union iwreq_data *wrqu, char *extra)
7832 {
7833 	struct ipw2100_priv *priv = libipw_priv(dev);
7834 	int *parms = (int *)extra;
7835 	int enable = (parms[0] > 0);
7836 	int err = 0;
7837 
7838 	mutex_lock(&priv->action_mutex);
7839 	if (!(priv->status & STATUS_INITIALIZED)) {
7840 		err = -EIO;
7841 		goto done;
7842 	}
7843 
7844 	if (enable) {
7845 		if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7846 			err = ipw2100_set_channel(priv, parms[1], 0);
7847 			goto done;
7848 		}
7849 		priv->channel = parms[1];
7850 		err = ipw2100_switch_mode(priv, IW_MODE_MONITOR);
7851 	} else {
7852 		if (priv->ieee->iw_mode == IW_MODE_MONITOR)
7853 			err = ipw2100_switch_mode(priv, priv->last_mode);
7854 	}
7855       done:
7856 	mutex_unlock(&priv->action_mutex);
7857 	return err;
7858 }
7859 
7860 static int ipw2100_wx_reset(struct net_device *dev,
7861 			    struct iw_request_info *info,
7862 			    union iwreq_data *wrqu, char *extra)
7863 {
7864 	struct ipw2100_priv *priv = libipw_priv(dev);
7865 	if (priv->status & STATUS_INITIALIZED)
7866 		schedule_reset(priv);
7867 	return 0;
7868 }
7869 
7870 #endif
7871 
7872 static int ipw2100_wx_set_powermode(struct net_device *dev,
7873 				    struct iw_request_info *info,
7874 				    union iwreq_data *wrqu, char *extra)
7875 {
7876 	struct ipw2100_priv *priv = libipw_priv(dev);
7877 	int err = 0, mode = *(int *)extra;
7878 
7879 	mutex_lock(&priv->action_mutex);
7880 	if (!(priv->status & STATUS_INITIALIZED)) {
7881 		err = -EIO;
7882 		goto done;
7883 	}
7884 
7885 	if ((mode < 0) || (mode > POWER_MODES))
7886 		mode = IPW_POWER_AUTO;
7887 
7888 	if (IPW_POWER_LEVEL(priv->power_mode) != mode)
7889 		err = ipw2100_set_power_mode(priv, mode);
7890       done:
7891 	mutex_unlock(&priv->action_mutex);
7892 	return err;
7893 }
7894 
7895 #define MAX_POWER_STRING 80
7896 static int ipw2100_wx_get_powermode(struct net_device *dev,
7897 				    struct iw_request_info *info,
7898 				    union iwreq_data *wrqu, char *extra)
7899 {
7900 	/*
7901 	 * This can be called at any time.  No action lock required
7902 	 */
7903 
7904 	struct ipw2100_priv *priv = libipw_priv(dev);
7905 	int level = IPW_POWER_LEVEL(priv->power_mode);
7906 	s32 timeout, period;
7907 
7908 	if (!(priv->power_mode & IPW_POWER_ENABLED)) {
7909 		snprintf(extra, MAX_POWER_STRING,
7910 			 "Power save level: %d (Off)", level);
7911 	} else {
7912 		switch (level) {
7913 		case IPW_POWER_MODE_CAM:
7914 			snprintf(extra, MAX_POWER_STRING,
7915 				 "Power save level: %d (None)", level);
7916 			break;
7917 		case IPW_POWER_AUTO:
7918 			snprintf(extra, MAX_POWER_STRING,
7919 				 "Power save level: %d (Auto)", level);
7920 			break;
7921 		default:
7922 			timeout = timeout_duration[level - 1] / 1000;
7923 			period = period_duration[level - 1] / 1000;
7924 			snprintf(extra, MAX_POWER_STRING,
7925 				 "Power save level: %d "
7926 				 "(Timeout %dms, Period %dms)",
7927 				 level, timeout, period);
7928 		}
7929 	}
7930 
7931 	wrqu->data.length = strlen(extra) + 1;
7932 
7933 	return 0;
7934 }
7935 
7936 static int ipw2100_wx_set_preamble(struct net_device *dev,
7937 				   struct iw_request_info *info,
7938 				   union iwreq_data *wrqu, char *extra)
7939 {
7940 	struct ipw2100_priv *priv = libipw_priv(dev);
7941 	int err, mode = *(int *)extra;
7942 
7943 	mutex_lock(&priv->action_mutex);
7944 	if (!(priv->status & STATUS_INITIALIZED)) {
7945 		err = -EIO;
7946 		goto done;
7947 	}
7948 
7949 	if (mode == 1)
7950 		priv->config |= CFG_LONG_PREAMBLE;
7951 	else if (mode == 0)
7952 		priv->config &= ~CFG_LONG_PREAMBLE;
7953 	else {
7954 		err = -EINVAL;
7955 		goto done;
7956 	}
7957 
7958 	err = ipw2100_system_config(priv, 0);
7959 
7960       done:
7961 	mutex_unlock(&priv->action_mutex);
7962 	return err;
7963 }
7964 
7965 static int ipw2100_wx_get_preamble(struct net_device *dev,
7966 				   struct iw_request_info *info,
7967 				   union iwreq_data *wrqu, char *extra)
7968 {
7969 	/*
7970 	 * This can be called at any time.  No action lock required
7971 	 */
7972 
7973 	struct ipw2100_priv *priv = libipw_priv(dev);
7974 
7975 	if (priv->config & CFG_LONG_PREAMBLE)
7976 		snprintf(wrqu->name, IFNAMSIZ, "long (1)");
7977 	else
7978 		snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
7979 
7980 	return 0;
7981 }
7982 
7983 #ifdef CONFIG_IPW2100_MONITOR
7984 static int ipw2100_wx_set_crc_check(struct net_device *dev,
7985 				    struct iw_request_info *info,
7986 				    union iwreq_data *wrqu, char *extra)
7987 {
7988 	struct ipw2100_priv *priv = libipw_priv(dev);
7989 	int err, mode = *(int *)extra;
7990 
7991 	mutex_lock(&priv->action_mutex);
7992 	if (!(priv->status & STATUS_INITIALIZED)) {
7993 		err = -EIO;
7994 		goto done;
7995 	}
7996 
7997 	if (mode == 1)
7998 		priv->config |= CFG_CRC_CHECK;
7999 	else if (mode == 0)
8000 		priv->config &= ~CFG_CRC_CHECK;
8001 	else {
8002 		err = -EINVAL;
8003 		goto done;
8004 	}
8005 	err = 0;
8006 
8007       done:
8008 	mutex_unlock(&priv->action_mutex);
8009 	return err;
8010 }
8011 
8012 static int ipw2100_wx_get_crc_check(struct net_device *dev,
8013 				    struct iw_request_info *info,
8014 				    union iwreq_data *wrqu, char *extra)
8015 {
8016 	/*
8017 	 * This can be called at any time.  No action lock required
8018 	 */
8019 
8020 	struct ipw2100_priv *priv = libipw_priv(dev);
8021 
8022 	if (priv->config & CFG_CRC_CHECK)
8023 		snprintf(wrqu->name, IFNAMSIZ, "CRC checked (1)");
8024 	else
8025 		snprintf(wrqu->name, IFNAMSIZ, "CRC ignored (0)");
8026 
8027 	return 0;
8028 }
8029 #endif				/* CONFIG_IPW2100_MONITOR */
8030 
8031 static iw_handler ipw2100_wx_handlers[] = {
8032 	IW_HANDLER(SIOCGIWNAME, ipw2100_wx_get_name),
8033 	IW_HANDLER(SIOCSIWFREQ, ipw2100_wx_set_freq),
8034 	IW_HANDLER(SIOCGIWFREQ, ipw2100_wx_get_freq),
8035 	IW_HANDLER(SIOCSIWMODE, ipw2100_wx_set_mode),
8036 	IW_HANDLER(SIOCGIWMODE, ipw2100_wx_get_mode),
8037 	IW_HANDLER(SIOCGIWRANGE, ipw2100_wx_get_range),
8038 	IW_HANDLER(SIOCSIWAP, ipw2100_wx_set_wap),
8039 	IW_HANDLER(SIOCGIWAP, ipw2100_wx_get_wap),
8040 	IW_HANDLER(SIOCSIWMLME, ipw2100_wx_set_mlme),
8041 	IW_HANDLER(SIOCSIWSCAN, ipw2100_wx_set_scan),
8042 	IW_HANDLER(SIOCGIWSCAN, ipw2100_wx_get_scan),
8043 	IW_HANDLER(SIOCSIWESSID, ipw2100_wx_set_essid),
8044 	IW_HANDLER(SIOCGIWESSID, ipw2100_wx_get_essid),
8045 	IW_HANDLER(SIOCSIWNICKN, ipw2100_wx_set_nick),
8046 	IW_HANDLER(SIOCGIWNICKN, ipw2100_wx_get_nick),
8047 	IW_HANDLER(SIOCSIWRATE, ipw2100_wx_set_rate),
8048 	IW_HANDLER(SIOCGIWRATE, ipw2100_wx_get_rate),
8049 	IW_HANDLER(SIOCSIWRTS, ipw2100_wx_set_rts),
8050 	IW_HANDLER(SIOCGIWRTS, ipw2100_wx_get_rts),
8051 	IW_HANDLER(SIOCSIWFRAG, ipw2100_wx_set_frag),
8052 	IW_HANDLER(SIOCGIWFRAG, ipw2100_wx_get_frag),
8053 	IW_HANDLER(SIOCSIWTXPOW, ipw2100_wx_set_txpow),
8054 	IW_HANDLER(SIOCGIWTXPOW, ipw2100_wx_get_txpow),
8055 	IW_HANDLER(SIOCSIWRETRY, ipw2100_wx_set_retry),
8056 	IW_HANDLER(SIOCGIWRETRY, ipw2100_wx_get_retry),
8057 	IW_HANDLER(SIOCSIWENCODE, ipw2100_wx_set_encode),
8058 	IW_HANDLER(SIOCGIWENCODE, ipw2100_wx_get_encode),
8059 	IW_HANDLER(SIOCSIWPOWER, ipw2100_wx_set_power),
8060 	IW_HANDLER(SIOCGIWPOWER, ipw2100_wx_get_power),
8061 	IW_HANDLER(SIOCSIWGENIE, ipw2100_wx_set_genie),
8062 	IW_HANDLER(SIOCGIWGENIE, ipw2100_wx_get_genie),
8063 	IW_HANDLER(SIOCSIWAUTH, ipw2100_wx_set_auth),
8064 	IW_HANDLER(SIOCGIWAUTH, ipw2100_wx_get_auth),
8065 	IW_HANDLER(SIOCSIWENCODEEXT, ipw2100_wx_set_encodeext),
8066 	IW_HANDLER(SIOCGIWENCODEEXT, ipw2100_wx_get_encodeext),
8067 };
8068 
8069 #define IPW2100_PRIV_SET_MONITOR	SIOCIWFIRSTPRIV
8070 #define IPW2100_PRIV_RESET		SIOCIWFIRSTPRIV+1
8071 #define IPW2100_PRIV_SET_POWER		SIOCIWFIRSTPRIV+2
8072 #define IPW2100_PRIV_GET_POWER		SIOCIWFIRSTPRIV+3
8073 #define IPW2100_PRIV_SET_LONGPREAMBLE	SIOCIWFIRSTPRIV+4
8074 #define IPW2100_PRIV_GET_LONGPREAMBLE	SIOCIWFIRSTPRIV+5
8075 #define IPW2100_PRIV_SET_CRC_CHECK	SIOCIWFIRSTPRIV+6
8076 #define IPW2100_PRIV_GET_CRC_CHECK	SIOCIWFIRSTPRIV+7
8077 
8078 static const struct iw_priv_args ipw2100_private_args[] = {
8079 
8080 #ifdef CONFIG_IPW2100_MONITOR
8081 	{
8082 	 IPW2100_PRIV_SET_MONITOR,
8083 	 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
8084 	{
8085 	 IPW2100_PRIV_RESET,
8086 	 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
8087 #endif				/* CONFIG_IPW2100_MONITOR */
8088 
8089 	{
8090 	 IPW2100_PRIV_SET_POWER,
8091 	 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_power"},
8092 	{
8093 	 IPW2100_PRIV_GET_POWER,
8094 	 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_POWER_STRING,
8095 	 "get_power"},
8096 	{
8097 	 IPW2100_PRIV_SET_LONGPREAMBLE,
8098 	 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_preamble"},
8099 	{
8100 	 IPW2100_PRIV_GET_LONGPREAMBLE,
8101 	 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_preamble"},
8102 #ifdef CONFIG_IPW2100_MONITOR
8103 	{
8104 	 IPW2100_PRIV_SET_CRC_CHECK,
8105 	 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_crc_check"},
8106 	{
8107 	 IPW2100_PRIV_GET_CRC_CHECK,
8108 	 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_crc_check"},
8109 #endif				/* CONFIG_IPW2100_MONITOR */
8110 };
8111 
8112 static iw_handler ipw2100_private_handler[] = {
8113 #ifdef CONFIG_IPW2100_MONITOR
8114 	ipw2100_wx_set_promisc,
8115 	ipw2100_wx_reset,
8116 #else				/* CONFIG_IPW2100_MONITOR */
8117 	NULL,
8118 	NULL,
8119 #endif				/* CONFIG_IPW2100_MONITOR */
8120 	ipw2100_wx_set_powermode,
8121 	ipw2100_wx_get_powermode,
8122 	ipw2100_wx_set_preamble,
8123 	ipw2100_wx_get_preamble,
8124 #ifdef CONFIG_IPW2100_MONITOR
8125 	ipw2100_wx_set_crc_check,
8126 	ipw2100_wx_get_crc_check,
8127 #else				/* CONFIG_IPW2100_MONITOR */
8128 	NULL,
8129 	NULL,
8130 #endif				/* CONFIG_IPW2100_MONITOR */
8131 };
8132 
8133 /*
8134  * Get wireless statistics.
8135  * Called by /proc/net/wireless
8136  * Also called by SIOCGIWSTATS
8137  */
8138 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev)
8139 {
8140 	enum {
8141 		POOR = 30,
8142 		FAIR = 60,
8143 		GOOD = 80,
8144 		VERY_GOOD = 90,
8145 		EXCELLENT = 95,
8146 		PERFECT = 100
8147 	};
8148 	int rssi_qual;
8149 	int tx_qual;
8150 	int beacon_qual;
8151 	int quality;
8152 
8153 	struct ipw2100_priv *priv = libipw_priv(dev);
8154 	struct iw_statistics *wstats;
8155 	u32 rssi, tx_retries, missed_beacons, tx_failures;
8156 	u32 ord_len = sizeof(u32);
8157 
8158 	if (!priv)
8159 		return (struct iw_statistics *)NULL;
8160 
8161 	wstats = &priv->wstats;
8162 
8163 	/* if hw is disabled, then ipw2100_get_ordinal() can't be called.
8164 	 * ipw2100_wx_wireless_stats seems to be called before fw is
8165 	 * initialized.  STATUS_ASSOCIATED will only be set if the hw is up
8166 	 * and associated; if not associcated, the values are all meaningless
8167 	 * anyway, so set them all to NULL and INVALID */
8168 	if (!(priv->status & STATUS_ASSOCIATED)) {
8169 		wstats->miss.beacon = 0;
8170 		wstats->discard.retries = 0;
8171 		wstats->qual.qual = 0;
8172 		wstats->qual.level = 0;
8173 		wstats->qual.noise = 0;
8174 		wstats->qual.updated = 7;
8175 		wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
8176 		    IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
8177 		return wstats;
8178 	}
8179 
8180 	if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_MISSED_BCNS,
8181 				&missed_beacons, &ord_len))
8182 		goto fail_get_ordinal;
8183 
8184 	/* If we don't have a connection the quality and level is 0 */
8185 	if (!(priv->status & STATUS_ASSOCIATED)) {
8186 		wstats->qual.qual = 0;
8187 		wstats->qual.level = 0;
8188 	} else {
8189 		if (ipw2100_get_ordinal(priv, IPW_ORD_RSSI_AVG_CURR,
8190 					&rssi, &ord_len))
8191 			goto fail_get_ordinal;
8192 		wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM;
8193 		if (rssi < 10)
8194 			rssi_qual = rssi * POOR / 10;
8195 		else if (rssi < 15)
8196 			rssi_qual = (rssi - 10) * (FAIR - POOR) / 5 + POOR;
8197 		else if (rssi < 20)
8198 			rssi_qual = (rssi - 15) * (GOOD - FAIR) / 5 + FAIR;
8199 		else if (rssi < 30)
8200 			rssi_qual = (rssi - 20) * (VERY_GOOD - GOOD) /
8201 			    10 + GOOD;
8202 		else
8203 			rssi_qual = (rssi - 30) * (PERFECT - VERY_GOOD) /
8204 			    10 + VERY_GOOD;
8205 
8206 		if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_RETRIES,
8207 					&tx_retries, &ord_len))
8208 			goto fail_get_ordinal;
8209 
8210 		if (tx_retries > 75)
8211 			tx_qual = (90 - tx_retries) * POOR / 15;
8212 		else if (tx_retries > 70)
8213 			tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR;
8214 		else if (tx_retries > 65)
8215 			tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR;
8216 		else if (tx_retries > 50)
8217 			tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) /
8218 			    15 + GOOD;
8219 		else
8220 			tx_qual = (50 - tx_retries) *
8221 			    (PERFECT - VERY_GOOD) / 50 + VERY_GOOD;
8222 
8223 		if (missed_beacons > 50)
8224 			beacon_qual = (60 - missed_beacons) * POOR / 10;
8225 		else if (missed_beacons > 40)
8226 			beacon_qual = (50 - missed_beacons) * (FAIR - POOR) /
8227 			    10 + POOR;
8228 		else if (missed_beacons > 32)
8229 			beacon_qual = (40 - missed_beacons) * (GOOD - FAIR) /
8230 			    18 + FAIR;
8231 		else if (missed_beacons > 20)
8232 			beacon_qual = (32 - missed_beacons) *
8233 			    (VERY_GOOD - GOOD) / 20 + GOOD;
8234 		else
8235 			beacon_qual = (20 - missed_beacons) *
8236 			    (PERFECT - VERY_GOOD) / 20 + VERY_GOOD;
8237 
8238 		quality = min(tx_qual, rssi_qual);
8239 		quality = min(beacon_qual, quality);
8240 
8241 #ifdef CONFIG_IPW2100_DEBUG
8242 		if (beacon_qual == quality)
8243 			IPW_DEBUG_WX("Quality clamped by Missed Beacons\n");
8244 		else if (tx_qual == quality)
8245 			IPW_DEBUG_WX("Quality clamped by Tx Retries\n");
8246 		else if (quality != 100)
8247 			IPW_DEBUG_WX("Quality clamped by Signal Strength\n");
8248 		else
8249 			IPW_DEBUG_WX("Quality not clamped.\n");
8250 #endif
8251 
8252 		wstats->qual.qual = quality;
8253 		wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM;
8254 	}
8255 
8256 	wstats->qual.noise = 0;
8257 	wstats->qual.updated = 7;
8258 	wstats->qual.updated |= IW_QUAL_NOISE_INVALID;
8259 
8260 	/* FIXME: this is percent and not a # */
8261 	wstats->miss.beacon = missed_beacons;
8262 
8263 	if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURES,
8264 				&tx_failures, &ord_len))
8265 		goto fail_get_ordinal;
8266 	wstats->discard.retries = tx_failures;
8267 
8268 	return wstats;
8269 
8270       fail_get_ordinal:
8271 	IPW_DEBUG_WX("failed querying ordinals.\n");
8272 
8273 	return (struct iw_statistics *)NULL;
8274 }
8275 
8276 static struct iw_handler_def ipw2100_wx_handler_def = {
8277 	.standard = ipw2100_wx_handlers,
8278 	.num_standard = ARRAY_SIZE(ipw2100_wx_handlers),
8279 	.num_private = ARRAY_SIZE(ipw2100_private_handler),
8280 	.num_private_args = ARRAY_SIZE(ipw2100_private_args),
8281 	.private = (iw_handler *) ipw2100_private_handler,
8282 	.private_args = (struct iw_priv_args *)ipw2100_private_args,
8283 	.get_wireless_stats = ipw2100_wx_wireless_stats,
8284 };
8285 
8286 static void ipw2100_wx_event_work(struct work_struct *work)
8287 {
8288 	struct ipw2100_priv *priv =
8289 		container_of(work, struct ipw2100_priv, wx_event_work.work);
8290 	union iwreq_data wrqu;
8291 	unsigned int len = ETH_ALEN;
8292 
8293 	if (priv->status & STATUS_STOPPING)
8294 		return;
8295 
8296 	mutex_lock(&priv->action_mutex);
8297 
8298 	IPW_DEBUG_WX("enter\n");
8299 
8300 	mutex_unlock(&priv->action_mutex);
8301 
8302 	wrqu.ap_addr.sa_family = ARPHRD_ETHER;
8303 
8304 	/* Fetch BSSID from the hardware */
8305 	if (!(priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) ||
8306 	    priv->status & STATUS_RF_KILL_MASK ||
8307 	    ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID,
8308 				&priv->bssid, &len)) {
8309 		eth_zero_addr(wrqu.ap_addr.sa_data);
8310 	} else {
8311 		/* We now have the BSSID, so can finish setting to the full
8312 		 * associated state */
8313 		memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
8314 		memcpy(priv->ieee->bssid, priv->bssid, ETH_ALEN);
8315 		priv->status &= ~STATUS_ASSOCIATING;
8316 		priv->status |= STATUS_ASSOCIATED;
8317 		netif_carrier_on(priv->net_dev);
8318 		netif_wake_queue(priv->net_dev);
8319 	}
8320 
8321 	if (!(priv->status & STATUS_ASSOCIATED)) {
8322 		IPW_DEBUG_WX("Configuring ESSID\n");
8323 		mutex_lock(&priv->action_mutex);
8324 		/* This is a disassociation event, so kick the firmware to
8325 		 * look for another AP */
8326 		if (priv->config & CFG_STATIC_ESSID)
8327 			ipw2100_set_essid(priv, priv->essid, priv->essid_len,
8328 					  0);
8329 		else
8330 			ipw2100_set_essid(priv, NULL, 0, 0);
8331 		mutex_unlock(&priv->action_mutex);
8332 	}
8333 
8334 	wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
8335 }
8336 
8337 #define IPW2100_FW_MAJOR_VERSION 1
8338 #define IPW2100_FW_MINOR_VERSION 3
8339 
8340 #define IPW2100_FW_MINOR(x) ((x & 0xff) >> 8)
8341 #define IPW2100_FW_MAJOR(x) (x & 0xff)
8342 
8343 #define IPW2100_FW_VERSION ((IPW2100_FW_MINOR_VERSION << 8) | \
8344                              IPW2100_FW_MAJOR_VERSION)
8345 
8346 #define IPW2100_FW_PREFIX "ipw2100-" __stringify(IPW2100_FW_MAJOR_VERSION) \
8347 "." __stringify(IPW2100_FW_MINOR_VERSION)
8348 
8349 #define IPW2100_FW_NAME(x) IPW2100_FW_PREFIX "" x ".fw"
8350 
8351 /*
8352 
8353 BINARY FIRMWARE HEADER FORMAT
8354 
8355 offset      length   desc
8356 0           2        version
8357 2           2        mode == 0:BSS,1:IBSS,2:MONITOR
8358 4           4        fw_len
8359 8           4        uc_len
8360 C           fw_len   firmware data
8361 12 + fw_len uc_len   microcode data
8362 
8363 */
8364 
8365 struct ipw2100_fw_header {
8366 	short version;
8367 	short mode;
8368 	unsigned int fw_size;
8369 	unsigned int uc_size;
8370 } __packed;
8371 
8372 static int ipw2100_mod_firmware_load(struct ipw2100_fw *fw)
8373 {
8374 	struct ipw2100_fw_header *h =
8375 	    (struct ipw2100_fw_header *)fw->fw_entry->data;
8376 
8377 	if (IPW2100_FW_MAJOR(h->version) != IPW2100_FW_MAJOR_VERSION) {
8378 		printk(KERN_WARNING DRV_NAME ": Firmware image not compatible "
8379 		       "(detected version id of %u). "
8380 		       "See Documentation/networking/README.ipw2100\n",
8381 		       h->version);
8382 		return 1;
8383 	}
8384 
8385 	fw->version = h->version;
8386 	fw->fw.data = fw->fw_entry->data + sizeof(struct ipw2100_fw_header);
8387 	fw->fw.size = h->fw_size;
8388 	fw->uc.data = fw->fw.data + h->fw_size;
8389 	fw->uc.size = h->uc_size;
8390 
8391 	return 0;
8392 }
8393 
8394 static int ipw2100_get_firmware(struct ipw2100_priv *priv,
8395 				struct ipw2100_fw *fw)
8396 {
8397 	char *fw_name;
8398 	int rc;
8399 
8400 	IPW_DEBUG_INFO("%s: Using hotplug firmware load.\n",
8401 		       priv->net_dev->name);
8402 
8403 	switch (priv->ieee->iw_mode) {
8404 	case IW_MODE_ADHOC:
8405 		fw_name = IPW2100_FW_NAME("-i");
8406 		break;
8407 #ifdef CONFIG_IPW2100_MONITOR
8408 	case IW_MODE_MONITOR:
8409 		fw_name = IPW2100_FW_NAME("-p");
8410 		break;
8411 #endif
8412 	case IW_MODE_INFRA:
8413 	default:
8414 		fw_name = IPW2100_FW_NAME("");
8415 		break;
8416 	}
8417 
8418 	rc = request_firmware(&fw->fw_entry, fw_name, &priv->pci_dev->dev);
8419 
8420 	if (rc < 0) {
8421 		printk(KERN_ERR DRV_NAME ": "
8422 		       "%s: Firmware '%s' not available or load failed.\n",
8423 		       priv->net_dev->name, fw_name);
8424 		return rc;
8425 	}
8426 	IPW_DEBUG_INFO("firmware data %p size %zd\n", fw->fw_entry->data,
8427 		       fw->fw_entry->size);
8428 
8429 	ipw2100_mod_firmware_load(fw);
8430 
8431 	return 0;
8432 }
8433 
8434 MODULE_FIRMWARE(IPW2100_FW_NAME("-i"));
8435 #ifdef CONFIG_IPW2100_MONITOR
8436 MODULE_FIRMWARE(IPW2100_FW_NAME("-p"));
8437 #endif
8438 MODULE_FIRMWARE(IPW2100_FW_NAME(""));
8439 
8440 static void ipw2100_release_firmware(struct ipw2100_priv *priv,
8441 				     struct ipw2100_fw *fw)
8442 {
8443 	fw->version = 0;
8444 	release_firmware(fw->fw_entry);
8445 	fw->fw_entry = NULL;
8446 }
8447 
8448 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf,
8449 				 size_t max)
8450 {
8451 	char ver[MAX_FW_VERSION_LEN];
8452 	u32 len = MAX_FW_VERSION_LEN;
8453 	u32 tmp;
8454 	int i;
8455 	/* firmware version is an ascii string (max len of 14) */
8456 	if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_FW_VER_NUM, ver, &len))
8457 		return -EIO;
8458 	tmp = max;
8459 	if (len >= max)
8460 		len = max - 1;
8461 	for (i = 0; i < len; i++)
8462 		buf[i] = ver[i];
8463 	buf[i] = '\0';
8464 	return tmp;
8465 }
8466 
8467 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf,
8468 				    size_t max)
8469 {
8470 	u32 ver;
8471 	u32 len = sizeof(ver);
8472 	/* microcode version is a 32 bit integer */
8473 	if (ipw2100_get_ordinal(priv, IPW_ORD_UCODE_VERSION, &ver, &len))
8474 		return -EIO;
8475 	return snprintf(buf, max, "%08X", ver);
8476 }
8477 
8478 /*
8479  * On exit, the firmware will have been freed from the fw list
8480  */
8481 static int ipw2100_fw_download(struct ipw2100_priv *priv, struct ipw2100_fw *fw)
8482 {
8483 	/* firmware is constructed of N contiguous entries, each entry is
8484 	 * structured as:
8485 	 *
8486 	 * offset    sie         desc
8487 	 * 0         4           address to write to
8488 	 * 4         2           length of data run
8489 	 * 6         length      data
8490 	 */
8491 	unsigned int addr;
8492 	unsigned short len;
8493 
8494 	const unsigned char *firmware_data = fw->fw.data;
8495 	unsigned int firmware_data_left = fw->fw.size;
8496 
8497 	while (firmware_data_left > 0) {
8498 		addr = *(u32 *) (firmware_data);
8499 		firmware_data += 4;
8500 		firmware_data_left -= 4;
8501 
8502 		len = *(u16 *) (firmware_data);
8503 		firmware_data += 2;
8504 		firmware_data_left -= 2;
8505 
8506 		if (len > 32) {
8507 			printk(KERN_ERR DRV_NAME ": "
8508 			       "Invalid firmware run-length of %d bytes\n",
8509 			       len);
8510 			return -EINVAL;
8511 		}
8512 
8513 		write_nic_memory(priv->net_dev, addr, len, firmware_data);
8514 		firmware_data += len;
8515 		firmware_data_left -= len;
8516 	}
8517 
8518 	return 0;
8519 }
8520 
8521 struct symbol_alive_response {
8522 	u8 cmd_id;
8523 	u8 seq_num;
8524 	u8 ucode_rev;
8525 	u8 eeprom_valid;
8526 	u16 valid_flags;
8527 	u8 IEEE_addr[6];
8528 	u16 flags;
8529 	u16 pcb_rev;
8530 	u16 clock_settle_time;	// 1us LSB
8531 	u16 powerup_settle_time;	// 1us LSB
8532 	u16 hop_settle_time;	// 1us LSB
8533 	u8 date[3];		// month, day, year
8534 	u8 time[2];		// hours, minutes
8535 	u8 ucode_valid;
8536 };
8537 
8538 static int ipw2100_ucode_download(struct ipw2100_priv *priv,
8539 				  struct ipw2100_fw *fw)
8540 {
8541 	struct net_device *dev = priv->net_dev;
8542 	const unsigned char *microcode_data = fw->uc.data;
8543 	unsigned int microcode_data_left = fw->uc.size;
8544 	void __iomem *reg = priv->ioaddr;
8545 
8546 	struct symbol_alive_response response;
8547 	int i, j;
8548 	u8 data;
8549 
8550 	/* Symbol control */
8551 	write_nic_word(dev, IPW2100_CONTROL_REG, 0x703);
8552 	readl(reg);
8553 	write_nic_word(dev, IPW2100_CONTROL_REG, 0x707);
8554 	readl(reg);
8555 
8556 	/* HW config */
8557 	write_nic_byte(dev, 0x210014, 0x72);	/* fifo width =16 */
8558 	readl(reg);
8559 	write_nic_byte(dev, 0x210014, 0x72);	/* fifo width =16 */
8560 	readl(reg);
8561 
8562 	/* EN_CS_ACCESS bit to reset control store pointer */
8563 	write_nic_byte(dev, 0x210000, 0x40);
8564 	readl(reg);
8565 	write_nic_byte(dev, 0x210000, 0x0);
8566 	readl(reg);
8567 	write_nic_byte(dev, 0x210000, 0x40);
8568 	readl(reg);
8569 
8570 	/* copy microcode from buffer into Symbol */
8571 
8572 	while (microcode_data_left > 0) {
8573 		write_nic_byte(dev, 0x210010, *microcode_data++);
8574 		write_nic_byte(dev, 0x210010, *microcode_data++);
8575 		microcode_data_left -= 2;
8576 	}
8577 
8578 	/* EN_CS_ACCESS bit to reset the control store pointer */
8579 	write_nic_byte(dev, 0x210000, 0x0);
8580 	readl(reg);
8581 
8582 	/* Enable System (Reg 0)
8583 	 * first enable causes garbage in RX FIFO */
8584 	write_nic_byte(dev, 0x210000, 0x0);
8585 	readl(reg);
8586 	write_nic_byte(dev, 0x210000, 0x80);
8587 	readl(reg);
8588 
8589 	/* Reset External Baseband Reg */
8590 	write_nic_word(dev, IPW2100_CONTROL_REG, 0x703);
8591 	readl(reg);
8592 	write_nic_word(dev, IPW2100_CONTROL_REG, 0x707);
8593 	readl(reg);
8594 
8595 	/* HW Config (Reg 5) */
8596 	write_nic_byte(dev, 0x210014, 0x72);	// fifo width =16
8597 	readl(reg);
8598 	write_nic_byte(dev, 0x210014, 0x72);	// fifo width =16
8599 	readl(reg);
8600 
8601 	/* Enable System (Reg 0)
8602 	 * second enable should be OK */
8603 	write_nic_byte(dev, 0x210000, 0x00);	// clear enable system
8604 	readl(reg);
8605 	write_nic_byte(dev, 0x210000, 0x80);	// set enable system
8606 
8607 	/* check Symbol is enabled - upped this from 5 as it wasn't always
8608 	 * catching the update */
8609 	for (i = 0; i < 10; i++) {
8610 		udelay(10);
8611 
8612 		/* check Dino is enabled bit */
8613 		read_nic_byte(dev, 0x210000, &data);
8614 		if (data & 0x1)
8615 			break;
8616 	}
8617 
8618 	if (i == 10) {
8619 		printk(KERN_ERR DRV_NAME ": %s: Error initializing Symbol\n",
8620 		       dev->name);
8621 		return -EIO;
8622 	}
8623 
8624 	/* Get Symbol alive response */
8625 	for (i = 0; i < 30; i++) {
8626 		/* Read alive response structure */
8627 		for (j = 0;
8628 		     j < (sizeof(struct symbol_alive_response) >> 1); j++)
8629 			read_nic_word(dev, 0x210004, ((u16 *) & response) + j);
8630 
8631 		if ((response.cmd_id == 1) && (response.ucode_valid == 0x1))
8632 			break;
8633 		udelay(10);
8634 	}
8635 
8636 	if (i == 30) {
8637 		printk(KERN_ERR DRV_NAME
8638 		       ": %s: No response from Symbol - hw not alive\n",
8639 		       dev->name);
8640 		printk_buf(IPW_DL_ERROR, (u8 *) & response, sizeof(response));
8641 		return -EIO;
8642 	}
8643 
8644 	return 0;
8645 }
8646