drivers/net: Remove unnecessary returns from void function()s
[linux-3.10.git] / drivers / net / wireless / ipw2x00 / ipw2100.c
1 /******************************************************************************
2
3   Copyright(c) 2003 - 2006 Intel Corporation. All rights reserved.
4
5   This program is free software; you can redistribute it and/or modify it
6   under the terms of version 2 of the GNU General Public License as
7   published by the Free Software Foundation.
8
9   This program is distributed in the hope that it will be useful, but WITHOUT
10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12   more details.
13
14   You should have received a copy of the GNU General Public License along with
15   this program; if not, write to the Free Software Foundation, Inc., 59
16   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17
18   The full GNU General Public License is included in this distribution in the
19   file called LICENSE.
20
21   Contact Information:
22   Intel Linux Wireless <ilw@linux.intel.com>
23   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
24
25   Portions of this file are based on the sample_* files provided by Wireless
26   Extensions 0.26 package and copyright (c) 1997-2003 Jean Tourrilhes
27   <jt@hpl.hp.com>
28
29   Portions of this file are based on the Host AP project,
30   Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
31     <j@w1.fi>
32   Copyright (c) 2002-2003, Jouni Malinen <j@w1.fi>
33
34   Portions of ipw2100_mod_firmware_load, ipw2100_do_mod_firmware_load, and
35   ipw2100_fw_load are loosely based on drivers/sound/sound_firmware.c
36   available in the 2.4.25 kernel sources, and are copyright (c) Alan Cox
37
38 ******************************************************************************/
39 /*
40
41  Initial driver on which this is based was developed by Janusz Gorycki,
42  Maciej Urbaniak, and Maciej Sosnowski.
43
44  Promiscuous mode support added by Jacek Wysoczynski and Maciej Urbaniak.
45
46 Theory of Operation
47
48 Tx - Commands and Data
49
50 Firmware and host share a circular queue of Transmit Buffer Descriptors (TBDs)
51 Each TBD contains a pointer to the physical (dma_addr_t) address of data being
52 sent to the firmware as well as the length of the data.
53
54 The host writes to the TBD queue at the WRITE index.  The WRITE index points
55 to the _next_ packet to be written and is advanced when after the TBD has been
56 filled.
57
58 The firmware pulls from the TBD queue at the READ index.  The READ index points
59 to the currently being read entry, and is advanced once the firmware is
60 done with a packet.
61
62 When data is sent to the firmware, the first TBD is used to indicate to the
63 firmware if a Command or Data is being sent.  If it is Command, all of the
64 command information is contained within the physical address referred to by the
65 TBD.  If it is Data, the first TBD indicates the type of data packet, number
66 of fragments, etc.  The next TBD then referrs to the actual packet location.
67
68 The Tx flow cycle is as follows:
69
70 1) ipw2100_tx() is called by kernel with SKB to transmit
71 2) Packet is move from the tx_free_list and appended to the transmit pending
72    list (tx_pend_list)
73 3) work is scheduled to move pending packets into the shared circular queue.
74 4) when placing packet in the circular queue, the incoming SKB is DMA mapped
75    to a physical address.  That address is entered into a TBD.  Two TBDs are
76    filled out.  The first indicating a data packet, the second referring to the
77    actual payload data.
78 5) the packet is removed from tx_pend_list and placed on the end of the
79    firmware pending list (fw_pend_list)
80 6) firmware is notified that the WRITE index has
81 7) Once the firmware has processed the TBD, INTA is triggered.
82 8) For each Tx interrupt received from the firmware, the READ index is checked
83    to see which TBDs are done being processed.
84 9) For each TBD that has been processed, the ISR pulls the oldest packet
85    from the fw_pend_list.
86 10)The packet structure contained in the fw_pend_list is then used
87    to unmap the DMA address and to free the SKB originally passed to the driver
88    from the kernel.
89 11)The packet structure is placed onto the tx_free_list
90
91 The above steps are the same for commands, only the msg_free_list/msg_pend_list
92 are used instead of tx_free_list/tx_pend_list
93
94 ...
95
96 Critical Sections / Locking :
97
98 There are two locks utilized.  The first is the low level lock (priv->low_lock)
99 that protects the following:
100
101 - Access to the Tx/Rx queue lists via priv->low_lock. The lists are as follows:
102
103   tx_free_list : Holds pre-allocated Tx buffers.
104     TAIL modified in __ipw2100_tx_process()
105     HEAD modified in ipw2100_tx()
106
107   tx_pend_list : Holds used Tx buffers waiting to go into the TBD ring
108     TAIL modified ipw2100_tx()
109     HEAD modified by ipw2100_tx_send_data()
110
111   msg_free_list : Holds pre-allocated Msg (Command) buffers
112     TAIL modified in __ipw2100_tx_process()
113     HEAD modified in ipw2100_hw_send_command()
114
115   msg_pend_list : Holds used Msg buffers waiting to go into the TBD ring
116     TAIL modified in ipw2100_hw_send_command()
117     HEAD modified in ipw2100_tx_send_commands()
118
119   The flow of data on the TX side is as follows:
120
121   MSG_FREE_LIST + COMMAND => MSG_PEND_LIST => TBD => MSG_FREE_LIST
122   TX_FREE_LIST + DATA => TX_PEND_LIST => TBD => TX_FREE_LIST
123
124   The methods that work on the TBD ring are protected via priv->low_lock.
125
126 - The internal data state of the device itself
127 - Access to the firmware read/write indexes for the BD queues
128   and associated logic
129
130 All external entry functions are locked with the priv->action_lock to ensure
131 that only one external action is invoked at a time.
132
133
134 */
135
136 #include <linux/compiler.h>
137 #include <linux/errno.h>
138 #include <linux/if_arp.h>
139 #include <linux/in6.h>
140 #include <linux/in.h>
141 #include <linux/ip.h>
142 #include <linux/kernel.h>
143 #include <linux/kmod.h>
144 #include <linux/module.h>
145 #include <linux/netdevice.h>
146 #include <linux/ethtool.h>
147 #include <linux/pci.h>
148 #include <linux/dma-mapping.h>
149 #include <linux/proc_fs.h>
150 #include <linux/skbuff.h>
151 #include <asm/uaccess.h>
152 #include <asm/io.h>
153 #include <linux/fs.h>
154 #include <linux/mm.h>
155 #include <linux/slab.h>
156 #include <linux/unistd.h>
157 #include <linux/stringify.h>
158 #include <linux/tcp.h>
159 #include <linux/types.h>
160 #include <linux/time.h>
161 #include <linux/firmware.h>
162 #include <linux/acpi.h>
163 #include <linux/ctype.h>
164 #include <linux/pm_qos_params.h>
165
166 #include <net/lib80211.h>
167
168 #include "ipw2100.h"
169
170 #define IPW2100_VERSION "git-1.2.2"
171
172 #define DRV_NAME        "ipw2100"
173 #define DRV_VERSION     IPW2100_VERSION
174 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2100 Network Driver"
175 #define DRV_COPYRIGHT   "Copyright(c) 2003-2006 Intel Corporation"
176
177 /* Debugging stuff */
178 #ifdef CONFIG_IPW2100_DEBUG
179 #define IPW2100_RX_DEBUG        /* Reception debugging */
180 #endif
181
182 MODULE_DESCRIPTION(DRV_DESCRIPTION);
183 MODULE_VERSION(DRV_VERSION);
184 MODULE_AUTHOR(DRV_COPYRIGHT);
185 MODULE_LICENSE("GPL");
186
187 static int debug = 0;
188 static int network_mode = 0;
189 static int channel = 0;
190 static int associate = 0;
191 static int disable = 0;
192 #ifdef CONFIG_PM
193 static struct ipw2100_fw ipw2100_firmware;
194 #endif
195
196 #include <linux/moduleparam.h>
197 module_param(debug, int, 0444);
198 module_param_named(mode, network_mode, int, 0444);
199 module_param(channel, int, 0444);
200 module_param(associate, int, 0444);
201 module_param(disable, int, 0444);
202
203 MODULE_PARM_DESC(debug, "debug level");
204 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
205 MODULE_PARM_DESC(channel, "channel");
206 MODULE_PARM_DESC(associate, "auto associate when scanning (default off)");
207 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
208
209 static u32 ipw2100_debug_level = IPW_DL_NONE;
210
211 #ifdef CONFIG_IPW2100_DEBUG
212 #define IPW_DEBUG(level, message...) \
213 do { \
214         if (ipw2100_debug_level & (level)) { \
215                 printk(KERN_DEBUG "ipw2100: %c %s ", \
216                        in_interrupt() ? 'I' : 'U',  __func__); \
217                 printk(message); \
218         } \
219 } while (0)
220 #else
221 #define IPW_DEBUG(level, message...) do {} while (0)
222 #endif                          /* CONFIG_IPW2100_DEBUG */
223
224 #ifdef CONFIG_IPW2100_DEBUG
225 static const char *command_types[] = {
226         "undefined",
227         "unused",               /* HOST_ATTENTION */
228         "HOST_COMPLETE",
229         "unused",               /* SLEEP */
230         "unused",               /* HOST_POWER_DOWN */
231         "unused",
232         "SYSTEM_CONFIG",
233         "unused",               /* SET_IMR */
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",
279         "unused",               /* SAVE_CALIBRATION */
280         "unused",               /* RESTORE_CALIBRATION */
281         "undefined",
282         "undefined",
283         "undefined",
284         "HOST_PRE_POWER_DOWN",
285         "unused",               /* HOST_INTERRUPT_COALESCING */
286         "undefined",
287         "CARD_DISABLE_PHY_OFF",
288         "MSDU_TX_RATES" "undefined",
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
299 #define WEXT_USECHANNELS 1
300
301 static 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
310 static const long ipw2100_rates_11b[] = {
311         1000000,
312         2000000,
313         5500000,
314         11000000
315 };
316
317 static 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
326 /* Pre-decl until we get the code solid and then we can clean it up */
327 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv);
328 static void ipw2100_tx_send_data(struct ipw2100_priv *priv);
329 static int ipw2100_adapter_setup(struct ipw2100_priv *priv);
330
331 static void ipw2100_queues_initialize(struct ipw2100_priv *priv);
332 static void ipw2100_queues_free(struct ipw2100_priv *priv);
333 static int ipw2100_queues_allocate(struct ipw2100_priv *priv);
334
335 static int ipw2100_fw_download(struct ipw2100_priv *priv,
336                                struct ipw2100_fw *fw);
337 static int ipw2100_get_firmware(struct ipw2100_priv *priv,
338                                 struct ipw2100_fw *fw);
339 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf,
340                                  size_t max);
341 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf,
342                                     size_t max);
343 static void ipw2100_release_firmware(struct ipw2100_priv *priv,
344                                      struct ipw2100_fw *fw);
345 static int ipw2100_ucode_download(struct ipw2100_priv *priv,
346                                   struct ipw2100_fw *fw);
347 static void ipw2100_wx_event_work(struct work_struct *work);
348 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev);
349 static struct iw_handler_def ipw2100_wx_handler_def;
350
351 static inline void read_register(struct net_device *dev, u32 reg, u32 * val)
352 {
353         *val = readl((void __iomem *)(dev->base_addr + reg));
354         IPW_DEBUG_IO("r: 0x%08X => 0x%08X\n", reg, *val);
355 }
356
357 static inline void write_register(struct net_device *dev, u32 reg, u32 val)
358 {
359         writel(val, (void __iomem *)(dev->base_addr + reg));
360         IPW_DEBUG_IO("w: 0x%08X <= 0x%08X\n", reg, val);
361 }
362
363 static inline void read_register_word(struct net_device *dev, u32 reg,
364                                       u16 * val)
365 {
366         *val = readw((void __iomem *)(dev->base_addr + reg));
367         IPW_DEBUG_IO("r: 0x%08X => %04X\n", reg, *val);
368 }
369
370 static inline void read_register_byte(struct net_device *dev, u32 reg, u8 * val)
371 {
372         *val = readb((void __iomem *)(dev->base_addr + reg));
373         IPW_DEBUG_IO("r: 0x%08X => %02X\n", reg, *val);
374 }
375
376 static inline void write_register_word(struct net_device *dev, u32 reg, u16 val)
377 {
378         writew(val, (void __iomem *)(dev->base_addr + reg));
379         IPW_DEBUG_IO("w: 0x%08X <= %04X\n", reg, val);
380 }
381
382 static inline void write_register_byte(struct net_device *dev, u32 reg, u8 val)
383 {
384         writeb(val, (void __iomem *)(dev->base_addr + reg));
385         IPW_DEBUG_IO("w: 0x%08X =< %02X\n", reg, val);
386 }
387
388 static inline void read_nic_dword(struct net_device *dev, u32 addr, u32 * val)
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
395 static 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
402 static inline void read_nic_word(struct net_device *dev, u32 addr, u16 * val)
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
409 static 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
416 static inline void read_nic_byte(struct net_device *dev, u32 addr, u8 * val)
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
423 static 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
430 static 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
436 static 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
441 static void write_nic_memory(struct net_device *dev, u32 addr, u32 len,
442                                     const u8 * buf)
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++)
457                         write_register_byte(dev,
458                                             IPW_REG_INDIRECT_ACCESS_DATA + i,
459                                             *buf);
460
461                 len -= dif_len;
462                 aligned_addr += 4;
463         }
464
465         /* read DWs through autoincrement registers */
466         write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr);
467         aligned_len = len & (~0x3);
468         for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
469                 write_register(dev, IPW_REG_AUTOINCREMENT_DATA, *(u32 *) buf);
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++)
475                 write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i,
476                                     *buf);
477 }
478
479 static void read_nic_memory(struct net_device *dev, u32 addr, u32 len,
480                                    u8 * buf)
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++)
495                         read_register_byte(dev,
496                                            IPW_REG_INDIRECT_ACCESS_DATA + i,
497                                            buf);
498
499                 len -= dif_len;
500                 aligned_addr += 4;
501         }
502
503         /* read DWs through autoincrement registers */
504         write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr);
505         aligned_len = len & (~0x3);
506         for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
507                 read_register(dev, IPW_REG_AUTOINCREMENT_DATA, (u32 *) buf);
508
509         /* copy the last nibble */
510         dif_len = len - aligned_len;
511         write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr);
512         for (i = 0; i < dif_len; i++, buf++)
513                 read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i, buf);
514 }
515
516 static inline int ipw2100_hw_is_adapter_in_system(struct net_device *dev)
517 {
518         return (dev->base_addr &&
519                 (readl
520                  ((void __iomem *)(dev->base_addr +
521                                    IPW_REG_DOA_DEBUG_AREA_START))
522                  == IPW_DATA_DOA_DEBUG_VALUE));
523 }
524
525 static int ipw2100_get_ordinal(struct ipw2100_priv *priv, u32 ord,
526                                void *val, u32 * len)
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) {
536                 printk(KERN_WARNING DRV_NAME ": attempt to use fw ordinals "
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
545                         printk(KERN_WARNING DRV_NAME
546                                ": ordinal buffer length too small, need %zd\n",
547                                IPW_ORD_TAB_1_ENTRY_SIZE);
548
549                         return -EINVAL;
550                 }
551
552                 read_nic_dword(priv->net_dev,
553                                ordinals->table1_addr + (ord << 2), &addr);
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 */
566                 read_nic_dword(priv->net_dev,
567                                ordinals->table2_addr + (ord << 3), &addr);
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 */
576                 field_len = *((u16 *) & field_info);
577
578                 /* get number of entries */
579                 field_count = *(((u16 *) & field_info) + 1);
580
581                 /* abort if no enough memory */
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
598         printk(KERN_WARNING DRV_NAME ": ordinal %d neither in table 1 nor "
599                "in table 2\n", ord);
600
601         return -EINVAL;
602 }
603
604 static int ipw2100_set_ordinal(struct ipw2100_priv *priv, u32 ord, u32 * val,
605                                u32 * len)
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
617                 read_nic_dword(priv->net_dev,
618                                ordinals->table1_addr + (ord << 2), &addr);
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
634 static char *snprint_line(char *buf, size_t count,
635                           const u8 * data, u32 len, u32 ofs)
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
669 static void printk_buf(int level, const u8 * data, u32 len)
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
685 #define MAX_RESET_BACKOFF 10
686
687 static void schedule_reset(struct ipw2100_priv *priv)
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
710                         queue_delayed_work(priv->workqueue, &priv->reset_work,
711                                            0);
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)
724 static int ipw2100_hw_send_command(struct ipw2100_priv *priv,
725                                    struct host_command *cmd)
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);
735         printk_buf(IPW_DL_HC, (u8 *) cmd->host_command_parameters,
736                    cmd->host_command_length);
737
738         spin_lock_irqsave(&priv->low_lock, flags);
739
740         if (priv->fatal_error) {
741                 IPW_DEBUG_INFO
742                     ("Attempt to send command while hardware in fatal error condition.\n");
743                 err = -EIO;
744                 goto fail_unlock;
745         }
746
747         if (!(priv->status & STATUS_RUNNING)) {
748                 IPW_DEBUG_INFO
749                     ("Attempt to send command while hardware is not running.\n");
750                 err = -EIO;
751                 goto fail_unlock;
752         }
753
754         if (priv->status & STATUS_CMD_ACTIVE) {
755                 IPW_DEBUG_INFO
756                     ("Attempt to send command while another command is pending.\n");
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;
777         packet->info.c_struct.cmd->host_command_len_reg =
778             cmd->host_command_length;
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
791         ipw2100_tx_send_commands(priv);
792         ipw2100_tx_send_data(priv);
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
802         err =
803             wait_event_interruptible_timeout(priv->wait_command_queue,
804                                              !(priv->
805                                                status & STATUS_CMD_ACTIVE),
806                                              HOST_COMPLETE_TIMEOUT);
807
808         if (err == 0) {
809                 IPW_DEBUG_INFO("Command completion failed out after %dms.\n",
810                                1000 * (HOST_COMPLETE_TIMEOUT / HZ));
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) {
818                 printk(KERN_WARNING DRV_NAME ": %s: firmware fatal error\n",
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 */
828         schedule_timeout_uninterruptible(msecs_to_jiffies(10));
829
830         return 0;
831
832       fail_unlock:
833         spin_unlock_irqrestore(&priv->low_lock, flags);
834
835         return err;
836 }
837
838 /*
839  * Verify the values and data access of the hardware
840  * No locks needed or used.  No functions called.
841  */
842 static 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;
852              address < IPW_REG_DOA_DEBUG_AREA_END; address += sizeof(u32)) {
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
886 static 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
924 /*********************************************************************
925     Procedure   :   sw_reset_and_clock
926     Purpose     :   Asserts s/w reset, asserts clock initialization
927                     and waits for clock stabilization
928  ********************************************************************/
929 static 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
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);
973
974         return 0;
975 }
976
977 /*********************************************************************
978     Procedure   :   ipw2100_download_firmware
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  *******************************************************************/
988 static 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 "
1000                                 "fatal error %d.  Interface must be brought down.\n",
1001                                 priv->net_dev->name, priv->fatal_error);
1002                 return -EINVAL;
1003         }
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",
1009                                         priv->net_dev->name, err);
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",
1018                                 priv->net_dev->name, err);
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",
1029                                 priv->net_dev->name, err);
1030                 goto fail;
1031         }
1032
1033         err = ipw2100_verify(priv);
1034         if (err) {
1035                 IPW_DEBUG_ERROR("%s: ipw2100_verify failed: %d\n",
1036                                 priv->net_dev->name, err);
1037                 goto fail;
1038         }
1039
1040         /* Hold ARC */
1041         write_nic_dword(priv->net_dev,
1042                         IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x80000000);
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) {
1050                 printk(KERN_ERR DRV_NAME ": %s: Error loading microcode: %d\n",
1051                        priv->net_dev->name, err);
1052                 goto fail;
1053         }
1054
1055         /* release ARC */
1056         write_nic_dword(priv->net_dev,
1057                         IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x00000000);
1058
1059         /* s/w reset and clock stabilization (again!!!) */
1060         err = sw_reset_and_clock(priv);
1061         if (err) {
1062                 printk(KERN_ERR DRV_NAME
1063                        ": %s: sw_reset_and_clock failed: %d\n",
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",
1072                                 priv->net_dev->name, err);
1073                 goto fail;
1074         }
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
1106       fail:
1107         ipw2100_release_firmware(priv, &ipw2100_firmware);
1108         return err;
1109 }
1110
1111 static 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
1119 static 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
1127 static 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
1149 static 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
1161 static int rf_kill_active(struct ipw2100_priv *priv)
1162 {
1163 #define MAX_RF_KILL_CHECKS 5
1164 #define RF_KILL_CHECK_DELAY 40
1165
1166         unsigned short value = 0;
1167         u32 reg = 0;
1168         int i;
1169
1170         if (!(priv->hw_features & HW_FEATURE_RFKILL)) {
1171                 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
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
1182         if (value == 0) {
1183                 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
1184                 priv->status |= STATUS_RF_KILL_HW;
1185         } else {
1186                 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
1187                 priv->status &= ~STATUS_RF_KILL_HW;
1188         }
1189
1190         return (value == 0);
1191 }
1192
1193 static 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);
1202         if (ipw2100_get_ordinal
1203             (priv, IPW_ORD_EEPROM_SRAM_DB_BLOCK_START_ADDRESS, &addr, &len)) {
1204                 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1205                                __LINE__);
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
1218         /*
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",
1230                        (priv->hw_features & HW_FEATURE_RFKILL) ? "" : "not ");
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  */
1241 static int ipw2100_start_adapter(struct ipw2100_priv *priv)
1242 {
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)) {
1257                 printk(KERN_ERR DRV_NAME
1258                        ": %s: Failed to power on the adapter.\n",
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 {
1279                 schedule_timeout_uninterruptible(msecs_to_jiffies(40));
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                 }
1302         } while (--i);
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) {
1317                 printk(KERN_WARNING DRV_NAME
1318                        ": %s: Firmware did not initialize.\n",
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
1341 static 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
1351 /* NOTE: Our interrupt is disabled when this method is called */
1352 static 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
1366          *         (not more than 50us, otherwise ret error */
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;
1374         } while (--i);
1375
1376         priv->status &= ~STATUS_RESET_PENDING;
1377
1378         if (!i) {
1379                 IPW_DEBUG_INFO
1380                     ("exit - waited too long for master assert stop\n");
1381                 return -EIO;
1382         }
1383
1384         write_register(priv->net_dev, IPW_REG_RESET_REG,
1385                        IPW_AUX_HOST_RESET_REG_SW_RESET);
1386
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  */
1405 static 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
1433                 schedule_timeout_uninterruptible(HW_PHY_OFF_LOOP_DELAY);
1434         }
1435
1436         return -EIO;
1437 }
1438
1439 static 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
1453         mutex_lock(&priv->adapter_mutex);
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) {
1468                 IPW_DEBUG_INFO("%s: card not responding to init command.\n",
1469                                priv->net_dev->name);
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
1478       fail_up:
1479         mutex_unlock(&priv->adapter_mutex);
1480         return err;
1481 }
1482
1483 static int ipw2100_hw_stop_adapter(struct ipw2100_priv *priv)
1484 {
1485 #define HW_POWER_DOWN_DELAY (msecs_to_jiffies(100))
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)
1510                         printk(KERN_WARNING DRV_NAME
1511                                ": Error disabling radio %d\n", err);
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
1520                  * out of D0-standby if it is already in that state.
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)
1537                         printk(KERN_WARNING DRV_NAME ": "
1538                                "%s: Power down command failed: Error %d\n",
1539                                priv->net_dev->name, err);
1540                 else
1541                         schedule_timeout_uninterruptible(HW_POWER_DOWN_DELAY);
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)
1576                 printk(KERN_WARNING DRV_NAME
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
1589 static 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
1611         mutex_lock(&priv->adapter_mutex);
1612
1613         err = ipw2100_hw_send_command(priv, &cmd);
1614         if (err) {
1615                 printk(KERN_WARNING DRV_NAME
1616                        ": exit - failed to send CARD_DISABLE command\n");
1617                 goto fail_up;
1618         }
1619
1620         err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_DISABLED);
1621         if (err) {
1622                 printk(KERN_WARNING DRV_NAME
1623                        ": exit - card failed to change to DISABLED\n");
1624                 goto fail_up;
1625         }
1626
1627         IPW_DEBUG_INFO("TODO: implement scan state machine\n");
1628
1629       fail_up:
1630         mutex_unlock(&priv->adapter_mutex);
1631         return err;
1632 }
1633
1634 static int ipw2100_set_scan_options(struct ipw2100_priv *priv)
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;
1651         if ((priv->ieee->sec.flags & SEC_ENABLED) && priv->ieee->sec.enabled)
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
1666 static int ipw2100_start_scan(struct ipw2100_priv *priv)
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
1707 static const struct libipw_geo ipw_geos[] = {
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
1719 static 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
1726         /* Age scan list entries found before suspend */
1727         if (priv->suspend_time) {
1728                 libipw_networks_age(priv->ieee, priv->suspend_time);
1729                 priv->suspend_time = 0;
1730         }
1731
1732         /* Quiet if manually disabled. */
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
1739         /* the ipw2100 hardware really doesn't want power management delays
1740          * longer than 175usec
1741          */
1742         pm_qos_update_requirement(PM_QOS_CPU_DMA_LATENCY, "ipw2100", 175);
1743
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)) {
1756                         printk(KERN_WARNING DRV_NAME
1757                                ": %s: Could not cycle adapter.\n",
1758                                priv->net_dev->name);
1759                         rc = 1;
1760                         goto exit;
1761                 }
1762         } else
1763                 priv->status |= STATUS_POWERED;
1764
1765         /* Load the firmware, start the clocks, etc. */
1766         if (ipw2100_start_adapter(priv)) {
1767                 printk(KERN_ERR DRV_NAME
1768                        ": %s: Failed to start the firmware.\n",
1769                        priv->net_dev->name);
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)) {
1778                 printk(KERN_ERR DRV_NAME
1779                        ": %s: Failed to determine HW features.\n",
1780                        priv->net_dev->name);
1781                 rc = 1;
1782                 goto exit;
1783         }
1784
1785         /* Initialize the geo */
1786         if (libipw_set_geo(priv->ieee, &ipw_geos[0])) {
1787                 printk(KERN_WARNING DRV_NAME "Could not set geo\n");
1788                 return 0;
1789         }
1790         priv->ieee->freq_band = LIBIPW_24GHZ_BAND;
1791
1792         lock = LOCK_NONE;
1793         if (ipw2100_set_ordinal(priv, IPW_ORD_PERS_DB_LOCK, &lock, &ord_len)) {
1794                 printk(KERN_ERR DRV_NAME
1795                        ": %s: Failed to clear ordinal lock.\n",
1796                        priv->net_dev->name);
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;
1809                         queue_delayed_work(priv->workqueue, &priv->rf_kill,
1810                                            round_jiffies_relative(HZ));
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)) {
1822                 printk(KERN_ERR DRV_NAME ": %s: Failed to start the card.\n",
1823                        priv->net_dev->name);
1824                 rc = 1;
1825                 goto exit;
1826         }
1827
1828         if (!deferred) {
1829                 /* Enable the adapter - sends HOST_COMPLETE */
1830                 if (ipw2100_enable_adapter(priv)) {
1831                         printk(KERN_ERR DRV_NAME ": "
1832                                "%s: failed in call to enable adapter.\n",
1833                                priv->net_dev->name);
1834                         ipw2100_hw_stop_adapter(priv);
1835                         rc = 1;
1836                         goto exit;
1837                 }
1838
1839                 /* Start a scan . . . */
1840                 ipw2100_set_scan_options(priv);
1841                 ipw2100_start_scan(priv);
1842         }
1843
1844       exit:
1845         return rc;
1846 }
1847
1848 static void ipw2100_down(struct ipw2100_priv *priv)
1849 {
1850         unsigned long flags;
1851         union iwreq_data wrqu = {
1852                 .ap_addr = {
1853                             .sa_family = ARPHRD_ETHER}
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
1863         /* Kill the firmware hang check timer */
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))
1880                 printk(KERN_ERR DRV_NAME ": %s: Error stopping adapter.\n",
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
1890         pm_qos_update_requirement(PM_QOS_CPU_DMA_LATENCY, "ipw2100",
1891                         PM_QOS_DEFAULT_VALUE);
1892
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
1902 /* Called by register_netdev() */
1903 static 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
1960 static void ipw2100_reset_adapter(struct work_struct *work)
1961 {
1962         struct ipw2100_priv *priv =
1963                 container_of(work, struct ipw2100_priv, reset_work.work);
1964         unsigned long flags;
1965         union iwreq_data wrqu = {
1966                 .ap_addr = {
1967                             .sa_family = ARPHRD_ETHER}
1968         };
1969         int associated = priv->status & STATUS_ASSOCIATED;
1970
1971         spin_lock_irqsave(&priv->low_lock, flags);
1972         IPW_DEBUG_INFO(": %s: Restarting adapter.\n", priv->net_dev->name);
1973         priv->resets++;
1974         priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1975         priv->status |= STATUS_SECURITY_UPDATED;
1976
1977         /* Force a power cycle even if interface hasn't been opened
1978          * yet */
1979         cancel_delayed_work(&priv->reset_work);
1980         priv->status |= STATUS_RESET_PENDING;
1981         spin_unlock_irqrestore(&priv->low_lock, flags);
1982
1983         mutex_lock(&priv->action_mutex);
1984         /* stop timed checks so that they don't interfere with reset */
1985         priv->stop_hang_check = 1;
1986         cancel_delayed_work(&priv->hang_check);
1987
1988         /* We have to signal any supplicant if we are disassociating */
1989         if (associated)
1990                 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1991
1992         ipw2100_up(priv, 0);
1993         mutex_unlock(&priv->action_mutex);
1994
1995 }
1996
1997 static void isr_indicate_associated(struct ipw2100_priv *priv, u32 status)
1998 {
1999
2000 #define MAC_ASSOCIATION_READ_DELAY (HZ)
2001         int ret;
2002         unsigned int len, essid_len;
2003         char essid[IW_ESSID_MAX_SIZE];
2004         u32 txrate;
2005         u32 chan;
2006         char *txratename;
2007         u8 bssid[ETH_ALEN];
2008         DECLARE_SSID_BUF(ssid);
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",
2022                                __LINE__);
2023                 return;
2024         }
2025
2026         len = sizeof(u32);
2027         ret = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &txrate, &len);
2028         if (ret) {
2029                 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
2030                                __LINE__);
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",
2038                                __LINE__);
2039                 return;
2040         }
2041         len = ETH_ALEN;
2042         ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, &bssid, &len);
2043         if (ret) {
2044                 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
2045                                __LINE__);
2046                 return;
2047         }
2048         memcpy(priv->ieee->bssid, bssid, ETH_ALEN);
2049
2050         switch (txrate) {
2051         case TX_RATE_1_MBIT:
2052                 txratename = "1Mbps";
2053                 break;
2054         case TX_RATE_2_MBIT:
2055                 txratename = "2Mbsp";
2056                 break;
2057         case TX_RATE_5_5_MBIT:
2058                 txratename = "5.5Mbps";
2059                 break;
2060         case TX_RATE_11_MBIT:
2061                 txratename = "11Mbps";
2062                 break;
2063         default:
2064                 IPW_DEBUG_INFO("Unknown rate: %d\n", txrate);
2065                 txratename = "unknown rate";
2066                 break;
2067         }
2068
2069         IPW_DEBUG_INFO("%s: Associated with '%s' at %s, channel %d (BSSID=%pM)\n",
2070                        priv->net_dev->name, print_ssid(ssid, essid, essid_len),
2071                        txratename, chan, bssid);
2072
2073         /* now we copy read ssid into dev */
2074         if (!(priv->config & CFG_STATIC_ESSID)) {
2075                 priv->essid_len = min((u8) essid_len, (u8) IW_ESSID_MAX_SIZE);
2076                 memcpy(priv->essid, essid, priv->essid_len);
2077         }
2078         priv->channel = chan;
2079         memcpy(priv->bssid, bssid, ETH_ALEN);
2080
2081         priv->status |= STATUS_ASSOCIATING;
2082         priv->connect_start = get_seconds();
2083
2084         queue_delayed_work(priv->workqueue, &priv->wx_event_work, HZ / 10);
2085 }
2086
2087 static int ipw2100_set_essid(struct ipw2100_priv *priv, char *essid,
2088                              int length, int batch_mode)
2089 {
2090         int ssid_len = min(length, IW_ESSID_MAX_SIZE);
2091         struct host_command cmd = {
2092                 .host_command = SSID,
2093                 .host_command_sequence = 0,
2094                 .host_command_length = ssid_len
2095         };
2096         int err;
2097         DECLARE_SSID_BUF(ssid);
2098
2099         IPW_DEBUG_HC("SSID: '%s'\n", print_ssid(ssid, essid, ssid_len));
2100
2101         if (ssid_len)
2102                 memcpy(cmd.host_command_parameters, essid, ssid_len);
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;
2114                 u8 *bogus = (u8 *) cmd.host_command_parameters;
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) {
2125                 memset(priv->essid + ssid_len, 0, IW_ESSID_MAX_SIZE - ssid_len);
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
2138 static void isr_indicate_association_lost(struct ipw2100_priv *priv, u32 status)
2139 {
2140         DECLARE_SSID_BUF(ssid);
2141
2142         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
2143                   "disassociated: '%s' %pM\n",
2144                   print_ssid(ssid, priv->essid, priv->essid_len),
2145                   priv->bssid);
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)
2164                 queue_delayed_work(priv->workqueue, &priv->security_work, 0);
2165
2166         queue_delayed_work(priv->workqueue, &priv->wx_event_work, 0);
2167 }
2168
2169 static 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",
2172                        priv->net_dev->name);
2173
2174         /* RF_KILL is now enabled (else we wouldn't be here) */
2175         wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
2176         priv->status |= STATUS_RF_KILL_HW;
2177
2178         /* Make sure the RF Kill check timer is running */
2179         priv->stop_rf_kill = 0;
2180         cancel_delayed_work(&priv->rf_kill);
2181         queue_delayed_work(priv->workqueue, &priv->rf_kill,
2182                            round_jiffies_relative(HZ));
2183 }
2184
2185 static 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
2195 static 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
2201 static 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
2207 static 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;
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,
2219                                         round_jiffies_relative(msecs_to_jiffies(4000)));
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         }
2225 }
2226
2227 #ifdef CONFIG_IPW2100_DEBUG
2228 #define IPW2100_HANDLER(v, f) { v, f, # v }
2229 struct ipw2100_status_indicator {
2230         int status;
2231         void (*cb) (struct ipw2100_priv * priv, u32 status);
2232         char *name;
2233 };
2234 #else
2235 #define IPW2100_HANDLER(v, f) { v, f }
2236 struct ipw2100_status_indicator {
2237         int status;
2238         void (*cb) (struct ipw2100_priv * priv, u32 status);
2239 };
2240 #endif                          /* CONFIG_IPW2100_DEBUG */
2241
2242 static void isr_indicate_scanning(struct ipw2100_priv *priv, u32 status)
2243 {
2244         IPW_DEBUG_SCAN("Scanning...\n");
2245         priv->status |= STATUS_SCANNING;
2246 }
2247
2248 static const struct ipw2100_status_indicator status_handlers[] = {
2249         IPW2100_HANDLER(IPW_STATE_INITIALIZED, NULL),
2250         IPW2100_HANDLER(IPW_STATE_COUNTRY_FOUND, NULL),
2251         IPW2100_HANDLER(IPW_STATE_ASSOCIATED, isr_indicate_associated),
2252         IPW2100_HANDLER(IPW_STATE_ASSN_LOST, isr_indicate_association_lost),
2253         IPW2100_HANDLER(IPW_STATE_ASSN_CHANGED, NULL),
2254         IPW2100_HANDLER(IPW_STATE_SCAN_COMPLETE, isr_scan_complete),
2255         IPW2100_HANDLER(IPW_STATE_ENTERED_PSP, NULL),
2256         IPW2100_HANDLER(IPW_STATE_LEFT_PSP, NULL),
2257         IPW2100_HANDLER(IPW_STATE_RF_KILL, isr_indicate_rf_kill),
2258         IPW2100_HANDLER(IPW_STATE_DISABLED, NULL),
2259         IPW2100_HANDLER(IPW_STATE_POWER_DOWN, NULL),
2260         IPW2100_HANDLER(IPW_STATE_SCANNING, isr_indicate_scanning),
2261         IPW2100_HANDLER(-1, NULL)
2262 };
2263
2264 static 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",
2281                                         status_handlers[i].name);
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
2292 static void isr_rx_complete_command(struct ipw2100_priv *priv,
2293                                     struct ipw2100_cmd_header *cmd)
2294 {
2295 #ifdef CONFIG_IPW2100_DEBUG
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
2313 #ifdef CONFIG_IPW2100_DEBUG
2314 static const char *frame_types[] = {
2315         "COMMAND_STATUS_VAL",
2316         "STATUS_CHANGE_VAL",
2317         "P80211_DATA_VAL",
2318         "P8023_DATA_VAL",
2319         "HOST_NOTIFICATION_VAL"
2320 };
2321 #endif
2322
2323 static int ipw2100_alloc_skb(struct ipw2100_priv *priv,
2324                                     struct ipw2100_rx_packet *packet)
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
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))
2347 static 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
2357 #ifdef IPW2100_DEBUG_C3
2358 static int ipw2100_snapshot_alloc(struct ipw2100_priv *priv)
2359 {
2360         int i;
2361         if (priv->snapshot[0])
2362                 return 1;
2363         for (i = 0; i < 0x30; i++) {
2364                 priv->snapshot[i] = kmalloc(0x1000, GFP_ATOMIC);
2365                 if (!priv->snapshot[i]) {
2366                         IPW_DEBUG_INFO("%s: Error allocating snapshot "
2367                                        "buffer %d\n", priv->net_dev->name, i);
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
2378 static u32 ipw2100_match_buf(struct ipw2100_priv *priv, u8 * in_buf,
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)
2395                         *(u32 *) SNAPSHOT_ADDR(i) = tmp;
2396                 if (ret == SEARCH_FAIL) {
2397                         d = (u8 *) & tmp;
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 }
2416 #endif
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  *
2426  * .  libipw_hdr
2427  * .  libipw_snap_hdr
2428  *
2429  * The size of the constructed ethernet
2430  *
2431  */
2432 #ifdef IPW2100_RX_DEBUG
2433 static u8 packet_data[IPW_RX_NIC_BUFFER_LENGTH];
2434 #endif
2435
2436 static void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i)
2437 {
2438 #ifdef IPW2100_DEBUG_C3
2439         struct ipw2100_status *status = &priv->status_queue.drv[i];
2440         u32 match, reg;
2441         int j;
2442 #endif
2443
2444         IPW_DEBUG_INFO(": PCI latency error detected at 0x%04zX.\n",
2445                        i * sizeof(struct ipw2100_status));
2446
2447 #ifdef IPW2100_DEBUG_C3
2448         /* Halt the firmware so we can get a good image */
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;
2458         } while (j--);
2459
2460         match = ipw2100_match_buf(priv, (u8 *) status,
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
2472         printk_buf((u8 *) priv->status_queue.drv,
2473                    sizeof(struct ipw2100_status) * RX_QUEUE_LENGTH);
2474 #endif
2475
2476         priv->fatal_error = IPW2100_ERR_C3_CORRUPTION;
2477         priv->net_dev->stats.rx_errors++;
2478         schedule_reset(priv);
2479 }
2480
2481 static void isr_rx(struct ipw2100_priv *priv, int i,
2482                           struct libipw_rx_stats *stats)
2483 {
2484         struct net_device *dev = priv->net_dev;
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",
2493                                dev->name,
2494                                status->frame_size, skb_tailroom(packet->skb));
2495                 dev->stats.rx_errors++;
2496                 return;
2497         }
2498
2499         if (unlikely(!netif_running(dev))) {
2500                 dev->stats.rx_errors++;
2501                 priv->wstats.discard.misc++;
2502                 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
2503                 return;
2504         }
2505
2506         if (unlikely(priv->ieee->iw_mode != IW_MODE_MONITOR &&
2507                      !(priv->status & STATUS_ASSOCIATED))) {
2508                 IPW_DEBUG_DROP("Dropping packet while not associated.\n");
2509                 priv->wstats.discard.misc++;
2510                 return;
2511         }
2512
2513         pci_unmap_single(priv->pci_dev,
2514                          packet->dma_addr,
2515                          sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE);
2516
2517         skb_put(packet->skb, status->frame_size);
2518
2519 #ifdef IPW2100_RX_DEBUG
2520         /* Make a copy of the frame so we can dump it to the logs if
2521          * libipw_rx fails */
2522         skb_copy_from_linear_data(packet->skb, packet_data,
2523                                   min_t(u32, status->frame_size,
2524                                              IPW_RX_NIC_BUFFER_LENGTH));
2525 #endif
2526
2527         if (!libipw_rx(priv->ieee, packet->skb, stats)) {
2528 #ifdef IPW2100_RX_DEBUG
2529                 IPW_DEBUG_DROP("%s: Non consumed packet:\n",
2530                                dev->name);
2531                 printk_buf(IPW_DL_DROP, packet_data, status->frame_size);
2532 #endif
2533                 dev->stats.rx_errors++;
2534
2535                 /* libipw_rx failed, so it didn't free the SKB */
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))) {
2542                 printk(KERN_WARNING DRV_NAME ": "
2543                        "%s: Unable to allocate SKB onto RBD ring - disabling "
2544                        "adapter.\n", dev->name);
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
2553 #ifdef CONFIG_IPW2100_MONITOR
2554
2555 static void isr_rx_monitor(struct ipw2100_priv *priv, int i,
2556                    struct libipw_rx_stats *stats)
2557 {
2558         struct net_device *dev = priv->net_dev;
2559         struct ipw2100_status *status = &priv->status_queue.drv[i];
2560         struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
2561
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
2570         IPW_DEBUG_RX("Handler...\n");
2571
2572         if (unlikely(status->frame_size > skb_tailroom(packet->skb) -
2573                                 sizeof(struct ipw_rt_hdr))) {
2574                 IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!"
2575                                "  Dropping.\n",
2576                                dev->name,
2577                                status->frame_size,
2578                                skb_tailroom(packet->skb));
2579                 dev->stats.rx_errors++;
2580                 return;
2581         }
2582
2583         if (unlikely(!netif_running(dev))) {
2584                 dev->stats.rx_errors++;
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");
2593                 dev->stats.rx_errors++;
2594                 return;
2595         }
2596
2597         pci_unmap_single(priv->pci_dev, packet->dma_addr,
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 */
2606         ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total hdr+data */
2607
2608         ipw_rt->rt_hdr.it_present = cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL);
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
2614         if (!libipw_rx(priv->ieee, packet->skb, stats)) {
2615                 dev->stats.rx_errors++;
2616
2617                 /* libipw_rx failed, so it didn't free the SKB */
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 "
2626                         "adapter.\n", dev->name);
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
2637 static int ipw2100_corruption_check(struct ipw2100_priv *priv, int i)
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
2655                 switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) {
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  */
2693 static void __ipw2100_rx_process(struct ipw2100_priv *priv)
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;
2701         struct libipw_rx_stats stats = {
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 */
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);
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;
2741                 frame_type = sq->drv[i].status_fields & STATUS_TYPE_MASK;
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)
2747                         stats.mask |= LIBIPW_STATMASK_RSSI;
2748                 stats.freq = LIBIPW_24GHZ_BAND;
2749
2750                 IPW_DEBUG_RX("%s: '%s' frame type received (%d).\n",
2751                              priv->net_dev->name, frame_types[frame_type],
2752                              stats.len);
2753
2754                 switch (frame_type) {
2755                 case COMMAND_STATUS_VAL:
2756                         /* Reset Rx watchdog */
2757                         isr_rx_complete_command(priv, &u->rx_data.command);
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) {
2768                                 isr_rx_monitor(priv, i, &stats);
2769                                 break;
2770                         }
2771 #endif
2772                         if (stats.len < sizeof(struct libipw_hdr_3addr))
2773                                 break;
2774                         switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) {
2775                         case IEEE80211_FTYPE_MGMT:
2776                                 libipw_rx_mgt(priv->ieee,
2777                                                  &u->rx_data.header, &stats);
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
2791               increment:
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,
2803                                IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, rxq->next);
2804         }
2805 }
2806
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  */
2846 static int __ipw2100_tx_process(struct ipw2100_priv *priv)
2847 {
2848         struct ipw2100_bd_queue *txq = &priv->tx_queue;
2849         struct ipw2100_bd *tbd;
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);
2862         tbd = &txq->drv[packet->index];
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;
2875                 frag_num = tbd->num_fragments - 1;
2876                 e = txq->oldest + frag_num;
2877                 e %= txq->entries;
2878                 break;
2879
2880         default:
2881                 printk(KERN_WARNING DRV_NAME ": %s: Bad fw_pend_list entry!\n",
2882                        priv->net_dev->name);
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)
2895                 printk(KERN_WARNING DRV_NAME ": %s: write index mismatch\n",
2896                        priv->net_dev->name);
2897
2898         /*
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
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
2928 #ifdef CONFIG_IPW2100_DEBUG
2929         {
2930                 i = txq->oldest;
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);
2935
2936                 if (packet->type == DATA) {
2937                         i = (i + 1) % txq->entries;
2938
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);
2945                 }
2946         }
2947 #endif
2948
2949         switch (packet->type) {
2950         case DATA:
2951                 if (txq->drv[txq->oldest].status.info.fields.txType != 0)
2952                         printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch.  "
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 */
2958                 for (i = 0; i < frag_num; i++) {
2959                         tbd = &txq->drv[(packet->index + 1 + i) % txq->entries];
2960
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);
2964
2965                         pci_unmap_single(priv->pci_dev,
2966                                          tbd->host_addr,
2967                                          tbd->buf_length, PCI_DMA_TODEVICE);
2968                 }
2969
2970                 libipw_txb_free(packet->info.d_struct.txb);
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. */
2978                 if (priv->status & STATUS_ASSOCIATED)
2979                         netif_wake_queue(priv->net_dev);
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)
2989                         printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch.  "
2990                                "Expecting COMMAND TBD but pulled "
2991                                "something else: ids %d=%d.\n",
2992                                priv->net_dev->name, txq->oldest, packet->index);
2993
2994 #ifdef CONFIG_IPW2100_DEBUG
2995                 if (packet->info.c_struct.cmd->host_command_reg <
2996                     ARRAY_SIZE(command_types))
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);
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",
3017                      jiffies - packet->jiffy_start);
3018
3019         return (!list_empty(&priv->fw_pend_list));
3020 }
3021
3022 static inline void __ipw2100_tx_complete(struct ipw2100_priv *priv)
3023 {
3024         int i = 0;
3025
3026         while (__ipw2100_tx_process(priv) && i < 200)
3027                 i++;
3028
3029         if (i == 200) {
3030                 printk(KERN_WARNING DRV_NAME ": "
3031                        "%s: Driver is running slow (%d iters).\n",
3032                        priv->net_dev->name, i);
3033         }
3034 }
3035
3036 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv)
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
3060                 packet = list_entry(element, struct ipw2100_tx_packet, list);
3061
3062                 IPW_DEBUG_TX("using TBD at virt=%p, phys=%p\n",
3063                              &txq->drv[txq->next],
3064                              (void *)(txq->nic + txq->next *
3065                                       sizeof(struct ipw2100_bd)));
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 =
3078                     IPW_BD_STATUS_TX_FRAME_COMMAND |
3079                     IPW_BD_STATUS_TX_INTERRUPT_ENABLE;
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
3101 /*
3102  * ipw2100_tx_send_data
3103  *
3104  */
3105 static void ipw2100_tx_send_data(struct ipw2100_priv *priv)
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;
3112         int i = 0;
3113         struct ipw2100_data_header *ipw_hdr;
3114         struct libipw_hdr_3addr *hdr;
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;
3124                 packet = list_entry(element, struct ipw2100_tx_packet, list);
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 */
3130                         IPW_DEBUG_INFO("%s: Maximum BD threshold exceeded.  "
3131                                        "Increase fragmentation level.\n",
3132                                        priv->net_dev->name);
3133                 }
3134
3135                 if (txq->available <= 3 + packet->info.d_struct.txb->nr_frags) {
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;
3148                 hdr = (struct libipw_hdr_3addr *)packet->info.d_struct.txb->
3149                     fragments[0]->data;
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 =
3171                             packet->info.d_struct.txb->frag_size -
3172                             LIBIPW_3ADDR_LEN;
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 =
3180                     IPW_BD_STATUS_TX_FRAME_802_3 |
3181                     IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT;
3182                 txq->next++;
3183                 txq->next %= txq->entries;
3184
3185                 IPW_DEBUG_TX("data header tbd TX%d P=%08x L=%d\n",
3186                              packet->index, tbd->host_addr, tbd->buf_length);
3187 #ifdef CONFIG_IPW2100_DEBUG
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
3193                 for (i = 0; i < packet->info.d_struct.txb->nr_frags; i++) {
3194                         tbd = &txq->drv[txq->next];
3195                         if (i == packet->info.d_struct.txb->nr_frags - 1)
3196                                 tbd->status.info.field =
3197                                     IPW_BD_STATUS_TX_FRAME_802_3 |
3198                                     IPW_BD_STATUS_TX_INTERRUPT_ENABLE;
3199                         else
3200                                 tbd->status.info.field =
3201                                     IPW_BD_STATUS_TX_FRAME_802_3 |
3202                                     IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT;
3203
3204                         tbd->buf_length = packet->info.d_struct.txb->
3205                             fragments[i]->len - LIBIPW_3ADDR_LEN;
3206
3207                         tbd->host_addr = pci_map_single(priv->pci_dev,
3208                                                         packet->info.d_struct.
3209                                                         txb->fragments[i]->
3210                                                         data +
3211                                                         LIBIPW_3ADDR_LEN,
3212                                                         tbd->buf_length,
3213                                                         PCI_DMA_TODEVICE);
3214
3215                         IPW_DEBUG_TX("data frag tbd TX%d P=%08x L=%d\n",
3216                                      txq->next, tbd->host_addr,
3217                                      tbd->buf_length);
3218
3219                         pci_dma_sync_single_for_device(priv->pci_dev,
3220                                                        tbd->host_addr,
3221                                                        tbd->buf_length,
3222                                                        PCI_DMA_TODEVICE);
3223
3224                         txq->next++;
3225                         txq->next %= txq->entries;
3226                 }
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         }
3242 }
3243
3244 static 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) {
3268                 printk(KERN_WARNING DRV_NAME
3269                        ": Fatal interrupt. Scheduling firmware restart.\n");
3270                 priv->inta_other++;
3271                 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FATAL_ERROR);
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) {
3286                 printk(KERN_ERR DRV_NAME
3287                        ": ***** PARITY ERROR INTERRUPT !!!!\n");
3288                 priv->inta_other++;
3289                 write_register(dev, IPW_REG_INTA, IPW2100_INTA_PARITY_ERROR);
3290         }
3291
3292         if (inta & IPW2100_INTA_RX_TRANSFER) {
3293                 IPW_DEBUG_ISR("RX interrupt\n");
3294
3295                 priv->rx_interrupts++;
3296
3297                 write_register(dev, IPW_REG_INTA, IPW2100_INTA_RX_TRANSFER);
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
3308                 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_TRANSFER);
3309
3310                 __ipw2100_tx_complete(priv);
3311                 ipw2100_tx_send_commands(priv);
3312                 ipw2100_tx_send_data(priv);
3313         }
3314
3315         if (inta & IPW2100_INTA_TX_COMPLETE) {
3316                 IPW_DEBUG_ISR("TX complete\n");
3317                 priv->inta_other++;
3318                 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_COMPLETE);
3319
3320                 __ipw2100_tx_complete(priv);
3321         }
3322
3323         if (inta & IPW2100_INTA_EVENT_INTERRUPT) {
3324                 /* ipw2100_handle_event(dev); */
3325                 priv->inta_other++;
3326                 write_register(dev, IPW_REG_INTA, IPW2100_INTA_EVENT_INTERRUPT);
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)) {
3336                         write_register(dev, IPW_REG_INTA,
3337                                        IPW2100_INTA_FATAL_ERROR |
3338                                        IPW2100_INTA_PARITY_ERROR);
3339                 }
3340
3341                 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FW_INIT_DONE);
3342         }
3343
3344         if (inta & IPW2100_INTA_STATUS_CHANGE) {
3345                 IPW_DEBUG_ISR("Status change interrupt\n");
3346                 priv->inta_other++;
3347                 write_register(dev, IPW_REG_INTA, IPW2100_INTA_STATUS_CHANGE);
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++;
3353                 write_register(dev, IPW_REG_INTA,
3354                                IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE);
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
3365 static irqreturn_t ipw2100_interrupt(int irq, void *data)
3366 {
3367         struct ipw2100_priv *priv = data;
3368         u32 inta, inta_mask;
3369
3370         if (!data)
3371                 return IRQ_NONE;
3372
3373         spin_lock(&priv->low_lock);
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 */
3389                 printk(KERN_WARNING DRV_NAME ": IRQ INTA == 0xFFFFFFFF\n");
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);
3407         spin_unlock(&priv->low_lock);
3408
3409         return IRQ_HANDLED;
3410       none:
3411         spin_unlock(&priv->low_lock);
3412         return IRQ_NONE;
3413 }
3414
3415 static netdev_tx_t ipw2100_tx(struct libipw_txb *txb,
3416                               struct net_device *dev, int pri)
3417 {
3418         struct ipw2100_priv *priv = libipw_priv(dev);
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");
3427                 priv->net_dev->stats.tx_carrier_errors++;
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
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);
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
3451         ipw2100_tx_send_data(priv);
3452
3453         spin_unlock_irqrestore(&priv->low_lock, flags);
3454         return NETDEV_TX_OK;
3455
3456 fail_unlock:
3457         netif_stop_queue(dev);
3458         spin_unlock_irqrestore(&priv->low_lock, flags);
3459         return NETDEV_TX_BUSY;
3460 }
3461
3462 static int ipw2100_msg_allocate(struct ipw2100_priv *priv)
3463 {
3464         int i, j, err = -EINVAL;
3465         void *v;
3466         dma_addr_t p;
3467
3468         priv->msg_buffers =
3469             (struct ipw2100_tx_packet *)kmalloc(IPW_COMMAND_POOL_SIZE *
3470                                                 sizeof(struct
3471                                                        ipw2100_tx_packet),
3472                                                 GFP_KERNEL);
3473         if (!priv->msg_buffers) {
3474                 printk(KERN_ERR DRV_NAME ": %s: PCI alloc failed for msg "
3475                        "buffers.\n", priv->net_dev->name);
3476                 return -ENOMEM;
3477         }
3478
3479         for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) {
3480                 v = pci_alloc_consistent(priv->pci_dev,
3481                                          sizeof(struct ipw2100_cmd_header), &p);
3482                 if (!v) {
3483                         printk(KERN_ERR DRV_NAME ": "
3484                                "%s: PCI alloc failed for msg "
3485                                "buffers.\n", priv->net_dev->name);
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 =
3494                     (struct ipw2100_cmd_header *)v;
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++) {
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);
3507         }
3508
3509         kfree(priv->msg_buffers);
3510         priv->msg_buffers = NULL;
3511
3512         return err;
3513 }
3514
3515 static 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
3529 static 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,
3540                                     priv->msg_buffers[i].info.c_struct.
3541                                     cmd_phys);
3542         }
3543
3544         kfree(priv->msg_buffers);
3545         priv->msg_buffers = NULL;
3546 }
3547
3548 static ssize_t show_pci(struct device *d, struct device_attribute *attr,
3549                         char *buf)
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 }
3567
3568 static DEVICE_ATTR(pci, S_IRUGO, show_pci, NULL);
3569
3570 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
3571                         char *buf)
3572 {
3573         struct ipw2100_priv *p = dev_get_drvdata(d);
3574         return sprintf(buf, "0x%08x\n", (int)p->config);
3575 }
3576
3577 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
3578
3579 static ssize_t show_status(struct device *d, struct device_attribute *attr,
3580                            char *buf)
3581 {
3582         struct ipw2100_priv *p = dev_get_drvdata(d);
3583         return sprintf(buf, "0x%08x\n", (int)p->status);
3584 }
3585
3586 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
3587
3588 static ssize_t show_capability(struct device *d, struct device_attribute *attr,
3589                                char *buf)
3590 {
3591         struct ipw2100_priv *p = dev_get_drvdata(d);
3592         return sprintf(buf, "0x%08x\n", (int)p->capability);
3593 }
3594
3595 static DEVICE_ATTR(capability, S_IRUGO, show_capability, NULL);
3596
3597 #define IPW2100_REG(x) { IPW_ ##x, #x }
3598 static const struct {
3599         u32 addr;
3600         const char *name;
3601 } hw_data[] = {
3602 IPW2100_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),};
3606 #define IPW2100_NIC(x, s) { x, #x, s }
3607 static const struct {
3608         u32 addr;
3609         const char *name;
3610         size_t size;
3611 } nic_data[] = {
3612 IPW2100_NIC(IPW2100_CONTROL_REG, 2),
3613             IPW2100_NIC(0x210014, 1), IPW2100_NIC(0x210000, 1),};
3614 #define IPW2100_ORD(x, d) { IPW_ORD_ ##x, #x, d }
3615 static const struct {
3616         u8 index;
3617         const char *name;
3618         const char *desc;
3619 } ord_data[] = {
3620 IPW2100_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"),};
3831
3832 static ssize_t show_registers(struct device *d, struct device_attribute *attr,
3833                               char *buf)
3834 {
3835         int i;
3836         struct ipw2100_priv *priv = dev_get_drvdata(d);
3837         struct net_device *dev = priv->net_dev;
3838         char *out = buf;
3839         u32 val = 0;
3840
3841         out += sprintf(out, "%30s [Address ] : Hex\n", "Register");
3842
3843         for (i = 0; i < ARRAY_SIZE(hw_data); i++) {
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 }
3851
3852 static DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL);
3853
3854 static ssize_t show_hardware(struct device *d, struct device_attribute *attr,
3855                              char *buf)
3856 {
3857         struct ipw2100_priv *priv = dev_get_drvdata(d);
3858         struct net_device *dev = priv->net_dev;
3859         char *out = buf;
3860         int i;
3861
3862         out += sprintf(out, "%30s [Address ] : Hex\n", "NIC entry");
3863
3864         for (i = 0; i < ARRAY_SIZE(nic_data); i++) {
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 }
3892
3893 static DEVICE_ATTR(hardware, S_IRUGO, show_hardware, NULL);
3894
3895 static ssize_t show_memory(struct device *d, struct device_attribute *attr,
3896                            char *buf)
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
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]);
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",
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]);
3942                 else
3943                         len += sprintf(buf + len, "%s\n",
3944                                        snprint_line(line, sizeof(line),
3945                                                     (u8 *) buffer, 16, loop));
3946                 loop += 16;
3947         }
3948
3949         return len;
3950 }
3951
3952 static ssize_t store_memory(struct device *d, struct device_attribute *attr,
3953                             const char *buf, size_t count)
3954 {
3955         struct ipw2100_priv *priv = dev_get_drvdata(d);
3956         struct net_device *dev = priv->net_dev;
3957         const char *p = buf;
3958
3959         (void)dev;              /* kill unused-var warning for debug-only code */
3960
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",
3967                                dev->name);
3968                 priv->dump_raw = 1;
3969
3970         } else if (p[0] == '0' || (count >= 2 && tolower(p[0]) == 'o' &&
3971                                    tolower(p[1]) == 'f')) {
3972                 IPW_DEBUG_INFO("%s: Setting memory dump to HEX mode.\n",
3973                                dev->name);
3974                 priv->dump_raw = 0;
3975
3976         } else if (tolower(p[0]) == 'r') {
3977                 IPW_DEBUG_INFO("%s: Resetting firmware snapshot.\n", dev->name);
3978                 ipw2100_snapshot_free(priv);
3979
3980         } else
3981                 IPW_DEBUG_INFO("%s: Usage: 0|on = HEX, 1|off = RAW, "
3982                                "reset = clear memory snapshot\n", dev->name);
3983
3984         return count;
3985 }
3986
3987 static DEVICE_ATTR(memory, S_IWUSR | S_IRUGO, show_memory, store_memory);
3988
3989 static ssize_t show_ordinals(struct device *d, struct device_attribute *attr,
3990                              char *buf)
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
3998         if (priv->status & STATUS_RF_KILL_MASK)
3999                 return 0;
4000
4001         if (loop >= ARRAY_SIZE(ord_data))
4002                 loop = 0;
4003
4004         /* sysfs provides us PAGE_SIZE buffer */
4005         while (len < PAGE_SIZE - 128 && loop < ARRAY_SIZE(ord_data)) {
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 }
4022
4023 static DEVICE_ATTR(ordinals, S_IRUGO, show_ordinals, NULL);
4024
4025 static ssize_t show_stats(struct device *d, struct device_attribute *attr,
4026                           char *buf)
4027 {
4028         struct ipw2100_priv *priv = dev_get_drvdata(d);
4029         char *out = buf;
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);
4036 #ifdef CONFIG_IPW2100_DEBUG
4037         out += sprintf(out, "packet mismatch image: %s\n",
4038                        priv->snapshot[0] ? "YES" : "NO");
4039 #endif
4040
4041         return out - buf;
4042 }
4043
4044 static DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL);
4045
4046 static int ipw2100_switch_mode(struct ipw2100_priv *priv, u32 mode)
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) {
4055                 printk(KERN_ERR DRV_NAME ": %s: Could not disable adapter %d\n",
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;
4070                 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
4071                 break;
4072 #endif                          /* CONFIG_IPW2100_MONITOR */
4073         }
4074
4075         priv->ieee->iw_mode = mode;
4076
4077 #ifdef CONFIG_PM
4078         /* Indicate ipw2100_download_firmware download firmware
4079          * from disk instead of memory. */
4080         ipw2100_firmware.version = 0;
4081 #endif
4082
4083         printk(KERN_INFO "%s: Reseting on mode change.\n", priv->net_dev->name);
4084         priv->reset_backoff = 0;
4085         schedule_reset(priv);
4086
4087         return 0;
4088 }
4089
4090 static ssize_t show_internals(struct device *d, struct device_attribute *attr,
4091                               char *buf)
4092 {
4093         struct ipw2100_priv *priv = dev_get_drvdata(d);
4094         int len = 0;
4095
4096 #define DUMP_VAR(x,y) len += sprintf(buf + len, # x ": %" y "\n", priv-> x)
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
4104         DUMP_VAR(ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx], "p");
4105         DUMP_VAR(status, "08lx");
4106         DUMP_VAR(config, "08lx");
4107         DUMP_VAR(capability, "08lx");
4108
4109         len +=
4110             sprintf(buf + len, "last_rtc: %lu\n",
4111                     (unsigned long)priv->last_rtc);
4112
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");
4117
4118         DUMP_VAR(tx_pend_stat.value, "d");
4119         DUMP_VAR(tx_pend_stat.hi, "d");
4120
4121         DUMP_VAR(tx_free_stat.value, "d");
4122         DUMP_VAR(tx_free_stat.lo, "d");
4123
4124         DUMP_VAR(msg_free_stat.value, "d");
4125         DUMP_VAR(msg_free_stat.lo, "d");
4126
4127         DUMP_VAR(msg_pend_stat.value, "d");
4128         DUMP_VAR(msg_pend_stat.hi, "d");
4129
4130         DUMP_VAR(fw_pend_stat.value, "d");
4131         DUMP_VAR(fw_pend_stat.hi, "d");
4132
4133         DUMP_VAR(txq_stat.value, "d");
4134         DUMP_VAR(txq_stat.lo, "d");
4135
4136         DUMP_VAR(ieee->scans, "d");
4137         DUMP_VAR(reset_backoff, "d");
4138
4139         return len;
4140 }
4141
4142 static DEVICE_ATTR(internals, S_IRUGO, show_internals, NULL);
4143
4144 static ssize_t show_bssinfo(struct device *d, struct device_attribute *attr,
4145                             char *buf)
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;
4151         char *out = buf;
4152         unsigned int length;
4153         int ret;
4154
4155         if (priv->status & STATUS_RF_KILL_MASK)
4156                 return 0;
4157
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);
4181         out += sprintf(out, "BSSID:   %pM\n", bssid);
4182         out += sprintf(out, "Channel: %d\n", chan);
4183
4184         return out - buf;
4185 }
4186
4187 static DEVICE_ATTR(bssinfo, S_IRUGO, show_bssinfo, NULL);
4188
4189 #ifdef CONFIG_IPW2100_DEBUG
4190 static ssize_t show_debug_level(struct device_driver *d, char *buf)
4191 {
4192         return sprintf(buf, "0x%08X\n", ipw2100_debug_level);
4193 }
4194
4195 static ssize_t store_debug_level(struct device_driver *d,
4196                                  const char *buf, size_t count)
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)
4209                 IPW_DEBUG_INFO(": %s is not in hex or decimal form.\n", buf);
4210         else
4211                 ipw2100_debug_level = val;
4212
4213         return strnlen(buf, count);
4214 }
4215
4216 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO, show_debug_level,
4217                    store_debug_level);
4218 #endif                          /* CONFIG_IPW2100_DEBUG */
4219
4220 static ssize_t show_fatal_error(struct device *d,
4221                                 struct device_attribute *attr, char *buf)
4222 {
4223         struct ipw2100_priv *priv = dev_get_drvdata(d);
4224         char *out = buf;
4225         int i;
4226
4227         if (priv->fatal_error)
4228                 out += sprintf(out, "0x%08X\n", priv->fatal_error);
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
4245 static ssize_t store_fatal_error(struct device *d,
4246                                  struct device_attribute *attr, const char *buf,
4247                                  size_t count)
4248 {
4249         struct ipw2100_priv *priv = dev_get_drvdata(d);
4250         schedule_reset(priv);
4251         return count;
4252 }
4253
4254 static DEVICE_ATTR(fatal_error, S_IWUSR | S_IRUGO, show_fatal_error,
4255                    store_fatal_error);
4256
4257 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
4258                              char *buf)
4259 {
4260         struct ipw2100_priv *priv = dev_get_drvdata(d);
4261         return sprintf(buf, "%d\n", priv->ieee->scan_age);
4262 }
4263
4264 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
4265                               const char *buf, size_t count)
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
4275         (void)dev;              /* kill unused-var warning for debug-only code */
4276
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) {
4290                 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
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 }
4299
4300 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
4301
4302 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
4303                             char *buf)
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 */
4309         struct ipw2100_priv *priv = dev_get_drvdata(d);
4310         int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
4311             (rf_kill_active(priv) ? 0x2 : 0x0);
4312         return sprintf(buf, "%i\n", val);
4313 }
4314
4315 static 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))
4319                 return 0;
4320
4321         IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO  %s\n",
4322                           disable_radio ? "OFF" : "ON");
4323
4324         mutex_lock(&priv->action_mutex);
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);
4337                         queue_delayed_work(priv->workqueue, &priv->rf_kill,
4338                                            round_jiffies_relative(HZ));
4339                 } else
4340                         schedule_reset(priv);
4341         }
4342
4343         mutex_unlock(&priv->action_mutex);
4344         return 1;
4345 }
4346
4347 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
4348                              const char *buf, size_t count)
4349 {
4350         struct ipw2100_priv *priv = dev_get_drvdata(d);
4351         ipw_radio_kill_sw(priv, buf[0] == '1');
4352         return count;
4353 }
4354
4355 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
4356
4357 static 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
4375 static struct attribute_group ipw2100_attribute_group = {
4376         .attrs = ipw2100_sysfs_entries,
4377 };
4378
4379 static 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);
4386         q->drv =
4387             (struct ipw2100_status *)pci_alloc_consistent(priv->pci_dev,
4388                                                           q->size, &q->nic);
4389         if (!q->drv) {
4390                 IPW_DEBUG_WARNING("Can not allocate status queue.\n");
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
4401 static void status_queue_free(struct ipw2100_priv *priv)
4402 {
4403         IPW_DEBUG_INFO("enter\n");
4404
4405         if (priv->status_queue.drv) {
4406                 pci_free_consistent(priv->pci_dev, priv->status_queue.size,
4407                                     priv->status_queue.drv,
4408                                     priv->status_queue.nic);
4409                 priv->status_queue.drv = NULL;
4410         }
4411
4412         IPW_DEBUG_INFO("exit\n");
4413 }
4414
4415 static 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) {
4426                 IPW_DEBUG_INFO
4427                     ("can't allocate shared memory for buffer descriptors\n");
4428                 return -ENOMEM;
4429         }
4430         memset(q->drv, 0, q->size);
4431
4432         IPW_DEBUG_INFO("exit\n");
4433
4434         return 0;
4435 }
4436
4437 static void bd_queue_free(struct ipw2100_priv *priv, struct ipw2100_bd_queue *q)
4438 {
4439         IPW_DEBUG_INFO("enter\n");
4440
4441         if (!q)
4442                 return;
4443
4444         if (q->drv) {
4445                 pci_free_consistent(priv->pci_dev, q->size, q->drv, q->nic);
4446                 q->drv = NULL;
4447         }
4448
4449         IPW_DEBUG_INFO("exit\n");
4450 }
4451
4452 static void bd_queue_initialize(struct ipw2100_priv *priv,
4453                                 struct ipw2100_bd_queue *q, u32 base, u32 size,
4454                                 u32 r, u32 w)
4455 {
4456         IPW_DEBUG_INFO("enter\n");
4457
4458         IPW_DEBUG_INFO("initializing bd queue at virt=%p, phys=%08x\n", q->drv,
4459                        (u32) q->nic);
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
4469 static 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);
4479                 cancel_delayed_work(&priv->scan_event_later);
4480                 destroy_workqueue(priv->workqueue);
4481                 priv->workqueue = NULL;
4482         }
4483 }
4484
4485 static 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",
4496                                 priv->net_dev->name);
4497                 return err;
4498         }
4499
4500         priv->tx_buffers =
4501             (struct ipw2100_tx_packet *)kmalloc(TX_PENDED_QUEUE_LENGTH *
4502                                                 sizeof(struct
4503                                                        ipw2100_tx_packet),
4504                                                 GFP_ATOMIC);
4505         if (!priv->tx_buffers) {
4506                 printk(KERN_ERR DRV_NAME
4507                        ": %s: alloc failed form tx buffers.\n",
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++) {
4514                 v = pci_alloc_consistent(priv->pci_dev,
4515                                          sizeof(struct ipw2100_data_header),
4516                                          &p);
4517                 if (!v) {
4518                         printk(KERN_ERR DRV_NAME
4519                                ": %s: PCI alloc failed for tx " "buffers.\n",
4520                                priv->net_dev->name);
4521                         err = -ENOMEM;
4522                         break;
4523                 }
4524
4525                 priv->tx_buffers[i].type = DATA;
4526                 priv->tx_buffers[i].info.d_struct.data =
4527                     (struct ipw2100_data_header *)v;
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++) {
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);
4541         }
4542
4543         kfree(priv->tx_buffers);
4544         priv->tx_buffers = NULL;
4545
4546         return err;
4547 }
4548
4549 static 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) {
4573                         libipw_txb_free(priv->tx_buffers[i].info.d_struct.
4574                                            txb);
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
4599 static 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) {
4612                         libipw_txb_free(priv->tx_buffers[i].info.d_struct.
4613                                            txb);
4614                         priv->tx_buffers[i].info.d_struct.txb = NULL;
4615                 }
4616                 if (priv->tx_buffers[i].info.d_struct.data)
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);
4623         }
4624
4625         kfree(priv->tx_buffers);
4626         priv->tx_buffers = NULL;
4627
4628         IPW_DEBUG_INFO("exit\n");
4629 }
4630
4631 static 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
4701 static 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
4725 static 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
4753 static int ipw2100_read_mac_address(struct ipw2100_priv *priv)
4754 {
4755         u32 length = ETH_ALEN;
4756         u8 addr[ETH_ALEN];
4757
4758         int err;
4759
4760         err = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ADAPTER_MAC, addr, &length);
4761         if (err) {
4762                 IPW_DEBUG_INFO("MAC address read failed\n");
4763                 return -EIO;
4764         }
4765
4766         memcpy(priv->net_dev->dev_addr, addr, ETH_ALEN);
4767         IPW_DEBUG_INFO("card MAC is %pM\n", priv->net_dev->dev_addr);
4768
4769         return 0;
4770 }
4771
4772 /********************************************************************
4773  *
4774  * Firmware Commands
4775  *
4776  ********************************************************************/
4777
4778 static int ipw2100_set_mac_address(struct ipw2100_priv *priv, int batch_mode)
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) {
4792                 memcpy(cmd.host_command_parameters, priv->mac_addr, ETH_ALEN);
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
4804 static int ipw2100_set_port_type(struct ipw2100_priv *priv, u32 port_type,
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) {
4829                         printk(KERN_ERR DRV_NAME
4830                                ": %s: Could not disable adapter %d\n",
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
4845 static int ipw2100_set_channel(struct ipw2100_priv *priv, u32 channel,
4846                                int batch_mode)
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) {
4875                 IPW_DEBUG_INFO("Failed to set channel to %d", channel);
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
4895 static int ipw2100_system_config(struct ipw2100_priv *priv, int batch_mode)
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 |
4917             IPW_CFG_BSS_MASK | IPW_CFG_802_1x_ENABLE;
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,
4924                                   &ibss_mask, &len);
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 */
4932         /*cmd.host_command_parameters[0] |= DIVERSITY_ANTENNA_A; */
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
4956 static int ipw2100_set_tx_rates(struct ipw2100_priv *priv, u32 rate,
4957                                 int batch_mode)
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
4996 static int ipw2100_set_power_mode(struct ipw2100_priv *priv, int power_level)
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
5016 #ifdef IPW2100_TX_POWER
5017         if (priv->port_type == IBSS && priv->adhoc_power != DFTL_IBSS_TX_POWER) {
5018                 /* Set beacon interval */
5019                 cmd.host_command = TX_POWER_INDEX;
5020                 cmd.host_command_parameters[0] = (u32) priv->adhoc_power;
5021
5022                 err = ipw2100_hw_send_command(priv, &cmd);
5023                 if (err)
5024                         return err;
5025         }
5026 #endif
5027
5028         return 0;
5029 }
5030
5031 static int ipw2100_set_rts_threshold(struct ipw2100_priv *priv, u32 threshold)
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
5055 int 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
5095 static int ipw2100_set_short_retry(struct ipw2100_priv *priv, u32 retry)
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
5115 static int ipw2100_set_long_retry(struct ipw2100_priv *priv, u32 retry)
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
5135 static int ipw2100_set_mandatory_bssid(struct ipw2100_priv *priv, u8 * bssid,
5136                                        int batch_mode)
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
5145 #ifdef CONFIG_IPW2100_DEBUG
5146         if (bssid != NULL)
5147                 IPW_DEBUG_HC("MANDATORY_BSSID: %pM\n", bssid);
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)
5153                 memcpy(cmd.host_command_parameters, bssid, ETH_ALEN);
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
5169 static 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 }
5192
5193 static int ipw2100_set_wpa_ie(struct ipw2100_priv *,
5194                               struct ipw2100_wpa_assoc_frame *, int)
5195     __attribute__ ((unused));
5196
5197 static 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
5229 struct 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
5237 static 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)
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 =
5249             (struct security_info_params *)&cmd.host_command_parameters;
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 |
5267                     IPW_WEP104_CIPHER;
5268                 break;
5269         case SEC_LEVEL_2:
5270                 security->allowed_ciphers = IPW_WEP40_CIPHER |
5271                     IPW_WEP104_CIPHER | IPW_TKIP_CIPHER;
5272                 break;
5273         case SEC_LEVEL_2_CKIP:
5274                 security->allowed_ciphers = IPW_WEP40_CIPHER |
5275                     IPW_WEP104_CIPHER | IPW_CKIP_CIPHER;
5276                 break;
5277         case SEC_LEVEL_3:
5278                 security->allowed_ciphers = IPW_WEP40_CIPHER |
5279                     IPW_WEP104_CIPHER | IPW_TKIP_CIPHER | IPW_CCMP_CIPHER;
5280                 break;
5281         }
5282
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);
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
5303 static int ipw2100_set_tx_power(struct ipw2100_priv *priv, u32 tx_power)
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;
5311         u32 tmp = tx_power;
5312
5313         if (tx_power != IPW_TX_POWER_DEFAULT)
5314                 tmp = (tx_power - IPW_TX_POWER_MIN_DBM) * 16 /
5315                       (IPW_TX_POWER_MAX_DBM - IPW_TX_POWER_MIN_DBM);
5316
5317         cmd.host_command_parameters[0] = tmp;
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
5327 static int ipw2100_set_ibss_beacon_interval(struct ipw2100_priv *priv,
5328                                             u32 interval, int batch_mode)
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
5362 static void ipw2100_queues_initialize(struct ipw2100_priv *priv)
5363 {
5364         ipw2100_tx_initialize(priv);
5365         ipw2100_rx_initialize(priv);
5366         ipw2100_msg_initialize(priv);
5367 }
5368
5369 static void ipw2100_queues_free(struct ipw2100_priv *priv)
5370 {
5371         ipw2100_tx_free(priv);
5372         ipw2100_rx_free(priv);
5373         ipw2100_msg_free(priv);
5374 }
5375
5376 static int ipw2100_queues_allocate(struct ipw2100_priv *priv)
5377 {
5378         if (ipw2100_tx_allocate(priv) ||
5379             ipw2100_rx_allocate(priv) || ipw2100_msg_allocate(priv))
5380                 goto fail;
5381
5382         return 0;
5383
5384       fail:
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
5393 static 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) {
5410                         printk(KERN_ERR DRV_NAME
5411                                ": %s: Could not disable adapter %d\n",
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
5426 struct 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
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  */
5453 static 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         };
5462         struct ipw2100_wep_key *wep_key = (void *)cmd.host_command_parameters;
5463         int err;
5464
5465         IPW_DEBUG_HC("WEP_KEY_INFO: index = %d, len = %d/%d\n",
5466                      idx, keylen, len);
5467
5468         /* NOTE: We don't check cached values in case the firmware was reset
5469          * or some other problem is occurring.  If the user is setting the key,
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",
5483                               priv->net_dev->name, wep_key->idx);
5484         else if (keylen == 5)
5485                 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_64 "\n",
5486                               priv->net_dev->name, wep_key->idx, wep_key->len,
5487                               WEP_STR_64(wep_key->key));
5488         else
5489                 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_128
5490                               "\n",
5491                               priv->net_dev->name, wep_key->idx, wep_key->len,
5492                               WEP_STR_128(wep_key->key));
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) {
5498                         printk(KERN_ERR DRV_NAME
5499                                ": %s: Could not disable adapter %d\n",
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
5516 static 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,
5523                 .host_command_parameters = {idx},
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) {
5535                         printk(KERN_ERR DRV_NAME
5536                                ": %s: Could not disable adapter %d\n",
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
5551 static int ipw2100_configure_security(struct ipw2100_priv *priv, int batch_mode)
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
5564         if (!priv->ieee->sec.enabled) {
5565                 err =
5566                     ipw2100_set_security_information(priv, IPW_AUTH_OPEN,
5567                                                      SEC_LEVEL_0, 0, 1);
5568         } else {
5569                 auth_mode = IPW_AUTH_OPEN;
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                 }
5576
5577                 sec_level = SEC_LEVEL_0;
5578                 if (priv->ieee->sec.flags & SEC_LEVEL)
5579                         sec_level = priv->ieee->sec.level;
5580
5581                 use_group = 0;
5582                 if (priv->ieee->sec.flags & SEC_UNICAST_GROUP)
5583                         use_group = priv->ieee->sec.unicast_uses_group;
5584
5585                 err =
5586                     ipw2100_set_security_information(priv, auth_mode, sec_level,
5587                                                      use_group, 1);
5588         }
5589
5590         if (err)
5591                 goto exit;
5592
5593         if (priv->ieee->sec.enabled) {
5594                 for (i = 0; i < 4; i++) {
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;
5598                         } else {
5599                                 err = ipw2100_set_key(priv, i,
5600                                                       priv->ieee->sec.keys[i],
5601                                                       priv->ieee->sec.
5602                                                       key_sizes[i], 1);
5603                                 if (err)
5604                                         goto exit;
5605                         }
5606                 }
5607
5608                 ipw2100_set_key_index(priv, priv->ieee->crypt_info.tx_keyidx, 1);
5609         }
5610
5611         /* Always enable privacy so the Host can filter WEP packets if
5612          * encrypted data is sent up */
5613         err =
5614             ipw2100_set_wep_flags(priv,
5615                                   priv->ieee->sec.
5616                                   enabled ? IPW_PRIVACY_CAPABLE : 0, 1);
5617         if (err)
5618                 goto exit;
5619
5620         priv->status &= ~STATUS_SECURITY_UPDATED;
5621
5622       exit:
5623         if (!batch_mode)
5624                 ipw2100_enable_adapter(priv);
5625
5626         return err;
5627 }
5628
5629 static void ipw2100_security_work(struct work_struct *work)
5630 {
5631         struct ipw2100_priv *priv =
5632                 container_of(work, struct ipw2100_priv, security_work.work);
5633
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
5642 static void shim__set_security(struct net_device *dev,
5643                                struct libipw_security *sec)
5644 {
5645         struct ipw2100_priv *priv = libipw_priv(dev);
5646         int i, force_update = 0;
5647
5648         mutex_lock(&priv->action_mutex);
5649         if (!(priv->status & STATUS_INITIALIZED))
5650                 goto done;
5651
5652         for (i = 0; i < 4; i++) {
5653                 if (sec->flags & (1 << i)) {
5654                         priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
5655                         if (sec->key_sizes[i] == 0)
5656                                 priv->ieee->sec.flags &= ~(1 << i);
5657                         else
5658                                 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
5659                                        sec->key_sizes[i]);
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);
5665                 }
5666         }
5667
5668         if ((sec->flags & SEC_ACTIVE_KEY) &&
5669             priv->ieee->sec.active_key != sec->active_key) {
5670                 if (sec->active_key <= 3) {
5671                         priv->ieee->sec.active_key = sec->active_key;
5672                         priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
5673                 } else
5674                         priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
5675
5676                 priv->status |= STATUS_SECURITY_UPDATED;
5677         }
5678
5679         if ((sec->flags & SEC_AUTH_MODE) &&
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;
5683                 priv->status |= STATUS_SECURITY_UPDATED;
5684         }
5685
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;
5689                 priv->status |= STATUS_SECURITY_UPDATED;
5690                 force_update = 1;
5691         }
5692
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;
5699                 priv->status |= STATUS_SECURITY_UPDATED;
5700         }
5701
5702         IPW_DEBUG_WEP("Security flags: %c %c%c%c%c %c%c%c%c\n",
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');
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);
5720       done:
5721         mutex_unlock(&priv->action_mutex);
5722 }
5723
5724 static 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         }
5745 #endif                          /* CONFIG_IPW2100_MONITOR */
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
5765         err = ipw2100_system_config(priv, batch_mode);
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) {
5803                 err =
5804                     ipw2100_set_ibss_beacon_interval(priv,
5805                                                      priv->beacon_interval,
5806                                                      batch_mode);
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         /*
5816            err = ipw2100_set_fragmentation_threshold(
5817            priv, priv->frag_threshold, batch_mode);
5818            if (err)
5819            return err;
5820          */
5821
5822         IPW_DEBUG_INFO("exit\n");
5823
5824         return 0;
5825 }
5826
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 */
5836 static int ipw2100_set_address(struct net_device *dev, void *p)
5837 {
5838         struct ipw2100_priv *priv = libipw_priv(dev);
5839         struct sockaddr *addr = p;
5840         int err = 0;
5841
5842         if (!is_valid_ether_addr(addr->sa_data))
5843                 return -EADDRNOTAVAIL;
5844
5845         mutex_lock(&priv->action_mutex);
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;
5855         mutex_unlock(&priv->action_mutex);
5856         ipw2100_reset_adapter(&priv->reset_work.work);
5857         return 0;
5858
5859       done:
5860         mutex_unlock(&priv->action_mutex);
5861         return err;
5862 }
5863
5864 static int ipw2100_open(struct net_device *dev)
5865 {
5866         struct ipw2100_priv *priv = libipw_priv(dev);
5867         unsigned long flags;
5868         IPW_DEBUG_INFO("dev->open\n");
5869
5870         spin_lock_irqsave(&priv->low_lock, flags);
5871         if (priv->status & STATUS_ASSOCIATED) {
5872                 netif_carrier_on(dev);
5873                 netif_start_queue(dev);
5874         }
5875         spin_unlock_irqrestore(&priv->low_lock, flags);
5876
5877         return 0;
5878 }
5879
5880 static int ipw2100_close(struct net_device *dev)
5881 {
5882         struct ipw2100_priv *priv = libipw_priv(dev);
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;
5898                 packet = list_entry(element, struct ipw2100_tx_packet, list);
5899
5900                 list_del(element);
5901                 DEC_STAT(&priv->tx_pend_stat);
5902
5903                 libipw_txb_free(packet->info.d_struct.txb);
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
5916 /*
5917  * TODO:  Fix this function... its just wrong
5918  */
5919 static void ipw2100_tx_timeout(struct net_device *dev)
5920 {
5921         struct ipw2100_priv *priv = libipw_priv(dev);
5922
5923         dev->stats.tx_errors++;
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
5935 static int ipw2100_wpa_enable(struct ipw2100_priv *priv, int value)
5936 {
5937         /* This is called when wpa_supplicant loads and closes the driver
5938          * interface. */
5939         priv->ieee->wpa_enabled = value;
5940         return 0;
5941 }
5942
5943 static int ipw2100_wpa_set_auth_algs(struct ipw2100_priv *priv, int value)
5944 {
5945
5946         struct libipw_device *ieee = priv->ieee;
5947         struct libipw_security sec = {
5948                 .flags = SEC_AUTH_MODE,
5949         };
5950         int ret = 0;
5951
5952         if (value & IW_AUTH_ALG_SHARED_KEY) {
5953                 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
5954                 ieee->open_wep = 0;
5955         } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
5956                 sec.auth_mode = WLAN_AUTH_OPEN;
5957                 ieee->open_wep = 1;
5958         } else if (value & IW_AUTH_ALG_LEAP) {
5959                 sec.auth_mode = WLAN_AUTH_LEAP;
5960                 ieee->open_wep = 1;
5961         } else
5962                 return -EINVAL;
5963
5964         if (ieee->set_security)
5965                 ieee->set_security(ieee->dev, &sec);
5966         else
5967                 ret = -EOPNOTSUPP;
5968
5969         return ret;
5970 }
5971
5972 static void ipw2100_wpa_assoc_frame(struct ipw2100_priv *priv,
5973                                     char *wpa_ie, int wpa_ie_len)
5974 {
5975
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;
5983
5984         /* make sure WPA is enabled */
5985         ipw2100_wpa_enable(priv, 1);
5986         ipw2100_set_wpa_ie(priv, &frame, 0);
5987 }
5988
5989 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
5990                                     struct ethtool_drvinfo *info)
5991 {
5992         struct ipw2100_priv *priv = libipw_priv(dev);
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
6007 static u32 ipw2100_ethtool_get_link(struct net_device *dev)
6008 {
6009         struct ipw2100_priv *priv = libipw_priv(dev);
6010         return (priv->status & STATUS_ASSOCIATED) ? 1 : 0;
6011 }
6012
6013 static const struct ethtool_ops ipw2100_ethtool_ops = {
6014         .get_link = ipw2100_ethtool_get_link,
6015         .get_drvinfo = ipw_ethtool_get_drvinfo,
6016 };
6017
6018 static void ipw2100_hang_check(struct work_struct *work)
6019 {
6020         struct ipw2100_priv *priv =
6021                 container_of(work, struct ipw2100_priv, hang_check.work);
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);