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