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