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