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/time.h>
161 #include <linux/firmware.h>
162 #include <linux/acpi.h>
163 #include <linux/ctype.h>
164 #include <linux/pm_qos_params.h>
166 #include <net/lib80211.h>
170 #define IPW2100_VERSION "git-1.2.2"
172 #define DRV_NAME "ipw2100"
173 #define DRV_VERSION IPW2100_VERSION
174 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2100 Network Driver"
175 #define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation"
177 /* Debugging stuff */
178 #ifdef CONFIG_IPW2100_DEBUG
179 #define IPW2100_RX_DEBUG /* Reception debugging */
182 MODULE_DESCRIPTION(DRV_DESCRIPTION);
183 MODULE_VERSION(DRV_VERSION);
184 MODULE_AUTHOR(DRV_COPYRIGHT);
185 MODULE_LICENSE("GPL");
187 static int debug = 0;
189 static int channel = 0;
190 static int associate = 0;
191 static int disable = 0;
193 static struct ipw2100_fw ipw2100_firmware;
196 #include <linux/moduleparam.h>
197 module_param(debug, int, 0444);
198 module_param(mode, int, 0444);
199 module_param(channel, int, 0444);
200 module_param(associate, int, 0444);
201 module_param(disable, int, 0444);
203 MODULE_PARM_DESC(debug, "debug level");
204 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
205 MODULE_PARM_DESC(channel, "channel");
206 MODULE_PARM_DESC(associate, "auto associate when scanning (default off)");
207 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
209 static u32 ipw2100_debug_level = IPW_DL_NONE;
211 #ifdef CONFIG_IPW2100_DEBUG
212 #define IPW_DEBUG(level, message...) \
214 if (ipw2100_debug_level & (level)) { \
215 printk(KERN_DEBUG "ipw2100: %c %s ", \
216 in_interrupt() ? 'I' : 'U', __func__); \
221 #define IPW_DEBUG(level, message...) do {} while (0)
222 #endif /* CONFIG_IPW2100_DEBUG */
224 #ifdef CONFIG_IPW2100_DEBUG
225 static const char *command_types[] = {
227 "unused", /* HOST_ATTENTION */
229 "unused", /* SLEEP */
230 "unused", /* HOST_POWER_DOWN */
233 "unused", /* SET_IMR */
236 "AUTHENTICATION_TYPE",
239 "INTERNATIONAL_MODE",
254 "CLEAR_ALL_MULTICAST",
275 "AP_OR_STATION_TABLE",
279 "unused", /* SAVE_CALIBRATION */
280 "unused", /* RESTORE_CALIBRATION */
284 "HOST_PRE_POWER_DOWN",
285 "unused", /* HOST_INTERRUPT_COALESCING */
287 "CARD_DISABLE_PHY_OFF",
288 "MSDU_TX_RATES" "undefined",
290 "SET_STATION_STAT_BITS",
291 "CLEAR_STATIONS_STAT_BITS",
293 "SET_SECURITY_INFORMATION",
294 "DISASSOCIATION_BSSID",
299 /* Pre-decl until we get the code solid and then we can clean it up */
300 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv);
301 static void ipw2100_tx_send_data(struct ipw2100_priv *priv);
302 static int ipw2100_adapter_setup(struct ipw2100_priv *priv);
304 static void ipw2100_queues_initialize(struct ipw2100_priv *priv);
305 static void ipw2100_queues_free(struct ipw2100_priv *priv);
306 static int ipw2100_queues_allocate(struct ipw2100_priv *priv);
308 static int ipw2100_fw_download(struct ipw2100_priv *priv,
309 struct ipw2100_fw *fw);
310 static int ipw2100_get_firmware(struct ipw2100_priv *priv,
311 struct ipw2100_fw *fw);
312 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf,
314 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf,
316 static void ipw2100_release_firmware(struct ipw2100_priv *priv,
317 struct ipw2100_fw *fw);
318 static int ipw2100_ucode_download(struct ipw2100_priv *priv,
319 struct ipw2100_fw *fw);
320 static void ipw2100_wx_event_work(struct work_struct *work);
321 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev);
322 static struct iw_handler_def ipw2100_wx_handler_def;
324 static inline void read_register(struct net_device *dev, u32 reg, u32 * val)
326 *val = readl((void __iomem *)(dev->base_addr + reg));
327 IPW_DEBUG_IO("r: 0x%08X => 0x%08X\n", reg, *val);
330 static inline void write_register(struct net_device *dev, u32 reg, u32 val)
332 writel(val, (void __iomem *)(dev->base_addr + reg));
333 IPW_DEBUG_IO("w: 0x%08X <= 0x%08X\n", reg, val);
336 static inline void read_register_word(struct net_device *dev, u32 reg,
339 *val = readw((void __iomem *)(dev->base_addr + reg));
340 IPW_DEBUG_IO("r: 0x%08X => %04X\n", reg, *val);
343 static inline void read_register_byte(struct net_device *dev, u32 reg, u8 * val)
345 *val = readb((void __iomem *)(dev->base_addr + reg));
346 IPW_DEBUG_IO("r: 0x%08X => %02X\n", reg, *val);
349 static inline void write_register_word(struct net_device *dev, u32 reg, u16 val)
351 writew(val, (void __iomem *)(dev->base_addr + reg));
352 IPW_DEBUG_IO("w: 0x%08X <= %04X\n", reg, val);
355 static inline void write_register_byte(struct net_device *dev, u32 reg, u8 val)
357 writeb(val, (void __iomem *)(dev->base_addr + reg));
358 IPW_DEBUG_IO("w: 0x%08X =< %02X\n", reg, val);
361 static inline void read_nic_dword(struct net_device *dev, u32 addr, u32 * val)
363 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
364 addr & IPW_REG_INDIRECT_ADDR_MASK);
365 read_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
368 static inline void write_nic_dword(struct net_device *dev, u32 addr, u32 val)
370 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
371 addr & IPW_REG_INDIRECT_ADDR_MASK);
372 write_register(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
375 static inline void read_nic_word(struct net_device *dev, u32 addr, u16 * val)
377 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
378 addr & IPW_REG_INDIRECT_ADDR_MASK);
379 read_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
382 static inline void write_nic_word(struct net_device *dev, u32 addr, u16 val)
384 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
385 addr & IPW_REG_INDIRECT_ADDR_MASK);
386 write_register_word(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
389 static inline void read_nic_byte(struct net_device *dev, u32 addr, u8 * val)
391 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
392 addr & IPW_REG_INDIRECT_ADDR_MASK);
393 read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
396 static inline void write_nic_byte(struct net_device *dev, u32 addr, u8 val)
398 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
399 addr & IPW_REG_INDIRECT_ADDR_MASK);
400 write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA, val);
403 static inline void write_nic_auto_inc_address(struct net_device *dev, u32 addr)
405 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS,
406 addr & IPW_REG_INDIRECT_ADDR_MASK);
409 static inline void write_nic_dword_auto_inc(struct net_device *dev, u32 val)
411 write_register(dev, IPW_REG_AUTOINCREMENT_DATA, val);
414 static void write_nic_memory(struct net_device *dev, u32 addr, u32 len,
422 /* read first nibble byte by byte */
423 aligned_addr = addr & (~0x3);
424 dif_len = addr - aligned_addr;
426 /* Start reading at aligned_addr + dif_len */
427 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
429 for (i = dif_len; i < 4; i++, buf++)
430 write_register_byte(dev,
431 IPW_REG_INDIRECT_ACCESS_DATA + i,
438 /* read DWs through autoincrement registers */
439 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr);
440 aligned_len = len & (~0x3);
441 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
442 write_register(dev, IPW_REG_AUTOINCREMENT_DATA, *(u32 *) buf);
444 /* copy the last nibble */
445 dif_len = len - aligned_len;
446 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr);
447 for (i = 0; i < dif_len; i++, buf++)
448 write_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i,
452 static void read_nic_memory(struct net_device *dev, u32 addr, u32 len,
460 /* read first nibble byte by byte */
461 aligned_addr = addr & (~0x3);
462 dif_len = addr - aligned_addr;
464 /* Start reading at aligned_addr + dif_len */
465 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS,
467 for (i = dif_len; i < 4; i++, buf++)
468 read_register_byte(dev,
469 IPW_REG_INDIRECT_ACCESS_DATA + i,
476 /* read DWs through autoincrement registers */
477 write_register(dev, IPW_REG_AUTOINCREMENT_ADDRESS, aligned_addr);
478 aligned_len = len & (~0x3);
479 for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
480 read_register(dev, IPW_REG_AUTOINCREMENT_DATA, (u32 *) buf);
482 /* copy the last nibble */
483 dif_len = len - aligned_len;
484 write_register(dev, IPW_REG_INDIRECT_ACCESS_ADDRESS, aligned_addr);
485 for (i = 0; i < dif_len; i++, buf++)
486 read_register_byte(dev, IPW_REG_INDIRECT_ACCESS_DATA + i, buf);
489 static inline int ipw2100_hw_is_adapter_in_system(struct net_device *dev)
491 return (dev->base_addr &&
493 ((void __iomem *)(dev->base_addr +
494 IPW_REG_DOA_DEBUG_AREA_START))
495 == IPW_DATA_DOA_DEBUG_VALUE));
498 static int ipw2100_get_ordinal(struct ipw2100_priv *priv, u32 ord,
499 void *val, u32 * len)
501 struct ipw2100_ordinals *ordinals = &priv->ordinals;
508 if (ordinals->table1_addr == 0) {
509 printk(KERN_WARNING DRV_NAME ": attempt to use fw ordinals "
510 "before they have been loaded.\n");
514 if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) {
515 if (*len < IPW_ORD_TAB_1_ENTRY_SIZE) {
516 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
518 printk(KERN_WARNING DRV_NAME
519 ": ordinal buffer length too small, need %zd\n",
520 IPW_ORD_TAB_1_ENTRY_SIZE);
525 read_nic_dword(priv->net_dev,
526 ordinals->table1_addr + (ord << 2), &addr);
527 read_nic_dword(priv->net_dev, addr, val);
529 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
534 if (IS_ORDINAL_TABLE_TWO(ordinals, ord)) {
536 ord -= IPW_START_ORD_TAB_2;
538 /* get the address of statistic */
539 read_nic_dword(priv->net_dev,
540 ordinals->table2_addr + (ord << 3), &addr);
542 /* get the second DW of statistics ;
543 * two 16-bit words - first is length, second is count */
544 read_nic_dword(priv->net_dev,
545 ordinals->table2_addr + (ord << 3) + sizeof(u32),
548 /* get each entry length */
549 field_len = *((u16 *) & field_info);
551 /* get number of entries */
552 field_count = *(((u16 *) & field_info) + 1);
554 /* abort if no enought memory */
555 total_length = field_len * field_count;
556 if (total_length > *len) {
565 /* read the ordinal data from the SRAM */
566 read_nic_memory(priv->net_dev, addr, total_length, val);
571 printk(KERN_WARNING DRV_NAME ": ordinal %d neither in table 1 nor "
572 "in table 2\n", ord);
577 static int ipw2100_set_ordinal(struct ipw2100_priv *priv, u32 ord, u32 * val,
580 struct ipw2100_ordinals *ordinals = &priv->ordinals;
583 if (IS_ORDINAL_TABLE_ONE(ordinals, ord)) {
584 if (*len != IPW_ORD_TAB_1_ENTRY_SIZE) {
585 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
586 IPW_DEBUG_INFO("wrong size\n");
590 read_nic_dword(priv->net_dev,
591 ordinals->table1_addr + (ord << 2), &addr);
593 write_nic_dword(priv->net_dev, addr, *val);
595 *len = IPW_ORD_TAB_1_ENTRY_SIZE;
600 IPW_DEBUG_INFO("wrong table\n");
601 if (IS_ORDINAL_TABLE_TWO(ordinals, ord))
607 static char *snprint_line(char *buf, size_t count,
608 const u8 * data, u32 len, u32 ofs)
613 out = snprintf(buf, count, "%08X", ofs);
615 for (l = 0, i = 0; i < 2; i++) {
616 out += snprintf(buf + out, count - out, " ");
617 for (j = 0; j < 8 && l < len; j++, l++)
618 out += snprintf(buf + out, count - out, "%02X ",
621 out += snprintf(buf + out, count - out, " ");
624 out += snprintf(buf + out, count - out, " ");
625 for (l = 0, i = 0; i < 2; i++) {
626 out += snprintf(buf + out, count - out, " ");
627 for (j = 0; j < 8 && l < len; j++, l++) {
628 c = data[(i * 8 + j)];
629 if (!isascii(c) || !isprint(c))
632 out += snprintf(buf + out, count - out, "%c", c);
636 out += snprintf(buf + out, count - out, " ");
642 static void printk_buf(int level, const u8 * data, u32 len)
646 if (!(ipw2100_debug_level & level))
650 printk(KERN_DEBUG "%s\n",
651 snprint_line(line, sizeof(line), &data[ofs],
652 min(len, 16U), ofs));
654 len -= min(len, 16U);
658 #define MAX_RESET_BACKOFF 10
660 static void schedule_reset(struct ipw2100_priv *priv)
662 unsigned long now = get_seconds();
664 /* If we haven't received a reset request within the backoff period,
665 * then we can reset the backoff interval so this reset occurs
667 if (priv->reset_backoff &&
668 (now - priv->last_reset > priv->reset_backoff))
669 priv->reset_backoff = 0;
671 priv->last_reset = get_seconds();
673 if (!(priv->status & STATUS_RESET_PENDING)) {
674 IPW_DEBUG_INFO("%s: Scheduling firmware restart (%ds).\n",
675 priv->net_dev->name, priv->reset_backoff);
676 netif_carrier_off(priv->net_dev);
677 netif_stop_queue(priv->net_dev);
678 priv->status |= STATUS_RESET_PENDING;
679 if (priv->reset_backoff)
680 queue_delayed_work(priv->workqueue, &priv->reset_work,
681 priv->reset_backoff * HZ);
683 queue_delayed_work(priv->workqueue, &priv->reset_work,
686 if (priv->reset_backoff < MAX_RESET_BACKOFF)
687 priv->reset_backoff++;
689 wake_up_interruptible(&priv->wait_command_queue);
691 IPW_DEBUG_INFO("%s: Firmware restart already in progress.\n",
692 priv->net_dev->name);
696 #define HOST_COMPLETE_TIMEOUT (2 * HZ)
697 static int ipw2100_hw_send_command(struct ipw2100_priv *priv,
698 struct host_command *cmd)
700 struct list_head *element;
701 struct ipw2100_tx_packet *packet;
705 IPW_DEBUG_HC("Sending %s command (#%d), %d bytes\n",
706 command_types[cmd->host_command], cmd->host_command,
707 cmd->host_command_length);
708 printk_buf(IPW_DL_HC, (u8 *) cmd->host_command_parameters,
709 cmd->host_command_length);
711 spin_lock_irqsave(&priv->low_lock, flags);
713 if (priv->fatal_error) {
715 ("Attempt to send command while hardware in fatal error condition.\n");
720 if (!(priv->status & STATUS_RUNNING)) {
722 ("Attempt to send command while hardware is not running.\n");
727 if (priv->status & STATUS_CMD_ACTIVE) {
729 ("Attempt to send command while another command is pending.\n");
734 if (list_empty(&priv->msg_free_list)) {
735 IPW_DEBUG_INFO("no available msg buffers\n");
739 priv->status |= STATUS_CMD_ACTIVE;
740 priv->messages_sent++;
742 element = priv->msg_free_list.next;
744 packet = list_entry(element, struct ipw2100_tx_packet, list);
745 packet->jiffy_start = jiffies;
747 /* initialize the firmware command packet */
748 packet->info.c_struct.cmd->host_command_reg = cmd->host_command;
749 packet->info.c_struct.cmd->host_command_reg1 = cmd->host_command1;
750 packet->info.c_struct.cmd->host_command_len_reg =
751 cmd->host_command_length;
752 packet->info.c_struct.cmd->sequence = cmd->host_command_sequence;
754 memcpy(packet->info.c_struct.cmd->host_command_params_reg,
755 cmd->host_command_parameters,
756 sizeof(packet->info.c_struct.cmd->host_command_params_reg));
759 DEC_STAT(&priv->msg_free_stat);
761 list_add_tail(element, &priv->msg_pend_list);
762 INC_STAT(&priv->msg_pend_stat);
764 ipw2100_tx_send_commands(priv);
765 ipw2100_tx_send_data(priv);
767 spin_unlock_irqrestore(&priv->low_lock, flags);
770 * We must wait for this command to complete before another
771 * command can be sent... but if we wait more than 3 seconds
772 * then there is a problem.
776 wait_event_interruptible_timeout(priv->wait_command_queue,
778 status & STATUS_CMD_ACTIVE),
779 HOST_COMPLETE_TIMEOUT);
782 IPW_DEBUG_INFO("Command completion failed out after %dms.\n",
783 1000 * (HOST_COMPLETE_TIMEOUT / HZ));
784 priv->fatal_error = IPW2100_ERR_MSG_TIMEOUT;
785 priv->status &= ~STATUS_CMD_ACTIVE;
786 schedule_reset(priv);
790 if (priv->fatal_error) {
791 printk(KERN_WARNING DRV_NAME ": %s: firmware fatal error\n",
792 priv->net_dev->name);
796 /* !!!!! HACK TEST !!!!!
797 * When lots of debug trace statements are enabled, the driver
798 * doesn't seem to have as many firmware restart cycles...
800 * As a test, we're sticking in a 1/100s delay here */
801 schedule_timeout_uninterruptible(msecs_to_jiffies(10));
806 spin_unlock_irqrestore(&priv->low_lock, flags);
812 * Verify the values and data access of the hardware
813 * No locks needed or used. No functions called.
815 static int ipw2100_verify(struct ipw2100_priv *priv)
820 u32 val1 = 0x76543210;
821 u32 val2 = 0xFEDCBA98;
823 /* Domain 0 check - all values should be DOA_DEBUG */
824 for (address = IPW_REG_DOA_DEBUG_AREA_START;
825 address < IPW_REG_DOA_DEBUG_AREA_END; address += sizeof(u32)) {
826 read_register(priv->net_dev, address, &data1);
827 if (data1 != IPW_DATA_DOA_DEBUG_VALUE)
831 /* Domain 1 check - use arbitrary read/write compare */
832 for (address = 0; address < 5; address++) {
833 /* The memory area is not used now */
834 write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32,
836 write_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36,
838 read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x32,
840 read_register(priv->net_dev, IPW_REG_DOMAIN_1_OFFSET + 0x36,
842 if (val1 == data1 && val2 == data2)
851 * Loop until the CARD_DISABLED bit is the same value as the
854 * TODO: See if it would be more efficient to do a wait/wake
855 * cycle and have the completion event trigger the wakeup
858 #define IPW_CARD_DISABLE_COMPLETE_WAIT 100 // 100 milli
859 static int ipw2100_wait_for_card_state(struct ipw2100_priv *priv, int state)
863 u32 len = sizeof(card_state);
866 for (i = 0; i <= IPW_CARD_DISABLE_COMPLETE_WAIT * 1000; i += 50) {
867 err = ipw2100_get_ordinal(priv, IPW_ORD_CARD_DISABLED,
870 IPW_DEBUG_INFO("Query of CARD_DISABLED ordinal "
875 /* We'll break out if either the HW state says it is
876 * in the state we want, or if HOST_COMPLETE command
878 if ((card_state == state) ||
879 ((priv->status & STATUS_ENABLED) ?
880 IPW_HW_STATE_ENABLED : IPW_HW_STATE_DISABLED) == state) {
881 if (state == IPW_HW_STATE_ENABLED)
882 priv->status |= STATUS_ENABLED;
884 priv->status &= ~STATUS_ENABLED;
892 IPW_DEBUG_INFO("ipw2100_wait_for_card_state to %s state timed out\n",
893 state ? "DISABLED" : "ENABLED");
897 /*********************************************************************
898 Procedure : sw_reset_and_clock
899 Purpose : Asserts s/w reset, asserts clock initialization
900 and waits for clock stabilization
901 ********************************************************************/
902 static int sw_reset_and_clock(struct ipw2100_priv *priv)
908 write_register(priv->net_dev, IPW_REG_RESET_REG,
909 IPW_AUX_HOST_RESET_REG_SW_RESET);
911 // wait for clock stabilization
912 for (i = 0; i < 1000; i++) {
913 udelay(IPW_WAIT_RESET_ARC_COMPLETE_DELAY);
915 // check clock ready bit
916 read_register(priv->net_dev, IPW_REG_RESET_REG, &r);
917 if (r & IPW_AUX_HOST_RESET_REG_PRINCETON_RESET)
922 return -EIO; // TODO: better error value
924 /* set "initialization complete" bit to move adapter to
926 write_register(priv->net_dev, IPW_REG_GP_CNTRL,
927 IPW_AUX_HOST_GP_CNTRL_BIT_INIT_DONE);
929 /* wait for clock stabilization */
930 for (i = 0; i < 10000; i++) {
931 udelay(IPW_WAIT_CLOCK_STABILIZATION_DELAY * 4);
933 /* check clock ready bit */
934 read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r);
935 if (r & IPW_AUX_HOST_GP_CNTRL_BIT_CLOCK_READY)
940 return -EIO; /* TODO: better error value */
942 /* set D0 standby bit */
943 read_register(priv->net_dev, IPW_REG_GP_CNTRL, &r);
944 write_register(priv->net_dev, IPW_REG_GP_CNTRL,
945 r | IPW_AUX_HOST_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
950 /*********************************************************************
951 Procedure : ipw2100_download_firmware
952 Purpose : Initiaze adapter after power on.
954 1. assert s/w reset first!
955 2. awake clocks & wait for clock stabilization
956 3. hold ARC (don't ask me why...)
957 4. load Dino ucode and reset/clock init again
958 5. zero-out shared mem
960 *******************************************************************/
961 static int ipw2100_download_firmware(struct ipw2100_priv *priv)
967 /* Fetch the firmware and microcode */
968 struct ipw2100_fw ipw2100_firmware;
971 if (priv->fatal_error) {
972 IPW_DEBUG_ERROR("%s: ipw2100_download_firmware called after "
973 "fatal error %d. Interface must be brought down.\n",
974 priv->net_dev->name, priv->fatal_error);
978 if (!ipw2100_firmware.version) {
979 err = ipw2100_get_firmware(priv, &ipw2100_firmware);
981 IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n",
982 priv->net_dev->name, err);
983 priv->fatal_error = IPW2100_ERR_FW_LOAD;
988 err = ipw2100_get_firmware(priv, &ipw2100_firmware);
990 IPW_DEBUG_ERROR("%s: ipw2100_get_firmware failed: %d\n",
991 priv->net_dev->name, err);
992 priv->fatal_error = IPW2100_ERR_FW_LOAD;
996 priv->firmware_version = ipw2100_firmware.version;
998 /* s/w reset and clock stabilization */
999 err = sw_reset_and_clock(priv);
1001 IPW_DEBUG_ERROR("%s: sw_reset_and_clock failed: %d\n",
1002 priv->net_dev->name, err);
1006 err = ipw2100_verify(priv);
1008 IPW_DEBUG_ERROR("%s: ipw2100_verify failed: %d\n",
1009 priv->net_dev->name, err);
1014 write_nic_dword(priv->net_dev,
1015 IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x80000000);
1017 /* allow ARC to run */
1018 write_register(priv->net_dev, IPW_REG_RESET_REG, 0);
1020 /* load microcode */
1021 err = ipw2100_ucode_download(priv, &ipw2100_firmware);
1023 printk(KERN_ERR DRV_NAME ": %s: Error loading microcode: %d\n",
1024 priv->net_dev->name, err);
1029 write_nic_dword(priv->net_dev,
1030 IPW_INTERNAL_REGISTER_HALT_AND_RESET, 0x00000000);
1032 /* s/w reset and clock stabilization (again!!!) */
1033 err = sw_reset_and_clock(priv);
1035 printk(KERN_ERR DRV_NAME
1036 ": %s: sw_reset_and_clock failed: %d\n",
1037 priv->net_dev->name, err);
1042 err = ipw2100_fw_download(priv, &ipw2100_firmware);
1044 IPW_DEBUG_ERROR("%s: Error loading firmware: %d\n",
1045 priv->net_dev->name, err);
1050 * When the .resume method of the driver is called, the other
1051 * part of the system, i.e. the ide driver could still stay in
1052 * the suspend stage. This prevents us from loading the firmware
1053 * from the disk. --YZ
1056 /* free any storage allocated for firmware image */
1057 ipw2100_release_firmware(priv, &ipw2100_firmware);
1060 /* zero out Domain 1 area indirectly (Si requirement) */
1061 for (address = IPW_HOST_FW_SHARED_AREA0;
1062 address < IPW_HOST_FW_SHARED_AREA0_END; address += 4)
1063 write_nic_dword(priv->net_dev, address, 0);
1064 for (address = IPW_HOST_FW_SHARED_AREA1;
1065 address < IPW_HOST_FW_SHARED_AREA1_END; address += 4)
1066 write_nic_dword(priv->net_dev, address, 0);
1067 for (address = IPW_HOST_FW_SHARED_AREA2;
1068 address < IPW_HOST_FW_SHARED_AREA2_END; address += 4)
1069 write_nic_dword(priv->net_dev, address, 0);
1070 for (address = IPW_HOST_FW_SHARED_AREA3;
1071 address < IPW_HOST_FW_SHARED_AREA3_END; address += 4)
1072 write_nic_dword(priv->net_dev, address, 0);
1073 for (address = IPW_HOST_FW_INTERRUPT_AREA;
1074 address < IPW_HOST_FW_INTERRUPT_AREA_END; address += 4)
1075 write_nic_dword(priv->net_dev, address, 0);
1080 ipw2100_release_firmware(priv, &ipw2100_firmware);
1084 static inline void ipw2100_enable_interrupts(struct ipw2100_priv *priv)
1086 if (priv->status & STATUS_INT_ENABLED)
1088 priv->status |= STATUS_INT_ENABLED;
1089 write_register(priv->net_dev, IPW_REG_INTA_MASK, IPW_INTERRUPT_MASK);
1092 static inline void ipw2100_disable_interrupts(struct ipw2100_priv *priv)
1094 if (!(priv->status & STATUS_INT_ENABLED))
1096 priv->status &= ~STATUS_INT_ENABLED;
1097 write_register(priv->net_dev, IPW_REG_INTA_MASK, 0x0);
1100 static void ipw2100_initialize_ordinals(struct ipw2100_priv *priv)
1102 struct ipw2100_ordinals *ord = &priv->ordinals;
1104 IPW_DEBUG_INFO("enter\n");
1106 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_1,
1109 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_ORDINALS_TABLE_2,
1112 read_nic_dword(priv->net_dev, ord->table1_addr, &ord->table1_size);
1113 read_nic_dword(priv->net_dev, ord->table2_addr, &ord->table2_size);
1115 ord->table2_size &= 0x0000FFFF;
1117 IPW_DEBUG_INFO("table 1 size: %d\n", ord->table1_size);
1118 IPW_DEBUG_INFO("table 2 size: %d\n", ord->table2_size);
1119 IPW_DEBUG_INFO("exit\n");
1122 static inline void ipw2100_hw_set_gpio(struct ipw2100_priv *priv)
1126 * Set GPIO 3 writable by FW; GPIO 1 writable
1127 * by driver and enable clock
1129 reg = (IPW_BIT_GPIO_GPIO3_MASK | IPW_BIT_GPIO_GPIO1_ENABLE |
1130 IPW_BIT_GPIO_LED_OFF);
1131 write_register(priv->net_dev, IPW_REG_GPIO, reg);
1134 static int rf_kill_active(struct ipw2100_priv *priv)
1136 #define MAX_RF_KILL_CHECKS 5
1137 #define RF_KILL_CHECK_DELAY 40
1139 unsigned short value = 0;
1143 if (!(priv->hw_features & HW_FEATURE_RFKILL)) {
1144 priv->status &= ~STATUS_RF_KILL_HW;
1148 for (i = 0; i < MAX_RF_KILL_CHECKS; i++) {
1149 udelay(RF_KILL_CHECK_DELAY);
1150 read_register(priv->net_dev, IPW_REG_GPIO, ®);
1151 value = (value << 1) | ((reg & IPW_BIT_GPIO_RF_KILL) ? 0 : 1);
1155 priv->status |= STATUS_RF_KILL_HW;
1157 priv->status &= ~STATUS_RF_KILL_HW;
1159 return (value == 0);
1162 static int ipw2100_get_hw_features(struct ipw2100_priv *priv)
1168 * EEPROM_SRAM_DB_START_ADDRESS using ordinal in ordinal table 1
1171 if (ipw2100_get_ordinal
1172 (priv, IPW_ORD_EEPROM_SRAM_DB_BLOCK_START_ADDRESS, &addr, &len)) {
1173 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1178 IPW_DEBUG_INFO("EEPROM address: %08X\n", addr);
1181 * EEPROM version is the byte at offset 0xfd in firmware
1182 * We read 4 bytes, then shift out the byte we actually want */
1183 read_nic_dword(priv->net_dev, addr + 0xFC, &val);
1184 priv->eeprom_version = (val >> 24) & 0xFF;
1185 IPW_DEBUG_INFO("EEPROM version: %d\n", priv->eeprom_version);
1188 * HW RF Kill enable is bit 0 in byte at offset 0x21 in firmware
1190 * notice that the EEPROM bit is reverse polarity, i.e.
1191 * bit = 0 signifies HW RF kill switch is supported
1192 * bit = 1 signifies HW RF kill switch is NOT supported
1194 read_nic_dword(priv->net_dev, addr + 0x20, &val);
1195 if (!((val >> 24) & 0x01))
1196 priv->hw_features |= HW_FEATURE_RFKILL;
1198 IPW_DEBUG_INFO("HW RF Kill: %ssupported.\n",
1199 (priv->hw_features & HW_FEATURE_RFKILL) ? "" : "not ");
1205 * Start firmware execution after power on and intialization
1208 * 2. Wait for f/w initialization completes;
1210 static int ipw2100_start_adapter(struct ipw2100_priv *priv)
1213 u32 inta, inta_mask, gpio;
1215 IPW_DEBUG_INFO("enter\n");
1217 if (priv->status & STATUS_RUNNING)
1221 * Initialize the hw - drive adapter to DO state by setting
1222 * init_done bit. Wait for clk_ready bit and Download
1225 if (ipw2100_download_firmware(priv)) {
1226 printk(KERN_ERR DRV_NAME
1227 ": %s: Failed to power on the adapter.\n",
1228 priv->net_dev->name);
1232 /* Clear the Tx, Rx and Msg queues and the r/w indexes
1233 * in the firmware RBD and TBD ring queue */
1234 ipw2100_queues_initialize(priv);
1236 ipw2100_hw_set_gpio(priv);
1238 /* TODO -- Look at disabling interrupts here to make sure none
1239 * get fired during FW initialization */
1241 /* Release ARC - clear reset bit */
1242 write_register(priv->net_dev, IPW_REG_RESET_REG, 0);
1244 /* wait for f/w intialization complete */
1245 IPW_DEBUG_FW("Waiting for f/w initialization to complete...\n");
1248 schedule_timeout_uninterruptible(msecs_to_jiffies(40));
1249 /* Todo... wait for sync command ... */
1251 read_register(priv->net_dev, IPW_REG_INTA, &inta);
1253 /* check "init done" bit */
1254 if (inta & IPW2100_INTA_FW_INIT_DONE) {
1255 /* reset "init done" bit */
1256 write_register(priv->net_dev, IPW_REG_INTA,
1257 IPW2100_INTA_FW_INIT_DONE);
1261 /* check error conditions : we check these after the firmware
1262 * check so that if there is an error, the interrupt handler
1263 * will see it and the adapter will be reset */
1265 (IPW2100_INTA_FATAL_ERROR | IPW2100_INTA_PARITY_ERROR)) {
1266 /* clear error conditions */
1267 write_register(priv->net_dev, IPW_REG_INTA,
1268 IPW2100_INTA_FATAL_ERROR |
1269 IPW2100_INTA_PARITY_ERROR);
1273 /* Clear out any pending INTAs since we aren't supposed to have
1274 * interrupts enabled at this point... */
1275 read_register(priv->net_dev, IPW_REG_INTA, &inta);
1276 read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask);
1277 inta &= IPW_INTERRUPT_MASK;
1278 /* Clear out any pending interrupts */
1279 if (inta & inta_mask)
1280 write_register(priv->net_dev, IPW_REG_INTA, inta);
1282 IPW_DEBUG_FW("f/w initialization complete: %s\n",
1283 i ? "SUCCESS" : "FAILED");
1286 printk(KERN_WARNING DRV_NAME
1287 ": %s: Firmware did not initialize.\n",
1288 priv->net_dev->name);
1292 /* allow firmware to write to GPIO1 & GPIO3 */
1293 read_register(priv->net_dev, IPW_REG_GPIO, &gpio);
1295 gpio |= (IPW_BIT_GPIO_GPIO1_MASK | IPW_BIT_GPIO_GPIO3_MASK);
1297 write_register(priv->net_dev, IPW_REG_GPIO, gpio);
1299 /* Ready to receive commands */
1300 priv->status |= STATUS_RUNNING;
1302 /* The adapter has been reset; we are not associated */
1303 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
1305 IPW_DEBUG_INFO("exit\n");
1310 static inline void ipw2100_reset_fatalerror(struct ipw2100_priv *priv)
1312 if (!priv->fatal_error)
1315 priv->fatal_errors[priv->fatal_index++] = priv->fatal_error;
1316 priv->fatal_index %= IPW2100_ERROR_QUEUE;
1317 priv->fatal_error = 0;
1320 /* NOTE: Our interrupt is disabled when this method is called */
1321 static int ipw2100_power_cycle_adapter(struct ipw2100_priv *priv)
1326 IPW_DEBUG_INFO("Power cycling the hardware.\n");
1328 ipw2100_hw_set_gpio(priv);
1330 /* Step 1. Stop Master Assert */
1331 write_register(priv->net_dev, IPW_REG_RESET_REG,
1332 IPW_AUX_HOST_RESET_REG_STOP_MASTER);
1334 /* Step 2. Wait for stop Master Assert
1335 * (not more than 50us, otherwise ret error */
1338 udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY);
1339 read_register(priv->net_dev, IPW_REG_RESET_REG, ®);
1341 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
1345 priv->status &= ~STATUS_RESET_PENDING;
1349 ("exit - waited too long for master assert stop\n");
1353 write_register(priv->net_dev, IPW_REG_RESET_REG,
1354 IPW_AUX_HOST_RESET_REG_SW_RESET);
1356 /* Reset any fatal_error conditions */
1357 ipw2100_reset_fatalerror(priv);
1359 /* At this point, the adapter is now stopped and disabled */
1360 priv->status &= ~(STATUS_RUNNING | STATUS_ASSOCIATING |
1361 STATUS_ASSOCIATED | STATUS_ENABLED);
1367 * Send the CARD_DISABLE_PHY_OFF comamnd to the card to disable it
1369 * After disabling, if the card was associated, a STATUS_ASSN_LOST will be sent.
1371 * STATUS_CARD_DISABLE_NOTIFICATION will be sent regardless of
1372 * if STATUS_ASSN_LOST is sent.
1374 static int ipw2100_hw_phy_off(struct ipw2100_priv *priv)
1377 #define HW_PHY_OFF_LOOP_DELAY (HZ / 5000)
1379 struct host_command cmd = {
1380 .host_command = CARD_DISABLE_PHY_OFF,
1381 .host_command_sequence = 0,
1382 .host_command_length = 0,
1387 IPW_DEBUG_HC("CARD_DISABLE_PHY_OFF\n");
1389 /* Turn off the radio */
1390 err = ipw2100_hw_send_command(priv, &cmd);
1394 for (i = 0; i < 2500; i++) {
1395 read_nic_dword(priv->net_dev, IPW2100_CONTROL_REG, &val1);
1396 read_nic_dword(priv->net_dev, IPW2100_COMMAND, &val2);
1398 if ((val1 & IPW2100_CONTROL_PHY_OFF) &&
1399 (val2 & IPW2100_COMMAND_PHY_OFF))
1402 schedule_timeout_uninterruptible(HW_PHY_OFF_LOOP_DELAY);
1408 static int ipw2100_enable_adapter(struct ipw2100_priv *priv)
1410 struct host_command cmd = {
1411 .host_command = HOST_COMPLETE,
1412 .host_command_sequence = 0,
1413 .host_command_length = 0
1417 IPW_DEBUG_HC("HOST_COMPLETE\n");
1419 if (priv->status & STATUS_ENABLED)
1422 mutex_lock(&priv->adapter_mutex);
1424 if (rf_kill_active(priv)) {
1425 IPW_DEBUG_HC("Command aborted due to RF kill active.\n");
1429 err = ipw2100_hw_send_command(priv, &cmd);
1431 IPW_DEBUG_INFO("Failed to send HOST_COMPLETE command\n");
1435 err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_ENABLED);
1437 IPW_DEBUG_INFO("%s: card not responding to init command.\n",
1438 priv->net_dev->name);
1442 if (priv->stop_hang_check) {
1443 priv->stop_hang_check = 0;
1444 queue_delayed_work(priv->workqueue, &priv->hang_check, HZ / 2);
1448 mutex_unlock(&priv->adapter_mutex);
1452 static int ipw2100_hw_stop_adapter(struct ipw2100_priv *priv)
1454 #define HW_POWER_DOWN_DELAY (msecs_to_jiffies(100))
1456 struct host_command cmd = {
1457 .host_command = HOST_PRE_POWER_DOWN,
1458 .host_command_sequence = 0,
1459 .host_command_length = 0,
1464 if (!(priv->status & STATUS_RUNNING))
1467 priv->status |= STATUS_STOPPING;
1469 /* We can only shut down the card if the firmware is operational. So,
1470 * if we haven't reset since a fatal_error, then we can not send the
1471 * shutdown commands. */
1472 if (!priv->fatal_error) {
1473 /* First, make sure the adapter is enabled so that the PHY_OFF
1474 * command can shut it down */
1475 ipw2100_enable_adapter(priv);
1477 err = ipw2100_hw_phy_off(priv);
1479 printk(KERN_WARNING DRV_NAME
1480 ": Error disabling radio %d\n", err);
1483 * If in D0-standby mode going directly to D3 may cause a
1484 * PCI bus violation. Therefore we must change out of the D0
1487 * Sending the PREPARE_FOR_POWER_DOWN will restrict the
1488 * hardware from going into standby mode and will transition
1489 * out of D0-standby if it is already in that state.
1491 * STATUS_PREPARE_POWER_DOWN_COMPLETE will be sent by the
1492 * driver upon completion. Once received, the driver can
1493 * proceed to the D3 state.
1495 * Prepare for power down command to fw. This command would
1496 * take HW out of D0-standby and prepare it for D3 state.
1498 * Currently FW does not support event notification for this
1499 * event. Therefore, skip waiting for it. Just wait a fixed
1502 IPW_DEBUG_HC("HOST_PRE_POWER_DOWN\n");
1504 err = ipw2100_hw_send_command(priv, &cmd);
1506 printk(KERN_WARNING DRV_NAME ": "
1507 "%s: Power down command failed: Error %d\n",
1508 priv->net_dev->name, err);
1510 schedule_timeout_uninterruptible(HW_POWER_DOWN_DELAY);
1513 priv->status &= ~STATUS_ENABLED;
1516 * Set GPIO 3 writable by FW; GPIO 1 writable
1517 * by driver and enable clock
1519 ipw2100_hw_set_gpio(priv);
1522 * Power down adapter. Sequence:
1523 * 1. Stop master assert (RESET_REG[9]=1)
1524 * 2. Wait for stop master (RESET_REG[8]==1)
1525 * 3. S/w reset assert (RESET_REG[7] = 1)
1528 /* Stop master assert */
1529 write_register(priv->net_dev, IPW_REG_RESET_REG,
1530 IPW_AUX_HOST_RESET_REG_STOP_MASTER);
1532 /* wait stop master not more than 50 usec.
1533 * Otherwise return error. */
1534 for (i = 5; i > 0; i--) {
1537 /* Check master stop bit */
1538 read_register(priv->net_dev, IPW_REG_RESET_REG, ®);
1540 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
1545 printk(KERN_WARNING DRV_NAME
1546 ": %s: Could now power down adapter.\n",
1547 priv->net_dev->name);
1549 /* assert s/w reset */
1550 write_register(priv->net_dev, IPW_REG_RESET_REG,
1551 IPW_AUX_HOST_RESET_REG_SW_RESET);
1553 priv->status &= ~(STATUS_RUNNING | STATUS_STOPPING);
1558 static int ipw2100_disable_adapter(struct ipw2100_priv *priv)
1560 struct host_command cmd = {
1561 .host_command = CARD_DISABLE,
1562 .host_command_sequence = 0,
1563 .host_command_length = 0
1567 IPW_DEBUG_HC("CARD_DISABLE\n");
1569 if (!(priv->status & STATUS_ENABLED))
1572 /* Make sure we clear the associated state */
1573 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1575 if (!priv->stop_hang_check) {
1576 priv->stop_hang_check = 1;
1577 cancel_delayed_work(&priv->hang_check);
1580 mutex_lock(&priv->adapter_mutex);
1582 err = ipw2100_hw_send_command(priv, &cmd);
1584 printk(KERN_WARNING DRV_NAME
1585 ": exit - failed to send CARD_DISABLE command\n");
1589 err = ipw2100_wait_for_card_state(priv, IPW_HW_STATE_DISABLED);
1591 printk(KERN_WARNING DRV_NAME
1592 ": exit - card failed to change to DISABLED\n");
1596 IPW_DEBUG_INFO("TODO: implement scan state machine\n");
1599 mutex_unlock(&priv->adapter_mutex);
1603 static int ipw2100_set_scan_options(struct ipw2100_priv *priv)
1605 struct host_command cmd = {
1606 .host_command = SET_SCAN_OPTIONS,
1607 .host_command_sequence = 0,
1608 .host_command_length = 8
1612 IPW_DEBUG_INFO("enter\n");
1614 IPW_DEBUG_SCAN("setting scan options\n");
1616 cmd.host_command_parameters[0] = 0;
1618 if (!(priv->config & CFG_ASSOCIATE))
1619 cmd.host_command_parameters[0] |= IPW_SCAN_NOASSOCIATE;
1620 if ((priv->ieee->sec.flags & SEC_ENABLED) && priv->ieee->sec.enabled)
1621 cmd.host_command_parameters[0] |= IPW_SCAN_MIXED_CELL;
1622 if (priv->config & CFG_PASSIVE_SCAN)
1623 cmd.host_command_parameters[0] |= IPW_SCAN_PASSIVE;
1625 cmd.host_command_parameters[1] = priv->channel_mask;
1627 err = ipw2100_hw_send_command(priv, &cmd);
1629 IPW_DEBUG_HC("SET_SCAN_OPTIONS 0x%04X\n",
1630 cmd.host_command_parameters[0]);
1635 static int ipw2100_start_scan(struct ipw2100_priv *priv)
1637 struct host_command cmd = {
1638 .host_command = BROADCAST_SCAN,
1639 .host_command_sequence = 0,
1640 .host_command_length = 4
1644 IPW_DEBUG_HC("START_SCAN\n");
1646 cmd.host_command_parameters[0] = 0;
1648 /* No scanning if in monitor mode */
1649 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
1652 if (priv->status & STATUS_SCANNING) {
1653 IPW_DEBUG_SCAN("Scan requested while already in scan...\n");
1657 IPW_DEBUG_INFO("enter\n");
1659 /* Not clearing here; doing so makes iwlist always return nothing...
1661 * We should modify the table logic to use aging tables vs. clearing
1662 * the table on each scan start.
1664 IPW_DEBUG_SCAN("starting scan\n");
1666 priv->status |= STATUS_SCANNING;
1667 err = ipw2100_hw_send_command(priv, &cmd);
1669 priv->status &= ~STATUS_SCANNING;
1671 IPW_DEBUG_INFO("exit\n");
1676 static const struct ieee80211_geo ipw_geos[] = {
1680 .bg = {{2412, 1}, {2417, 2}, {2422, 3},
1681 {2427, 4}, {2432, 5}, {2437, 6},
1682 {2442, 7}, {2447, 8}, {2452, 9},
1683 {2457, 10}, {2462, 11}, {2467, 12},
1684 {2472, 13}, {2484, 14}},
1688 static int ipw2100_up(struct ipw2100_priv *priv, int deferred)
1690 unsigned long flags;
1693 u32 ord_len = sizeof(lock);
1695 /* Quite if manually disabled. */
1696 if (priv->status & STATUS_RF_KILL_SW) {
1697 IPW_DEBUG_INFO("%s: Radio is disabled by Manual Disable "
1698 "switch\n", priv->net_dev->name);
1702 /* the ipw2100 hardware really doesn't want power management delays
1703 * longer than 175usec
1705 pm_qos_update_requirement(PM_QOS_CPU_DMA_LATENCY, "ipw2100", 175);
1707 /* If the interrupt is enabled, turn it off... */
1708 spin_lock_irqsave(&priv->low_lock, flags);
1709 ipw2100_disable_interrupts(priv);
1711 /* Reset any fatal_error conditions */
1712 ipw2100_reset_fatalerror(priv);
1713 spin_unlock_irqrestore(&priv->low_lock, flags);
1715 if (priv->status & STATUS_POWERED ||
1716 (priv->status & STATUS_RESET_PENDING)) {
1717 /* Power cycle the card ... */
1718 if (ipw2100_power_cycle_adapter(priv)) {
1719 printk(KERN_WARNING DRV_NAME
1720 ": %s: Could not cycle adapter.\n",
1721 priv->net_dev->name);
1726 priv->status |= STATUS_POWERED;
1728 /* Load the firmware, start the clocks, etc. */
1729 if (ipw2100_start_adapter(priv)) {
1730 printk(KERN_ERR DRV_NAME
1731 ": %s: Failed to start the firmware.\n",
1732 priv->net_dev->name);
1737 ipw2100_initialize_ordinals(priv);
1739 /* Determine capabilities of this particular HW configuration */
1740 if (ipw2100_get_hw_features(priv)) {
1741 printk(KERN_ERR DRV_NAME
1742 ": %s: Failed to determine HW features.\n",
1743 priv->net_dev->name);
1748 /* Initialize the geo */
1749 if (ieee80211_set_geo(priv->ieee, &ipw_geos[0])) {
1750 printk(KERN_WARNING DRV_NAME "Could not set geo\n");
1753 priv->ieee->freq_band = IEEE80211_24GHZ_BAND;
1756 if (ipw2100_set_ordinal(priv, IPW_ORD_PERS_DB_LOCK, &lock, &ord_len)) {
1757 printk(KERN_ERR DRV_NAME
1758 ": %s: Failed to clear ordinal lock.\n",
1759 priv->net_dev->name);
1764 priv->status &= ~STATUS_SCANNING;
1766 if (rf_kill_active(priv)) {
1767 printk(KERN_INFO "%s: Radio is disabled by RF switch.\n",
1768 priv->net_dev->name);
1770 if (priv->stop_rf_kill) {
1771 priv->stop_rf_kill = 0;
1772 queue_delayed_work(priv->workqueue, &priv->rf_kill,
1773 round_jiffies_relative(HZ));
1779 /* Turn on the interrupt so that commands can be processed */
1780 ipw2100_enable_interrupts(priv);
1782 /* Send all of the commands that must be sent prior to
1784 if (ipw2100_adapter_setup(priv)) {
1785 printk(KERN_ERR DRV_NAME ": %s: Failed to start the card.\n",
1786 priv->net_dev->name);
1792 /* Enable the adapter - sends HOST_COMPLETE */
1793 if (ipw2100_enable_adapter(priv)) {
1794 printk(KERN_ERR DRV_NAME ": "
1795 "%s: failed in call to enable adapter.\n",
1796 priv->net_dev->name);
1797 ipw2100_hw_stop_adapter(priv);
1802 /* Start a scan . . . */
1803 ipw2100_set_scan_options(priv);
1804 ipw2100_start_scan(priv);
1811 /* Called by register_netdev() */
1812 static int ipw2100_net_init(struct net_device *dev)
1814 struct ipw2100_priv *priv = ieee80211_priv(dev);
1815 return ipw2100_up(priv, 1);
1818 static void ipw2100_down(struct ipw2100_priv *priv)
1820 unsigned long flags;
1821 union iwreq_data wrqu = {
1823 .sa_family = ARPHRD_ETHER}
1825 int associated = priv->status & STATUS_ASSOCIATED;
1827 /* Kill the RF switch timer */
1828 if (!priv->stop_rf_kill) {
1829 priv->stop_rf_kill = 1;
1830 cancel_delayed_work(&priv->rf_kill);
1833 /* Kill the firmare hang check timer */
1834 if (!priv->stop_hang_check) {
1835 priv->stop_hang_check = 1;
1836 cancel_delayed_work(&priv->hang_check);
1839 /* Kill any pending resets */
1840 if (priv->status & STATUS_RESET_PENDING)
1841 cancel_delayed_work(&priv->reset_work);
1843 /* Make sure the interrupt is on so that FW commands will be
1844 * processed correctly */
1845 spin_lock_irqsave(&priv->low_lock, flags);
1846 ipw2100_enable_interrupts(priv);
1847 spin_unlock_irqrestore(&priv->low_lock, flags);
1849 if (ipw2100_hw_stop_adapter(priv))
1850 printk(KERN_ERR DRV_NAME ": %s: Error stopping adapter.\n",
1851 priv->net_dev->name);
1853 /* Do not disable the interrupt until _after_ we disable
1854 * the adaptor. Otherwise the CARD_DISABLE command will never
1855 * be ack'd by the firmware */
1856 spin_lock_irqsave(&priv->low_lock, flags);
1857 ipw2100_disable_interrupts(priv);
1858 spin_unlock_irqrestore(&priv->low_lock, flags);
1860 pm_qos_update_requirement(PM_QOS_CPU_DMA_LATENCY, "ipw2100",
1861 PM_QOS_DEFAULT_VALUE);
1863 /* We have to signal any supplicant if we are disassociating */
1865 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1867 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1868 netif_carrier_off(priv->net_dev);
1869 netif_stop_queue(priv->net_dev);
1872 static void ipw2100_reset_adapter(struct work_struct *work)
1874 struct ipw2100_priv *priv =
1875 container_of(work, struct ipw2100_priv, reset_work.work);
1876 unsigned long flags;
1877 union iwreq_data wrqu = {
1879 .sa_family = ARPHRD_ETHER}
1881 int associated = priv->status & STATUS_ASSOCIATED;
1883 spin_lock_irqsave(&priv->low_lock, flags);
1884 IPW_DEBUG_INFO(": %s: Restarting adapter.\n", priv->net_dev->name);
1886 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
1887 priv->status |= STATUS_SECURITY_UPDATED;
1889 /* Force a power cycle even if interface hasn't been opened
1891 cancel_delayed_work(&priv->reset_work);
1892 priv->status |= STATUS_RESET_PENDING;
1893 spin_unlock_irqrestore(&priv->low_lock, flags);
1895 mutex_lock(&priv->action_mutex);
1896 /* stop timed checks so that they don't interfere with reset */
1897 priv->stop_hang_check = 1;
1898 cancel_delayed_work(&priv->hang_check);
1900 /* We have to signal any supplicant if we are disassociating */
1902 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1904 ipw2100_up(priv, 0);
1905 mutex_unlock(&priv->action_mutex);
1909 static void isr_indicate_associated(struct ipw2100_priv *priv, u32 status)
1912 #define MAC_ASSOCIATION_READ_DELAY (HZ)
1913 int ret, len, essid_len;
1914 char essid[IW_ESSID_MAX_SIZE];
1919 DECLARE_SSID_BUF(ssid);
1922 * TBD: BSSID is usually 00:00:00:00:00:00 here and not
1923 * an actual MAC of the AP. Seems like FW sets this
1924 * address too late. Read it later and expose through
1925 * /proc or schedule a later task to query and update
1928 essid_len = IW_ESSID_MAX_SIZE;
1929 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID,
1932 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1938 ret = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &txrate, &len);
1940 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1946 ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &len);
1948 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1953 ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID, &bssid, &len);
1955 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
1959 memcpy(priv->ieee->bssid, bssid, ETH_ALEN);
1962 case TX_RATE_1_MBIT:
1963 txratename = "1Mbps";
1965 case TX_RATE_2_MBIT:
1966 txratename = "2Mbsp";
1968 case TX_RATE_5_5_MBIT:
1969 txratename = "5.5Mbps";
1971 case TX_RATE_11_MBIT:
1972 txratename = "11Mbps";
1975 IPW_DEBUG_INFO("Unknown rate: %d\n", txrate);
1976 txratename = "unknown rate";
1980 IPW_DEBUG_INFO("%s: Associated with '%s' at %s, channel %d (BSSID=%pM)\n",
1981 priv->net_dev->name, print_ssid(ssid, essid, essid_len),
1982 txratename, chan, bssid);
1984 /* now we copy read ssid into dev */
1985 if (!(priv->config & CFG_STATIC_ESSID)) {
1986 priv->essid_len = min((u8) essid_len, (u8) IW_ESSID_MAX_SIZE);
1987 memcpy(priv->essid, essid, priv->essid_len);
1989 priv->channel = chan;
1990 memcpy(priv->bssid, bssid, ETH_ALEN);
1992 priv->status |= STATUS_ASSOCIATING;
1993 priv->connect_start = get_seconds();
1995 queue_delayed_work(priv->workqueue, &priv->wx_event_work, HZ / 10);
1998 static int ipw2100_set_essid(struct ipw2100_priv *priv, char *essid,
1999 int length, int batch_mode)
2001 int ssid_len = min(length, IW_ESSID_MAX_SIZE);
2002 struct host_command cmd = {
2003 .host_command = SSID,
2004 .host_command_sequence = 0,
2005 .host_command_length = ssid_len
2008 DECLARE_SSID_BUF(ssid);
2010 IPW_DEBUG_HC("SSID: '%s'\n", print_ssid(ssid, essid, ssid_len));
2013 memcpy(cmd.host_command_parameters, essid, ssid_len);
2016 err = ipw2100_disable_adapter(priv);
2021 /* Bug in FW currently doesn't honor bit 0 in SET_SCAN_OPTIONS to
2022 * disable auto association -- so we cheat by setting a bogus SSID */
2023 if (!ssid_len && !(priv->config & CFG_ASSOCIATE)) {
2025 u8 *bogus = (u8 *) cmd.host_command_parameters;
2026 for (i = 0; i < IW_ESSID_MAX_SIZE; i++)
2027 bogus[i] = 0x18 + i;
2028 cmd.host_command_length = IW_ESSID_MAX_SIZE;
2031 /* NOTE: We always send the SSID command even if the provided ESSID is
2032 * the same as what we currently think is set. */
2034 err = ipw2100_hw_send_command(priv, &cmd);
2036 memset(priv->essid + ssid_len, 0, IW_ESSID_MAX_SIZE - ssid_len);
2037 memcpy(priv->essid, essid, ssid_len);
2038 priv->essid_len = ssid_len;
2042 if (ipw2100_enable_adapter(priv))
2049 static void isr_indicate_association_lost(struct ipw2100_priv *priv, u32 status)
2051 DECLARE_SSID_BUF(ssid);
2053 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DL_ASSOC,
2054 "disassociated: '%s' %pM \n",
2055 print_ssid(ssid, priv->essid, priv->essid_len),
2058 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
2060 if (priv->status & STATUS_STOPPING) {
2061 IPW_DEBUG_INFO("Card is stopping itself, discard ASSN_LOST.\n");
2065 memset(priv->bssid, 0, ETH_ALEN);
2066 memset(priv->ieee->bssid, 0, ETH_ALEN);
2068 netif_carrier_off(priv->net_dev);
2069 netif_stop_queue(priv->net_dev);
2071 if (!(priv->status & STATUS_RUNNING))
2074 if (priv->status & STATUS_SECURITY_UPDATED)
2075 queue_delayed_work(priv->workqueue, &priv->security_work, 0);
2077 queue_delayed_work(priv->workqueue, &priv->wx_event_work, 0);
2080 static void isr_indicate_rf_kill(struct ipw2100_priv *priv, u32 status)
2082 IPW_DEBUG_INFO("%s: RF Kill state changed to radio OFF.\n",
2083 priv->net_dev->name);
2085 /* RF_KILL is now enabled (else we wouldn't be here) */
2086 priv->status |= STATUS_RF_KILL_HW;
2088 /* Make sure the RF Kill check timer is running */
2089 priv->stop_rf_kill = 0;
2090 cancel_delayed_work(&priv->rf_kill);
2091 queue_delayed_work(priv->workqueue, &priv->rf_kill,
2092 round_jiffies_relative(HZ));
2095 static void send_scan_event(void *data)
2097 struct ipw2100_priv *priv = data;
2098 union iwreq_data wrqu;
2100 wrqu.data.length = 0;
2101 wrqu.data.flags = 0;
2102 wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
2105 static void ipw2100_scan_event_later(struct work_struct *work)
2107 send_scan_event(container_of(work, struct ipw2100_priv,
2108 scan_event_later.work));
2111 static void ipw2100_scan_event_now(struct work_struct *work)
2113 send_scan_event(container_of(work, struct ipw2100_priv,
2117 static void isr_scan_complete(struct ipw2100_priv *priv, u32 status)
2119 IPW_DEBUG_SCAN("scan complete\n");
2120 /* Age the scan results... */
2121 priv->ieee->scans++;
2122 priv->status &= ~STATUS_SCANNING;
2124 /* Only userspace-requested scan completion events go out immediately */
2125 if (!priv->user_requested_scan) {
2126 if (!delayed_work_pending(&priv->scan_event_later))
2127 queue_delayed_work(priv->workqueue,
2128 &priv->scan_event_later,
2129 round_jiffies_relative(msecs_to_jiffies(4000)));
2131 priv->user_requested_scan = 0;
2132 cancel_delayed_work(&priv->scan_event_later);
2133 queue_work(priv->workqueue, &priv->scan_event_now);
2137 #ifdef CONFIG_IPW2100_DEBUG
2138 #define IPW2100_HANDLER(v, f) { v, f, # v }
2139 struct ipw2100_status_indicator {
2141 void (*cb) (struct ipw2100_priv * priv, u32 status);
2145 #define IPW2100_HANDLER(v, f) { v, f }
2146 struct ipw2100_status_indicator {
2148 void (*cb) (struct ipw2100_priv * priv, u32 status);
2150 #endif /* CONFIG_IPW2100_DEBUG */
2152 static void isr_indicate_scanning(struct ipw2100_priv *priv, u32 status)
2154 IPW_DEBUG_SCAN("Scanning...\n");
2155 priv->status |= STATUS_SCANNING;
2158 static const struct ipw2100_status_indicator status_handlers[] = {
2159 IPW2100_HANDLER(IPW_STATE_INITIALIZED, NULL),
2160 IPW2100_HANDLER(IPW_STATE_COUNTRY_FOUND, NULL),
2161 IPW2100_HANDLER(IPW_STATE_ASSOCIATED, isr_indicate_associated),
2162 IPW2100_HANDLER(IPW_STATE_ASSN_LOST, isr_indicate_association_lost),
2163 IPW2100_HANDLER(IPW_STATE_ASSN_CHANGED, NULL),
2164 IPW2100_HANDLER(IPW_STATE_SCAN_COMPLETE, isr_scan_complete),
2165 IPW2100_HANDLER(IPW_STATE_ENTERED_PSP, NULL),
2166 IPW2100_HANDLER(IPW_STATE_LEFT_PSP, NULL),
2167 IPW2100_HANDLER(IPW_STATE_RF_KILL, isr_indicate_rf_kill),
2168 IPW2100_HANDLER(IPW_STATE_DISABLED, NULL),
2169 IPW2100_HANDLER(IPW_STATE_POWER_DOWN, NULL),
2170 IPW2100_HANDLER(IPW_STATE_SCANNING, isr_indicate_scanning),
2171 IPW2100_HANDLER(-1, NULL)
2174 static void isr_status_change(struct ipw2100_priv *priv, int status)
2178 if (status == IPW_STATE_SCANNING &&
2179 priv->status & STATUS_ASSOCIATED &&
2180 !(priv->status & STATUS_SCANNING)) {
2181 IPW_DEBUG_INFO("Scan detected while associated, with "
2182 "no scan request. Restarting firmware.\n");
2184 /* Wake up any sleeping jobs */
2185 schedule_reset(priv);
2188 for (i = 0; status_handlers[i].status != -1; i++) {
2189 if (status == status_handlers[i].status) {
2190 IPW_DEBUG_NOTIF("Status change: %s\n",
2191 status_handlers[i].name);
2192 if (status_handlers[i].cb)
2193 status_handlers[i].cb(priv, status);
2194 priv->wstats.status = status;
2199 IPW_DEBUG_NOTIF("unknown status received: %04x\n", status);
2202 static void isr_rx_complete_command(struct ipw2100_priv *priv,
2203 struct ipw2100_cmd_header *cmd)
2205 #ifdef CONFIG_IPW2100_DEBUG
2206 if (cmd->host_command_reg < ARRAY_SIZE(command_types)) {
2207 IPW_DEBUG_HC("Command completed '%s (%d)'\n",
2208 command_types[cmd->host_command_reg],
2209 cmd->host_command_reg);
2212 if (cmd->host_command_reg == HOST_COMPLETE)
2213 priv->status |= STATUS_ENABLED;
2215 if (cmd->host_command_reg == CARD_DISABLE)
2216 priv->status &= ~STATUS_ENABLED;
2218 priv->status &= ~STATUS_CMD_ACTIVE;
2220 wake_up_interruptible(&priv->wait_command_queue);
2223 #ifdef CONFIG_IPW2100_DEBUG
2224 static const char *frame_types[] = {
2225 "COMMAND_STATUS_VAL",
2226 "STATUS_CHANGE_VAL",
2229 "HOST_NOTIFICATION_VAL"
2233 static int ipw2100_alloc_skb(struct ipw2100_priv *priv,
2234 struct ipw2100_rx_packet *packet)
2236 packet->skb = dev_alloc_skb(sizeof(struct ipw2100_rx));
2240 packet->rxp = (struct ipw2100_rx *)packet->skb->data;
2241 packet->dma_addr = pci_map_single(priv->pci_dev, packet->skb->data,
2242 sizeof(struct ipw2100_rx),
2243 PCI_DMA_FROMDEVICE);
2244 /* NOTE: pci_map_single does not return an error code, and 0 is a valid
2250 #define SEARCH_ERROR 0xffffffff
2251 #define SEARCH_FAIL 0xfffffffe
2252 #define SEARCH_SUCCESS 0xfffffff0
2253 #define SEARCH_DISCARD 0
2254 #define SEARCH_SNAPSHOT 1
2256 #define SNAPSHOT_ADDR(ofs) (priv->snapshot[((ofs) >> 12) & 0xff] + ((ofs) & 0xfff))
2257 static void ipw2100_snapshot_free(struct ipw2100_priv *priv)
2260 if (!priv->snapshot[0])
2262 for (i = 0; i < 0x30; i++)
2263 kfree(priv->snapshot[i]);
2264 priv->snapshot[0] = NULL;
2267 #ifdef IPW2100_DEBUG_C3
2268 static int ipw2100_snapshot_alloc(struct ipw2100_priv *priv)
2271 if (priv->snapshot[0])
2273 for (i = 0; i < 0x30; i++) {
2274 priv->snapshot[i] = kmalloc(0x1000, GFP_ATOMIC);
2275 if (!priv->snapshot[i]) {
2276 IPW_DEBUG_INFO("%s: Error allocating snapshot "
2277 "buffer %d\n", priv->net_dev->name, i);
2279 kfree(priv->snapshot[--i]);
2280 priv->snapshot[0] = NULL;
2288 static u32 ipw2100_match_buf(struct ipw2100_priv *priv, u8 * in_buf,
2289 size_t len, int mode)
2297 if (mode == SEARCH_SNAPSHOT) {
2298 if (!ipw2100_snapshot_alloc(priv))
2299 mode = SEARCH_DISCARD;
2302 for (ret = SEARCH_FAIL, i = 0; i < 0x30000; i += 4) {
2303 read_nic_dword(priv->net_dev, i, &tmp);
2304 if (mode == SEARCH_SNAPSHOT)
2305 *(u32 *) SNAPSHOT_ADDR(i) = tmp;
2306 if (ret == SEARCH_FAIL) {
2308 for (j = 0; j < 4; j++) {
2317 if ((s - in_buf) == len)
2318 ret = (i + j) - len + 1;
2320 } else if (mode == SEARCH_DISCARD)
2330 * 0) Disconnect the SKB from the firmware (just unmap)
2331 * 1) Pack the ETH header into the SKB
2332 * 2) Pass the SKB to the network stack
2334 * When packet is provided by the firmware, it contains the following:
2337 * . ieee80211_snap_hdr
2339 * The size of the constructed ethernet
2342 #ifdef IPW2100_RX_DEBUG
2343 static u8 packet_data[IPW_RX_NIC_BUFFER_LENGTH];
2346 static void ipw2100_corruption_detected(struct ipw2100_priv *priv, int i)
2348 #ifdef IPW2100_DEBUG_C3
2349 struct ipw2100_status *status = &priv->status_queue.drv[i];
2354 IPW_DEBUG_INFO(": PCI latency error detected at 0x%04zX.\n",
2355 i * sizeof(struct ipw2100_status));
2357 #ifdef IPW2100_DEBUG_C3
2358 /* Halt the fimrware so we can get a good image */
2359 write_register(priv->net_dev, IPW_REG_RESET_REG,
2360 IPW_AUX_HOST_RESET_REG_STOP_MASTER);
2363 udelay(IPW_WAIT_RESET_MASTER_ASSERT_COMPLETE_DELAY);
2364 read_register(priv->net_dev, IPW_REG_RESET_REG, ®);
2366 if (reg & IPW_AUX_HOST_RESET_REG_MASTER_DISABLED)
2370 match = ipw2100_match_buf(priv, (u8 *) status,
2371 sizeof(struct ipw2100_status),
2373 if (match < SEARCH_SUCCESS)
2374 IPW_DEBUG_INFO("%s: DMA status match in Firmware at "
2375 "offset 0x%06X, length %d:\n",
2376 priv->net_dev->name, match,
2377 sizeof(struct ipw2100_status));
2379 IPW_DEBUG_INFO("%s: No DMA status match in "
2380 "Firmware.\n", priv->net_dev->name);
2382 printk_buf((u8 *) priv->status_queue.drv,
2383 sizeof(struct ipw2100_status) * RX_QUEUE_LENGTH);
2386 priv->fatal_error = IPW2100_ERR_C3_CORRUPTION;
2387 priv->ieee->stats.rx_errors++;
2388 schedule_reset(priv);
2391 static void isr_rx(struct ipw2100_priv *priv, int i,
2392 struct ieee80211_rx_stats *stats)
2394 struct ipw2100_status *status = &priv->status_queue.drv[i];
2395 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
2397 IPW_DEBUG_RX("Handler...\n");
2399 if (unlikely(status->frame_size > skb_tailroom(packet->skb))) {
2400 IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!"
2402 priv->net_dev->name,
2403 status->frame_size, skb_tailroom(packet->skb));
2404 priv->ieee->stats.rx_errors++;
2408 if (unlikely(!netif_running(priv->net_dev))) {
2409 priv->ieee->stats.rx_errors++;
2410 priv->wstats.discard.misc++;
2411 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
2415 if (unlikely(priv->ieee->iw_mode != IW_MODE_MONITOR &&
2416 !(priv->status & STATUS_ASSOCIATED))) {
2417 IPW_DEBUG_DROP("Dropping packet while not associated.\n");
2418 priv->wstats.discard.misc++;
2422 pci_unmap_single(priv->pci_dev,
2424 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE);
2426 skb_put(packet->skb, status->frame_size);
2428 #ifdef IPW2100_RX_DEBUG
2429 /* Make a copy of the frame so we can dump it to the logs if
2430 * ieee80211_rx fails */
2431 skb_copy_from_linear_data(packet->skb, packet_data,
2432 min_t(u32, status->frame_size,
2433 IPW_RX_NIC_BUFFER_LENGTH));
2436 if (!ieee80211_rx(priv->ieee, packet->skb, stats)) {
2437 #ifdef IPW2100_RX_DEBUG
2438 IPW_DEBUG_DROP("%s: Non consumed packet:\n",
2439 priv->net_dev->name);
2440 printk_buf(IPW_DL_DROP, packet_data, status->frame_size);
2442 priv->ieee->stats.rx_errors++;
2444 /* ieee80211_rx failed, so it didn't free the SKB */
2445 dev_kfree_skb_any(packet->skb);
2449 /* We need to allocate a new SKB and attach it to the RDB. */
2450 if (unlikely(ipw2100_alloc_skb(priv, packet))) {
2451 printk(KERN_WARNING DRV_NAME ": "
2452 "%s: Unable to allocate SKB onto RBD ring - disabling "
2453 "adapter.\n", priv->net_dev->name);
2454 /* TODO: schedule adapter shutdown */
2455 IPW_DEBUG_INFO("TODO: Shutdown adapter...\n");
2458 /* Update the RDB entry */
2459 priv->rx_queue.drv[i].host_addr = packet->dma_addr;
2462 #ifdef CONFIG_IPW2100_MONITOR
2464 static void isr_rx_monitor(struct ipw2100_priv *priv, int i,
2465 struct ieee80211_rx_stats *stats)
2467 struct ipw2100_status *status = &priv->status_queue.drv[i];
2468 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
2470 /* Magic struct that slots into the radiotap header -- no reason
2471 * to build this manually element by element, we can write it much
2472 * more efficiently than we can parse it. ORDER MATTERS HERE */
2474 struct ieee80211_radiotap_header rt_hdr;
2475 s8 rt_dbmsignal; /* signal in dbM, kluged to signed */
2478 IPW_DEBUG_RX("Handler...\n");
2480 if (unlikely(status->frame_size > skb_tailroom(packet->skb) -
2481 sizeof(struct ipw_rt_hdr))) {
2482 IPW_DEBUG_INFO("%s: frame_size (%u) > skb_tailroom (%u)!"
2484 priv->net_dev->name,
2486 skb_tailroom(packet->skb));
2487 priv->ieee->stats.rx_errors++;
2491 if (unlikely(!netif_running(priv->net_dev))) {
2492 priv->ieee->stats.rx_errors++;
2493 priv->wstats.discard.misc++;
2494 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
2498 if (unlikely(priv->config & CFG_CRC_CHECK &&
2499 status->flags & IPW_STATUS_FLAG_CRC_ERROR)) {
2500 IPW_DEBUG_RX("CRC error in packet. Dropping.\n");
2501 priv->ieee->stats.rx_errors++;
2505 pci_unmap_single(priv->pci_dev, packet->dma_addr,
2506 sizeof(struct ipw2100_rx), PCI_DMA_FROMDEVICE);
2507 memmove(packet->skb->data + sizeof(struct ipw_rt_hdr),
2508 packet->skb->data, status->frame_size);
2510 ipw_rt = (struct ipw_rt_hdr *) packet->skb->data;
2512 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
2513 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
2514 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total hdr+data */
2516 ipw_rt->rt_hdr.it_present = cpu_to_le32(1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL);
2518 ipw_rt->rt_dbmsignal = status->rssi + IPW2100_RSSI_TO_DBM;
2520 skb_put(packet->skb, status->frame_size + sizeof(struct ipw_rt_hdr));
2522 if (!ieee80211_rx(priv->ieee, packet->skb, stats)) {
2523 priv->ieee->stats.rx_errors++;
2525 /* ieee80211_rx failed, so it didn't free the SKB */
2526 dev_kfree_skb_any(packet->skb);
2530 /* We need to allocate a new SKB and attach it to the RDB. */
2531 if (unlikely(ipw2100_alloc_skb(priv, packet))) {
2533 "%s: Unable to allocate SKB onto RBD ring - disabling "
2534 "adapter.\n", priv->net_dev->name);
2535 /* TODO: schedule adapter shutdown */
2536 IPW_DEBUG_INFO("TODO: Shutdown adapter...\n");
2539 /* Update the RDB entry */
2540 priv->rx_queue.drv[i].host_addr = packet->dma_addr;
2545 static int ipw2100_corruption_check(struct ipw2100_priv *priv, int i)
2547 struct ipw2100_status *status = &priv->status_queue.drv[i];
2548 struct ipw2100_rx *u = priv->rx_buffers[i].rxp;
2549 u16 frame_type = status->status_fields & STATUS_TYPE_MASK;
2551 switch (frame_type) {
2552 case COMMAND_STATUS_VAL:
2553 return (status->frame_size != sizeof(u->rx_data.command));
2554 case STATUS_CHANGE_VAL:
2555 return (status->frame_size != sizeof(u->rx_data.status));
2556 case HOST_NOTIFICATION_VAL:
2557 return (status->frame_size < sizeof(u->rx_data.notification));
2558 case P80211_DATA_VAL:
2559 case P8023_DATA_VAL:
2560 #ifdef CONFIG_IPW2100_MONITOR
2563 switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) {
2564 case IEEE80211_FTYPE_MGMT:
2565 case IEEE80211_FTYPE_CTL:
2567 case IEEE80211_FTYPE_DATA:
2568 return (status->frame_size >
2569 IPW_MAX_802_11_PAYLOAD_LENGTH);
2578 * ipw2100 interrupts are disabled at this point, and the ISR
2579 * is the only code that calls this method. So, we do not need
2580 * to play with any locks.
2582 * RX Queue works as follows:
2584 * Read index - firmware places packet in entry identified by the
2585 * Read index and advances Read index. In this manner,
2586 * Read index will always point to the next packet to
2587 * be filled--but not yet valid.
2589 * Write index - driver fills this entry with an unused RBD entry.
2590 * This entry has not filled by the firmware yet.
2592 * In between the W and R indexes are the RBDs that have been received
2593 * but not yet processed.
2595 * The process of handling packets will start at WRITE + 1 and advance
2596 * until it reaches the READ index.
2598 * The WRITE index is cached in the variable 'priv->rx_queue.next'.
2601 static void __ipw2100_rx_process(struct ipw2100_priv *priv)
2603 struct ipw2100_bd_queue *rxq = &priv->rx_queue;
2604 struct ipw2100_status_queue *sq = &priv->status_queue;
2605 struct ipw2100_rx_packet *packet;
2608 struct ipw2100_rx *u;
2609 struct ieee80211_rx_stats stats = {
2610 .mac_time = jiffies,
2613 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_READ_INDEX, &r);
2614 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, &w);
2616 if (r >= rxq->entries) {
2617 IPW_DEBUG_RX("exit - bad read index\n");
2621 i = (rxq->next + 1) % rxq->entries;
2624 /* IPW_DEBUG_RX("r = %d : w = %d : processing = %d\n",
2625 r, rxq->next, i); */
2627 packet = &priv->rx_buffers[i];
2629 /* Sync the DMA for the STATUS buffer so CPU is sure to get
2630 * the correct values */
2631 pci_dma_sync_single_for_cpu(priv->pci_dev,
2633 sizeof(struct ipw2100_status) * i,
2634 sizeof(struct ipw2100_status),
2635 PCI_DMA_FROMDEVICE);
2637 /* Sync the DMA for the RX buffer so CPU is sure to get
2638 * the correct values */
2639 pci_dma_sync_single_for_cpu(priv->pci_dev, packet->dma_addr,
2640 sizeof(struct ipw2100_rx),
2641 PCI_DMA_FROMDEVICE);
2643 if (unlikely(ipw2100_corruption_check(priv, i))) {
2644 ipw2100_corruption_detected(priv, i);
2649 frame_type = sq->drv[i].status_fields & STATUS_TYPE_MASK;
2650 stats.rssi = sq->drv[i].rssi + IPW2100_RSSI_TO_DBM;
2651 stats.len = sq->drv[i].frame_size;
2654 if (stats.rssi != 0)
2655 stats.mask |= IEEE80211_STATMASK_RSSI;
2656 stats.freq = IEEE80211_24GHZ_BAND;
2658 IPW_DEBUG_RX("%s: '%s' frame type received (%d).\n",
2659 priv->net_dev->name, frame_types[frame_type],
2662 switch (frame_type) {
2663 case COMMAND_STATUS_VAL:
2664 /* Reset Rx watchdog */
2665 isr_rx_complete_command(priv, &u->rx_data.command);
2668 case STATUS_CHANGE_VAL:
2669 isr_status_change(priv, u->rx_data.status);
2672 case P80211_DATA_VAL:
2673 case P8023_DATA_VAL:
2674 #ifdef CONFIG_IPW2100_MONITOR
2675 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
2676 isr_rx_monitor(priv, i, &stats);
2680 if (stats.len < sizeof(struct ieee80211_hdr_3addr))
2682 switch (WLAN_FC_GET_TYPE(le16_to_cpu(u->rx_data.header.frame_ctl))) {
2683 case IEEE80211_FTYPE_MGMT:
2684 ieee80211_rx_mgt(priv->ieee,
2685 &u->rx_data.header, &stats);
2688 case IEEE80211_FTYPE_CTL:
2691 case IEEE80211_FTYPE_DATA:
2692 isr_rx(priv, i, &stats);
2700 /* clear status field associated with this RBD */
2701 rxq->drv[i].status.info.field = 0;
2703 i = (i + 1) % rxq->entries;
2707 /* backtrack one entry, wrapping to end if at 0 */
2708 rxq->next = (i ? i : rxq->entries) - 1;
2710 write_register(priv->net_dev,
2711 IPW_MEM_HOST_SHARED_RX_WRITE_INDEX, rxq->next);
2716 * __ipw2100_tx_process
2718 * This routine will determine whether the next packet on
2719 * the fw_pend_list has been processed by the firmware yet.
2721 * If not, then it does nothing and returns.
2723 * If so, then it removes the item from the fw_pend_list, frees
2724 * any associated storage, and places the item back on the
2725 * free list of its source (either msg_free_list or tx_free_list)
2727 * TX Queue works as follows:
2729 * Read index - points to the next TBD that the firmware will
2730 * process. The firmware will read the data, and once
2731 * done processing, it will advance the Read index.
2733 * Write index - driver fills this entry with an constructed TBD
2734 * entry. The Write index is not advanced until the
2735 * packet has been configured.
2737 * In between the W and R indexes are the TBDs that have NOT been
2738 * processed. Lagging behind the R index are packets that have
2739 * been processed but have not been freed by the driver.
2741 * In order to free old storage, an internal index will be maintained
2742 * that points to the next packet to be freed. When all used
2743 * packets have been freed, the oldest index will be the same as the
2744 * firmware's read index.
2746 * The OLDEST index is cached in the variable 'priv->tx_queue.oldest'
2748 * Because the TBD structure can not contain arbitrary data, the
2749 * driver must keep an internal queue of cached allocations such that
2750 * it can put that data back into the tx_free_list and msg_free_list
2751 * for use by future command and data packets.
2754 static int __ipw2100_tx_process(struct ipw2100_priv *priv)
2756 struct ipw2100_bd_queue *txq = &priv->tx_queue;
2757 struct ipw2100_bd *tbd;
2758 struct list_head *element;
2759 struct ipw2100_tx_packet *packet;
2760 int descriptors_used;
2762 u32 r, w, frag_num = 0;
2764 if (list_empty(&priv->fw_pend_list))
2767 element = priv->fw_pend_list.next;
2769 packet = list_entry(element, struct ipw2100_tx_packet, list);
2770 tbd = &txq->drv[packet->index];
2772 /* Determine how many TBD entries must be finished... */
2773 switch (packet->type) {
2775 /* COMMAND uses only one slot; don't advance */
2776 descriptors_used = 1;
2781 /* DATA uses two slots; advance and loop position. */
2782 descriptors_used = tbd->num_fragments;
2783 frag_num = tbd->num_fragments - 1;
2784 e = txq->oldest + frag_num;
2789 printk(KERN_WARNING DRV_NAME ": %s: Bad fw_pend_list entry!\n",
2790 priv->net_dev->name);
2794 /* if the last TBD is not done by NIC yet, then packet is
2795 * not ready to be released.
2798 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX,
2800 read_register(priv->net_dev, IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
2803 printk(KERN_WARNING DRV_NAME ": %s: write index mismatch\n",
2804 priv->net_dev->name);
2807 * txq->next is the index of the last packet written txq->oldest is
2808 * the index of the r is the index of the next packet to be read by
2813 * Quick graphic to help you visualize the following
2814 * if / else statement
2816 * ===>| s---->|===============
2818 * | a | b | c | d | e | f | g | h | i | j | k | l
2822 * w - updated by driver
2823 * r - updated by firmware
2824 * s - start of oldest BD entry (txq->oldest)
2825 * e - end of oldest BD entry
2828 if (!((r <= w && (e < r || e >= w)) || (e < r && e >= w))) {
2829 IPW_DEBUG_TX("exit - no processed packets ready to release.\n");
2834 DEC_STAT(&priv->fw_pend_stat);
2836 #ifdef CONFIG_IPW2100_DEBUG
2838 int i = txq->oldest;
2839 IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i,
2841 (u32) (txq->nic + i * sizeof(struct ipw2100_bd)),
2842 txq->drv[i].host_addr, txq->drv[i].buf_length);
2844 if (packet->type == DATA) {
2845 i = (i + 1) % txq->entries;
2847 IPW_DEBUG_TX("TX%d V=%p P=%04X T=%04X L=%d\n", i,
2849 (u32) (txq->nic + i *
2850 sizeof(struct ipw2100_bd)),
2851 (u32) txq->drv[i].host_addr,
2852 txq->drv[i].buf_length);
2857 switch (packet->type) {
2859 if (txq->drv[txq->oldest].status.info.fields.txType != 0)
2860 printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch. "
2861 "Expecting DATA TBD but pulled "
2862 "something else: ids %d=%d.\n",
2863 priv->net_dev->name, txq->oldest, packet->index);
2865 /* DATA packet; we have to unmap and free the SKB */
2866 for (i = 0; i < frag_num; i++) {
2867 tbd = &txq->drv[(packet->index + 1 + i) % txq->entries];
2869 IPW_DEBUG_TX("TX%d P=%08x L=%d\n",
2870 (packet->index + 1 + i) % txq->entries,
2871 tbd->host_addr, tbd->buf_length);
2873 pci_unmap_single(priv->pci_dev,
2875 tbd->buf_length, PCI_DMA_TODEVICE);
2878 ieee80211_txb_free(packet->info.d_struct.txb);
2879 packet->info.d_struct.txb = NULL;
2881 list_add_tail(element, &priv->tx_free_list);
2882 INC_STAT(&priv->tx_free_stat);
2884 /* We have a free slot in the Tx queue, so wake up the
2885 * transmit layer if it is stopped. */
2886 if (priv->status & STATUS_ASSOCIATED)
2887 netif_wake_queue(priv->net_dev);
2889 /* A packet was processed by the hardware, so update the
2891 priv->net_dev->trans_start = jiffies;
2896 if (txq->drv[txq->oldest].status.info.fields.txType != 1)
2897 printk(KERN_WARNING DRV_NAME ": %s: Queue mismatch. "
2898 "Expecting COMMAND TBD but pulled "
2899 "something else: ids %d=%d.\n",
2900 priv->net_dev->name, txq->oldest, packet->index);
2902 #ifdef CONFIG_IPW2100_DEBUG
2903 if (packet->info.c_struct.cmd->host_command_reg <
2904 ARRAY_SIZE(command_types))
2905 IPW_DEBUG_TX("Command '%s (%d)' processed: %d.\n",
2906 command_types[packet->info.c_struct.cmd->
2908 packet->info.c_struct.cmd->
2910 packet->info.c_struct.cmd->cmd_status_reg);
2913 list_add_tail(element, &priv->msg_free_list);
2914 INC_STAT(&priv->msg_free_stat);
2918 /* advance oldest used TBD pointer to start of next entry */
2919 txq->oldest = (e + 1) % txq->entries;
2920 /* increase available TBDs number */
2921 txq->available += descriptors_used;
2922 SET_STAT(&priv->txq_stat, txq->available);
2924 IPW_DEBUG_TX("packet latency (send to process) %ld jiffies\n",
2925 jiffies - packet->jiffy_start);
2927 return (!list_empty(&priv->fw_pend_list));
2930 static inline void __ipw2100_tx_complete(struct ipw2100_priv *priv)
2934 while (__ipw2100_tx_process(priv) && i < 200)
2938 printk(KERN_WARNING DRV_NAME ": "
2939 "%s: Driver is running slow (%d iters).\n",
2940 priv->net_dev->name, i);
2944 static void ipw2100_tx_send_commands(struct ipw2100_priv *priv)
2946 struct list_head *element;
2947 struct ipw2100_tx_packet *packet;
2948 struct ipw2100_bd_queue *txq = &priv->tx_queue;
2949 struct ipw2100_bd *tbd;
2950 int next = txq->next;
2952 while (!list_empty(&priv->msg_pend_list)) {
2953 /* if there isn't enough space in TBD queue, then
2954 * don't stuff a new one in.
2955 * NOTE: 3 are needed as a command will take one,
2956 * and there is a minimum of 2 that must be
2957 * maintained between the r and w indexes
2959 if (txq->available <= 3) {
2960 IPW_DEBUG_TX("no room in tx_queue\n");
2964 element = priv->msg_pend_list.next;
2966 DEC_STAT(&priv->msg_pend_stat);
2968 packet = list_entry(element, struct ipw2100_tx_packet, list);
2970 IPW_DEBUG_TX("using TBD at virt=%p, phys=%p\n",
2971 &txq->drv[txq->next],
2972 (void *)(txq->nic + txq->next *
2973 sizeof(struct ipw2100_bd)));
2975 packet->index = txq->next;
2977 tbd = &txq->drv[txq->next];
2979 /* initialize TBD */
2980 tbd->host_addr = packet->info.c_struct.cmd_phys;
2981 tbd->buf_length = sizeof(struct ipw2100_cmd_header);
2982 /* not marking number of fragments causes problems
2983 * with f/w debug version */
2984 tbd->num_fragments = 1;
2985 tbd->status.info.field =
2986 IPW_BD_STATUS_TX_FRAME_COMMAND |
2987 IPW_BD_STATUS_TX_INTERRUPT_ENABLE;
2989 /* update TBD queue counters */
2991 txq->next %= txq->entries;
2993 DEC_STAT(&priv->txq_stat);
2995 list_add_tail(element, &priv->fw_pend_list);
2996 INC_STAT(&priv->fw_pend_stat);
2999 if (txq->next != next) {
3000 /* kick off the DMA by notifying firmware the
3001 * write index has moved; make sure TBD stores are sync'd */
3003 write_register(priv->net_dev,
3004 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
3010 * ipw2100_tx_send_data
3013 static void ipw2100_tx_send_data(struct ipw2100_priv *priv)
3015 struct list_head *element;
3016 struct ipw2100_tx_packet *packet;
3017 struct ipw2100_bd_queue *txq = &priv->tx_queue;
3018 struct ipw2100_bd *tbd;
3019 int next = txq->next;
3021 struct ipw2100_data_header *ipw_hdr;
3022 struct ieee80211_hdr_3addr *hdr;
3024 while (!list_empty(&priv->tx_pend_list)) {
3025 /* if there isn't enough space in TBD queue, then
3026 * don't stuff a new one in.
3027 * NOTE: 4 are needed as a data will take two,
3028 * and there is a minimum of 2 that must be
3029 * maintained between the r and w indexes
3031 element = priv->tx_pend_list.next;
3032 packet = list_entry(element, struct ipw2100_tx_packet, list);
3034 if (unlikely(1 + packet->info.d_struct.txb->nr_frags >
3036 /* TODO: Support merging buffers if more than
3037 * IPW_MAX_BDS are used */
3038 IPW_DEBUG_INFO("%s: Maximum BD theshold exceeded. "
3039 "Increase fragmentation level.\n",
3040 priv->net_dev->name);
3043 if (txq->available <= 3 + packet->info.d_struct.txb->nr_frags) {
3044 IPW_DEBUG_TX("no room in tx_queue\n");
3049 DEC_STAT(&priv->tx_pend_stat);
3051 tbd = &txq->drv[txq->next];
3053 packet->index = txq->next;
3055 ipw_hdr = packet->info.d_struct.data;
3056 hdr = (struct ieee80211_hdr_3addr *)packet->info.d_struct.txb->
3059 if (priv->ieee->iw_mode == IW_MODE_INFRA) {
3060 /* To DS: Addr1 = BSSID, Addr2 = SA,
3062 memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN);
3063 memcpy(ipw_hdr->dst_addr, hdr->addr3, ETH_ALEN);
3064 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
3065 /* not From/To DS: Addr1 = DA, Addr2 = SA,
3067 memcpy(ipw_hdr->src_addr, hdr->addr2, ETH_ALEN);
3068 memcpy(ipw_hdr->dst_addr, hdr->addr1, ETH_ALEN);
3071 ipw_hdr->host_command_reg = SEND;
3072 ipw_hdr->host_command_reg1 = 0;
3074 /* For now we only support host based encryption */
3075 ipw_hdr->needs_encryption = 0;
3076 ipw_hdr->encrypted = packet->info.d_struct.txb->encrypted;
3077 if (packet->info.d_struct.txb->nr_frags > 1)
3078 ipw_hdr->fragment_size =
3079 packet->info.d_struct.txb->frag_size -
3080 IEEE80211_3ADDR_LEN;
3082 ipw_hdr->fragment_size = 0;
3084 tbd->host_addr = packet->info.d_struct.data_phys;
3085 tbd->buf_length = sizeof(struct ipw2100_data_header);
3086 tbd->num_fragments = 1 + packet->info.d_struct.txb->nr_frags;
3087 tbd->status.info.field =
3088 IPW_BD_STATUS_TX_FRAME_802_3 |
3089 IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT;
3091 txq->next %= txq->entries;
3093 IPW_DEBUG_TX("data header tbd TX%d P=%08x L=%d\n",
3094 packet->index, tbd->host_addr, tbd->buf_length);
3095 #ifdef CONFIG_IPW2100_DEBUG
3096 if (packet->info.d_struct.txb->nr_frags > 1)
3097 IPW_DEBUG_FRAG("fragment Tx: %d frames\n",
3098 packet->info.d_struct.txb->nr_frags);
3101 for (i = 0; i < packet->info.d_struct.txb->nr_frags; i++) {
3102 tbd = &txq->drv[txq->next];
3103 if (i == packet->info.d_struct.txb->nr_frags - 1)
3104 tbd->status.info.field =
3105 IPW_BD_STATUS_TX_FRAME_802_3 |
3106 IPW_BD_STATUS_TX_INTERRUPT_ENABLE;
3108 tbd->status.info.field =
3109 IPW_BD_STATUS_TX_FRAME_802_3 |
3110 IPW_BD_STATUS_TX_FRAME_NOT_LAST_FRAGMENT;
3112 tbd->buf_length = packet->info.d_struct.txb->
3113 fragments[i]->len - IEEE80211_3ADDR_LEN;
3115 tbd->host_addr = pci_map_single(priv->pci_dev,
3116 packet->info.d_struct.
3119 IEEE80211_3ADDR_LEN,
3123 IPW_DEBUG_TX("data frag tbd TX%d P=%08x L=%d\n",
3124 txq->next, tbd->host_addr,
3127 pci_dma_sync_single_for_device(priv->pci_dev,
3133 txq->next %= txq->entries;
3136 txq->available -= 1 + packet->info.d_struct.txb->nr_frags;
3137 SET_STAT(&priv->txq_stat, txq->available);
3139 list_add_tail(element, &priv->fw_pend_list);
3140 INC_STAT(&priv->fw_pend_stat);
3143 if (txq->next != next) {
3144 /* kick off the DMA by notifying firmware the
3145 * write index has moved; make sure TBD stores are sync'd */
3146 write_register(priv->net_dev,
3147 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX,
3153 static void ipw2100_irq_tasklet(struct ipw2100_priv *priv)
3155 struct net_device *dev = priv->net_dev;
3156 unsigned long flags;
3159 spin_lock_irqsave(&priv->low_lock, flags);
3160 ipw2100_disable_interrupts(priv);
3162 read_register(dev, IPW_REG_INTA, &inta);
3164 IPW_DEBUG_ISR("enter - INTA: 0x%08lX\n",
3165 (unsigned long)inta & IPW_INTERRUPT_MASK);
3170 /* We do not loop and keep polling for more interrupts as this
3171 * is frowned upon and doesn't play nicely with other potentially
3173 IPW_DEBUG_ISR("INTA: 0x%08lX\n",
3174 (unsigned long)inta & IPW_INTERRUPT_MASK);
3176 if (inta & IPW2100_INTA_FATAL_ERROR) {
3177 printk(KERN_WARNING DRV_NAME
3178 ": Fatal interrupt. Scheduling firmware restart.\n");
3180 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FATAL_ERROR);
3182 read_nic_dword(dev, IPW_NIC_FATAL_ERROR, &priv->fatal_error);
3183 IPW_DEBUG_INFO("%s: Fatal error value: 0x%08X\n",
3184 priv->net_dev->name, priv->fatal_error);
3186 read_nic_dword(dev, IPW_ERROR_ADDR(priv->fatal_error), &tmp);
3187 IPW_DEBUG_INFO("%s: Fatal error address value: 0x%08X\n",
3188 priv->net_dev->name, tmp);
3190 /* Wake up any sleeping jobs */
3191 schedule_reset(priv);
3194 if (inta & IPW2100_INTA_PARITY_ERROR) {
3195 printk(KERN_ERR DRV_NAME
3196 ": ***** PARITY ERROR INTERRUPT !!!! \n");
3198 write_register(dev, IPW_REG_INTA, IPW2100_INTA_PARITY_ERROR);
3201 if (inta & IPW2100_INTA_RX_TRANSFER) {
3202 IPW_DEBUG_ISR("RX interrupt\n");
3204 priv->rx_interrupts++;
3206 write_register(dev, IPW_REG_INTA, IPW2100_INTA_RX_TRANSFER);
3208 __ipw2100_rx_process(priv);
3209 __ipw2100_tx_complete(priv);
3212 if (inta & IPW2100_INTA_TX_TRANSFER) {
3213 IPW_DEBUG_ISR("TX interrupt\n");
3215 priv->tx_interrupts++;
3217 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_TRANSFER);
3219 __ipw2100_tx_complete(priv);
3220 ipw2100_tx_send_commands(priv);
3221 ipw2100_tx_send_data(priv);
3224 if (inta & IPW2100_INTA_TX_COMPLETE) {
3225 IPW_DEBUG_ISR("TX complete\n");
3227 write_register(dev, IPW_REG_INTA, IPW2100_INTA_TX_COMPLETE);
3229 __ipw2100_tx_complete(priv);
3232 if (inta & IPW2100_INTA_EVENT_INTERRUPT) {
3233 /* ipw2100_handle_event(dev); */
3235 write_register(dev, IPW_REG_INTA, IPW2100_INTA_EVENT_INTERRUPT);
3238 if (inta & IPW2100_INTA_FW_INIT_DONE) {
3239 IPW_DEBUG_ISR("FW init done interrupt\n");
3242 read_register(dev, IPW_REG_INTA, &tmp);
3243 if (tmp & (IPW2100_INTA_FATAL_ERROR |
3244 IPW2100_INTA_PARITY_ERROR)) {
3245 write_register(dev, IPW_REG_INTA,
3246 IPW2100_INTA_FATAL_ERROR |
3247 IPW2100_INTA_PARITY_ERROR);
3250 write_register(dev, IPW_REG_INTA, IPW2100_INTA_FW_INIT_DONE);
3253 if (inta & IPW2100_INTA_STATUS_CHANGE) {
3254 IPW_DEBUG_ISR("Status change interrupt\n");
3256 write_register(dev, IPW_REG_INTA, IPW2100_INTA_STATUS_CHANGE);
3259 if (inta & IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE) {
3260 IPW_DEBUG_ISR("slave host mode interrupt\n");
3262 write_register(dev, IPW_REG_INTA,
3263 IPW2100_INTA_SLAVE_MODE_HOST_COMMAND_DONE);
3267 ipw2100_enable_interrupts(priv);
3269 spin_unlock_irqrestore(&priv->low_lock, flags);
3271 IPW_DEBUG_ISR("exit\n");
3274 static irqreturn_t ipw2100_interrupt(int irq, void *data)
3276 struct ipw2100_priv *priv = data;
3277 u32 inta, inta_mask;
3282 spin_lock(&priv->low_lock);
3284 /* We check to see if we should be ignoring interrupts before
3285 * we touch the hardware. During ucode load if we try and handle
3286 * an interrupt we can cause keyboard problems as well as cause
3287 * the ucode to fail to initialize */
3288 if (!(priv->status & STATUS_INT_ENABLED)) {
3293 read_register(priv->net_dev, IPW_REG_INTA_MASK, &inta_mask);
3294 read_register(priv->net_dev, IPW_REG_INTA, &inta);
3296 if (inta == 0xFFFFFFFF) {
3297 /* Hardware disappeared */
3298 printk(KERN_WARNING DRV_NAME ": IRQ INTA == 0xFFFFFFFF\n");
3302 inta &= IPW_INTERRUPT_MASK;
3304 if (!(inta & inta_mask)) {
3305 /* Shared interrupt */
3309 /* We disable the hardware interrupt here just to prevent unneeded
3310 * calls to be made. We disable this again within the actual
3311 * work tasklet, so if another part of the code re-enables the
3312 * interrupt, that is fine */
3313 ipw2100_disable_interrupts(priv);
3315 tasklet_schedule(&priv->irq_tasklet);
3316 spin_unlock(&priv->low_lock);
3320 spin_unlock(&priv->low_lock);
3324 static int ipw2100_tx(struct ieee80211_txb *txb, struct net_device *dev,
3327 struct ipw2100_priv *priv = ieee80211_priv(dev);
3328 struct list_head *element;
3329 struct ipw2100_tx_packet *packet;
3330 unsigned long flags;
3332 spin_lock_irqsave(&priv->low_lock, flags);
3334 if (!(priv->status & STATUS_ASSOCIATED)) {
3335 IPW_DEBUG_INFO("Can not transmit when not connected.\n");
3336 priv->ieee->stats.tx_carrier_errors++;
3337 netif_stop_queue(dev);
3341 if (list_empty(&priv->tx_free_list))
3344 element = priv->tx_free_list.next;
3345 packet = list_entry(element, struct ipw2100_tx_packet, list);
3347 packet->info.d_struct.txb = txb;
3349 IPW_DEBUG_TX("Sending fragment (%d bytes):\n", txb->fragments[0]->len);
3350 printk_buf(IPW_DL_TX, txb->fragments[0]->data, txb->fragments[0]->len);
3352 packet->jiffy_start = jiffies;
3355 DEC_STAT(&priv->tx_free_stat);
3357 list_add_tail(element, &priv->tx_pend_list);
3358 INC_STAT(&priv->tx_pend_stat);
3360 ipw2100_tx_send_data(priv);
3362 spin_unlock_irqrestore(&priv->low_lock, flags);
3366 netif_stop_queue(dev);
3367 spin_unlock_irqrestore(&priv->low_lock, flags);
3371 static int ipw2100_msg_allocate(struct ipw2100_priv *priv)
3373 int i, j, err = -EINVAL;
3378 (struct ipw2100_tx_packet *)kmalloc(IPW_COMMAND_POOL_SIZE *
3382 if (!priv->msg_buffers) {
3383 printk(KERN_ERR DRV_NAME ": %s: PCI alloc failed for msg "
3384 "buffers.\n", priv->net_dev->name);
3388 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) {
3389 v = pci_alloc_consistent(priv->pci_dev,
3390 sizeof(struct ipw2100_cmd_header), &p);
3392 printk(KERN_ERR DRV_NAME ": "
3393 "%s: PCI alloc failed for msg "
3394 "buffers.\n", priv->net_dev->name);
3399 memset(v, 0, sizeof(struct ipw2100_cmd_header));
3401 priv->msg_buffers[i].type = COMMAND;
3402 priv->msg_buffers[i].info.c_struct.cmd =
3403 (struct ipw2100_cmd_header *)v;
3404 priv->msg_buffers[i].info.c_struct.cmd_phys = p;
3407 if (i == IPW_COMMAND_POOL_SIZE)
3410 for (j = 0; j < i; j++) {
3411 pci_free_consistent(priv->pci_dev,
3412 sizeof(struct ipw2100_cmd_header),
3413 priv->msg_buffers[j].info.c_struct.cmd,
3414 priv->msg_buffers[j].info.c_struct.
3418 kfree(priv->msg_buffers);
3419 priv->msg_buffers = NULL;
3424 static int ipw2100_msg_initialize(struct ipw2100_priv *priv)
3428 INIT_LIST_HEAD(&priv->msg_free_list);
3429 INIT_LIST_HEAD(&priv->msg_pend_list);
3431 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++)
3432 list_add_tail(&priv->msg_buffers[i].list, &priv->msg_free_list);
3433 SET_STAT(&priv->msg_free_stat, i);
3438 static void ipw2100_msg_free(struct ipw2100_priv *priv)
3442 if (!priv->msg_buffers)
3445 for (i = 0; i < IPW_COMMAND_POOL_SIZE; i++) {
3446 pci_free_consistent(priv->pci_dev,
3447 sizeof(struct ipw2100_cmd_header),
3448 priv->msg_buffers[i].info.c_struct.cmd,
3449 priv->msg_buffers[i].info.c_struct.
3453 kfree(priv->msg_buffers);
3454 priv->msg_buffers = NULL;
3457 static ssize_t show_pci(struct device *d, struct device_attribute *attr,
3460 struct pci_dev *pci_dev = container_of(d, struct pci_dev, dev);
3465 for (i = 0; i < 16; i++) {
3466 out += sprintf(out, "[%08X] ", i * 16);
3467 for (j = 0; j < 16; j += 4) {
3468 pci_read_config_dword(pci_dev, i * 16 + j, &val);
3469 out += sprintf(out, "%08X ", val);
3471 out += sprintf(out, "\n");
3477 static DEVICE_ATTR(pci, S_IRUGO, show_pci, NULL);
3479 static ssize_t show_cfg(struct device *d, struct device_attribute *attr,
3482 struct ipw2100_priv *p = d->driver_data;
3483 return sprintf(buf, "0x%08x\n", (int)p->config);
3486 static DEVICE_ATTR(cfg, S_IRUGO, show_cfg, NULL);
3488 static ssize_t show_status(struct device *d, struct device_attribute *attr,
3491 struct ipw2100_priv *p = d->driver_data;
3492 return sprintf(buf, "0x%08x\n", (int)p->status);
3495 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
3497 static ssize_t show_capability(struct device *d, struct device_attribute *attr,
3500 struct ipw2100_priv *p = d->driver_data;
3501 return sprintf(buf, "0x%08x\n", (int)p->capability);
3504 static DEVICE_ATTR(capability, S_IRUGO, show_capability, NULL);
3506 #define IPW2100_REG(x) { IPW_ ##x, #x }
3507 static const struct {
3511 IPW2100_REG(REG_GP_CNTRL),
3512 IPW2100_REG(REG_GPIO),
3513 IPW2100_REG(REG_INTA),
3514 IPW2100_REG(REG_INTA_MASK), IPW2100_REG(REG_RESET_REG),};
3515 #define IPW2100_NIC(x, s) { x, #x, s }
3516 static const struct {
3521 IPW2100_NIC(IPW2100_CONTROL_REG, 2),
3522 IPW2100_NIC(0x210014, 1), IPW2100_NIC(0x210000, 1),};
3523 #define IPW2100_ORD(x, d) { IPW_ORD_ ##x, #x, d }
3524 static const struct {
3529 IPW2100_ORD(STAT_TX_HOST_REQUESTS, "requested Host Tx's (MSDU)"),
3530 IPW2100_ORD(STAT_TX_HOST_COMPLETE,
3531 "successful Host Tx's (MSDU)"),
3532 IPW2100_ORD(STAT_TX_DIR_DATA,
3533 "successful Directed Tx's (MSDU)"),
3534 IPW2100_ORD(STAT_TX_DIR_DATA1,
3535 "successful Directed Tx's (MSDU) @ 1MB"),
3536 IPW2100_ORD(STAT_TX_DIR_DATA2,
3537 "successful Directed Tx's (MSDU) @ 2MB"),
3538 IPW2100_ORD(STAT_TX_DIR_DATA5_5,
3539 "successful Directed Tx's (MSDU) @ 5_5MB"),
3540 IPW2100_ORD(STAT_TX_DIR_DATA11,
3541 "successful Directed Tx's (MSDU) @ 11MB"),
3542 IPW2100_ORD(STAT_TX_NODIR_DATA1,
3543 "successful Non_Directed Tx's (MSDU) @ 1MB"),
3544 IPW2100_ORD(STAT_TX_NODIR_DATA2,
3545 "successful Non_Directed Tx's (MSDU) @ 2MB"),
3546 IPW2100_ORD(STAT_TX_NODIR_DATA5_5,
3547 "successful Non_Directed Tx's (MSDU) @ 5.5MB"),
3548 IPW2100_ORD(STAT_TX_NODIR_DATA11,
3549 "successful Non_Directed Tx's (MSDU) @ 11MB"),
3550 IPW2100_ORD(STAT_NULL_DATA, "successful NULL data Tx's"),
3551 IPW2100_ORD(STAT_TX_RTS, "successful Tx RTS"),
3552 IPW2100_ORD(STAT_TX_CTS, "successful Tx CTS"),
3553 IPW2100_ORD(STAT_TX_ACK, "successful Tx ACK"),
3554 IPW2100_ORD(STAT_TX_ASSN, "successful Association Tx's"),
3555 IPW2100_ORD(STAT_TX_ASSN_RESP,
3556 "successful Association response Tx's"),
3557 IPW2100_ORD(STAT_TX_REASSN,
3558 "successful Reassociation Tx's"),
3559 IPW2100_ORD(STAT_TX_REASSN_RESP,
3560 "successful Reassociation response Tx's"),
3561 IPW2100_ORD(STAT_TX_PROBE,
3562 "probes successfully transmitted"),
3563 IPW2100_ORD(STAT_TX_PROBE_RESP,
3564 "probe responses successfully transmitted"),
3565 IPW2100_ORD(STAT_TX_BEACON, "tx beacon"),
3566 IPW2100_ORD(STAT_TX_ATIM, "Tx ATIM"),
3567 IPW2100_ORD(STAT_TX_DISASSN,
3568 "successful Disassociation TX"),
3569 IPW2100_ORD(STAT_TX_AUTH, "successful Authentication Tx"),
3570 IPW2100_ORD(STAT_TX_DEAUTH,
3571 "successful Deauthentication TX"),
3572 IPW2100_ORD(STAT_TX_TOTAL_BYTES,
3573 "Total successful Tx data bytes"),
3574 IPW2100_ORD(STAT_TX_RETRIES, "Tx retries"),
3575 IPW2100_ORD(STAT_TX_RETRY1, "Tx retries at 1MBPS"),
3576 IPW2100_ORD(STAT_TX_RETRY2, "Tx retries at 2MBPS"),
3577 IPW2100_ORD(STAT_TX_RETRY5_5, "Tx retries at 5.5MBPS"),
3578 IPW2100_ORD(STAT_TX_RETRY11, "Tx retries at 11MBPS"),
3579 IPW2100_ORD(STAT_TX_FAILURES, "Tx Failures"),
3580 IPW2100_ORD(STAT_TX_MAX_TRIES_IN_HOP,
3581 "times max tries in a hop failed"),
3582 IPW2100_ORD(STAT_TX_DISASSN_FAIL,
3583 "times disassociation failed"),
3584 IPW2100_ORD(STAT_TX_ERR_CTS, "missed/bad CTS frames"),
3585 IPW2100_ORD(STAT_TX_ERR_ACK, "tx err due to acks"),
3586 IPW2100_ORD(STAT_RX_HOST, "packets passed to host"),
3587 IPW2100_ORD(STAT_RX_DIR_DATA, "directed packets"),
3588 IPW2100_ORD(STAT_RX_DIR_DATA1, "directed packets at 1MB"),
3589 IPW2100_ORD(STAT_RX_DIR_DATA2, "directed packets at 2MB"),
3590 IPW2100_ORD(STAT_RX_DIR_DATA5_5,
3591 "directed packets at 5.5MB"),
3592 IPW2100_ORD(STAT_RX_DIR_DATA11, "directed packets at 11MB"),
3593 IPW2100_ORD(STAT_RX_NODIR_DATA, "nondirected packets"),
3594 IPW2100_ORD(STAT_RX_NODIR_DATA1,
3595 "nondirected packets at 1MB"),
3596 IPW2100_ORD(STAT_RX_NODIR_DATA2,
3597 "nondirected packets at 2MB"),
3598 IPW2100_ORD(STAT_RX_NODIR_DATA5_5,
3599 "nondirected packets at 5.5MB"),
3600 IPW2100_ORD(STAT_RX_NODIR_DATA11,
3601 "nondirected packets at 11MB"),
3602 IPW2100_ORD(STAT_RX_NULL_DATA, "null data rx's"),
3603 IPW2100_ORD(STAT_RX_RTS, "Rx RTS"), IPW2100_ORD(STAT_RX_CTS,
3605 IPW2100_ORD(STAT_RX_ACK, "Rx ACK"),
3606 IPW2100_ORD(STAT_RX_CFEND, "Rx CF End"),
3607 IPW2100_ORD(STAT_RX_CFEND_ACK, "Rx CF End + CF Ack"),
3608 IPW2100_ORD(STAT_RX_ASSN, "Association Rx's"),
3609 IPW2100_ORD(STAT_RX_ASSN_RESP, "Association response Rx's"),
3610 IPW2100_ORD(STAT_RX_REASSN, "Reassociation Rx's"),
3611 IPW2100_ORD(STAT_RX_REASSN_RESP,
3612 "Reassociation response Rx's"),
3613 IPW2100_ORD(STAT_RX_PROBE, "probe Rx's"),
3614 IPW2100_ORD(STAT_RX_PROBE_RESP, "probe response Rx's"),
3615 IPW2100_ORD(STAT_RX_BEACON, "Rx beacon"),
3616 IPW2100_ORD(STAT_RX_ATIM, "Rx ATIM"),
3617 IPW2100_ORD(STAT_RX_DISASSN, "disassociation Rx"),
3618 IPW2100_ORD(STAT_RX_AUTH, "authentication Rx"),
3619 IPW2100_ORD(STAT_RX_DEAUTH, "deauthentication Rx"),
3620 IPW2100_ORD(STAT_RX_TOTAL_BYTES,
3621 "Total rx data bytes received"),
3622 IPW2100_ORD(STAT_RX_ERR_CRC, "packets with Rx CRC error"),
3623 IPW2100_ORD(STAT_RX_ERR_CRC1, "Rx CRC errors at 1MB"),
3624 IPW2100_ORD(STAT_RX_ERR_CRC2, "Rx CRC errors at 2MB"),
3625 IPW2100_ORD(STAT_RX_ERR_CRC5_5, "Rx CRC errors at 5.5MB"),
3626 IPW2100_ORD(STAT_RX_ERR_CRC11, "Rx CRC errors at 11MB"),
3627 IPW2100_ORD(STAT_RX_DUPLICATE1,
3628 "duplicate rx packets at 1MB"),
3629 IPW2100_ORD(STAT_RX_DUPLICATE2,
3630 "duplicate rx packets at 2MB"),
3631 IPW2100_ORD(STAT_RX_DUPLICATE5_5,
3632 "duplicate rx packets at 5.5MB"),
3633 IPW2100_ORD(STAT_RX_DUPLICATE11,
3634 "duplicate rx packets at 11MB"),
3635 IPW2100_ORD(STAT_RX_DUPLICATE, "duplicate rx packets"),
3636 IPW2100_ORD(PERS_DB_LOCK, "locking fw permanent db"),
3637 IPW2100_ORD(PERS_DB_SIZE, "size of fw permanent db"),
3638 IPW2100_ORD(PERS_DB_ADDR, "address of fw permanent db"),
3639 IPW2100_ORD(STAT_RX_INVALID_PROTOCOL,
3640 "rx frames with invalid protocol"),
3641 IPW2100_ORD(SYS_BOOT_TIME, "Boot time"),
3642 IPW2100_ORD(STAT_RX_NO_BUFFER,
3643 "rx frames rejected due to no buffer"),
3644 IPW2100_ORD(STAT_RX_MISSING_FRAG,
3645 "rx frames dropped due to missing fragment"),
3646 IPW2100_ORD(STAT_RX_ORPHAN_FRAG,
3647 "rx frames dropped due to non-sequential fragment"),
3648 IPW2100_ORD(STAT_RX_ORPHAN_FRAME,
3649 "rx frames dropped due to unmatched 1st frame"),
3650 IPW2100_ORD(STAT_RX_FRAG_AGEOUT,
3651 "rx frames dropped due to uncompleted frame"),
3652 IPW2100_ORD(STAT_RX_ICV_ERRORS,
3653 "ICV errors during decryption"),
3654 IPW2100_ORD(STAT_PSP_SUSPENSION, "times adapter suspended"),
3655 IPW2100_ORD(STAT_PSP_BCN_TIMEOUT, "beacon timeout"),
3656 IPW2100_ORD(STAT_PSP_POLL_TIMEOUT,
3657 "poll response timeouts"),
3658 IPW2100_ORD(STAT_PSP_NONDIR_TIMEOUT,
3659 "timeouts waiting for last {broad,multi}cast pkt"),
3660 IPW2100_ORD(STAT_PSP_RX_DTIMS, "PSP DTIMs received"),
3661 IPW2100_ORD(STAT_PSP_RX_TIMS, "PSP TIMs received"),
3662 IPW2100_ORD(STAT_PSP_STATION_ID, "PSP Station ID"),
3663 IPW2100_ORD(LAST_ASSN_TIME, "RTC time of last association"),
3664 IPW2100_ORD(STAT_PERCENT_MISSED_BCNS,
3665 "current calculation of % missed beacons"),
3666 IPW2100_ORD(STAT_PERCENT_RETRIES,
3667 "current calculation of % missed tx retries"),
3668 IPW2100_ORD(ASSOCIATED_AP_PTR,
3669 "0 if not associated, else pointer to AP table entry"),
3670 IPW2100_ORD(AVAILABLE_AP_CNT,
3671 "AP's decsribed in the AP table"),
3672 IPW2100_ORD(AP_LIST_PTR, "Ptr to list of available APs"),
3673 IPW2100_ORD(STAT_AP_ASSNS, "associations"),
3674 IPW2100_ORD(STAT_ASSN_FAIL, "association failures"),
3675 IPW2100_ORD(STAT_ASSN_RESP_FAIL,
3676 "failures due to response fail"),
3677 IPW2100_ORD(STAT_FULL_SCANS, "full scans"),
3678 IPW2100_ORD(CARD_DISABLED, "Card Disabled"),
3679 IPW2100_ORD(STAT_ROAM_INHIBIT,
3680 "times roaming was inhibited due to activity"),
3681 IPW2100_ORD(RSSI_AT_ASSN,
3682 "RSSI of associated AP at time of association"),
3683 IPW2100_ORD(STAT_ASSN_CAUSE1,
3684 "reassociation: no probe response or TX on hop"),
3685 IPW2100_ORD(STAT_ASSN_CAUSE2,
3686 "reassociation: poor tx/rx quality"),
3687 IPW2100_ORD(STAT_ASSN_CAUSE3,
3688 "reassociation: tx/rx quality (excessive AP load"),
3689 IPW2100_ORD(STAT_ASSN_CAUSE4,
3690 "reassociation: AP RSSI level"),
3691 IPW2100_ORD(STAT_ASSN_CAUSE5,
3692 "reassociations due to load leveling"),
3693 IPW2100_ORD(STAT_AUTH_FAIL, "times authentication failed"),
3694 IPW2100_ORD(STAT_AUTH_RESP_FAIL,
3695 "times authentication response failed"),
3696 IPW2100_ORD(STATION_TABLE_CNT,
3697 "entries in association table"),
3698 IPW2100_ORD(RSSI_AVG_CURR, "Current avg RSSI"),
3699 IPW2100_ORD(POWER_MGMT_MODE, "Power mode - 0=CAM, 1=PSP"),
3700 IPW2100_ORD(COUNTRY_CODE,
3701 "IEEE country code as recv'd from beacon"),
3702 IPW2100_ORD(COUNTRY_CHANNELS,
3703 "channels suported by country"),
3704 IPW2100_ORD(RESET_CNT, "adapter resets (warm)"),
3705 IPW2100_ORD(BEACON_INTERVAL, "Beacon interval"),
3706 IPW2100_ORD(ANTENNA_DIVERSITY,
3707 "TRUE if antenna diversity is disabled"),
3708 IPW2100_ORD(DTIM_PERIOD, "beacon intervals between DTIMs"),
3709 IPW2100_ORD(OUR_FREQ,
3710 "current radio freq lower digits - channel ID"),
3711 IPW2100_ORD(RTC_TIME, "current RTC time"),
3712 IPW2100_ORD(PORT_TYPE, "operating mode"),
3713 IPW2100_ORD(CURRENT_TX_RATE, "current tx rate"),
3714 IPW2100_ORD(SUPPORTED_RATES, "supported tx rates"),
3715 IPW2100_ORD(ATIM_WINDOW, "current ATIM Window"),
3716 IPW2100_ORD(BASIC_RATES, "basic tx rates"),
3717 IPW2100_ORD(NIC_HIGHEST_RATE, "NIC highest tx rate"),
3718 IPW2100_ORD(AP_HIGHEST_RATE, "AP highest tx rate"),
3719 IPW2100_ORD(CAPABILITIES,
3720 "Management frame capability field"),
3721 IPW2100_ORD(AUTH_TYPE, "Type of authentication"),
3722 IPW2100_ORD(RADIO_TYPE, "Adapter card platform type"),
3723 IPW2100_ORD(RTS_THRESHOLD,
3724 "Min packet length for RTS handshaking"),
3725 IPW2100_ORD(INT_MODE, "International mode"),
3726 IPW2100_ORD(FRAGMENTATION_THRESHOLD,
3727 "protocol frag threshold"),
3728 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_START_ADDRESS,
3729 "EEPROM offset in SRAM"),
3730 IPW2100_ORD(EEPROM_SRAM_DB_BLOCK_SIZE,
3731 "EEPROM size in SRAM"),
3732 IPW2100_ORD(EEPROM_SKU_CAPABILITY, "EEPROM SKU Capability"),
3733 IPW2100_ORD(EEPROM_IBSS_11B_CHANNELS,
3734 "EEPROM IBSS 11b channel set"),
3735 IPW2100_ORD(MAC_VERSION, "MAC Version"),
3736 IPW2100_ORD(MAC_REVISION, "MAC Revision"),
3737 IPW2100_ORD(RADIO_VERSION, "Radio Version"),
3738 IPW2100_ORD(NIC_MANF_DATE_TIME, "MANF Date/Time STAMP"),
3739 IPW2100_ORD(UCODE_VERSION, "Ucode Version"),};
3741 static ssize_t show_registers(struct device *d, struct device_attribute *attr,
3745 struct ipw2100_priv *priv = dev_get_drvdata(d);
3746 struct net_device *dev = priv->net_dev;
3750 out += sprintf(out, "%30s [Address ] : Hex\n", "Register");
3752 for (i = 0; i < ARRAY_SIZE(hw_data); i++) {
3753 read_register(dev, hw_data[i].addr, &val);
3754 out += sprintf(out, "%30s [%08X] : %08X\n",
3755 hw_data[i].name, hw_data[i].addr, val);
3761 static DEVICE_ATTR(registers, S_IRUGO, show_registers, NULL);
3763 static ssize_t show_hardware(struct device *d, struct device_attribute *attr,
3766 struct ipw2100_priv *priv = dev_get_drvdata(d);
3767 struct net_device *dev = priv->net_dev;
3771 out += sprintf(out, "%30s [Address ] : Hex\n", "NIC entry");
3773 for (i = 0; i < ARRAY_SIZE(nic_data); i++) {
3778 switch (nic_data[i].size) {
3780 read_nic_byte(dev, nic_data[i].addr, &tmp8);
3781 out += sprintf(out, "%30s [%08X] : %02X\n",
3782 nic_data[i].name, nic_data[i].addr,
3786 read_nic_word(dev, nic_data[i].addr, &tmp16);
3787 out += sprintf(out, "%30s [%08X] : %04X\n",
3788 nic_data[i].name, nic_data[i].addr,
3792 read_nic_dword(dev, nic_data[i].addr, &tmp32);
3793 out += sprintf(out, "%30s [%08X] : %08X\n",
3794 nic_data[i].name, nic_data[i].addr,
3802 static DEVICE_ATTR(hardware, S_IRUGO, show_hardware, NULL);
3804 static ssize_t show_memory(struct device *d, struct device_attribute *attr,
3807 struct ipw2100_priv *priv = dev_get_drvdata(d);
3808 struct net_device *dev = priv->net_dev;
3809 static unsigned long loop = 0;
3815 if (loop >= 0x30000)
3818 /* sysfs provides us PAGE_SIZE buffer */
3819 while (len < PAGE_SIZE - 128 && loop < 0x30000) {
3821 if (priv->snapshot[0])
3822 for (i = 0; i < 4; i++)
3824 *(u32 *) SNAPSHOT_ADDR(loop + i * 4);
3826 for (i = 0; i < 4; i++)
3827 read_nic_dword(dev, loop + i * 4, &buffer[i]);
3830 len += sprintf(buf + len,
3835 ((u8 *) buffer)[0x0],
3836 ((u8 *) buffer)[0x1],
3837 ((u8 *) buffer)[0x2],
3838 ((u8 *) buffer)[0x3],
3839 ((u8 *) buffer)[0x4],
3840 ((u8 *) buffer)[0x5],
3841 ((u8 *) buffer)[0x6],
3842 ((u8 *) buffer)[0x7],
3843 ((u8 *) buffer)[0x8],
3844 ((u8 *) buffer)[0x9],
3845 ((u8 *) buffer)[0xa],
3846 ((u8 *) buffer)[0xb],
3847 ((u8 *) buffer)[0xc],
3848 ((u8 *) buffer)[0xd],
3849 ((u8 *) buffer)[0xe],
3850 ((u8 *) buffer)[0xf]);
3852 len += sprintf(buf + len, "%s\n",
3853 snprint_line(line, sizeof(line),
3854 (u8 *) buffer, 16, loop));
3861 static ssize_t store_memory(struct device *d, struct device_attribute *attr,
3862 const char *buf, size_t count)
3864 struct ipw2100_priv *priv = dev_get_drvdata(d);
3865 struct net_device *dev = priv->net_dev;
3866 const char *p = buf;
3868 (void)dev; /* kill unused-var warning for debug-only code */
3874 (count >= 2 && tolower(p[0]) == 'o' && tolower(p[1]) == 'n')) {
3875 IPW_DEBUG_INFO("%s: Setting memory dump to RAW mode.\n",
3879 } else if (p[0] == '0' || (count >= 2 && tolower(p[0]) == 'o' &&
3880 tolower(p[1]) == 'f')) {
3881 IPW_DEBUG_INFO("%s: Setting memory dump to HEX mode.\n",
3885 } else if (tolower(p[0]) == 'r') {
3886 IPW_DEBUG_INFO("%s: Resetting firmware snapshot.\n", dev->name);
3887 ipw2100_snapshot_free(priv);
3890 IPW_DEBUG_INFO("%s: Usage: 0|on = HEX, 1|off = RAW, "
3891 "reset = clear memory snapshot\n", dev->name);
3896 static DEVICE_ATTR(memory, S_IWUSR | S_IRUGO, show_memory, store_memory);
3898 static ssize_t show_ordinals(struct device *d, struct device_attribute *attr,
3901 struct ipw2100_priv *priv = dev_get_drvdata(d);
3905 static int loop = 0;
3907 if (priv->status & STATUS_RF_KILL_MASK)
3910 if (loop >= ARRAY_SIZE(ord_data))
3913 /* sysfs provides us PAGE_SIZE buffer */
3914 while (len < PAGE_SIZE - 128 && loop < ARRAY_SIZE(ord_data)) {
3915 val_len = sizeof(u32);
3917 if (ipw2100_get_ordinal(priv, ord_data[loop].index, &val,
3919 len += sprintf(buf + len, "[0x%02X] = ERROR %s\n",
3920 ord_data[loop].index,
3921 ord_data[loop].desc);
3923 len += sprintf(buf + len, "[0x%02X] = 0x%08X %s\n",
3924 ord_data[loop].index, val,
3925 ord_data[loop].desc);
3932 static DEVICE_ATTR(ordinals, S_IRUGO, show_ordinals, NULL);
3934 static ssize_t show_stats(struct device *d, struct device_attribute *attr,
3937 struct ipw2100_priv *priv = dev_get_drvdata(d);
3940 out += sprintf(out, "interrupts: %d {tx: %d, rx: %d, other: %d}\n",
3941 priv->interrupts, priv->tx_interrupts,
3942 priv->rx_interrupts, priv->inta_other);
3943 out += sprintf(out, "firmware resets: %d\n", priv->resets);
3944 out += sprintf(out, "firmware hangs: %d\n", priv->hangs);
3945 #ifdef CONFIG_IPW2100_DEBUG
3946 out += sprintf(out, "packet mismatch image: %s\n",
3947 priv->snapshot[0] ? "YES" : "NO");
3953 static DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL);
3955 static int ipw2100_switch_mode(struct ipw2100_priv *priv, u32 mode)
3959 if (mode == priv->ieee->iw_mode)
3962 err = ipw2100_disable_adapter(priv);
3964 printk(KERN_ERR DRV_NAME ": %s: Could not disable adapter %d\n",
3965 priv->net_dev->name, err);
3971 priv->net_dev->type = ARPHRD_ETHER;
3974 priv->net_dev->type = ARPHRD_ETHER;
3976 #ifdef CONFIG_IPW2100_MONITOR
3977 case IW_MODE_MONITOR:
3978 priv->last_mode = priv->ieee->iw_mode;
3979 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
3981 #endif /* CONFIG_IPW2100_MONITOR */
3984 priv->ieee->iw_mode = mode;
3987 /* Indicate ipw2100_download_firmware download firmware
3988 * from disk instead of memory. */
3989 ipw2100_firmware.version = 0;
3992 printk(KERN_INFO "%s: Reseting on mode change.\n", priv->net_dev->name);
3993 priv->reset_backoff = 0;
3994 schedule_reset(priv);
3999 static ssize_t show_internals(struct device *d, struct device_attribute *attr,
4002 struct ipw2100_priv *priv = dev_get_drvdata(d);
4005 #define DUMP_VAR(x,y) len += sprintf(buf + len, # x ": %" y "\n", priv-> x)
4007 if (priv->status & STATUS_ASSOCIATED)
4008 len += sprintf(buf + len, "connected: %lu\n",
4009 get_seconds() - priv->connect_start);
4011 len += sprintf(buf + len, "not connected\n");
4013 DUMP_VAR(ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx], "p");
4014 DUMP_VAR(status, "08lx");
4015 DUMP_VAR(config, "08lx");
4016 DUMP_VAR(capability, "08lx");
4019 sprintf(buf + len, "last_rtc: %lu\n",
4020 (unsigned long)priv->last_rtc);
4022 DUMP_VAR(fatal_error, "d");
4023 DUMP_VAR(stop_hang_check, "d");
4024 DUMP_VAR(stop_rf_kill, "d");
4025 DUMP_VAR(messages_sent, "d");
4027 DUMP_VAR(tx_pend_stat.value, "d");
4028 DUMP_VAR(tx_pend_stat.hi, "d");
4030 DUMP_VAR(tx_free_stat.value, "d");
4031 DUMP_VAR(tx_free_stat.lo, "d");
4033 DUMP_VAR(msg_free_stat.value, "d");
4034 DUMP_VAR(msg_free_stat.lo, "d");
4036 DUMP_VAR(msg_pend_stat.value, "d");
4037 DUMP_VAR(msg_pend_stat.hi, "d");
4039 DUMP_VAR(fw_pend_stat.value, "d");
4040 DUMP_VAR(fw_pend_stat.hi, "d");
4042 DUMP_VAR(txq_stat.value, "d");
4043 DUMP_VAR(txq_stat.lo, "d");
4045 DUMP_VAR(ieee->scans, "d");
4046 DUMP_VAR(reset_backoff, "d");
4051 static DEVICE_ATTR(internals, S_IRUGO, show_internals, NULL);
4053 static ssize_t show_bssinfo(struct device *d, struct device_attribute *attr,
4056 struct ipw2100_priv *priv = dev_get_drvdata(d);
4057 char essid[IW_ESSID_MAX_SIZE + 1];
4064 if (priv->status & STATUS_RF_KILL_MASK)
4067 memset(essid, 0, sizeof(essid));
4068 memset(bssid, 0, sizeof(bssid));
4070 length = IW_ESSID_MAX_SIZE;
4071 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_SSID, essid, &length);
4073 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4076 length = sizeof(bssid);
4077 ret = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID,
4080 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4083 length = sizeof(u32);
4084 ret = ipw2100_get_ordinal(priv, IPW_ORD_OUR_FREQ, &chan, &length);
4086 IPW_DEBUG_INFO("failed querying ordinals at line %d\n",
4089 out += sprintf(out, "ESSID: %s\n", essid);
4090 out += sprintf(out, "BSSID: %pM\n", bssid);
4091 out += sprintf(out, "Channel: %d\n", chan);
4096 static DEVICE_ATTR(bssinfo, S_IRUGO, show_bssinfo, NULL);
4098 #ifdef CONFIG_IPW2100_DEBUG
4099 static ssize_t show_debug_level(struct device_driver *d, char *buf)
4101 return sprintf(buf, "0x%08X\n", ipw2100_debug_level);
4104 static ssize_t store_debug_level(struct device_driver *d,
4105 const char *buf, size_t count)
4107 char *p = (char *)buf;
4110 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
4112 if (p[0] == 'x' || p[0] == 'X')
4114 val = simple_strtoul(p, &p, 16);
4116 val = simple_strtoul(p, &p, 10);
4118 IPW_DEBUG_INFO(": %s is not in hex or decimal form.\n", buf);
4120 ipw2100_debug_level = val;
4122 return strnlen(buf, count);
4125 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO, show_debug_level,
4127 #endif /* CONFIG_IPW2100_DEBUG */
4129 static ssize_t show_fatal_error(struct device *d,
4130 struct device_attribute *attr, char *buf)
4132 struct ipw2100_priv *priv = dev_get_drvdata(d);
4136 if (priv->fatal_error)
4137 out += sprintf(out, "0x%08X\n", priv->fatal_error);
4139 out += sprintf(out, "0\n");
4141 for (i = 1; i <= IPW2100_ERROR_QUEUE; i++) {
4142 if (!priv->fatal_errors[(priv->fatal_index - i) %
4143 IPW2100_ERROR_QUEUE])
4146 out += sprintf(out, "%d. 0x%08X\n", i,
4147 priv->fatal_errors[(priv->fatal_index - i) %
4148 IPW2100_ERROR_QUEUE]);
4154 static ssize_t store_fatal_error(struct device *d,
4155 struct device_attribute *attr, const char *buf,
4158 struct ipw2100_priv *priv = dev_get_drvdata(d);
4159 schedule_reset(priv);
4163 static DEVICE_ATTR(fatal_error, S_IWUSR | S_IRUGO, show_fatal_error,
4166 static ssize_t show_scan_age(struct device *d, struct device_attribute *attr,
4169 struct ipw2100_priv *priv = dev_get_drvdata(d);
4170 return sprintf(buf, "%d\n", priv->ieee->scan_age);
4173 static ssize_t store_scan_age(struct device *d, struct device_attribute *attr,
4174 const char *buf, size_t count)
4176 struct ipw2100_priv *priv = dev_get_drvdata(d);
4177 struct net_device *dev = priv->net_dev;
4178 char buffer[] = "00000000";
4180 (sizeof(buffer) - 1) > count ? count : sizeof(buffer) - 1;
4184 (void)dev; /* kill unused-var warning for debug-only code */
4186 IPW_DEBUG_INFO("enter\n");
4188 strncpy(buffer, buf, len);
4191 if (p[1] == 'x' || p[1] == 'X' || p[0] == 'x' || p[0] == 'X') {
4193 if (p[0] == 'x' || p[0] == 'X')
4195 val = simple_strtoul(p, &p, 16);
4197 val = simple_strtoul(p, &p, 10);
4199 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
4201 priv->ieee->scan_age = val;
4202 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
4205 IPW_DEBUG_INFO("exit\n");
4209 static DEVICE_ATTR(scan_age, S_IWUSR | S_IRUGO, show_scan_age, store_scan_age);
4211 static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
4214 /* 0 - RF kill not enabled
4215 1 - SW based RF kill active (sysfs)
4216 2 - HW based RF kill active
4217 3 - Both HW and SW baed RF kill active */
4218 struct ipw2100_priv *priv = (struct ipw2100_priv *)d->driver_data;
4219 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
4220 (rf_kill_active(priv) ? 0x2 : 0x0);
4221 return sprintf(buf, "%i\n", val);
4224 static int ipw_radio_kill_sw(struct ipw2100_priv *priv, int disable_radio)
4226 if ((disable_radio ? 1 : 0) ==
4227 (priv->status & STATUS_RF_KILL_SW ? 1 : 0))
4230 IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
4231 disable_radio ? "OFF" : "ON");
4233 mutex_lock(&priv->action_mutex);
4235 if (disable_radio) {
4236 priv->status |= STATUS_RF_KILL_SW;
4239 priv->status &= ~STATUS_RF_KILL_SW;
4240 if (rf_kill_active(priv)) {
4241 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
4242 "disabled by HW switch\n");
4243 /* Make sure the RF_KILL check timer is running */
4244 priv->stop_rf_kill = 0;
4245 cancel_delayed_work(&priv->rf_kill);
4246 queue_delayed_work(priv->workqueue, &priv->rf_kill,
4247 round_jiffies_relative(HZ));
4249 schedule_reset(priv);
4252 mutex_unlock(&priv->action_mutex);
4256 static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
4257 const char *buf, size_t count)
4259 struct ipw2100_priv *priv = dev_get_drvdata(d);
4260 ipw_radio_kill_sw(priv, buf[0] == '1');
4264 static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
4266 static struct attribute *ipw2100_sysfs_entries[] = {
4267 &dev_attr_hardware.attr,
4268 &dev_attr_registers.attr,
4269 &dev_attr_ordinals.attr,
4271 &dev_attr_stats.attr,
4272 &dev_attr_internals.attr,
4273 &dev_attr_bssinfo.attr,
4274 &dev_attr_memory.attr,
4275 &dev_attr_scan_age.attr,
4276 &dev_attr_fatal_error.attr,
4277 &dev_attr_rf_kill.attr,
4279 &dev_attr_status.attr,
4280 &dev_attr_capability.attr,
4284 static struct attribute_group ipw2100_attribute_group = {
4285 .attrs = ipw2100_sysfs_entries,
4288 static int status_queue_allocate(struct ipw2100_priv *priv, int entries)
4290 struct ipw2100_status_queue *q = &priv->status_queue;
4292 IPW_DEBUG_INFO("enter\n");
4294 q->size = entries * sizeof(struct ipw2100_status);
4296 (struct ipw2100_status *)pci_alloc_consistent(priv->pci_dev,
4299 IPW_DEBUG_WARNING("Can not allocate status queue.\n");
4303 memset(q->drv, 0, q->size);
4305 IPW_DEBUG_INFO("exit\n");
4310 static void status_queue_free(struct ipw2100_priv *priv)
4312 IPW_DEBUG_INFO("enter\n");
4314 if (priv->status_queue.drv) {
4315 pci_free_consistent(priv->pci_dev, priv->status_queue.size,
4316 priv->status_queue.drv,
4317 priv->status_queue.nic);
4318 priv->status_queue.drv = NULL;
4321 IPW_DEBUG_INFO("exit\n");
4324 static int bd_queue_allocate(struct ipw2100_priv *priv,
4325 struct ipw2100_bd_queue *q, int entries)
4327 IPW_DEBUG_INFO("enter\n");
4329 memset(q, 0, sizeof(struct ipw2100_bd_queue));
4331 q->entries = entries;
4332 q->size = entries * sizeof(struct ipw2100_bd);
4333 q->drv = pci_alloc_consistent(priv->pci_dev, q->size, &q->nic);
4336 ("can't allocate shared memory for buffer descriptors\n");
4339 memset(q->drv, 0, q->size);
4341 IPW_DEBUG_INFO("exit\n");
4346 static void bd_queue_free(struct ipw2100_priv *priv, struct ipw2100_bd_queue *q)
4348 IPW_DEBUG_INFO("enter\n");
4354 pci_free_consistent(priv->pci_dev, q->size, q->drv, q->nic);
4358 IPW_DEBUG_INFO("exit\n");
4361 static void bd_queue_initialize(struct ipw2100_priv *priv,
4362 struct ipw2100_bd_queue *q, u32 base, u32 size,
4365 IPW_DEBUG_INFO("enter\n");
4367 IPW_DEBUG_INFO("initializing bd queue at virt=%p, phys=%08x\n", q->drv,
4370 write_register(priv->net_dev, base, q->nic);
4371 write_register(priv->net_dev, size, q->entries);
4372 write_register(priv->net_dev, r, q->oldest);
4373 write_register(priv->net_dev, w, q->next);
4375 IPW_DEBUG_INFO("exit\n");
4378 static void ipw2100_kill_workqueue(struct ipw2100_priv *priv)
4380 if (priv->workqueue) {
4381 priv->stop_rf_kill = 1;
4382 priv->stop_hang_check = 1;
4383 cancel_delayed_work(&priv->reset_work);
4384 cancel_delayed_work(&priv->security_work);
4385 cancel_delayed_work(&priv->wx_event_work);
4386 cancel_delayed_work(&priv->hang_check);
4387 cancel_delayed_work(&priv->rf_kill);
4388 cancel_delayed_work(&priv->scan_event_later);
4389 destroy_workqueue(priv->workqueue);
4390 priv->workqueue = NULL;
4394 static int ipw2100_tx_allocate(struct ipw2100_priv *priv)
4396 int i, j, err = -EINVAL;
4400 IPW_DEBUG_INFO("enter\n");
4402 err = bd_queue_allocate(priv, &priv->tx_queue, TX_QUEUE_LENGTH);
4404 IPW_DEBUG_ERROR("%s: failed bd_queue_allocate\n",
4405 priv->net_dev->name);
4410 (struct ipw2100_tx_packet *)kmalloc(TX_PENDED_QUEUE_LENGTH *
4414 if (!priv->tx_buffers) {
4415 printk(KERN_ERR DRV_NAME
4416 ": %s: alloc failed form tx buffers.\n",
4417 priv->net_dev->name);
4418 bd_queue_free(priv, &priv->tx_queue);
4422 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4423 v = pci_alloc_consistent(priv->pci_dev,
4424 sizeof(struct ipw2100_data_header),
4427 printk(KERN_ERR DRV_NAME
4428 ": %s: PCI alloc failed for tx " "buffers.\n",
4429 priv->net_dev->name);
4434 priv->tx_buffers[i].type = DATA;
4435 priv->tx_buffers[i].info.d_struct.data =
4436 (struct ipw2100_data_header *)v;
4437 priv->tx_buffers[i].info.d_struct.data_phys = p;
4438 priv->tx_buffers[i].info.d_struct.txb = NULL;
4441 if (i == TX_PENDED_QUEUE_LENGTH)
4444 for (j = 0; j < i; j++) {
4445 pci_free_consistent(priv->pci_dev,
4446 sizeof(struct ipw2100_data_header),
4447 priv->tx_buffers[j].info.d_struct.data,
4448 priv->tx_buffers[j].info.d_struct.
4452 kfree(priv->tx_buffers);
4453 priv->tx_buffers = NULL;
4458 static void ipw2100_tx_initialize(struct ipw2100_priv *priv)
4462 IPW_DEBUG_INFO("enter\n");
4465 * reinitialize packet info lists
4467 INIT_LIST_HEAD(&priv->fw_pend_list);
4468 INIT_STAT(&priv->fw_pend_stat);
4471 * reinitialize lists
4473 INIT_LIST_HEAD(&priv->tx_pend_list);
4474 INIT_LIST_HEAD(&priv->tx_free_list);
4475 INIT_STAT(&priv->tx_pend_stat);
4476 INIT_STAT(&priv->tx_free_stat);
4478 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4479 /* We simply drop any SKBs that have been queued for
4481 if (priv->tx_buffers[i].info.d_struct.txb) {
4482 ieee80211_txb_free(priv->tx_buffers[i].info.d_struct.
4484 priv->tx_buffers[i].info.d_struct.txb = NULL;
4487 list_add_tail(&priv->tx_buffers[i].list, &priv->tx_free_list);
4490 SET_STAT(&priv->tx_free_stat, i);
4492 priv->tx_queue.oldest = 0;
4493 priv->tx_queue.available = priv->tx_queue.entries;
4494 priv->tx_queue.next = 0;
4495 INIT_STAT(&priv->txq_stat);
4496 SET_STAT(&priv->txq_stat, priv->tx_queue.available);
4498 bd_queue_initialize(priv, &priv->tx_queue,
4499 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_BASE,
4500 IPW_MEM_HOST_SHARED_TX_QUEUE_BD_SIZE,
4501 IPW_MEM_HOST_SHARED_TX_QUEUE_READ_INDEX,
4502 IPW_MEM_HOST_SHARED_TX_QUEUE_WRITE_INDEX);
4504 IPW_DEBUG_INFO("exit\n");
4508 static void ipw2100_tx_free(struct ipw2100_priv *priv)
4512 IPW_DEBUG_INFO("enter\n");
4514 bd_queue_free(priv, &priv->tx_queue);
4516 if (!priv->tx_buffers)
4519 for (i = 0; i < TX_PENDED_QUEUE_LENGTH; i++) {
4520 if (priv->tx_buffers[i].info.d_struct.txb) {
4521 ieee80211_txb_free(priv->tx_buffers[i].info.d_struct.
4523 priv->tx_buffers[i].info.d_struct.txb = NULL;
4525 if (priv->tx_buffers[i].info.d_struct.data)
4526 pci_free_consistent(priv->pci_dev,
4527 sizeof(struct ipw2100_data_header),
4528 priv->tx_buffers[i].info.d_struct.
4530 priv->tx_buffers[i].info.d_struct.
4534 kfree(priv->tx_buffers);
4535 priv->tx_buffers = NULL;
4537 IPW_DEBUG_INFO("exit\n");
4540 static int ipw2100_rx_allocate(struct ipw2100_priv *priv)
4542 int i, j, err = -EINVAL;
4544 IPW_DEBUG_INFO("enter\n");
4546 err = bd_queue_allocate(priv, &priv->rx_queue, RX_QUEUE_LENGTH);
4548 IPW_DEBUG_INFO("failed bd_queue_allocate\n");
4552 err = status_queue_allocate(priv, RX_QUEUE_LENGTH);
4554 IPW_DEBUG_INFO("failed status_queue_allocate\n");
4555 bd_queue_free(priv, &priv->rx_queue);
4562 priv->rx_buffers = (struct ipw2100_rx_packet *)
4563 kmalloc(RX_QUEUE_LENGTH * sizeof(struct ipw2100_rx_packet),
4565 if (!priv->rx_buffers) {
4566 IPW_DEBUG_INFO("can't allocate rx packet buffer table\n");
4568 bd_queue_free(priv, &priv->rx_queue);
4570 status_queue_free(priv);
4575 for (i = 0; i < RX_QUEUE_LENGTH; i++) {
4576 struct ipw2100_rx_packet *packet = &priv->rx_buffers[i];
4578 err = ipw2100_alloc_skb(priv, packet);
4579 if (unlikely(err)) {
4584 /* The BD holds the cache aligned address */
4585 priv->rx_queue.drv[i].host_addr = packet->dma_addr;
4586 priv->rx_queue.drv[i].buf_length = IPW_RX_NIC_BUFFER_LENGTH;
4587 priv->status_queue.drv[i].status_fields = 0;
4590 if (i == RX_QUEUE_LENGTH)
4593 for (j = 0; j < i; j++) {
4594 pci_unmap_single(priv->pci_dev, priv->rx_buffers[j].dma_addr,
4595 sizeof(struct ipw2100_rx_packet),
4596 PCI_DMA_FROMDEVICE);
4597 dev_kfree_skb(priv->rx_buffers[j].skb);
4600 kfree(priv->rx_buffers);
4601 priv->rx_buffers = NULL;
4603 bd_queue_free(priv, &priv->rx_queue);
4605 status_queue_free(priv);
4610 static void ipw2100_rx_initialize(struct ipw2100_priv *priv)
4612 IPW_DEBUG_INFO("enter\n");
4614 priv->rx_queue.oldest = 0;
4615 priv->rx_queue.available = priv->rx_queue.entries - 1;
4616 priv->rx_queue.next = priv->rx_queue.entries - 1;
4618 INIT_STAT(&priv->rxq_stat);
4619 SET_STAT(&priv->rxq_stat, priv->rx_queue.available);
4621 bd_queue_initialize(priv, &priv->rx_queue,
4622 IPW_MEM_HOST_SHARED_RX_BD_BASE,
4623 IPW_MEM_HOST_SHARED_RX_BD_SIZE,
4624 IPW_MEM_HOST_SHARED_RX_READ_INDEX,
4625 IPW_MEM_HOST_SHARED_RX_WRITE_INDEX);
4627 /* set up the status queue */
4628 write_register(priv->net_dev, IPW_MEM_HOST_SHARED_RX_STATUS_BASE,
4629 priv->status_queue.nic);
4631 IPW_DEBUG_INFO("exit\n");
4634 static void ipw2100_rx_free(struct ipw2100_priv *priv)
4638 IPW_DEBUG_INFO("enter\n");
4640 bd_queue_free(priv, &priv->rx_queue);
4641 status_queue_free(priv);
4643 if (!priv->rx_buffers)
4646 for (i = 0; i < RX_QUEUE_LENGTH; i++) {
4647 if (priv->rx_buffers[i].rxp) {
4648 pci_unmap_single(priv->pci_dev,
4649 priv->rx_buffers[i].dma_addr,
4650 sizeof(struct ipw2100_rx),
4651 PCI_DMA_FROMDEVICE);
4652 dev_kfree_skb(priv->rx_buffers[i].skb);
4656 kfree(priv->rx_buffers);
4657 priv->rx_buffers = NULL;
4659 IPW_DEBUG_INFO("exit\n");
4662 static int ipw2100_read_mac_address(struct ipw2100_priv *priv)
4664 u32 length = ETH_ALEN;
4669 err = ipw2100_get_ordinal(priv, IPW_ORD_STAT_ADAPTER_MAC, addr, &length);
4671 IPW_DEBUG_INFO("MAC address read failed\n");
4675 memcpy(priv->net_dev->dev_addr, addr, ETH_ALEN);
4676 IPW_DEBUG_INFO("card MAC is %pM\n", priv->net_dev->dev_addr);
4681 /********************************************************************
4685 ********************************************************************/
4687 static int ipw2100_set_mac_address(struct ipw2100_priv *priv, int batch_mode)
4689 struct host_command cmd = {
4690 .host_command = ADAPTER_ADDRESS,
4691 .host_command_sequence = 0,
4692 .host_command_length = ETH_ALEN
4696 IPW_DEBUG_HC("SET_MAC_ADDRESS\n");
4698 IPW_DEBUG_INFO("enter\n");
4700 if (priv->config & CFG_CUSTOM_MAC) {
4701 memcpy(cmd.host_command_parameters, priv->mac_addr, ETH_ALEN);
4702 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
4704 memcpy(cmd.host_command_parameters, priv->net_dev->dev_addr,
4707 err = ipw2100_hw_send_command(priv, &cmd);
4709 IPW_DEBUG_INFO("exit\n");
4713 static int ipw2100_set_port_type(struct ipw2100_priv *priv, u32 port_type,
4716 struct host_command cmd = {
4717 .host_command = PORT_TYPE,
4718 .host_command_sequence = 0,
4719 .host_command_length = sizeof(u32)
4723 switch (port_type) {
4725 cmd.host_command_parameters[0] = IPW_BSS;
4728 cmd.host_command_parameters[0] = IPW_IBSS;
4732 IPW_DEBUG_HC("PORT_TYPE: %s\n",
4733 port_type == IPW_IBSS ? "Ad-Hoc" : "Managed");
4736 err = ipw2100_disable_adapter(priv);
4738 printk(KERN_ERR DRV_NAME
4739 ": %s: Could not disable adapter %d\n",
4740 priv->net_dev->name, err);
4745 /* send cmd to firmware */
4746 err = ipw2100_hw_send_command(priv, &cmd);
4749 ipw2100_enable_adapter(priv);
4754 static int ipw2100_set_channel(struct ipw2100_priv *priv, u32 channel,
4757 struct host_command cmd = {
4758 .host_command = CHANNEL,
4759 .host_command_sequence = 0,
4760 .host_command_length = sizeof(u32)
4764 cmd.host_command_parameters[0] = channel;
4766 IPW_DEBUG_HC("CHANNEL: %d\n", channel);
4768 /* If BSS then we don't support channel selection */
4769 if (priv->ieee->iw_mode == IW_MODE_INFRA)
4772 if ((channel != 0) &&
4773 ((channel < REG_MIN_CHANNEL) || (channel > REG_MAX_CHANNEL)))
4777 err = ipw2100_disable_adapter(priv);
4782 err = ipw2100_hw_send_command(priv, &cmd);
4784 IPW_DEBUG_INFO("Failed to set channel to %d", channel);
4789 priv->config |= CFG_STATIC_CHANNEL;
4791 priv->config &= ~CFG_STATIC_CHANNEL;
4793 priv->channel = channel;
4796 err = ipw2100_enable_adapter(priv);
4804 static int ipw2100_system_config(struct ipw2100_priv *priv, int batch_mode)
4806 struct host_command cmd = {
4807 .host_command = SYSTEM_CONFIG,
4808 .host_command_sequence = 0,
4809 .host_command_length = 12,
4811 u32 ibss_mask, len = sizeof(u32);
4814 /* Set system configuration */
4817 err = ipw2100_disable_adapter(priv);
4822 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
4823 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_AUTO_START;
4825 cmd.host_command_parameters[0] |= IPW_CFG_IBSS_MASK |
4826 IPW_CFG_BSS_MASK | IPW_CFG_802_1x_ENABLE;
4828 if (!(priv->config & CFG_LONG_PREAMBLE))
4829 cmd.host_command_parameters[0] |= IPW_CFG_PREAMBLE_AUTO;
4831 err = ipw2100_get_ordinal(priv,
4832 IPW_ORD_EEPROM_IBSS_11B_CHANNELS,
4835 ibss_mask = IPW_IBSS_11B_DEFAULT_MASK;
4837 cmd.host_command_parameters[1] = REG_CHANNEL_MASK;
4838 cmd.host_command_parameters[2] = REG_CHANNEL_MASK & ibss_mask;
4841 /*cmd.host_command_parameters[0] |= DIVERSITY_ANTENNA_A; */
4843 err = ipw2100_hw_send_command(priv, &cmd);
4847 /* If IPv6 is configured in the kernel then we don't want to filter out all
4848 * of the multicast packets as IPv6 needs some. */
4849 #if !defined(CONFIG_IPV6) && !defined(CONFIG_IPV6_MODULE)
4850 cmd.host_command = ADD_MULTICAST;
4851 cmd.host_command_sequence = 0;
4852 cmd.host_command_length = 0;
4854 ipw2100_hw_send_command(priv, &cmd);
4857 err = ipw2100_enable_adapter(priv);
4865 static int ipw2100_set_tx_rates(struct ipw2100_priv *priv, u32 rate,
4868 struct host_command cmd = {
4869 .host_command = BASIC_TX_RATES,
4870 .host_command_sequence = 0,
4871 .host_command_length = 4
4875 cmd.host_command_parameters[0] = rate & TX_RATE_MASK;
4878 err = ipw2100_disable_adapter(priv);
4883 /* Set BASIC TX Rate first */
4884 ipw2100_hw_send_command(priv, &cmd);
4887 cmd.host_command = TX_RATES;
4888 ipw2100_hw_send_command(priv, &cmd);
4890 /* Set MSDU TX Rate */
4891 cmd.host_command = MSDU_TX_RATES;
4892 ipw2100_hw_send_command(priv, &cmd);
4895 err = ipw2100_enable_adapter(priv);
4900 priv->tx_rates = rate;
4905 static int ipw2100_set_power_mode(struct ipw2100_priv *priv, int power_level)
4907 struct host_command cmd = {
4908 .host_command = POWER_MODE,
4909 .host_command_sequence = 0,
4910 .host_command_length = 4
4914 cmd.host_command_parameters[0] = power_level;
4916 err = ipw2100_hw_send_command(priv, &cmd);
4920 if (power_level == IPW_POWER_MODE_CAM)
4921 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
4923 priv->power_mode = IPW_POWER_ENABLED | power_level;
4925 #ifdef IPW2100_TX_POWER
4926 if (priv->port_type == IBSS && priv->adhoc_power != DFTL_IBSS_TX_POWER) {
4927 /* Set beacon interval */
4928 cmd.host_command = TX_POWER_INDEX;
4929 cmd.host_command_parameters[0] = (u32) priv->adhoc_power;
4931 err = ipw2100_hw_send_command(priv, &cmd);
4940 static int ipw2100_set_rts_threshold(struct ipw2100_priv *priv, u32 threshold)
4942 struct host_command cmd = {
4943 .host_command = RTS_THRESHOLD,
4944 .host_command_sequence = 0,
4945 .host_command_length = 4
4949 if (threshold & RTS_DISABLED)
4950 cmd.host_command_parameters[0] = MAX_RTS_THRESHOLD;
4952 cmd.host_command_parameters[0] = threshold & ~RTS_DISABLED;
4954 err = ipw2100_hw_send_command(priv, &cmd);
4958 priv->rts_threshold = threshold;
4964 int ipw2100_set_fragmentation_threshold(struct ipw2100_priv *priv,
4965 u32 threshold, int batch_mode)
4967 struct host_command cmd = {
4968 .host_command = FRAG_THRESHOLD,
4969 .host_command_sequence = 0,
4970 .host_command_length = 4,
4971 .host_command_parameters[0] = 0,
4976 err = ipw2100_disable_adapter(priv);
4982 threshold = DEFAULT_FRAG_THRESHOLD;
4984 threshold = max(threshold, MIN_FRAG_THRESHOLD);
4985 threshold = min(threshold, MAX_FRAG_THRESHOLD);
4988 cmd.host_command_parameters[0] = threshold;
4990 IPW_DEBUG_HC("FRAG_THRESHOLD: %u\n", threshold);
4992 err = ipw2100_hw_send_command(priv, &cmd);
4995 ipw2100_enable_adapter(priv);
4998 priv->frag_threshold = threshold;
5004 static int ipw2100_set_short_retry(struct ipw2100_priv *priv, u32 retry)
5006 struct host_command cmd = {
5007 .host_command = SHORT_RETRY_LIMIT,
5008 .host_command_sequence = 0,
5009 .host_command_length = 4
5013 cmd.host_command_parameters[0] = retry;
5015 err = ipw2100_hw_send_command(priv, &cmd);
5019 priv->short_retry_limit = retry;
5024 static int ipw2100_set_long_retry(struct ipw2100_priv *priv, u32 retry)
5026 struct host_command cmd = {
5027 .host_command = LONG_RETRY_LIMIT,
5028 .host_command_sequence = 0,
5029 .host_command_length = 4
5033 cmd.host_command_parameters[0] = retry;
5035 err = ipw2100_hw_send_command(priv, &cmd);
5039 priv->long_retry_limit = retry;
5044 static int ipw2100_set_mandatory_bssid(struct ipw2100_priv *priv, u8 * bssid,
5047 struct host_command cmd = {
5048 .host_command = MANDATORY_BSSID,
5049 .host_command_sequence = 0,
5050 .host_command_length = (bssid == NULL) ? 0 : ETH_ALEN
5054 #ifdef CONFIG_IPW2100_DEBUG
5056 IPW_DEBUG_HC("MANDATORY_BSSID: %pM\n", bssid);
5058 IPW_DEBUG_HC("MANDATORY_BSSID: <clear>\n");
5060 /* if BSSID is empty then we disable mandatory bssid mode */
5062 memcpy(cmd.host_command_parameters, bssid, ETH_ALEN);
5065 err = ipw2100_disable_adapter(priv);
5070 err = ipw2100_hw_send_command(priv, &cmd);
5073 ipw2100_enable_adapter(priv);
5078 static int ipw2100_disassociate_bssid(struct ipw2100_priv *priv)
5080 struct host_command cmd = {
5081 .host_command = DISASSOCIATION_BSSID,
5082 .host_command_sequence = 0,
5083 .host_command_length = ETH_ALEN
5088 IPW_DEBUG_HC("DISASSOCIATION_BSSID\n");
5091 /* The Firmware currently ignores the BSSID and just disassociates from
5092 * the currently associated AP -- but in the off chance that a future
5093 * firmware does use the BSSID provided here, we go ahead and try and
5094 * set it to the currently associated AP's BSSID */
5095 memcpy(cmd.host_command_parameters, priv->bssid, ETH_ALEN);
5097 err = ipw2100_hw_send_command(priv, &cmd);
5102 static int ipw2100_set_wpa_ie(struct ipw2100_priv *,
5103 struct ipw2100_wpa_assoc_frame *, int)
5104 __attribute__ ((unused));
5106 static int ipw2100_set_wpa_ie(struct ipw2100_priv *priv,
5107 struct ipw2100_wpa_assoc_frame *wpa_frame,
5110 struct host_command cmd = {
5111 .host_command = SET_WPA_IE,
5112 .host_command_sequence = 0,
5113 .host_command_length = sizeof(struct ipw2100_wpa_assoc_frame),
5117 IPW_DEBUG_HC("SET_WPA_IE\n");
5120 err = ipw2100_disable_adapter(priv);
5125 memcpy(cmd.host_command_parameters, wpa_frame,
5126 sizeof(struct ipw2100_wpa_assoc_frame));
5128 err = ipw2100_hw_send_command(priv, &cmd);
5131 if (ipw2100_enable_adapter(priv))
5138 struct security_info_params {
5139 u32 allowed_ciphers;
5142 u8 replay_counters_number;
5143 u8 unicast_using_group;
5144 } __attribute__ ((packed));
5146 static int ipw2100_set_security_information(struct ipw2100_priv *priv,
5149 int unicast_using_group,
5152 struct host_command cmd = {
5153 .host_command = SET_SECURITY_INFORMATION,
5154 .host_command_sequence = 0,
5155 .host_command_length = sizeof(struct security_info_params)
5157 struct security_info_params *security =
5158 (struct security_info_params *)&cmd.host_command_parameters;
5160 memset(security, 0, sizeof(*security));
5162 /* If shared key AP authentication is turned on, then we need to
5163 * configure the firmware to try and use it.
5165 * Actual data encryption/decryption is handled by the host. */
5166 security->auth_mode = auth_mode;
5167 security->unicast_using_group = unicast_using_group;
5169 switch (security_level) {
5172 security->allowed_ciphers = IPW_NONE_CIPHER;
5175 security->allowed_ciphers = IPW_WEP40_CIPHER |
5179 security->allowed_ciphers = IPW_WEP40_CIPHER |
5180 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER;
5182 case SEC_LEVEL_2_CKIP:
5183 security->allowed_ciphers = IPW_WEP40_CIPHER |
5184 IPW_WEP104_CIPHER | IPW_CKIP_CIPHER;
5187 security->allowed_ciphers = IPW_WEP40_CIPHER |
5188 IPW_WEP104_CIPHER | IPW_TKIP_CIPHER | IPW_CCMP_CIPHER;
5193 ("SET_SECURITY_INFORMATION: auth:%d cipher:0x%02X (level %d)\n",
5194 security->auth_mode, security->allowed_ciphers, security_level);
5196 security->replay_counters_number = 0;
5199 err = ipw2100_disable_adapter(priv);
5204 err = ipw2100_hw_send_command(priv, &cmd);
5207 ipw2100_enable_adapter(priv);
5212 static int ipw2100_set_tx_power(struct ipw2100_priv *priv, u32 tx_power)
5214 struct host_command cmd = {
5215 .host_command = TX_POWER_INDEX,
5216 .host_command_sequence = 0,
5217 .host_command_length = 4
5222 if (tx_power != IPW_TX_POWER_DEFAULT)
5223 tmp = (tx_power - IPW_TX_POWER_MIN_DBM) * 16 /
5224 (IPW_TX_POWER_MAX_DBM - IPW_TX_POWER_MIN_DBM);
5226 cmd.host_command_parameters[0] = tmp;
5228 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
5229 err = ipw2100_hw_send_command(priv, &cmd);
5231 priv->tx_power = tx_power;
5236 static int ipw2100_set_ibss_beacon_interval(struct ipw2100_priv *priv,
5237 u32 interval, int batch_mode)
5239 struct host_command cmd = {
5240 .host_command = BEACON_INTERVAL,
5241 .host_command_sequence = 0,
5242 .host_command_length = 4
5246 cmd.host_command_parameters[0] = interval;
5248 IPW_DEBUG_INFO("enter\n");
5250 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5252 err = ipw2100_disable_adapter(priv);
5257 ipw2100_hw_send_command(priv, &cmd);
5260 err = ipw2100_enable_adapter(priv);
5266 IPW_DEBUG_INFO("exit\n");
5271 static void ipw2100_queues_initialize(struct ipw2100_priv *priv)
5273 ipw2100_tx_initialize(priv);
5274 ipw2100_rx_initialize(priv);
5275 ipw2100_msg_initialize(priv);
5278 static void ipw2100_queues_free(struct ipw2100_priv *priv)
5280 ipw2100_tx_free(priv);
5281 ipw2100_rx_free(priv);
5282 ipw2100_msg_free(priv);
5285 static int ipw2100_queues_allocate(struct ipw2100_priv *priv)
5287 if (ipw2100_tx_allocate(priv) ||
5288 ipw2100_rx_allocate(priv) || ipw2100_msg_allocate(priv))
5294 ipw2100_tx_free(priv);
5295 ipw2100_rx_free(priv);
5296 ipw2100_msg_free(priv);
5300 #define IPW_PRIVACY_CAPABLE 0x0008
5302 static int ipw2100_set_wep_flags(struct ipw2100_priv *priv, u32 flags,
5305 struct host_command cmd = {
5306 .host_command = WEP_FLAGS,
5307 .host_command_sequence = 0,
5308 .host_command_length = 4
5312 cmd.host_command_parameters[0] = flags;
5314 IPW_DEBUG_HC("WEP_FLAGS: flags = 0x%08X\n", flags);
5317 err = ipw2100_disable_adapter(priv);
5319 printk(KERN_ERR DRV_NAME
5320 ": %s: Could not disable adapter %d\n",
5321 priv->net_dev->name, err);
5326 /* send cmd to firmware */
5327 err = ipw2100_hw_send_command(priv, &cmd);
5330 ipw2100_enable_adapter(priv);
5335 struct ipw2100_wep_key {
5341 /* Macros to ease up priting WEP keys */
5342 #define WEP_FMT_64 "%02X%02X%02X%02X-%02X"
5343 #define WEP_FMT_128 "%02X%02X%02X%02X-%02X%02X%02X%02X-%02X%02X%02X"
5344 #define WEP_STR_64(x) x[0],x[1],x[2],x[3],x[4]
5345 #define WEP_STR_128(x) x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],x[8],x[9],x[10]
5350 * @priv: struct to work on
5351 * @idx: index of the key we want to set
5352 * @key: ptr to the key data to set
5353 * @len: length of the buffer at @key
5354 * @batch_mode: FIXME perform the operation in batch mode, not
5355 * disabling the device.
5357 * @returns 0 if OK, < 0 errno code on error.
5359 * Fill out a command structure with the new wep key, length an
5360 * index and send it down the wire.
5362 static int ipw2100_set_key(struct ipw2100_priv *priv,
5363 int idx, char *key, int len, int batch_mode)
5365 int keylen = len ? (len <= 5 ? 5 : 13) : 0;
5366 struct host_command cmd = {
5367 .host_command = WEP_KEY_INFO,
5368 .host_command_sequence = 0,
5369 .host_command_length = sizeof(struct ipw2100_wep_key),
5371 struct ipw2100_wep_key *wep_key = (void *)cmd.host_command_parameters;
5374 IPW_DEBUG_HC("WEP_KEY_INFO: index = %d, len = %d/%d\n",
5377 /* NOTE: We don't check cached values in case the firmware was reset
5378 * or some other problem is occurring. If the user is setting the key,
5379 * then we push the change */
5382 wep_key->len = keylen;
5385 memcpy(wep_key->key, key, len);
5386 memset(wep_key->key + len, 0, keylen - len);
5389 /* Will be optimized out on debug not being configured in */
5391 IPW_DEBUG_WEP("%s: Clearing key %d\n",
5392 priv->net_dev->name, wep_key->idx);
5393 else if (keylen == 5)
5394 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_64 "\n",
5395 priv->net_dev->name, wep_key->idx, wep_key->len,
5396 WEP_STR_64(wep_key->key));
5398 IPW_DEBUG_WEP("%s: idx: %d, len: %d key: " WEP_FMT_128
5400 priv->net_dev->name, wep_key->idx, wep_key->len,
5401 WEP_STR_128(wep_key->key));
5404 err = ipw2100_disable_adapter(priv);
5405 /* FIXME: IPG: shouldn't this prink be in _disable_adapter()? */
5407 printk(KERN_ERR DRV_NAME
5408 ": %s: Could not disable adapter %d\n",
5409 priv->net_dev->name, err);
5414 /* send cmd to firmware */
5415 err = ipw2100_hw_send_command(priv, &cmd);
5418 int err2 = ipw2100_enable_adapter(priv);
5425 static int ipw2100_set_key_index(struct ipw2100_priv *priv,
5426 int idx, int batch_mode)
5428 struct host_command cmd = {
5429 .host_command = WEP_KEY_INDEX,
5430 .host_command_sequence = 0,
5431 .host_command_length = 4,
5432 .host_command_parameters = {idx},
5436 IPW_DEBUG_HC("WEP_KEY_INDEX: index = %d\n", idx);
5438 if (idx < 0 || idx > 3)
5442 err = ipw2100_disable_adapter(priv);
5444 printk(KERN_ERR DRV_NAME
5445 ": %s: Could not disable adapter %d\n",
5446 priv->net_dev->name, err);
5451 /* send cmd to firmware */
5452 err = ipw2100_hw_send_command(priv, &cmd);
5455 ipw2100_enable_adapter(priv);
5460 static int ipw2100_configure_security(struct ipw2100_priv *priv, int batch_mode)
5462 int i, err, auth_mode, sec_level, use_group;
5464 if (!(priv->status & STATUS_RUNNING))
5468 err = ipw2100_disable_adapter(priv);
5473 if (!priv->ieee->sec.enabled) {
5475 ipw2100_set_security_information(priv, IPW_AUTH_OPEN,
5478 auth_mode = IPW_AUTH_OPEN;
5479 if (priv->ieee->sec.flags & SEC_AUTH_MODE) {
5480 if (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)
5481 auth_mode = IPW_AUTH_SHARED;
5482 else if (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP)
5483 auth_mode = IPW_AUTH_LEAP_CISCO_ID;
5486 sec_level = SEC_LEVEL_0;
5487 if (priv->ieee->sec.flags & SEC_LEVEL)
5488 sec_level = priv->ieee->sec.level;
5491 if (priv->ieee->sec.flags & SEC_UNICAST_GROUP)
5492 use_group = priv->ieee->sec.unicast_uses_group;
5495 ipw2100_set_security_information(priv, auth_mode, sec_level,
5502 if (priv->ieee->sec.enabled) {
5503 for (i = 0; i < 4; i++) {
5504 if (!(priv->ieee->sec.flags & (1 << i))) {
5505 memset(priv->ieee->sec.keys[i], 0, WEP_KEY_LEN);
5506 priv->ieee->sec.key_sizes[i] = 0;
5508 err = ipw2100_set_key(priv, i,
5509 priv->ieee->sec.keys[i],
5517 ipw2100_set_key_index(priv, priv->ieee->crypt_info.tx_keyidx, 1);
5520 /* Always enable privacy so the Host can filter WEP packets if
5521 * encrypted data is sent up */
5523 ipw2100_set_wep_flags(priv,
5525 enabled ? IPW_PRIVACY_CAPABLE : 0, 1);
5529 priv->status &= ~STATUS_SECURITY_UPDATED;
5533 ipw2100_enable_adapter(priv);
5538 static void ipw2100_security_work(struct work_struct *work)
5540 struct ipw2100_priv *priv =
5541 container_of(work, struct ipw2100_priv, security_work.work);
5543 /* If we happen to have reconnected before we get a chance to
5544 * process this, then update the security settings--which causes
5545 * a disassociation to occur */
5546 if (!(priv->status & STATUS_ASSOCIATED) &&
5547 priv->status & STATUS_SECURITY_UPDATED)
5548 ipw2100_configure_security(priv, 0);
5551 static void shim__set_security(struct net_device *dev,
5552 struct ieee80211_security *sec)
5554 struct ipw2100_priv *priv = ieee80211_priv(dev);
5555 int i, force_update = 0;
5557 mutex_lock(&priv->action_mutex);
5558 if (!(priv->status & STATUS_INITIALIZED))
5561 for (i = 0; i < 4; i++) {
5562 if (sec->flags & (1 << i)) {
5563 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
5564 if (sec->key_sizes[i] == 0)
5565 priv->ieee->sec.flags &= ~(1 << i);
5567 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
5569 if (sec->level == SEC_LEVEL_1) {
5570 priv->ieee->sec.flags |= (1 << i);
5571 priv->status |= STATUS_SECURITY_UPDATED;
5573 priv->ieee->sec.flags &= ~(1 << i);
5577 if ((sec->flags & SEC_ACTIVE_KEY) &&
5578 priv->ieee->sec.active_key != sec->active_key) {
5579 if (sec->active_key <= 3) {
5580 priv->ieee->sec.active_key = sec->active_key;
5581 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
5583 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
5585 priv->status |= STATUS_SECURITY_UPDATED;
5588 if ((sec->flags & SEC_AUTH_MODE) &&
5589 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
5590 priv->ieee->sec.auth_mode = sec->auth_mode;
5591 priv->ieee->sec.flags |= SEC_AUTH_MODE;
5592 priv->status |= STATUS_SECURITY_UPDATED;
5595 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
5596 priv->ieee->sec.flags |= SEC_ENABLED;
5597 priv->ieee->sec.enabled = sec->enabled;
5598 priv->status |= STATUS_SECURITY_UPDATED;
5602 if (sec->flags & SEC_ENCRYPT)
5603 priv->ieee->sec.encrypt = sec->encrypt;
5605 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
5606 priv->ieee->sec.level = sec->level;
5607 priv->ieee->sec.flags |= SEC_LEVEL;
5608 priv->status |= STATUS_SECURITY_UPDATED;
5611 IPW_DEBUG_WEP("Security flags: %c %c%c%c%c %c%c%c%c\n",
5612 priv->ieee->sec.flags & (1 << 8) ? '1' : '0',
5613 priv->ieee->sec.flags & (1 << 7) ? '1' : '0',
5614 priv->ieee->sec.flags & (1 << 6) ? '1' : '0',
5615 priv->ieee->sec.flags & (1 << 5) ? '1' : '0',
5616 priv->ieee->sec.flags & (1 << 4) ? '1' : '0',
5617 priv->ieee->sec.flags & (1 << 3) ? '1' : '0',
5618 priv->ieee->sec.flags & (1 << 2) ? '1' : '0',
5619 priv->ieee->sec.flags & (1 << 1) ? '1' : '0',
5620 priv->ieee->sec.flags & (1 << 0) ? '1' : '0');
5622 /* As a temporary work around to enable WPA until we figure out why
5623 * wpa_supplicant toggles the security capability of the driver, which
5624 * forces a disassocation with force_update...
5626 * if (force_update || !(priv->status & STATUS_ASSOCIATED))*/
5627 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
5628 ipw2100_configure_security(priv, 0);
5630 mutex_unlock(&priv->action_mutex);
5633 static int ipw2100_adapter_setup(struct ipw2100_priv *priv)
5639 IPW_DEBUG_INFO("enter\n");
5641 err = ipw2100_disable_adapter(priv);
5644 #ifdef CONFIG_IPW2100_MONITOR
5645 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
5646 err = ipw2100_set_channel(priv, priv->channel, batch_mode);
5650 IPW_DEBUG_INFO("exit\n");
5654 #endif /* CONFIG_IPW2100_MONITOR */
5656 err = ipw2100_read_mac_address(priv);
5660 err = ipw2100_set_mac_address(priv, batch_mode);
5664 err = ipw2100_set_port_type(priv, priv->ieee->iw_mode, batch_mode);
5668 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5669 err = ipw2100_set_channel(priv, priv->channel, batch_mode);
5674 err = ipw2100_system_config(priv, batch_mode);
5678 err = ipw2100_set_tx_rates(priv, priv->tx_rates, batch_mode);
5682 /* Default to power mode OFF */
5683 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM);
5687 err = ipw2100_set_rts_threshold(priv, priv->rts_threshold);
5691 if (priv->config & CFG_STATIC_BSSID)
5692 bssid = priv->bssid;
5695 err = ipw2100_set_mandatory_bssid(priv, bssid, batch_mode);
5699 if (priv->config & CFG_STATIC_ESSID)
5700 err = ipw2100_set_essid(priv, priv->essid, priv->essid_len,
5703 err = ipw2100_set_essid(priv, NULL, 0, batch_mode);
5707 err = ipw2100_configure_security(priv, batch_mode);
5711 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5713 ipw2100_set_ibss_beacon_interval(priv,
5714 priv->beacon_interval,
5719 err = ipw2100_set_tx_power(priv, priv->tx_power);
5725 err = ipw2100_set_fragmentation_threshold(
5726 priv, priv->frag_threshold, batch_mode);
5731 IPW_DEBUG_INFO("exit\n");
5736 /*************************************************************************
5738 * EXTERNALLY CALLED METHODS
5740 *************************************************************************/
5742 /* This method is called by the network layer -- not to be confused with
5743 * ipw2100_set_mac_address() declared above called by this driver (and this
5744 * method as well) to talk to the firmware */
5745 static int ipw2100_set_address(struct net_device *dev, void *p)
5747 struct ipw2100_priv *priv = ieee80211_priv(dev);
5748 struct sockaddr *addr = p;
5751 if (!is_valid_ether_addr(addr->sa_data))
5752 return -EADDRNOTAVAIL;
5754 mutex_lock(&priv->action_mutex);
5756 priv->config |= CFG_CUSTOM_MAC;
5757 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
5759 err = ipw2100_set_mac_address(priv, 0);
5763 priv->reset_backoff = 0;
5764 mutex_unlock(&priv->action_mutex);
5765 ipw2100_reset_adapter(&priv->reset_work.work);
5769 mutex_unlock(&priv->action_mutex);
5773 static int ipw2100_open(struct net_device *dev)
5775 struct ipw2100_priv *priv = ieee80211_priv(dev);
5776 unsigned long flags;
5777 IPW_DEBUG_INFO("dev->open\n");
5779 spin_lock_irqsave(&priv->low_lock, flags);
5780 if (priv->status & STATUS_ASSOCIATED) {
5781 netif_carrier_on(dev);
5782 netif_start_queue(dev);
5784 spin_unlock_irqrestore(&priv->low_lock, flags);
5789 static int ipw2100_close(struct net_device *dev)
5791 struct ipw2100_priv *priv = ieee80211_priv(dev);
5792 unsigned long flags;
5793 struct list_head *element;
5794 struct ipw2100_tx_packet *packet;
5796 IPW_DEBUG_INFO("enter\n");
5798 spin_lock_irqsave(&priv->low_lock, flags);
5800 if (priv->status & STATUS_ASSOCIATED)
5801 netif_carrier_off(dev);
5802 netif_stop_queue(dev);
5804 /* Flush the TX queue ... */
5805 while (!list_empty(&priv->tx_pend_list)) {
5806 element = priv->tx_pend_list.next;
5807 packet = list_entry(element, struct ipw2100_tx_packet, list);
5810 DEC_STAT(&priv->tx_pend_stat);
5812 ieee80211_txb_free(packet->info.d_struct.txb);
5813 packet->info.d_struct.txb = NULL;
5815 list_add_tail(element, &priv->tx_free_list);
5816 INC_STAT(&priv->tx_free_stat);
5818 spin_unlock_irqrestore(&priv->low_lock, flags);
5820 IPW_DEBUG_INFO("exit\n");
5826 * TODO: Fix this function... its just wrong
5828 static void ipw2100_tx_timeout(struct net_device *dev)
5830 struct ipw2100_priv *priv = ieee80211_priv(dev);
5832 priv->ieee->stats.tx_errors++;
5834 #ifdef CONFIG_IPW2100_MONITOR
5835 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
5839 IPW_DEBUG_INFO("%s: TX timed out. Scheduling firmware restart.\n",
5841 schedule_reset(priv);
5844 static int ipw2100_wpa_enable(struct ipw2100_priv *priv, int value)
5846 /* This is called when wpa_supplicant loads and closes the driver
5848 priv->ieee->wpa_enabled = value;
5852 static int ipw2100_wpa_set_auth_algs(struct ipw2100_priv *priv, int value)
5855 struct ieee80211_device *ieee = priv->ieee;
5856 struct ieee80211_security sec = {
5857 .flags = SEC_AUTH_MODE,
5861 if (value & IW_AUTH_ALG_SHARED_KEY) {
5862 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
5864 } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
5865 sec.auth_mode = WLAN_AUTH_OPEN;
5867 } else if (value & IW_AUTH_ALG_LEAP) {
5868 sec.auth_mode = WLAN_AUTH_LEAP;
5873 if (ieee->set_security)
5874 ieee->set_security(ieee->dev, &sec);
5881 static void ipw2100_wpa_assoc_frame(struct ipw2100_priv *priv,
5882 char *wpa_ie, int wpa_ie_len)
5885 struct ipw2100_wpa_assoc_frame frame;
5887 frame.fixed_ie_mask = 0;
5890 memcpy(frame.var_ie, wpa_ie, wpa_ie_len);
5891 frame.var_ie_len = wpa_ie_len;
5893 /* make sure WPA is enabled */
5894 ipw2100_wpa_enable(priv, 1);
5895 ipw2100_set_wpa_ie(priv, &frame, 0);
5898 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
5899 struct ethtool_drvinfo *info)
5901 struct ipw2100_priv *priv = ieee80211_priv(dev);
5902 char fw_ver[64], ucode_ver[64];
5904 strcpy(info->driver, DRV_NAME);
5905 strcpy(info->version, DRV_VERSION);
5907 ipw2100_get_fwversion(priv, fw_ver, sizeof(fw_ver));
5908 ipw2100_get_ucodeversion(priv, ucode_ver, sizeof(ucode_ver));
5910 snprintf(info->fw_version, sizeof(info->fw_version), "%s:%d:%s",
5911 fw_ver, priv->eeprom_version, ucode_ver);
5913 strcpy(info->bus_info, pci_name(priv->pci_dev));
5916 static u32 ipw2100_ethtool_get_link(struct net_device *dev)
5918 struct ipw2100_priv *priv = ieee80211_priv(dev);
5919 return (priv->status & STATUS_ASSOCIATED) ? 1 : 0;
5922 static const struct ethtool_ops ipw2100_ethtool_ops = {
5923 .get_link = ipw2100_ethtool_get_link,
5924 .get_drvinfo = ipw_ethtool_get_drvinfo,
5927 static void ipw2100_hang_check(struct work_struct *work)
5929 struct ipw2100_priv *priv =
5930 container_of(work, struct ipw2100_priv, hang_check.work);
5931 unsigned long flags;
5932 u32 rtc = 0xa5a5a5a5;
5933 u32 len = sizeof(rtc);
5936 spin_lock_irqsave(&priv->low_lock, flags);
5938 if (priv->fatal_error != 0) {
5939 /* If fatal_error is set then we need to restart */
5940 IPW_DEBUG_INFO("%s: Hardware fatal error detected.\n",
5941 priv->net_dev->name);
5944 } else if (ipw2100_get_ordinal(priv, IPW_ORD_RTC_TIME, &rtc, &len) ||
5945 (rtc == priv->last_rtc)) {
5946 /* Check if firmware is hung */
5947 IPW_DEBUG_INFO("%s: Firmware RTC stalled.\n",
5948 priv->net_dev->name);
5955 priv->stop_hang_check = 1;
5958 /* Restart the NIC */
5959 schedule_reset(priv);
5962 priv->last_rtc = rtc;
5964 if (!priv->stop_hang_check)
5965 queue_delayed_work(priv->workqueue, &priv->hang_check, HZ / 2);
5967 spin_unlock_irqrestore(&priv->low_lock, flags);
5970 static void ipw2100_rf_kill(struct work_struct *work)
5972 struct ipw2100_priv *priv =
5973 container_of(work, struct ipw2100_priv, rf_kill.work);
5974 unsigned long flags;
5976 spin_lock_irqsave(&priv->low_lock, flags);
5978 if (rf_kill_active(priv)) {
5979 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
5980 if (!priv->stop_rf_kill)
5981 queue_delayed_work(priv->workqueue, &priv->rf_kill,
5982 round_jiffies_relative(HZ));
5986 /* RF Kill is now disabled, so bring the device back up */
5988 if (!(priv->status & STATUS_RF_KILL_MASK)) {
5989 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
5991 schedule_reset(priv);
5993 IPW_DEBUG_RF_KILL("HW RF Kill deactivated. SW RF Kill still "
5997 spin_unlock_irqrestore(&priv->low_lock, flags);
6000 static void ipw2100_irq_tasklet(struct ipw2100_priv *priv);
6002 /* Look into using netdev destructor to shutdown ieee80211? */
6004 static struct net_device *ipw2100_alloc_device(struct pci_dev *pci_dev,
6005 void __iomem * base_addr,
6006 unsigned long mem_start,
6007 unsigned long mem_len)
6009 struct ipw2100_priv *priv;
6010 struct net_device *dev;
6012 dev = alloc_ieee80211(sizeof(struct ipw2100_priv));
6015 priv = ieee80211_priv(dev);
6016 priv->ieee = netdev_priv(dev);
6017 priv->pci_dev = pci_dev;
6018 priv->net_dev = dev;
6020 priv->ieee->hard_start_xmit = ipw2100_tx;
6021 priv->ieee->set_security = shim__set_security;
6023 priv->ieee->perfect_rssi = -20;
6024 priv->ieee->worst_rssi = -85;
6026 dev->open = ipw2100_open;
6027 dev->stop = ipw2100_close;
6028 dev->init = ipw2100_net_init;
6029 dev->ethtool_ops = &ipw2100_ethtool_ops;
6030 dev->tx_timeout = ipw2100_tx_timeout;
6031 dev->wireless_handlers = &ipw2100_wx_handler_def;
6032 priv->wireless_data.ieee80211 = priv->ieee;
6033 dev->wireless_data = &priv->wireless_data;
6034 dev->set_mac_address = ipw2100_set_address;
6035 dev->watchdog_timeo = 3 * HZ;
6038 dev->base_addr = (unsigned long)base_addr;
6039 dev->mem_start = mem_start;
6040 dev->mem_end = dev->mem_start + mem_len - 1;
6042 /* NOTE: We don't use the wireless_handlers hook
6043 * in dev as the system will start throwing WX requests
6044 * to us before we're actually initialized and it just
6045 * ends up causing problems. So, we just handle
6046 * the WX extensions through the ipw2100_ioctl interface */
6048 /* memset() puts everything to 0, so we only have explicitly set
6049 * those values that need to be something else */
6051 /* If power management is turned on, default to AUTO mode */
6052 priv->power_mode = IPW_POWER_AUTO;
6054 #ifdef CONFIG_IPW2100_MONITOR
6055 priv->config |= CFG_CRC_CHECK;
6057 priv->ieee->wpa_enabled = 0;
6058 priv->ieee->drop_unencrypted = 0;
6059 priv->ieee->privacy_invoked = 0;
6060 priv->ieee->ieee802_1x = 1;
6062 /* Set module parameters */
6065 priv->ieee->iw_mode = IW_MODE_ADHOC;
6067 #ifdef CONFIG_IPW2100_MONITOR
6069 priv->ieee->iw_mode = IW_MODE_MONITOR;
6074 priv->ieee->iw_mode = IW_MODE_INFRA;
6079 priv->status |= STATUS_RF_KILL_SW;
6082 ((channel >= REG_MIN_CHANNEL) && (channel <= REG_MAX_CHANNEL))) {
6083 priv->config |= CFG_STATIC_CHANNEL;
6084 priv->channel = channel;
6088 priv->config |= CFG_ASSOCIATE;
6090 priv->beacon_interval = DEFAULT_BEACON_INTERVAL;
6091 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
6092 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
6093 priv->rts_threshold = DEFAULT_RTS_THRESHOLD | RTS_DISABLED;
6094 priv->frag_threshold = DEFAULT_FTS | FRAG_DISABLED;
6095 priv->tx_power = IPW_TX_POWER_DEFAULT;
6096 priv->tx_rates = DEFAULT_TX_RATES;
6098 strcpy(priv->nick, "ipw2100");
6100 spin_lock_init(&priv->low_lock);
6101 mutex_init(&priv->action_mutex);
6102 mutex_init(&priv->adapter_mutex);
6104 init_waitqueue_head(&priv->wait_command_queue);
6106 netif_carrier_off(dev);
6108 INIT_LIST_HEAD(&priv->msg_free_list);
6109 INIT_LIST_HEAD(&priv->msg_pend_list);
6110 INIT_STAT(&priv->msg_free_stat);
6111 INIT_STAT(&priv->msg_pend_stat);
6113 INIT_LIST_HEAD(&priv->tx_free_list);
6114 INIT_LIST_HEAD(&priv->tx_pend_list);
6115 INIT_STAT(&priv->tx_free_stat);
6116 INIT_STAT(&priv->tx_pend_stat);
6118 INIT_LIST_HEAD(&priv->fw_pend_list);
6119 INIT_STAT(&priv->fw_pend_stat);
6121 priv->workqueue = create_workqueue(DRV_NAME);
6123 INIT_DELAYED_WORK(&priv->reset_work, ipw2100_reset_adapter);
6124 INIT_DELAYED_WORK(&priv->security_work, ipw2100_security_work);
6125 INIT_DELAYED_WORK(&priv->wx_event_work, ipw2100_wx_event_work);
6126 INIT_DELAYED_WORK(&priv->hang_check, ipw2100_hang_check);
6127 INIT_DELAYED_WORK(&priv->rf_kill, ipw2100_rf_kill);
6128 INIT_WORK(&priv->scan_event_now, ipw2100_scan_event_now);
6129 INIT_DELAYED_WORK(&priv->scan_event_later, ipw2100_scan_event_later);
6131 tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
6132 ipw2100_irq_tasklet, (unsigned long)priv);
6134 /* NOTE: We do not start the deferred work for status checks yet */
6135 priv->stop_rf_kill = 1;
6136 priv->stop_hang_check = 1;
6141 static int ipw2100_pci_init_one(struct pci_dev *pci_dev,
6142 const struct pci_device_id *ent)
6144 unsigned long mem_start, mem_len, mem_flags;
6145 void __iomem *base_addr = NULL;
6146 struct net_device *dev = NULL;
6147 struct ipw2100_priv *priv = NULL;
6152 IPW_DEBUG_INFO("enter\n");
6154 mem_start = pci_resource_start(pci_dev, 0);
6155 mem_len = pci_resource_len(pci_dev, 0);
6156 mem_flags = pci_resource_flags(pci_dev, 0);
6158 if ((mem_flags & IORESOURCE_MEM) != IORESOURCE_MEM) {
6159 IPW_DEBUG_INFO("weird - resource type is not memory\n");
6164 base_addr = ioremap_nocache(mem_start, mem_len);
6166 printk(KERN_WARNING DRV_NAME
6167 "Error calling ioremap_nocache.\n");
6172 /* allocate and initialize our net_device */
6173 dev = ipw2100_alloc_device(pci_dev, base_addr, mem_start, mem_len);
6175 printk(KERN_WARNING DRV_NAME
6176 "Error calling ipw2100_alloc_device.\n");
6181 /* set up PCI mappings for device */
6182 err = pci_enable_device(pci_dev);
6184 printk(KERN_WARNING DRV_NAME
6185 "Error calling pci_enable_device.\n");
6189 priv = ieee80211_priv(dev);
6191 pci_set_master(pci_dev);
6192 pci_set_drvdata(pci_dev, priv);
6194 err = pci_set_dma_mask(pci_dev, DMA_32BIT_MASK);
6196 printk(KERN_WARNING DRV_NAME
6197 "Error calling pci_set_dma_mask.\n");
6198 pci_disable_device(pci_dev);
6202 err = pci_request_regions(pci_dev, DRV_NAME);
6204 printk(KERN_WARNING DRV_NAME
6205 "Error calling pci_request_regions.\n");
6206 pci_disable_device(pci_dev);
6210 /* We disable the RETRY_TIMEOUT register (0x41) to keep
6211 * PCI Tx retries from interfering with C3 CPU state */
6212 pci_read_config_dword(pci_dev, 0x40, &val);
6213 if ((val & 0x0000ff00) != 0)
6214 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff);
6216 pci_set_power_state(pci_dev, PCI_D0);
6218 if (!ipw2100_hw_is_adapter_in_system(dev)) {
6219 printk(KERN_WARNING DRV_NAME
6220 "Device not found via register read.\n");
6225 SET_NETDEV_DEV(dev, &pci_dev->dev);
6227 /* Force interrupts to be shut off on the device */
6228 priv->status |= STATUS_INT_ENABLED;
6229 ipw2100_disable_interrupts(priv);
6231 /* Allocate and initialize the Tx/Rx queues and lists */
6232 if (ipw2100_queues_allocate(priv)) {
6233 printk(KERN_WARNING DRV_NAME
6234 "Error calling ipw2100_queues_allocate.\n");
6238 ipw2100_queues_initialize(priv);
6240 err = request_irq(pci_dev->irq,
6241 ipw2100_interrupt, IRQF_SHARED, dev->name, priv);
6243 printk(KERN_WARNING DRV_NAME
6244 "Error calling request_irq: %d.\n", pci_dev->irq);
6247 dev->irq = pci_dev->irq;
6249 IPW_DEBUG_INFO("Attempting to register device...\n");
6251 printk(KERN_INFO DRV_NAME
6252 ": Detected Intel PRO/Wireless 2100 Network Connection\n");
6254 /* Bring up the interface. Pre 0.46, after we registered the
6255 * network device we would call ipw2100_up. This introduced a race
6256 * condition with newer hotplug configurations (network was coming
6257 * up and making calls before the device was initialized).
6259 * If we called ipw2100_up before we registered the device, then the
6260 * device name wasn't registered. So, we instead use the net_dev->init
6261 * member to call a function that then just turns and calls ipw2100_up.
6262 * net_dev->init is called after name allocation but before the
6263 * notifier chain is called */
6264 err = register_netdev(dev);
6266 printk(KERN_WARNING DRV_NAME
6267 "Error calling register_netdev.\n");
6271 mutex_lock(&priv->action_mutex);
6274 IPW_DEBUG_INFO("%s: Bound to %s\n", dev->name, pci_name(pci_dev));
6276 /* perform this after register_netdev so that dev->name is set */
6277 err = sysfs_create_group(&pci_dev->dev.kobj, &ipw2100_attribute_group);
6281 /* If the RF Kill switch is disabled, go ahead and complete the
6282 * startup sequence */
6283 if (!(priv->status & STATUS_RF_KILL_MASK)) {
6284 /* Enable the adapter - sends HOST_COMPLETE */
6285 if (ipw2100_enable_adapter(priv)) {
6286 printk(KERN_WARNING DRV_NAME
6287 ": %s: failed in call to enable adapter.\n",
6288 priv->net_dev->name);
6289 ipw2100_hw_stop_adapter(priv);
6294 /* Start a scan . . . */
6295 ipw2100_set_scan_options(priv);
6296 ipw2100_start_scan(priv);
6299 IPW_DEBUG_INFO("exit\n");
6301 priv->status |= STATUS_INITIALIZED;
6303 mutex_unlock(&priv->action_mutex);
6308 mutex_unlock(&priv->action_mutex);
6313 unregister_netdev(dev);
6315 ipw2100_hw_stop_adapter(priv);
6317 ipw2100_disable_interrupts(priv);
6320 free_irq(dev->irq, priv);
6322 ipw2100_kill_workqueue(priv);
6324 /* These are safe to call even if they weren't allocated */
6325 ipw2100_queues_free(priv);
6326 sysfs_remove_group(&pci_dev->dev.kobj,
6327 &ipw2100_attribute_group);
6329 free_ieee80211(dev);
6330 pci_set_drvdata(pci_dev, NULL);
6336 pci_release_regions(pci_dev);
6337 pci_disable_device(pci_dev);
6342 static void __devexit ipw2100_pci_remove_one(struct pci_dev *pci_dev)
6344 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6345 struct net_device *dev;
6348 mutex_lock(&priv->action_mutex);
6350 priv->status &= ~STATUS_INITIALIZED;
6352 dev = priv->net_dev;
6353 sysfs_remove_group(&pci_dev->dev.kobj,
6354 &ipw2100_attribute_group);
6357 if (ipw2100_firmware.version)
6358 ipw2100_release_firmware(priv, &ipw2100_firmware);
6360 /* Take down the hardware */
6363 /* Release the mutex so that the network subsystem can
6364 * complete any needed calls into the driver... */
6365 mutex_unlock(&priv->action_mutex);
6367 /* Unregister the device first - this results in close()
6368 * being called if the device is open. If we free storage
6369 * first, then close() will crash. */
6370 unregister_netdev(dev);
6372 /* ipw2100_down will ensure that there is no more pending work
6373 * in the workqueue's, so we can safely remove them now. */
6374 ipw2100_kill_workqueue(priv);
6376 ipw2100_queues_free(priv);
6378 /* Free potential debugging firmware snapshot */
6379 ipw2100_snapshot_free(priv);
6382 free_irq(dev->irq, priv);
6385 iounmap((void __iomem *)dev->base_addr);
6387 free_ieee80211(dev);
6390 pci_release_regions(pci_dev);
6391 pci_disable_device(pci_dev);
6393 IPW_DEBUG_INFO("exit\n");
6397 static int ipw2100_suspend(struct pci_dev *pci_dev, pm_message_t state)
6399 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6400 struct net_device *dev = priv->net_dev;
6402 IPW_DEBUG_INFO("%s: Going into suspend...\n", dev->name);
6404 mutex_lock(&priv->action_mutex);
6405 if (priv->status & STATUS_INITIALIZED) {
6406 /* Take down the device; powers it off, etc. */
6410 /* Remove the PRESENT state of the device */
6411 netif_device_detach(dev);
6413 pci_save_state(pci_dev);
6414 pci_disable_device(pci_dev);
6415 pci_set_power_state(pci_dev, PCI_D3hot);
6417 mutex_unlock(&priv->action_mutex);
6422 static int ipw2100_resume(struct pci_dev *pci_dev)
6424 struct ipw2100_priv *priv = pci_get_drvdata(pci_dev);
6425 struct net_device *dev = priv->net_dev;
6429 if (IPW2100_PM_DISABLED)
6432 mutex_lock(&priv->action_mutex);
6434 IPW_DEBUG_INFO("%s: Coming out of suspend...\n", dev->name);
6436 pci_set_power_state(pci_dev, PCI_D0);
6437 err = pci_enable_device(pci_dev);
6439 printk(KERN_ERR "%s: pci_enable_device failed on resume\n",
6441 mutex_unlock(&priv->action_mutex);
6444 pci_restore_state(pci_dev);
6447 * Suspend/Resume resets the PCI configuration space, so we have to
6448 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
6449 * from interfering with C3 CPU state. pci_restore_state won't help
6450 * here since it only restores the first 64 bytes pci config header.
6452 pci_read_config_dword(pci_dev, 0x40, &val);
6453 if ((val & 0x0000ff00) != 0)
6454 pci_write_config_dword(pci_dev, 0x40, val & 0xffff00ff);
6456 /* Set the device back into the PRESENT state; this will also wake
6457 * the queue of needed */
6458 netif_device_attach(dev);
6460 /* Bring the device back up */
6461 if (!(priv->status & STATUS_RF_KILL_SW))
6462 ipw2100_up(priv, 0);
6464 mutex_unlock(&priv->action_mutex);
6470 #define IPW2100_DEV_ID(x) { PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, x }
6472 static struct pci_device_id ipw2100_pci_id_table[] __devinitdata = {
6473 IPW2100_DEV_ID(0x2520), /* IN 2100A mPCI 3A */
6474 IPW2100_DEV_ID(0x2521), /* IN 2100A mPCI 3B */
6475 IPW2100_DEV_ID(0x2524), /* IN 2100A mPCI 3B */
6476 IPW2100_DEV_ID(0x2525), /* IN 2100A mPCI 3B */
6477 IPW2100_DEV_ID(0x2526), /* IN 2100A mPCI Gen A3 */
6478 IPW2100_DEV_ID(0x2522), /* IN 2100 mPCI 3B */
6479 IPW2100_DEV_ID(0x2523), /* IN 2100 mPCI 3A */
6480 IPW2100_DEV_ID(0x2527), /* IN 2100 mPCI 3B */
6481 IPW2100_DEV_ID(0x2528), /* IN 2100 mPCI 3B */
6482 IPW2100_DEV_ID(0x2529), /* IN 2100 mPCI 3B */
6483 IPW2100_DEV_ID(0x252B), /* IN 2100 mPCI 3A */
6484 IPW2100_DEV_ID(0x252C), /* IN 2100 mPCI 3A */
6485 IPW2100_DEV_ID(0x252D), /* IN 2100 mPCI 3A */
6487 IPW2100_DEV_ID(0x2550), /* IB 2100A mPCI 3B */
6488 IPW2100_DEV_ID(0x2551), /* IB 2100 mPCI 3B */
6489 IPW2100_DEV_ID(0x2553), /* IB 2100 mPCI 3B */
6490 IPW2100_DEV_ID(0x2554), /* IB 2100 mPCI 3B */
6491 IPW2100_DEV_ID(0x2555), /* IB 2100 mPCI 3B */
6493 IPW2100_DEV_ID(0x2560), /* DE 2100A mPCI 3A */
6494 IPW2100_DEV_ID(0x2562), /* DE 2100A mPCI 3A */
6495 IPW2100_DEV_ID(0x2563), /* DE 2100A mPCI 3A */
6496 IPW2100_DEV_ID(0x2561), /* DE 2100 mPCI 3A */
6497 IPW2100_DEV_ID(0x2565), /* DE 2100 mPCI 3A */
6498 IPW2100_DEV_ID(0x2566), /* DE 2100 mPCI 3A */
6499 IPW2100_DEV_ID(0x2567), /* DE 2100 mPCI 3A */
6501 IPW2100_DEV_ID(0x2570), /* GA 2100 mPCI 3B */
6503 IPW2100_DEV_ID(0x2580), /* TO 2100A mPCI 3B */
6504 IPW2100_DEV_ID(0x2582), /* TO 2100A mPCI 3B */
6505 IPW2100_DEV_ID(0x2583), /* TO 2100A mPCI 3B */
6506 IPW2100_DEV_ID(0x2581), /* TO 2100 mPCI 3B */
6507 IPW2100_DEV_ID(0x2585), /* TO 2100 mPCI 3B */
6508 IPW2100_DEV_ID(0x2586), /* TO 2100 mPCI 3B */
6509 IPW2100_DEV_ID(0x2587), /* TO 2100 mPCI 3B */
6511 IPW2100_DEV_ID(0x2590), /* SO 2100A mPCI 3B */
6512 IPW2100_DEV_ID(0x2592), /* SO 2100A mPCI 3B */
6513 IPW2100_DEV_ID(0x2591), /* SO 2100 mPCI 3B */
6514 IPW2100_DEV_ID(0x2593), /* SO 2100 mPCI 3B */
6515 IPW2100_DEV_ID(0x2596), /* SO 2100 mPCI 3B */
6516 IPW2100_DEV_ID(0x2598), /* SO 2100 mPCI 3B */
6518 IPW2100_DEV_ID(0x25A0), /* HP 2100 mPCI 3B */
6522 MODULE_DEVICE_TABLE(pci, ipw2100_pci_id_table);
6524 static struct pci_driver ipw2100_pci_driver = {
6526 .id_table = ipw2100_pci_id_table,
6527 .probe = ipw2100_pci_init_one,
6528 .remove = __devexit_p(ipw2100_pci_remove_one),
6530 .suspend = ipw2100_suspend,
6531 .resume = ipw2100_resume,
6536 * Initialize the ipw2100 driver/module
6538 * @returns 0 if ok, < 0 errno node con error.
6540 * Note: we cannot init the /proc stuff until the PCI driver is there,
6541 * or we risk an unlikely race condition on someone accessing
6542 * uninitialized data in the PCI dev struct through /proc.
6544 static int __init ipw2100_init(void)
6548 printk(KERN_INFO DRV_NAME ": %s, %s\n", DRV_DESCRIPTION, DRV_VERSION);
6549 printk(KERN_INFO DRV_NAME ": %s\n", DRV_COPYRIGHT);
6551 ret = pci_register_driver(&ipw2100_pci_driver);
6555 pm_qos_add_requirement(PM_QOS_CPU_DMA_LATENCY, "ipw2100",
6556 PM_QOS_DEFAULT_VALUE);
6557 #ifdef CONFIG_IPW2100_DEBUG
6558 ipw2100_debug_level = debug;
6559 ret = driver_create_file(&ipw2100_pci_driver.driver,
6560 &driver_attr_debug_level);
6568 * Cleanup ipw2100 driver registration
6570 static void __exit ipw2100_exit(void)
6572 /* FIXME: IPG: check that we have no instances of the devices open */
6573 #ifdef CONFIG_IPW2100_DEBUG
6574 driver_remove_file(&ipw2100_pci_driver.driver,
6575 &driver_attr_debug_level);
6577 pci_unregister_driver(&ipw2100_pci_driver);
6578 pm_qos_remove_requirement(PM_QOS_CPU_DMA_LATENCY, "ipw2100");
6581 module_init(ipw2100_init);
6582 module_exit(ipw2100_exit);
6584 #define WEXT_USECHANNELS 1
6586 static const long ipw2100_frequencies[] = {
6587 2412, 2417, 2422, 2427,
6588 2432, 2437, 2442, 2447,
6589 2452, 2457, 2462, 2467,
6593 #define FREQ_COUNT ARRAY_SIZE(ipw2100_frequencies)
6595 static const long ipw2100_rates_11b[] = {
6602 #define RATE_COUNT ARRAY_SIZE(ipw2100_rates_11b)
6604 static int ipw2100_wx_get_name(struct net_device *dev,
6605 struct iw_request_info *info,
6606 union iwreq_data *wrqu, char *extra)
6609 * This can be called at any time. No action lock required
6612 struct ipw2100_priv *priv = ieee80211_priv(dev);
6613 if (!(priv->status & STATUS_ASSOCIATED))
6614 strcpy(wrqu->name, "unassociated");
6616 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b");
6618 IPW_DEBUG_WX("Name: %s\n", wrqu->name);
6622 static int ipw2100_wx_set_freq(struct net_device *dev,
6623 struct iw_request_info *info,
6624 union iwreq_data *wrqu, char *extra)
6626 struct ipw2100_priv *priv = ieee80211_priv(dev);
6627 struct iw_freq *fwrq = &wrqu->freq;
6630 if (priv->ieee->iw_mode == IW_MODE_INFRA)
6633 mutex_lock(&priv->action_mutex);
6634 if (!(priv->status & STATUS_INITIALIZED)) {
6639 /* if setting by freq convert to channel */
6641 if ((fwrq->m >= (int)2.412e8 && fwrq->m <= (int)2.487e8)) {
6642 int f = fwrq->m / 100000;
6645 while ((c < REG_MAX_CHANNEL) &&
6646 (f != ipw2100_frequencies[c]))
6649 /* hack to fall through */
6655 if (fwrq->e > 0 || fwrq->m > 1000) {
6658 } else { /* Set the channel */
6659 IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
6660 err = ipw2100_set_channel(priv, fwrq->m, 0);
6664 mutex_unlock(&priv->action_mutex);
6668 static int ipw2100_wx_get_freq(struct net_device *dev,
6669 struct iw_request_info *info,
6670 union iwreq_data *wrqu, char *extra)
6673 * This can be called at any time. No action lock required
6676 struct ipw2100_priv *priv = ieee80211_priv(dev);
6680 /* If we are associated, trying to associate, or have a statically
6681 * configured CHANNEL then return that; otherwise return ANY */
6682 if (priv->config & CFG_STATIC_CHANNEL ||
6683 priv->status & STATUS_ASSOCIATED)
6684 wrqu->freq.m = priv->channel;
6688 IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
6693 static int ipw2100_wx_set_mode(struct net_device *dev,
6694 struct iw_request_info *info,
6695 union iwreq_data *wrqu, char *extra)
6697 struct ipw2100_priv *priv = ieee80211_priv(dev);
6700 IPW_DEBUG_WX("SET Mode -> %d \n", wrqu->mode);
6702 if (wrqu->mode == priv->ieee->iw_mode)
6705 mutex_lock(&priv->action_mutex);
6706 if (!(priv->status & STATUS_INITIALIZED)) {
6711 switch (wrqu->mode) {
6712 #ifdef CONFIG_IPW2100_MONITOR
6713 case IW_MODE_MONITOR:
6714 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR);
6716 #endif /* CONFIG_IPW2100_MONITOR */
6718 err = ipw2100_switch_mode(priv, IW_MODE_ADHOC);
6723 err = ipw2100_switch_mode(priv, IW_MODE_INFRA);
6728 mutex_unlock(&priv->action_mutex);
6732 static int ipw2100_wx_get_mode(struct net_device *dev,
6733 struct iw_request_info *info,
6734 union iwreq_data *wrqu, char *extra)
6737 * This can be called at any time. No action lock required
6740 struct ipw2100_priv *priv = ieee80211_priv(dev);
6742 wrqu->mode = priv->ieee->iw_mode;
6743 IPW_DEBUG_WX("GET Mode -> %d\n", wrqu->mode);
6748 #define POWER_MODES 5
6750 /* Values are in microsecond */
6751 static const s32 timeout_duration[POWER_MODES] = {
6759 static const s32 period_duration[POWER_MODES] = {
6767 static int ipw2100_wx_get_range(struct net_device *dev,
6768 struct iw_request_info *info,
6769 union iwreq_data *wrqu, char *extra)
6772 * This can be called at any time. No action lock required
6775 struct ipw2100_priv *priv = ieee80211_priv(dev);
6776 struct iw_range *range = (struct iw_range *)extra;
6780 wrqu->data.length = sizeof(*range);
6781 memset(range, 0, sizeof(*range));
6783 /* Let's try to keep this struct in the same order as in
6784 * linux/include/wireless.h
6787 /* TODO: See what values we can set, and remove the ones we can't
6788 * set, or fill them with some default data.
6791 /* ~5 Mb/s real (802.11b) */
6792 range->throughput = 5 * 1000 * 1000;
6794 // range->sensitivity; /* signal level threshold range */
6796 range->max_qual.qual = 100;
6797 /* TODO: Find real max RSSI and stick here */
6798 range->max_qual.level = 0;
6799 range->max_qual.noise = 0;
6800 range->max_qual.updated = 7; /* Updated all three */
6802 range->avg_qual.qual = 70; /* > 8% missed beacons is 'bad' */
6803 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
6804 range->avg_qual.level = 20 + IPW2100_RSSI_TO_DBM;
6805 range->avg_qual.noise = 0;
6806 range->avg_qual.updated = 7; /* Updated all three */
6808 range->num_bitrates = RATE_COUNT;
6810 for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) {
6811 range->bitrate[i] = ipw2100_rates_11b[i];
6814 range->min_rts = MIN_RTS_THRESHOLD;
6815 range->max_rts = MAX_RTS_THRESHOLD;
6816 range->min_frag = MIN_FRAG_THRESHOLD;
6817 range->max_frag = MAX_FRAG_THRESHOLD;
6819 range->min_pmp = period_duration[0]; /* Minimal PM period */
6820 range->max_pmp = period_duration[POWER_MODES - 1]; /* Maximal PM period */
6821 range->min_pmt = timeout_duration[POWER_MODES - 1]; /* Minimal PM timeout */
6822 range->max_pmt = timeout_duration[0]; /* Maximal PM timeout */
6824 /* How to decode max/min PM period */
6825 range->pmp_flags = IW_POWER_PERIOD;
6826 /* How to decode max/min PM period */
6827 range->pmt_flags = IW_POWER_TIMEOUT;
6828 /* What PM options are supported */
6829 range->pm_capa = IW_POWER_TIMEOUT | IW_POWER_PERIOD;
6831 range->encoding_size[0] = 5;
6832 range->encoding_size[1] = 13; /* Different token sizes */
6833 range->num_encoding_sizes = 2; /* Number of entry in the list */
6834 range->max_encoding_tokens = WEP_KEYS; /* Max number of tokens */
6835 // range->encoding_login_index; /* token index for login token */
6837 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6838 range->txpower_capa = IW_TXPOW_DBM;
6839 range->num_txpower = IW_MAX_TXPOWER;
6840 for (i = 0, level = (IPW_TX_POWER_MAX_DBM * 16);
6843 ((IPW_TX_POWER_MAX_DBM -
6844 IPW_TX_POWER_MIN_DBM) * 16) / (IW_MAX_TXPOWER - 1))
6845 range->txpower[i] = level / 16;
6847 range->txpower_capa = 0;
6848 range->num_txpower = 0;
6851 /* Set the Wireless Extension versions */
6852 range->we_version_compiled = WIRELESS_EXT;
6853 range->we_version_source = 18;
6855 // range->retry_capa; /* What retry options are supported */
6856 // range->retry_flags; /* How to decode max/min retry limit */
6857 // range->r_time_flags; /* How to decode max/min retry life */
6858 // range->min_retry; /* Minimal number of retries */
6859 // range->max_retry; /* Maximal number of retries */
6860 // range->min_r_time; /* Minimal retry lifetime */
6861 // range->max_r_time; /* Maximal retry lifetime */
6863 range->num_channels = FREQ_COUNT;
6866 for (i = 0; i < FREQ_COUNT; i++) {
6867 // TODO: Include only legal frequencies for some countries
6868 // if (local->channel_mask & (1 << i)) {
6869 range->freq[val].i = i + 1;
6870 range->freq[val].m = ipw2100_frequencies[i] * 100000;
6871 range->freq[val].e = 1;
6874 if (val == IW_MAX_FREQUENCIES)
6877 range->num_frequency = val;
6879 /* Event capability (kernel + driver) */
6880 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
6881 IW_EVENT_CAPA_MASK(SIOCGIWAP));
6882 range->event_capa[1] = IW_EVENT_CAPA_K_1;
6884 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
6885 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
6887 IPW_DEBUG_WX("GET Range\n");
6892 static int ipw2100_wx_set_wap(struct net_device *dev,
6893 struct iw_request_info *info,
6894 union iwreq_data *wrqu, char *extra)
6896 struct ipw2100_priv *priv = ieee80211_priv(dev);
6899 static const unsigned char any[] = {
6900 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
6902 static const unsigned char off[] = {
6903 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
6907 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
6910 mutex_lock(&priv->action_mutex);
6911 if (!(priv->status & STATUS_INITIALIZED)) {
6916 if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
6917 !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
6918 /* we disable mandatory BSSID association */
6919 IPW_DEBUG_WX("exit - disable mandatory BSSID\n");
6920 priv->config &= ~CFG_STATIC_BSSID;
6921 err = ipw2100_set_mandatory_bssid(priv, NULL, 0);
6925 priv->config |= CFG_STATIC_BSSID;
6926 memcpy(priv->mandatory_bssid_mac, wrqu->ap_addr.sa_data, ETH_ALEN);
6928 err = ipw2100_set_mandatory_bssid(priv, wrqu->ap_addr.sa_data, 0);
6930 IPW_DEBUG_WX("SET BSSID -> %pM\n", wrqu->ap_addr.sa_data);
6933 mutex_unlock(&priv->action_mutex);
6937 static int ipw2100_wx_get_wap(struct net_device *dev,
6938 struct iw_request_info *info,
6939 union iwreq_data *wrqu, char *extra)
6942 * This can be called at any time. No action lock required
6945 struct ipw2100_priv *priv = ieee80211_priv(dev);
6947 /* If we are associated, trying to associate, or have a statically
6948 * configured BSSID then return that; otherwise return ANY */
6949 if (priv->config & CFG_STATIC_BSSID || priv->status & STATUS_ASSOCIATED) {
6950 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
6951 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
6953 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
6955 IPW_DEBUG_WX("Getting WAP BSSID: %pM\n", wrqu->ap_addr.sa_data);
6959 static int ipw2100_wx_set_essid(struct net_device *dev,
6960 struct iw_request_info *info,
6961 union iwreq_data *wrqu, char *extra)
6963 struct ipw2100_priv *priv = ieee80211_priv(dev);
6964 char *essid = ""; /* ANY */
6967 DECLARE_SSID_BUF(ssid);
6969 mutex_lock(&priv->action_mutex);
6970 if (!(priv->status & STATUS_INITIALIZED)) {
6975 if (wrqu->essid.flags && wrqu->essid.length) {
6976 length = wrqu->essid.length;
6981 IPW_DEBUG_WX("Setting ESSID to ANY\n");
6982 priv->config &= ~CFG_STATIC_ESSID;
6983 err = ipw2100_set_essid(priv, NULL, 0, 0);
6987 length = min(length, IW_ESSID_MAX_SIZE);
6989 priv->config |= CFG_STATIC_ESSID;
6991 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
6992 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
6997 IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n",
6998 print_ssid(ssid, essid, length), length);
7000 priv->essid_len = length;
7001 memcpy(priv->essid, essid, priv->essid_len);
7003 err = ipw2100_set_essid(priv, essid, length, 0);
7006 mutex_unlock(&priv->action_mutex);
7010 static int ipw2100_wx_get_essid(struct net_device *dev,
7011 struct iw_request_info *info,
7012 union iwreq_data *wrqu, char *extra)
7015 * This can be called at any time. No action lock required
7018 struct ipw2100_priv *priv = ieee80211_priv(dev);
7019 DECLARE_SSID_BUF(ssid);
7021 /* If we are associated, trying to associate, or have a statically
7022 * configured ESSID then return that; otherwise return ANY */
7023 if (priv->config & CFG_STATIC_ESSID || priv->status & STATUS_ASSOCIATED) {
7024 IPW_DEBUG_WX("Getting essid: '%s'\n",
7025 print_ssid(ssid, priv->essid, priv->essid_len));
7026 memcpy(extra, priv->essid, priv->essid_len);
7027 wrqu->essid.length = priv->essid_len;
7028 wrqu->essid.flags = 1; /* active */
7030 IPW_DEBUG_WX("Getting essid: ANY\n");
7031 wrqu->essid.length = 0;
7032 wrqu->essid.flags = 0; /* active */
7038 static int ipw2100_wx_set_nick(struct net_device *dev,
7039 struct iw_request_info *info,
7040 union iwreq_data *wrqu, char *extra)
7043 * This can be called at any time. No action lock required
7046 struct ipw2100_priv *priv = ieee80211_priv(dev);
7048 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
7051 wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
7052 memset(priv->nick, 0, sizeof(priv->nick));
7053 memcpy(priv->nick, extra, wrqu->data.length);
7055 IPW_DEBUG_WX("SET Nickname -> %s \n", priv->nick);
7060 static int ipw2100_wx_get_nick(struct net_device *dev,
7061 struct iw_request_info *info,
7062 union iwreq_data *wrqu, char *extra)
7065 * This can be called at any time. No action lock required
7068 struct ipw2100_priv *priv = ieee80211_priv(dev);
7070 wrqu->data.length = strlen(priv->nick);
7071 memcpy(extra, priv->nick, wrqu->data.length);
7072 wrqu->data.flags = 1; /* active */
7074 IPW_DEBUG_WX("GET Nickname -> %s \n", extra);
7079 static int ipw2100_wx_set_rate(struct net_device *dev,
7080 struct iw_request_info *info,
7081 union iwreq_data *wrqu, char *extra)
7083 struct ipw2100_priv *priv = ieee80211_priv(dev);
7084 u32 target_rate = wrqu->bitrate.value;
7088 mutex_lock(&priv->action_mutex);
7089 if (!(priv->status & STATUS_INITIALIZED)) {
7096 if (target_rate == 1000000 ||
7097 (!wrqu->bitrate.fixed && target_rate > 1000000))
7098 rate |= TX_RATE_1_MBIT;
7099 if (target_rate == 2000000 ||
7100 (!wrqu->bitrate.fixed && target_rate > 2000000))
7101 rate |= TX_RATE_2_MBIT;
7102 if (target_rate == 5500000 ||
7103 (!wrqu->bitrate.fixed && target_rate > 5500000))
7104 rate |= TX_RATE_5_5_MBIT;
7105 if (target_rate == 11000000 ||
7106 (!wrqu->bitrate.fixed && target_rate > 11000000))
7107 rate |= TX_RATE_11_MBIT;
7109 rate = DEFAULT_TX_RATES;
7111 err = ipw2100_set_tx_rates(priv, rate, 0);
7113 IPW_DEBUG_WX("SET Rate -> %04X \n", rate);
7115 mutex_unlock(&priv->action_mutex);
7119 static int ipw2100_wx_get_rate(struct net_device *dev,
7120 struct iw_request_info *info,
7121 union iwreq_data *wrqu, char *extra)
7123 struct ipw2100_priv *priv = ieee80211_priv(dev);
7125 int len = sizeof(val);
7128 if (!(priv->status & STATUS_ENABLED) ||
7129 priv->status & STATUS_RF_KILL_MASK ||
7130 !(priv->status & STATUS_ASSOCIATED)) {
7131 wrqu->bitrate.value = 0;
7135 mutex_lock(&priv->action_mutex);
7136 if (!(priv->status & STATUS_INITIALIZED)) {
7141 err = ipw2100_get_ordinal(priv, IPW_ORD_CURRENT_TX_RATE, &val, &len);
7143 IPW_DEBUG_WX("failed querying ordinals.\n");
7147 switch (val & TX_RATE_MASK) {
7148 case TX_RATE_1_MBIT:
7149 wrqu->bitrate.value = 1000000;
7151 case TX_RATE_2_MBIT:
7152 wrqu->bitrate.value = 2000000;
7154 case TX_RATE_5_5_MBIT:
7155 wrqu->bitrate.value = 5500000;
7157 case TX_RATE_11_MBIT:
7158 wrqu->bitrate.value = 11000000;
7161 wrqu->bitrate.value = 0;
7164 IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
7167 mutex_unlock(&priv->action_mutex);
7171 static int ipw2100_wx_set_rts(struct net_device *dev,
7172 struct iw_request_info *info,
7173 union iwreq_data *wrqu, char *extra)
7175 struct ipw2100_priv *priv = ieee80211_priv(dev);
7178 /* Auto RTS not yet supported */
7179 if (wrqu->rts.fixed == 0)
7182 mutex_lock(&priv->action_mutex);
7183 if (!(priv->status & STATUS_INITIALIZED)) {
7188 if (wrqu->rts.disabled)
7189 value = priv->rts_threshold | RTS_DISABLED;
7191 if (wrqu->rts.value < 1 || wrqu->rts.value > 2304) {
7195 value = wrqu->rts.value;
7198 err = ipw2100_set_rts_threshold(priv, value);
7200 IPW_DEBUG_WX("SET RTS Threshold -> 0x%08X \n", value);
7202 mutex_unlock(&priv->action_mutex);
7206 static int ipw2100_wx_get_rts(struct net_device *dev,
7207 struct iw_request_info *info,
7208 union iwreq_data *wrqu, char *extra)
7211 * This can be called at any time. No action lock required
7214 struct ipw2100_priv *priv = ieee80211_priv(dev);
7216 wrqu->rts.value = priv->rts_threshold & ~RTS_DISABLED;
7217 wrqu->rts.fixed = 1; /* no auto select */
7219 /* If RTS is set to the default value, then it is disabled */
7220 wrqu->rts.disabled = (priv->rts_threshold & RTS_DISABLED) ? 1 : 0;
7222 IPW_DEBUG_WX("GET RTS Threshold -> 0x%08X \n", wrqu->rts.value);
7227 static int ipw2100_wx_set_txpow(struct net_device *dev,
7228 struct iw_request_info *info,
7229 union iwreq_data *wrqu, char *extra)
7231 struct ipw2100_priv *priv = ieee80211_priv(dev);
7234 if (ipw_radio_kill_sw(priv, wrqu->txpower.disabled))
7235 return -EINPROGRESS;
7237 if (priv->ieee->iw_mode != IW_MODE_ADHOC)
7240 if ((wrqu->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)
7243 if (wrqu->txpower.fixed == 0)
7244 value = IPW_TX_POWER_DEFAULT;
7246 if (wrqu->txpower.value < IPW_TX_POWER_MIN_DBM ||
7247 wrqu->txpower.value > IPW_TX_POWER_MAX_DBM)
7250 value = wrqu->txpower.value;
7253 mutex_lock(&priv->action_mutex);
7254 if (!(priv->status & STATUS_INITIALIZED)) {
7259 err = ipw2100_set_tx_power(priv, value);
7261 IPW_DEBUG_WX("SET TX Power -> %d \n", value);
7264 mutex_unlock(&priv->action_mutex);
7268 static int ipw2100_wx_get_txpow(struct net_device *dev,
7269 struct iw_request_info *info,
7270 union iwreq_data *wrqu, char *extra)
7273 * This can be called at any time. No action lock required
7276 struct ipw2100_priv *priv = ieee80211_priv(dev);
7278 wrqu->txpower.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
7280 if (priv->tx_power == IPW_TX_POWER_DEFAULT) {
7281 wrqu->txpower.fixed = 0;
7282 wrqu->txpower.value = IPW_TX_POWER_MAX_DBM;
7284 wrqu->txpower.fixed = 1;
7285 wrqu->txpower.value = priv->tx_power;
7288 wrqu->txpower.flags = IW_TXPOW_DBM;
7290 IPW_DEBUG_WX("GET TX Power -> %d \n", wrqu->txpower.value);
7295 static int ipw2100_wx_set_frag(struct net_device *dev,
7296 struct iw_request_info *info,
7297 union iwreq_data *wrqu, char *extra)
7300 * This can be called at any time. No action lock required
7303 struct ipw2100_priv *priv = ieee80211_priv(dev);
7305 if (!wrqu->frag.fixed)
7308 if (wrqu->frag.disabled) {
7309 priv->frag_threshold |= FRAG_DISABLED;
7310 priv->ieee->fts = DEFAULT_FTS;
7312 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
7313 wrqu->frag.value > MAX_FRAG_THRESHOLD)
7316 priv->ieee->fts = wrqu->frag.value & ~0x1;
7317 priv->frag_threshold = priv->ieee->fts;
7320 IPW_DEBUG_WX("SET Frag Threshold -> %d \n", priv->ieee->fts);
7325 static int ipw2100_wx_get_frag(struct net_device *dev,
7326 struct iw_request_info *info,
7327 union iwreq_data *wrqu, char *extra)
7330 * This can be called at any time. No action lock required
7333 struct ipw2100_priv *priv = ieee80211_priv(dev);
7334 wrqu->frag.value = priv->frag_threshold & ~FRAG_DISABLED;
7335 wrqu->frag.fixed = 0; /* no auto select */
7336 wrqu->frag.disabled = (priv->frag_threshold & FRAG_DISABLED) ? 1 : 0;
7338 IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
7343 static int ipw2100_wx_set_retry(struct net_device *dev,
7344 struct iw_request_info *info,
7345 union iwreq_data *wrqu, char *extra)
7347 struct ipw2100_priv *priv = ieee80211_priv(dev);
7350 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
7353 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
7356 mutex_lock(&priv->action_mutex);
7357 if (!(priv->status & STATUS_INITIALIZED)) {
7362 if (wrqu->retry.flags & IW_RETRY_SHORT) {
7363 err = ipw2100_set_short_retry(priv, wrqu->retry.value);
7364 IPW_DEBUG_WX("SET Short Retry Limit -> %d \n",
7369 if (wrqu->retry.flags & IW_RETRY_LONG) {
7370 err = ipw2100_set_long_retry(priv, wrqu->retry.value);
7371 IPW_DEBUG_WX("SET Long Retry Limit -> %d \n",
7376 err = ipw2100_set_short_retry(priv, wrqu->retry.value);
7378 err = ipw2100_set_long_retry(priv, wrqu->retry.value);
7380 IPW_DEBUG_WX("SET Both Retry Limits -> %d \n", wrqu->retry.value);
7383 mutex_unlock(&priv->action_mutex);
7387 static int ipw2100_wx_get_retry(struct net_device *dev,
7388 struct iw_request_info *info,
7389 union iwreq_data *wrqu, char *extra)
7392 * This can be called at any time. No action lock required
7395 struct ipw2100_priv *priv = ieee80211_priv(dev);
7397 wrqu->retry.disabled = 0; /* can't be disabled */
7399 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME)
7402 if (wrqu->retry.flags & IW_RETRY_LONG) {
7403 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
7404 wrqu->retry.value = priv->long_retry_limit;
7407 (priv->short_retry_limit !=
7408 priv->long_retry_limit) ?
7409 IW_RETRY_LIMIT | IW_RETRY_SHORT : IW_RETRY_LIMIT;
7411 wrqu->retry.value = priv->short_retry_limit;
7414 IPW_DEBUG_WX("GET Retry -> %d \n", wrqu->retry.value);
7419 static int ipw2100_wx_set_scan(struct net_device *dev,
7420 struct iw_request_info *info,
7421 union iwreq_data *wrqu, char *extra)
7423 struct ipw2100_priv *priv = ieee80211_priv(dev);
7426 mutex_lock(&priv->action_mutex);
7427 if (!(priv->status & STATUS_INITIALIZED)) {
7432 IPW_DEBUG_WX("Initiating scan...\n");
7434 priv->user_requested_scan = 1;
7435 if (ipw2100_set_scan_options(priv) || ipw2100_start_scan(priv)) {
7436 IPW_DEBUG_WX("Start scan failed.\n");
7438 /* TODO: Mark a scan as pending so when hardware initialized
7443 mutex_unlock(&priv->action_mutex);
7447 static int ipw2100_wx_get_scan(struct net_device *dev,
7448 struct iw_request_info *info,
7449 union iwreq_data *wrqu, char *extra)
7452 * This can be called at any time. No action lock required
7455 struct ipw2100_priv *priv = ieee80211_priv(dev);
7456 return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
7460 * Implementation based on code in hostap-driver v0.1.3 hostap_ioctl.c
7462 static int ipw2100_wx_set_encode(struct net_device *dev,
7463 struct iw_request_info *info,
7464 union iwreq_data *wrqu, char *key)
7467 * No check of STATUS_INITIALIZED required
7470 struct ipw2100_priv *priv = ieee80211_priv(dev);
7471 return ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
7474 static int ipw2100_wx_get_encode(struct net_device *dev,
7475 struct iw_request_info *info,
7476 union iwreq_data *wrqu, char *key)
7479 * This can be called at any time. No action lock required
7482 struct ipw2100_priv *priv = ieee80211_priv(dev);
7483 return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
7486 static int ipw2100_wx_set_power(struct net_device *dev,
7487 struct iw_request_info *info,
7488 union iwreq_data *wrqu, char *extra)
7490 struct ipw2100_priv *priv = ieee80211_priv(dev);
7493 mutex_lock(&priv->action_mutex);
7494 if (!(priv->status & STATUS_INITIALIZED)) {
7499 if (wrqu->power.disabled) {
7500 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
7501 err = ipw2100_set_power_mode(priv, IPW_POWER_MODE_CAM);
7502 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
7506 switch (wrqu->power.flags & IW_POWER_MODE) {
7507 case IW_POWER_ON: /* If not specified */
7508 case IW_POWER_MODE: /* If set all mask */
7509 case IW_POWER_ALL_R: /* If explicitly state all */
7511 default: /* Otherwise we don't support it */
7512 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
7518 /* If the user hasn't specified a power management mode yet, default
7520 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
7521 err = ipw2100_set_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
7523 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
7526 mutex_unlock(&priv->action_mutex);
7531 static int ipw2100_wx_get_power(struct net_device *dev,
7532 struct iw_request_info *info,
7533 union iwreq_data *wrqu, char *extra)
7536 * This can be called at any time. No action lock required
7539 struct ipw2100_priv *priv = ieee80211_priv(dev);
7541 if (!(priv->power_mode & IPW_POWER_ENABLED))
7542 wrqu->power.disabled = 1;
7544 wrqu->power.disabled = 0;
7545 wrqu->power.flags = 0;
7548 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
7558 static int ipw2100_wx_set_genie(struct net_device *dev,
7559 struct iw_request_info *info,
7560 union iwreq_data *wrqu, char *extra)
7563 struct ipw2100_priv *priv = ieee80211_priv(dev);
7564 struct ieee80211_device *ieee = priv->ieee;
7567 if (!ieee->wpa_enabled)
7570 if (wrqu->data.length > MAX_WPA_IE_LEN ||
7571 (wrqu->data.length && extra == NULL))
7574 if (wrqu->data.length) {
7575 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
7579 kfree(ieee->wpa_ie);
7581 ieee->wpa_ie_len = wrqu->data.length;
7583 kfree(ieee->wpa_ie);
7584 ieee->wpa_ie = NULL;
7585 ieee->wpa_ie_len = 0;
7588 ipw2100_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
7594 static int ipw2100_wx_get_genie(struct net_device *dev,
7595 struct iw_request_info *info,
7596 union iwreq_data *wrqu, char *extra)
7598 struct ipw2100_priv *priv = ieee80211_priv(dev);
7599 struct ieee80211_device *ieee = priv->ieee;
7601 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
7602 wrqu->data.length = 0;
7606 if (wrqu->data.length < ieee->wpa_ie_len)
7609 wrqu->data.length = ieee->wpa_ie_len;
7610 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
7616 static int ipw2100_wx_set_auth(struct net_device *dev,
7617 struct iw_request_info *info,
7618 union iwreq_data *wrqu, char *extra)
7620 struct ipw2100_priv *priv = ieee80211_priv(dev);
7621 struct ieee80211_device *ieee = priv->ieee;
7622 struct iw_param *param = &wrqu->param;
7623 struct lib80211_crypt_data *crypt;
7624 unsigned long flags;
7627 switch (param->flags & IW_AUTH_INDEX) {
7628 case IW_AUTH_WPA_VERSION:
7629 case IW_AUTH_CIPHER_PAIRWISE:
7630 case IW_AUTH_CIPHER_GROUP:
7631 case IW_AUTH_KEY_MGMT:
7633 * ipw2200 does not use these parameters
7637 case IW_AUTH_TKIP_COUNTERMEASURES:
7638 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
7639 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
7642 flags = crypt->ops->get_flags(crypt->priv);
7645 flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
7647 flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
7649 crypt->ops->set_flags(flags, crypt->priv);
7653 case IW_AUTH_DROP_UNENCRYPTED:{
7656 * wpa_supplicant calls set_wpa_enabled when the driver
7657 * is loaded and unloaded, regardless of if WPA is being
7658 * used. No other calls are made which can be used to
7659 * determine if encryption will be used or not prior to
7660 * association being expected. If encryption is not being
7661 * used, drop_unencrypted is set to false, else true -- we
7662 * can use this to determine if the CAP_PRIVACY_ON bit should
7665 struct ieee80211_security sec = {
7666 .flags = SEC_ENABLED,
7667 .enabled = param->value,
7669 priv->ieee->drop_unencrypted = param->value;
7670 /* We only change SEC_LEVEL for open mode. Others
7671 * are set by ipw_wpa_set_encryption.
7673 if (!param->value) {
7674 sec.flags |= SEC_LEVEL;
7675 sec.level = SEC_LEVEL_0;
7677 sec.flags |= SEC_LEVEL;
7678 sec.level = SEC_LEVEL_1;
7680 if (priv->ieee->set_security)
7681 priv->ieee->set_security(priv->ieee->dev, &sec);
7685 case IW_AUTH_80211_AUTH_ALG:
7686 ret = ipw2100_wpa_set_auth_algs(priv, param->value);
7689 case IW_AUTH_WPA_ENABLED:
7690 ret = ipw2100_wpa_enable(priv, param->value);
7693 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
7694 ieee->ieee802_1x = param->value;
7697 //case IW_AUTH_ROAMING_CONTROL:
7698 case IW_AUTH_PRIVACY_INVOKED:
7699 ieee->privacy_invoked = param->value;
7709 static int ipw2100_wx_get_auth(struct net_device *dev,
7710 struct iw_request_info *info,
7711 union iwreq_data *wrqu, char *extra)
7713 struct ipw2100_priv *priv = ieee80211_priv(dev);
7714 struct ieee80211_device *ieee = priv->ieee;
7715 struct lib80211_crypt_data *crypt;
7716 struct iw_param *param = &wrqu->param;
7719 switch (param->flags & IW_AUTH_INDEX) {
7720 case IW_AUTH_WPA_VERSION:
7721 case IW_AUTH_CIPHER_PAIRWISE:
7722 case IW_AUTH_CIPHER_GROUP:
7723 case IW_AUTH_KEY_MGMT:
7725 * wpa_supplicant will control these internally
7730 case IW_AUTH_TKIP_COUNTERMEASURES:
7731 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
7732 if (!crypt || !crypt->ops->get_flags) {
7733 IPW_DEBUG_WARNING("Can't get TKIP countermeasures: "
7734 "crypt not set!\n");
7738 param->value = (crypt->ops->get_flags(crypt->priv) &
7739 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
7743 case IW_AUTH_DROP_UNENCRYPTED:
7744 param->value = ieee->drop_unencrypted;
7747 case IW_AUTH_80211_AUTH_ALG:
7748 param->value = priv->ieee->sec.auth_mode;
7751 case IW_AUTH_WPA_ENABLED:
7752 param->value = ieee->wpa_enabled;
7755 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
7756 param->value = ieee->ieee802_1x;
7759 case IW_AUTH_ROAMING_CONTROL:
7760 case IW_AUTH_PRIVACY_INVOKED:
7761 param->value = ieee->privacy_invoked;
7770 /* SIOCSIWENCODEEXT */
7771 static int ipw2100_wx_set_encodeext(struct net_device *dev,
7772 struct iw_request_info *info,
7773 union iwreq_data *wrqu, char *extra)
7775 struct ipw2100_priv *priv = ieee80211_priv(dev);
7776 return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
7779 /* SIOCGIWENCODEEXT */
7780 static int ipw2100_wx_get_encodeext(struct net_device *dev,
7781 struct iw_request_info *info,
7782 union iwreq_data *wrqu, char *extra)
7784 struct ipw2100_priv *priv = ieee80211_priv(dev);
7785 return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
7789 static int ipw2100_wx_set_mlme(struct net_device *dev,
7790 struct iw_request_info *info,
7791 union iwreq_data *wrqu, char *extra)
7793 struct ipw2100_priv *priv = ieee80211_priv(dev);
7794 struct iw_mlme *mlme = (struct iw_mlme *)extra;
7797 reason = cpu_to_le16(mlme->reason_code);
7799 switch (mlme->cmd) {
7800 case IW_MLME_DEAUTH:
7804 case IW_MLME_DISASSOC:
7805 ipw2100_disassociate_bssid(priv);
7819 #ifdef CONFIG_IPW2100_MONITOR
7820 static int ipw2100_wx_set_promisc(struct net_device *dev,
7821 struct iw_request_info *info,
7822 union iwreq_data *wrqu, char *extra)
7824 struct ipw2100_priv *priv = ieee80211_priv(dev);
7825 int *parms = (int *)extra;
7826 int enable = (parms[0] > 0);
7829 mutex_lock(&priv->action_mutex);
7830 if (!(priv->status & STATUS_INITIALIZED)) {
7836 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7837 err = ipw2100_set_channel(priv, parms[1], 0);
7840 priv->channel = parms[1];
7841 err = ipw2100_switch_mode(priv, IW_MODE_MONITOR);
7843 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
7844 err = ipw2100_switch_mode(priv, priv->last_mode);
7847 mutex_unlock(&priv->action_mutex);
7851 static int ipw2100_wx_reset(struct net_device *dev,
7852 struct iw_request_info *info,
7853 union iwreq_data *wrqu, char *extra)
7855 struct ipw2100_priv *priv = ieee80211_priv(dev);
7856 if (priv->status & STATUS_INITIALIZED)
7857 schedule_reset(priv);
7863 static int ipw2100_wx_set_powermode(struct net_device *dev,
7864 struct iw_request_info *info,
7865 union iwreq_data *wrqu, char *extra)
7867 struct ipw2100_priv *priv = ieee80211_priv(dev);
7868 int err = 0, mode = *(int *)extra;
7870 mutex_lock(&priv->action_mutex);
7871 if (!(priv->status & STATUS_INITIALIZED)) {
7876 if ((mode < 0) || (mode > POWER_MODES))
7877 mode = IPW_POWER_AUTO;
7879 if (IPW_POWER_LEVEL(priv->power_mode) != mode)
7880 err = ipw2100_set_power_mode(priv, mode);
7882 mutex_unlock(&priv->action_mutex);
7886 #define MAX_POWER_STRING 80
7887 static int ipw2100_wx_get_powermode(struct net_device *dev,
7888 struct iw_request_info *info,
7889 union iwreq_data *wrqu, char *extra)
7892 * This can be called at any time. No action lock required
7895 struct ipw2100_priv *priv = ieee80211_priv(dev);
7896 int level = IPW_POWER_LEVEL(priv->power_mode);
7897 s32 timeout, period;
7899 if (!(priv->power_mode & IPW_POWER_ENABLED)) {
7900 snprintf(extra, MAX_POWER_STRING,
7901 "Power save level: %d (Off)", level);
7904 case IPW_POWER_MODE_CAM:
7905 snprintf(extra, MAX_POWER_STRING,
7906 "Power save level: %d (None)", level);
7908 case IPW_POWER_AUTO:
7909 snprintf(extra, MAX_POWER_STRING,
7910 "Power save level: %d (Auto)", level);
7913 timeout = timeout_duration[level - 1] / 1000;
7914 period = period_duration[level - 1] / 1000;
7915 snprintf(extra, MAX_POWER_STRING,
7916 "Power save level: %d "
7917 "(Timeout %dms, Period %dms)",
7918 level, timeout, period);
7922 wrqu->data.length = strlen(extra) + 1;
7927 static int ipw2100_wx_set_preamble(struct net_device *dev,
7928 struct iw_request_info *info,
7929 union iwreq_data *wrqu, char *extra)
7931 struct ipw2100_priv *priv = ieee80211_priv(dev);
7932 int err, mode = *(int *)extra;
7934 mutex_lock(&priv->action_mutex);
7935 if (!(priv->status & STATUS_INITIALIZED)) {
7941 priv->config |= CFG_LONG_PREAMBLE;
7943 priv->config &= ~CFG_LONG_PREAMBLE;
7949 err = ipw2100_system_config(priv, 0);
7952 mutex_unlock(&priv->action_mutex);
7956 static int ipw2100_wx_get_preamble(struct net_device *dev,
7957 struct iw_request_info *info,
7958 union iwreq_data *wrqu, char *extra)
7961 * This can be called at any time. No action lock required
7964 struct ipw2100_priv *priv = ieee80211_priv(dev);
7966 if (priv->config & CFG_LONG_PREAMBLE)
7967 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
7969 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
7974 #ifdef CONFIG_IPW2100_MONITOR
7975 static int ipw2100_wx_set_crc_check(struct net_device *dev,
7976 struct iw_request_info *info,
7977 union iwreq_data *wrqu, char *extra)
7979 struct ipw2100_priv *priv = ieee80211_priv(dev);
7980 int err, mode = *(int *)extra;
7982 mutex_lock(&priv->action_mutex);
7983 if (!(priv->status & STATUS_INITIALIZED)) {
7989 priv->config |= CFG_CRC_CHECK;
7991 priv->config &= ~CFG_CRC_CHECK;
7999 mutex_unlock(&priv->action_mutex);
8003 static int ipw2100_wx_get_crc_check(struct net_device *dev,
8004 struct iw_request_info *info,
8005 union iwreq_data *wrqu, char *extra)
8008 * This can be called at any time. No action lock required
8011 struct ipw2100_priv *priv = ieee80211_priv(dev);
8013 if (priv->config & CFG_CRC_CHECK)
8014 snprintf(wrqu->name, IFNAMSIZ, "CRC checked (1)");
8016 snprintf(wrqu->name, IFNAMSIZ, "CRC ignored (0)");
8020 #endif /* CONFIG_IPW2100_MONITOR */
8022 static iw_handler ipw2100_wx_handlers[] = {
8023 NULL, /* SIOCSIWCOMMIT */
8024 ipw2100_wx_get_name, /* SIOCGIWNAME */
8025 NULL, /* SIOCSIWNWID */
8026 NULL, /* SIOCGIWNWID */
8027 ipw2100_wx_set_freq, /* SIOCSIWFREQ */
8028 ipw2100_wx_get_freq, /* SIOCGIWFREQ */
8029 ipw2100_wx_set_mode, /* SIOCSIWMODE */
8030 ipw2100_wx_get_mode, /* SIOCGIWMODE */
8031 NULL, /* SIOCSIWSENS */
8032 NULL, /* SIOCGIWSENS */
8033 NULL, /* SIOCSIWRANGE */
8034 ipw2100_wx_get_range, /* SIOCGIWRANGE */
8035 NULL, /* SIOCSIWPRIV */
8036 NULL, /* SIOCGIWPRIV */
8037 NULL, /* SIOCSIWSTATS */
8038 NULL, /* SIOCGIWSTATS */
8039 NULL, /* SIOCSIWSPY */
8040 NULL, /* SIOCGIWSPY */
8041 NULL, /* SIOCGIWTHRSPY */
8042 NULL, /* SIOCWIWTHRSPY */
8043 ipw2100_wx_set_wap, /* SIOCSIWAP */
8044 ipw2100_wx_get_wap, /* SIOCGIWAP */
8045 ipw2100_wx_set_mlme, /* SIOCSIWMLME */
8046 NULL, /* SIOCGIWAPLIST -- deprecated */
8047 ipw2100_wx_set_scan, /* SIOCSIWSCAN */
8048 ipw2100_wx_get_scan, /* SIOCGIWSCAN */
8049 ipw2100_wx_set_essid, /* SIOCSIWESSID */
8050 ipw2100_wx_get_essid, /* SIOCGIWESSID */
8051 ipw2100_wx_set_nick, /* SIOCSIWNICKN */
8052 ipw2100_wx_get_nick, /* SIOCGIWNICKN */
8053 NULL, /* -- hole -- */
8054 NULL, /* -- hole -- */
8055 ipw2100_wx_set_rate, /* SIOCSIWRATE */
8056 ipw2100_wx_get_rate, /* SIOCGIWRATE */
8057 ipw2100_wx_set_rts, /* SIOCSIWRTS */
8058 ipw2100_wx_get_rts, /* SIOCGIWRTS */
8059 ipw2100_wx_set_frag, /* SIOCSIWFRAG */
8060 ipw2100_wx_get_frag, /* SIOCGIWFRAG */
8061 ipw2100_wx_set_txpow, /* SIOCSIWTXPOW */
8062 ipw2100_wx_get_txpow, /* SIOCGIWTXPOW */
8063 ipw2100_wx_set_retry, /* SIOCSIWRETRY */
8064 ipw2100_wx_get_retry, /* SIOCGIWRETRY */
8065 ipw2100_wx_set_encode, /* SIOCSIWENCODE */
8066 ipw2100_wx_get_encode, /* SIOCGIWENCODE */
8067 ipw2100_wx_set_power, /* SIOCSIWPOWER */
8068 ipw2100_wx_get_power, /* SIOCGIWPOWER */
8069 NULL, /* -- hole -- */
8070 NULL, /* -- hole -- */
8071 ipw2100_wx_set_genie, /* SIOCSIWGENIE */
8072 ipw2100_wx_get_genie, /* SIOCGIWGENIE */
8073 ipw2100_wx_set_auth, /* SIOCSIWAUTH */
8074 ipw2100_wx_get_auth, /* SIOCGIWAUTH */
8075 ipw2100_wx_set_encodeext, /* SIOCSIWENCODEEXT */
8076 ipw2100_wx_get_encodeext, /* SIOCGIWENCODEEXT */
8077 NULL, /* SIOCSIWPMKSA */
8080 #define IPW2100_PRIV_SET_MONITOR SIOCIWFIRSTPRIV
8081 #define IPW2100_PRIV_RESET SIOCIWFIRSTPRIV+1
8082 #define IPW2100_PRIV_SET_POWER SIOCIWFIRSTPRIV+2
8083 #define IPW2100_PRIV_GET_POWER SIOCIWFIRSTPRIV+3
8084 #define IPW2100_PRIV_SET_LONGPREAMBLE SIOCIWFIRSTPRIV+4
8085 #define IPW2100_PRIV_GET_LONGPREAMBLE SIOCIWFIRSTPRIV+5
8086 #define IPW2100_PRIV_SET_CRC_CHECK SIOCIWFIRSTPRIV+6
8087 #define IPW2100_PRIV_GET_CRC_CHECK SIOCIWFIRSTPRIV+7
8089 static const struct iw_priv_args ipw2100_private_args[] = {
8091 #ifdef CONFIG_IPW2100_MONITOR
8093 IPW2100_PRIV_SET_MONITOR,
8094 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
8097 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
8098 #endif /* CONFIG_IPW2100_MONITOR */
8101 IPW2100_PRIV_SET_POWER,
8102 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_power"},
8104 IPW2100_PRIV_GET_POWER,
8105 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_POWER_STRING,
8108 IPW2100_PRIV_SET_LONGPREAMBLE,
8109 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_preamble"},
8111 IPW2100_PRIV_GET_LONGPREAMBLE,
8112 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_preamble"},
8113 #ifdef CONFIG_IPW2100_MONITOR
8115 IPW2100_PRIV_SET_CRC_CHECK,
8116 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_crc_check"},
8118 IPW2100_PRIV_GET_CRC_CHECK,
8119 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ, "get_crc_check"},
8120 #endif /* CONFIG_IPW2100_MONITOR */
8123 static iw_handler ipw2100_private_handler[] = {
8124 #ifdef CONFIG_IPW2100_MONITOR
8125 ipw2100_wx_set_promisc,
8127 #else /* CONFIG_IPW2100_MONITOR */
8130 #endif /* CONFIG_IPW2100_MONITOR */
8131 ipw2100_wx_set_powermode,
8132 ipw2100_wx_get_powermode,
8133 ipw2100_wx_set_preamble,
8134 ipw2100_wx_get_preamble,
8135 #ifdef CONFIG_IPW2100_MONITOR
8136 ipw2100_wx_set_crc_check,
8137 ipw2100_wx_get_crc_check,
8138 #else /* CONFIG_IPW2100_MONITOR */
8141 #endif /* CONFIG_IPW2100_MONITOR */
8145 * Get wireless statistics.
8146 * Called by /proc/net/wireless
8147 * Also called by SIOCGIWSTATS
8149 static struct iw_statistics *ipw2100_wx_wireless_stats(struct net_device *dev)
8163 struct ipw2100_priv *priv = ieee80211_priv(dev);
8164 struct iw_statistics *wstats;
8165 u32 rssi, quality, tx_retries, missed_beacons, tx_failures;
8166 u32 ord_len = sizeof(u32);
8169 return (struct iw_statistics *)NULL;
8171 wstats = &priv->wstats;
8173 /* if hw is disabled, then ipw2100_get_ordinal() can't be called.
8174 * ipw2100_wx_wireless_stats seems to be called before fw is
8175 * initialized. STATUS_ASSOCIATED will only be set if the hw is up
8176 * and associated; if not associcated, the values are all meaningless
8177 * anyway, so set them all to NULL and INVALID */
8178 if (!(priv->status & STATUS_ASSOCIATED)) {
8179 wstats->miss.beacon = 0;
8180 wstats->discard.retries = 0;
8181 wstats->qual.qual = 0;
8182 wstats->qual.level = 0;
8183 wstats->qual.noise = 0;
8184 wstats->qual.updated = 7;
8185 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
8186 IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
8190 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_MISSED_BCNS,
8191 &missed_beacons, &ord_len))
8192 goto fail_get_ordinal;
8194 /* If we don't have a connection the quality and level is 0 */
8195 if (!(priv->status & STATUS_ASSOCIATED)) {
8196 wstats->qual.qual = 0;
8197 wstats->qual.level = 0;
8199 if (ipw2100_get_ordinal(priv, IPW_ORD_RSSI_AVG_CURR,
8201 goto fail_get_ordinal;
8202 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM;
8204 rssi_qual = rssi * POOR / 10;
8206 rssi_qual = (rssi - 10) * (FAIR - POOR) / 5 + POOR;
8208 rssi_qual = (rssi - 15) * (GOOD - FAIR) / 5 + FAIR;
8210 rssi_qual = (rssi - 20) * (VERY_GOOD - GOOD) /
8213 rssi_qual = (rssi - 30) * (PERFECT - VERY_GOOD) /
8216 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_PERCENT_RETRIES,
8217 &tx_retries, &ord_len))
8218 goto fail_get_ordinal;
8220 if (tx_retries > 75)
8221 tx_qual = (90 - tx_retries) * POOR / 15;
8222 else if (tx_retries > 70)
8223 tx_qual = (75 - tx_retries) * (FAIR - POOR) / 5 + POOR;
8224 else if (tx_retries > 65)
8225 tx_qual = (70 - tx_retries) * (GOOD - FAIR) / 5 + FAIR;
8226 else if (tx_retries > 50)
8227 tx_qual = (65 - tx_retries) * (VERY_GOOD - GOOD) /
8230 tx_qual = (50 - tx_retries) *
8231 (PERFECT - VERY_GOOD) / 50 + VERY_GOOD;
8233 if (missed_beacons > 50)
8234 beacon_qual = (60 - missed_beacons) * POOR / 10;
8235 else if (missed_beacons > 40)
8236 beacon_qual = (50 - missed_beacons) * (FAIR - POOR) /
8238 else if (missed_beacons > 32)
8239 beacon_qual = (40 - missed_beacons) * (GOOD - FAIR) /
8241 else if (missed_beacons > 20)
8242 beacon_qual = (32 - missed_beacons) *
8243 (VERY_GOOD - GOOD) / 20 + GOOD;
8245 beacon_qual = (20 - missed_beacons) *
8246 (PERFECT - VERY_GOOD) / 20 + VERY_GOOD;
8248 quality = min(beacon_qual, min(tx_qual, rssi_qual));
8250 #ifdef CONFIG_IPW2100_DEBUG
8251 if (beacon_qual == quality)
8252 IPW_DEBUG_WX("Quality clamped by Missed Beacons\n");
8253 else if (tx_qual == quality)
8254 IPW_DEBUG_WX("Quality clamped by Tx Retries\n");
8255 else if (quality != 100)
8256 IPW_DEBUG_WX("Quality clamped by Signal Strength\n");
8258 IPW_DEBUG_WX("Quality not clamped.\n");
8261 wstats->qual.qual = quality;
8262 wstats->qual.level = rssi + IPW2100_RSSI_TO_DBM;
8265 wstats->qual.noise = 0;
8266 wstats->qual.updated = 7;
8267 wstats->qual.updated |= IW_QUAL_NOISE_INVALID;
8269 /* FIXME: this is percent and not a # */
8270 wstats->miss.beacon = missed_beacons;
8272 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURES,
8273 &tx_failures, &ord_len))
8274 goto fail_get_ordinal;
8275 wstats->discard.retries = tx_failures;
8280 IPW_DEBUG_WX("failed querying ordinals.\n");
8282 return (struct iw_statistics *)NULL;
8285 static struct iw_handler_def ipw2100_wx_handler_def = {
8286 .standard = ipw2100_wx_handlers,
8287 .num_standard = ARRAY_SIZE(ipw2100_wx_handlers),
8288 .num_private = ARRAY_SIZE(ipw2100_private_handler),
8289 .num_private_args = ARRAY_SIZE(ipw2100_private_args),
8290 .private = (iw_handler *) ipw2100_private_handler,
8291 .private_args = (struct iw_priv_args *)ipw2100_private_args,
8292 .get_wireless_stats = ipw2100_wx_wireless_stats,
8295 static void ipw2100_wx_event_work(struct work_struct *work)
8297 struct ipw2100_priv *priv =
8298 container_of(work, struct ipw2100_priv, wx_event_work.work);
8299 union iwreq_data wrqu;
8302 if (priv->status & STATUS_STOPPING)
8305 mutex_lock(&priv->action_mutex);
8307 IPW_DEBUG_WX("enter\n");
8309 mutex_unlock(&priv->action_mutex);
8311 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
8313 /* Fetch BSSID from the hardware */
8314 if (!(priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) ||
8315 priv->status & STATUS_RF_KILL_MASK ||
8316 ipw2100_get_ordinal(priv, IPW_ORD_STAT_ASSN_AP_BSSID,
8317 &priv->bssid, &len)) {
8318 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
8320 /* We now have the BSSID, so can finish setting to the full
8321 * associated state */
8322 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
8323 memcpy(priv->ieee->bssid, priv->bssid, ETH_ALEN);
8324 priv->status &= ~STATUS_ASSOCIATING;
8325 priv->status |= STATUS_ASSOCIATED;
8326 netif_carrier_on(priv->net_dev);
8327 netif_wake_queue(priv->net_dev);
8330 if (!(priv->status & STATUS_ASSOCIATED)) {
8331 IPW_DEBUG_WX("Configuring ESSID\n");
8332 mutex_lock(&priv->action_mutex);
8333 /* This is a disassociation event, so kick the firmware to
8334 * look for another AP */
8335 if (priv->config & CFG_STATIC_ESSID)
8336 ipw2100_set_essid(priv, priv->essid, priv->essid_len,
8339 ipw2100_set_essid(priv, NULL, 0, 0);
8340 mutex_unlock(&priv->action_mutex);
8343 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
8346 #define IPW2100_FW_MAJOR_VERSION 1
8347 #define IPW2100_FW_MINOR_VERSION 3
8349 #define IPW2100_FW_MINOR(x) ((x & 0xff) >> 8)
8350 #define IPW2100_FW_MAJOR(x) (x & 0xff)
8352 #define IPW2100_FW_VERSION ((IPW2100_FW_MINOR_VERSION << 8) | \
8353 IPW2100_FW_MAJOR_VERSION)
8355 #define IPW2100_FW_PREFIX "ipw2100-" __stringify(IPW2100_FW_MAJOR_VERSION) \
8356 "." __stringify(IPW2100_FW_MINOR_VERSION)
8358 #define IPW2100_FW_NAME(x) IPW2100_FW_PREFIX "" x ".fw"
8362 BINARY FIRMWARE HEADER FORMAT
8366 2 2 mode == 0:BSS,1:IBSS,2:MONITOR
8369 C fw_len firmware data
8370 12 + fw_len uc_len microcode data
8374 struct ipw2100_fw_header {
8377 unsigned int fw_size;
8378 unsigned int uc_size;
8379 } __attribute__ ((packed));
8381 static int ipw2100_mod_firmware_load(struct ipw2100_fw *fw)
8383 struct ipw2100_fw_header *h =
8384 (struct ipw2100_fw_header *)fw->fw_entry->data;
8386 if (IPW2100_FW_MAJOR(h->version) != IPW2100_FW_MAJOR_VERSION) {
8387 printk(KERN_WARNING DRV_NAME ": Firmware image not compatible "
8388 "(detected version id of %u). "
8389 "See Documentation/networking/README.ipw2100\n",
8394 fw->version = h->version;
8395 fw->fw.data = fw->fw_entry->data + sizeof(struct ipw2100_fw_header);
8396 fw->fw.size = h->fw_size;
8397 fw->uc.data = fw->fw.data + h->fw_size;
8398 fw->uc.size = h->uc_size;
8403 static int ipw2100_get_firmware(struct ipw2100_priv *priv,
8404 struct ipw2100_fw *fw)
8409 IPW_DEBUG_INFO("%s: Using hotplug firmware load.\n",
8410 priv->net_dev->name);
8412 switch (priv->ieee->iw_mode) {
8414 fw_name = IPW2100_FW_NAME("-i");
8416 #ifdef CONFIG_IPW2100_MONITOR
8417 case IW_MODE_MONITOR:
8418 fw_name = IPW2100_FW_NAME("-p");
8423 fw_name = IPW2100_FW_NAME("");
8427 rc = request_firmware(&fw->fw_entry, fw_name, &priv->pci_dev->dev);
8430 printk(KERN_ERR DRV_NAME ": "
8431 "%s: Firmware '%s' not available or load failed.\n",
8432 priv->net_dev->name, fw_name);
8435 IPW_DEBUG_INFO("firmware data %p size %zd\n", fw->fw_entry->data,
8436 fw->fw_entry->size);
8438 ipw2100_mod_firmware_load(fw);
8443 static void ipw2100_release_firmware(struct ipw2100_priv *priv,
8444 struct ipw2100_fw *fw)
8448 release_firmware(fw->fw_entry);
8449 fw->fw_entry = NULL;
8452 static int ipw2100_get_fwversion(struct ipw2100_priv *priv, char *buf,
8455 char ver[MAX_FW_VERSION_LEN];
8456 u32 len = MAX_FW_VERSION_LEN;
8459 /* firmware version is an ascii string (max len of 14) */
8460 if (ipw2100_get_ordinal(priv, IPW_ORD_STAT_FW_VER_NUM, ver, &len))
8465 for (i = 0; i < len; i++)
8471 static int ipw2100_get_ucodeversion(struct ipw2100_priv *priv, char *buf,
8475 u32 len = sizeof(ver);
8476 /* microcode version is a 32 bit integer */
8477 if (ipw2100_get_ordinal(priv, IPW_ORD_UCODE_VERSION, &ver, &len))
8479 return snprintf(buf, max, "%08X", ver);
8483 * On exit, the firmware will have been freed from the fw list
8485 static int ipw2100_fw_download(struct ipw2100_priv *priv, struct ipw2100_fw *fw)
8487 /* firmware is constructed of N contiguous entries, each entry is
8491 * 0 4 address to write to
8492 * 4 2 length of data run
8498 const unsigned char *firmware_data = fw->fw.data;
8499 unsigned int firmware_data_left = fw->fw.size;
8501 while (firmware_data_left > 0) {
8502 addr = *(u32 *) (firmware_data);
8504 firmware_data_left -= 4;
8506 len = *(u16 *) (firmware_data);
8508 firmware_data_left -= 2;
8511 printk(KERN_ERR DRV_NAME ": "
8512 "Invalid firmware run-length of %d bytes\n",
8517 write_nic_memory(priv->net_dev, addr, len, firmware_data);
8518 firmware_data += len;
8519 firmware_data_left -= len;
8525 struct symbol_alive_response {
8534 u16 clock_settle_time; // 1us LSB
8535 u16 powerup_settle_time; // 1us LSB
8536 u16 hop_settle_time; // 1us LSB
8537 u8 date[3]; // month, day, year
8538 u8 time[2]; // hours, minutes
8542 static int ipw2100_ucode_download(struct ipw2100_priv *priv,
8543 struct ipw2100_fw *fw)
8545 struct net_device *dev = priv->net_dev;
8546 const unsigned char *microcode_data = fw->uc.data;
8547 unsigned int microcode_data_left = fw->uc.size;
8548 void __iomem *reg = (void __iomem *)dev->base_addr;
8550 struct symbol_alive_response response;
8554 /* Symbol control */
8555 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703);
8557 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707);
8561 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */
8563 write_nic_byte(dev, 0x210014, 0x72); /* fifo width =16 */
8566 /* EN_CS_ACCESS bit to reset control store pointer */
8567 write_nic_byte(dev, 0x210000, 0x40);
8569 write_nic_byte(dev, 0x210000, 0x0);
8571 write_nic_byte(dev, 0x210000, 0x40);
8574 /* copy microcode from buffer into Symbol */
8576 while (microcode_data_left > 0) {
8577 write_nic_byte(dev, 0x210010, *microcode_data++);
8578 write_nic_byte(dev, 0x210010, *microcode_data++);
8579 microcode_data_left -= 2;
8582 /* EN_CS_ACCESS bit to reset the control store pointer */
8583 write_nic_byte(dev, 0x210000, 0x0);
8586 /* Enable System (Reg 0)
8587 * first enable causes garbage in RX FIFO */
8588 write_nic_byte(dev, 0x210000, 0x0);
8590 write_nic_byte(dev, 0x210000, 0x80);
8593 /* Reset External Baseband Reg */
8594 write_nic_word(dev, IPW2100_CONTROL_REG, 0x703);
8596 write_nic_word(dev, IPW2100_CONTROL_REG, 0x707);
8599 /* HW Config (Reg 5) */
8600 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16
8602 write_nic_byte(dev, 0x210014, 0x72); // fifo width =16
8605 /* Enable System (Reg 0)
8606 * second enable should be OK */
8607 write_nic_byte(dev, 0x210000, 0x00); // clear enable system
8609 write_nic_byte(dev, 0x210000, 0x80); // set enable system
8611 /* check Symbol is enabled - upped this from 5 as it wasn't always
8612 * catching the update */
8613 for (i = 0; i < 10; i++) {
8616 /* check Dino is enabled bit */
8617 read_nic_byte(dev, 0x210000, &data);
8623 printk(KERN_ERR DRV_NAME ": %s: Error initializing Symbol\n",
8628 /* Get Symbol alive response */
8629 for (i = 0; i < 30; i++) {
8630 /* Read alive response structure */
8632 j < (sizeof(struct symbol_alive_response) >> 1); j++)
8633 read_nic_word(dev, 0x210004, ((u16 *) & response) + j);
8635 if ((response.cmd_id == 1) && (response.ucode_valid == 0x1))
8641 printk(KERN_ERR DRV_NAME
8642 ": %s: No response from Symbol - hw not alive\n",
8644 printk_buf(IPW_DL_ERROR, (u8 *) & response, sizeof(response));
git://ftp.safe.ca / safe / jmp / linux-2.6 / blob