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