1 /******************************************************************************
3 Copyright(c) 2003 - 2006 Intel Corporation. All rights reserved.
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.
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
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.
18 The full GNU General Public License is included in this distribution in the
22 James P. Ketrenos <ipw2100-admin@linux.intel.com>
23 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
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
29 Portions of this file are based on the Host AP project,
30 Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
32 Copyright (c) 2002-2003, Jouni Malinen <j@w1.fi>
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
38 ******************************************************************************/
41 Initial driver on which this is based was developed by Janusz Gorycki,
42 Maciej Urbaniak, and Maciej Sosnowski.
44 Promiscuous mode support added by Jacek Wysoczynski and Maciej Urbaniak.
48 Tx - Commands and Data
50 Firmware and host share a circular queue of Transmit Buffer Descriptors (TBDs)
51 Each TBD contains a pointer to the physical (dma_addr_t) address of data being
52 sent to the firmware as well as the length of the data.
54 The host writes to the TBD queue at the WRITE index. The WRITE index points
55 to the _next_ packet to be written and is advanced when after the TBD has been
58 The firmware pulls from the TBD queue at the READ index. The READ index points
59 to the currently being read entry, and is advanced once the firmware is
62 When data is sent to the firmware, the first TBD is used to indicate to the
63 firmware if a Command or Data is being sent. If it is Command, all of the
64 command information is contained within the physical address referred to by the
65 TBD. If it is Data, the first TBD indicates the type of data packet, number
66 of fragments, etc. The next TBD then referrs to the actual packet location.
68 The Tx flow cycle is as follows:
70 1) ipw2100_tx() is called by kernel with SKB to transmit
71 2) Packet is move from the tx_free_list and appended to the transmit pending
73 3) work is scheduled to move pending packets into the shared circular queue.
74 4) when placing packet in the circular queue, the incoming SKB is DMA mapped
75 to a physical address. That address is entered into a TBD. Two TBDs are
76 filled out. The first indicating a data packet, the second referring to the
78 5) the packet is removed from tx_pend_list and placed on the end of the
79 firmware pending list (fw_pend_list)
80 6) firmware is notified that the WRITE index has
81 7) Once the firmware has processed the TBD, INTA is triggered.
82 8) For each Tx interrupt received from the firmware, the READ index is checked
83 to see which TBDs are done being processed.
84 9) For each TBD that has been processed, the ISR pulls the oldest packet
85 from the fw_pend_list.
86 10)The packet structure contained in the fw_pend_list is then used
87 to unmap the DMA address and to free the SKB originally passed to the driver
89 11)The packet structure is placed onto the tx_free_list
91 The above steps are the same for commands, only the msg_free_list/msg_pend_list
92 are used instead of tx_free_list/tx_pend_list
96 Critical Sections / Locking :
98 There are two locks utilized. The first is the low level lock (priv->low_lock)
99 that protects the following:
101 - Access to the Tx/Rx queue lists via priv->low_lock. The lists are as follows:
103 tx_free_list : Holds pre-allocated Tx buffers.
104 TAIL modified in __ipw2100_tx_process()
105 HEAD modified in ipw2100_tx()
107 tx_pend_list : Holds used Tx buffers waiting to go into the TBD ring
108 TAIL modified ipw2100_tx()
109 HEAD modified by ipw2100_tx_send_data()
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()
115 msg_pend_list : Holds used Msg buffers waiting to go into the TBD ring
116 TAIL modified in ipw2100_hw_send_command()
117 HEAD modified in ipw2100_tx_send_commands()
119 The flow of data on the TX side is as follows:
121 MSG_FREE_LIST + COMMAND => MSG_PEND_LIST => TBD => MSG_FREE_LIST
122 TX_FREE_LIST + DATA => TX_PEND_LIST => TBD => TX_FREE_LIST
124 The methods that work on the TBD ring are protected via priv->low_lock.
126 - The internal data state of the device itself
127 - Access to the firmware read/write indexes for the BD queues
130 All external entry functions are locked with the priv->action_lock to ensure
131 that only one external action is invoked at a time.
136 #include <linux/compiler.h>
137 #include <linux/errno.h>
138 #include <linux/if_arp.h>
139 #include <linux/in6.h>
140 #include <linux/in.h>
141 #include <linux/ip.h>
142 #include <linux/kernel.h>
143 #include <linux/kmod.h>
144 #include <linux/module.h>
145 #include <linux/netdevice.h>
146 #include <linux/ethtool.h>
147 #include <linux/pci.h>
148 #include <linux/dma-mapping.h>
149 #include <linux/proc_fs.h>
150 #include <linux/skbuff.h>
151 #include <asm/uaccess.h>
153 #include <linux/fs.h>
154 #include <linux/mm.h>
155 #include <linux/slab.h>
156 #include <linux/unistd.h>
157 #include <linux/stringify.h>
158 #include <linux/tcp.h>
159 #include <linux/types.h>
160 #include <linux/version.h>
161 #include <linux/time.h>
162 #include <linux/firmware.h>
163 #include <linux/acpi.h>
164 #include <linux/ctype.h>
165 #include <linux/latency.h>
169 #define IPW2100_VERSION "git-1.2.2"
171 #define DRV_NAME "ipw2100"
172 #define DRV_VERSION IPW2100_VERSION
173 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2100 Network Driver"
174 #define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation"
176 /* Debugging stuff */
177 #ifdef CONFIG_IPW2100_DEBUG
178 #define IPW2100_RX_DEBUG /* Reception debugging */
181 MODULE_DESCRIPTION(DRV_DESCRIPTION);
182 MODULE_VERSION(DRV_VERSION);
183 MODULE_AUTHOR(DRV_COPYRIGHT);
184 MODULE_LICENSE("GPL");
186 static int debug = 0;
188 static int channel = 0;
189 static int associate = 1;
190 static int disable = 0;
192 static struct ipw2100_fw ipw2100_firmware;
195 #include <linux/moduleparam.h>
196 module_param(debug, int, 0444);
197 module_param(mode, int, 0444);
198 module_param(channel, int, 0444);
199 module_param(associate, int, 0444);
200 module_param(disable, int, 0444);
202 MODULE_PARM_DESC(debug, "debug level");
203 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
204 MODULE_PARM_DESC(channel, "channel");
205 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
206 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
208 static u32 ipw2100_debug_level = IPW_DL_NONE;
210 #ifdef CONFIG_IPW2100_DEBUG
211 #define IPW_DEBUG(level, message...) \
213 if (ipw2100_debug_level & (level)) { \
214 printk(KERN_DEBUG "ipw2100: %c %s ", \
215 in_interrupt() ? 'I' : 'U', __FUNCTION__); \
220 #define IPW_DEBUG(level, message...) do {} while (0)
221 #endif /* CONFIG_IPW2100_DEBUG */
223 #ifdef CONFIG_IPW2100_DEBUG
224 static const char *command_types[] = {
226 "unused", /* HOST_ATTENTION */
228 "unused", /* SLEEP */
229 "unused", /* HOST_POWER_DOWN */
232 "unused", /* SET_IMR */
235 "AUTHENTICATION_TYPE",
238 "INTERNATIONAL_MODE",
253 "CLEAR_ALL_MULTICAST",
274 "AP_OR_STATION_TABLE",
278 "unused", /* SAVE_CALIBRATION */
279 "unused", /* RESTORE_CALIBRATION */
283 "HOST_PRE_POWER_DOWN",
284 "unused", /* HOST_INTERRUPT_COALESCING */
286 "CARD_DISABLE_PHY_OFF",
287 "MSDU_TX_RATES" "undefined",
289 "SET_STATION_STAT_BITS",
290 "CLEAR_STATIONS_STAT_BITS",
292 "SET_SECURITY_INFORMATION",
293 "DISASSOCIATION_BSSID",
298 /* Pre-decl until we get the code solid and then we can clean it up */
299 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv);
300 static void ipw2100_tx_send_data(struct ipw2100_priv *priv);
301 static int ipw2100_adapter_setup(struct ipw2100_priv *priv);
303 static void ipw2100_queues_initialize(struct ipw2100_priv *priv);
304 static void ipw2100_queues_free(struct ipw2100_priv *priv);
305 static int ipw2100_queues_allocate(struct ipw2100_priv *priv);
307 static int ipw2100_fw_download(struct ipw2100_priv *priv,
308 struct ipw2100_fw *fw);
309 static int ipw2100_get_firmware(struct ipw2100_priv *priv,
310 struct ipw2100_fw *fw);
311 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf,
313 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf,
315 static void ipw2100_release_firmware(struct ipw2100_priv *priv,
316 struct ipw2100_fw *fw);
317 static int ipw2100_ucode_download(struct ipw2100_priv *priv,
318 struct ipw2100_fw *fw);
319 static void ipw2100_wx_event_work(struct work_struct *work);
320 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev);
321 static struct iw_handler_def ipw2100_wx_handler_def;
323 static inline void read_register(struct net_device *dev, u32 reg, u32 * val)
325 *val = readl((void __iomem *)(dev->base_addr + reg));
326 IPW_DEBUG_IO("r: 0x%08X => 0x%08X\n", reg, *val);
329 static inline void write_register(struct net_device *dev, u32 reg, u32 val)
331 writel(val, (void __iomem *)(dev->base_addr + reg));
332 IPW_DEBUG_IO("w: 0x%08X <= 0x%08X\n", reg, val);
335 static inline void read_register_word(struct net_device *dev, u32 reg,
338 *val = readw((void __iomem *)(dev->base_addr + reg));
339 IPW_DEBUG_IO("r: 0x%08X => %04X\n", reg, *val);
342 static inline void read_register_byte(struct net_device *dev, u32 reg, u8 * val)
344 *val = readb((void __iomem *)(dev->base_addr + reg));
345 IPW_DEBUG_IO("r: 0x%08X => %02X\n", reg, *val);
348 static inline void write_register_word(struct net_device *dev, u32 reg, u16 val)
350 writew(val, (void __iomem *)(dev->base_addr + reg));
351 IPW_DEBUG_IO("w: 0x%08X <= %04X\n", reg, val);
354 static inline void write_register_byte(struct net_device *dev, u32 reg, u8 val)
356 writeb(val, (void __iomem *)(dev->base_addr + reg));
357 IPW_DEBUG_IO("w: 0x%08X =< %02X\n", reg, val);
360 static inline void read_nic_dword(struct net_device *dev, u32 addr, u32 * val)
362 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
363 addr & IPW_REG_INDIRECT_ADDR_MASK);
364 read_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
367 static inline void write_nic_dword(struct net_device *dev, u32 addr, u32 val)
369 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
370 addr & IPW_REG_INDIRECT_ADDR_MASK);
371 write_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
374 static inline void read_nic_word(struct net_device *dev, u32 addr, u16 * val)
376 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
377 addr & IPW_REG_INDIRECT_ADDR_MASK);
378 read_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
381 static inline void write_nic_word(struct net_device *dev, u32 addr, u16 val)
383 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
384 addr & IPW_REG_INDIRECT_ADDR_MASK);
385 write_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
388 static inline void read_nic_byte(struct net_device *dev, u32 addr, u8 * val)
390 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
391 addr & IPW_REG_INDIRECT_ADDR_MASK);
392 read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
395 static inline void write_nic_byte(struct net_device *dev, u32 addr, u8 val)
397 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
398 addr & IPW_REG_INDIRECT_ADDR_MASK);
399 write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
402 static inline void write_nic_auto_inc_address(struct net_device *dev, u32 addr)
404 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS,
405 addr & IPW_REG_INDIRECT_ADDR_MASK);
408 static inline void write_nic_dword_auto_inc(struct net_device *dev, u32 val)
410 write_register(dev, IPW_REG_AUTOINCREMENT_DATA, val);
413 static void write_nic_memory(struct net_device *dev, u32 addr, u32 len,
421 /* read first nibble byte by byte */
422 aligned_addr = addr & (~0x3);
423 dif_len = addr - aligned_addr;
425 /* Start reading at aligned_addr + dif_len */
426 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
428 for (i = dif_len; i < 4; i++, buf++)
429 write_register_byte(dev,
430 IPW_REG_INDIRECT_ACCESS_DATA + i,
437 /* read DWs through autoincrement registers */
438 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr);
439 aligned_len = len & (~0x3);
440 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
441 write_register(dev, IPW_REG_AUTOINCREMENT_DATA, *(u32 *) buf);
443 /* copy the last nibble */
444 dif_len = len - aligned_len;
445 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr);
446 for (i = 0; i < dif_len; i++, buf++)
447 write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i,
451 static void read_nic_memory(struct net_device *dev, u32 addr, u32 len,
459 /* read first nibble byte by byte */
460 aligned_addr = addr & (~0x3);
461 dif_len = addr - aligned_addr;
463 /* Start reading at aligned_addr + dif_len */
464 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
466 for (i = dif_len; i < 4; i++, buf++)
467 read_register_byte(dev,
468 IPW_REG_INDIRECT_ACCESS_DATA + i,
475 /* read DWs through autoincrement registers */
476 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr);
477 aligned_len = len & (~0x3);
478 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
479 read_register(dev, IPW_REG_AUTOINCREMENT_DATA, (u32 *) buf);
481 /* copy the last nibble */
482 dif_len = len - aligned_len;
483 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr);
484 for (i = 0; i < dif_len; i++, buf++)
485 read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i, buf);
488 static inline int ipw2100_hw_is_adapter_in_system(struct net_device *dev)
490 return (dev->base_addr &&
492 ((void __iomem *)(dev->base_addr +
493 IPW_REG_DOA_DEBUG_AREA_START))
494 == IPW_DATA_DOA_DEBUG_VALUE));
497 static int ipw2100_get_ordinal(struct ipw2100_priv *priv, u32 ord,
498 void *val, u32 * len)
500 struct ipw2100_ordinals *ordinals = &priv->ordinals;
507 if (ordinals->table1_addr == 0) {
508 printk(KERN_WARNING DRV_NAME ": attempt to use fw ordinals "
509 "before they have been loaded.\n");
513 if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) {
514 if (*len < IPW_ORD_TAB_1_ENTRY_SIZE) {
515 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
517 printk(KERN_WARNING DRV_NAME
518 ": ordinal buffer length too small, need %zd\n",
519 IPW_ORD_TAB_1_ENTRY_SIZE);
524 read_nic_dword(priv->net_dev,
525 ordinals->table1_addr + (ord << 2), &addr);
526 read_nic_dword(priv->net_dev, addr, val);
528 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
533 if (IS_ORDINAL_TABLE_TWO(ordinals, ord)) {
535 ord -= IPW_START_ORD_TAB_2;
537 /* get the address of statistic */
538 read_nic_dword(priv->net_dev,
539 ordinals->table2_addr + (ord << 3), &addr);
541 /* get the second DW of statistics ;
542 * two 16-bit words - first is length, second is count */
543 read_nic_dword(priv->net_dev,
544 ordinals->table2_addr + (ord << 3) + sizeof(u32),
547 /* get each entry length */
548 field_len = *((u16 *) & field_info);
550 /* get number of entries */
551 field_count = *(((u16 *) & field_info) + 1);
553 /* abort if no enought memory */
554 total_length = field_len * field_count;
555 if (total_length > *len) {
564 /* read the ordinal data from the SRAM */
565 read_nic_memory(priv->net_dev, addr, total_length, val);
570 printk(KERN_WARNING DRV_NAME ": ordinal %d neither in table 1 nor "
571 "in table 2\n", ord);
576 static int ipw2100_set_ordinal(struct ipw2100_priv *priv, u32 ord, u32 * val,
579 struct ipw2100_ordinals *ordinals = &priv->ordinals;
582 if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) {
583 if (*len != IPW_ORD_TAB_1_ENTRY_SIZE) {
584 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
585 IPW_DEBUG_INFO("wrong size\n");
589 read_nic_dword(priv->net_dev,
590 ordinals->table1_addr + (ord << 2), &addr);
592 write_nic_dword(priv->net_dev, addr, *val);
594 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
599 IPW_DEBUG_INFO("wrong table\n");
600 if (IS_ORDINAL_TABLE_TWO(ordinals, ord))
606 static char *snprint_line(char *buf, size_t count,
607 const u8 * data, u32 len, u32 ofs)
612 out = snprintf(buf, count, "%08X", ofs);
614 for (l = 0, i = 0; i < 2; i++) {
615 out += snprintf(buf + out, count - out, " ");
616 for (j = 0; j < 8 && l < len; j++, l++)
617 out += snprintf(buf + out, count - out, "%02X ",
620 out += snprintf(buf + out, count - out, " ");
623 out += snprintf(buf + out, count - out, " ");
624 for (l = 0, i = 0; i < 2; i++) {
625 out += snprintf(buf + out, count - out, " ");
626 for (j = 0; j < 8 && l < len; j++, l++) {
627 c = data[(i * 8 + j)];
628 if (!isascii(c) || !isprint(c))
631 out += snprintf(buf + out, count - out, "%c", c);
635 out += snprintf(buf + out, count - out, " ");
641 static void printk_buf(int level, const u8 * data, u32 len)
645 if (!(ipw2100_debug_level & level))
649 printk(KERN_DEBUG "%s\n",
650 snprint_line(line, sizeof(line), &data[ofs],
651 min(len, 16U), ofs));
653 len -= min(len, 16U);
657 #define MAX_RESET_BACKOFF 10
659 static void schedule_reset(struct ipw2100_priv *priv)
661 unsigned long now = get_seconds();
663 /* If we haven't received a reset request within the backoff period,
664 * then we can reset the backoff interval so this reset occurs
666 if (priv->reset_backoff &&
667 (now - priv->last_reset > priv->reset_backoff))
668 priv->reset_backoff = 0;
670 priv->last_reset = get_seconds();
672 if (!(priv->status & STATUS_RESET_PENDING)) {
673 IPW_DEBUG_INFO("%s: Scheduling firmware restart (%ds).\n",
674 priv->net_dev->name, priv->reset_backoff);
675 netif_carrier_off(priv->net_dev);
676 netif_stop_queue(priv->net_dev);
677 priv->status |= STATUS_RESET_PENDING;
678 if (priv->reset_backoff)
679 queue_delayed_work(priv->workqueue, &priv->reset_work,
680 priv->reset_backoff * HZ);
682 queue_delayed_work(priv->workqueue, &priv->reset_work,
685 if (priv->reset_backoff < MAX_RESET_BACKOFF)
686 priv->reset_backoff++;
688 wake_up_interruptible(&priv->wait_command_queue);
690 IPW_DEBUG_INFO("%s: Firmware restart already in progress.\n",
691 priv->net_dev->name);
695 #define HOST_COMPLETE_TIMEOUT (2 * HZ)
696 static int ipw2100_hw_send_command(struct ipw2100_priv *priv,
697 struct host_command *cmd)
699 struct list_head *element;
700 struct ipw2100_tx_packet *packet;
704 IPW_DEBUG_HC("Sending %s command (#%d), %d bytes\n",
705 command_types[cmd->host_command], cmd->host_command,
706 cmd->host_command_length);
707 printk_buf(IPW_DL_HC, (u8 *) cmd->host_command_parameters,
708 cmd->host_command_length);
710 spin_lock_irqsave(&priv->low_lock, flags);
712 if (priv->fatal_error) {
714 ("Attempt to send command while hardware in fatal error condition.\n");
719 if (!(priv->status & STATUS_RUNNING)) {
721 ("Attempt to send command while hardware is not running.\n");
726 if (priv->status & STATUS_CMD_ACTIVE) {
728 ("Attempt to send command while another command is pending.\n");
733 if (list_empty(&priv->msg_free_list)) {
734 IPW_DEBUG_INFO("no available msg buffers\n");
738 priv->status |= STATUS_CMD_ACTIVE;
739 priv->messages_sent++;
741 element = priv->msg_free_list.next;
743 packet = list_entry(element, struct ipw2100_tx_packet, list);
744 packet->jiffy_start = jiffies;
746 /* initialize the firmware command packet */
747 packet->info.c_struct.cmd->host_command_reg = cmd->host_command;
748 packet->info.c_struct.cmd->host_command_reg1 = cmd->host_command1;
749 packet->info.c_struct.cmd->host_command_len_reg =
750 cmd->host_command_length;
751 packet->info.c_struct.cmd->sequence = cmd->host_command_sequence;
753 memcpy(packet->info.c_struct.cmd->host_command_params_reg,
754 cmd->host_command_parameters,
755 sizeof(packet->info.c_struct.cmd->host_command_params_reg));
758 DEC_STAT(&priv->msg_free_stat);
760 list_add_tail(element, &priv->msg_pend_list);
761 INC_STAT(&priv->msg_pend_stat);
763 ipw2100_tx_send_commands(priv);
764 ipw2100_tx_send_data(priv);
766 spin_unlock_irqrestore(&priv->low_lock, flags);
769 * We must wait for this command to complete before another
770 * command can be sent... but if we wait more than 3 seconds
771 * then there is a problem.
775 wait_event_interruptible_timeout(priv->wait_command_queue,
777 status & STATUS_CMD_ACTIVE),
778 HOST_COMPLETE_TIMEOUT);
781 IPW_DEBUG_INFO("Command completion failed out after %dms.\n",
782 1000 * (HOST_COMPLETE_TIMEOUT / HZ));
783 priv->fatal_error = IPW2100_ERR_MSG_TIMEOUT;
784 priv->status &= ~STATUS_CMD_ACTIVE;
785 schedule_reset(priv);
789 if (priv->fatal_error) {
790 printk(KERN_WARNING DRV_NAME ": %s: firmware fatal error\n",
791 priv->net_dev->name);
795 /* !!!!! HACK TEST !!!!!
796 * When lots of debug trace statements are enabled, the driver
797 * doesn't seem to have as many firmware restart cycles...
799 * As a test, we're sticking in a 1/100s delay here */
800 schedule_timeout_uninterruptible(msecs_to_jiffies(10));
805 spin_unlock_irqrestore(&priv->low_lock, flags);
811 * Verify the values and data access of the hardware
812 * No locks needed or used. No functions called.
814 static int ipw2100_verify(struct ipw2100_priv *priv)
819 u32 val1 = 0x76543210;
820 u32 val2 = 0xFEDCBA98;
822 /* Domain 0 check - all values should be DOA_DEBUG */
823 for (address = IPW_REG_DOA_DEBUG_AREA_START;
824 address < IPW_REG_DOA_DEBUG_AREA_END; address += sizeof(u32)) {
825 read_register(priv->net_dev, address, &data1);
826 if (data1 != IPW_DATA_DOA_DEBUG_VALUE)
830 /* Domain 1 check - use arbitrary read/write compare */
831 for (address = 0; address < 5; address++) {
832 /* The memory area is not used now */
833 write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32,
835 write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36,
837 read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32,
839 read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36,
841 if (val1 == data1 && val2 == data2)
850 * Loop until the CARD_DISABLED bit is the same value as the
853 * TODO: See if it would be more efficient to do a wait/wake
854 * cycle and have the completion event trigger the wakeup
857 #define IPW_CARD_DISABLE_COMPLETE_WAIT 100 // 100 milli
858 static int ipw2100_wait_for_card_state(struct ipw2100_priv *priv, int state)
862 u32 len = sizeof(card_state);
865 for (i = 0; i <= IPW_CARD_DISABLE_COMPLETE_WAIT * 1000; i += 50) {
866 err = ipw2100_get_ordinal(priv, IPW_ORD_CARD_DISABLED,
869 IPW_DEBUG_INFO("Query of CARD_DISABLED ordinal "
874 /* We'll break out if either the HW state says it is
875 * in the state we want, or if HOST_COMPLETE command
877 if ((card_state == state) ||
878 ((priv->status & STATUS_ENABLED) ?
879 IPW_HW_STATE_ENABLED : IPW_HW_STATE_DISABLED) == state) {
880 if (state == IPW_HW_STATE_ENABLED)
881 priv->status |= STATUS_ENABLED;
883 priv->status &= ~STATUS_ENABLED;
891 IPW_DEBUG_INFO("ipw2100_wait_for_card_state to %s state timed out\n",
892 state ? "DISABLED" : "ENABLED");
896 /*********************************************************************
897 Procedure : sw_reset_and_clock
898 Purpose : Asserts s/w reset, asserts clock initialization
899 and waits for clock stabilization
900 ********************************************************************/
901 static int sw_reset_and_clock(struct ipw2100_priv *priv)
907 write_register(priv->net_dev, IPW_REG_RESET_REG,
908 IPW_AUX_HOST_RESET_REG_SW_RESET);
910 // wait for clock stabilization
911 for (i = 0; i < 1000; i++) {
912 udelay(IPW_WAIT_RESET_ARC_COMPLETE_DELAY);
914 // check clock ready bit
915 read_register(priv->net_dev, IPW_REG_RESET_REG, &r);
916 if (r & IPW_AUX_HOST_RESET_REG_PRINCETON_RESET)
921 return -EIO; // TODO: better error value
923 /* set "initialization complete" bit to move adapter to
925 write_register(priv->net_dev, IPW_REG_GP_CNTRL,
926 IPW_AUX_HOST_GP_CNTRL_BIT_INIT_DONE);
928 /* wait for clock stabilization */
929 for (i = 0; i < 10000; i++) {
930 udelay(IPW_WAIT_CLOCK_STABILIZATION_DELAY * 4);
932 /* check clock ready bit */
933 read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r);
934 if (r & IPW_AUX_HOST_GP_CNTRL_BIT_CLOCK_READY)
939 return -EIO; /* TODO: better error value */
941 /* set D0 standby bit */
942 read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r);
943 write_register(priv->net_dev, IPW_REG_GP_CNTRL,
944 r | IPW_AUX_HOST_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
949 /*********************************************************************
950 Procedure : ipw2100_download_firmware
951 Purpose : Initiaze adapter after power on.
953 1. assert s/w reset first!
954 2. awake clocks & wait for clock stabilization
955 3. hold ARC (don't ask me why...)
956 4. load Dino ucode and reset/clock init again
957 5. zero-out shared mem
959 *******************************************************************/
960 static int ipw2100_download_firmware(struct ipw2100_priv *priv)
966 /* Fetch the firmware and microcode */
967 struct ipw2100_fw ipw2100_firmware;
970 if (priv->fatal_error) {
971 IPW_DEBUG_ERROR("%s: ipw2100_download_firmware called after "
972 "fatal error %d. Interface must be brought down.\n",
973 priv->net_dev->name, priv->fatal_error);
977 if (!ipw2100_firmware.version) {
978 err = ipw2100_get_firmware(priv, &ipw2100_firmware);
980 IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n",
981 priv->net_dev->name, err);
982 priv->fatal_error = IPW2100_ERR_FW_LOAD;
987 err = ipw2100_get_firmware(priv, &ipw2100_firmware);
989 IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n",
990 priv->net_dev->name, err);
991 priv->fatal_error = IPW2100_ERR_FW_LOAD;
995 priv->firmware_version = ipw2100_firmware.version;
997 /* s/w reset and clock stabilization */
998 err = sw_reset_and_clock(priv);
1000 IPW_DEBUG_ERROR("%s: sw_reset_and_clock failed: %d\n",
1001 priv->net_dev->name, err);
1005 err = ipw2100_verify(priv);
1007 IPW_DEBUG_ERROR("%s: ipw2100_verify failed: %d\n",
1008 priv->net_dev->name, err);
1013 write_nic_dword(priv->net_dev,
1014 IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x80000000);
1016 /* allow ARC to run */
1017 write_register(priv->net_dev, IPW_REG_RESET_REG, 0);
1019 /* load microcode */
1020 err = ipw2100_ucode_download(priv, &ipw2100_firmware);
1022 printk(KERN_ERR DRV_NAME ": %s: Error loading microcode: %d\n",
1023 priv->net_dev->name, err);
1028 write_nic_dword(priv->net_dev,
1029 IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x00000000);
1031 /* s/w reset and clock stabilization (again!!!) */
1032 err = sw_reset_and_clock(priv);
1034 printk(KERN_ERR DRV_NAME
1035 ": %s: sw_reset_and_clock failed: %d\n",
1036 priv->net_dev->name, err);
1041 err = ipw2100_fw_download(priv, &ipw2100_firmware);
1043 IPW_DEBUG_ERROR("%s: Error loading firmware: %d\n",
1044 priv->net_dev->name, err);
1049 * When the .resume method of the driver is called, the other
1050 * part of the system, i.e. the ide driver could still stay in
1051 * the suspend stage. This prevents us from loading the firmware
1052 * from the disk. --YZ
1055 /* free any storage allocated for firmware image */
1056 ipw2100_release_firmware(priv, &ipw2100_firmware);
1059 /* zero out Domain 1 area indirectly (Si requirement) */
1060 for (address = IPW_HOST_FW_SHARED_AREA0;
1061 address < IPW_HOST_FW_SHARED_AREA0_END; address += 4)
1062 write_nic_dword(priv->net_dev, address, 0);
1063 for (address = IPW_HOST_FW_SHARED_AREA1;
1064 address < IPW_HOST_FW_SHARED_AREA1_END; address += 4)
1065 write_nic_dword(priv->net_dev, address, 0);
1066 for (address = IPW_HOST_FW_SHARED_AREA2;
1067 address < IPW_HOST_FW_SHARED_AREA2_END; address += 4)
1068 write_nic_dword(priv->net_dev, address, 0);
1069 for (address = IPW_HOST_FW_SHARED_AREA3;
1070 address < IPW_HOST_FW_SHARED_AREA3_END; address += 4)
1071 write_nic_dword(priv->net_dev, address, 0);
1072 for (address = IPW_HOST_FW_INTERRUPT_AREA;
1073 address < IPW_HOST_FW_INTERRUPT_AREA_END; address += 4)
1074 write_nic_dword(priv->net_dev, address, 0);
1079 ipw2100_release_firmware(priv, &ipw2100_firmware);
1083 static inline void ipw2100_enable_interrupts(struct ipw2100_priv *priv)
1085 if (priv->status & STATUS_INT_ENABLED)
1087 priv->status |= STATUS_INT_ENABLED;
1088 write_register(priv->net_dev, IPW_REG_INTA_MASK, IPW_INTERRUPT_MASK);
1091 static inline void ipw2100_disable_interrupts(struct ipw2100_priv *priv)
1093 if (!(priv->status & STATUS_INT_ENABLED))
1095 priv->status &= ~STATUS_INT_ENABLED;
1096 write_register(priv->net_dev, IPW_REG_INTA_MASK, 0x0);
1099 static void ipw2100_initialize_ordinals(struct ipw2100_priv *priv)
1101 struct ipw2100_ordinals *ord = &priv->ordinals;
1103 IPW_DEBUG_INFO("enter\n");
1105 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_1,
1108 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_2,
1111 read_nic_dword(priv->net_dev, ord->table1_addr, &ord->table1_size);
1112 read_nic_dword(priv->net_dev, ord->table2_addr, &ord->table2_size);
1114 ord->table2_size &= 0x0000FFFF;
1116 IPW_DEBUG_INFO("table 1 size: %d\n", ord->table1_size);
1117 IPW_DEBUG_INFO("table 2 size: %d\n", ord->table2_size);
1118 IPW_DEBUG_INFO("exit\n");
1121 static inline void ipw2100_hw_set_gpio(struct ipw2100_priv *priv)
1125 * Set GPIO 3 writable by FW; GPIO 1 writable
1126 * by driver and enable clock
1128 reg = (IPW_BIT_GPIO_GPIO3_MASK | IPW_BIT_GPIO_GPIO1_ENABLE |
1129 IPW_BIT_GPIO_LED_OFF);
1130 write_register(priv->net_dev, IPW_REG_GPIO, reg);
1133 static int rf_kill_active(struct ipw2100_priv *priv)
1135 #define MAX_RF_KILL_CHECKS 5
1136 #define RF_KILL_CHECK_DELAY 40
1138 unsigned short value = 0;
1142 if (!(priv->hw_features & HW_FEATURE_RFKILL)) {
1143 priv->status &= ~STATUS_RF_KILL_HW;
1147 for (i = 0; i < MAX_RF_KILL_CHECKS; i++) {
1148 udelay(RF_KILL_CHECK_DELAY);
1149 read_register(priv->net_dev, IPW_REG_GPIO, ®);
1150 value = (value << 1) | ((reg & IPW_BIT_GPIO_RF_KILL) ? 0 : 1);
1154 priv->status |= STATUS_RF_KILL_HW;
1156 priv->status &= ~STATUS_RF_KILL_HW;
1158 return (value == 0);
1161 static int ipw2100_get_hw_features(struct ipw2100_priv *priv)
1167 * EEPROM_SRAM_DB_START_ADDRESS using ordinal in ordinal table 1
1170 if (ipw2100_get_ordinal
1171 (priv, IPW_ORD_EEPROM_SRAM_DB_BLOCK_START_ADDRESS, &addr, &len)) {
1172 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1177 IPW_DEBUG_INFO("EEPROM address: %08X\n", addr);
1180 * EEPROM version is the byte at offset 0xfd in firmware
1181 * We read 4 bytes, then shift out the byte we actually want */
1182 read_nic_dword(priv->net_dev, addr + 0xFC, &val);
1183 priv->eeprom_version = (val >> 24) & 0xFF;
1184 IPW_DEBUG_INFO("EEPROM version: %d\n", priv->eeprom_version);
1187 * HW RF Kill enable is bit 0 in byte at offset 0x21 in firmware
1189 * notice that the EEPROM bit is reverse polarity, i.e.
1190 * bit = 0 signifies HW RF kill switch is supported
1191 * bit = 1 signifies HW RF kill switch is NOT supported
1193 read_nic_dword(priv->net_dev, addr + 0x20, &val);
1194 if (!((val >> 24) & 0x01))
1195 priv->hw_features |= HW_FEATURE_RFKILL;
1197 IPW_DEBUG_INFO("HW RF Kill: %ssupported.\n",
1198 (priv->hw_features & HW_FEATURE_RFKILL) ? "" : "not ");
1204 * Start firmware execution after power on and intialization
1207 * 2. Wait for f/w initialization completes;
1209 static int ipw2100_start_adapter(struct ipw2100_priv *priv)
1212 u32 inta, inta_mask, gpio;
1214 IPW_DEBUG_INFO("enter\n");
1216 if (priv->status & STATUS_RUNNING)
1220 * Initialize the hw - drive adapter to DO state by setting
1221 * init_done bit. Wait for clk_ready bit and Download
1224 if (ipw2100_download_firmware(priv)) {
1225 printk(KERN_ERR DRV_NAME
1226 ": %s: Failed to power on the adapter.\n",
1227 priv->net_dev->name);
1231 /* Clear the Tx, Rx and Msg queues and the r/w indexes
1232 * in the firmware RBD and TBD ring queue */
1233 ipw2100_queues_initialize(priv);
1235 ipw2100_hw_set_gpio(priv);
1237 /* TODO -- Look at disabling interrupts here to make sure none
1238 * get fired during FW initialization */
1240 /* Release ARC - clear reset bit */
1241 write_register(priv->net_dev, IPW_REG_RESET_REG, 0);
1243 /* wait for f/w intialization complete */
1244 IPW_DEBUG_FW("Waiting for f/w initialization to complete...\n");
1247 schedule_timeout_uninterruptible(msecs_to_jiffies(40));
1248 /* Todo... wait for sync command ... */
1250 read_register(priv->net_dev, IPW_REG_INTA, &inta);
1252 /* check "init done" bit */
1253 if (inta & IPW2100_INTA_FW_INIT_DONE) {
1254 /* reset "init done" bit */
1255 write_register(priv->net_dev, IPW_REG_INTA,
1256 IPW2100_INTA_FW_INIT_DONE);
1260 /* check error conditions : we check these after the firmware
1261 * check so that if there is an error, the interrupt handler
1262 * will see it and the adapter will be reset */
1264 (IPW2100_INTA_FATAL_ERROR | IPW2100_INTA_PARITY_ERROR)) {
1265 /* clear error conditions */
1266 write_register(priv->net_dev, IPW_REG_INTA,
1267 IPW2100_INTA_FATAL_ERROR |
1268 IPW2100_INTA_PARITY_ERROR);
1272 /* Clear out any pending INTAs since we aren't supposed to have
1273 * interrupts enabled at this point... */
1274 read_register(priv->net_dev, IPW_REG_INTA, &inta);
1275 read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask);
1276 inta &= IPW_INTERRUPT_MASK;
1277 /* Clear out any pending interrupts */
1278 if (inta & inta_mask)
1279 write_register(priv->net_dev, IPW_REG_INTA, inta);
1281 IPW_DEBUG_FW("f/w initialization complete: %s\n",
1282 i ? "SUCCESS" : "FAILED");
1285 printk(KERN_WARNING DRV_NAME
1286 ": %s: Firmware did not initialize.\n",
1287 priv->net_dev->name);
1291 /* allow firmware to write to GPIO1 & GPIO3 */
1292 read_register(priv->net_dev, IPW_REG_GPIO, &gpio);
1294 gpio |= (IPW_BIT_GPIO_GPIO1_MASK | IPW_BIT_GPIO_GPIO3_MASK);
1296 write_register(priv->net_dev, IPW_REG_GPIO, gpio);
1298 /* Ready to receive commands */
1299 priv->status |= STATUS_RUNNING;
1301 /* The adapter has been reset; we are not associated */
1302 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
1304 IPW_DEBUG_INFO("exit\n");
1309 static inline void ipw2100_reset_fatalerror(struct ipw2100_priv *priv)
1311 if (!priv->fatal_error)
1314 priv->fatal_errors[priv->fatal_index++] = priv->fatal_error;
1315 priv->fatal_index %= IPW2100_ERROR_QUEUE;
1316 priv->fatal_error = 0;
1319 /* NOTE: Our interrupt is disabled when this method is called */
1320 static int ipw2100_power_cycle_adapter(struct ipw2100_priv *priv)
1325 IPW_DEBUG_INFO("Power cycling the hardware.\n");
1327 ipw2100_hw_set_gpio(priv);
1329 /* Step 1. Stop Master Assert */
1330 write_register(priv->net_dev, IPW_REG_RESET_REG,
1331 IPW_AUX_HOST_RESET_REG_STOP_MASTER);
1333 /* Step 2. Wait for stop Master Assert
1334 * (not more then 50us, otherwise ret error */
1337 udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY);
1338 read_register(priv->net_dev, IPW_REG_RESET_REG, ®);
1340 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
1344 priv->status &= ~STATUS_RESET_PENDING;
1348 ("exit - waited too long for master assert stop\n");
1352 write_register(priv->net_dev, IPW_REG_RESET_REG,
1353 IPW_AUX_HOST_RESET_REG_SW_RESET);
1355 /* Reset any fatal_error conditions */
1356 ipw2100_reset_fatalerror(priv);
1358 /* At this point, the adapter is now stopped and disabled */
1359 priv->status &= ~(STATUS_RUNNING | STATUS_ASSOCIATING |
1360 STATUS_ASSOCIATED | STATUS_ENABLED);
1366 * Send the CARD_DISABLE_PHY_OFF comamnd to the card to disable it
1368 * After disabling, if the card was associated, a STATUS_ASSN_LOST will be sent.
1370 * STATUS_CARD_DISABLE_NOTIFICATION will be sent regardless of
1371 * if STATUS_ASSN_LOST is sent.
1373 static int ipw2100_hw_phy_off(struct ipw2100_priv *priv)
1376 #define HW_PHY_OFF_LOOP_DELAY (HZ / 5000)
1378 struct host_command cmd = {
1379 .host_command = CARD_DISABLE_PHY_OFF,
1380 .host_command_sequence = 0,
1381 .host_command_length = 0,
1386 IPW_DEBUG_HC("CARD_DISABLE_PHY_OFF\n");
1388 /* Turn off the radio */
1389 err = ipw2100_hw_send_command(priv, &cmd);
1393 for (i = 0; i < 2500; i++) {
1394 read_nic_dword(priv->net_dev, IPW2100_CONTROL_REG, &val1);
1395 read_nic_dword(priv->net_dev, IPW2100_COMMAND, &val2);
1397 if ((val1 & IPW2100_CONTROL_PHY_OFF) &&
1398 (val2 & IPW2100_COMMAND_PHY_OFF))
1401 schedule_timeout_uninterruptible(HW_PHY_OFF_LOOP_DELAY);
1407 static int ipw2100_enable_adapter(struct ipw2100_priv *priv)
1409 struct host_command cmd = {
1410 .host_command = HOST_COMPLETE,
1411 .host_command_sequence = 0,
1412 .host_command_length = 0
1416 IPW_DEBUG_HC("HOST_COMPLETE\n");
1418 if (priv->status & STATUS_ENABLED)
1421 mutex_lock(&priv->adapter_mutex);
1423 if (rf_kill_active(priv)) {
1424 IPW_DEBUG_HC("Command aborted due to RF kill active.\n");
1428 err = ipw2100_hw_send_command(priv, &cmd);
1430 IPW_DEBUG_INFO("Failed to send HOST_COMPLETE command\n");
1434 err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_ENABLED);
1436 IPW_DEBUG_INFO("%s: card not responding to init command.\n",
1437 priv->net_dev->name);
1441 if (priv->stop_hang_check) {
1442 priv->stop_hang_check = 0;
1443 queue_delayed_work(priv->workqueue, &priv->hang_check, HZ / 2);
1447 mutex_unlock(&priv->adapter_mutex);
1451 static int ipw2100_hw_stop_adapter(struct ipw2100_priv *priv)
1453 #define HW_POWER_DOWN_DELAY (msecs_to_jiffies(100))
1455 struct host_command cmd = {
1456 .host_command = HOST_PRE_POWER_DOWN,
1457 .host_command_sequence = 0,
1458 .host_command_length = 0,
1463 if (!(priv->status & STATUS_RUNNING))
1466 priv->status |= STATUS_STOPPING;
1468 /* We can only shut down the card if the firmware is operational. So,
1469 * if we haven't reset since a fatal_error, then we can not send the
1470 * shutdown commands. */
1471 if (!priv->fatal_error) {
1472 /* First, make sure the adapter is enabled so that the PHY_OFF
1473 * command can shut it down */
1474 ipw2100_enable_adapter(priv);
1476 err = ipw2100_hw_phy_off(priv);
1478 printk(KERN_WARNING DRV_NAME
1479 ": Error disabling radio %d\n", err);
1482 * If in D0-standby mode going directly to D3 may cause a
1483 * PCI bus violation. Therefore we must change out of the D0
1486 * Sending the PREPARE_FOR_POWER_DOWN will restrict the
1487 * hardware from going into standby mode and will transition
1488 * out of D0-standby if it is already in that state.
1490 * STATUS_PREPARE_POWER_DOWN_COMPLETE will be sent by the
1491 * driver upon completion. Once received, the driver can
1492 * proceed to the D3 state.
1494 * Prepare for power down command to fw. This command would
1495 * take HW out of D0-standby and prepare it for D3 state.
1497 * Currently FW does not support event notification for this
1498 * event. Therefore, skip waiting for it. Just wait a fixed
1501 IPW_DEBUG_HC("HOST_PRE_POWER_DOWN\n");
1503 err = ipw2100_hw_send_command(priv, &cmd);
1505 printk(KERN_WARNING DRV_NAME ": "
1506 "%s: Power down command failed: Error %d\n",
1507 priv->net_dev->name, err);
1509 schedule_timeout_uninterruptible(HW_POWER_DOWN_DELAY);
1512 priv->status &= ~STATUS_ENABLED;
1515 * Set GPIO 3 writable by FW; GPIO 1 writable
1516 * by driver and enable clock
1518 ipw2100_hw_set_gpio(priv);
1521 * Power down adapter. Sequence:
1522 * 1. Stop master assert (RESET_REG[9]=1)
1523 * 2. Wait for stop master (RESET_REG[8]==1)
1524 * 3. S/w reset assert (RESET_REG[7] = 1)
1527 /* Stop master assert */
1528 write_register(priv->net_dev, IPW_REG_RESET_REG,
1529 IPW_AUX_HOST_RESET_REG_STOP_MASTER);
1531 /* wait stop master not more than 50 usec.
1532 * Otherwise return error. */
1533 for (i = 5; i > 0; i--) {
1536 /* Check master stop bit */
1537 read_register(priv->net_dev, IPW_REG_RESET_REG, ®);
1539 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
1544 printk(KERN_WARNING DRV_NAME
1545 ": %s: Could now power down adapter.\n",
1546 priv->net_dev->name);
1548 /* assert s/w reset */
1549 write_register(priv->net_dev, IPW_REG_RESET_REG,
1550 IPW_AUX_HOST_RESET_REG_SW_RESET);
1552 priv->status &= ~(STATUS_RUNNING | STATUS_STOPPING);
1557 static int ipw2100_disable_adapter(struct ipw2100_priv *priv)
1559 struct host_command cmd = {
1560 .host_command = CARD_DISABLE,
1561 .host_command_sequence = 0,
1562 .host_command_length = 0
1566 IPW_DEBUG_HC("CARD_DISABLE\n");
1568 if (!(priv->status & STATUS_ENABLED))
1571 /* Make sure we clear the associated state */
1572 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1574 if (!priv->stop_hang_check) {
1575 priv->stop_hang_check = 1;
1576 cancel_delayed_work(&priv->hang_check);
1579 mutex_lock(&priv->adapter_mutex);
1581 err = ipw2100_hw_send_command(priv, &cmd);
1583 printk(KERN_WARNING DRV_NAME
1584 ": exit - failed to send CARD_DISABLE command\n");
1588 err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_DISABLED);
1590 printk(KERN_WARNING DRV_NAME
1591 ": exit - card failed to change to DISABLED\n");
1595 IPW_DEBUG_INFO("TODO: implement scan state machine\n");
1598 mutex_unlock(&priv->adapter_mutex);
1602 static int ipw2100_set_scan_options(struct ipw2100_priv *priv)
1604 struct host_command cmd = {
1605 .host_command = SET_SCAN_OPTIONS,
1606 .host_command_sequence = 0,
1607 .host_command_length = 8
1611 IPW_DEBUG_INFO("enter\n");
1613 IPW_DEBUG_SCAN("setting scan options\n");
1615 cmd.host_command_parameters[0] = 0;
1617 if (!(priv->config & CFG_ASSOCIATE))
1618 cmd.host_command_parameters[0] |= IPW_SCAN_NOASSOCIATE;
1619 if ((priv->ieee->sec.flags & SEC_ENABLED) && priv->ieee->sec.enabled)
1620 cmd.host_command_parameters[0] |= IPW_SCAN_MIXED_CELL;
1621 if (priv->config & CFG_PASSIVE_SCAN)
1622 cmd.host_command_parameters[0] |= IPW_SCAN_PASSIVE;
1624 cmd.host_command_parameters[1] = priv->channel_mask;
1626 err = ipw2100_hw_send_command(priv, &cmd);
1628 IPW_DEBUG_HC("SET_SCAN_OPTIONS 0x%04X\n",
1629 cmd.host_command_parameters[0]);
1634 static int ipw2100_start_scan(struct ipw2100_priv *priv)
1636 struct host_command cmd = {
1637 .host_command = BROADCAST_SCAN,
1638 .host_command_sequence = 0,
1639 .host_command_length = 4
1643 IPW_DEBUG_HC("START_SCAN\n");
1645 cmd.host_command_parameters[0] = 0;
1647 /* No scanning if in monitor mode */
1648 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
1651 if (priv->status & STATUS_SCANNING) {
1652 IPW_DEBUG_SCAN("Scan requested while already in scan...\n");
1656 IPW_DEBUG_INFO("enter\n");
1658 /* Not clearing here; doing so makes iwlist always return nothing...
1660 * We should modify the table logic to use aging tables vs. clearing
1661 * the table on each scan start.
1663 IPW_DEBUG_SCAN("starting scan\n");
1665 priv->status |= STATUS_SCANNING;
1666 err = ipw2100_hw_send_command(priv, &cmd);
1668 priv->status &= ~STATUS_SCANNING;
1670 IPW_DEBUG_INFO("exit\n");
1675 static const struct ieee80211_geo ipw_geos[] = {
1679 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
1680 {2427, 4}, {2432, 5}, {2437, 6},
1681 {2442, 7}, {2447, 8}, {2452, 9},
1682 {2457, 10}, {2462, 11}, {2467, 12},
1683 {2472, 13}, {2484, 14}},
1687 static int ipw2100_up(struct ipw2100_priv *priv, int deferred)
1689 unsigned long flags;
1692 u32 ord_len = sizeof(lock);
1694 /* Quite if manually disabled. */
1695 if (priv->status & STATUS_RF_KILL_SW) {
1696 IPW_DEBUG_INFO("%s: Radio is disabled by Manual Disable "
1697 "switch\n", priv->net_dev->name);
1701 /* the ipw2100 hardware really doesn't want power management delays
1702 * longer than 175usec
1704 modify_acceptable_latency("ipw2100", 175);
1706 /* If the interrupt is enabled, turn it off... */
1707 spin_lock_irqsave(&priv->low_lock, flags);
1708 ipw2100_disable_interrupts(priv);
1710 /* Reset any fatal_error conditions */
1711 ipw2100_reset_fatalerror(priv);
1712 spin_unlock_irqrestore(&priv->low_lock, flags);
1714 if (priv->status & STATUS_POWERED ||
1715 (priv->status & STATUS_RESET_PENDING)) {
1716 /* Power cycle the card ... */
1717 if (ipw2100_power_cycle_adapter(priv)) {
1718 printk(KERN_WARNING DRV_NAME
1719 ": %s: Could not cycle adapter.\n",
1720 priv->net_dev->name);
1725 priv->status |= STATUS_POWERED;
1727 /* Load the firmware, start the clocks, etc. */
1728 if (ipw2100_start_adapter(priv)) {
1729 printk(KERN_ERR DRV_NAME
1730 ": %s: Failed to start the firmware.\n",
1731 priv->net_dev->name);
1736 ipw2100_initialize_ordinals(priv);
1738 /* Determine capabilities of this particular HW configuration */
1739 if (ipw2100_get_hw_features(priv)) {
1740 printk(KERN_ERR DRV_NAME
1741 ": %s: Failed to determine HW features.\n",
1742 priv->net_dev->name);
1747 /* Initialize the geo */
1748 if (ieee80211_set_geo(priv->ieee, &ipw_geos[0])) {
1749 printk(KERN_WARNING DRV_NAME "Could not set geo\n");
1752 priv->ieee->freq_band = IEEE80211_24GHZ_BAND;
1755 if (ipw2100_set_ordinal(priv, IPW_ORD_PERS_DB_LOCK, &lock, &ord_len)) {
1756 printk(KERN_ERR DRV_NAME
1757 ": %s: Failed to clear ordinal lock.\n",
1758 priv->net_dev->name);
1763 priv->status &= ~STATUS_SCANNING;
1765 if (rf_kill_active(priv)) {
1766 printk(KERN_INFO "%s: Radio is disabled by RF switch.\n",
1767 priv->net_dev->name);
1769 if (priv->stop_rf_kill) {
1770 priv->stop_rf_kill = 0;
1771 queue_delayed_work(priv->workqueue, &priv->rf_kill,
1778 /* Turn on the interrupt so that commands can be processed */
1779 ipw2100_enable_interrupts(priv);
1781 /* Send all of the commands that must be sent prior to
1783 if (ipw2100_adapter_setup(priv)) {
1784 printk(KERN_ERR DRV_NAME ": %s: Failed to start the card.\n",
1785 priv->net_dev->name);
1791 /* Enable the adapter - sends HOST_COMPLETE */
1792 if (ipw2100_enable_adapter(priv)) {
1793 printk(KERN_ERR DRV_NAME ": "
1794 "%s: failed in call to enable adapter.\n",
1795 priv->net_dev->name);
1796 ipw2100_hw_stop_adapter(priv);
1801 /* Start a scan . . . */
1802 ipw2100_set_scan_options(priv);
1803 ipw2100_start_scan(priv);
1810 /* Called by register_netdev() */
1811 static int ipw2100_net_init(struct net_device *dev)
1813 struct ipw2100_priv *priv = ieee80211_priv(dev);
1814 return ipw2100_up(priv, 1);
1817 static void ipw2100_down(struct ipw2100_priv *priv)
1819 unsigned long flags;
1820 union iwreq_data wrqu = {
1822 .sa_family = ARPHRD_ETHER}
1824 int associated = priv->status & STATUS_ASSOCIATED;
1826 /* Kill the RF switch timer */
1827 if (!priv->stop_rf_kill) {
1828 priv->stop_rf_kill = 1;
1829 cancel_delayed_work(&priv->rf_kill);
1832 /* Kill the firmare hang check timer */
1833 if (!priv->stop_hang_check) {
1834 priv->stop_hang_check = 1;
1835 cancel_delayed_work(&priv->hang_check);
1838 /* Kill any pending resets */
1839 if (priv->status & STATUS_RESET_PENDING)
1840 cancel_delayed_work(&priv->reset_work);
1842 /* Make sure the interrupt is on so that FW commands will be
1843 * processed correctly */
1844 spin_lock_irqsave(&priv->low_lock, flags);
1845 ipw2100_enable_interrupts(priv);
1846 spin_unlock_irqrestore(&priv->low_lock, flags);
1848 if (ipw2100_hw_stop_adapter(priv))
1849 printk(KERN_ERR DRV_NAME ": %s: Error stopping adapter.\n",
1850 priv->net_dev->name);
1852 /* Do not disable the interrupt until _after_ we disable
1853 * the adaptor. Otherwise the CARD_DISABLE command will never
1854 * be ack'd by the firmware */
1855 spin_lock_irqsave(&priv->low_lock, flags);
1856 ipw2100_disable_interrupts(priv);
1857 spin_unlock_irqrestore(&priv->low_lock, flags);
1859 modify_acceptable_latency("ipw2100", INFINITE_LATENCY);
1861 /* We have to signal any supplicant if we are disassociating */
1863 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1865 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1866 netif_carrier_off(priv->net_dev);
1867 netif_stop_queue(priv->net_dev);
1870 static void ipw2100_reset_adapter(struct work_struct *work)
1872 struct ipw2100_priv *priv =
1873 container_of(work, struct ipw2100_priv, reset_work.work);
1874 unsigned long flags;
1875 union iwreq_data wrqu = {
1877 .sa_family = ARPHRD_ETHER}
1879 int associated = priv->status & STATUS_ASSOCIATED;
1881 spin_lock_irqsave(&priv->low_lock, flags);
1882 IPW_DEBUG_INFO(": %s: Restarting adapter.\n", priv->net_dev->name);
1884 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1885 priv->status |= STATUS_SECURITY_UPDATED;
1887 /* Force a power cycle even if interface hasn't been opened
1889 cancel_delayed_work(&priv->reset_work);
1890 priv->status |= STATUS_RESET_PENDING;
1891 spin_unlock_irqrestore(&priv->low_lock, flags);
1893 mutex_lock(&priv->action_mutex);
1894 /* stop timed checks so that they don't interfere with reset */
1895 priv->stop_hang_check = 1;
1896 cancel_delayed_work(&priv->hang_check);
1898 /* We have to signal any supplicant if we are disassociating */
1900 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1902 ipw2100_up(priv, 0);
1903 mutex_unlock(&priv->action_mutex);
1907 static void isr_indicate_associated(struct ipw2100_priv *priv, u32 status)
1910 #define MAC_ASSOCIATION_READ_DELAY (HZ)
1911 int ret, len, essid_len;
1912 char essid[IW_ESSID_MAX_SIZE];
1917 DECLARE_MAC_BUF(mac);
1920 * TBD: BSSID is usually 00:00:00:00:00:00 here and not
1921 * an actual MAC of the AP. Seems like FW sets this
1922 * address too late. Read it later and expose through
1923 * /proc or schedule a later task to query and update
1926 essid_len = IW_ESSID_MAX_SIZE;
1927 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID,
1930 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1936 ret = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &txrate, &len);
1938 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1944 ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &len);
1946 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1951 ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, &bssid, &len);
1953 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1957 memcpy(priv->ieee->bssid, bssid, ETH_ALEN);
1960 case TX_RATE_1_MBIT:
1961 txratename = "1Mbps";
1963 case TX_RATE_2_MBIT:
1964 txratename = "2Mbsp";
1966 case TX_RATE_5_5_MBIT:
1967 txratename = "5.5Mbps";
1969 case TX_RATE_11_MBIT:
1970 txratename = "11Mbps";
1973 IPW_DEBUG_INFO("Unknown rate: %d\n", txrate);
1974 txratename = "unknown rate";
1978 IPW_DEBUG_INFO("%s: Associated with '%s' at %s, channel %d (BSSID="
1980 priv->net_dev->name, escape_essid(essid, essid_len),
1981 txratename, chan, print_mac(mac, bssid));
1983 /* now we copy read ssid into dev */
1984 if (!(priv->config & CFG_STATIC_ESSID)) {
1985 priv->essid_len = min((u8) essid_len, (u8) IW_ESSID_MAX_SIZE);
1986 memcpy(priv->essid, essid, priv->essid_len);
1988 priv->channel = chan;
1989 memcpy(priv->bssid, bssid, ETH_ALEN);
1991 priv->status |= STATUS_ASSOCIATING;
1992 priv->connect_start = get_seconds();
1994 queue_delayed_work(priv->workqueue, &priv->wx_event_work, HZ / 10);
1997 static int ipw2100_set_essid(struct ipw2100_priv *priv, char *essid,
1998 int length, int batch_mode)
2000 int ssid_len = min(length, IW_ESSID_MAX_SIZE);
2001 struct host_command cmd = {
2002 .host_command = SSID,
2003 .host_command_sequence = 0,
2004 .host_command_length = ssid_len
2008 IPW_DEBUG_HC("SSID: '%s'\n", escape_essid(essid, ssid_len));
2011 memcpy(cmd.host_command_parameters, essid, ssid_len);
2014 err = ipw2100_disable_adapter(priv);
2019 /* Bug in FW currently doesn't honor bit 0 in SET_SCAN_OPTIONS to
2020 * disable auto association -- so we cheat by setting a bogus SSID */
2021 if (!ssid_len && !(priv->config & CFG_ASSOCIATE)) {
2023 u8 *bogus = (u8 *) cmd.host_command_parameters;
2024 for (i = 0; i < IW_ESSID_MAX_SIZE; i++)
2025 bogus[i] = 0x18 + i;
2026 cmd.host_command_length = IW_ESSID_MAX_SIZE;
2029 /* NOTE: We always send the SSID command even if the provided ESSID is
2030 * the same as what we currently think is set. */
2032 err = ipw2100_hw_send_command(priv, &cmd);
2034 memset(priv->essid + ssid_len, 0, IW_ESSID_MAX_SIZE - ssid_len);
2035 memcpy(priv->essid, essid, ssid_len);
2036 priv->essid_len = ssid_len;
2040 if (ipw2100_enable_adapter(priv))
2047 static void isr_indicate_association_lost(struct ipw2100_priv *priv, u32 status)
2049 DECLARE_MAC_BUF(mac);
2051 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
2052 "disassociated: '%s' %s \n",
2053 escape_essid(priv->essid, priv->essid_len),
2054 print_mac(mac, priv->bssid));
2056 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
2058 if (priv->status & STATUS_STOPPING) {
2059 IPW_DEBUG_INFO("Card is stopping itself, discard ASSN_LOST.\n");
2063 memset(priv->bssid, 0, ETH_ALEN);
2064 memset(priv->ieee->bssid, 0, ETH_ALEN);
2066 netif_carrier_off(priv->net_dev);
2067 netif_stop_queue(priv->net_dev);
2069 if (!(priv->status & STATUS_RUNNING))
2072 if (priv->status & STATUS_SECURITY_UPDATED)
2073 queue_delayed_work(priv->workqueue, &priv->security_work, 0);
2075 queue_delayed_work(priv->workqueue, &priv->wx_event_work, 0);
2078 static void isr_indicate_rf_kill(struct ipw2100_priv *priv, u32 status)
2080 IPW_DEBUG_INFO("%s: RF Kill state changed to radio OFF.\n",
2081 priv->net_dev->name);
2083 /* RF_KILL is now enabled (else we wouldn't be here) */
2084 priv->status |= STATUS_RF_KILL_HW;
2086 /* Make sure the RF Kill check timer is running */
2087 priv->stop_rf_kill = 0;
2088 cancel_delayed_work(&priv->rf_kill);
2089 queue_delayed_work(priv->workqueue, &priv->rf_kill, round_jiffies(HZ));
2092 static void isr_scan_complete(struct ipw2100_priv *priv, u32 status)
2094 IPW_DEBUG_SCAN("scan complete\n");
2095 /* Age the scan results... */
2096 priv->ieee->scans++;
2097 priv->status &= ~STATUS_SCANNING;
2100 #ifdef CONFIG_IPW2100_DEBUG
2101 #define IPW2100_HANDLER(v, f) { v, f, # v }
2102 struct ipw2100_status_indicator {
2104 void (*cb) (struct ipw2100_priv * priv, u32 status);
2108 #define IPW2100_HANDLER(v, f) { v, f }
2109 struct ipw2100_status_indicator {
2111 void (*cb) (struct ipw2100_priv * priv, u32 status);
2113 #endif /* CONFIG_IPW2100_DEBUG */
2115 static void isr_indicate_scanning(struct ipw2100_priv *priv, u32 status)
2117 IPW_DEBUG_SCAN("Scanning...\n");
2118 priv->status |= STATUS_SCANNING;
2121 static const struct ipw2100_status_indicator status_handlers[] = {
2122 IPW2100_HANDLER(IPW_STATE_INITIALIZED, NULL),
2123 IPW2100_HANDLER(IPW_STATE_COUNTRY_FOUND, NULL),
2124 IPW2100_HANDLER(IPW_STATE_ASSOCIATED, isr_indicate_associated),
2125 IPW2100_HANDLER(IPW_STATE_ASSN_LOST, isr_indicate_association_lost),
2126 IPW2100_HANDLER(IPW_STATE_ASSN_CHANGED, NULL),
2127 IPW2100_HANDLER(IPW_STATE_SCAN_COMPLETE, isr_scan_complete),
2128 IPW2100_HANDLER(IPW_STATE_ENTERED_PSP, NULL),
2129 IPW2100_HANDLER(IPW_STATE_LEFT_PSP, NULL),
2130 IPW2100_HANDLER(IPW_STATE_RF_KILL, isr_indicate_rf_kill),
2131 IPW2100_HANDLER(IPW_STATE_DISABLED, NULL),
2132 IPW2100_HANDLER(IPW_STATE_POWER_DOWN, NULL),
2133 IPW2100_HANDLER(IPW_STATE_SCANNING, isr_indicate_scanning),
2134 IPW2100_HANDLER(-1, NULL)
2137 static void isr_status_change(struct ipw2100_priv *priv, int status)
2141 if (status == IPW_STATE_SCANNING &&
2142 priv->status & STATUS_ASSOCIATED &&
2143 !(priv->status & STATUS_SCANNING)) {
2144 IPW_DEBUG_INFO("Scan detected while associated, with "
2145 "no scan request. Restarting firmware.\n");
2147 /* Wake up any sleeping jobs */
2148 schedule_reset(priv);
2151 for (i = 0; status_handlers[i].status != -1; i++) {
2152 if (status == status_handlers[i].status) {
2153 IPW_DEBUG_NOTIF("Status change: %s\n",
2154 status_handlers[i].name);
2155 if (status_handlers[i].cb)
2156 status_handlers[i].cb(priv, status);
2157 priv->wstats.status = status;
2162 IPW_DEBUG_NOTIF("unknown status received: %04x\n", status);
2165 static void isr_rx_complete_command(struct ipw2100_priv *priv,
2166 struct ipw2100_cmd_header *cmd)
2168 #ifdef CONFIG_IPW2100_DEBUG
2169 if (cmd->host_command_reg < ARRAY_SIZE(command_types)) {
2170 IPW_DEBUG_HC("Command completed '%s (%d)'\n",
2171 command_types[cmd->host_command_reg],
2172 cmd->host_command_reg);
2175 if (cmd->host_command_reg == HOST_COMPLETE)
2176 priv->status |= STATUS_ENABLED;
2178 if (cmd->host_command_reg == CARD_DISABLE)
2179 priv->status &= ~STATUS_ENABLED;
2181 priv->status &= ~STATUS_CMD_ACTIVE;
2183 wake_up_interruptible(&priv->wait_command_queue);
2186 #ifdef CONFIG_IPW2100_DEBUG
2187 static const char *frame_types[] = {
2188 "COMMAND_STATUS_VAL",
2189 "STATUS_CHANGE_VAL",
2192 "HOST_NOTIFICATION_VAL"
2196 static int ipw2100_alloc_skb(struct ipw2100_priv *priv,
2197 struct ipw2100_rx_packet *packet)
2199 packet->skb = dev_alloc_skb(sizeof(struct ipw2100_rx));
2203 packet->rxp = (struct ipw2100_rx *)packet->skb->data;
2204 packet->dma_addr = pci_map_single(priv->pci_dev, packet->skb->data,
2205 sizeof(struct ipw2100_rx),
2206 PCI_DMA_FROMDEVICE);
2207 /* NOTE: pci_map_single does not return an error code, and 0 is a valid
2213 #define SEARCH_ERROR 0xffffffff
2214 #define SEARCH_FAIL 0xfffffffe
2215 #define SEARCH_SUCCESS 0xfffffff0
2216 #define SEARCH_DISCARD 0
2217 #define SEARCH_SNAPSHOT 1
2219 #define SNAPSHOT_ADDR(ofs) (priv->snapshot[((ofs) >> 12) & 0xff] + ((ofs) & 0xfff))
2220 static void ipw2100_snapshot_free(struct ipw2100_priv *priv)
2223 if (!priv->snapshot[0])
2225 for (i = 0; i < 0x30; i++)
2226 kfree(priv->snapshot[i]);
2227 priv->snapshot[0] = NULL;
2230 #ifdef IPW2100_DEBUG_C3
2231 static int ipw2100_snapshot_alloc(struct ipw2100_priv *priv)
2234 if (priv->snapshot[0])
2236 for (i = 0; i < 0x30; i++) {
2237 priv->snapshot[i] = kmalloc(0x1000, GFP_ATOMIC);
2238 if (!priv->snapshot[i]) {
2239 IPW_DEBUG_INFO("%s: Error allocating snapshot "
2240 "buffer %d\n", priv->net_dev->name, i);
2242 kfree(priv->snapshot[--i]);
2243 priv->snapshot[0] = NULL;
2251 static u32 ipw2100_match_buf(struct ipw2100_priv *priv, u8 * in_buf,
2252 size_t len, int mode)
2260 if (mode == SEARCH_SNAPSHOT) {
2261 if (!ipw2100_snapshot_alloc(priv))
2262 mode = SEARCH_DISCARD;
2265 for (ret = SEARCH_FAIL, i = 0; i < 0x30000; i += 4) {
2266 read_nic_dword(priv->net_dev, i, &tmp);
2267 if (mode == SEARCH_SNAPSHOT)
2268 *(u32 *) SNAPSHOT_ADDR(i) = tmp;
2269 if (ret == SEARCH_FAIL) {
2271 for (j = 0; j < 4; j++) {
2280 if ((s - in_buf) == len)
2281 ret = (i + j) - len + 1;
2283 } else if (mode == SEARCH_DISCARD)
2293 * 0) Disconnect the SKB from the firmware (just unmap)
2294 * 1) Pack the ETH header into the SKB
2295 * 2) Pass the SKB to the network stack
2297 * When packet is provided by the firmware, it contains the following:
2300 * . ieee80211_snap_hdr
2302 * The size of the constructed ethernet
2305 #ifdef IPW2100_RX_DEBUG
2306 static u8 packet_data[IPW_RX_NIC_BUFFER_LENGTH];
2309 static void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i)
2311 #ifdef IPW2100_DEBUG_C3
2312 struct ipw2100_status *status = &priv->status_queue.drv[i];
2317 IPW_DEBUG_INFO(": PCI latency error detected at 0x%04zX.\n",
2318 i * sizeof(struct ipw2100_status));
2320 #ifdef IPW2100_DEBUG_C3
2321 /* Halt the fimrware so we can get a good image */
2322 write_register(priv->net_dev, IPW_REG_RESET_REG,
2323 IPW_AUX_HOST_RESET_REG_STOP_MASTER);
2326 udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY);
2327 read_register(priv->net_dev, IPW_REG_RESET_REG, ®);
2329 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
2333 match = ipw2100_match_buf(priv, (u8 *) status,
2334 sizeof(struct ipw2100_status),
2336 if (match < SEARCH_SUCCESS)
2337 IPW_DEBUG_INFO("%s: DMA status match in Firmware at "
2338 "offset 0x%06X, length %d:\n",
2339 priv->net_dev->name, match,
2340 sizeof(struct ipw2100_status));
2342 IPW_DEBUG_INFO("%s: No DMA status match in "
2343 "Firmware.\n", priv->net_dev->name);
2345 printk_buf((u8 *) priv->status_queue.drv,
2346 sizeof(struct ipw2100_status) * RX_QUEUE_LENGTH);
2349 priv->fatal_error = IPW2100_ERR_C3_CORRUPTION;
2350 priv->ieee->stats.rx_errors++;
2351 schedule_reset(priv);
2354 static void isr_rx(struct ipw2100_priv *priv, int i,
2355 struct ieee80211_rx_stats *stats)
2357 struct ipw2100_status *status = &priv->status_queue.drv[i];
2358 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
2360 IPW_DEBUG_RX("Handler...\n");
2362 if (unlikely(status->frame_size > skb_tailroom(packet->skb))) {
2363 IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!"
2365 priv->net_dev->name,
2366 status->frame_size, skb_tailroom(packet->skb));
2367 priv->ieee->stats.rx_errors++;
2371 if (unlikely(!netif_running(priv->net_dev))) {
2372 priv->ieee->stats.rx_errors++;
2373 priv->wstats.discard.misc++;
2374 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
2378 if (unlikely(priv->ieee->iw_mode != IW_MODE_MONITOR &&
2379 !(priv->status & STATUS_ASSOCIATED))) {
2380 IPW_DEBUG_DROP("Dropping packet while not associated.\n");
2381 priv->wstats.discard.misc++;
2385 pci_unmap_single(priv->pci_dev,
2387 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE);
2389 skb_put(packet->skb, status->frame_size);
2391 #ifdef IPW2100_RX_DEBUG
2392 /* Make a copy of the frame so we can dump it to the logs if
2393 * ieee80211_rx fails */
2394 skb_copy_from_linear_data(packet->skb, packet_data,
2395 min_t(u32, status->frame_size,
2396 IPW_RX_NIC_BUFFER_LENGTH));
2399 if (!ieee80211_rx(priv->ieee, packet->skb, stats)) {
2400 #ifdef IPW2100_RX_DEBUG
2401 IPW_DEBUG_DROP("%s: Non consumed packet:\n",
2402 priv->net_dev->name);
2403 printk_buf(IPW_DL_DROP, packet_data, status->frame_size);
2405 priv->ieee->stats.rx_errors++;
2407 /* ieee80211_rx failed, so it didn't free the SKB */
2408 dev_kfree_skb_any(packet->skb);
2412 /* We need to allocate a new SKB and attach it to the RDB. */
2413 if (unlikely(ipw2100_alloc_skb(priv, packet))) {
2414 printk(KERN_WARNING DRV_NAME ": "
2415 "%s: Unable to allocate SKB onto RBD ring - disabling "
2416 "adapter.\n", priv->net_dev->name);
2417 /* TODO: schedule adapter shutdown */
2418 IPW_DEBUG_INFO("TODO: Shutdown adapter...\n");
2421 /* Update the RDB entry */
2422 priv->rx_queue.drv[i].host_addr = packet->dma_addr;
2425 #ifdef CONFIG_IPW2100_MONITOR
2427 static void isr_rx_monitor(struct ipw2100_priv *priv, int i,
2428 struct ieee80211_rx_stats *stats)
2430 struct ipw2100_status *status = &priv->status_queue.drv[i];
2431 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
2433 /* Magic struct that slots into the radiotap header -- no reason
2434 * to build this manually element by element, we can write it much
2435 * more efficiently than we can parse it. ORDER MATTERS HERE */
2437 struct ieee80211_radiotap_header rt_hdr;
2438 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
2441 IPW_DEBUG_RX("Handler...\n");
2443 if (unlikely(status->frame_size > skb_tailroom(packet->skb) -
2444 sizeof(struct ipw_rt_hdr))) {
2445 IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!"
2447 priv->net_dev->name,
2449 skb_tailroom(packet->skb));
2450 priv->ieee->stats.rx_errors++;
2454 if (unlikely(!netif_running(priv->net_dev))) {
2455 priv->ieee->stats.rx_errors++;
2456 priv->wstats.discard.misc++;
2457 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
2461 if (unlikely(priv->config & CFG_CRC_CHECK &&
2462 status->flags & IPW_STATUS_FLAG_CRC_ERROR)) {
2463 IPW_DEBUG_RX("CRC error in packet. Dropping.\n");
2464 priv->ieee->stats.rx_errors++;
2468 pci_unmap_single(priv->pci_dev, packet->dma_addr,
2469 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE);
2470 memmove(packet->skb->data + sizeof(struct ipw_rt_hdr),
2471 packet->skb->data, status->frame_size);
2473 ipw_rt = (struct ipw_rt_hdr *) packet->skb->data;
2475 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
2476 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
2477 ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr); /* total hdr+data */
2479 ipw_rt->rt_hdr.it_present = 1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL;
2481 ipw_rt->rt_dbmsignal = status->rssi + IPW2100_RSSI_TO_DBM;
2483 skb_put(packet->skb, status->frame_size + sizeof(struct ipw_rt_hdr));
2485 if (!ieee80211_rx(priv->ieee, packet->skb, stats)) {
2486 priv->ieee->stats.rx_errors++;
2488 /* ieee80211_rx failed, so it didn't free the SKB */
2489 dev_kfree_skb_any(packet->skb);
2493 /* We need to allocate a new SKB and attach it to the RDB. */
2494 if (unlikely(ipw2100_alloc_skb(priv, packet))) {
2496 "%s: Unable to allocate SKB onto RBD ring - disabling "
2497 "adapter.\n", priv->net_dev->name);
2498 /* TODO: schedule adapter shutdown */
2499 IPW_DEBUG_INFO("TODO: Shutdown adapter...\n");
2502 /* Update the RDB entry */
2503 priv->rx_queue.drv[i].host_addr = packet->dma_addr;
2508 static int ipw2100_corruption_check(struct ipw2100_priv *priv, int i)
2510 struct ipw2100_status *status = &priv->status_queue.drv[i];
2511 struct ipw2100_rx *u = priv->rx_buffers[i].rxp;
2512 u16 frame_type = status->status_fields & STATUS_TYPE_MASK;
2514 switch (frame_type) {
2515 case COMMAND_STATUS_VAL:
2516 return (status->frame_size != sizeof(u->rx_data.command));
2517 case STATUS_CHANGE_VAL:
2518 return (status->frame_size != sizeof(u->rx_data.status));
2519 case HOST_NOTIFICATION_VAL:
2520 return (status->frame_size < sizeof(u->rx_data.notification));
2521 case P80211_DATA_VAL:
2522 case P8023_DATA_VAL:
2523 #ifdef CONFIG_IPW2100_MONITOR
2526 switch (WLAN_FC_GET_TYPE(u->rx_data.header.frame_ctl)) {
2527 case IEEE80211_FTYPE_MGMT:
2528 case IEEE80211_FTYPE_CTL:
2530 case IEEE80211_FTYPE_DATA:
2531 return (status->frame_size >
2532 IPW_MAX_802_11_PAYLOAD_LENGTH);
2541 * ipw2100 interrupts are disabled at this point, and the ISR
2542 * is the only code that calls this method. So, we do not need
2543 * to play with any locks.
2545 * RX Queue works as follows:
2547 * Read index - firmware places packet in entry identified by the
2548 * Read index and advances Read index. In this manner,
2549 * Read index will always point to the next packet to
2550 * be filled--but not yet valid.
2552 * Write index - driver fills this entry with an unused RBD entry.
2553 * This entry has not filled by the firmware yet.
2555 * In between the W and R indexes are the RBDs that have been received
2556 * but not yet processed.
2558 * The process of handling packets will start at WRITE + 1 and advance
2559 * until it reaches the READ index.
2561 * The WRITE index is cached in the variable 'priv->rx_queue.next'.
2564 static void __ipw2100_rx_process(struct ipw2100_priv *priv)
2566 struct ipw2100_bd_queue *rxq = &priv->rx_queue;
2567 struct ipw2100_status_queue *sq = &priv->status_queue;
2568 struct ipw2100_rx_packet *packet;
2571 struct ipw2100_rx *u;
2572 struct ieee80211_rx_stats stats = {
2573 .mac_time = jiffies,
2576 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_READ_INDEX, &r);
2577 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, &w);
2579 if (r >= rxq->entries) {
2580 IPW_DEBUG_RX("exit - bad read index\n");
2584 i = (rxq->next + 1) % rxq->entries;
2587 /* IPW_DEBUG_RX("r = %d : w = %d : processing = %d\n",
2588 r, rxq->next, i); */
2590 packet = &priv->rx_buffers[i];
2592 /* Sync the DMA for the STATUS buffer so CPU is sure to get
2593 * the correct values */
2594 pci_dma_sync_single_for_cpu(priv->pci_dev,
2596 sizeof(struct ipw2100_status) * i,
2597 sizeof(struct ipw2100_status),
2598 PCI_DMA_FROMDEVICE);
2600 /* Sync the DMA for the RX buffer so CPU is sure to get
2601 * the correct values */
2602 pci_dma_sync_single_for_cpu(priv->pci_dev, packet->dma_addr,
2603 sizeof(struct ipw2100_rx),
2604 PCI_DMA_FROMDEVICE);
2606 if (unlikely(ipw2100_corruption_check(priv, i))) {
2607 ipw2100_corruption_detected(priv, i);
2612 frame_type = sq->drv[i].status_fields & STATUS_TYPE_MASK;
2613 stats.rssi = sq->drv[i].rssi + IPW2100_RSSI_TO_DBM;
2614 stats.len = sq->drv[i].frame_size;
2617 if (stats.rssi != 0)
2618 stats.mask |= IEEE80211_STATMASK_RSSI;
2619 stats.freq = IEEE80211_24GHZ_BAND;
2621 IPW_DEBUG_RX("%s: '%s' frame type received (%d).\n",
2622 priv->net_dev->name, frame_types[frame_type],
2625 switch (frame_type) {
2626 case COMMAND_STATUS_VAL:
2627 /* Reset Rx watchdog */
2628 isr_rx_complete_command(priv, &u->rx_data.command);
2631 case STATUS_CHANGE_VAL:
2632 isr_status_change(priv, u->rx_data.status);
2635 case P80211_DATA_VAL:
2636 case P8023_DATA_VAL:
2637 #ifdef CONFIG_IPW2100_MONITOR
2638 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
2639 isr_rx_monitor(priv, i, &stats);
2643 if (stats.len < sizeof(struct ieee80211_hdr_3addr))
2645 switch (WLAN_FC_GET_TYPE(u->rx_data.header.frame_ctl)) {
2646 case IEEE80211_FTYPE_MGMT:
2647 ieee80211_rx_mgt(priv->ieee,
2648 &u->rx_data.header, &stats);
2651 case IEEE80211_FTYPE_CTL:
2654 case IEEE80211_FTYPE_DATA:
2655 isr_rx(priv, i, &stats);
2663 /* clear status field associated with this RBD */
2664 rxq->drv[i].status.info.field = 0;
2666 i = (i + 1) % rxq->entries;
2670 /* backtrack one entry, wrapping to end if at 0 */
2671 rxq->next = (i ? i : rxq->entries) - 1;
2673 write_register(priv->net_dev,
2674 IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, rxq->next);
2679 * __ipw2100_tx_process
2681 * This routine will determine whether the next packet on
2682 * the fw_pend_list has been processed by the firmware yet.
2684 * If not, then it does nothing and returns.
2686 * If so, then it removes the item from the fw_pend_list, frees
2687 * any associated storage, and places the item back on the
2688 * free list of its source (either msg_free_list or tx_free_list)
2690 * TX Queue works as follows:
2692 * Read index - points to the next TBD that the firmware will
2693 * process. The firmware will read the data, and once
2694 * done processing, it will advance the Read index.
2696 * Write index - driver fills this entry with an constructed TBD
2697 * entry. The Write index is not advanced until the
2698 * packet has been configured.
2700 * In between the W and R indexes are the TBDs that have NOT been
2701 * processed. Lagging behind the R index are packets that have
2702 * been processed but have not been freed by the driver.
2704 * In order to free old storage, an internal index will be maintained
2705 * that points to the next packet to be freed. When all used
2706 * packets have been freed, the oldest index will be the same as the
2707 * firmware's read index.
2709 * The OLDEST index is cached in the variable 'priv->tx_queue.oldest'
2711 * Because the TBD structure can not contain arbitrary data, the
2712 * driver must keep an internal queue of cached allocations such that
2713 * it can put that data back into the tx_free_list and msg_free_list
2714 * for use by future command and data packets.
2717 static int __ipw2100_tx_process(struct ipw2100_priv *priv)
2719 struct ipw2100_bd_queue *txq = &priv->tx_queue;
2720 struct ipw2100_bd *tbd;
2721 struct list_head *element;
2722 struct ipw2100_tx_packet *packet;
2723 int descriptors_used;
2725 u32 r, w, frag_num = 0;
2727 if (list_empty(&priv->fw_pend_list))
2730 element = priv->fw_pend_list.next;
2732 packet = list_entry(element, struct ipw2100_tx_packet, list);
2733 tbd = &txq->drv[packet->index];
2735 /* Determine how many TBD entries must be finished... */
2736 switch (packet->type) {
2738 /* COMMAND uses only one slot; don't advance */
2739 descriptors_used = 1;
2744 /* DATA uses two slots; advance and loop position. */
2745 descriptors_used = tbd->num_fragments;
2746 frag_num = tbd->num_fragments - 1;
2747 e = txq->oldest + frag_num;
2752 printk(KERN_WARNING DRV_NAME ": %s: Bad fw_pend_list entry!\n",
2753 priv->net_dev->name);
2757 /* if the last TBD is not done by NIC yet, then packet is
2758 * not ready to be released.
2761 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX,
2763 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
2766 printk(KERN_WARNING DRV_NAME ": %s: write index mismatch\n",
2767 priv->net_dev->name);
2770 * txq->next is the index of the last packet written txq->oldest is
2771 * the index of the r is the index of the next packet to be read by
2776 * Quick graphic to help you visualize the following
2777 * if / else statement
2779 * ===>| s---->|===============
2781 * | a | b | c | d | e | f | g | h | i | j | k | l
2785 * w - updated by driver
2786 * r - updated by firmware
2787 * s - start of oldest BD entry (txq->oldest)
2788 * e - end of oldest BD entry
2791 if (!((r <= w && (e < r || e >= w)) || (e < r && e >= w))) {
2792 IPW_DEBUG_TX("exit - no processed packets ready to release.\n");
2797 DEC_STAT(&priv->fw_pend_stat);
2799 #ifdef CONFIG_IPW2100_DEBUG
2801 int i = txq->oldest;
2802 IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i,
2804 (u32) (txq->nic + i * sizeof(struct ipw2100_bd)),
2805 txq->drv[i].host_addr, txq->drv[i].buf_length);
2807 if (packet->type == DATA) {
2808 i = (i + 1) % txq->entries;
2810 IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i,
2812 (u32) (txq->nic + i *
2813 sizeof(struct ipw2100_bd)),
2814 (u32) txq->drv[i].host_addr,
2815 txq->drv[i].buf_length);
2820 switch (packet->type) {
2822 if (txq->drv[txq->oldest].status.info.fields.txType != 0)
2823 printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch. "
2824 "Expecting DATA TBD but pulled "
2825 "something else: ids %d=%d.\n",
2826 priv->net_dev->name, txq->oldest, packet->index);
2828 /* DATA packet; we have to unmap and free the SKB */
2829 for (i = 0; i < frag_num; i++) {
2830 tbd = &txq->drv[(packet->index + 1 + i) % txq->entries];
2832 IPW_DEBUG_TX("TX%d P=%08x L=%d\n",
2833 (packet->index + 1 + i) % txq->entries,
2834 tbd->host_addr, tbd->buf_length);
2836 pci_unmap_single(priv->pci_dev,
2838 tbd->buf_length, PCI_DMA_TODEVICE);
2841 ieee80211_txb_free(packet->info.d_struct.txb);
2842 packet->info.d_struct.txb = NULL;
2844 list_add_tail(element, &priv->tx_free_list);
2845 INC_STAT(&priv->tx_free_stat);
2847 /* We have a free slot in the Tx queue, so wake up the
2848 * transmit layer if it is stopped. */
2849 if (priv->status & STATUS_ASSOCIATED)
2850 netif_wake_queue(priv->net_dev);
2852 /* A packet was processed by the hardware, so update the
2854 priv->net_dev->trans_start = jiffies;
2859 if (txq->drv[txq->oldest].status.info.fields.txType != 1)
2860 printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch. "
2861 "Expecting COMMAND TBD but pulled "
2862 "something else: ids %d=%d.\n",
2863 priv->net_dev->name, txq->oldest, packet->index);
2865 #ifdef CONFIG_IPW2100_DEBUG
2866 if (packet->info.c_struct.cmd->host_command_reg <
2867 ARRAY_SIZE(command_types))
2868 IPW_DEBUG_TX("Command '%s (%d)' processed: %d.\n",
2869 command_types[packet->info.c_struct.cmd->
2871 packet->info.c_struct.cmd->
2873 packet->info.c_struct.cmd->cmd_status_reg);
2876 list_add_tail(element, &priv->msg_free_list);
2877 INC_STAT(&priv->msg_free_stat);
2881 /* advance oldest used TBD pointer to start of next entry */
2882 txq->oldest = (e + 1) % txq->entries;
2883 /* increase available TBDs number */
2884 txq->available += descriptors_used;
2885 SET_STAT(&priv->txq_stat, txq->available);
2887 IPW_DEBUG_TX("packet latency (send to process) %ld jiffies\n",
2888 jiffies - packet->jiffy_start);
2890 return (!list_empty(&priv->fw_pend_list));
2893 static inline void __ipw2100_tx_complete(struct ipw2100_priv *priv)
2897 while (__ipw2100_tx_process(priv) && i < 200)
2901 printk(KERN_WARNING DRV_NAME ": "
2902 "%s: Driver is running slow (%d iters).\n",
2903 priv->net_dev->name, i);
2907 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv)
2909 struct list_head *element;
2910 struct ipw2100_tx_packet *packet;
2911 struct ipw2100_bd_queue *txq = &priv->tx_queue;
2912 struct ipw2100_bd *tbd;
2913 int next = txq->next;
2915 while (!list_empty(&priv->msg_pend_list)) {
2916 /* if there isn't enough space in TBD queue, then
2917 * don't stuff a new one in.
2918 * NOTE: 3 are needed as a command will take one,
2919 * and there is a minimum of 2 that must be
2920 * maintained between the r and w indexes
2922 if (txq->available <= 3) {
2923 IPW_DEBUG_TX("no room in tx_queue\n");
2927 element = priv->msg_pend_list.next;
2929 DEC_STAT(&priv->msg_pend_stat);
2931 packet = list_entry(element, struct ipw2100_tx_packet, list);
2933 IPW_DEBUG_TX("using TBD at virt=%p, phys=%p\n",
2934 &txq->drv[txq->next],
2935 (void *)(txq->nic + txq->next *
2936 sizeof(struct ipw2100_bd)));
2938 packet->index = txq->next;
2940 tbd = &txq->drv[txq->next];
2942 /* initialize TBD */
2943 tbd->host_addr = packet->info.c_struct.cmd_phys;
2944 tbd->buf_length = sizeof(struct ipw2100_cmd_header);
2945 /* not marking number of fragments causes problems
2946 * with f/w debug version */
2947 tbd->num_fragments = 1;
2948 tbd->status.info.field =
2949 IPW_BD_STATUS_TX_FRAME_COMMAND |
2950 IPW_BD_STATUS_TX_INTERRUPT_ENABLE;
2952 /* update TBD queue counters */
2954 txq->next %= txq->entries;
2956 DEC_STAT(&priv->txq_stat);
2958 list_add_tail(element, &priv->fw_pend_list);
2959 INC_STAT(&priv->fw_pend_stat);
2962 if (txq->next != next) {
2963 /* kick off the DMA by notifying firmware the
2964 * write index has moved; make sure TBD stores are sync'd */
2966 write_register(priv->net_dev,
2967 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
2973 * ipw2100_tx_send_data
2976 static void ipw2100_tx_send_data(struct ipw2100_priv *priv)
2978 struct list_head *element;
2979 struct ipw2100_tx_packet *packet;
2980 struct ipw2100_bd_queue *txq = &priv->tx_queue;
2981 struct ipw2100_bd *tbd;
2982 int next = txq->next;
2984 struct ipw2100_data_header *ipw_hdr;
2985 struct ieee80211_hdr_3addr *hdr;
2987 while (!list_empty(&priv->tx_pend_list)) {
2988 /* if there isn't enough space in TBD queue, then
2989 * don't stuff a new one in.
2990 * NOTE: 4 are needed as a data will take two,
2991 * and there is a minimum of 2 that must be
2992 * maintained between the r and w indexes
2994 element = priv->tx_pend_list.next;
2995 packet = list_entry(element, struct ipw2100_tx_packet, list);
2997 if (unlikely(1 + packet->info.d_struct.txb->nr_frags >
2999 /* TODO: Support merging buffers if more than
3000 * IPW_MAX_BDS are used */
3001 IPW_DEBUG_INFO("%s: Maximum BD theshold exceeded. "
3002 "Increase fragmentation level.\n",
3003 priv->net_dev->name);
3006 if (txq->available <= 3 + packet->info.d_struct.txb->nr_frags) {
3007 IPW_DEBUG_TX("no room in tx_queue\n");
3012 DEC_STAT(&priv->tx_pend_stat);
3014 tbd = &txq->drv[txq->next];
3016 packet->index = txq->next;
3018 ipw_hdr = packet->info.d_struct.data;
3019 hdr = (struct ieee80211_hdr_3addr *)packet->info.d_struct.txb->
3022 if (priv->ieee->iw_mode == IW_MODE_INFRA) {
3023 /* To DS: Addr1 = BSSID, Addr2 = SA,
3025 memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN);
3026 memcpy(ipw_hdr->dst_addr, hdr->addr3, ETH_ALEN);
3027 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
3028 /* not From/To DS: Addr1 = DA, Addr2 = SA,
3030 memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN);
3031 memcpy(ipw_hdr->dst_addr, hdr->addr1, ETH_ALEN);
3034 ipw_hdr->host_command_reg = SEND;
3035 ipw_hdr->host_command_reg1 = 0;
3037 /* For now we only support host based encryption */
3038 ipw_hdr->needs_encryption = 0;
3039 ipw_hdr->encrypted = packet->info.d_struct.txb->encrypted;
3040 if (packet->info.d_struct.txb->nr_frags > 1)
3041 ipw_hdr->fragment_size =
3042 packet->info.d_struct.txb->frag_size -
3043 IEEE80211_3ADDR_LEN;
3045 ipw_hdr->fragment_size = 0;
3047 tbd->host_addr = packet->info.d_struct.data_phys;
3048 tbd->buf_length = sizeof(struct ipw2100_data_header);
3049 tbd->num_fragments = 1 + packet->info.d_struct.txb->nr_frags;
3050 tbd->status.info.field =
3051 IPW_BD_STATUS_TX_FRAME_802_3 |
3052 IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT;
3054 txq->next %= txq->entries;
3056 IPW_DEBUG_TX("data header tbd TX%d P=%08x L=%d\n",
3057 packet->index, tbd->host_addr, tbd->buf_length);
3058 #ifdef CONFIG_IPW2100_DEBUG
3059 if (packet->info.d_struct.txb->nr_frags > 1)
3060 IPW_DEBUG_FRAG("fragment Tx: %d frames\n",
3061 packet->info.d_struct.txb->nr_frags);
3064 for (i = 0; i < packet->info.d_struct.txb->nr_frags; i++) {
3065 tbd = &txq->drv[txq->next];
3066 if (i == packet->info.d_struct.txb->nr_frags - 1)
3067 tbd->status.info.field =
3068 IPW_BD_STATUS_TX_FRAME_802_3 |
3069 IPW_BD_STATUS_TX_INTERRUPT_ENABLE;
3071 tbd->status.info.field =
3072 IPW_BD_STATUS_TX_FRAME_802_3 |
3073 IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT;
3075 tbd->buf_length = packet->info.d_struct.txb->
3076 fragments[i]->len - IEEE80211_3ADDR_LEN;
3078 tbd->host_addr = pci_map_single(priv->pci_dev,
3079 packet->info.d_struct.
3082 IEEE80211_3ADDR_LEN,
3086 IPW_DEBUG_TX("data frag tbd TX%d P=%08x L=%d\n",
3087 txq->next, tbd->host_addr,
3090 pci_dma_sync_single_for_device(priv->pci_dev,
3096 txq->next %= txq->entries;
3099 txq->available -= 1 + packet->info.d_struct.txb->nr_frags;
3100 SET_STAT(&priv->txq_stat, txq->available);
3102 list_add_tail(element, &priv->fw_pend_list);
3103 INC_STAT(&priv->fw_pend_stat);
3106 if (txq->next != next) {
3107 /* kick off the DMA by notifying firmware the
3108 * write index has moved; make sure TBD stores are sync'd */
3109 write_register(priv->net_dev,
3110 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
3116 static void ipw2100_irq_tasklet(struct ipw2100_priv *priv)
3118 struct net_device *dev = priv->net_dev;
3119 unsigned long flags;
3122 spin_lock_irqsave(&priv->low_lock, flags);
3123 ipw2100_disable_interrupts(priv);
3125 read_register(dev, IPW_REG_INTA, &inta);
3127 IPW_DEBUG_ISR("enter - INTA: 0x%08lX\n",
3128 (unsigned long)inta & IPW_INTERRUPT_MASK);
3133 /* We do not loop and keep polling for more interrupts as this
3134 * is frowned upon and doesn't play nicely with other potentially
3136 IPW_DEBUG_ISR("INTA: 0x%08lX\n",
3137 (unsigned long)inta & IPW_INTERRUPT_MASK);
3139 if (inta & IPW2100_INTA_FATAL_ERROR) {
3140 printk(KERN_WARNING DRV_NAME
3141 ": Fatal interrupt. Scheduling firmware restart.\n");
3143 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FATAL_ERROR);
3145 read_nic_dword(dev, IPW_NIC_FATAL_ERROR, &priv->fatal_error);
3146 IPW_DEBUG_INFO("%s: Fatal error value: 0x%08X\n",
3147 priv->net_dev->name, priv->fatal_error);
3149 read_nic_dword(dev, IPW_ERROR_ADDR(priv->fatal_error), &tmp);
3150 IPW_DEBUG_INFO("%s: Fatal error address value: 0x%08X\n",
3151 priv->net_dev->name, tmp);
3153 /* Wake up any sleeping jobs */
3154 schedule_reset(priv);
3157 if (inta & IPW2100_INTA_PARITY_ERROR) {
3158 printk(KERN_ERR DRV_NAME
3159 ": ***** PARITY ERROR INTERRUPT !!!! \n");
3161 write_register(dev, IPW_REG_INTA, IPW2100_INTA_PARITY_ERROR);
3164 if (inta & IPW2100_INTA_RX_TRANSFER) {
3165 IPW_DEBUG_ISR("RX interrupt\n");
3167 priv->rx_interrupts++;
3169 write_register(dev, IPW_REG_INTA, IPW2100_INTA_RX_TRANSFER);
3171 __ipw2100_rx_process(priv);
3172 __ipw2100_tx_complete(priv);
3175 if (inta & IPW2100_INTA_TX_TRANSFER) {
3176 IPW_DEBUG_ISR("TX interrupt\n");
3178 priv->tx_interrupts++;
3180 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_TRANSFER);
3182 __ipw2100_tx_complete(priv);
3183 ipw2100_tx_send_commands(priv);
3184 ipw2100_tx_send_data(priv);
3187 if (inta & IPW2100_INTA_TX_COMPLETE) {
3188 IPW_DEBUG_ISR("TX complete\n");
3190 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_COMPLETE);
3192 __ipw2100_tx_complete(priv);
3195 if (inta & IPW2100_INTA_EVENT_INTERRUPT) {
3196 /* ipw2100_handle_event(dev); */
3198 write_register(dev, IPW_REG_INTA, IPW2100_INTA_EVENT_INTERRUPT);
3201 if (inta & IPW2100_INTA_FW_INIT_DONE) {
3202 IPW_DEBUG_ISR("FW init done interrupt\n");
3205 read_register(dev, IPW_REG_INTA, &tmp);
3206 if (tmp & (IPW2100_INTA_FATAL_ERROR |
3207 IPW2100_INTA_PARITY_ERROR)) {
3208 write_register(dev, IPW_REG_INTA,
3209 IPW2100_INTA_FATAL_ERROR |
3210 IPW2100_INTA_PARITY_ERROR);
3213 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FW_INIT_DONE);
3216 if (inta & IPW2100_INTA_STATUS_CHANGE) {
3217 IPW_DEBUG_ISR("Status change interrupt\n");
3219 write_register(dev, IPW_REG_INTA, IPW2100_INTA_STATUS_CHANGE);
3222 if (inta & IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE) {
3223 IPW_DEBUG_ISR("slave host mode interrupt\n");
3225 write_register(dev, IPW_REG_INTA,
3226 IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE);
3230 ipw2100_enable_interrupts(priv);
3232 spin_unlock_irqrestore(&priv->low_lock, flags);
3234 IPW_DEBUG_ISR("exit\n");
3237 static irqreturn_t ipw2100_interrupt(int irq, void *data)
3239 struct ipw2100_priv *priv = data;
3240 u32 inta, inta_mask;
3245 spin_lock(&priv->low_lock);
3247 /* We check to see if we should be ignoring interrupts before
3248 * we touch the hardware. During ucode load if we try and handle
3249 * an interrupt we can cause keyboard problems as well as cause
3250 * the ucode to fail to initialize */
3251 if (!(priv->status & STATUS_INT_ENABLED)) {
3256 read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask);
3257 read_register(priv->net_dev, IPW_REG_INTA, &inta);
3259 if (inta == 0xFFFFFFFF) {
3260 /* Hardware disappeared */
3261 printk(KERN_WARNING DRV_NAME ": IRQ INTA == 0xFFFFFFFF\n");
3265 inta &= IPW_INTERRUPT_MASK;
3267 if (!(inta & inta_mask)) {
3268 /* Shared interrupt */
3272 /* We disable the hardware interrupt here just to prevent unneeded
3273 * calls to be made. We disable this again within the actual
3274 * work tasklet, so if another part of the code re-enables the
3275 * interrupt, that is fine */
3276 ipw2100_disable_interrupts(priv);
3278 tasklet_schedule(&priv->irq_tasklet);
3279 spin_unlock(&priv->low_lock);
3283 spin_unlock(&priv->low_lock);
3287 static int ipw2100_tx(struct ieee80211_txb *txb, struct net_device *dev,
3290 struct ipw2100_priv *priv = ieee80211_priv(dev);
3291 struct list_head *element;
3292 struct ipw2100_tx_packet *packet;
3293 unsigned long flags;
3295 spin_lock_irqsave(&priv->low_lock, flags);
3297 if (!(priv->status & STATUS_ASSOCIATED)) {
3298 IPW_DEBUG_INFO("Can not transmit when not connected.\n");
3299 priv->ieee->stats.tx_carrier_errors++;
3300 netif_stop_queue(dev);
3304 if (list_empty(&priv->tx_free_list))
3307 element = priv->tx_free_list.next;
3308 packet = list_entry(element, struct ipw2100_tx_packet, list);
3310 packet->info.d_struct.txb = txb;
3312 IPW_DEBUG_TX("Sending fragment (%d bytes):\n", txb->fragments[0]->len);
3313 printk_buf(IPW_DL_TX, txb->fragments[0]->data, txb->fragments[0]->len);
3315 packet->jiffy_start = jiffies;
3318 DEC_STAT(&priv->tx_free_stat);
3320 list_add_tail(element, &priv->tx_pend_list);
3321 INC_STAT(&priv->tx_pend_stat);
3323 ipw2100_tx_send_data(priv);
3325 spin_unlock_irqrestore(&priv->low_lock, flags);
3329 netif_stop_queue(dev);
3330 spin_unlock_irqrestore(&priv->low_lock, flags);
3334 static int ipw2100_msg_allocate(struct ipw2100_priv *priv)
3336 int i, j, err = -EINVAL;
3341 (struct ipw2100_tx_packet *)kmalloc(IPW_COMMAND_POOL_SIZE *
3345 if (!priv->msg_buffers) {
3346 printk(KERN_ERR DRV_NAME ": %s: PCI alloc failed for msg "
3347 "buffers.\n", priv->net_dev->name);
3351 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) {
3352 v = pci_alloc_consistent(priv->pci_dev,
3353 sizeof(struct ipw2100_cmd_header), &p);
3355 printk(KERN_ERR DRV_NAME ": "
3356 "%s: PCI alloc failed for msg "
3357 "buffers.\n", priv->net_dev->name);
3362 memset(v, 0, sizeof(struct ipw2100_cmd_header));
3364 priv->msg_buffers[i].type = COMMAND;
3365 priv->msg_buffers[i].info.c_struct.cmd =
3366 (struct ipw2100_cmd_header *)v;
3367 priv->msg_buffers[i].info.c_struct.cmd_phys = p;
3370 if (i == IPW_COMMAND_POOL_SIZE)
3373 for (j = 0; j < i; j++) {
3374 pci_free_consistent(priv->pci_dev,
3375 sizeof(struct ipw2100_cmd_header),
3376 priv->msg_buffers[j].info.c_struct.cmd,
3377 priv->msg_buffers[j].info.c_struct.
3381 kfree(priv->msg_buffers);
3382 priv->msg_buffers = NULL;
3387 static int ipw2100_msg_initialize(struct ipw2100_priv *priv)
3391 INIT_LIST_HEAD(&priv->msg_free_list);
3392 INIT_LIST_HEAD(&priv->msg_pend_list);
3394 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++)
3395 list_add_tail(&priv->msg_buffers[i].list, &priv->msg_free_list);
3396 SET_STAT(&priv->msg_free_stat, i);
3401 static void ipw2100_msg_free(struct ipw2100_priv *priv)
3405 if (!priv->msg_buffers)
3408 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) {
3409 pci_free_consistent(priv->pci_dev,
3410 sizeof(struct ipw2100_cmd_header),
3411 priv->msg_buffers[i].info.c_struct.cmd,
3412 priv->msg_buffers[i].info.c_struct.
3416 kfree(priv->msg_buffers);
3417 priv->msg_buffers = NULL;
3420 static ssize_t show_pci(struct device *d, struct device_attribute *attr,
3423 struct pci_dev *pci_dev = container_of(d, struct pci_dev, dev);
3428 for (i = 0; i < 16; i++) {
3429 out += sprintf(out, "[%08X] ", i * 16);
3430 for (j = 0; j < 16; j += 4) {
3431 pci_read_config_dword(pci_dev, i * 16 + j, &val);
3432 out += sprintf(out, "%08X ", val);
3434 out += sprintf(out, "\n");
3440 static DEVICE_ATTR(pci, S_IRUGO, show_pci, NULL);
3442 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
3445 struct ipw2100_priv *p = d->driver_data;
3446 return sprintf(buf, "0x%08x\n", (int)p->config);
3449 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
3451 static ssize_t show_status(struct device *d, struct device_attribute *attr,
3454 struct ipw2100_priv *p = d->driver_data;
3455 return sprintf(buf, "0x%08x\n", (int)p->status);
3458 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
3460 static ssize_t show_capability(struct device *d, struct device_attribute *attr,
3463 struct ipw2100_priv *p = d->driver_data;
3464 return sprintf(buf, "0x%08x\n", (int)p->capability);
3467 static DEVICE_ATTR(capability, S_IRUGO, show_capability, NULL);
3469 #define IPW2100_REG(x) { IPW_ ##x, #x }
3470 static const struct {
3474 IPW2100_REG(REG_GP_CNTRL),
3475 IPW2100_REG(REG_GPIO),
3476 IPW2100_REG(REG_INTA),
3477 IPW2100_REG(REG_INTA_MASK), IPW2100_REG(REG_RESET_REG),};
3478 #define IPW2100_NIC(x, s) { x, #x, s }
3479 static const struct {
3484 IPW2100_NIC(IPW2100_CONTROL_REG, 2),
3485 IPW2100_NIC(0x210014, 1), IPW2100_NIC(0x210000, 1),};
3486 #define IPW2100_ORD(x, d) { IPW_ORD_ ##x, #x, d }
3487 static const struct {
3492 IPW2100_ORD(STAT_TX_HOST_REQUESTS, "requested Host Tx's (MSDU)"),
3493 IPW2100_ORD(STAT_TX_HOST_COMPLETE,
3494 "successful Host Tx's (MSDU)"),
3495 IPW2100_ORD(STAT_TX_DIR_DATA,
3496 "successful Directed Tx's (MSDU)"),
3497 IPW2100_ORD(STAT_TX_DIR_DATA1,
3498 "successful Directed Tx's (MSDU) @ 1MB"),
3499 IPW2100_ORD(STAT_TX_DIR_DATA2,
3500 "successful Directed Tx's (MSDU) @ 2MB"),
3501 IPW2100_ORD(STAT_TX_DIR_DATA5_5,
3502 "successful Directed Tx's (MSDU) @ 5_5MB"),
3503 IPW2100_ORD(STAT_TX_DIR_DATA11,
3504 "successful Directed Tx's (MSDU) @ 11MB"),
3505 IPW2100_ORD(STAT_TX_NODIR_DATA1,
3506 "successful Non_Directed Tx's (MSDU) @ 1MB"),
3507 IPW2100_ORD(STAT_TX_NODIR_DATA2,
3508 "successful Non_Directed Tx's (MSDU) @ 2MB"),
3509 IPW2100_ORD(STAT_TX_NODIR_DATA5_5,
3510 "successful Non_Directed Tx's (MSDU) @ 5.5MB"),
3511 IPW2100_ORD(STAT_TX_NODIR_DATA11,
3512 "successful Non_Directed Tx's (MSDU) @ 11MB"),
3513 IPW2100_ORD(STAT_NULL_DATA, "successful NULL data Tx's"),
3514 IPW2100_ORD(STAT_TX_RTS, "successful Tx RTS"),
3515 IPW2100_ORD(STAT_TX_CTS, "successful Tx CTS"),
3516 IPW2100_ORD(STAT_TX_ACK, "successful Tx ACK"),
3517 IPW2100_ORD(STAT_TX_ASSN, "successful Association Tx's"),
3518 IPW2100_ORD(STAT_TX_ASSN_RESP,
3519 "successful Association response Tx's"),
3520 IPW2100_ORD(STAT_TX_REASSN,
3521 "successful Reassociation Tx's"),
3522 IPW2100_ORD(STAT_TX_REASSN_RESP,
3523 "successful Reassociation response Tx's"),
3524 IPW2100_ORD(STAT_TX_PROBE,
3525 "probes successfully transmitted"),
3526 IPW2100_ORD(STAT_TX_PROBE_RESP,
3527 "probe responses successfully transmitted"),
3528 IPW2100_ORD(STAT_TX_BEACON, "tx beacon"),
3529 IPW2100_ORD(STAT_TX_ATIM, "Tx ATIM"),
3530 IPW2100_ORD(STAT_TX_DISASSN,
3531 "successful Disassociation TX"),
3532 IPW2100_ORD(STAT_TX_AUTH, "successful Authentication Tx"),
3533 IPW2100_ORD(STAT_TX_DEAUTH,
3534 "successful Deauthentication TX"),
3535 IPW2100_ORD(STAT_TX_TOTAL_BYTES,
3536 "Total successful Tx data bytes"),
3537 IPW2100_ORD(STAT_TX_RETRIES, "Tx retries"),
3538 IPW2100_ORD(STAT_TX_RETRY1, "Tx retries at 1MBPS"),
3539 IPW2100_ORD(STAT_TX_RETRY2, "Tx retries at 2MBPS"),
3540 IPW2100_ORD(STAT_TX_RETRY5_5, "Tx retries at 5.5MBPS"),
3541 IPW2100_ORD(STAT_TX_RETRY11, "Tx retries at 11MBPS"),
3542 IPW2100_ORD(STAT_TX_FAILURES, "Tx Failures"),
3543 IPW2100_ORD(STAT_TX_MAX_TRIES_IN_HOP,
3544 "times max tries in a hop failed"),
3545 IPW2100_ORD(STAT_TX_DISASSN_FAIL,
3546 "times disassociation failed"),
3547 IPW2100_ORD(STAT_TX_ERR_CTS, "missed/bad CTS frames"),
3548 IPW2100_ORD(STAT_TX_ERR_ACK, "tx err due to acks"),
3549 IPW2100_ORD(STAT_RX_HOST, "packets passed to host"),
3550 IPW2100_ORD(STAT_RX_DIR_DATA, "directed packets"),
3551 IPW2100_ORD(STAT_RX_DIR_DATA1, "directed packets at 1MB"),
3552 IPW2100_ORD(STAT_RX_DIR_DATA2, "directed packets at 2MB"),
3553 IPW2100_ORD(STAT_RX_DIR_DATA5_5,
3554 "directed packets at 5.5MB"),
3555 IPW2100_ORD(STAT_RX_DIR_DATA11, "directed packets at 11MB"),
3556 IPW2100_ORD(STAT_RX_NODIR_DATA, "nondirected packets"),
3557 IPW2100_ORD(STAT_RX_NODIR_DATA1,
3558 "nondirected packets at 1MB"),
3559 IPW2100_ORD(STAT_RX_NODIR_DATA2,
3560 "nondirected packets at 2MB"),
3561 IPW2100_ORD(STAT_RX_NODIR_DATA5_5,
3562 "nondirected packets at 5.5MB"),
3563 IPW2100_ORD(STAT_RX_NODIR_DATA11,
3564 "nondirected packets at 11MB"),
3565 IPW2100_ORD(STAT_RX_NULL_DATA, "null data rx's"),
3566 IPW2100_ORD(STAT_RX_RTS, "Rx RTS"), IPW2100_ORD(STAT_RX_CTS,
3568 IPW2100_ORD(STAT_RX_ACK, "Rx ACK"),
3569 IPW2100_ORD(STAT_RX_CFEND, "Rx CF End"),
3570 IPW2100_ORD(STAT_RX_CFEND_ACK, "Rx CF End + CF Ack"),
3571 IPW2100_ORD(STAT_RX_ASSN, "Association Rx's"),
3572 IPW2100_ORD(STAT_RX_ASSN_RESP, "Association response Rx's"),
3573 IPW2100_ORD(STAT_RX_REASSN, "Reassociation Rx's"),
3574 IPW2100_ORD(STAT_RX_REASSN_RESP,
3575 "Reassociation response Rx's"),
3576 IPW2100_ORD(STAT_RX_PROBE, "probe Rx's"),
3577 IPW2100_ORD(STAT_RX_PROBE_RESP, "probe response Rx's"),
3578 IPW2100_ORD(STAT_RX_BEACON, "Rx beacon"),
3579 IPW2100_ORD(STAT_RX_ATIM, "Rx ATIM"),
3580 IPW2100_ORD(STAT_RX_DISASSN, "disassociation Rx"),
3581 IPW2100_ORD(STAT_RX_AUTH, "authentication Rx"),
3582 IPW2100_ORD(STAT_RX_DEAUTH, "deauthentication Rx"),
3583 IPW2100_ORD(STAT_RX_TOTAL_BYTES,
3584 "Total rx data bytes received"),
3585 IPW2100_ORD(STAT_RX_ERR_CRC, "packets with Rx CRC error"),
3586 IPW2100_ORD(STAT_RX_ERR_CRC1, "Rx CRC errors at 1MB"),
3587 IPW2100_ORD(STAT_RX_ERR_CRC2, "Rx CRC errors at 2MB"),
3588 IPW2100_ORD(STAT_RX_ERR_CRC5_5, "Rx CRC errors at 5.5MB"),
3589 IPW2100_ORD(STAT_RX_ERR_CRC11, "Rx CRC errors at 11MB"),
3590 IPW2100_ORD(STAT_RX_DUPLICATE1,
3591 "duplicate rx packets at 1MB"),
3592 IPW2100_ORD(STAT_RX_DUPLICATE2,
3593 "duplicate rx packets at 2MB"),
3594 IPW2100_ORD(STAT_RX_DUPLICATE5_5,
3595 "duplicate rx packets at 5.5MB"),
3596 IPW2100_ORD(STAT_RX_DUPLICATE11,
3597 "duplicate rx packets at 11MB"),
3598 IPW2100_ORD(STAT_RX_DUPLICATE, "duplicate rx packets"),
3599 IPW2100_ORD(PERS_DB_LOCK, "locking fw permanent db"),
3600 IPW2100_ORD(PERS_DB_SIZE, "size of fw permanent db"),
3601 IPW2100_ORD(PERS_DB_ADDR, "address of fw permanent db"),
3602 IPW2100_ORD(STAT_RX_INVALID_PROTOCOL,
3603 "rx frames with invalid protocol"),
3604 IPW2100_ORD(SYS_BOOT_TIME, "Boot time"),
3605 IPW2100_ORD(STAT_RX_NO_BUFFER,
3606 "rx frames rejected due to no buffer"),
3607 IPW2100_ORD(STAT_RX_MISSING_FRAG,
3608 "rx frames dropped due to missing fragment"),
3609 IPW2100_ORD(STAT_RX_ORPHAN_FRAG,
3610 "rx frames dropped due to non-sequential fragment"),
3611 IPW2100_ORD(STAT_RX_ORPHAN_FRAME,
3612 "rx frames dropped due to unmatched 1st frame"),
3613 IPW2100_ORD(STAT_RX_FRAG_AGEOUT,
3614 "rx frames dropped due to uncompleted frame"),
3615 IPW2100_ORD(STAT_RX_ICV_ERRORS,
3616 "ICV errors during decryption"),
3617 IPW2100_ORD(STAT_PSP_SUSPENSION, "times adapter suspended"),
3618 IPW2100_ORD(STAT_PSP_BCN_TIMEOUT, "beacon timeout"),
3619 IPW2100_ORD(STAT_PSP_POLL_TIMEOUT,
3620 "poll response timeouts"),
3621 IPW2100_ORD(STAT_PSP_NONDIR_TIMEOUT,
3622 "timeouts waiting for last {broad,multi}cast pkt"),
3623 IPW2100_ORD(STAT_PSP_RX_DTIMS, "PSP DTIMs received"),
3624 IPW2100_ORD(STAT_PSP_RX_TIMS, "PSP TIMs received"),
3625 IPW2100_ORD(STAT_PSP_STATION_ID, "PSP Station ID"),
3626 IPW2100_ORD(LAST_ASSN_TIME, "RTC time of last association"),
3627 IPW2100_ORD(STAT_PERCENT_MISSED_BCNS,
3628 "current calculation of % missed beacons"),
3629 IPW2100_ORD(STAT_PERCENT_RETRIES,
3630 "current calculation of % missed tx retries"),
3631 IPW2100_ORD(ASSOCIATED_AP_PTR,
3632 "0 if not associated, else pointer to AP table entry"),
3633 IPW2100_ORD(AVAILABLE_AP_CNT,
3634 "AP's decsribed in the AP table"),
3635 IPW2100_ORD(AP_LIST_PTR, "Ptr to list of available APs"),
3636 IPW2100_ORD(STAT_AP_ASSNS, "associations"),
3637 IPW2100_ORD(STAT_ASSN_FAIL, "association failures"),
3638 IPW2100_ORD(STAT_ASSN_RESP_FAIL,
3639 "failures due to response fail"),
3640 IPW2100_ORD(STAT_FULL_SCANS, "full scans"),
3641 IPW2100_ORD(CARD_DISABLED, "Card Disabled"),
3642 IPW2100_ORD(STAT_ROAM_INHIBIT,
3643 "times roaming was inhibited due to activity"),
3644 IPW2100_ORD(RSSI_AT_ASSN,
3645 "RSSI of associated AP at time of association"),
3646 IPW2100_ORD(STAT_ASSN_CAUSE1,
3647 "reassociation: no probe response or TX on hop"),
3648 IPW2100_ORD(STAT_ASSN_CAUSE2,
3649 "reassociation: poor tx/rx quality"),
3650 IPW2100_ORD(STAT_ASSN_CAUSE3,
3651 "reassociation: tx/rx quality (excessive AP load"),
3652 IPW2100_ORD(STAT_ASSN_CAUSE4,
3653 "reassociation: AP RSSI level"),
3654 IPW2100_ORD(STAT_ASSN_CAUSE5,
3655 "reassociations due to load leveling"),
3656 IPW2100_ORD(STAT_AUTH_FAIL, "times authentication failed"),
3657 IPW2100_ORD(STAT_AUTH_RESP_FAIL,
3658 "times authentication response failed"),
3659 IPW2100_ORD(STATION_TABLE_CNT,
3660 "entries in association table"),
3661 IPW2100_ORD(RSSI_AVG_CURR, "Current avg RSSI"),
3662 IPW2100_ORD(POWER_MGMT_MODE, "Power mode - 0=CAM, 1=PSP"),
3663 IPW2100_ORD(COUNTRY_CODE,
3664 "IEEE country code as recv'd from beacon"),
3665 IPW2100_ORD(COUNTRY_CHANNELS,
3666 "channels suported by country"),
3667 IPW2100_ORD(RESET_CNT, "adapter resets (warm)"),
3668 IPW2100_ORD(BEACON_INTERVAL, "Beacon interval"),
3669 IPW2100_ORD(ANTENNA_DIVERSITY,
3670 "TRUE if antenna diversity is disabled"),
3671 IPW2100_ORD(DTIM_PERIOD, "beacon intervals between DTIMs"),
3672 IPW2100_ORD(OUR_FREQ,
3673 "current radio freq lower digits - channel ID"),
3674 IPW2100_ORD(RTC_TIME, "current RTC time"),
3675 IPW2100_ORD(PORT_TYPE, "operating mode"),
3676 IPW2100_ORD(CURRENT_TX_RATE, "current tx rate"),
3677 IPW2100_ORD(SUPPORTED_RATES, "supported tx rates"),
3678 IPW2100_ORD(ATIM_WINDOW, "current ATIM Window"),
3679 IPW2100_ORD(BASIC_RATES, "basic tx rates"),
3680 IPW2100_ORD(NIC_HIGHEST_RATE, "NIC highest tx rate"),
3681 IPW2100_ORD(AP_HIGHEST_RATE, "AP highest tx rate"),
3682 IPW2100_ORD(CAPABILITIES,
3683 "Management frame capability field"),
3684 IPW2100_ORD(AUTH_TYPE, "Type of authentication"),
3685 IPW2100_ORD(RADIO_TYPE, "Adapter card platform type"),
3686 IPW2100_ORD(RTS_THRESHOLD,
3687 "Min packet length for RTS handshaking"),
3688 IPW2100_ORD(INT_MODE, "International mode"),
3689 IPW2100_ORD(FRAGMENTATION_THRESHOLD,
3690 "protocol frag threshold"),
3691 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_START_ADDRESS,
3692 "EEPROM offset in SRAM"),
3693 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_SIZE,
3694 "EEPROM size in SRAM"),
3695 IPW2100_ORD(EEPROM_SKU_CAPABILITY, "EEPROM SKU Capability"),
3696 IPW2100_ORD(EEPROM_IBSS_11B_CHANNELS,
3697 "EEPROM IBSS 11b channel set"),
3698 IPW2100_ORD(MAC_VERSION, "MAC Version"),
3699 IPW2100_ORD(MAC_REVISION, "MAC Revision"),
3700 IPW2100_ORD(RADIO_VERSION, "Radio Version"),
3701 IPW2100_ORD(NIC_MANF_DATE_TIME, "MANF Date/Time STAMP"),
3702 IPW2100_ORD(UCODE_VERSION, "Ucode Version"),};
3704 static ssize_t show_registers(struct device *d, struct device_attribute *attr,
3708 struct ipw2100_priv *priv = dev_get_drvdata(d);
3709 struct net_device *dev = priv->net_dev;
3713 out += sprintf(out, "%30s [Address ] : Hex\n", "Register");
3715 for (i = 0; i < ARRAY_SIZE(hw_data); i++) {
3716 read_register(dev, hw_data[i].addr, &val);
3717 out += sprintf(out, "%30s [%08X] : %08X\n",
3718 hw_data[i].name, hw_data[i].addr, val);
3724 static DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL);
3726 static ssize_t show_hardware(struct device *d, struct device_attribute *attr,
3729 struct ipw2100_priv *priv = dev_get_drvdata(d);
3730 struct net_device *dev = priv->net_dev;
3734 out += sprintf(out, "%30s [Address ] : Hex\n", "NIC entry");
3736 for (i = 0; i < ARRAY_SIZE(nic_data); i++) {
3741 switch (nic_data[i].size) {
3743 read_nic_byte(dev, nic_data[i].addr, &tmp8);
3744 out += sprintf(out, "%30s [%08X] : %02X\n",
3745 nic_data[i].name, nic_data[i].addr,
3749 read_nic_word(dev, nic_data[i].addr, &tmp16);
3750 out += sprintf(out, "%30s [%08X] : %04X\n",
3751 nic_data[i].name, nic_data[i].addr,
3755 read_nic_dword(dev, nic_data[i].addr, &tmp32);
3756 out += sprintf(out, "%30s [%08X] : %08X\n",
3757 nic_data[i].name, nic_data[i].addr,
3765 static DEVICE_ATTR(hardware, S_IRUGO, show_hardware, NULL);
3767 static ssize_t show_memory(struct device *d, struct device_attribute *attr,
3770 struct ipw2100_priv *priv = dev_get_drvdata(d);
3771 struct net_device *dev = priv->net_dev;
3772 static unsigned long loop = 0;
3778 if (loop >= 0x30000)
3781 /* sysfs provides us PAGE_SIZE buffer */
3782 while (len < PAGE_SIZE - 128 && loop < 0x30000) {
3784 if (priv->snapshot[0])
3785 for (i = 0; i < 4; i++)
3787 *(u32 *) SNAPSHOT_ADDR(loop + i * 4);
3789 for (i = 0; i < 4; i++)
3790 read_nic_dword(dev, loop + i * 4, &buffer[i]);
3793 len += sprintf(buf + len,
3798 ((u8 *) buffer)[0x0],
3799 ((u8 *) buffer)[0x1],
3800 ((u8 *) buffer)[0x2],
3801 ((u8 *) buffer)[0x3],
3802 ((u8 *) buffer)[0x4],
3803 ((u8 *) buffer)[0x5],
3804 ((u8 *) buffer)[0x6],
3805 ((u8 *) buffer)[0x7],
3806 ((u8 *) buffer)[0x8],
3807 ((u8 *) buffer)[0x9],
3808 ((u8 *) buffer)[0xa],
3809 ((u8 *) buffer)[0xb],
3810 ((u8 *) buffer)[0xc],
3811 ((u8 *) buffer)[0xd],
3812 ((u8 *) buffer)[0xe],
3813 ((u8 *) buffer)[0xf]);
3815 len += sprintf(buf + len, "%s\n",
3816 snprint_line(line, sizeof(line),
3817 (u8 *) buffer, 16, loop));
3824 static ssize_t store_memory(struct device *d, struct device_attribute *attr,
3825 const char *buf, size_t count)
3827 struct ipw2100_priv *priv = dev_get_drvdata(d);
3828 struct net_device *dev = priv->net_dev;
3829 const char *p = buf;
3831 (void)dev; /* kill unused-var warning for debug-only code */
3837 (count >= 2 && tolower(p[0]) == 'o' && tolower(p[1]) == 'n')) {
3838 IPW_DEBUG_INFO("%s: Setting memory dump to RAW mode.\n",
3842 } else if (p[0] == '0' || (count >= 2 && tolower(p[0]) == 'o' &&
3843 tolower(p[1]) == 'f')) {
3844 IPW_DEBUG_INFO("%s: Setting memory dump to HEX mode.\n",
3848 } else if (tolower(p[0]) == 'r') {
3849 IPW_DEBUG_INFO("%s: Resetting firmware snapshot.\n", dev->name);
3850 ipw2100_snapshot_free(priv);
3853 IPW_DEBUG_INFO("%s: Usage: 0|on = HEX, 1|off = RAW, "
3854 "reset = clear memory snapshot\n", dev->name);
3859 static DEVICE_ATTR(memory, S_IWUSR | S_IRUGO, show_memory, store_memory);
3861 static ssize_t show_ordinals(struct device *d, struct device_attribute *attr,
3864 struct ipw2100_priv *priv = dev_get_drvdata(d);
3868 static int loop = 0;
3870 if (priv->status & STATUS_RF_KILL_MASK)
3873 if (loop >= ARRAY_SIZE(ord_data))
3876 /* sysfs provides us PAGE_SIZE buffer */
3877 while (len < PAGE_SIZE - 128 && loop < ARRAY_SIZE(ord_data)) {
3878 val_len = sizeof(u32);
3880 if (ipw2100_get_ordinal(priv, ord_data[loop].index, &val,
3882 len += sprintf(buf + len, "[0x%02X] = ERROR %s\n",
3883 ord_data[loop].index,
3884 ord_data[loop].desc);
3886 len += sprintf(buf + len, "[0x%02X] = 0x%08X %s\n",
3887 ord_data[loop].index, val,
3888 ord_data[loop].desc);
3895 static DEVICE_ATTR(ordinals, S_IRUGO, show_ordinals, NULL);
3897 static ssize_t show_stats(struct device *d, struct device_attribute *attr,
3900 struct ipw2100_priv *priv = dev_get_drvdata(d);
3903 out += sprintf(out, "interrupts: %d {tx: %d, rx: %d, other: %d}\n",
3904 priv->interrupts, priv->tx_interrupts,
3905 priv->rx_interrupts, priv->inta_other);
3906 out += sprintf(out, "firmware resets: %d\n", priv->resets);
3907 out += sprintf(out, "firmware hangs: %d\n", priv->hangs);
3908 #ifdef CONFIG_IPW2100_DEBUG
3909 out += sprintf(out, "packet mismatch image: %s\n",
3910 priv->snapshot[0] ? "YES" : "NO");
3916 static DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL);
3918 static int ipw2100_switch_mode(struct ipw2100_priv *priv, u32 mode)
3922 if (mode == priv->ieee->iw_mode)
3925 err = ipw2100_disable_adapter(priv);
3927 printk(KERN_ERR DRV_NAME ": %s: Could not disable adapter %d\n",
3928 priv->net_dev->name, err);
3934 priv->net_dev->type = ARPHRD_ETHER;
3937 priv->net_dev->type = ARPHRD_ETHER;
3939 #ifdef CONFIG_IPW2100_MONITOR
3940 case IW_MODE_MONITOR:
3941 priv->last_mode = priv->ieee->iw_mode;
3942 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
3944 #endif /* CONFIG_IPW2100_MONITOR */
3947 priv->ieee->iw_mode = mode;
3950 /* Indicate ipw2100_download_firmware download firmware
3951 * from disk instead of memory. */
3952 ipw2100_firmware.version = 0;
3955 printk(KERN_INFO "%s: Reseting on mode change.\n", priv->net_dev->name);
3956 priv->reset_backoff = 0;
3957 schedule_reset(priv);
3962 static ssize_t show_internals(struct device *d, struct device_attribute *attr,
3965 struct ipw2100_priv *priv = dev_get_drvdata(d);
3968 #define DUMP_VAR(x,y) len += sprintf(buf + len, # x ": %" y "\n", priv-> x)
3970 if (priv->status & STATUS_ASSOCIATED)
3971 len += sprintf(buf + len, "connected: %lu\n",
3972 get_seconds() - priv->connect_start);
3974 len += sprintf(buf + len, "not connected\n");
3976 DUMP_VAR(ieee->crypt[priv->ieee->tx_keyidx], "p");
3977 DUMP_VAR(status, "08lx");
3978 DUMP_VAR(config, "08lx");
3979 DUMP_VAR(capability, "08lx");
3982 sprintf(buf + len, "last_rtc: %lu\n",
3983 (unsigned long)priv->last_rtc);
3985 DUMP_VAR(fatal_error, "d");
3986 DUMP_VAR(stop_hang_check, "d");
3987 DUMP_VAR(stop_rf_kill, "d");
3988 DUMP_VAR(messages_sent, "d");
3990 DUMP_VAR(tx_pend_stat.value, "d");
3991 DUMP_VAR(tx_pend_stat.hi, "d");
3993 DUMP_VAR(tx_free_stat.value, "d");
3994 DUMP_VAR(tx_free_stat.lo, "d");
3996 DUMP_VAR(msg_free_stat.value, "d");
3997 DUMP_VAR(msg_free_stat.lo, "d");
3999 DUMP_VAR(msg_pend_stat.value, "d");
4000 DUMP_VAR(msg_pend_stat.hi, "d");
4002 DUMP_VAR(fw_pend_stat.value, "d");
4003 DUMP_VAR(fw_pend_stat.hi, "d");
4005 DUMP_VAR(txq_stat.value, "d");
4006 DUMP_VAR(txq_stat.lo, "d");
4008 DUMP_VAR(ieee->scans, "d");
4009 DUMP_VAR(reset_backoff, "d");
4014 static DEVICE_ATTR(internals, S_IRUGO, show_internals, NULL);
4016 static ssize_t show_bssinfo(struct device *d, struct device_attribute *attr,
4019 struct ipw2100_priv *priv = dev_get_drvdata(d);
4020 char essid[IW_ESSID_MAX_SIZE + 1];
4026 DECLARE_MAC_BUF(mac);
4028 if (priv->status & STATUS_RF_KILL_MASK)
4031 memset(essid, 0, sizeof(essid));
4032 memset(bssid, 0, sizeof(bssid));
4034 length = IW_ESSID_MAX_SIZE;
4035 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID, essid, &length);
4037 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4040 length = sizeof(bssid);
4041 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID,
4044 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4047 length = sizeof(u32);
4048 ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &length);
4050 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4053 out += sprintf(out, "ESSID: %s\n", essid);
4054 out += sprintf(out, "BSSID: %s\n", print_mac(mac, bssid));
4055 out += sprintf(out, "Channel: %d\n", chan);
4060 static DEVICE_ATTR(bssinfo, S_IRUGO, show_bssinfo, NULL);
4062 #ifdef CONFIG_IPW2100_DEBUG
4063 static ssize_t show_debug_level(struct device_driver *d, char *buf)
4065 return sprintf(buf, "0x%08X\n", ipw2100_debug_level);
4068 static ssize_t store_debug_level(struct device_driver *d,
4069 const char *buf, size_t count)
4071 char *p = (char *)buf;
4074 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
4076 if (p[0] == 'x' || p[0] == 'X')
4078 val = simple_strtoul(p, &p, 16);
4080 val = simple_strtoul(p, &p, 10);
4082 IPW_DEBUG_INFO(": %s is not in hex or decimal form.\n", buf);
4084 ipw2100_debug_level = val;
4086 return strnlen(buf, count);
4089 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO, show_debug_level,
4091 #endif /* CONFIG_IPW2100_DEBUG */
4093 static ssize_t show_fatal_error(struct device *d,
4094 struct device_attribute *attr, char *buf)
4096 struct ipw2100_priv *priv = dev_get_drvdata(d);
4100 if (priv->fatal_error)
4101 out += sprintf(out, "0x%08X\n", priv->fatal_error);
4103 out += sprintf(out, "0\n");
4105 for (i = 1; i <= IPW2100_ERROR_QUEUE; i++) {
4106 if (!priv->fatal_errors[(priv->fatal_index - i) %
4107 IPW2100_ERROR_QUEUE])
4110 out += sprintf(out, "%d. 0x%08X\n", i,
4111 priv->fatal_errors[(priv->fatal_index - i) %
4112 IPW2100_ERROR_QUEUE]);
4118 static ssize_t store_fatal_error(struct device *d,
4119 struct device_attribute *attr, const char *buf,
4122 struct ipw2100_priv *priv = dev_get_drvdata(d);
4123 schedule_reset(priv);
4127 static DEVICE_ATTR(fatal_error, S_IWUSR | S_IRUGO, show_fatal_error,
4130 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
4133 struct ipw2100_priv *priv = dev_get_drvdata(d);
4134 return sprintf(buf, "%d\n", priv->ieee->scan_age);
4137 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
4138 const char *buf, size_t count)
4140 struct ipw2100_priv *priv = dev_get_drvdata(d);
4141 struct net_device *dev = priv->net_dev;
4142 char buffer[] = "00000000";
4144 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
4148 (void)dev; /* kill unused-var warning for debug-only code */
4150 IPW_DEBUG_INFO("enter\n");
4152 strncpy(buffer, buf, len);
4155 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
4157 if (p[0] == 'x' || p[0] == 'X')
4159 val = simple_strtoul(p, &p, 16);
4161 val = simple_strtoul(p, &p, 10);
4163 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
4165 priv->ieee->scan_age = val;
4166 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
4169 IPW_DEBUG_INFO("exit\n");
4173 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
4175 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
4178 /* 0 - RF kill not enabled
4179 1 - SW based RF kill active (sysfs)
4180 2 - HW based RF kill active
4181 3 - Both HW and SW baed RF kill active */
4182 struct ipw2100_priv *priv = (struct ipw2100_priv *)d->driver_data;
4183 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
4184 (rf_kill_active(priv) ? 0x2 : 0x0);
4185 return sprintf(buf, "%i\n", val);
4188 static int ipw_radio_kill_sw(struct ipw2100_priv *priv, int disable_radio)
4190 if ((disable_radio ? 1 : 0) ==
4191 (priv->status & STATUS_RF_KILL_SW ? 1 : 0))
4194 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
4195 disable_radio ? "OFF" : "ON");
4197 mutex_lock(&priv->action_mutex);
4199 if (disable_radio) {
4200 priv->status |= STATUS_RF_KILL_SW;
4203 priv->status &= ~STATUS_RF_KILL_SW;
4204 if (rf_kill_active(priv)) {
4205 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
4206 "disabled by HW switch\n");
4207 /* Make sure the RF_KILL check timer is running */
4208 priv->stop_rf_kill = 0;
4209 cancel_delayed_work(&priv->rf_kill);
4210 queue_delayed_work(priv->workqueue, &priv->rf_kill,
4213 schedule_reset(priv);
4216 mutex_unlock(&priv->action_mutex);
4220 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
4221 const char *buf, size_t count)
4223 struct ipw2100_priv *priv = dev_get_drvdata(d);
4224 ipw_radio_kill_sw(priv, buf[0] == '1');
4228 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
4230 static struct attribute *ipw2100_sysfs_entries[] = {
4231 &dev_attr_hardware.attr,
4232 &dev_attr_registers.attr,
4233 &dev_attr_ordinals.attr,
4235 &dev_attr_stats.attr,
4236 &dev_attr_internals.attr,
4237 &dev_attr_bssinfo.attr,
4238 &dev_attr_memory.attr,
4239 &dev_attr_scan_age.attr,
4240 &dev_attr_fatal_error.attr,
4241 &dev_attr_rf_kill.attr,
4243 &dev_attr_status.attr,
4244 &dev_attr_capability.attr,
4248 static struct attribute_group ipw2100_attribute_group = {
4249 .attrs = ipw2100_sysfs_entries,
4252 static int status_queue_allocate(struct ipw2100_priv *priv, int entries)
4254 struct ipw2100_status_queue *q = &priv->status_queue;
4256 IPW_DEBUG_INFO("enter\n");
4258 q->size = entries * sizeof(struct ipw2100_status);
4260 (struct ipw2100_status *)pci_alloc_consistent(priv->pci_dev,
4263 IPW_DEBUG_WARNING("Can not allocate status queue.\n");
4267 memset(q->drv, 0, q->size);
4269 IPW_DEBUG_INFO("exit\n");
4274 static void status_queue_free(struct ipw2100_priv *priv)
4276 IPW_DEBUG_INFO("enter\n");
4278 if (priv->status_queue.drv) {
4279 pci_free_consistent(priv->pci_dev, priv->status_queue.size,
4280 priv->status_queue.drv,
4281 priv->status_queue.nic);
4282 priv->status_queue.drv = NULL;
4285 IPW_DEBUG_INFO("exit\n");
4288 static int bd_queue_allocate(struct ipw2100_priv *priv,
4289 struct ipw2100_bd_queue *q, int entries)
4291 IPW_DEBUG_INFO("enter\n");
4293 memset(q, 0, sizeof(struct ipw2100_bd_queue));
4295 q->entries = entries;
4296 q->size = entries * sizeof(struct ipw2100_bd);
4297 q->drv = pci_alloc_consistent(priv->pci_dev, q->size, &q->nic);
4300 ("can't allocate shared memory for buffer descriptors\n");
4303 memset(q->drv, 0, q->size);
4305 IPW_DEBUG_INFO("exit\n");
4310 static void bd_queue_free(struct ipw2100_priv *priv, struct ipw2100_bd_queue *q)
4312 IPW_DEBUG_INFO("enter\n");
4318 pci_free_consistent(priv->pci_dev, q->size, q->drv, q->nic);
4322 IPW_DEBUG_INFO("exit\n");
4325 static void bd_queue_initialize(struct ipw2100_priv *priv,
4326 struct ipw2100_bd_queue *q, u32 base, u32 size,
4329 IPW_DEBUG_INFO("enter\n");
4331 IPW_DEBUG_INFO("initializing bd queue at virt=%p, phys=%08x\n", q->drv,
4334 write_register(priv->net_dev, base, q->nic);
4335 write_register(priv->net_dev, size, q->entries);
4336 write_register(priv->net_dev, r, q->oldest);
4337 write_register(priv->net_dev, w, q->next);
4339 IPW_DEBUG_INFO("exit\n");
4342 static void ipw2100_kill_workqueue(struct ipw2100_priv *priv)
4344 if (priv->workqueue) {
4345 priv->stop_rf_kill = 1;
4346 priv->stop_hang_check = 1;
4347 cancel_delayed_work(&priv->reset_work);
4348 cancel_delayed_work(&priv->security_work);
4349 cancel_delayed_work(&priv->wx_event_work);
4350 cancel_delayed_work(&priv->hang_check);
4351 cancel_delayed_work(&priv->rf_kill);
4352 destroy_workqueue(priv->workqueue);
4353 priv->workqueue = NULL;
4357 static int ipw2100_tx_allocate(struct ipw2100_priv *priv)
4359 int i, j, err = -EINVAL;
4363 IPW_DEBUG_INFO("enter\n");
4365 err = bd_queue_allocate(priv, &priv->tx_queue, TX_QUEUE_LENGTH);
4367 IPW_DEBUG_ERROR("%s: failed bd_queue_allocate\n",
4368 priv->net_dev->name);
4373 (struct ipw2100_tx_packet *)kmalloc(TX_PENDED_QUEUE_LENGTH *
4377 if (!priv->tx_buffers) {
4378 printk(KERN_ERR DRV_NAME
4379 ": %s: alloc failed form tx buffers.\n",
4380 priv->net_dev->name);
4381 bd_queue_free(priv, &priv->tx_queue);
4385 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4386 v = pci_alloc_consistent(priv->pci_dev,
4387 sizeof(struct ipw2100_data_header),
4390 printk(KERN_ERR DRV_NAME
4391 ": %s: PCI alloc failed for tx " "buffers.\n",
4392 priv->net_dev->name);
4397 priv->tx_buffers[i].type = DATA;
4398 priv->tx_buffers[i].info.d_struct.data =
4399 (struct ipw2100_data_header *)v;
4400 priv->tx_buffers[i].info.d_struct.data_phys = p;
4401 priv->tx_buffers[i].info.d_struct.txb = NULL;
4404 if (i == TX_PENDED_QUEUE_LENGTH)
4407 for (j = 0; j < i; j++) {
4408 pci_free_consistent(priv->pci_dev,
4409 sizeof(struct ipw2100_data_header),
4410 priv->tx_buffers[j].info.d_struct.data,
4411 priv->tx_buffers[j].info.d_struct.
4415 kfree(priv->tx_buffers);
4416 priv->tx_buffers = NULL;
4421 static void ipw2100_tx_initialize(struct ipw2100_priv *priv)
4425 IPW_DEBUG_INFO("enter\n");
4428 * reinitialize packet info lists
4430 INIT_LIST_HEAD(&priv->fw_pend_list);
4431 INIT_STAT(&priv->fw_pend_stat);
4434 * reinitialize lists
4436 INIT_LIST_HEAD(&priv->tx_pend_list);
4437 INIT_LIST_HEAD(&priv->tx_free_list);
4438 INIT_STAT(&priv->tx_pend_stat);
4439 INIT_STAT(&priv->tx_free_stat);
4441 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4442 /* We simply drop any SKBs that have been queued for
4444 if (priv->tx_buffers[i].info.d_struct.txb) {
4445 ieee80211_txb_free(priv->tx_buffers[i].info.d_struct.
4447 priv->tx_buffers[i].info.d_struct.txb = NULL;
4450 list_add_tail(&priv->tx_buffers[i].list, &priv->tx_free_list);
4453 SET_STAT(&priv->tx_free_stat, i);
4455 priv->tx_queue.oldest = 0;
4456 priv->tx_queue.available = priv->tx_queue.entries;
4457 priv->tx_queue.next = 0;
4458 INIT_STAT(&priv->txq_stat);
4459 SET_STAT(&priv->txq_stat, priv->tx_queue.available);
4461 bd_queue_initialize(priv, &priv->tx_queue,
4462 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_BASE,
4463 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_SIZE,
4464 IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX,
4465 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX);
4467 IPW_DEBUG_INFO("exit\n");
4471 static void ipw2100_tx_free(struct ipw2100_priv *priv)
4475 IPW_DEBUG_INFO("enter\n");
4477 bd_queue_free(priv, &priv->tx_queue);
4479 if (!priv->tx_buffers)
4482 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4483 if (priv->tx_buffers[i].info.d_struct.txb) {
4484 ieee80211_txb_free(priv->tx_buffers[i].info.d_struct.
4486 priv->tx_buffers[i].info.d_struct.txb = NULL;
4488 if (priv->tx_buffers[i].info.d_struct.data)
4489 pci_free_consistent(priv->pci_dev,
4490 sizeof(struct ipw2100_data_header),
4491 priv->tx_buffers[i].info.d_struct.
4493 priv->tx_buffers[i].info.d_struct.
4497 kfree(priv->tx_buffers);
4498 priv->tx_buffers = NULL;
4500 IPW_DEBUG_INFO("exit\n");
4503 static int ipw2100_rx_allocate(struct ipw2100_priv *priv)
4505 int i, j, err = -EINVAL;
4507 IPW_DEBUG_INFO("enter\n");
4509 err = bd_queue_allocate(priv, &priv->rx_queue, RX_QUEUE_LENGTH);
4511 IPW_DEBUG_INFO("failed bd_queue_allocate\n");
4515 err = status_queue_allocate(priv, RX_QUEUE_LENGTH);
4517 IPW_DEBUG_INFO("failed status_queue_allocate\n");
4518 bd_queue_free(priv, &priv->rx_queue);
4525 priv->rx_buffers = (struct ipw2100_rx_packet *)
4526 kmalloc(RX_QUEUE_LENGTH * sizeof(struct ipw2100_rx_packet),
4528 if (!priv->rx_buffers) {
4529 IPW_DEBUG_INFO("can't allocate rx packet buffer table\n");
4531 bd_queue_free(priv, &priv->rx_queue);
4533 status_queue_free(priv);
4538 for (i = 0; i < RX_QUEUE_LENGTH; i++) {
4539 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
4541 err = ipw2100_alloc_skb(priv, packet);
4542 if (unlikely(err)) {
4547 /* The BD holds the cache aligned address */
4548 priv->rx_queue.drv[i].host_addr = packet->dma_addr;
4549 priv->rx_queue.drv[i].buf_length = IPW_RX_NIC_BUFFER_LENGTH;
4550 priv->status_queue.drv[i].status_fields = 0;
4553 if (i == RX_QUEUE_LENGTH)
4556 for (j = 0; j < i; j++) {
4557 pci_unmap_single(priv->pci_dev, priv->rx_buffers[j].dma_addr,
4558 sizeof(struct ipw2100_rx_packet),
4559 PCI_DMA_FROMDEVICE);
4560 dev_kfree_skb(priv->rx_buffers[j].skb);
4563 kfree(priv->rx_buffers);
4564 priv->rx_buffers = NULL;
4566 bd_queue_free(priv, &priv->rx_queue);
4568 status_queue_free(priv);
4573 static void ipw2100_rx_initialize(struct ipw2100_priv *priv)
4575 IPW_DEBUG_INFO("enter\n");
4577 priv->rx_queue.oldest = 0;
4578 priv->rx_queue.available = priv->rx_queue.entries - 1;
4579 priv->rx_queue.next = priv->rx_queue.entries - 1;
4581 INIT_STAT(&priv->rxq_stat);
4582 SET_STAT(&priv->rxq_stat, priv->rx_queue.available);
4584 bd_queue_initialize(priv, &priv->rx_queue,
4585 IPW_MEM_HOST_SHARED_RX_BD_BASE,
4586 IPW_MEM_HOST_SHARED_RX_BD_SIZE,
4587 IPW_MEM_HOST_SHARED_RX_READ_INDEX,
4588 IPW_MEM_HOST_SHARED_RX_WRITE_INDEX);
4590 /* set up the status queue */
4591 write_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_STATUS_BASE,
4592 priv->status_queue.nic);
4594 IPW_DEBUG_INFO("exit\n");
4597 static void ipw2100_rx_free(struct ipw2100_priv *priv)
4601 IPW_DEBUG_INFO("enter\n");
4603 bd_queue_free(priv, &priv->rx_queue);
4604 status_queue_free(priv);
4606 if (!priv->rx_buffers)
4609 for (i = 0; i < RX_QUEUE_LENGTH; i++) {
4610 if (priv->rx_buffers[i].rxp) {
4611 pci_unmap_single(priv->pci_dev,
4612 priv->rx_buffers[i].dma_addr,
4613 sizeof(struct ipw2100_rx),
4614 PCI_DMA_FROMDEVICE);
4615 dev_kfree_skb(priv->rx_buffers[i].skb);
4619 kfree(priv->rx_buffers);
4620 priv->rx_buffers = NULL;
4622 IPW_DEBUG_INFO("exit\n");
4625 static int ipw2100_read_mac_address(struct ipw2100_priv *priv)
4627 u32 length = ETH_ALEN;
4629 DECLARE_MAC_BUF(mac);
4633 err = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ADAPTER_MAC, addr, &length);
4635 IPW_DEBUG_INFO("MAC address read failed\n");
4639 memcpy(priv->net_dev->dev_addr, addr, ETH_ALEN);
4640 IPW_DEBUG_INFO("card MAC is %s\n",
4641 print_mac(mac, priv->net_dev->dev_addr));
4646 /********************************************************************
4650 ********************************************************************/
4652 static int ipw2100_set_mac_address(struct ipw2100_priv *priv, int batch_mode)
4654 struct host_command cmd = {
4655 .host_command = ADAPTER_ADDRESS,
4656 .host_command_sequence = 0,
4657 .host_command_length = ETH_ALEN
4661 IPW_DEBUG_HC("SET_MAC_ADDRESS\n");
4663 IPW_DEBUG_INFO("enter\n");
4665 if (priv->config & CFG_CUSTOM_MAC) {
4666 memcpy(cmd.host_command_parameters, priv->mac_addr, ETH_ALEN);
4667 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
4669 memcpy(cmd.host_command_parameters, priv->net_dev->dev_addr,
4672 err = ipw2100_hw_send_command(priv, &cmd);
4674 IPW_DEBUG_INFO("exit\n");
4678 static int ipw2100_set_port_type(struct ipw2100_priv *priv, u32 port_type,
4681 struct host_command cmd = {
4682 .host_command = PORT_TYPE,
4683 .host_command_sequence = 0,
4684 .host_command_length = sizeof(u32)
4688 switch (port_type) {
4690 cmd.host_command_parameters[0] = IPW_BSS;
4693 cmd.host_command_parameters[0] = IPW_IBSS;
4697 IPW_DEBUG_HC("PORT_TYPE: %s\n",
4698 port_type == IPW_IBSS ? "Ad-Hoc" : "Managed");
4701 err = ipw2100_disable_adapter(priv);
4703 printk(KERN_ERR DRV_NAME
4704 ": %s: Could not disable adapter %d\n",
4705 priv->net_dev->name, err);
4710 /* send cmd to firmware */
4711 err = ipw2100_hw_send_command(priv, &cmd);
4714 ipw2100_enable_adapter(priv);
4719 static int ipw2100_set_channel(struct ipw2100_priv *priv, u32 channel,
4722 struct host_command cmd = {
4723 .host_command = CHANNEL,
4724 .host_command_sequence = 0,
4725 .host_command_length = sizeof(u32)
4729 cmd.host_command_parameters[0] = channel;
4731 IPW_DEBUG_HC("CHANNEL: %d\n", channel);
4733 /* If BSS then we don't support channel selection */
4734 if (priv->ieee->iw_mode == IW_MODE_INFRA)
4737 if ((channel != 0) &&
4738 ((channel < REG_MIN_CHANNEL) || (channel > REG_MAX_CHANNEL)))
4742 err = ipw2100_disable_adapter(priv);
4747 err = ipw2100_hw_send_command(priv, &cmd);
4749 IPW_DEBUG_INFO("Failed to set channel to %d", channel);
4754 priv->config |= CFG_STATIC_CHANNEL;
4756 priv->config &= ~CFG_STATIC_CHANNEL;
4758 priv->channel = channel;
4761 err = ipw2100_enable_adapter(priv);
4769 static int ipw2100_system_config(struct ipw2100_priv *priv, int batch_mode)
4771 struct host_command cmd = {
4772 .host_command = SYSTEM_CONFIG,
4773 .host_command_sequence = 0,
4774 .host_command_length = 12,
4776 u32 ibss_mask, len = sizeof(u32);
4779 /* Set system configuration */
4782 err = ipw2100_disable_adapter(priv);
4787 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
4788 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_AUTO_START;
4790 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_MASK |
4791 IPW_CFG_BSS_MASK | IPW_CFG_802_1x_ENABLE;
4793 if (!(priv->config & CFG_LONG_PREAMBLE))
4794 cmd.host_command_parameters[0] |= IPW_CFG_PREAMBLE_AUTO;
4796 err = ipw2100_get_ordinal(priv,
4797 IPW_ORD_EEPROM_IBSS_11B_CHANNELS,
4800 ibss_mask = IPW_IBSS_11B_DEFAULT_MASK;
4802 cmd.host_command_parameters[1] = REG_CHANNEL_MASK;
4803 cmd.host_command_parameters[2] = REG_CHANNEL_MASK & ibss_mask;
4806 /*cmd.host_command_parameters[0] |= DIVERSITY_ANTENNA_A; */
4808 err = ipw2100_hw_send_command(priv, &cmd);
4812 /* If IPv6 is configured in the kernel then we don't want to filter out all
4813 * of the multicast packets as IPv6 needs some. */
4814 #if !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE)
4815 cmd.host_command = ADD_MULTICAST;
4816 cmd.host_command_sequence = 0;
4817 cmd.host_command_length = 0;
4819 ipw2100_hw_send_command(priv, &cmd);
4822 err = ipw2100_enable_adapter(priv);
4830 static int ipw2100_set_tx_rates(struct ipw2100_priv *priv, u32 rate,
4833 struct host_command cmd = {
4834 .host_command = BASIC_TX_RATES,
4835 .host_command_sequence = 0,
4836 .host_command_length = 4
4840 cmd.host_command_parameters[0] = rate & TX_RATE_MASK;
4843 err = ipw2100_disable_adapter(priv);
4848 /* Set BASIC TX Rate first */
4849 ipw2100_hw_send_command(priv, &cmd);
4852 cmd.host_command = TX_RATES;
4853 ipw2100_hw_send_command(priv, &cmd);
4855 /* Set MSDU TX Rate */
4856 cmd.host_command = MSDU_TX_RATES;
4857 ipw2100_hw_send_command(priv, &cmd);
4860 err = ipw2100_enable_adapter(priv);
4865 priv->tx_rates = rate;
4870 static int ipw2100_set_power_mode(struct ipw2100_priv *priv, int power_level)
4872 struct host_command cmd = {
4873 .host_command = POWER_MODE,
4874 .host_command_sequence = 0,
4875 .host_command_length = 4
4879 cmd.host_command_parameters[0] = power_level;
4881 err = ipw2100_hw_send_command(priv, &cmd);
4885 if (power_level == IPW_POWER_MODE_CAM)
4886 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
4888 priv->power_mode = IPW_POWER_ENABLED | power_level;
4890 #ifdef IPW2100_TX_POWER
4891 if (priv->port_type == IBSS && priv->adhoc_power != DFTL_IBSS_TX_POWER) {
4892 /* Set beacon interval */
4893 cmd.host_command = TX_POWER_INDEX;
4894 cmd.host_command_parameters[0] = (u32) priv->adhoc_power;
4896 err = ipw2100_hw_send_command(priv, &cmd);
4905 static int ipw2100_set_rts_threshold(struct ipw2100_priv *priv, u32 threshold)
4907 struct host_command cmd = {
4908 .host_command = RTS_THRESHOLD,
4909 .host_command_sequence = 0,
4910 .host_command_length = 4
4914 if (threshold & RTS_DISABLED)
4915 cmd.host_command_parameters[0] = MAX_RTS_THRESHOLD;
4917 cmd.host_command_parameters[0] = threshold & ~RTS_DISABLED;
4919 err = ipw2100_hw_send_command(priv, &cmd);
4923 priv->rts_threshold = threshold;
4929 int ipw2100_set_fragmentation_threshold(struct ipw2100_priv *priv,
4930 u32 threshold, int batch_mode)
4932 struct host_command cmd = {
4933 .host_command = FRAG_THRESHOLD,
4934 .host_command_sequence = 0,
4935 .host_command_length = 4,
4936 .host_command_parameters[0] = 0,
4941 err = ipw2100_disable_adapter(priv);
4947 threshold = DEFAULT_FRAG_THRESHOLD;
4949 threshold = max(threshold, MIN_FRAG_THRESHOLD);
4950 threshold = min(threshold, MAX_FRAG_THRESHOLD);
4953 cmd.host_command_parameters[0] = threshold;
4955 IPW_DEBUG_HC("FRAG_THRESHOLD: %u\n", threshold);
4957 err = ipw2100_hw_send_command(priv, &cmd);
4960 ipw2100_enable_adapter(priv);
4963 priv->frag_threshold = threshold;
4969 static int ipw2100_set_short_retry(struct ipw2100_priv *priv, u32 retry)
4971 struct host_command cmd = {
4972 .host_command = SHORT_RETRY_LIMIT,
4973 .host_command_sequence = 0,
4974 .host_command_length = 4
4978 cmd.host_command_parameters[0] = retry;
4980 err = ipw2100_hw_send_command(priv, &cmd);
4984 priv->short_retry_limit = retry;
4989 static int ipw2100_set_long_retry(struct ipw2100_priv *priv, u32 retry)
4991 struct host_command cmd = {
4992 .host_command = LONG_RETRY_LIMIT,
4993 .host_command_sequence = 0,
4994 .host_command_length = 4
4998 cmd.host_command_parameters[0] = retry;
5000 err = ipw2100_hw_send_command(priv, &cmd);
5004 priv->long_retry_limit = retry;
5009 static int ipw2100_set_mandatory_bssid(struct ipw2100_priv *priv, u8 * bssid,
5012 struct host_command cmd = {
5013 .host_command = MANDATORY_BSSID,
5014 .host_command_sequence = 0,
5015 .host_command_length = (bssid == NULL) ? 0 : ETH_ALEN
5019 #ifdef CONFIG_IPW2100_DEBUG
5020 DECLARE_MAC_BUF(mac);
5022 IPW_DEBUG_HC("MANDATORY_BSSID: %s\n",
5023 print_mac(mac, bssid));
5025 IPW_DEBUG_HC("MANDATORY_BSSID: <clear>\n");
5027 /* if BSSID is empty then we disable mandatory bssid mode */
5029 memcpy(cmd.host_command_parameters, bssid, ETH_ALEN);
5032 err = ipw2100_disable_adapter(priv);
5037 err = ipw2100_hw_send_command(priv, &cmd);
5040 ipw2100_enable_adapter(priv);
5045 static int ipw2100_disassociate_bssid(struct ipw2100_priv *priv)
5047 struct host_command cmd = {
5048 .host_command = DISASSOCIATION_BSSID,
5049 .host_command_sequence = 0,
5050 .host_command_length = ETH_ALEN
5055 IPW_DEBUG_HC("DISASSOCIATION_BSSID\n");
5058 /* The Firmware currently ignores the BSSID and just disassociates from
5059 * the currently associated AP -- but in the off chance that a future
5060 * firmware does use the BSSID provided here, we go ahead and try and
5061 * set it to the currently associated AP's BSSID */
5062 memcpy(cmd.host_command_parameters, priv->bssid, ETH_ALEN);
5064 err = ipw2100_hw_send_command(priv, &cmd);
5069 static int ipw2100_set_wpa_ie(struct ipw2100_priv *,
5070 struct ipw2100_wpa_assoc_frame *, int)
5071 __attribute__ ((unused));
5073 static int ipw2100_set_wpa_ie(struct ipw2100_priv *priv,
5074 struct ipw2100_wpa_assoc_frame *wpa_frame,
5077 struct host_command cmd = {
5078 .host_command = SET_WPA_IE,
5079 .host_command_sequence = 0,
5080 .host_command_length = sizeof(struct ipw2100_wpa_assoc_frame),
5084 IPW_DEBUG_HC("SET_WPA_IE\n");
5087 err = ipw2100_disable_adapter(priv);
5092 memcpy(cmd.host_command_parameters, wpa_frame,
5093 sizeof(struct ipw2100_wpa_assoc_frame));
5095 err = ipw2100_hw_send_command(priv, &cmd);
5098 if (ipw2100_enable_adapter(priv))
5105 struct security_info_params {
5106 u32 allowed_ciphers;
5109 u8 replay_counters_number;
5110 u8 unicast_using_group;
5111 } __attribute__ ((packed));
5113 static int ipw2100_set_security_information(struct ipw2100_priv *priv,
5116 int unicast_using_group,
5119 struct host_command cmd = {
5120 .host_command = SET_SECURITY_INFORMATION,
5121 .host_command_sequence = 0,
5122 .host_command_length = sizeof(struct security_info_params)
5124 struct security_info_params *security =
5125 (struct security_info_params *)&cmd.host_command_parameters;
5127 memset(security, 0, sizeof(*security));
5129 /* If shared key AP authentication is turned on, then we need to
5130 * configure the firmware to try and use it.
5132 * Actual data encryption/decryption is handled by the host. */
5133 security->auth_mode = auth_mode;
5134 security->unicast_using_group = unicast_using_group;
5136 switch (security_level) {
5139 security->allowed_ciphers = IPW_NONE_CIPHER;
5142 security->allowed_ciphers = IPW_WEP40_CIPHER |
5146 security->allowed_ciphers = IPW_WEP40_CIPHER |
5147 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER;
5149 case SEC_LEVEL_2_CKIP:
5150 security->allowed_ciphers = IPW_WEP40_CIPHER |
5151 IPW_WEP104_CIPHER | IPW_CKIP_CIPHER;
5154 security->allowed_ciphers = IPW_WEP40_CIPHER |
5155 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER | IPW_CCMP_CIPHER;
5160 ("SET_SECURITY_INFORMATION: auth:%d cipher:0x%02X (level %d)\n",
5161 security->auth_mode, security->allowed_ciphers, security_level);
5163 security->replay_counters_number = 0;
5166 err = ipw2100_disable_adapter(priv);
5171 err = ipw2100_hw_send_command(priv, &cmd);
5174 ipw2100_enable_adapter(priv);
5179 static int ipw2100_set_tx_power(struct ipw2100_priv *priv, u32 tx_power)
5181 struct host_command cmd = {
5182 .host_command = TX_POWER_INDEX,
5183 .host_command_sequence = 0,
5184 .host_command_length = 4
5189 if (tx_power != IPW_TX_POWER_DEFAULT)
5190 tmp = (tx_power - IPW_TX_POWER_MIN_DBM) * 16 /
5191 (IPW_TX_POWER_MAX_DBM - IPW_TX_POWER_MIN_DBM);
5193 cmd.host_command_parameters[0] = tmp;
5195 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
5196 err = ipw2100_hw_send_command(priv, &cmd);
5198 priv->tx_power = tx_power;
5203 static int ipw2100_set_ibss_beacon_interval(struct ipw2100_priv *priv,
5204 u32 interval, int batch_mode)
5206 struct host_command cmd = {
5207 .host_command = BEACON_INTERVAL,
5208 .host_command_sequence = 0,
5209 .host_command_length = 4
5213 cmd.host_command_parameters[0] = interval;
5215 IPW_DEBUG_INFO("enter\n");
5217 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5219 err = ipw2100_disable_adapter(priv);
5224 ipw2100_hw_send_command(priv, &cmd);
5227 err = ipw2100_enable_adapter(priv);
5233 IPW_DEBUG_INFO("exit\n");
5238 void ipw2100_queues_initialize(struct ipw2100_priv *priv)
5240 ipw2100_tx_initialize(priv);
5241 ipw2100_rx_initialize(priv);
5242 ipw2100_msg_initialize(priv);
5245 void ipw2100_queues_free(struct ipw2100_priv *priv)
5247 ipw2100_tx_free(priv);
5248 ipw2100_rx_free(priv);
5249 ipw2100_msg_free(priv);
5252 int ipw2100_queues_allocate(struct ipw2100_priv *priv)
5254 if (ipw2100_tx_allocate(priv) ||
5255 ipw2100_rx_allocate(priv) || ipw2100_msg_allocate(priv))
5261 ipw2100_tx_free(priv);
5262 ipw2100_rx_free(priv);
5263 ipw2100_msg_free(priv);
5267 #define IPW_PRIVACY_CAPABLE 0x0008
5269 static int ipw2100_set_wep_flags(struct ipw2100_priv *priv, u32 flags,
5272 struct host_command cmd = {
5273 .host_command = WEP_FLAGS,
5274 .host_command_sequence = 0,
5275 .host_command_length = 4
5279 cmd.host_command_parameters[0] = flags;
5281 IPW_DEBUG_HC("WEP_FLAGS: flags = 0x%08X\n", flags);
5284 err = ipw2100_disable_adapter(priv);
5286 printk(KERN_ERR DRV_NAME
5287 ": %s: Could not disable adapter %d\n",
5288 priv->net_dev->name, err);
5293 /* send cmd to firmware */
5294 err = ipw2100_hw_send_command(priv, &cmd);
5297 ipw2100_enable_adapter(priv);
5302 struct ipw2100_wep_key {
5308 /* Macros to ease up priting WEP keys */
5309 #define WEP_FMT_64 "%02X%02X%02X%02X-%02X"
5310 #define WEP_FMT_128 "%02X%02X%02X%02X-%02X%02X%02X%02X-%02X%02X%02X"
5311 #define WEP_STR_64(x) x[0],x[1],x[2],x[3],x[4]
5312 #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]
5317 * @priv: struct to work on
5318 * @idx: index of the key we want to set
5319 * @key: ptr to the key data to set
5320 * @len: length of the buffer at @key
5321 * @batch_mode: FIXME perform the operation in batch mode, not
5322 * disabling the device.
5324 * @returns 0 if OK, < 0 errno code on error.
5326 * Fill out a command structure with the new wep key, length an
5327 * index and send it down the wire.
5329 static int ipw2100_set_key(struct ipw2100_priv *priv,
5330 int idx, char *key, int len, int batch_mode)
5332 int keylen = len ? (len <= 5 ? 5 : 13) : 0;
5333 struct host_command cmd = {
5334 .host_command = WEP_KEY_INFO,
5335 .host_command_sequence = 0,
5336 .host_command_length = sizeof(struct ipw2100_wep_key),
5338 struct ipw2100_wep_key *wep_key = (void *)cmd.host_command_parameters;
5341 IPW_DEBUG_HC("WEP_KEY_INFO: index = %d, len = %d/%d\n",
5344 /* NOTE: We don't check cached values in case the firmware was reset
5345 * or some other problem is occurring. If the user is setting the key,
5346 * then we push the change */
5349 wep_key->len = keylen;
5352 memcpy(wep_key->key, key, len);
5353 memset(wep_key->key + len, 0, keylen - len);
5356 /* Will be optimized out on debug not being configured in */
5358 IPW_DEBUG_WEP("%s: Clearing key %d\n",
5359 priv->net_dev->name, wep_key->idx);
5360 else if (keylen == 5)
5361 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_64 "\n",
5362 priv->net_dev->name, wep_key->idx, wep_key->len,
5363 WEP_STR_64(wep_key->key));
5365 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_128
5367 priv->net_dev->name, wep_key->idx, wep_key->len,
5368 WEP_STR_128(wep_key->key));
5371 err = ipw2100_disable_adapter(priv);
5372 /* FIXME: IPG: shouldn't this prink be in _disable_adapter()? */
5374 printk(KERN_ERR DRV_NAME
5375 ": %s: Could not disable adapter %d\n",
5376 priv->net_dev->name, err);
5381 /* send cmd to firmware */
5382 err = ipw2100_hw_send_command(priv, &cmd);
5385 int err2 = ipw2100_enable_adapter(priv);
5392 static int ipw2100_set_key_index(struct ipw2100_priv *priv,
5393 int idx, int batch_mode)
5395 struct host_command cmd = {
5396 .host_command = WEP_KEY_INDEX,
5397 .host_command_sequence = 0,
5398 .host_command_length = 4,
5399 .host_command_parameters = {idx},
5403 IPW_DEBUG_HC("WEP_KEY_INDEX: index = %d\n", idx);
5405 if (idx < 0 || idx > 3)
5409 err = ipw2100_disable_adapter(priv);
5411 printk(KERN_ERR DRV_NAME
5412 ": %s: Could not disable adapter %d\n",
5413 priv->net_dev->name, err);
5418 /* send cmd to firmware */
5419 err = ipw2100_hw_send_command(priv, &cmd);
5422 ipw2100_enable_adapter(priv);
5427 static int ipw2100_configure_security(struct ipw2100_priv *priv, int batch_mode)
5429 int i, err, auth_mode, sec_level, use_group;
5431 if (!(priv->status & STATUS_RUNNING))
5435 err = ipw2100_disable_adapter(priv);
5440 if (!priv->ieee->sec.enabled) {
5442 ipw2100_set_security_information(priv, IPW_AUTH_OPEN,
5445 auth_mode = IPW_AUTH_OPEN;
5446 if (priv->ieee->sec.flags & SEC_AUTH_MODE) {
5447 if (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)
5448 auth_mode = IPW_AUTH_SHARED;
5449 else if (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP)
5450 auth_mode = IPW_AUTH_LEAP_CISCO_ID;
5453 sec_level = SEC_LEVEL_0;
5454 if (priv->ieee->sec.flags & SEC_LEVEL)
5455 sec_level = priv->ieee->sec.level;
5458 if (priv->ieee->sec.flags & SEC_UNICAST_GROUP)
5459 use_group = priv->ieee->sec.unicast_uses_group;
5462 ipw2100_set_security_information(priv, auth_mode, sec_level,
5469 if (priv->ieee->sec.enabled) {
5470 for (i = 0; i < 4; i++) {
5471 if (!(priv->ieee->sec.flags & (1 << i))) {
5472 memset(priv->ieee->sec.keys[i], 0, WEP_KEY_LEN);
5473 priv->ieee->sec.key_sizes[i] = 0;
5475 err = ipw2100_set_key(priv, i,
5476 priv->ieee->sec.keys[i],
5484 ipw2100_set_key_index(priv, priv->ieee->tx_keyidx, 1);
5487 /* Always enable privacy so the Host can filter WEP packets if
5488 * encrypted data is sent up */
5490 ipw2100_set_wep_flags(priv,
5492 enabled ? IPW_PRIVACY_CAPABLE : 0, 1);
5496 priv->status &= ~STATUS_SECURITY_UPDATED;
5500 ipw2100_enable_adapter(priv);
5505 static void ipw2100_security_work(struct work_struct *work)
5507 struct ipw2100_priv *priv =
5508 container_of(work, struct ipw2100_priv, security_work.work);
5510 /* If we happen to have reconnected before we get a chance to
5511 * process this, then update the security settings--which causes
5512 * a disassociation to occur */
5513 if (!(priv->status & STATUS_ASSOCIATED) &&
5514 priv->status & STATUS_SECURITY_UPDATED)
5515 ipw2100_configure_security(priv, 0);
5518 static void shim__set_security(struct net_device *dev,
5519 struct ieee80211_security *sec)
5521 struct ipw2100_priv *priv = ieee80211_priv(dev);
5522 int i, force_update = 0;
5524 mutex_lock(&priv->action_mutex);
5525 if (!(priv->status & STATUS_INITIALIZED))
5528 for (i = 0; i < 4; i++) {
5529 if (sec->flags & (1 << i)) {
5530 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
5531 if (sec->key_sizes[i] == 0)
5532 priv->ieee->sec.flags &= ~(1 << i);
5534 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
5536 if (sec->level == SEC_LEVEL_1) {
5537 priv->ieee->sec.flags |= (1 << i);
5538 priv->status |= STATUS_SECURITY_UPDATED;
5540 priv->ieee->sec.flags &= ~(1 << i);
5544 if ((sec->flags & SEC_ACTIVE_KEY) &&
5545 priv->ieee->sec.active_key != sec->active_key) {
5546 if (sec->active_key <= 3) {
5547 priv->ieee->sec.active_key = sec->active_key;
5548 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
5550 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
5552 priv->status |= STATUS_SECURITY_UPDATED;
5555 if ((sec->flags & SEC_AUTH_MODE) &&
5556 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
5557 priv->ieee->sec.auth_mode = sec->auth_mode;
5558 priv->ieee->sec.flags |= SEC_AUTH_MODE;
5559 priv->status |= STATUS_SECURITY_UPDATED;
5562 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
5563 priv->ieee->sec.flags |= SEC_ENABLED;
5564 priv->ieee->sec.enabled = sec->enabled;
5565 priv->status |= STATUS_SECURITY_UPDATED;
5569 if (sec->flags & SEC_ENCRYPT)
5570 priv->ieee->sec.encrypt = sec->encrypt;
5572 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
5573 priv->ieee->sec.level = sec->level;
5574 priv->ieee->sec.flags |= SEC_LEVEL;
5575 priv->status |= STATUS_SECURITY_UPDATED;
5578 IPW_DEBUG_WEP("Security flags: %c %c%c%c%c %c%c%c%c\n",
5579 priv->ieee->sec.flags & (1 << 8) ? '1' : '0',
5580 priv->ieee->sec.flags & (1 << 7) ? '1' : '0',
5581 priv->ieee->sec.flags & (1 << 6) ? '1' : '0',
5582 priv->ieee->sec.flags & (1 << 5) ? '1' : '0',
5583 priv->ieee->sec.flags & (1 << 4) ? '1' : '0',
5584 priv->ieee->sec.flags & (1 << 3) ? '1' : '0',
5585 priv->ieee->sec.flags & (1 << 2) ? '1' : '0',
5586 priv->ieee->sec.flags & (1 << 1) ? '1' : '0',
5587 priv->ieee->sec.flags & (1 << 0) ? '1' : '0');
5589 /* As a temporary work around to enable WPA until we figure out why
5590 * wpa_supplicant toggles the security capability of the driver, which
5591 * forces a disassocation with force_update...
5593 * if (force_update || !(priv->status & STATUS_ASSOCIATED))*/
5594 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
5595 ipw2100_configure_security(priv, 0);
5597 mutex_unlock(&priv->action_mutex);
5600 static int ipw2100_adapter_setup(struct ipw2100_priv *priv)
5606 IPW_DEBUG_INFO("enter\n");
5608 err = ipw2100_disable_adapter(priv);
5611 #ifdef CONFIG_IPW2100_MONITOR
5612 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
5613 err = ipw2100_set_channel(priv, priv->channel, batch_mode);
5617 IPW_DEBUG_INFO("exit\n");
5621 #endif /* CONFIG_IPW2100_MONITOR */
5623 err = ipw2100_read_mac_address(priv);
5627 err = ipw2100_set_mac_address(priv, batch_mode);
5631 err = ipw2100_set_port_type(priv, priv->ieee->iw_mode, batch_mode);
5635 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5636 err = ipw2100_set_channel(priv, priv->channel, batch_mode);
5641 err = ipw2100_system_config(priv, batch_mode);
5645 err = ipw2100_set_tx_rates(priv, priv->tx_rates, batch_mode);
5649 /* Default to power mode OFF */
5650 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM);
5654 err = ipw2100_set_rts_threshold(priv, priv->rts_threshold);
5658 if (priv->config & CFG_STATIC_BSSID)
5659 bssid = priv->bssid;
5662 err = ipw2100_set_mandatory_bssid(priv, bssid, batch_mode);
5666 if (priv->config & CFG_STATIC_ESSID)
5667 err = ipw2100_set_essid(priv, priv->essid, priv->essid_len,
5670 err = ipw2100_set_essid(priv, NULL, 0, batch_mode);
5674 err = ipw2100_configure_security(priv, batch_mode);
5678 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5680 ipw2100_set_ibss_beacon_interval(priv,
5681 priv->beacon_interval,
5686 err = ipw2100_set_tx_power(priv, priv->tx_power);
5692 err = ipw2100_set_fragmentation_threshold(
5693 priv, priv->frag_threshold, batch_mode);
5698 IPW_DEBUG_INFO("exit\n");
5703 /*************************************************************************
5705 * EXTERNALLY CALLED METHODS
5707 *************************************************************************/
5709 /* This method is called by the network layer -- not to be confused with
5710 * ipw2100_set_mac_address() declared above called by this driver (and this
5711 * method as well) to talk to the firmware */
5712 static int ipw2100_set_address(struct net_device *dev, void *p)
5714 struct ipw2100_priv *priv = ieee80211_priv(dev);
5715 struct sockaddr *addr = p;
5718 if (!is_valid_ether_addr(addr->sa_data))
5719 return -EADDRNOTAVAIL;
5721 mutex_lock(&priv->action_mutex);
5723 priv->config |= CFG_CUSTOM_MAC;
5724 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
5726 err = ipw2100_set_mac_address(priv, 0);
5730 priv->reset_backoff = 0;
5731 mutex_unlock(&priv->action_mutex);
5732 ipw2100_reset_adapter(&priv->reset_work.work);
5736 mutex_unlock(&priv->action_mutex);
5740 static int ipw2100_open(struct net_device *dev)
5742 struct ipw2100_priv *priv = ieee80211_priv(dev);
5743 unsigned long flags;
5744 IPW_DEBUG_INFO("dev->open\n");
5746 spin_lock_irqsave(&priv->low_lock, flags);
5747 if (priv->status & STATUS_ASSOCIATED) {
5748 netif_carrier_on(dev);
5749 netif_start_queue(dev);
5751 spin_unlock_irqrestore(&priv->low_lock, flags);
5756 static int ipw2100_close(struct net_device *dev)
5758 struct ipw2100_priv *priv = ieee80211_priv(dev);
5759 unsigned long flags;
5760 struct list_head *element;
5761 struct ipw2100_tx_packet *packet;
5763 IPW_DEBUG_INFO("enter\n");
5765 spin_lock_irqsave(&priv->low_lock, flags);
5767 if (priv->status & STATUS_ASSOCIATED)
5768 netif_carrier_off(dev);
5769 netif_stop_queue(dev);
5771 /* Flush the TX queue ... */
5772 while (!list_empty(&priv->tx_pend_list)) {
5773 element = priv->tx_pend_list.next;
5774 packet = list_entry(element, struct ipw2100_tx_packet, list);
5777 DEC_STAT(&priv->tx_pend_stat);
5779 ieee80211_txb_free(packet->info.d_struct.txb);
5780 packet->info.d_struct.txb = NULL;
5782 list_add_tail(element, &priv->tx_free_list);
5783 INC_STAT(&priv->tx_free_stat);
5785 spin_unlock_irqrestore(&priv->low_lock, flags);
5787 IPW_DEBUG_INFO("exit\n");
5793 * TODO: Fix this function... its just wrong
5795 static void ipw2100_tx_timeout(struct net_device *dev)
5797 struct ipw2100_priv *priv = ieee80211_priv(dev);
5799 priv->ieee->stats.tx_errors++;
5801 #ifdef CONFIG_IPW2100_MONITOR
5802 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
5806 IPW_DEBUG_INFO("%s: TX timed out. Scheduling firmware restart.\n",
5808 schedule_reset(priv);
5811 static int ipw2100_wpa_enable(struct ipw2100_priv *priv, int value)
5813 /* This is called when wpa_supplicant loads and closes the driver
5815 priv->ieee->wpa_enabled = value;
5819 static int ipw2100_wpa_set_auth_algs(struct ipw2100_priv *priv, int value)
5822 struct ieee80211_device *ieee = priv->ieee;
5823 struct ieee80211_security sec = {
5824 .flags = SEC_AUTH_MODE,
5828 if (value & IW_AUTH_ALG_SHARED_KEY) {
5829 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
5831 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
5832 sec.auth_mode = WLAN_AUTH_OPEN;
5834 } else if (value & IW_AUTH_ALG_LEAP) {
5835 sec.auth_mode = WLAN_AUTH_LEAP;
5840 if (ieee->set_security)
5841 ieee->set_security(ieee->dev, &sec);
5848 static void ipw2100_wpa_assoc_frame(struct ipw2100_priv *priv,
5849 char *wpa_ie, int wpa_ie_len)
5852 struct ipw2100_wpa_assoc_frame frame;
5854 frame.fixed_ie_mask = 0;
5857 memcpy(frame.var_ie, wpa_ie, wpa_ie_len);
5858 frame.var_ie_len = wpa_ie_len;
5860 /* make sure WPA is enabled */
5861 ipw2100_wpa_enable(priv, 1);
5862 ipw2100_set_wpa_ie(priv, &frame, 0);
5865 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
5866 struct ethtool_drvinfo *info)
5868 struct ipw2100_priv *priv = ieee80211_priv(dev);
5869 char fw_ver[64], ucode_ver[64];
5871 strcpy(info->driver, DRV_NAME);
5872 strcpy(info->version, DRV_VERSION);
5874 ipw2100_get_fwversion(priv, fw_ver, sizeof(fw_ver));
5875 ipw2100_get_ucodeversion(priv, ucode_ver, sizeof(ucode_ver));
5877 snprintf(info->fw_version, sizeof(info->fw_version), "%s:%d:%s",
5878 fw_ver, priv->eeprom_version, ucode_ver);
5880 strcpy(info->bus_info, pci_name(priv->pci_dev));
5883 static u32 ipw2100_ethtool_get_link(struct net_device *dev)
5885 struct ipw2100_priv *priv = ieee80211_priv(dev);
5886 return (priv->status & STATUS_ASSOCIATED) ? 1 : 0;
5889 static const struct ethtool_ops ipw2100_ethtool_ops = {
5890 .get_link = ipw2100_ethtool_get_link,
5891 .get_drvinfo = ipw_ethtool_get_drvinfo,
5894 static void ipw2100_hang_check(struct work_struct *work)
5896 struct ipw2100_priv *priv =
5897 container_of(work, struct ipw2100_priv, hang_check.work);
5898 unsigned long flags;
5899 u32 rtc = 0xa5a5a5a5;
5900 u32 len = sizeof(rtc);
5903 spin_lock_irqsave(&priv->low_lock, flags);
5905 if (priv->fatal_error != 0) {
5906 /* If fatal_error is set then we need to restart */
5907 IPW_DEBUG_INFO("%s: Hardware fatal error detected.\n",
5908 priv->net_dev->name);
5911 } else if (ipw2100_get_ordinal(priv, IPW_ORD_RTC_TIME, &rtc, &len) ||
5912 (rtc == priv->last_rtc)) {
5913 /* Check if firmware is hung */
5914 IPW_DEBUG_INFO("%s: Firmware RTC stalled.\n",
5915 priv->net_dev->name);
5922 priv->stop_hang_check = 1;
5925 /* Restart the NIC */
5926 schedule_reset(priv);
5929 priv->last_rtc = rtc;
5931 if (!priv->stop_hang_check)
5932 queue_delayed_work(priv->workqueue, &priv->hang_check, HZ / 2);
5934 spin_unlock_irqrestore(&priv->low_lock, flags);
5937 static void ipw2100_rf_kill(struct work_struct *work)
5939 struct ipw2100_priv *priv =
5940 container_of(work, struct ipw2100_priv, rf_kill.work);
5941 unsigned long flags;
5943 spin_lock_irqsave(&priv->low_lock, flags);
5945 if (rf_kill_active(priv)) {
5946 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
5947 if (!priv->stop_rf_kill)
5948 queue_delayed_work(priv->workqueue, &priv->rf_kill,
5953 /* RF Kill is now disabled, so bring the device back up */
5955 if (!(priv->status & STATUS_RF_KILL_MASK)) {
5956 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
5958 schedule_reset(priv);
5960 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
5964 spin_unlock_irqrestore(&priv->low_lock, flags);
5967 static void ipw2100_irq_tasklet(struct ipw2100_priv *priv);
5969 /* Look into using netdev destructor to shutdown ieee80211? */
5971 static struct net_device *ipw2100_alloc_device(struct pci_dev *pci_dev,
5972 void __iomem * base_addr,
5973 unsigned long mem_start,
5974 unsigned long mem_len)
5976 struct ipw2100_priv *priv;
5977 struct net_device *dev;
5979 dev = alloc_ieee80211(sizeof(struct ipw2100_priv));
5982 priv = ieee80211_priv(dev);
5983 priv->ieee = netdev_priv(dev);
5984 priv->pci_dev = pci_dev;
5985 priv->net_dev = dev;
5987 priv->ieee->hard_start_xmit = ipw2100_tx;
5988 priv->ieee->set_security = shim__set_security;
5990 priv->ieee->perfect_rssi = -20;
5991 priv->ieee->worst_rssi = -85;
5993 dev->open = ipw2100_open;
5994 dev->stop = ipw2100_close;
5995 dev->init = ipw2100_net_init;
5996 dev->ethtool_ops = &ipw2100_ethtool_ops;
5997 dev->tx_timeout = ipw2100_tx_timeout;
5998 dev->wireless_handlers = &ipw2100_wx_handler_def;
5999 priv->wireless_data.ieee80211 = priv->ieee;
6000 dev->wireless_data = &priv->wireless_data;
6001 dev->set_mac_address = ipw2100_set_address;
6002 dev->watchdog_timeo = 3 * HZ;
6005 dev->base_addr = (unsigned long)base_addr;
6006 dev->mem_start = mem_start;
6007 dev->mem_end = dev->mem_start + mem_len - 1;
6009 /* NOTE: We don't use the wireless_handlers hook
6010 * in dev as the system will start throwing WX requests
6011 * to us before we're actually initialized and it just
6012 * ends up causing problems. So, we just handle
6013 * the WX extensions through the ipw2100_ioctl interface */
6015 /* memset() puts everything to 0, so we only have explicitely set
6016 * those values that need to be something else */
6018 /* If power management is turned on, default to AUTO mode */
6019 priv->power_mode = IPW_POWER_AUTO;
6021 #ifdef CONFIG_IPW2100_MONITOR
6022 priv->config |= CFG_CRC_CHECK;
6024 priv->ieee->wpa_enabled = 0;
6025 priv->ieee->drop_unencrypted = 0;
6026 priv->ieee->privacy_invoked = 0;
6027 priv->ieee->ieee802_1x = 1;
6029 /* Set module parameters */
6032 priv->ieee->iw_mode = IW_MODE_ADHOC;
6034 #ifdef CONFIG_IPW2100_MONITOR
6036 priv->ieee->iw_mode = IW_MODE_MONITOR;
6041 priv->ieee->iw_mode = IW_MODE_INFRA;
6046 priv->status |= STATUS_RF_KILL_SW;
6049 ((channel >= REG_MIN_CHANNEL) && (channel <= REG_MAX_CHANNEL))) {
6050 priv->config |= CFG_STATIC_CHANNEL;
6051 priv->channel = channel;
6055 priv->config |= CFG_ASSOCIATE;
6057 priv->beacon_interval = DEFAULT_BEACON_INTERVAL;
6058 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
6059 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
6060 priv->rts_threshold = DEFAULT_RTS_THRESHOLD | RTS_DISABLED;
6061 priv->frag_threshold = DEFAULT_FTS | FRAG_DISABLED;
6062 priv->tx_power = IPW_TX_POWER_DEFAULT;
6063 priv->tx_rates = DEFAULT_TX_RATES;
6065 strcpy(priv->nick, "ipw2100");
6067 spin_lock_init(&priv->low_lock);
6068 mutex_init(&priv->action_mutex);
6069 mutex_init(&priv->adapter_mutex);
6071 init_waitqueue_head(&priv->wait_command_queue);
6073 netif_carrier_off(dev);
6075 INIT_LIST_HEAD(&priv->msg_free_list);
6076 INIT_LIST_HEAD(&priv->msg_pend_list);
6077 INIT_STAT(&priv->msg_free_stat);
6078 INIT_STAT(&priv->msg_pend_stat);
6080 INIT_LIST_HEAD(&priv->tx_free_list);
6081 INIT_LIST_HEAD(&priv->tx_pend_list);
6082 INIT_STAT(&priv->tx_free_stat);
6083 INIT_STAT(&priv->tx_pend_stat);
6085 INIT_LIST_HEAD(&priv->fw_pend_list);
6086 INIT_STAT(&priv->fw_pend_stat);
6088 priv->workqueue = create_workqueue(DRV_NAME);
6090 INIT_DELAYED_WORK(&priv->reset_work, ipw2100_reset_adapter);
6091 INIT_DELAYED_WORK(&priv->security_work, ipw2100_security_work);
6092 INIT_DELAYED_WORK(&priv->wx_event_work, ipw2100_wx_event_work);
6093 INIT_DELAYED_WORK(&priv->hang_check, ipw2100_hang_check);
6094 INIT_DELAYED_WORK(&priv->rf_kill, ipw2100_rf_kill);
6096 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
6097 ipw2100_irq_tasklet, (unsigned long)priv);
6099 /* NOTE: We do not start the deferred work for status checks yet */
6100 priv->stop_rf_kill = 1;
6101 priv->stop_hang_check = 1;
6106 static int ipw2100_pci_init_one(struct pci_dev *pci_dev,
6107 const struct pci_device_id *ent)
6109 unsigned long mem_start, mem_len, mem_flags;
6110 void __iomem *base_addr = NULL;
6111 struct net_device *dev = NULL;
6112 struct ipw2100_priv *priv = NULL;
6117 IPW_DEBUG_INFO("enter\n");
6119 mem_start = pci_resource_start(pci_dev, 0);
6120 mem_len = pci_resource_len(pci_dev, 0);
6121 mem_flags = pci_resource_flags(pci_dev, 0);
6123 if ((mem_flags & IORESOURCE_MEM) != IORESOURCE_MEM) {
6124 IPW_DEBUG_INFO("weird - resource type is not memory\n");
6129 base_addr = ioremap_nocache(mem_start, mem_len);
6131 printk(KERN_WARNING DRV_NAME
6132 "Error calling ioremap_nocache.\n");
6137 /* allocate and initialize our net_device */
6138 dev = ipw2100_alloc_device(pci_dev, base_addr, mem_start, mem_len);
6140 printk(KERN_WARNING DRV_NAME
6141 "Error calling ipw2100_alloc_device.\n");
6146 /* set up PCI mappings for device */
6147 err = pci_enable_device(pci_dev);
6149 printk(KERN_WARNING DRV_NAME
6150 "Error calling pci_enable_device.\n");
6154 priv = ieee80211_priv(dev);
6156 pci_set_master(pci_dev);
6157 pci_set_drvdata(pci_dev, priv);
6159 err = pci_set_dma_mask(pci_dev, DMA_32BIT_MASK);
6161 printk(KERN_WARNING DRV_NAME
6162 "Error calling pci_set_dma_mask.\n");
6163 pci_disable_device(pci_dev);
6167 err = pci_request_regions(pci_dev, DRV_NAME);
6169 printk(KERN_WARNING DRV_NAME
6170 "Error calling pci_request_regions.\n");
6171 pci_disable_device(pci_dev);
6175 /* We disable the RETRY_TIMEOUT register (0x41) to keep
6176 * PCI Tx retries from interfering with C3 CPU state */
6177 pci_read_config_dword(pci_dev, 0x40, &val);
6178 if ((val & 0x0000ff00) != 0)
6179 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff);
6181 pci_set_power_state(pci_dev, PCI_D0);
6183 if (!ipw2100_hw_is_adapter_in_system(dev)) {
6184 printk(KERN_WARNING DRV_NAME
6185 "Device not found via register read.\n");
6190 SET_NETDEV_DEV(dev, &pci_dev->dev);
6192 /* Force interrupts to be shut off on the device */
6193 priv->status |= STATUS_INT_ENABLED;
6194 ipw2100_disable_interrupts(priv);
6196 /* Allocate and initialize the Tx/Rx queues and lists */
6197 if (ipw2100_queues_allocate(priv)) {
6198 printk(KERN_WARNING DRV_NAME
6199 "Error calling ipw2100_queues_allocate.\n");
6203 ipw2100_queues_initialize(priv);
6205 err = request_irq(pci_dev->irq,
6206 ipw2100_interrupt, IRQF_SHARED, dev->name, priv);
6208 printk(KERN_WARNING DRV_NAME
6209 "Error calling request_irq: %d.\n", pci_dev->irq);
6212 dev->irq = pci_dev->irq;
6214 IPW_DEBUG_INFO("Attempting to register device...\n");
6216 printk(KERN_INFO DRV_NAME
6217 ": Detected Intel PRO/Wireless 2100 Network Connection\n");
6219 /* Bring up the interface. Pre 0.46, after we registered the
6220 * network device we would call ipw2100_up. This introduced a race
6221 * condition with newer hotplug configurations (network was coming
6222 * up and making calls before the device was initialized).
6224 * If we called ipw2100_up before we registered the device, then the
6225 * device name wasn't registered. So, we instead use the net_dev->init
6226 * member to call a function that then just turns and calls ipw2100_up.
6227 * net_dev->init is called after name allocation but before the
6228 * notifier chain is called */
6229 err = register_netdev(dev);
6231 printk(KERN_WARNING DRV_NAME
6232 "Error calling register_netdev.\n");
6236 mutex_lock(&priv->action_mutex);
6239 IPW_DEBUG_INFO("%s: Bound to %s\n", dev->name, pci_name(pci_dev));
6241 /* perform this after register_netdev so that dev->name is set */
6242 err = sysfs_create_group(&pci_dev->dev.kobj, &ipw2100_attribute_group);
6246 /* If the RF Kill switch is disabled, go ahead and complete the
6247 * startup sequence */
6248 if (!(priv->status & STATUS_RF_KILL_MASK)) {
6249 /* Enable the adapter - sends HOST_COMPLETE */
6250 if (ipw2100_enable_adapter(priv)) {
6251 printk(KERN_WARNING DRV_NAME
6252 ": %s: failed in call to enable adapter.\n",
6253 priv->net_dev->name);
6254 ipw2100_hw_stop_adapter(priv);
6259 /* Start a scan . . . */
6260 ipw2100_set_scan_options(priv);
6261 ipw2100_start_scan(priv);
6264 IPW_DEBUG_INFO("exit\n");
6266 priv->status |= STATUS_INITIALIZED;
6268 mutex_unlock(&priv->action_mutex);
6273 mutex_unlock(&priv->action_mutex);
6278 unregister_netdev(dev);
6280 ipw2100_hw_stop_adapter(priv);
6282 ipw2100_disable_interrupts(priv);
6285 free_irq(dev->irq, priv);
6287 ipw2100_kill_workqueue(priv);
6289 /* These are safe to call even if they weren't allocated */
6290 ipw2100_queues_free(priv);
6291 sysfs_remove_group(&pci_dev->dev.kobj,
6292 &ipw2100_attribute_group);
6294 free_ieee80211(dev);
6295 pci_set_drvdata(pci_dev, NULL);
6301 pci_release_regions(pci_dev);
6302 pci_disable_device(pci_dev);
6307 static void __devexit ipw2100_pci_remove_one(struct pci_dev *pci_dev)
6309 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6310 struct net_device *dev;
6313 mutex_lock(&priv->action_mutex);
6315 priv->status &= ~STATUS_INITIALIZED;
6317 dev = priv->net_dev;
6318 sysfs_remove_group(&pci_dev->dev.kobj,
6319 &ipw2100_attribute_group);
6322 if (ipw2100_firmware.version)
6323 ipw2100_release_firmware(priv, &ipw2100_firmware);
6325 /* Take down the hardware */
6328 /* Release the mutex so that the network subsystem can
6329 * complete any needed calls into the driver... */
6330 mutex_unlock(&priv->action_mutex);
6332 /* Unregister the device first - this results in close()
6333 * being called if the device is open. If we free storage
6334 * first, then close() will crash. */
6335 unregister_netdev(dev);
6337 /* ipw2100_down will ensure that there is no more pending work
6338 * in the workqueue's, so we can safely remove them now. */
6339 ipw2100_kill_workqueue(priv);
6341 ipw2100_queues_free(priv);
6343 /* Free potential debugging firmware snapshot */
6344 ipw2100_snapshot_free(priv);
6347 free_irq(dev->irq, priv);
6350 iounmap((void __iomem *)dev->base_addr);
6352 free_ieee80211(dev);
6355 pci_release_regions(pci_dev);
6356 pci_disable_device(pci_dev);
6358 IPW_DEBUG_INFO("exit\n");
6362 static int ipw2100_suspend(struct pci_dev *pci_dev, pm_message_t state)
6364 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6365 struct net_device *dev = priv->net_dev;
6367 IPW_DEBUG_INFO("%s: Going into suspend...\n", dev->name);
6369 mutex_lock(&priv->action_mutex);
6370 if (priv->status & STATUS_INITIALIZED) {
6371 /* Take down the device; powers it off, etc. */
6375 /* Remove the PRESENT state of the device */
6376 netif_device_detach(dev);
6378 pci_save_state(pci_dev);
6379 pci_disable_device(pci_dev);
6380 pci_set_power_state(pci_dev, PCI_D3hot);
6382 mutex_unlock(&priv->action_mutex);
6387 static int ipw2100_resume(struct pci_dev *pci_dev)
6389 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6390 struct net_device *dev = priv->net_dev;
6394 if (IPW2100_PM_DISABLED)
6397 mutex_lock(&priv->action_mutex);
6399 IPW_DEBUG_INFO("%s: Coming out of suspend...\n", dev->name);
6401 pci_set_power_state(pci_dev, PCI_D0);
6402 err = pci_enable_device(pci_dev);
6404 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
6408 pci_restore_state(pci_dev);
6411 * Suspend/Resume resets the PCI configuration space, so we have to
6412 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
6413 * from interfering with C3 CPU state. pci_restore_state won't help
6414 * here since it only restores the first 64 bytes pci config header.
6416 pci_read_config_dword(pci_dev, 0x40, &val);
6417 if ((val & 0x0000ff00) != 0)
6418 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff);
6420 /* Set the device back into the PRESENT state; this will also wake
6421 * the queue of needed */
6422 netif_device_attach(dev);
6424 /* Bring the device back up */
6425 if (!(priv->status & STATUS_RF_KILL_SW))
6426 ipw2100_up(priv, 0);
6428 mutex_unlock(&priv->action_mutex);
6434 #define IPW2100_DEV_ID(x) { PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, x }
6436 static struct pci_device_id ipw2100_pci_id_table[] __devinitdata = {
6437 IPW2100_DEV_ID(0x2520), /* IN 2100A mPCI 3A */
6438 IPW2100_DEV_ID(0x2521), /* IN 2100A mPCI 3B */
6439 IPW2100_DEV_ID(0x2524), /* IN 2100A mPCI 3B */
6440 IPW2100_DEV_ID(0x2525), /* IN 2100A mPCI 3B */
6441 IPW2100_DEV_ID(0x2526), /* IN 2100A mPCI Gen A3 */
6442 IPW2100_DEV_ID(0x2522), /* IN 2100 mPCI 3B */
6443 IPW2100_DEV_ID(0x2523), /* IN 2100 mPCI 3A */
6444 IPW2100_DEV_ID(0x2527), /* IN 2100 mPCI 3B */
6445 IPW2100_DEV_ID(0x2528), /* IN 2100 mPCI 3B */
6446 IPW2100_DEV_ID(0x2529), /* IN 2100 mPCI 3B */
6447 IPW2100_DEV_ID(0x252B), /* IN 2100 mPCI 3A */
6448 IPW2100_DEV_ID(0x252C), /* IN 2100 mPCI 3A */
6449 IPW2100_DEV_ID(0x252D), /* IN 2100 mPCI 3A */
6451 IPW2100_DEV_ID(0x2550), /* IB 2100A mPCI 3B */
6452 IPW2100_DEV_ID(0x2551), /* IB 2100 mPCI 3B */
6453 IPW2100_DEV_ID(0x2553), /* IB 2100 mPCI 3B */
6454 IPW2100_DEV_ID(0x2554), /* IB 2100 mPCI 3B */
6455 IPW2100_DEV_ID(0x2555), /* IB 2100 mPCI 3B */
6457 IPW2100_DEV_ID(0x2560), /* DE 2100A mPCI 3A */
6458 IPW2100_DEV_ID(0x2562), /* DE 2100A mPCI 3A */
6459 IPW2100_DEV_ID(0x2563), /* DE 2100A mPCI 3A */
6460 IPW2100_DEV_ID(0x2561), /* DE 2100 mPCI 3A */
6461 IPW2100_DEV_ID(0x2565), /* DE 2100 mPCI 3A */
6462 IPW2100_DEV_ID(0x2566), /* DE 2100 mPCI 3A */
6463 IPW2100_DEV_ID(0x2567), /* DE 2100 mPCI 3A */
6465 IPW2100_DEV_ID(0x2570), /* GA 2100 mPCI 3B */
6467 IPW2100_DEV_ID(0x2580), /* TO 2100A mPCI 3B */
6468 IPW2100_DEV_ID(0x2582), /* TO 2100A mPCI 3B */
6469 IPW2100_DEV_ID(0x2583), /* TO 2100A mPCI 3B */
6470 IPW2100_DEV_ID(0x2581), /* TO 2100 mPCI 3B */
6471 IPW2100_DEV_ID(0x2585), /* TO 2100 mPCI 3B */
6472 IPW2100_DEV_ID(0x2586), /* TO 2100 mPCI 3B */
6473 IPW2100_DEV_ID(0x2587), /* TO 2100 mPCI 3B */
6475 IPW2100_DEV_ID(0x2590), /* SO 2100A mPCI 3B */
6476 IPW2100_DEV_ID(0x2592), /* SO 2100A mPCI 3B */
6477 IPW2100_DEV_ID(0x2591), /* SO 2100 mPCI 3B */
6478 IPW2100_DEV_ID(0x2593), /* SO 2100 mPCI 3B */
6479 IPW2100_DEV_ID(0x2596), /* SO 2100 mPCI 3B */
6480 IPW2100_DEV_ID(0x2598), /* SO 2100 mPCI 3B */
6482 IPW2100_DEV_ID(0x25A0), /* HP 2100 mPCI 3B */
6486 MODULE_DEVICE_TABLE(pci, ipw2100_pci_id_table);
6488 static struct pci_driver ipw2100_pci_driver = {
6490 .id_table = ipw2100_pci_id_table,
6491 .probe = ipw2100_pci_init_one,
6492 .remove = __devexit_p(ipw2100_pci_remove_one),
6494 .suspend = ipw2100_suspend,
6495 .resume = ipw2100_resume,
6500 * Initialize the ipw2100 driver/module
6502 * @returns 0 if ok, < 0 errno node con error.
6504 * Note: we cannot init the /proc stuff until the PCI driver is there,
6505 * or we risk an unlikely race condition on someone accessing
6506 * uninitialized data in the PCI dev struct through /proc.
6508 static int __init ipw2100_init(void)
6512 printk(KERN_INFO DRV_NAME ": %s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
6513 printk(KERN_INFO DRV_NAME ": %s\n", DRV_COPYRIGHT);
6515 ret = pci_register_driver(&ipw2100_pci_driver);
6519 set_acceptable_latency("ipw2100", INFINITE_LATENCY);
6520 #ifdef CONFIG_IPW2100_DEBUG
6521 ipw2100_debug_level = debug;
6522 ret = driver_create_file(&ipw2100_pci_driver.driver,
6523 &driver_attr_debug_level);
6531 * Cleanup ipw2100 driver registration
6533 static void __exit ipw2100_exit(void)
6535 /* FIXME: IPG: check that we have no instances of the devices open */
6536 #ifdef CONFIG_IPW2100_DEBUG
6537 driver_remove_file(&ipw2100_pci_driver.driver,
6538 &driver_attr_debug_level);
6540 pci_unregister_driver(&ipw2100_pci_driver);
6541 remove_acceptable_latency("ipw2100");
6544 module_init(ipw2100_init);
6545 module_exit(ipw2100_exit);
6547 #define WEXT_USECHANNELS 1
6549 static const long ipw2100_frequencies[] = {
6550 2412, 2417, 2422, 2427,
6551 2432, 2437, 2442, 2447,
6552 2452, 2457, 2462, 2467,
6556 #define FREQ_COUNT (sizeof(ipw2100_frequencies) / \
6557 sizeof(ipw2100_frequencies[0]))
6559 static const long ipw2100_rates_11b[] = {
6566 #define RATE_COUNT ARRAY_SIZE(ipw2100_rates_11b)
6568 static int ipw2100_wx_get_name(struct net_device *dev,
6569 struct iw_request_info *info,
6570 union iwreq_data *wrqu, char *extra)
6573 * This can be called at any time. No action lock required
6576 struct ipw2100_priv *priv = ieee80211_priv(dev);
6577 if (!(priv->status & STATUS_ASSOCIATED))
6578 strcpy(wrqu->name, "unassociated");
6580 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b");
6582 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
6586 static int ipw2100_wx_set_freq(struct net_device *dev,
6587 struct iw_request_info *info,
6588 union iwreq_data *wrqu, char *extra)
6590 struct ipw2100_priv *priv = ieee80211_priv(dev);
6591 struct iw_freq *fwrq = &wrqu->freq;
6594 if (priv->ieee->iw_mode == IW_MODE_INFRA)
6597 mutex_lock(&priv->action_mutex);
6598 if (!(priv->status & STATUS_INITIALIZED)) {
6603 /* if setting by freq convert to channel */
6605 if ((fwrq->m >= (int)2.412e8 && fwrq->m <= (int)2.487e8)) {
6606 int f = fwrq->m / 100000;
6609 while ((c < REG_MAX_CHANNEL) &&
6610 (f != ipw2100_frequencies[c]))
6613 /* hack to fall through */
6619 if (fwrq->e > 0 || fwrq->m > 1000) {
6622 } else { /* Set the channel */
6623 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
6624 err = ipw2100_set_channel(priv, fwrq->m, 0);
6628 mutex_unlock(&priv->action_mutex);
6632 static int ipw2100_wx_get_freq(struct net_device *dev,
6633 struct iw_request_info *info,
6634 union iwreq_data *wrqu, char *extra)
6637 * This can be called at any time. No action lock required
6640 struct ipw2100_priv *priv = ieee80211_priv(dev);
6644 /* If we are associated, trying to associate, or have a statically
6645 * configured CHANNEL then return that; otherwise return ANY */
6646 if (priv->config & CFG_STATIC_CHANNEL ||
6647 priv->status & STATUS_ASSOCIATED)
6648 wrqu->freq.m = priv->channel;
6652 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
6657 static int ipw2100_wx_set_mode(struct net_device *dev,
6658 struct iw_request_info *info,
6659 union iwreq_data *wrqu, char *extra)
6661 struct ipw2100_priv *priv = ieee80211_priv(dev);
6664 IPW_DEBUG_WX("SET Mode -> %d \n", wrqu->mode);
6666 if (wrqu->mode == priv->ieee->iw_mode)
6669 mutex_lock(&priv->action_mutex);
6670 if (!(priv->status & STATUS_INITIALIZED)) {
6675 switch (wrqu->mode) {
6676 #ifdef CONFIG_IPW2100_MONITOR
6677 case IW_MODE_MONITOR:
6678 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR);
6680 #endif /* CONFIG_IPW2100_MONITOR */
6682 err = ipw2100_switch_mode(priv, IW_MODE_ADHOC);
6687 err = ipw2100_switch_mode(priv, IW_MODE_INFRA);
6692 mutex_unlock(&priv->action_mutex);
6696 static int ipw2100_wx_get_mode(struct net_device *dev,
6697 struct iw_request_info *info,
6698 union iwreq_data *wrqu, char *extra)
6701 * This can be called at any time. No action lock required
6704 struct ipw2100_priv *priv = ieee80211_priv(dev);
6706 wrqu->mode = priv->ieee->iw_mode;
6707 IPW_DEBUG_WX("GET Mode -> %d\n", wrqu->mode);
6712 #define POWER_MODES 5
6714 /* Values are in microsecond */
6715 static const s32 timeout_duration[POWER_MODES] = {
6723 static const s32 period_duration[POWER_MODES] = {
6731 static int ipw2100_wx_get_range(struct net_device *dev,
6732 struct iw_request_info *info,
6733 union iwreq_data *wrqu, char *extra)
6736 * This can be called at any time. No action lock required
6739 struct ipw2100_priv *priv = ieee80211_priv(dev);
6740 struct iw_range *range = (struct iw_range *)extra;
6744 wrqu->data.length = sizeof(*range);
6745 memset(range, 0, sizeof(*range));
6747 /* Let's try to keep this struct in the same order as in
6748 * linux/include/wireless.h
6751 /* TODO: See what values we can set, and remove the ones we can't
6752 * set, or fill them with some default data.
6755 /* ~5 Mb/s real (802.11b) */
6756 range->throughput = 5 * 1000 * 1000;
6758 // range->sensitivity; /* signal level threshold range */
6760 range->max_qual.qual = 100;
6761 /* TODO: Find real max RSSI and stick here */
6762 range->max_qual.level = 0;
6763 range->max_qual.noise = 0;
6764 range->max_qual.updated = 7; /* Updated all three */
6766 range->avg_qual.qual = 70; /* > 8% missed beacons is 'bad' */
6767 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
6768 range->avg_qual.level = 20 + IPW2100_RSSI_TO_DBM;
6769 range->avg_qual.noise = 0;
6770 range->avg_qual.updated = 7; /* Updated all three */
6772 range->num_bitrates = RATE_COUNT;
6774 for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) {
6775 range->bitrate[i] = ipw2100_rates_11b[i];
6778 range->min_rts = MIN_RTS_THRESHOLD;
6779 range->max_rts = MAX_RTS_THRESHOLD;
6780 range->min_frag = MIN_FRAG_THRESHOLD;
6781 range->max_frag = MAX_FRAG_THRESHOLD;
6783 range->min_pmp = period_duration[0]; /* Minimal PM period */
6784 range->max_pmp = period_duration[POWER_MODES - 1]; /* Maximal PM period */
6785 range->min_pmt = timeout_duration[POWER_MODES - 1]; /* Minimal PM timeout */
6786 range->max_pmt = timeout_duration[0]; /* Maximal PM timeout */
6788 /* How to decode max/min PM period */
6789 range->pmp_flags = IW_POWER_PERIOD;
6790 /* How to decode max/min PM period */
6791 range->pmt_flags = IW_POWER_TIMEOUT;
6792 /* What PM options are supported */
6793 range->pm_capa = IW_POWER_TIMEOUT | IW_POWER_PERIOD;
6795 range->encoding_size[0] = 5;
6796 range->encoding_size[1] = 13; /* Different token sizes */
6797 range->num_encoding_sizes = 2; /* Number of entry in the list */
6798 range->max_encoding_tokens = WEP_KEYS; /* Max number of tokens */
6799 // range->encoding_login_index; /* token index for login token */
6801 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6802 range->txpower_capa = IW_TXPOW_DBM;
6803 range->num_txpower = IW_MAX_TXPOWER;
6804 for (i = 0, level = (IPW_TX_POWER_MAX_DBM * 16);
6807 ((IPW_TX_POWER_MAX_DBM -
6808 IPW_TX_POWER_MIN_DBM) * 16) / (IW_MAX_TXPOWER - 1))
6809 range->txpower[i] = level / 16;
6811 range->txpower_capa = 0;
6812 range->num_txpower = 0;
6815 /* Set the Wireless Extension versions */
6816 range->we_version_compiled = WIRELESS_EXT;
6817 range->we_version_source = 18;
6819 // range->retry_capa; /* What retry options are supported */
6820 // range->retry_flags; /* How to decode max/min retry limit */
6821 // range->r_time_flags; /* How to decode max/min retry life */
6822 // range->min_retry; /* Minimal number of retries */
6823 // range->max_retry; /* Maximal number of retries */
6824 // range->min_r_time; /* Minimal retry lifetime */
6825 // range->max_r_time; /* Maximal retry lifetime */
6827 range->num_channels = FREQ_COUNT;
6830 for (i = 0; i < FREQ_COUNT; i++) {
6831 // TODO: Include only legal frequencies for some countries
6832 // if (local->channel_mask & (1 << i)) {
6833 range->freq[val].i = i + 1;
6834 range->freq[val].m = ipw2100_frequencies[i] * 100000;
6835 range->freq[val].e = 1;
6838 if (val == IW_MAX_FREQUENCIES)
6841 range->num_frequency = val;
6843 /* Event capability (kernel + driver) */
6844 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6845 IW_EVENT_CAPA_MASK(SIOCGIWAP));
6846 range->event_capa[1] = IW_EVENT_CAPA_K_1;
6848 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
6849 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
6851 IPW_DEBUG_WX("GET Range\n");
6856 static int ipw2100_wx_set_wap(struct net_device *dev,
6857 struct iw_request_info *info,
6858 union iwreq_data *wrqu, char *extra)
6860 struct ipw2100_priv *priv = ieee80211_priv(dev);
6863 static const unsigned char any[] = {
6864 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
6866 static const unsigned char off[] = {
6867 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
6869 DECLARE_MAC_BUF(mac);
6872 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
6875 mutex_lock(&priv->action_mutex);
6876 if (!(priv->status & STATUS_INITIALIZED)) {
6881 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
6882 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
6883 /* we disable mandatory BSSID association */
6884 IPW_DEBUG_WX("exit - disable mandatory BSSID\n");
6885 priv->config &= ~CFG_STATIC_BSSID;
6886 err = ipw2100_set_mandatory_bssid(priv, NULL, 0);
6890 priv->config |= CFG_STATIC_BSSID;
6891 memcpy(priv->mandatory_bssid_mac, wrqu->ap_addr.sa_data, ETH_ALEN);
6893 err = ipw2100_set_mandatory_bssid(priv, wrqu->ap_addr.sa_data, 0);
6895 IPW_DEBUG_WX("SET BSSID -> %s\n",
6896 print_mac(mac, wrqu->ap_addr.sa_data));
6899 mutex_unlock(&priv->action_mutex);
6903 static int ipw2100_wx_get_wap(struct net_device *dev,
6904 struct iw_request_info *info,
6905 union iwreq_data *wrqu, char *extra)
6908 * This can be called at any time. No action lock required
6911 struct ipw2100_priv *priv = ieee80211_priv(dev);
6912 DECLARE_MAC_BUF(mac);
6914 /* If we are associated, trying to associate, or have a statically
6915 * configured BSSID then return that; otherwise return ANY */
6916 if (priv->config & CFG_STATIC_BSSID || priv->status & STATUS_ASSOCIATED) {
6917 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
6918 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
6920 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
6922 IPW_DEBUG_WX("Getting WAP BSSID: %s\n",
6923 print_mac(mac, wrqu->ap_addr.sa_data));
6927 static int ipw2100_wx_set_essid(struct net_device *dev,
6928 struct iw_request_info *info,
6929 union iwreq_data *wrqu, char *extra)
6931 struct ipw2100_priv *priv = ieee80211_priv(dev);
6932 char *essid = ""; /* ANY */
6936 mutex_lock(&priv->action_mutex);
6937 if (!(priv->status & STATUS_INITIALIZED)) {
6942 if (wrqu->essid.flags && wrqu->essid.length) {
6943 length = wrqu->essid.length;
6948 IPW_DEBUG_WX("Setting ESSID to ANY\n");
6949 priv->config &= ~CFG_STATIC_ESSID;
6950 err = ipw2100_set_essid(priv, NULL, 0, 0);
6954 length = min(length, IW_ESSID_MAX_SIZE);
6956 priv->config |= CFG_STATIC_ESSID;
6958 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
6959 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
6964 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
6967 priv->essid_len = length;
6968 memcpy(priv->essid, essid, priv->essid_len);
6970 err = ipw2100_set_essid(priv, essid, length, 0);
6973 mutex_unlock(&priv->action_mutex);
6977 static int ipw2100_wx_get_essid(struct net_device *dev,
6978 struct iw_request_info *info,
6979 union iwreq_data *wrqu, char *extra)
6982 * This can be called at any time. No action lock required
6985 struct ipw2100_priv *priv = ieee80211_priv(dev);
6987 /* If we are associated, trying to associate, or have a statically
6988 * configured ESSID then return that; otherwise return ANY */
6989 if (priv->config & CFG_STATIC_ESSID || priv->status & STATUS_ASSOCIATED) {
6990 IPW_DEBUG_WX("Getting essid: '%s'\n",
6991 escape_essid(priv->essid, priv->essid_len));
6992 memcpy(extra, priv->essid, priv->essid_len);
6993 wrqu->essid.length = priv->essid_len;
6994 wrqu->essid.flags = 1; /* active */
6996 IPW_DEBUG_WX("Getting essid: ANY\n");
6997 wrqu->essid.length = 0;
6998 wrqu->essid.flags = 0; /* active */
7004 static int ipw2100_wx_set_nick(struct net_device *dev,
7005 struct iw_request_info *info,
7006 union iwreq_data *wrqu, char *extra)
7009 * This can be called at any time. No action lock required
7012 struct ipw2100_priv *priv = ieee80211_priv(dev);
7014 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
7017 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
7018 memset(priv->nick, 0, sizeof(priv->nick));
7019 memcpy(priv->nick, extra, wrqu->data.length);
7021 IPW_DEBUG_WX("SET Nickname -> %s \n", priv->nick);
7026 static int ipw2100_wx_get_nick(struct net_device *dev,
7027 struct iw_request_info *info,
7028 union iwreq_data *wrqu, char *extra)
7031 * This can be called at any time. No action lock required
7034 struct ipw2100_priv *priv = ieee80211_priv(dev);
7036 wrqu->data.length = strlen(priv->nick);
7037 memcpy(extra, priv->nick, wrqu->data.length);
7038 wrqu->data.flags = 1; /* active */
7040 IPW_DEBUG_WX("GET Nickname -> %s \n", extra);
7045 static int ipw2100_wx_set_rate(struct net_device *dev,
7046 struct iw_request_info *info,
7047 union iwreq_data *wrqu, char *extra)
7049 struct ipw2100_priv *priv = ieee80211_priv(dev);
7050 u32 target_rate = wrqu->bitrate.value;
7054 mutex_lock(&priv->action_mutex);
7055 if (!(priv->status & STATUS_INITIALIZED)) {
7062 if (target_rate == 1000000 ||
7063 (!wrqu->bitrate.fixed && target_rate > 1000000))
7064 rate |= TX_RATE_1_MBIT;
7065 if (target_rate == 2000000 ||
7066 (!wrqu->bitrate.fixed && target_rate > 2000000))
7067 rate |= TX_RATE_2_MBIT;
7068 if (target_rate == 5500000 ||
7069 (!wrqu->bitrate.fixed && target_rate > 5500000))
7070 rate |= TX_RATE_5_5_MBIT;
7071 if (target_rate == 11000000 ||
7072 (!wrqu->bitrate.fixed && target_rate > 11000000))
7073 rate |= TX_RATE_11_MBIT;
7075 rate = DEFAULT_TX_RATES;
7077 err = ipw2100_set_tx_rates(priv, rate, 0);
7079 IPW_DEBUG_WX("SET Rate -> %04X \n", rate);
7081 mutex_unlock(&priv->action_mutex);
7085 static int ipw2100_wx_get_rate(struct net_device *dev,
7086 struct iw_request_info *info,
7087 union iwreq_data *wrqu, char *extra)
7089 struct ipw2100_priv *priv = ieee80211_priv(dev);
7091 int len = sizeof(val);
7094 if (!(priv->status & STATUS_ENABLED) ||
7095 priv->status & STATUS_RF_KILL_MASK ||
7096 !(priv->status & STATUS_ASSOCIATED)) {
7097 wrqu->bitrate.value = 0;
7101 mutex_lock(&priv->action_mutex);
7102 if (!(priv->status & STATUS_INITIALIZED)) {
7107 err = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &val, &len);
7109 IPW_DEBUG_WX("failed querying ordinals.\n");
7113 switch (val & TX_RATE_MASK) {
7114 case TX_RATE_1_MBIT:
7115 wrqu->bitrate.value = 1000000;
7117 case TX_RATE_2_MBIT:
7118 wrqu->bitrate.value = 2000000;
7120 case TX_RATE_5_5_MBIT:
7121 wrqu->bitrate.value = 5500000;
7123 case TX_RATE_11_MBIT:
7124 wrqu->bitrate.value = 11000000;
7127 wrqu->bitrate.value = 0;
7130 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
7133 mutex_unlock(&priv->action_mutex);
7137 static int ipw2100_wx_set_rts(struct net_device *dev,
7138 struct iw_request_info *info,
7139 union iwreq_data *wrqu, char *extra)
7141 struct ipw2100_priv *priv = ieee80211_priv(dev);
7144 /* Auto RTS not yet supported */
7145 if (wrqu->rts.fixed == 0)
7148 mutex_lock(&priv->action_mutex);
7149 if (!(priv->status & STATUS_INITIALIZED)) {
7154 if (wrqu->rts.disabled)
7155 value = priv->rts_threshold | RTS_DISABLED;
7157 if (wrqu->rts.value < 1 || wrqu->rts.value > 2304) {
7161 value = wrqu->rts.value;
7164 err = ipw2100_set_rts_threshold(priv, value);
7166 IPW_DEBUG_WX("SET RTS Threshold -> 0x%08X \n", value);
7168 mutex_unlock(&priv->action_mutex);
7172 static int ipw2100_wx_get_rts(struct net_device *dev,
7173 struct iw_request_info *info,
7174 union iwreq_data *wrqu, char *extra)
7177 * This can be called at any time. No action lock required
7180 struct ipw2100_priv *priv = ieee80211_priv(dev);
7182 wrqu->rts.value = priv->rts_threshold & ~RTS_DISABLED;
7183 wrqu->rts.fixed = 1; /* no auto select */
7185 /* If RTS is set to the default value, then it is disabled */
7186 wrqu->rts.disabled = (priv->rts_threshold & RTS_DISABLED) ? 1 : 0;
7188 IPW_DEBUG_WX("GET RTS Threshold -> 0x%08X \n", wrqu->rts.value);
7193 static int ipw2100_wx_set_txpow(struct net_device *dev,
7194 struct iw_request_info *info,
7195 union iwreq_data *wrqu, char *extra)
7197 struct ipw2100_priv *priv = ieee80211_priv(dev);
7200 if (ipw_radio_kill_sw(priv, wrqu->txpower.disabled))
7201 return -EINPROGRESS;
7203 if (priv->ieee->iw_mode != IW_MODE_ADHOC)
7206 if ((wrqu->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)
7209 if (wrqu->txpower.fixed == 0)
7210 value = IPW_TX_POWER_DEFAULT;
7212 if (wrqu->txpower.value < IPW_TX_POWER_MIN_DBM ||
7213 wrqu->txpower.value > IPW_TX_POWER_MAX_DBM)
7216 value = wrqu->txpower.value;
7219 mutex_lock(&priv->action_mutex);
7220 if (!(priv->status & STATUS_INITIALIZED)) {
7225 err = ipw2100_set_tx_power(priv, value);
7227 IPW_DEBUG_WX("SET TX Power -> %d \n", value);
7230 mutex_unlock(&priv->action_mutex);
7234 static int ipw2100_wx_get_txpow(struct net_device *dev,
7235 struct iw_request_info *info,
7236 union iwreq_data *wrqu, char *extra)
7239 * This can be called at any time. No action lock required
7242 struct ipw2100_priv *priv = ieee80211_priv(dev);
7244 wrqu->txpower.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
7246 if (priv->tx_power == IPW_TX_POWER_DEFAULT) {
7247 wrqu->txpower.fixed = 0;
7248 wrqu->txpower.value = IPW_TX_POWER_MAX_DBM;
7250 wrqu->txpower.fixed = 1;
7251 wrqu->txpower.value = priv->tx_power;
7254 wrqu->txpower.flags = IW_TXPOW_DBM;
7256 IPW_DEBUG_WX("GET TX Power -> %d \n", wrqu->txpower.value);
7261 static int ipw2100_wx_set_frag(struct net_device *dev,
7262 struct iw_request_info *info,
7263 union iwreq_data *wrqu, char *extra)
7266 * This can be called at any time. No action lock required
7269 struct ipw2100_priv *priv = ieee80211_priv(dev);
7271 if (!wrqu->frag.fixed)
7274 if (wrqu->frag.disabled) {
7275 priv->frag_threshold |= FRAG_DISABLED;
7276 priv->ieee->fts = DEFAULT_FTS;
7278 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
7279 wrqu->frag.value > MAX_FRAG_THRESHOLD)
7282 priv->ieee->fts = wrqu->frag.value & ~0x1;
7283 priv->frag_threshold = priv->ieee->fts;
7286 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", priv->ieee->fts);
7291 static int ipw2100_wx_get_frag(struct net_device *dev,
7292 struct iw_request_info *info,
7293 union iwreq_data *wrqu, char *extra)
7296 * This can be called at any time. No action lock required
7299 struct ipw2100_priv *priv = ieee80211_priv(dev);
7300 wrqu->frag.value = priv->frag_threshold & ~FRAG_DISABLED;
7301 wrqu->frag.fixed = 0; /* no auto select */
7302 wrqu->frag.disabled = (priv->frag_threshold & FRAG_DISABLED) ? 1 : 0;
7304 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
7309 static int ipw2100_wx_set_retry(struct net_device *dev,
7310 struct iw_request_info *info,
7311 union iwreq_data *wrqu, char *extra)
7313 struct ipw2100_priv *priv = ieee80211_priv(dev);
7316 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
7319 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
7322 mutex_lock(&priv->action_mutex);
7323 if (!(priv->status & STATUS_INITIALIZED)) {
7328 if (wrqu->retry.flags & IW_RETRY_SHORT) {
7329 err = ipw2100_set_short_retry(priv, wrqu->retry.value);
7330 IPW_DEBUG_WX("SET Short Retry Limit -> %d \n",
7335 if (wrqu->retry.flags & IW_RETRY_LONG) {
7336 err = ipw2100_set_long_retry(priv, wrqu->retry.value);
7337 IPW_DEBUG_WX("SET Long Retry Limit -> %d \n",
7342 err = ipw2100_set_short_retry(priv, wrqu->retry.value);
7344 err = ipw2100_set_long_retry(priv, wrqu->retry.value);
7346 IPW_DEBUG_WX("SET Both Retry Limits -> %d \n", wrqu->retry.value);
7349 mutex_unlock(&priv->action_mutex);
7353 static int ipw2100_wx_get_retry(struct net_device *dev,
7354 struct iw_request_info *info,
7355 union iwreq_data *wrqu, char *extra)
7358 * This can be called at any time. No action lock required
7361 struct ipw2100_priv *priv = ieee80211_priv(dev);
7363 wrqu->retry.disabled = 0; /* can't be disabled */
7365 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME)
7368 if (wrqu->retry.flags & IW_RETRY_LONG) {
7369 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
7370 wrqu->retry.value = priv->long_retry_limit;
7373 (priv->short_retry_limit !=
7374 priv->long_retry_limit) ?
7375 IW_RETRY_LIMIT | IW_RETRY_SHORT : IW_RETRY_LIMIT;
7377 wrqu->retry.value = priv->short_retry_limit;
7380 IPW_DEBUG_WX("GET Retry -> %d \n", wrqu->retry.value);
7385 static int ipw2100_wx_set_scan(struct net_device *dev,
7386 struct iw_request_info *info,
7387 union iwreq_data *wrqu, char *extra)
7389 struct ipw2100_priv *priv = ieee80211_priv(dev);
7392 mutex_lock(&priv->action_mutex);
7393 if (!(priv->status & STATUS_INITIALIZED)) {
7398 IPW_DEBUG_WX("Initiating scan...\n");
7399 if (ipw2100_set_scan_options(priv) || ipw2100_start_scan(priv)) {
7400 IPW_DEBUG_WX("Start scan failed.\n");
7402 /* TODO: Mark a scan as pending so when hardware initialized
7407 mutex_unlock(&priv->action_mutex);
7411 static int ipw2100_wx_get_scan(struct net_device *dev,
7412 struct iw_request_info *info,
7413 union iwreq_data *wrqu, char *extra)
7416 * This can be called at any time. No action lock required
7419 struct ipw2100_priv *priv = ieee80211_priv(dev);
7420 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
7424 * Implementation based on code in hostap-driver v0.1.3 hostap_ioctl.c
7426 static int ipw2100_wx_set_encode(struct net_device *dev,
7427 struct iw_request_info *info,
7428 union iwreq_data *wrqu, char *key)
7431 * No check of STATUS_INITIALIZED required
7434 struct ipw2100_priv *priv = ieee80211_priv(dev);
7435 return ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
7438 static int ipw2100_wx_get_encode(struct net_device *dev,
7439 struct iw_request_info *info,
7440 union iwreq_data *wrqu, char *key)
7443 * This can be called at any time. No action lock required
7446 struct ipw2100_priv *priv = ieee80211_priv(dev);
7447 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
7450 static int ipw2100_wx_set_power(struct net_device *dev,
7451 struct iw_request_info *info,
7452 union iwreq_data *wrqu, char *extra)
7454 struct ipw2100_priv *priv = ieee80211_priv(dev);
7457 mutex_lock(&priv->action_mutex);
7458 if (!(priv->status & STATUS_INITIALIZED)) {
7463 if (wrqu->power.disabled) {
7464 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
7465 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM);
7466 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
7470 switch (wrqu->power.flags & IW_POWER_MODE) {
7471 case IW_POWER_ON: /* If not specified */
7472 case IW_POWER_MODE: /* If set all mask */
7473 case IW_POWER_ALL_R: /* If explicitely state all */
7475 default: /* Otherwise we don't support it */
7476 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
7482 /* If the user hasn't specified a power management mode yet, default
7484 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
7485 err = ipw2100_set_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
7487 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
7490 mutex_unlock(&priv->action_mutex);
7495 static int ipw2100_wx_get_power(struct net_device *dev,
7496 struct iw_request_info *info,
7497 union iwreq_data *wrqu, char *extra)
7500 * This can be called at any time. No action lock required
7503 struct ipw2100_priv *priv = ieee80211_priv(dev);
7505 if (!(priv->power_mode & IPW_POWER_ENABLED))
7506 wrqu->power.disabled = 1;
7508 wrqu->power.disabled = 0;
7509 wrqu->power.flags = 0;
7512 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
7522 static int ipw2100_wx_set_genie(struct net_device *dev,
7523 struct iw_request_info *info,
7524 union iwreq_data *wrqu, char *extra)
7527 struct ipw2100_priv *priv = ieee80211_priv(dev);
7528 struct ieee80211_device *ieee = priv->ieee;
7531 if (!ieee->wpa_enabled)
7534 if (wrqu->data.length > MAX_WPA_IE_LEN ||
7535 (wrqu->data.length && extra == NULL))
7538 if (wrqu->data.length) {
7539 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
7543 kfree(ieee->wpa_ie);
7545 ieee->wpa_ie_len = wrqu->data.length;
7547 kfree(ieee->wpa_ie);
7548 ieee->wpa_ie = NULL;
7549 ieee->wpa_ie_len = 0;
7552 ipw2100_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
7558 static int ipw2100_wx_get_genie(struct net_device *dev,
7559 struct iw_request_info *info,
7560 union iwreq_data *wrqu, char *extra)
7562 struct ipw2100_priv *priv = ieee80211_priv(dev);
7563 struct ieee80211_device *ieee = priv->ieee;
7565 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
7566 wrqu->data.length = 0;
7570 if (wrqu->data.length < ieee->wpa_ie_len)
7573 wrqu->data.length = ieee->wpa_ie_len;
7574 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
7580 static int ipw2100_wx_set_auth(struct net_device *dev,
7581 struct iw_request_info *info,
7582 union iwreq_data *wrqu, char *extra)
7584 struct ipw2100_priv *priv = ieee80211_priv(dev);
7585 struct ieee80211_device *ieee = priv->ieee;
7586 struct iw_param *param = &wrqu->param;
7587 struct ieee80211_crypt_data *crypt;
7588 unsigned long flags;
7591 switch (param->flags & IW_AUTH_INDEX) {
7592 case IW_AUTH_WPA_VERSION:
7593 case IW_AUTH_CIPHER_PAIRWISE:
7594 case IW_AUTH_CIPHER_GROUP:
7595 case IW_AUTH_KEY_MGMT:
7597 * ipw2200 does not use these parameters
7601 case IW_AUTH_TKIP_COUNTERMEASURES:
7602 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
7603 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
7606 flags = crypt->ops->get_flags(crypt->priv);
7609 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
7611 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
7613 crypt->ops->set_flags(flags, crypt->priv);
7617 case IW_AUTH_DROP_UNENCRYPTED:{
7620 * wpa_supplicant calls set_wpa_enabled when the driver
7621 * is loaded and unloaded, regardless of if WPA is being
7622 * used. No other calls are made which can be used to
7623 * determine if encryption will be used or not prior to
7624 * association being expected. If encryption is not being
7625 * used, drop_unencrypted is set to false, else true -- we
7626 * can use this to determine if the CAP_PRIVACY_ON bit should
7629 struct ieee80211_security sec = {
7630 .flags = SEC_ENABLED,
7631 .enabled = param->value,
7633 priv->ieee->drop_unencrypted = param->value;
7634 /* We only change SEC_LEVEL for open mode. Others
7635 * are set by ipw_wpa_set_encryption.
7637 if (!param->value) {
7638 sec.flags |= SEC_LEVEL;
7639 sec.level = SEC_LEVEL_0;
7641 sec.flags |= SEC_LEVEL;
7642 sec.level = SEC_LEVEL_1;
7644 if (priv->ieee->set_security)
7645 priv->ieee->set_security(priv->ieee->dev, &sec);
7649 case IW_AUTH_80211_AUTH_ALG:
7650 ret = ipw2100_wpa_set_auth_algs(priv, param->value);
7653 case IW_AUTH_WPA_ENABLED:
7654 ret = ipw2100_wpa_enable(priv, param->value);
7657 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
7658 ieee->ieee802_1x = param->value;
7661 //case IW_AUTH_ROAMING_CONTROL:
7662 case IW_AUTH_PRIVACY_INVOKED:
7663 ieee->privacy_invoked = param->value;
7673 static int ipw2100_wx_get_auth(struct net_device *dev,
7674 struct iw_request_info *info,
7675 union iwreq_data *wrqu, char *extra)
7677 struct ipw2100_priv *priv = ieee80211_priv(dev);
7678 struct ieee80211_device *ieee = priv->ieee;
7679 struct ieee80211_crypt_data *crypt;
7680 struct iw_param *param = &wrqu->param;
7683 switch (param->flags & IW_AUTH_INDEX) {
7684 case IW_AUTH_WPA_VERSION:
7685 case IW_AUTH_CIPHER_PAIRWISE:
7686 case IW_AUTH_CIPHER_GROUP:
7687 case IW_AUTH_KEY_MGMT:
7689 * wpa_supplicant will control these internally
7694 case IW_AUTH_TKIP_COUNTERMEASURES:
7695 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
7696 if (!crypt || !crypt->ops->get_flags) {
7697 IPW_DEBUG_WARNING("Can't get TKIP countermeasures: "
7698 "crypt not set!\n");
7702 param->value = (crypt->ops->get_flags(crypt->priv) &
7703 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
7707 case IW_AUTH_DROP_UNENCRYPTED:
7708 param->value = ieee->drop_unencrypted;
7711 case IW_AUTH_80211_AUTH_ALG:
7712 param->value = priv->ieee->sec.auth_mode;
7715 case IW_AUTH_WPA_ENABLED:
7716 param->value = ieee->wpa_enabled;
7719 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
7720 param->value = ieee->ieee802_1x;
7723 case IW_AUTH_ROAMING_CONTROL:
7724 case IW_AUTH_PRIVACY_INVOKED:
7725 param->value = ieee->privacy_invoked;
7734 /* SIOCSIWENCODEEXT */
7735 static int ipw2100_wx_set_encodeext(struct net_device *dev,
7736 struct iw_request_info *info,
7737 union iwreq_data *wrqu, char *extra)
7739 struct ipw2100_priv *priv = ieee80211_priv(dev);
7740 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
7743 /* SIOCGIWENCODEEXT */
7744 static int ipw2100_wx_get_encodeext(struct net_device *dev,
7745 struct iw_request_info *info,
7746 union iwreq_data *wrqu, char *extra)
7748 struct ipw2100_priv *priv = ieee80211_priv(dev);
7749 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
7753 static int ipw2100_wx_set_mlme(struct net_device *dev,
7754 struct iw_request_info *info,
7755 union iwreq_data *wrqu, char *extra)
7757 struct ipw2100_priv *priv = ieee80211_priv(dev);
7758 struct iw_mlme *mlme = (struct iw_mlme *)extra;
7761 reason = cpu_to_le16(mlme->reason_code);
7763 switch (mlme->cmd) {
7764 case IW_MLME_DEAUTH:
7768 case IW_MLME_DISASSOC:
7769 ipw2100_disassociate_bssid(priv);
7783 #ifdef CONFIG_IPW2100_MONITOR
7784 static int ipw2100_wx_set_promisc(struct net_device *dev,
7785 struct iw_request_info *info,
7786 union iwreq_data *wrqu, char *extra)
7788 struct ipw2100_priv *priv = ieee80211_priv(dev);
7789 int *parms = (int *)extra;
7790 int enable = (parms[0] > 0);
7793 mutex_lock(&priv->action_mutex);
7794 if (!(priv->status & STATUS_INITIALIZED)) {
7800 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7801 err = ipw2100_set_channel(priv, parms[1], 0);
7804 priv->channel = parms[1];
7805 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR);
7807 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
7808 err = ipw2100_switch_mode(priv, priv->last_mode);
7811 mutex_unlock(&priv->action_mutex);
7815 static int ipw2100_wx_reset(struct net_device *dev,
7816 struct iw_request_info *info,
7817 union iwreq_data *wrqu, char *extra)
7819 struct ipw2100_priv *priv = ieee80211_priv(dev);
7820 if (priv->status & STATUS_INITIALIZED)
7821 schedule_reset(priv);
7827 static int ipw2100_wx_set_powermode(struct net_device *dev,
7828 struct iw_request_info *info,
7829 union iwreq_data *wrqu, char *extra)
7831 struct ipw2100_priv *priv = ieee80211_priv(dev);
7832 int err = 0, mode = *(int *)extra;
7834 mutex_lock(&priv->action_mutex);
7835 if (!(priv->status & STATUS_INITIALIZED)) {
7840 if ((mode < 0) || (mode > POWER_MODES))
7841 mode = IPW_POWER_AUTO;
7843 if (IPW_POWER_LEVEL(priv->power_mode) != mode)
7844 err = ipw2100_set_power_mode(priv, mode);
7846 mutex_unlock(&priv->action_mutex);
7850 #define MAX_POWER_STRING 80
7851 static int ipw2100_wx_get_powermode(struct net_device *dev,
7852 struct iw_request_info *info,
7853 union iwreq_data *wrqu, char *extra)
7856 * This can be called at any time. No action lock required
7859 struct ipw2100_priv *priv = ieee80211_priv(dev);
7860 int level = IPW_POWER_LEVEL(priv->power_mode);
7861 s32 timeout, period;
7863 if (!(priv->power_mode & IPW_POWER_ENABLED)) {
7864 snprintf(extra, MAX_POWER_STRING,
7865 "Power save level: %d (Off)", level);
7868 case IPW_POWER_MODE_CAM:
7869 snprintf(extra, MAX_POWER_STRING,
7870 "Power save level: %d (None)", level);
7872 case IPW_POWER_AUTO:
7873 snprintf(extra, MAX_POWER_STRING,
7874 "Power save level: %d (Auto)", level);
7877 timeout = timeout_duration[level - 1] / 1000;
7878 period = period_duration[level - 1] / 1000;
7879 snprintf(extra, MAX_POWER_STRING,
7880 "Power save level: %d "
7881 "(Timeout %dms, Period %dms)",
7882 level, timeout, period);
7886 wrqu->data.length = strlen(extra) + 1;
7891 static int ipw2100_wx_set_preamble(struct net_device *dev,
7892 struct iw_request_info *info,
7893 union iwreq_data *wrqu, char *extra)
7895 struct ipw2100_priv *priv = ieee80211_priv(dev);
7896 int err, mode = *(int *)extra;
7898 mutex_lock(&priv->action_mutex);
7899 if (!(priv->status & STATUS_INITIALIZED)) {
7905 priv->config |= CFG_LONG_PREAMBLE;
7907 priv->config &= ~CFG_LONG_PREAMBLE;
7913 err = ipw2100_system_config(priv, 0);
7916 mutex_unlock(&priv->action_mutex);
7920 static int ipw2100_wx_get_preamble(struct net_device *dev,
7921 struct iw_request_info *info,
7922 union iwreq_data *wrqu, char *extra)
7925 * This can be called at any time. No action lock required
7928 struct ipw2100_priv *priv = ieee80211_priv(dev);
7930 if (priv->config & CFG_LONG_PREAMBLE)
7931 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
7933 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
7938 #ifdef CONFIG_IPW2100_MONITOR
7939 static int ipw2100_wx_set_crc_check(struct net_device *dev,
7940 struct iw_request_info *info,
7941 union iwreq_data *wrqu, char *extra)
7943 struct ipw2100_priv *priv = ieee80211_priv(dev);
7944 int err, mode = *(int *)extra;
7946 mutex_lock(&priv->action_mutex);
7947 if (!(priv->status & STATUS_INITIALIZED)) {
7953 priv->config |= CFG_CRC_CHECK;
7955 priv->config &= ~CFG_CRC_CHECK;
7963 mutex_unlock(&priv->action_mutex);
7967 static int ipw2100_wx_get_crc_check(struct net_device *dev,
7968 struct iw_request_info *info,
7969 union iwreq_data *wrqu, char *extra)
7972 * This can be called at any time. No action lock required
7975 struct ipw2100_priv *priv = ieee80211_priv(dev);
7977 if (priv->config & CFG_CRC_CHECK)
7978 snprintf(wrqu->name, IFNAMSIZ, "CRC checked (1)");
7980 snprintf(wrqu->name, IFNAMSIZ, "CRC ignored (0)");
7984 #endif /* CONFIG_IPW2100_MONITOR */
7986 static iw_handler ipw2100_wx_handlers[] = {
7987 NULL, /* SIOCSIWCOMMIT */
7988 ipw2100_wx_get_name, /* SIOCGIWNAME */
7989 NULL, /* SIOCSIWNWID */
7990 NULL, /* SIOCGIWNWID */
7991 ipw2100_wx_set_freq, /* SIOCSIWFREQ */
7992 ipw2100_wx_get_freq, /* SIOCGIWFREQ */
7993 ipw2100_wx_set_mode, /* SIOCSIWMODE */
7994 ipw2100_wx_get_mode, /* SIOCGIWMODE */
7995 NULL, /* SIOCSIWSENS */
7996 NULL, /* SIOCGIWSENS */
7997 NULL, /* SIOCSIWRANGE */
7998 ipw2100_wx_get_range, /* SIOCGIWRANGE */
7999 NULL, /* SIOCSIWPRIV */
8000 NULL, /* SIOCGIWPRIV */
8001 NULL, /* SIOCSIWSTATS */
8002 NULL, /* SIOCGIWSTATS */
8003 NULL, /* SIOCSIWSPY */
8004 NULL, /* SIOCGIWSPY */
8005 NULL, /* SIOCGIWTHRSPY */
8006 NULL, /* SIOCWIWTHRSPY */
8007 ipw2100_wx_set_wap, /* SIOCSIWAP */
8008 ipw2100_wx_get_wap, /* SIOCGIWAP */
8009 ipw2100_wx_set_mlme, /* SIOCSIWMLME */
8010 NULL, /* SIOCGIWAPLIST -- deprecated */
8011 ipw2100_wx_set_scan, /* SIOCSIWSCAN */
8012 ipw2100_wx_get_scan, /* SIOCGIWSCAN */
8013 ipw2100_wx_set_essid, /* SIOCSIWESSID */
8014 ipw2100_wx_get_essid, /* SIOCGIWESSID */
8015 ipw2100_wx_set_nick, /* SIOCSIWNICKN */
8016 ipw2100_wx_get_nick, /* SIOCGIWNICKN */
8017 NULL, /* -- hole -- */
8018 NULL, /* -- hole -- */
8019 ipw2100_wx_set_rate, /* SIOCSIWRATE */
8020 ipw2100_wx_get_rate, /* SIOCGIWRATE */
8021 ipw2100_wx_set_rts, /* SIOCSIWRTS */
8022 ipw2100_wx_get_rts, /* SIOCGIWRTS */
8023 ipw2100_wx_set_frag, /* SIOCSIWFRAG */
8024 ipw2100_wx_get_frag, /* SIOCGIWFRAG */
8025 ipw2100_wx_set_txpow, /* SIOCSIWTXPOW */
8026 ipw2100_wx_get_txpow, /* SIOCGIWTXPOW */
8027 ipw2100_wx_set_retry, /* SIOCSIWRETRY */
8028 ipw2100_wx_get_retry, /* SIOCGIWRETRY */
8029 ipw2100_wx_set_encode, /* SIOCSIWENCODE */
8030 ipw2100_wx_get_encode, /* SIOCGIWENCODE */
8031 ipw2100_wx_set_power, /* SIOCSIWPOWER */
8032 ipw2100_wx_get_power, /* SIOCGIWPOWER */
8033 NULL, /* -- hole -- */
8034 NULL, /* -- hole -- */
8035 ipw2100_wx_set_genie, /* SIOCSIWGENIE */
8036 ipw2100_wx_get_genie, /* SIOCGIWGENIE */
8037 ipw2100_wx_set_auth, /* SIOCSIWAUTH */
8038 ipw2100_wx_get_auth, /* SIOCGIWAUTH */
8039 ipw2100_wx_set_encodeext, /* SIOCSIWENCODEEXT */
8040 ipw2100_wx_get_encodeext, /* SIOCGIWENCODEEXT */
8041 NULL, /* SIOCSIWPMKSA */
8044 #define IPW2100_PRIV_SET_MONITOR SIOCIWFIRSTPRIV
8045 #define IPW2100_PRIV_RESET SIOCIWFIRSTPRIV+1
8046 #define IPW2100_PRIV_SET_POWER SIOCIWFIRSTPRIV+2
8047 #define IPW2100_PRIV_GET_POWER SIOCIWFIRSTPRIV+3
8048 #define IPW2100_PRIV_SET_LONGPREAMBLE SIOCIWFIRSTPRIV+4
8049 #define IPW2100_PRIV_GET_LONGPREAMBLE SIOCIWFIRSTPRIV+5
8050 #define IPW2100_PRIV_SET_CRC_CHECK SIOCIWFIRSTPRIV+6
8051 #define IPW2100_PRIV_GET_CRC_CHECK SIOCIWFIRSTPRIV+7
8053 static const struct iw_priv_args ipw2100_private_args[] = {
8055 #ifdef CONFIG_IPW2100_MONITOR
8057 IPW2100_PRIV_SET_MONITOR,
8058 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
8061 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
8062 #endif /* CONFIG_IPW2100_MONITOR */
8065 IPW2100_PRIV_SET_POWER,
8066 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_power"},
8068 IPW2100_PRIV_GET_POWER,
8069 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_POWER_STRING,
8072 IPW2100_PRIV_SET_LONGPREAMBLE,
8073 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_preamble"},
8075 IPW2100_PRIV_GET_LONGPREAMBLE,
8076 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_preamble"},
8077 #ifdef CONFIG_IPW2100_MONITOR
8079 IPW2100_PRIV_SET_CRC_CHECK,
8080 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_crc_check"},
8082 IPW2100_PRIV_GET_CRC_CHECK,
8083 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_crc_check"},
8084 #endif /* CONFIG_IPW2100_MONITOR */
8087 static iw_handler ipw2100_private_handler[] = {
8088 #ifdef CONFIG_IPW2100_MONITOR
8089 ipw2100_wx_set_promisc,
8091 #else /* CONFIG_IPW2100_MONITOR */
8094 #endif /* CONFIG_IPW2100_MONITOR */
8095 ipw2100_wx_set_powermode,
8096 ipw2100_wx_get_powermode,
8097 ipw2100_wx_set_preamble,
8098 ipw2100_wx_get_preamble,
8099 #ifdef CONFIG_IPW2100_MONITOR
8100 ipw2100_wx_set_crc_check,
8101 ipw2100_wx_get_crc_check,
8102 #else /* CONFIG_IPW2100_MONITOR */
8105 #endif /* CONFIG_IPW2100_MONITOR */
8109 * Get wireless statistics.
8110 * Called by /proc/net/wireless
8111 * Also called by SIOCGIWSTATS
8113 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev)
8127 struct ipw2100_priv *priv = ieee80211_priv(dev);
8128 struct iw_statistics *wstats;
8129 u32 rssi, quality, tx_retries, missed_beacons, tx_failures;
8130 u32 ord_len = sizeof(u32);
8133 return (struct iw_statistics *)NULL;
8135 wstats = &priv->wstats;
8137 /* if hw is disabled, then ipw2100_get_ordinal() can't be called.
8138 * ipw2100_wx_wireless_stats seems to be called before fw is
8139 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
8140 * and associated; if not associcated, the values are all meaningless
8141 * anyway, so set them all to NULL and INVALID */
8142 if (!(priv->status & STATUS_ASSOCIATED)) {
8143 wstats->miss.beacon = 0;
8144 wstats->discard.retries = 0;
8145 wstats->qual.qual = 0;
8146 wstats->qual.level = 0;
8147 wstats->qual.noise = 0;
8148 wstats->qual.updated = 7;
8149 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
8150 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
8154 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_MISSED_BCNS,
8155 &missed_beacons, &ord_len))
8156 goto fail_get_ordinal;
8158 /* If we don't have a connection the quality and level is 0 */
8159 if (!(priv->status & STATUS_ASSOCIATED)) {
8160 wstats->qual.qual = 0;
8161 wstats->qual.level = 0;
8163 if (ipw2100_get_ordinal(priv, IPW_ORD_RSSI_AVG_CURR,
8165 goto fail_get_ordinal;
8166 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM;
8168 rssi_qual = rssi * POOR / 10;
8170 rssi_qual = (rssi - 10) * (FAIR - POOR) / 5 + POOR;
8172 rssi_qual = (rssi - 15) * (GOOD - FAIR) / 5 + FAIR;
8174 rssi_qual = (rssi - 20) * (VERY_GOOD - GOOD) /
8177 rssi_qual = (rssi - 30) * (PERFECT - VERY_GOOD) /
8180 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_RETRIES,
8181 &tx_retries, &ord_len))
8182 goto fail_get_ordinal;
8184 if (tx_retries > 75)
8185 tx_qual = (90 - tx_retries) * POOR / 15;
8186 else if (tx_retries > 70)
8187 tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR;
8188 else if (tx_retries > 65)
8189 tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR;
8190 else if (tx_retries > 50)
8191 tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) /
8194 tx_qual = (50 - tx_retries) *
8195 (PERFECT - VERY_GOOD) / 50 + VERY_GOOD;
8197 if (missed_beacons > 50)
8198 beacon_qual = (60 - missed_beacons) * POOR / 10;
8199 else if (missed_beacons > 40)
8200 beacon_qual = (50 - missed_beacons) * (FAIR - POOR) /
8202 else if (missed_beacons > 32)
8203 beacon_qual = (40 - missed_beacons) * (GOOD - FAIR) /
8205 else if (missed_beacons > 20)
8206 beacon_qual = (32 - missed_beacons) *
8207 (VERY_GOOD - GOOD) / 20 + GOOD;
8209 beacon_qual = (20 - missed_beacons) *
8210 (PERFECT - VERY_GOOD) / 20 + VERY_GOOD;
8212 quality = min(beacon_qual, min(tx_qual, rssi_qual));
8214 #ifdef CONFIG_IPW2100_DEBUG
8215 if (beacon_qual == quality)
8216 IPW_DEBUG_WX("Quality clamped by Missed Beacons\n");
8217 else if (tx_qual == quality)
8218 IPW_DEBUG_WX("Quality clamped by Tx Retries\n");
8219 else if (quality != 100)
8220 IPW_DEBUG_WX("Quality clamped by Signal Strength\n");
8222 IPW_DEBUG_WX("Quality not clamped.\n");
8225 wstats->qual.qual = quality;
8226 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM;
8229 wstats->qual.noise = 0;
8230 wstats->qual.updated = 7;
8231 wstats->qual.updated |= IW_QUAL_NOISE_INVALID;
8233 /* FIXME: this is percent and not a # */
8234 wstats->miss.beacon = missed_beacons;
8236 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURES,
8237 &tx_failures, &ord_len))
8238 goto fail_get_ordinal;
8239 wstats->discard.retries = tx_failures;
8244 IPW_DEBUG_WX("failed querying ordinals.\n");
8246 return (struct iw_statistics *)NULL;
8249 static struct iw_handler_def ipw2100_wx_handler_def = {
8250 .standard = ipw2100_wx_handlers,
8251 .num_standard = ARRAY_SIZE(ipw2100_wx_handlers),
8252 .num_private = ARRAY_SIZE(ipw2100_private_handler),
8253 .num_private_args = ARRAY_SIZE(ipw2100_private_args),
8254 .private = (iw_handler *) ipw2100_private_handler,
8255 .private_args = (struct iw_priv_args *)ipw2100_private_args,
8256 .get_wireless_stats = ipw2100_wx_wireless_stats,
8259 static void ipw2100_wx_event_work(struct work_struct *work)
8261 struct ipw2100_priv *priv =
8262 container_of(work, struct ipw2100_priv, wx_event_work.work);
8263 union iwreq_data wrqu;
8266 if (priv->status & STATUS_STOPPING)
8269 mutex_lock(&priv->action_mutex);
8271 IPW_DEBUG_WX("enter\n");
8273 mutex_unlock(&priv->action_mutex);
8275 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
8277 /* Fetch BSSID from the hardware */
8278 if (!(priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) ||
8279 priv->status & STATUS_RF_KILL_MASK ||
8280 ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID,
8281 &priv->bssid, &len)) {
8282 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
8284 /* We now have the BSSID, so can finish setting to the full
8285 * associated state */
8286 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
8287 memcpy(priv->ieee->bssid, priv->bssid, ETH_ALEN);
8288 priv->status &= ~STATUS_ASSOCIATING;
8289 priv->status |= STATUS_ASSOCIATED;
8290 netif_carrier_on(priv->net_dev);
8291 netif_wake_queue(priv->net_dev);
8294 if (!(priv->status & STATUS_ASSOCIATED)) {
8295 IPW_DEBUG_WX("Configuring ESSID\n");
8296 mutex_lock(&priv->action_mutex);
8297 /* This is a disassociation event, so kick the firmware to
8298 * look for another AP */
8299 if (priv->config & CFG_STATIC_ESSID)
8300 ipw2100_set_essid(priv, priv->essid, priv->essid_len,
8303 ipw2100_set_essid(priv, NULL, 0, 0);
8304 mutex_unlock(&priv->action_mutex);
8307 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
8310 #define IPW2100_FW_MAJOR_VERSION 1
8311 #define IPW2100_FW_MINOR_VERSION 3
8313 #define IPW2100_FW_MINOR(x) ((x & 0xff) >> 8)
8314 #define IPW2100_FW_MAJOR(x) (x & 0xff)
8316 #define IPW2100_FW_VERSION ((IPW2100_FW_MINOR_VERSION << 8) | \
8317 IPW2100_FW_MAJOR_VERSION)
8319 #define IPW2100_FW_PREFIX "ipw2100-" __stringify(IPW2100_FW_MAJOR_VERSION) \
8320 "." __stringify(IPW2100_FW_MINOR_VERSION)
8322 #define IPW2100_FW_NAME(x) IPW2100_FW_PREFIX "" x ".fw"
8326 BINARY FIRMWARE HEADER FORMAT
8330 2 2 mode == 0:BSS,1:IBSS,2:MONITOR
8333 C fw_len firmware data
8334 12 + fw_len uc_len microcode data
8338 struct ipw2100_fw_header {
8341 unsigned int fw_size;
8342 unsigned int uc_size;
8343 } __attribute__ ((packed));
8345 static int ipw2100_mod_firmware_load(struct ipw2100_fw *fw)
8347 struct ipw2100_fw_header *h =
8348 (struct ipw2100_fw_header *)fw->fw_entry->data;
8350 if (IPW2100_FW_MAJOR(h->version) != IPW2100_FW_MAJOR_VERSION) {
8351 printk(KERN_WARNING DRV_NAME ": Firmware image not compatible "
8352 "(detected version id of %u). "
8353 "See Documentation/networking/README.ipw2100\n",
8358 fw->version = h->version;
8359 fw->fw.data = fw->fw_entry->data + sizeof(struct ipw2100_fw_header);
8360 fw->fw.size = h->fw_size;
8361 fw->uc.data = fw->fw.data + h->fw_size;
8362 fw->uc.size = h->uc_size;
8367 static int ipw2100_get_firmware(struct ipw2100_priv *priv,
8368 struct ipw2100_fw *fw)
8373 IPW_DEBUG_INFO("%s: Using hotplug firmware load.\n",
8374 priv->net_dev->name);
8376 switch (priv->ieee->iw_mode) {
8378 fw_name = IPW2100_FW_NAME("-i");
8380 #ifdef CONFIG_IPW2100_MONITOR
8381 case IW_MODE_MONITOR:
8382 fw_name = IPW2100_FW_NAME("-p");
8387 fw_name = IPW2100_FW_NAME("");
8391 rc = request_firmware(&fw->fw_entry, fw_name, &priv->pci_dev->dev);
8394 printk(KERN_ERR DRV_NAME ": "
8395 "%s: Firmware '%s' not available or load failed.\n",
8396 priv->net_dev->name, fw_name);
8399 IPW_DEBUG_INFO("firmware data %p size %zd\n", fw->fw_entry->data,
8400 fw->fw_entry->size);
8402 ipw2100_mod_firmware_load(fw);
8407 static void ipw2100_release_firmware(struct ipw2100_priv *priv,
8408 struct ipw2100_fw *fw)
8412 release_firmware(fw->fw_entry);
8413 fw->fw_entry = NULL;
8416 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf,
8419 char ver[MAX_FW_VERSION_LEN];
8420 u32 len = MAX_FW_VERSION_LEN;
8423 /* firmware version is an ascii string (max len of 14) */
8424 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_FW_VER_NUM, ver, &len))
8429 for (i = 0; i < len; i++)
8435 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf,
8439 u32 len = sizeof(ver);
8440 /* microcode version is a 32 bit integer */
8441 if (ipw2100_get_ordinal(priv, IPW_ORD_UCODE_VERSION, &ver, &len))
8443 return snprintf(buf, max, "%08X", ver);
8447 * On exit, the firmware will have been freed from the fw list
8449 static int ipw2100_fw_download(struct ipw2100_priv *priv, struct ipw2100_fw *fw)
8451 /* firmware is constructed of N contiguous entries, each entry is
8455 * 0 4 address to write to
8456 * 4 2 length of data run
8462 const unsigned char *firmware_data = fw->fw.data;
8463 unsigned int firmware_data_left = fw->fw.size;
8465 while (firmware_data_left > 0) {
8466 addr = *(u32 *) (firmware_data);
8468 firmware_data_left -= 4;
8470 len = *(u16 *) (firmware_data);
8472 firmware_data_left -= 2;
8475 printk(KERN_ERR DRV_NAME ": "
8476 "Invalid firmware run-length of %d bytes\n",
8481 write_nic_memory(priv->net_dev, addr, len, firmware_data);
8482 firmware_data += len;
8483 firmware_data_left -= len;
8489 struct symbol_alive_response {
8498 u16 clock_settle_time; // 1us LSB
8499 u16 powerup_settle_time; // 1us LSB
8500 u16 hop_settle_time; // 1us LSB
8501 u8 date[3]; // month, day, year
8502 u8 time[2]; // hours, minutes
8506 static int ipw2100_ucode_download(struct ipw2100_priv *priv,
8507 struct ipw2100_fw *fw)
8509 struct net_device *dev = priv->net_dev;
8510 const unsigned char *microcode_data = fw->uc.data;
8511 unsigned int microcode_data_left = fw->uc.size;
8512 void __iomem *reg = (void __iomem *)dev->base_addr;
8514 struct symbol_alive_response response;
8518 /* Symbol control */
8519 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703);
8521 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707);
8525 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */
8527 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */
8530 /* EN_CS_ACCESS bit to reset control store pointer */
8531 write_nic_byte(dev, 0x210000, 0x40);
8533 write_nic_byte(dev, 0x210000, 0x0);
8535 write_nic_byte(dev, 0x210000, 0x40);
8538 /* copy microcode from buffer into Symbol */
8540 while (microcode_data_left > 0) {
8541 write_nic_byte(dev, 0x210010, *microcode_data++);
8542 write_nic_byte(dev, 0x210010, *microcode_data++);
8543 microcode_data_left -= 2;
8546 /* EN_CS_ACCESS bit to reset the control store pointer */
8547 write_nic_byte(dev, 0x210000, 0x0);
8550 /* Enable System (Reg 0)
8551 * first enable causes garbage in RX FIFO */
8552 write_nic_byte(dev, 0x210000, 0x0);
8554 write_nic_byte(dev, 0x210000, 0x80);
8557 /* Reset External Baseband Reg */
8558 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703);
8560 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707);
8563 /* HW Config (Reg 5) */
8564 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16
8566 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16
8569 /* Enable System (Reg 0)
8570 * second enable should be OK */
8571 write_nic_byte(dev, 0x210000, 0x00); // clear enable system
8573 write_nic_byte(dev, 0x210000, 0x80); // set enable system
8575 /* check Symbol is enabled - upped this from 5 as it wasn't always
8576 * catching the update */
8577 for (i = 0; i < 10; i++) {
8580 /* check Dino is enabled bit */
8581 read_nic_byte(dev, 0x210000, &data);
8587 printk(KERN_ERR DRV_NAME ": %s: Error initializing Symbol\n",
8592 /* Get Symbol alive response */
8593 for (i = 0; i < 30; i++) {
8594 /* Read alive response structure */
8596 j < (sizeof(struct symbol_alive_response) >> 1); j++)
8597 read_nic_word(dev, 0x210004, ((u16 *) & response) + j);
8599 if ((response.cmd_id == 1) && (response.ucode_valid == 0x1))
8605 printk(KERN_ERR DRV_NAME
8606 ": %s: No response from Symbol - hw not alive\n",
8608 printk_buf(IPW_DL_ERROR, (u8 *) & response, sizeof(response));