brintos / linux-shallow public Read only

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