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