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