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