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#define __KERNEL_SYSCALLS__
68
69
70
71
72#include <wl_version.h>
73
74#include <linux/module.h>
75#include <linux/proc_fs.h>
76#include <linux/seq_file.h>
77#include <linux/types.h>
78#include <linux/kernel.h>
79
80
81
82
83
84
85
86
87
88
89
90
91#include <linux/unistd.h>
92#include <asm/uaccess.h>
93
94#include <linux/netdevice.h>
95#include <linux/etherdevice.h>
96
97
98
99
100#define BIN_DL 0
101#if BIN_DL
102#include <linux/vmalloc.h>
103#endif
104
105
106#include <debug.h>
107
108#include <hcf.h>
109#include <dhf.h>
110
111#include <hcfdef.h>
112
113#include <wl_if.h>
114#include <wl_internal.h>
115#include <wl_util.h>
116#include <wl_main.h>
117#include <wl_netdev.h>
118#include <wl_wext.h>
119
120#ifdef USE_PROFILE
121#include <wl_profile.h>
122#endif
123
124#ifdef BUS_PCMCIA
125#include <wl_cs.h>
126#endif
127
128#ifdef BUS_PCI
129#include <wl_pci.h>
130#endif
131
132
133
134#define VALID_PARAM(C) \
135 { \
136 if (!(C)) \
137 { \
138 printk(KERN_INFO "Wireless, parameter error: \"%s\"\n", #C); \
139 goto failed; \
140 } \
141 }
142
143
144
145void wl_isr_handler( unsigned long p );
146
147#if 0
148static int scull_read_procmem(struct seq_file *m, void *v);
149static int write_int(struct file *file, const char *buffer, unsigned long count, void *data);
150
151
152
153
154static int scull_read_procmem_open(struct inode *inode, struct file *file)
155{
156 return single_open(file, scull_read_procmem, PDE_DATA(inode));
157}
158
159static const struct file_operations scull_read_procmem_fops = {
160 .open = scull_read_procmem_open,
161 .read = seq_read,
162 .llseek = seq_lseek,
163 .release = single_release,
164};
165
166#endif
167
168
169
170
171static p_u16 irq_mask = 0xdeb8;
172static p_s8 irq_list[4] = { -1 };
173
174#if 0
175MODULE_PARM(irq_mask, "h");
176MODULE_PARM_DESC(irq_mask, "IRQ mask [0xdeb8]");
177MODULE_PARM(irq_list, "1-4b");
178MODULE_PARM_DESC(irq_list, "IRQ list [<irq_mask>]");
179#endif
180
181static p_u8 PARM_AUTHENTICATION = PARM_DEFAULT_AUTHENTICATION;
182static p_u16 PARM_AUTH_KEY_MGMT_SUITE = PARM_DEFAULT_AUTH_KEY_MGMT_SUITE;
183static p_u16 PARM_BRSC_2GHZ = PARM_DEFAULT_BRSC_2GHZ;
184static p_u16 PARM_BRSC_5GHZ = PARM_DEFAULT_BRSC_5GHZ;
185static p_u16 PARM_COEXISTENCE = PARM_DEFAULT_COEXISTENCE;
186static p_u16 PARM_CONNECTION_CONTROL = PARM_DEFAULT_CONNECTION_CONTROL;
187static p_char *PARM_CREATE_IBSS = PARM_DEFAULT_CREATE_IBSS_STR;
188static p_char *PARM_DESIRED_SSID = PARM_DEFAULT_SSID;
189static p_char *PARM_DOWNLOAD_FIRMWARE = "";
190static p_u16 PARM_ENABLE_ENCRYPTION = PARM_DEFAULT_ENABLE_ENCRYPTION;
191static p_char *PARM_EXCLUDE_UNENCRYPTED = PARM_DEFAULT_EXCLUDE_UNENCRYPTED_STR;
192static p_char *PARM_INTRA_BSS_RELAY = PARM_DEFAULT_INTRA_BSS_RELAY_STR;
193static p_char *PARM_KEY1 = "";
194static p_char *PARM_KEY2 = "";
195static p_char *PARM_KEY3 = "";
196static p_char *PARM_KEY4 = "";
197static p_char *PARM_LOAD_BALANCING = PARM_DEFAULT_LOAD_BALANCING_STR;
198static p_u16 PARM_MAX_SLEEP = PARM_DEFAULT_MAX_PM_SLEEP;
199static p_char *PARM_MEDIUM_DISTRIBUTION = PARM_DEFAULT_MEDIUM_DISTRIBUTION_STR;
200static p_char *PARM_MICROWAVE_ROBUSTNESS = PARM_DEFAULT_MICROWAVE_ROBUSTNESS_STR;
201static p_char *PARM_MULTICAST_PM_BUFFERING = PARM_DEFAULT_MULTICAST_PM_BUFFERING_STR;
202static p_u16 PARM_MULTICAST_RATE = PARM_DEFAULT_MULTICAST_RATE_2GHZ;
203static p_char *PARM_MULTICAST_RX = PARM_DEFAULT_MULTICAST_RX_STR;
204static p_u8 PARM_NETWORK_ADDR[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
205static p_u16 PARM_OWN_ATIM_WINDOW = PARM_DEFAULT_OWN_ATIM_WINDOW;
206static p_u16 PARM_OWN_BEACON_INTERVAL = PARM_DEFAULT_OWN_BEACON_INTERVAL;
207static p_u8 PARM_OWN_CHANNEL = PARM_DEFAULT_OWN_CHANNEL;
208static p_u8 PARM_OWN_DTIM_PERIOD = PARM_DEFAULT_OWN_DTIM_PERIOD;
209static p_char *PARM_OWN_NAME = PARM_DEFAULT_OWN_NAME;
210static p_char *PARM_OWN_SSID = PARM_DEFAULT_SSID;
211static p_u16 PARM_PM_ENABLED = WVLAN_PM_STATE_DISABLED;
212static p_u16 PARM_PM_HOLDOVER_DURATION = PARM_DEFAULT_PM_HOLDOVER_DURATION;
213static p_u8 PARM_PORT_TYPE = PARM_DEFAULT_PORT_TYPE;
214static p_char *PARM_PROMISCUOUS_MODE = PARM_DEFAULT_PROMISCUOUS_MODE_STR;
215static p_char *PARM_REJECT_ANY = PARM_DEFAULT_REJECT_ANY_STR;
216#ifdef USE_WDS
217static p_u16 PARM_RTS_THRESHOLD1 = PARM_DEFAULT_RTS_THRESHOLD;
218static p_u16 PARM_RTS_THRESHOLD2 = PARM_DEFAULT_RTS_THRESHOLD;
219static p_u16 PARM_RTS_THRESHOLD3 = PARM_DEFAULT_RTS_THRESHOLD;
220static p_u16 PARM_RTS_THRESHOLD4 = PARM_DEFAULT_RTS_THRESHOLD;
221static p_u16 PARM_RTS_THRESHOLD5 = PARM_DEFAULT_RTS_THRESHOLD;
222static p_u16 PARM_RTS_THRESHOLD6 = PARM_DEFAULT_RTS_THRESHOLD;
223#endif
224static p_u16 PARM_RTS_THRESHOLD = PARM_DEFAULT_RTS_THRESHOLD;
225static p_u16 PARM_SRSC_2GHZ = PARM_DEFAULT_SRSC_2GHZ;
226static p_u16 PARM_SRSC_5GHZ = PARM_DEFAULT_SRSC_5GHZ;
227static p_u8 PARM_SYSTEM_SCALE = PARM_DEFAULT_SYSTEM_SCALE;
228static p_u8 PARM_TX_KEY = PARM_DEFAULT_TX_KEY;
229static p_u16 PARM_TX_POW_LEVEL = PARM_DEFAULT_TX_POW_LEVEL;
230#ifdef USE_WDS
231static p_u16 PARM_TX_RATE1 = PARM_DEFAULT_TX_RATE_2GHZ;
232static p_u16 PARM_TX_RATE2 = PARM_DEFAULT_TX_RATE_2GHZ;
233static p_u16 PARM_TX_RATE3 = PARM_DEFAULT_TX_RATE_2GHZ;
234static p_u16 PARM_TX_RATE4 = PARM_DEFAULT_TX_RATE_2GHZ;
235static p_u16 PARM_TX_RATE5 = PARM_DEFAULT_TX_RATE_2GHZ;
236static p_u16 PARM_TX_RATE6 = PARM_DEFAULT_TX_RATE_2GHZ;
237#endif
238static p_u16 PARM_TX_RATE = PARM_DEFAULT_TX_RATE_2GHZ;
239#ifdef USE_WDS
240static p_u8 PARM_WDS_ADDRESS1[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
241static p_u8 PARM_WDS_ADDRESS2[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
242static p_u8 PARM_WDS_ADDRESS3[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
243static p_u8 PARM_WDS_ADDRESS4[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
244static p_u8 PARM_WDS_ADDRESS5[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
245static p_u8 PARM_WDS_ADDRESS6[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
246#endif
247
248
249#if 0
250MODULE_PARM(PARM_DESIRED_SSID, "s");
251MODULE_PARM_DESC(PARM_DESIRED_SSID, "Network Name (<string>) [ANY]");
252MODULE_PARM(PARM_OWN_SSID, "s");
253MODULE_PARM_DESC(PARM_OWN_SSID, "Network Name (<string>) [ANY]");
254MODULE_PARM(PARM_OWN_CHANNEL, "b");
255MODULE_PARM_DESC(PARM_OWN_CHANNEL, "Channel (0 - 14) [0]");
256MODULE_PARM(PARM_SYSTEM_SCALE, "b");
257MODULE_PARM_DESC(PARM_SYSTEM_SCALE, "Distance Between APs (1 - 3) [1]");
258MODULE_PARM(PARM_TX_RATE, "b");
259MODULE_PARM_DESC(PARM_TX_RATE, "Transmit Rate Control");
260MODULE_PARM(PARM_RTS_THRESHOLD, "h");
261MODULE_PARM_DESC(PARM_RTS_THRESHOLD, "Medium Reservation (RTS/CTS Fragment Length) (256 - 2347) [2347]");
262MODULE_PARM(PARM_MICROWAVE_ROBUSTNESS, "s");
263MODULE_PARM_DESC(PARM_MICROWAVE_ROBUSTNESS, "Microwave Oven Robustness Enabled (<string> N or Y) [N]");
264MODULE_PARM(PARM_OWN_NAME, "s");
265MODULE_PARM_DESC(PARM_OWN_NAME, "Station Name (<string>) [Linux]");
266
267MODULE_PARM(PARM_ENABLE_ENCRYPTION, "b");
268MODULE_PARM_DESC(PARM_ENABLE_ENCRYPTION, "Encryption Mode (0 - 7) [0]");
269
270MODULE_PARM(PARM_KEY1, "s");
271MODULE_PARM_DESC(PARM_KEY1, "Data Encryption Key 1 (<string>) []");
272MODULE_PARM(PARM_KEY2, "s");
273MODULE_PARM_DESC(PARM_KEY2, "Data Encryption Key 2 (<string>) []");
274MODULE_PARM(PARM_KEY3, "s");
275MODULE_PARM_DESC(PARM_KEY3, "Data Encryption Key 3 (<string>) []");
276MODULE_PARM(PARM_KEY4, "s");
277MODULE_PARM_DESC(PARM_KEY4, "Data Encryption Key 4 (<string>) []");
278MODULE_PARM(PARM_TX_KEY, "b");
279MODULE_PARM_DESC(PARM_TX_KEY, "Transmit Key ID (1 - 4) [1]");
280MODULE_PARM(PARM_MULTICAST_RATE, "b");
281MODULE_PARM_DESC(PARM_MULTICAST_RATE, "Multicast Rate");
282MODULE_PARM(PARM_DOWNLOAD_FIRMWARE, "s");
283MODULE_PARM_DESC(PARM_DOWNLOAD_FIRMWARE, "filename of firmware image");
284
285MODULE_PARM(PARM_AUTH_KEY_MGMT_SUITE, "b");
286MODULE_PARM_DESC(PARM_AUTH_KEY_MGMT_SUITE, "Authentication Key Management suite (0-4) [0]");
287
288MODULE_PARM(PARM_LOAD_BALANCING, "s");
289MODULE_PARM_DESC(PARM_LOAD_BALANCING, "Load Balancing Enabled (<string> N or Y) [Y]");
290MODULE_PARM(PARM_MEDIUM_DISTRIBUTION, "s");
291MODULE_PARM_DESC(PARM_MEDIUM_DISTRIBUTION, "Medium Distribution Enabled (<string> N or Y) [Y]");
292MODULE_PARM(PARM_TX_POW_LEVEL, "b");
293MODULE_PARM_DESC(PARM_TX_POW_LEVEL, "Transmit Power (0 - 6) [3]");
294MODULE_PARM(PARM_SRSC_2GHZ, "b");
295MODULE_PARM_DESC(PARM_SRSC_2GHZ, "Supported Rate Set Control 2.4 GHz");
296MODULE_PARM(PARM_SRSC_5GHZ, "b");
297MODULE_PARM_DESC(PARM_SRSC_5GHZ, "Supported Rate Set Control 5.0 GHz");
298MODULE_PARM(PARM_BRSC_2GHZ, "b");
299MODULE_PARM_DESC(PARM_BRSC_2GHZ, "Basic Rate Set Control 2.4 GHz");
300MODULE_PARM(PARM_BRSC_5GHZ, "b");
301MODULE_PARM_DESC(PARM_BRSC_5GHZ, "Basic Rate Set Control 5.0 GHz");
302#if 1
303
304MODULE_PARM(PARM_PM_ENABLED, "h");
305MODULE_PARM_DESC(PARM_PM_ENABLED, "Power Management State (0 - 2, 8001 - 8002) [0]");
306MODULE_PARM(PARM_PORT_TYPE, "b");
307MODULE_PARM_DESC(PARM_PORT_TYPE, "Port Type (1 - 3) [1]");
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330MODULE_PARM(PARM_CONNECTION_CONTROL, "b");
331MODULE_PARM_DESC(PARM_CONNECTION_CONTROL, "Connection Control (0 - 3) [2]");
332#endif
333#if 1
334
335MODULE_PARM(PARM_OWN_DTIM_PERIOD, "b");
336MODULE_PARM_DESC(PARM_OWN_DTIM_PERIOD, "DTIM Period (0 - 255) [1]");
337MODULE_PARM(PARM_REJECT_ANY, "s");
338MODULE_PARM_DESC(PARM_REJECT_ANY, "Closed System (<string> N or Y) [N]");
339MODULE_PARM(PARM_EXCLUDE_UNENCRYPTED, "s");
340MODULE_PARM_DESC(PARM_EXCLUDE_UNENCRYPTED, "Deny non-encrypted (<string> N or Y) [Y]");
341MODULE_PARM(PARM_MULTICAST_PM_BUFFERING,"s");
342MODULE_PARM_DESC(PARM_MULTICAST_PM_BUFFERING, "Buffer MAC frames for Tx after DTIM (<string> Y or N) [Y]");
343MODULE_PARM(PARM_INTRA_BSS_RELAY, "s");
344MODULE_PARM_DESC(PARM_INTRA_BSS_RELAY, "IntraBSS Relay (<string> N or Y) [Y]");
345MODULE_PARM(PARM_RTS_THRESHOLD1, "h");
346MODULE_PARM_DESC(PARM_RTS_THRESHOLD1, "RTS Threshold, WDS Port 1 (256 - 2347) [2347]");
347MODULE_PARM(PARM_RTS_THRESHOLD2, "h");
348MODULE_PARM_DESC(PARM_RTS_THRESHOLD2, "RTS Threshold, WDS Port 2 (256 - 2347) [2347]");
349MODULE_PARM(PARM_RTS_THRESHOLD3, "h");
350MODULE_PARM_DESC(PARM_RTS_THRESHOLD3, "RTS Threshold, WDS Port 3 (256 - 2347) [2347]");
351MODULE_PARM(PARM_RTS_THRESHOLD4, "h");
352MODULE_PARM_DESC(PARM_RTS_THRESHOLD4, "RTS Threshold, WDS Port 4 (256 - 2347) [2347]");
353MODULE_PARM(PARM_RTS_THRESHOLD5, "h");
354MODULE_PARM_DESC(PARM_RTS_THRESHOLD5, "RTS Threshold, WDS Port 5 (256 - 2347) [2347]");
355MODULE_PARM(PARM_RTS_THRESHOLD6, "h");
356MODULE_PARM_DESC(PARM_RTS_THRESHOLD6, "RTS Threshold, WDS Port 6 (256 - 2347) [2347]");
357MODULE_PARM(PARM_TX_RATE1, "b");
358MODULE_PARM_DESC(PARM_TX_RATE1, "Transmit Rate Control, WDS Port 1 (1 - 7) [3]");
359MODULE_PARM(PARM_TX_RATE2, "b");
360MODULE_PARM_DESC(PARM_TX_RATE2, "Transmit Rate Control, WDS Port 2 (1 - 7) [3]");
361MODULE_PARM(PARM_TX_RATE3, "b");
362MODULE_PARM_DESC(PARM_TX_RATE3, "Transmit Rate Control, WDS Port 3 (1 - 7) [3]");
363MODULE_PARM(PARM_TX_RATE4, "b");
364MODULE_PARM_DESC(PARM_TX_RATE4, "Transmit Rate Control, WDS Port 4 (1 - 7) [3]");
365MODULE_PARM(PARM_TX_RATE5, "b");
366MODULE_PARM_DESC(PARM_TX_RATE5, "Transmit Rate Control, WDS Port 5 (1 - 7) [3]");
367MODULE_PARM(PARM_TX_RATE6, "b");
368MODULE_PARM_DESC(PARM_TX_RATE6, "Transmit Rate Control, WDS Port 6 (1 - 7) [3]");
369MODULE_PARM(PARM_WDS_ADDRESS1, "6b");
370MODULE_PARM_DESC(PARM_WDS_ADDRESS1, "MAC Address, WDS Port 1 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
371MODULE_PARM(PARM_WDS_ADDRESS2, "6b");
372MODULE_PARM_DESC(PARM_WDS_ADDRESS2, "MAC Address, WDS Port 2 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
373MODULE_PARM(PARM_WDS_ADDRESS3, "6b");
374MODULE_PARM_DESC(PARM_WDS_ADDRESS3, "MAC Address, WDS Port 3 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
375MODULE_PARM(PARM_WDS_ADDRESS4, "6b");
376MODULE_PARM_DESC(PARM_WDS_ADDRESS4, "MAC Address, WDS Port 4 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
377MODULE_PARM(PARM_WDS_ADDRESS5, "6b");
378MODULE_PARM_DESC(PARM_WDS_ADDRESS5, "MAC Address, WDS Port 5 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
379MODULE_PARM(PARM_WDS_ADDRESS6, "6b");
380MODULE_PARM_DESC(PARM_WDS_ADDRESS6, "MAC Address, WDS Port 6 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
381
382MODULE_PARM(PARM_OWN_BEACON_INTERVAL, "b");
383MODULE_PARM_DESC(PARM_OWN_BEACON_INTERVAL, "Own Beacon Interval (20 - 200) [100]");
384MODULE_PARM(PARM_COEXISTENCE, "b");
385MODULE_PARM_DESC(PARM_COEXISTENCE, "Coexistence (0-7) [0]");
386
387#endif
388#endif
389
390
391
392
393
394#if DBG
395
396static p_u32 pc_debug = DBG_LVL;
397
398
399
400 p_u32 DebugFlag = ~0;
401
402
403dbg_info_t wl_info = { DBG_MOD_NAME, 0, 0 };
404dbg_info_t *DbgInfo = &wl_info;
405
406#endif
407#ifdef USE_RTS
408
409static p_char *useRTS = "N";
410MODULE_PARM( useRTS, "s" );
411MODULE_PARM_DESC( useRTS, "Use RTS test interface (<string> N or Y) [N]" );
412
413#endif
414
415
416
417extern struct CFG_RANGE2_STRCT BASED
418 cfg_drv_act_ranges_pri;
419
420#if 0
421extern memimage ap;
422#endif
423
424#if 1
425
426extern memimage fw_image;
427#endif
428
429
430int wl_insert( struct net_device *dev )
431{
432 int result = 0;
433 int hcf_status = HCF_SUCCESS;
434 int i;
435 unsigned long flags = 0;
436 struct wl_private *lp = wl_priv(dev);
437
438 DBG_FUNC( "wl_insert" );
439 DBG_ENTER( DbgInfo );
440
441
442 memset( &( lp->hcfCtx ), 0, sizeof( IFB_STRCT ));
443
444
445 spin_lock_init( &( lp->slock ));
446
447
448
449 lp->is_handling_int = WL_NOT_HANDLING_INT;
450 lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
451
452 lp->dev = dev;
453
454 DBG_PARAM( DbgInfo, "irq_mask", "0x%04x", irq_mask & 0x0FFFF );
455 DBG_PARAM( DbgInfo, "irq_list", "0x%02x 0x%02x 0x%02x 0x%02x",
456 irq_list[0] & 0x0FF, irq_list[1] & 0x0FF,
457 irq_list[2] & 0x0FF, irq_list[3] & 0x0FF );
458 DBG_PARAM( DbgInfo, PARM_NAME_DESIRED_SSID, "\"%s\"", PARM_DESIRED_SSID );
459 DBG_PARAM( DbgInfo, PARM_NAME_OWN_SSID, "\"%s\"", PARM_OWN_SSID );
460 DBG_PARAM( DbgInfo, PARM_NAME_OWN_CHANNEL, "%d", PARM_OWN_CHANNEL);
461 DBG_PARAM( DbgInfo, PARM_NAME_SYSTEM_SCALE, "%d", PARM_SYSTEM_SCALE );
462 DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE, "%d", PARM_TX_RATE );
463 DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD, "%d", PARM_RTS_THRESHOLD );
464 DBG_PARAM( DbgInfo, PARM_NAME_MICROWAVE_ROBUSTNESS, "\"%s\"", PARM_MICROWAVE_ROBUSTNESS );
465 DBG_PARAM( DbgInfo, PARM_NAME_OWN_NAME, "\"%s\"", PARM_OWN_NAME );
466
467 DBG_PARAM( DbgInfo, PARM_NAME_KEY1, "\"%s\"", PARM_KEY1 );
468 DBG_PARAM( DbgInfo, PARM_NAME_KEY2, "\"%s\"", PARM_KEY2 );
469 DBG_PARAM( DbgInfo, PARM_NAME_KEY3, "\"%s\"", PARM_KEY3 );
470 DBG_PARAM( DbgInfo, PARM_NAME_KEY4, "\"%s\"", PARM_KEY4 );
471 DBG_PARAM( DbgInfo, PARM_NAME_TX_KEY, "%d", PARM_TX_KEY );
472 DBG_PARAM( DbgInfo, PARM_NAME_MULTICAST_RATE, "%d", PARM_MULTICAST_RATE );
473 DBG_PARAM( DbgInfo, PARM_NAME_DOWNLOAD_FIRMWARE, "\"%s\"", PARM_DOWNLOAD_FIRMWARE );
474 DBG_PARAM( DbgInfo, PARM_NAME_AUTH_KEY_MGMT_SUITE, "%d", PARM_AUTH_KEY_MGMT_SUITE );
475
476
477
478 DBG_PARAM( DbgInfo, PARM_NAME_PM_ENABLED, "%04x", PARM_PM_ENABLED );
479
480
481
482
483
484
485
486
487
488
489
490
491#if 1
492
493
494 DBG_PARAM( DbgInfo, PARM_NAME_OWN_DTIM_PERIOD, "%d", PARM_OWN_DTIM_PERIOD );
495 DBG_PARAM( DbgInfo, PARM_NAME_REJECT_ANY, "\"%s\"", PARM_REJECT_ANY );
496 DBG_PARAM( DbgInfo, PARM_NAME_EXCLUDE_UNENCRYPTED, "\"%s\"", PARM_EXCLUDE_UNENCRYPTED );
497 DBG_PARAM( DbgInfo, PARM_NAME_MULTICAST_PM_BUFFERING, "\"%s\"", PARM_MULTICAST_PM_BUFFERING );
498 DBG_PARAM( DbgInfo, PARM_NAME_INTRA_BSS_RELAY, "\"%s\"", PARM_INTRA_BSS_RELAY );
499#ifdef USE_WDS
500 DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD1, "%d", PARM_RTS_THRESHOLD1 );
501 DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD2, "%d", PARM_RTS_THRESHOLD2 );
502 DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD3, "%d", PARM_RTS_THRESHOLD3 );
503 DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD4, "%d", PARM_RTS_THRESHOLD4 );
504 DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD5, "%d", PARM_RTS_THRESHOLD5 );
505 DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD6, "%d", PARM_RTS_THRESHOLD6 );
506 DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE1, "%d", PARM_TX_RATE1 );
507 DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE2, "%d", PARM_TX_RATE2 );
508 DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE3, "%d", PARM_TX_RATE3 );
509 DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE4, "%d", PARM_TX_RATE4 );
510 DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE5, "%d", PARM_TX_RATE5 );
511 DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE6, "%d", PARM_TX_RATE6 );
512 DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS1, "\"%pM\"",
513 PARM_WDS_ADDRESS1);
514 DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS2, "\"%pM\"",
515 PARM_WDS_ADDRESS2);
516 DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS3, "\"%pM\"",
517 PARM_WDS_ADDRESS3);
518 DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS4, "\"%pM\"",
519 PARM_WDS_ADDRESS4);
520 DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS5, "\"%pM\"",
521 PARM_WDS_ADDRESS5);
522 DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS6, "\"%pM\"",
523 PARM_WDS_ADDRESS6);
524#endif
525#endif
526
527 VALID_PARAM( !PARM_DESIRED_SSID || ( strlen( PARM_DESIRED_SSID ) <= PARM_MAX_NAME_LEN ));
528 VALID_PARAM( !PARM_OWN_SSID || ( strlen( PARM_OWN_SSID ) <= PARM_MAX_NAME_LEN ));
529 VALID_PARAM(( PARM_OWN_CHANNEL <= PARM_MAX_OWN_CHANNEL ));
530 VALID_PARAM(( PARM_SYSTEM_SCALE >= PARM_MIN_SYSTEM_SCALE ) && ( PARM_SYSTEM_SCALE <= PARM_MAX_SYSTEM_SCALE ));
531 VALID_PARAM(( PARM_TX_RATE >= PARM_MIN_TX_RATE ) && ( PARM_TX_RATE <= PARM_MAX_TX_RATE ));
532 VALID_PARAM(( PARM_RTS_THRESHOLD <= PARM_MAX_RTS_THRESHOLD ));
533 VALID_PARAM( !PARM_MICROWAVE_ROBUSTNESS || strchr( "NnYy", PARM_MICROWAVE_ROBUSTNESS[0] ) != NULL );
534 VALID_PARAM( !PARM_OWN_NAME || ( strlen( PARM_NAME_OWN_NAME ) <= PARM_MAX_NAME_LEN ));
535 VALID_PARAM(( PARM_ENABLE_ENCRYPTION <= PARM_MAX_ENABLE_ENCRYPTION ));
536 VALID_PARAM( is_valid_key_string( PARM_KEY1 ));
537 VALID_PARAM( is_valid_key_string( PARM_KEY2 ));
538 VALID_PARAM( is_valid_key_string( PARM_KEY3 ));
539 VALID_PARAM( is_valid_key_string( PARM_KEY4 ));
540 VALID_PARAM(( PARM_TX_KEY >= PARM_MIN_TX_KEY ) && ( PARM_TX_KEY <= PARM_MAX_TX_KEY ));
541
542 VALID_PARAM(( PARM_MULTICAST_RATE >= PARM_MIN_MULTICAST_RATE ) &&
543 ( PARM_MULTICAST_RATE <= PARM_MAX_MULTICAST_RATE ));
544
545 VALID_PARAM( !PARM_DOWNLOAD_FIRMWARE || ( strlen( PARM_DOWNLOAD_FIRMWARE ) <= 255 ));
546 VALID_PARAM(( PARM_AUTH_KEY_MGMT_SUITE < PARM_MAX_AUTH_KEY_MGMT_SUITE ));
547
548 VALID_PARAM( !PARM_LOAD_BALANCING || strchr( "NnYy", PARM_LOAD_BALANCING[0] ) != NULL );
549 VALID_PARAM( !PARM_MEDIUM_DISTRIBUTION || strchr( "NnYy", PARM_MEDIUM_DISTRIBUTION[0] ) != NULL );
550 VALID_PARAM(( PARM_TX_POW_LEVEL <= PARM_MAX_TX_POW_LEVEL ));
551
552 VALID_PARAM(( PARM_PORT_TYPE >= PARM_MIN_PORT_TYPE ) && ( PARM_PORT_TYPE <= PARM_MAX_PORT_TYPE ));
553 VALID_PARAM( PARM_PM_ENABLED <= WVLAN_PM_STATE_STANDARD ||
554 ( PARM_PM_ENABLED & 0x7FFF ) <= WVLAN_PM_STATE_STANDARD );
555 VALID_PARAM( !PARM_CREATE_IBSS || strchr( "NnYy", PARM_CREATE_IBSS[0] ) != NULL );
556 VALID_PARAM( !PARM_MULTICAST_RX || strchr( "NnYy", PARM_MULTICAST_RX[0] ) != NULL );
557 VALID_PARAM(( PARM_MAX_SLEEP <= PARM_MAX_MAX_PM_SLEEP ));
558 VALID_PARAM(( PARM_AUTHENTICATION <= PARM_MAX_AUTHENTICATION ));
559 VALID_PARAM(( PARM_OWN_ATIM_WINDOW <= PARM_MAX_OWN_ATIM_WINDOW ));
560 VALID_PARAM(( PARM_PM_HOLDOVER_DURATION <= PARM_MAX_PM_HOLDOVER_DURATION ));
561 VALID_PARAM( !PARM_PROMISCUOUS_MODE || strchr( "NnYy", PARM_PROMISCUOUS_MODE[0] ) != NULL );
562 VALID_PARAM(( PARM_CONNECTION_CONTROL <= PARM_MAX_CONNECTION_CONTROL ));
563
564 VALID_PARAM(( PARM_OWN_DTIM_PERIOD >= PARM_MIN_OWN_DTIM_PERIOD ));
565 VALID_PARAM( !PARM_REJECT_ANY || strchr( "NnYy", PARM_REJECT_ANY[0] ) != NULL );
566 VALID_PARAM( !PARM_EXCLUDE_UNENCRYPTED || strchr( "NnYy", PARM_EXCLUDE_UNENCRYPTED[0] ) != NULL );
567 VALID_PARAM( !PARM_MULTICAST_PM_BUFFERING || strchr( "NnYy", PARM_MULTICAST_PM_BUFFERING[0] ) != NULL );
568 VALID_PARAM( !PARM_INTRA_BSS_RELAY || strchr( "NnYy", PARM_INTRA_BSS_RELAY[0] ) != NULL );
569#ifdef USE_WDS
570 VALID_PARAM(( PARM_RTS_THRESHOLD1 <= PARM_MAX_RTS_THRESHOLD ));
571 VALID_PARAM(( PARM_RTS_THRESHOLD2 <= PARM_MAX_RTS_THRESHOLD ));
572 VALID_PARAM(( PARM_RTS_THRESHOLD3 <= PARM_MAX_RTS_THRESHOLD ));
573 VALID_PARAM(( PARM_RTS_THRESHOLD4 <= PARM_MAX_RTS_THRESHOLD ));
574 VALID_PARAM(( PARM_RTS_THRESHOLD5 <= PARM_MAX_RTS_THRESHOLD ));
575 VALID_PARAM(( PARM_RTS_THRESHOLD6 <= PARM_MAX_RTS_THRESHOLD ));
576 VALID_PARAM(( PARM_TX_RATE1 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE1 <= PARM_MAX_TX_RATE ));
577 VALID_PARAM(( PARM_TX_RATE2 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE2 <= PARM_MAX_TX_RATE ));
578 VALID_PARAM(( PARM_TX_RATE3 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE3 <= PARM_MAX_TX_RATE ));
579 VALID_PARAM(( PARM_TX_RATE4 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE4 <= PARM_MAX_TX_RATE ));
580 VALID_PARAM(( PARM_TX_RATE5 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE5 <= PARM_MAX_TX_RATE ));
581 VALID_PARAM(( PARM_TX_RATE6 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE6 <= PARM_MAX_TX_RATE ));
582#endif
583
584 VALID_PARAM(( PARM_OWN_BEACON_INTERVAL >= PARM_MIN_OWN_BEACON_INTERVAL ) && ( PARM_OWN_BEACON_INTERVAL <= PARM_MAX_OWN_BEACON_INTERVAL ));
585 VALID_PARAM(( PARM_COEXISTENCE <= PARM_COEXISTENCE ));
586
587
588
589
590
591
592
593
594 lp->Channel = PARM_OWN_CHANNEL;
595 lp->DistanceBetweenAPs = PARM_SYSTEM_SCALE;
596
597
598 lp->TxRateControl[0] = PARM_DEFAULT_TX_RATE_2GHZ;
599 lp->TxRateControl[1] = PARM_DEFAULT_TX_RATE_5GHZ;
600
601 lp->RTSThreshold = PARM_RTS_THRESHOLD;
602
603
604 lp->MulticastRate[0] = PARM_DEFAULT_MULTICAST_RATE_2GHZ;
605 lp->MulticastRate[1] = PARM_DEFAULT_MULTICAST_RATE_5GHZ;
606
607 if ( strchr( "Yy", PARM_MICROWAVE_ROBUSTNESS[0] ) != NULL ) {
608 lp->MicrowaveRobustness = 1;
609 } else {
610 lp->MicrowaveRobustness = 0;
611 }
612 if ( PARM_DESIRED_SSID && ( strlen( PARM_DESIRED_SSID ) <= HCF_MAX_NAME_LEN )) {
613 strcpy( lp->NetworkName, PARM_DESIRED_SSID );
614 }
615 if ( PARM_OWN_SSID && ( strlen( PARM_OWN_SSID ) <= HCF_MAX_NAME_LEN )) {
616 strcpy( lp->NetworkName, PARM_OWN_SSID );
617 }
618 if ( PARM_OWN_NAME && ( strlen( PARM_OWN_NAME ) <= HCF_MAX_NAME_LEN )) {
619 strcpy( lp->StationName, PARM_OWN_NAME );
620 }
621 lp->EnableEncryption = PARM_ENABLE_ENCRYPTION;
622 if ( PARM_KEY1 && ( strlen( PARM_KEY1 ) <= MAX_KEY_LEN )) {
623 strcpy( lp->Key1, PARM_KEY1 );
624 }
625 if ( PARM_KEY2 && ( strlen( PARM_KEY2 ) <= MAX_KEY_LEN )) {
626 strcpy( lp->Key2, PARM_KEY2 );
627 }
628 if ( PARM_KEY3 && ( strlen( PARM_KEY3 ) <= MAX_KEY_LEN )) {
629 strcpy( lp->Key3, PARM_KEY3 );
630 }
631 if ( PARM_KEY4 && ( strlen( PARM_KEY4 ) <= MAX_KEY_LEN )) {
632 strcpy( lp->Key4, PARM_KEY4 );
633 }
634
635 lp->TransmitKeyID = PARM_TX_KEY;
636
637 key_string2key( lp->Key1, &(lp->DefaultKeys.key[0] ));
638 key_string2key( lp->Key2, &(lp->DefaultKeys.key[1] ));
639 key_string2key( lp->Key3, &(lp->DefaultKeys.key[2] ));
640 key_string2key( lp->Key4, &(lp->DefaultKeys.key[3] ));
641
642 lp->DownloadFirmware = 1 ;
643 lp->AuthKeyMgmtSuite = PARM_AUTH_KEY_MGMT_SUITE;
644
645 if ( strchr( "Yy", PARM_LOAD_BALANCING[0] ) != NULL ) {
646 lp->loadBalancing = 1;
647 } else {
648 lp->loadBalancing = 0;
649 }
650
651 if ( strchr( "Yy", PARM_MEDIUM_DISTRIBUTION[0] ) != NULL ) {
652 lp->mediumDistribution = 1;
653 } else {
654 lp->mediumDistribution = 0;
655 }
656
657 lp->txPowLevel = PARM_TX_POW_LEVEL;
658
659 lp->srsc[0] = PARM_SRSC_2GHZ;
660 lp->srsc[1] = PARM_SRSC_5GHZ;
661 lp->brsc[0] = PARM_BRSC_2GHZ;
662 lp->brsc[1] = PARM_BRSC_5GHZ;
663#if 1
664
665 lp->PortType = PARM_PORT_TYPE;
666 lp->MaxSleepDuration = PARM_MAX_SLEEP;
667 lp->authentication = PARM_AUTHENTICATION;
668 lp->atimWindow = PARM_OWN_ATIM_WINDOW;
669 lp->holdoverDuration = PARM_PM_HOLDOVER_DURATION;
670 lp->PMEnabled = PARM_PM_ENABLED;
671 if ( strchr( "Yy", PARM_CREATE_IBSS[0] ) != NULL ) {
672 lp->CreateIBSS = 1;
673 } else {
674 lp->CreateIBSS = 0;
675 }
676 if ( strchr( "Nn", PARM_MULTICAST_RX[0] ) != NULL ) {
677 lp->MulticastReceive = 0;
678 } else {
679 lp->MulticastReceive = 1;
680 }
681 if ( strchr( "Yy", PARM_PROMISCUOUS_MODE[0] ) != NULL ) {
682 lp->promiscuousMode = 1;
683 } else {
684 lp->promiscuousMode = 0;
685 }
686 for( i = 0; i < ETH_ALEN; i++ ) {
687 lp->MACAddress[i] = PARM_NETWORK_ADDR[i];
688 }
689
690 lp->connectionControl = PARM_CONNECTION_CONTROL;
691
692#endif
693#if 1
694
695 lp->DTIMPeriod = PARM_OWN_DTIM_PERIOD;
696
697 if ( strchr( "Yy", PARM_REJECT_ANY[0] ) != NULL ) {
698 lp->RejectAny = 1;
699 } else {
700 lp->RejectAny = 0;
701 }
702 if ( strchr( "Nn", PARM_EXCLUDE_UNENCRYPTED[0] ) != NULL ) {
703 lp->ExcludeUnencrypted = 0;
704 } else {
705 lp->ExcludeUnencrypted = 1;
706 }
707 if ( strchr( "Yy", PARM_MULTICAST_PM_BUFFERING[0] ) != NULL ) {
708 lp->multicastPMBuffering = 1;
709 } else {
710 lp->multicastPMBuffering = 0;
711 }
712 if ( strchr( "Yy", PARM_INTRA_BSS_RELAY[0] ) != NULL ) {
713 lp->intraBSSRelay = 1;
714 } else {
715 lp->intraBSSRelay = 0;
716 }
717
718 lp->ownBeaconInterval = PARM_OWN_BEACON_INTERVAL;
719 lp->coexistence = PARM_COEXISTENCE;
720
721#ifdef USE_WDS
722 lp->wds_port[0].rtsThreshold = PARM_RTS_THRESHOLD1;
723 lp->wds_port[1].rtsThreshold = PARM_RTS_THRESHOLD2;
724 lp->wds_port[2].rtsThreshold = PARM_RTS_THRESHOLD3;
725 lp->wds_port[3].rtsThreshold = PARM_RTS_THRESHOLD4;
726 lp->wds_port[4].rtsThreshold = PARM_RTS_THRESHOLD5;
727 lp->wds_port[5].rtsThreshold = PARM_RTS_THRESHOLD6;
728 lp->wds_port[0].txRateCntl = PARM_TX_RATE1;
729 lp->wds_port[1].txRateCntl = PARM_TX_RATE2;
730 lp->wds_port[2].txRateCntl = PARM_TX_RATE3;
731 lp->wds_port[3].txRateCntl = PARM_TX_RATE4;
732 lp->wds_port[4].txRateCntl = PARM_TX_RATE5;
733 lp->wds_port[5].txRateCntl = PARM_TX_RATE6;
734
735 for( i = 0; i < ETH_ALEN; i++ ) {
736 lp->wds_port[0].wdsAddress[i] = PARM_WDS_ADDRESS1[i];
737 }
738 for( i = 0; i < ETH_ALEN; i++ ) {
739 lp->wds_port[1].wdsAddress[i] = PARM_WDS_ADDRESS2[i];
740 }
741 for( i = 0; i < ETH_ALEN; i++ ) {
742 lp->wds_port[2].wdsAddress[i] = PARM_WDS_ADDRESS3[i];
743 }
744 for( i = 0; i < ETH_ALEN; i++ ) {
745 lp->wds_port[3].wdsAddress[i] = PARM_WDS_ADDRESS4[i];
746 }
747 for( i = 0; i < ETH_ALEN; i++ ) {
748 lp->wds_port[4].wdsAddress[i] = PARM_WDS_ADDRESS5[i];
749 }
750 for( i = 0; i < ETH_ALEN; i++ ) {
751 lp->wds_port[5].wdsAddress[i] = PARM_WDS_ADDRESS6[i];
752 }
753#endif
754#endif
755#ifdef USE_RTS
756 if ( strchr( "Yy", useRTS[0] ) != NULL ) {
757 lp->useRTS = 1;
758 } else {
759 lp->useRTS = 0;
760 }
761#endif
762
763
764
765
766
767 wl_lock( lp, &flags );
768
769
770 lp->portState = WVLAN_PORT_STATE_DISABLED;
771
772
773 memset( &( lp->scan_results ), 0, sizeof( lp->scan_results ));
774 lp->scan_results.scan_complete = FALSE;
775
776
777 memset( &( lp->probe_results ), 0, sizeof( lp->probe_results ));
778 lp->probe_results.scan_complete = FALSE;
779 lp->probe_num_aps = 0;
780
781
782
783 memset( lp->txList, 0, sizeof( lp->txList ));
784
785 INIT_LIST_HEAD( &( lp->txFree ));
786
787 lp->txF.skb = NULL;
788 lp->txF.port = 0;
789
790
791 for( i = 0; i < DEFAULT_NUM_TX_FRAMES; i++ ) {
792 list_add_tail( &( lp->txList[i].node ), &( lp->txFree ));
793 }
794
795
796 for( i = 0; i < WVLAN_MAX_TX_QUEUES; i++ ) {
797 INIT_LIST_HEAD( &( lp->txQ[i] ));
798 }
799
800 lp->netif_queue_on = TRUE;
801 lp->txQ_count = 0;
802
803
804
805#ifdef WARP
806#ifdef ENABLE_DMA
807 DBG_TRACE( DbgInfo, "HERMES 2.5 BUSMASTER DMA MODE\n" );
808 lp->use_dma = 1;
809#else
810 DBG_TRACE( DbgInfo, "HERMES 2.5 PORT I/O MODE\n" );
811 lp->use_dma = 0;
812#endif
813#endif
814
815
816
817 tasklet_init(&lp->task, wl_isr_handler, (unsigned long)lp);
818
819
820 DBG_TRACE( DbgInfo, "Calling hcf_connect()...\n" );
821 hcf_status = hcf_connect( &lp->hcfCtx, dev->base_addr );
822
823
824 if ( hcf_status != HCF_SUCCESS && hcf_status != HCF_ERR_INCOMP_FW ) {
825 DBG_ERROR( DbgInfo, "hcf_connect() failed, status: 0x%x\n", hcf_status );
826 wl_unlock( lp, &flags );
827 goto hcf_failed;
828 }
829
830
831 lp->driverInfo.IO_address = dev->base_addr;
832 lp->driverInfo.IO_range = HCF_NUM_IO_PORTS;
833 lp->driverInfo.IRQ_number = dev->irq;
834 lp->driverInfo.card_stat = lp->hcfCtx.IFB_CardStat;
835
836
837
838 lp->driverIdentity.len = ( sizeof( lp->driverIdentity ) / sizeof( hcf_16 )) - 1;
839 lp->driverIdentity.typ = CFG_DRV_IDENTITY;
840 lp->driverIdentity.comp_id = DRV_IDENTITY;
841 lp->driverIdentity.variant = DRV_VARIANT;
842 lp->driverIdentity.version_major = DRV_MAJOR_VERSION;
843 lp->driverIdentity.version_minor = DRV_MINOR_VERSION;
844
845
846
847
848 DBG_TRACE( DbgInfo, "Calling wvlan_go() to perform a card reset...\n" );
849 hcf_status = wl_go( lp );
850
851 if ( hcf_status != HCF_SUCCESS ) {
852 DBG_ERROR( DbgInfo, "wl_go() failed\n" );
853 wl_unlock( lp, &flags );
854 goto hcf_failed;
855 }
856
857
858 wl_put_ltv_init( lp );
859
860#if 0
861
862 if ( wl_adapter_is_open( lp->dev )) {
863
864 DBG_TRACE( DbgInfo, "Enabling Port 0\n" );
865 hcf_status = wl_enable( lp );
866
867 if ( hcf_status != HCF_SUCCESS ) {
868 DBG_TRACE( DbgInfo, "Enable port 0 failed: 0x%x\n", hcf_status );
869 }
870
871#if (HCF_TYPE) & HCF_TYPE_AP
872 DBG_TRACE( DbgInfo, "Enabling WDS Ports\n" );
873
874#endif
875
876 }
877#endif
878
879
880 memcpy( lp->dev->dev_addr, lp->MACAddress, ETH_ALEN );
881 dev->addr_len = ETH_ALEN;
882
883 lp->is_registered = TRUE;
884
885#ifdef USE_PROFILE
886
887
888 parse_config( dev );
889#endif
890
891
892
893 WL_WDS_NETDEV_REGISTER( lp );
894
895
896
897
898
899
900
901 lp->DownloadFirmware = WVLAN_DRV_MODE_STA;
902
903#ifdef USE_RTS
904 if ( lp->useRTS == 1 ) {
905 DBG_TRACE( DbgInfo, "ENTERING RTS MODE...\n" );
906 wl_act_int_off( lp );
907 lp->is_handling_int = WL_NOT_HANDLING_INT;
908
909 wl_disable( lp );
910
911 hcf_connect( &lp->hcfCtx, HCF_DISCONNECT);
912 }
913#endif
914
915 wl_unlock( lp, &flags );
916
917 DBG_TRACE( DbgInfo, "%s: Wireless, io_addr %#03lx, irq %d, ""mac_address ",
918 dev->name, dev->base_addr, dev->irq );
919
920 for( i = 0; i < ETH_ALEN; i++ ) {
921 printk( "%02X%c", dev->dev_addr[i], (( i < ( ETH_ALEN-1 )) ? ':' : '\n' ));
922 }
923
924#if 0
925 proc_create_data( "wlags", 0, NULL, &scull_read_procmem_fops, dev );
926 proc_mkdir("driver/wlags49", 0);
927#endif
928
929 DBG_LEAVE( DbgInfo );
930 return result;
931
932hcf_failed:
933 wl_hcf_error( dev, hcf_status );
934
935failed:
936
937 DBG_ERROR( DbgInfo, "wl_insert() FAILED\n" );
938
939 if ( lp->is_registered == TRUE ) {
940 lp->is_registered = FALSE;
941 }
942
943 WL_WDS_NETDEV_DEREGISTER( lp );
944
945 result = -EFAULT;
946
947
948 DBG_LEAVE( DbgInfo );
949 return result;
950}
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971int wl_reset(struct net_device *dev)
972{
973 struct wl_private *lp = wl_priv(dev);
974 int hcf_status = HCF_SUCCESS;
975
976 DBG_FUNC( "wl_reset" );
977 DBG_ENTER( DbgInfo );
978 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
979 DBG_PARAM( DbgInfo, "dev->base_addr", "(%#03lx)", dev->base_addr );
980
981
982
983
984
985
986
987 DBG_TRACE( DbgInfo, "Device Base Address: %#03lx\n", dev->base_addr );
988 if ( dev->base_addr ) {
989
990 hcf_connect( &lp->hcfCtx, HCF_DISCONNECT );
991
992
993 lp->txBytes = 0;
994
995
996 hcf_status = hcf_connect( &lp->hcfCtx, dev->base_addr );
997 if ( hcf_status != HCF_SUCCESS && hcf_status != HCF_ERR_INCOMP_FW ) {
998 DBG_ERROR( DbgInfo, "hcf_connect() failed, status: 0x%x\n", hcf_status );
999 goto out;
1000 }
1001
1002
1003 if ( hcf_status == HCF_ERR_INCOMP_FW ) {
1004 lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
1005 }
1006
1007
1008 lp->portState = WVLAN_PORT_STATE_DISABLED;
1009
1010
1011 hcf_status = wl_go( lp );
1012 if ( hcf_status != HCF_SUCCESS ) {
1013 DBG_ERROR( DbgInfo, "wl_go() failed, status: 0x%x\n", hcf_status );
1014 goto out;
1015 }
1016
1017
1018 wl_put_ltv_init( lp );
1019 } else {
1020 DBG_ERROR( DbgInfo, "Device Base Address INVALID!!!\n" );
1021 }
1022
1023out:
1024 DBG_LEAVE( DbgInfo );
1025 return hcf_status;
1026}
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047int wl_go( struct wl_private *lp )
1048{
1049 int hcf_status = HCF_SUCCESS;
1050 char *cp = NULL;
1051 int retries = 0;
1052
1053 DBG_FUNC( "wl_go" );
1054 DBG_ENTER( DbgInfo );
1055
1056 hcf_status = wl_disable( lp );
1057 if ( hcf_status != HCF_SUCCESS ) {
1058 DBG_TRACE( DbgInfo, "Disable port 0 failed: 0x%x\n", hcf_status );
1059
1060 while (( hcf_status != HCF_SUCCESS ) && (retries < 10)) {
1061 retries++;
1062 hcf_status = wl_disable( lp );
1063 }
1064 if ( hcf_status == HCF_SUCCESS ) {
1065 DBG_TRACE( DbgInfo, "Disable port 0 succes : %d retries\n", retries );
1066 } else {
1067 DBG_TRACE( DbgInfo, "Disable port 0 failed after: %d retries\n", retries );
1068 }
1069 }
1070
1071#if 1
1072
1073
1074#endif
1075
1076
1077
1078
1079
1080
1081
1082#if BIN_DL
1083 if ( strlen( lp->fw_image_filename ) ) {
1084mm_segment_t fs;
1085int file_desc;
1086int rc;
1087
1088 DBG_TRACE( DbgInfo, "F/W image:%s:\n", lp->fw_image_filename );
1089
1090 fs = get_fs( );
1091 set_fs( get_ds( ));
1092 file_desc = open( lp->fw_image_filename, O_RDONLY, 0 );
1093 if ( file_desc == -1 ) {
1094 DBG_ERROR( DbgInfo, "No image file found\n" );
1095 } else {
1096 DBG_TRACE( DbgInfo, "F/W image file found\n" );
1097#define DHF_ALLOC_SIZE 96000
1098 cp = (char*)vmalloc( DHF_ALLOC_SIZE );
1099 if ( cp == NULL ) {
1100 DBG_ERROR( DbgInfo, "error in vmalloc\n" );
1101 } else {
1102 rc = read( file_desc, cp, DHF_ALLOC_SIZE );
1103 if ( rc == DHF_ALLOC_SIZE ) {
1104 DBG_ERROR( DbgInfo, "buffer too small, %d\n", DHF_ALLOC_SIZE );
1105 } else if ( rc > 0 ) {
1106 DBG_TRACE( DbgInfo, "read O.K.: %d bytes %.12s\n", rc, cp );
1107 rc = read( file_desc, &cp[rc], 1 );
1108 if ( rc == 0 ) {
1109 DBG_TRACE( DbgInfo, "no more to read\n" );
1110 }
1111 }
1112 if ( rc != 0 ) {
1113 DBG_ERROR( DbgInfo, "file not read in one swoop or other error"\
1114 ", give up, too complicated, rc = %0X\n", rc );
1115 DBG_ERROR( DbgInfo, "still have to change code to get a real download now !!!!!!!!\n" );
1116 } else {
1117 DBG_TRACE( DbgInfo, "before dhf_download_binary\n" );
1118 hcf_status = dhf_download_binary( (memimage *)cp );
1119 DBG_TRACE( DbgInfo, "after dhf_download_binary, before dhf_download_fw\n" );
1120
1121 hcf_status = dhf_download_fw( &lp->hcfCtx, (memimage *)cp );
1122 DBG_TRACE( DbgInfo, "after dhf_download_fw\n" );
1123 }
1124 vfree( cp );
1125 }
1126 close( file_desc );
1127 }
1128 set_fs( fs );
1129 }
1130#endif
1131
1132
1133 if ( (lp->firmware_present == WL_FRIMWARE_PRESENT)
1134 &&
1135 ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) != COMP_ID_FW_STA )
1136 &&
1137 ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) != COMP_ID_FW_AP ) ) {
1138
1139 lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
1140 }
1141
1142 if(lp->firmware_present == WL_FRIMWARE_NOT_PRESENT)
1143 {
1144 if ( cp == NULL ) {
1145 DBG_TRACE( DbgInfo, "Downloading STA firmware...\n" );
1146
1147 hcf_status = dhf_download_fw( &lp->hcfCtx, &fw_image );
1148 }
1149 if ( hcf_status != HCF_SUCCESS ) {
1150 DBG_ERROR( DbgInfo, "Firmware Download failed\n" );
1151 DBG_LEAVE( DbgInfo );
1152 return hcf_status;
1153 }
1154 }
1155
1156
1157 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA ) {
1158 DBG_TRACE( DbgInfo, "downloaded station F/W\n" );
1159 } else if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
1160 DBG_TRACE( DbgInfo, "downloaded AP F/W\n" );
1161 } else {
1162 DBG_ERROR( DbgInfo, "unknown F/W type\n" );
1163 }
1164
1165
1166
1167
1168
1169
1170
1171 lp->firmware_present = WL_FRIMWARE_PRESENT;
1172
1173 DBG_TRACE( DbgInfo, "ComponentID:%04x variant:%04x major:%04x minor:%04x\n",
1174 CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ),
1175 CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.variant ),
1176 CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.version_major ),
1177 CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.version_minor ));
1178
1179
1180 lp->ltvRecord.len = 4;
1181 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
1182 lp->ltvRecord.typ = CFG_NIC_MAC_ADDR;
1183 } else
1184 {
1185 lp->ltvRecord.typ = CFG_CNF_OWN_MAC_ADDR;
1186 }
1187 hcf_status = hcf_get_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1188 if ( hcf_status != HCF_SUCCESS ) {
1189 DBG_ERROR( DbgInfo, "Could not retrieve MAC address\n" );
1190 DBG_LEAVE( DbgInfo );
1191 return hcf_status;
1192 }
1193 memcpy( lp->MACAddress, &lp->ltvRecord.u.u8[0], ETH_ALEN );
1194 DBG_TRACE(DbgInfo, "Card MAC Address: %pM\n", lp->MACAddress);
1195
1196
1197
1198
1199 wl_put_ltv( lp );
1200
1201 hcf_status = wl_enable( lp );
1202
1203 if ( lp->DownloadFirmware == WVLAN_DRV_MODE_AP ) {
1204#ifdef USE_WDS
1205 wl_enable_wds_ports( lp );
1206#endif
1207 hcf_status = wl_connect( lp );
1208 }
1209 DBG_LEAVE( DbgInfo );
1210 return hcf_status;
1211}
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234void wl_set_wep_keys( struct wl_private *lp )
1235{
1236 int count = 0;
1237
1238 DBG_FUNC( "wl_set_wep_keys" );
1239 DBG_ENTER( DbgInfo );
1240 DBG_PARAM( DbgInfo, "lp", "%s (0x%p)", lp->dev->name, lp );
1241 if ( lp->EnableEncryption ) {
1242
1243
1244
1245
1246 lp->ltvRecord.len = 2;
1247 lp->ltvRecord.typ = CFG_TX_KEY_ID;
1248 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE(lp->TransmitKeyID - 1);
1249
1250 hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1251
1252 DBG_TRACE( DbgInfo, "Key 1 len: %d\n", lp->DefaultKeys.key[0].len );
1253 DBG_TRACE( DbgInfo, "Key 2 len: %d\n", lp->DefaultKeys.key[1].len );
1254 DBG_TRACE( DbgInfo, "Key 3 len: %d\n", lp->DefaultKeys.key[2].len );
1255 DBG_TRACE( DbgInfo, "Key 4 len: %d\n", lp->DefaultKeys.key[3].len );
1256
1257
1258 lp->DefaultKeys.len = sizeof( lp->DefaultKeys ) / sizeof( hcf_16 ) - 1;
1259 lp->DefaultKeys.typ = CFG_DEFAULT_KEYS;
1260
1261
1262 for( count = 0; count < MAX_KEYS; count++ ) {
1263 lp->DefaultKeys.key[count].len = CNV_INT_TO_LITTLE( lp->DefaultKeys.key[count].len );
1264 }
1265
1266 hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->DefaultKeys ));
1267
1268
1269
1270 for( count = 0; count < MAX_KEYS; count++ ) {
1271 lp->DefaultKeys.key[count].len = CNV_INT_TO_LITTLE( lp->DefaultKeys.key[count].len );
1272 }
1273
1274 DBG_NOTICE( DbgInfo, "encrypt: %d, ID: %d\n", lp->EnableEncryption, lp->TransmitKeyID );
1275 DBG_NOTICE( DbgInfo, "set key: %s(%d) [%d]\n", lp->DefaultKeys.key[lp->TransmitKeyID-1].key, lp->DefaultKeys.key[lp->TransmitKeyID-1].len, lp->TransmitKeyID-1 );
1276 }
1277
1278 DBG_LEAVE( DbgInfo );
1279}
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301int wl_apply(struct wl_private *lp)
1302{
1303 int hcf_status = HCF_SUCCESS;
1304
1305 DBG_FUNC( "wl_apply" );
1306 DBG_ENTER( DbgInfo );
1307 DBG_ASSERT( lp != NULL);
1308 DBG_PARAM( DbgInfo, "lp", "%s (0x%p)", lp->dev->name, lp );
1309
1310 if ( !( lp->flags & WVLAN2_UIL_BUSY )) {
1311
1312
1313
1314
1315
1316
1317 if ( wl_adapter_is_open( lp->dev )) {
1318
1319 hcf_status = wl_disconnect( lp );
1320 if ( hcf_status != HCF_SUCCESS ) {
1321 DBG_ERROR( DbgInfo, "Disconnect failed\n" );
1322 DBG_LEAVE( DbgInfo );
1323 return -1;
1324 }
1325 hcf_status = wl_disable( lp );
1326 if ( hcf_status != HCF_SUCCESS ) {
1327 DBG_ERROR( DbgInfo, "Disable failed\n" );
1328 DBG_LEAVE( DbgInfo );
1329 return -1;
1330 } else {
1331
1332
1333
1334
1335 hcf_status = wl_put_ltv( lp );
1336
1337 if ( hcf_status == HCF_SUCCESS ) {
1338 hcf_status = wl_enable( lp );
1339
1340 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
1341 hcf_status = wl_connect( lp );
1342 }
1343 } else {
1344 DBG_WARNING( DbgInfo, "wl_put_ltv() failed\n" );
1345 }
1346 }
1347 }
1348 }
1349
1350 DBG_LEAVE( DbgInfo );
1351 return hcf_status;
1352}
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373int wl_put_ltv_init( struct wl_private *lp )
1374{
1375 int i;
1376 int hcf_status;
1377 CFG_RID_LOG_STRCT *RidLog;
1378
1379 DBG_FUNC( "wl_put_ltv_init" );
1380 DBG_ENTER( DbgInfo );
1381 if ( lp == NULL ) {
1382 DBG_ERROR( DbgInfo, "lp pointer is NULL\n" );
1383 DBG_LEAVE( DbgInfo );
1384 return -1;
1385 }
1386
1387 lp->ltvRecord.len = 2;
1388 lp->ltvRecord.typ = CFG_CNTL_OPT;
1389
1390
1391
1392
1393#ifdef BUS_PCMCIA
1394 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( USE_16BIT );
1395#else
1396 if ( lp->use_dma ) {
1397 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( USE_DMA );
1398 } else {
1399 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0 );
1400 }
1401
1402#endif
1403 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1404 DBG_TRACE( DbgInfo, "CFG_CNTL_OPT : 0x%04x\n",
1405 lp->ltvRecord.u.u16[0] );
1406 DBG_TRACE( DbgInfo, "CFG_CNTL_OPT result : 0x%04x\n",
1407 hcf_status );
1408
1409
1410
1411
1412 i=0;
1413
1414 lp->RidList[i].len = sizeof( lp->ProbeResp );
1415 lp->RidList[i].typ = CFG_ACS_SCAN;
1416 lp->RidList[i].bufp = (wci_recordp)&lp->ProbeResp;
1417
1418 i++;
1419
1420 lp->RidList[i].len = sizeof( lp->assoc_stat );
1421 lp->RidList[i].typ = CFG_ASSOC_STAT;
1422 lp->RidList[i].bufp = (wci_recordp)&lp->assoc_stat;
1423 lp->assoc_stat.len = 0xFFFF;
1424 i++;
1425
1426 lp->RidList[i].len = 4;
1427 lp->RidList[i].typ = CFG_UPDATED_INFO_RECORD;
1428 lp->RidList[i].bufp = (wci_recordp)&lp->updatedRecord;
1429 lp->updatedRecord.len = 0xFFFF;
1430 i++;
1431
1432 lp->RidList[i].len = sizeof( lp->sec_stat );
1433 lp->RidList[i].typ = CFG_SECURITY_STAT;
1434 lp->RidList[i].bufp = (wci_recordp)&lp->sec_stat;
1435 lp->sec_stat.len = 0xFFFF;
1436 i++;
1437
1438 lp->RidList[i].typ = 0;
1439
1440 RidLog = (CFG_RID_LOG_STRCT *)&lp->ltvRecord;
1441 RidLog->len = 3;
1442 RidLog->typ = CFG_REG_INFO_LOG;
1443 RidLog->recordp = (RID_LOGP)&lp->RidList[0];
1444
1445 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1446 DBG_TRACE( DbgInfo, "CFG_REG_INFO_LOG\n" );
1447 DBG_TRACE( DbgInfo, "CFG_REG_INFO_LOG result : 0x%04x\n",
1448 hcf_status );
1449 DBG_LEAVE( DbgInfo );
1450 return hcf_status;
1451}
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472int wl_put_ltv( struct wl_private *lp )
1473{
1474 int len;
1475 int hcf_status;
1476
1477 DBG_FUNC( "wl_put_ltv" );
1478 DBG_ENTER( DbgInfo );
1479
1480 if ( lp == NULL ) {
1481 DBG_ERROR( DbgInfo, "lp pointer is NULL\n" );
1482 return -1;
1483 }
1484 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
1485 lp->maxPort = 6;
1486 } else {
1487 lp->maxPort = 0;
1488 }
1489
1490
1491
1492
1493 lp->ltvRecord.len = 4;
1494 lp->ltvRecord.typ = CFG_REG_MB;
1495 lp->ltvRecord.u.u32[0] = (u_long)&( lp->mailbox );
1496 lp->ltvRecord.u.u16[2] = ( MB_SIZE / sizeof( hcf_16 ));
1497 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1498
1499
1500 lp->ltvRecord.len = 2;
1501 lp->ltvRecord.typ = CFG_CNF_MAX_DATA_LEN;
1502 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( HCF_MAX_PACKET_SIZE );
1503 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1504
1505
1506 lp->ltvRecord.len = 2;
1507 lp->ltvRecord.typ = CFG_CNF_SYSTEM_SCALE;
1508 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->DistanceBetweenAPs );
1509 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1510
1511
1512 if ( lp->CreateIBSS && ( lp->Channel == 0 )) {
1513 DBG_TRACE( DbgInfo, "Create IBSS" );
1514 lp->Channel = 10;
1515 }
1516 lp->ltvRecord.len = 2;
1517 lp->ltvRecord.typ = CFG_CNF_OWN_CHANNEL;
1518 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->Channel );
1519 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1520
1521
1522 lp->ltvRecord.len = 2;
1523 lp->ltvRecord.typ = CFG_CNF_MICRO_WAVE;
1524 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->MicrowaveRobustness );
1525 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1526
1527
1528 lp->ltvRecord.len = 2;
1529 lp->ltvRecord.typ = CFG_CNF_LOAD_BALANCING;
1530 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->loadBalancing );
1531 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1532
1533
1534 lp->ltvRecord.len = 2;
1535 lp->ltvRecord.typ = CFG_CNF_MEDIUM_DISTRIBUTION;
1536 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->mediumDistribution );
1537 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1538
1539
1540#ifdef WARP
1541
1542 lp->ltvRecord.len = 2;
1543 lp->ltvRecord.typ = CFG_CNF_TX_POW_LVL;
1544 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->txPowLevel );
1545 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562 lp->ltvRecord.len = 3;
1563 lp->ltvRecord.typ = CFG_SUPPORTED_RATE_SET_CNTL;
1564 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->srsc[0] );
1565 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->srsc[1] );
1566 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1567
1568
1569 lp->ltvRecord.len = 3;
1570 lp->ltvRecord.typ = CFG_BASIC_RATE_SET_CNTL;
1571 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->brsc[0] );
1572 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->brsc[1] );
1573 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1574
1575
1576
1577
1578#endif
1579
1580#ifdef WARP
1581
1582 lp->ltvRecord.len = 3;
1583 lp->ltvRecord.typ = CFG_CNF_MCAST_RATE;
1584 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->MulticastRate[0] );
1585 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->MulticastRate[1] );
1586#else
1587 lp->ltvRecord.len = 2;
1588 lp->ltvRecord.typ = CFG_CNF_MCAST_RATE;
1589 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->MulticastRate[0] );
1590#endif
1591 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1592
1593
1594 if (( len = ( strlen( lp->StationName ) + 1 ) & ~0x01 ) != 0 ) {
1595
1596
1597
1598 lp->ltvRecord.len = 2 + ( len / sizeof( hcf_16 ));
1599 lp->ltvRecord.typ = CFG_CNF_OWN_NAME;
1600 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( strlen( lp->StationName ));
1601
1602 memcpy( &( lp->ltvRecord.u.u8[2] ), lp->StationName, len );
1603 } else {
1604
1605
1606 lp->ltvRecord.len = 2;
1607 lp->ltvRecord.typ = CFG_CNF_OWN_NAME;
1608 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0 );
1609 }
1610
1611 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1612
1613
1614
1615
1616
1617 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA ) {
1618
1619
1620 lp->ltvRecord.len = 2;
1621 lp->ltvRecord.typ = CFG_RTS_THRH;
1622 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->RTSThreshold );
1623 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1624
1625
1626 lp->ltvRecord.len = 2;
1627 lp->ltvRecord.typ = CFG_CNF_PORT_TYPE;
1628 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->PortType );
1629 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1630
1631
1632#ifdef WARP
1633 lp->ltvRecord.len = 3;
1634 lp->ltvRecord.typ = CFG_TX_RATE_CNTL;
1635 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->TxRateControl[0] );
1636 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->TxRateControl[1] );
1637#else
1638 lp->ltvRecord.len = 2;
1639 lp->ltvRecord.typ = CFG_TX_RATE_CNTL;
1640 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->TxRateControl[0] );
1641#endif
1642
1643
1644
1645 DBG_TRACE( DbgInfo, "CFG_TX_RATE_CNTL 2.4GHz : 0x%04x\n",
1646 lp->TxRateControl[0] );
1647 DBG_TRACE( DbgInfo, "CFG_TX_RATE_CNTL 5.0GHz : 0x%04x\n",
1648 lp->TxRateControl[1] );
1649 DBG_TRACE( DbgInfo, "CFG_TX_RATE_CNTL result : 0x%04x\n",
1650 hcf_status );
1651
1652 lp->ltvRecord.len = 2;
1653 lp->ltvRecord.typ = CFG_CNF_PM_ENABLED;
1654 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->PMEnabled );
1655
1656 DBG_TRACE( DbgInfo, "CFG_CNF_PM_ENABLED : 0x%04x\n", lp->PMEnabled );
1657 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1658
1659 lp->ltvRecord.len = 2;
1660 lp->ltvRecord.typ = CFG_CNF_MCAST_RX;
1661 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->MulticastReceive );
1662 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1663
1664
1665 lp->ltvRecord.len = 2;
1666 lp->ltvRecord.typ = CFG_CNF_MAX_SLEEP_DURATION;
1667 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->MaxSleepDuration );
1668 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1669
1670
1671 lp->ltvRecord.len = 2;
1672 lp->ltvRecord.typ = CFG_CREATE_IBSS;
1673 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->CreateIBSS );
1674 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1675
1676
1677 if ((( len = ( strlen( lp->NetworkName ) + 1 ) & ~0x01 ) != 0 ) &&
1678 ( strcmp( lp->NetworkName, "ANY" ) != 0 ) &&
1679 ( strcmp( lp->NetworkName, "any" ) != 0 )) {
1680
1681
1682
1683 lp->ltvRecord.len = 2 + (len / sizeof(hcf_16));
1684 lp->ltvRecord.typ = CFG_DESIRED_SSID;
1685 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( strlen( lp->NetworkName ));
1686
1687 memcpy( &( lp->ltvRecord.u.u8[2] ), lp->NetworkName, len );
1688 } else {
1689
1690
1691 lp->ltvRecord.len = 2;
1692 lp->ltvRecord.typ = CFG_DESIRED_SSID;
1693 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0 );
1694 }
1695
1696 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1697
1698
1699
1700
1701 lp->ltvRecord.len = 2;
1702 lp->ltvRecord.typ = CFG_CNF_OWN_ATIM_WINDOW;
1703 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->atimWindow );
1704 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1705
1706
1707
1708 lp->ltvRecord.len = 2;
1709 lp->ltvRecord.typ = CFG_CNF_HOLDOVER_DURATION;
1710 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->holdoverDuration );
1711 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1712
1713
1714 lp->ltvRecord.len = 2;
1715 lp->ltvRecord.typ = CFG_PROMISCUOUS_MODE;
1716 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->promiscuousMode );
1717 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1718
1719
1720 lp->ltvRecord.len = 2;
1721 lp->ltvRecord.typ = CFG_CNF_AUTHENTICATION;
1722 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->authentication );
1723 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1724#ifdef WARP
1725
1726 lp->ltvRecord.len = 2;
1727 lp->ltvRecord.typ = CFG_CNF_CONNECTION_CNTL;
1728 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->connectionControl );
1729 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746#endif
1747 } else {
1748
1749#if 0
1750
1751
1752
1753 lp->ltvRecord.len = 2;
1754 lp->ltvRecord.typ = CFG_CNF_OWN_DTIM_PERIOD;
1755 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->DTIMPeriod );
1756 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1757
1758
1759 lp->ltvRecord.len = 2;
1760 lp->ltvRecord.typ = CFG_CNF_MCAST_PM_BUF;
1761 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->multicastPMBuffering );
1762 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1763
1764
1765 lp->ltvRecord.len = 2;
1766 lp->ltvRecord.typ = CFG_CNF_REJECT_ANY;
1767 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->RejectAny );
1768
1769 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1770
1771
1772 lp->ltvRecord.len = 2;
1773 lp->ltvRecord.typ = CFG_CNF_EXCL_UNENCRYPTED;
1774 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ExcludeUnencrypted );
1775
1776 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1777
1778
1779 lp->ltvRecord.len = 2;
1780 lp->ltvRecord.typ = CFG_CNF_INTRA_BSS_RELAY;
1781 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->intraBSSRelay );
1782 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1783
1784
1785 lp->ltvRecord.len = 2;
1786 lp->ltvRecord.typ = CFG_RTS_THRH0;
1787 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->RTSThreshold );
1788
1789 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1790
1791
1792#ifdef WARP
1793 lp->ltvRecord.len = 3;
1794 lp->ltvRecord.typ = CFG_TX_RATE_CNTL0;
1795 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->TxRateControl[0] );
1796 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->TxRateControl[1] );
1797#else
1798 lp->ltvRecord.len = 2;
1799 lp->ltvRecord.typ = CFG_TX_RATE_CNTL0;
1800 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->TxRateControl[0] );
1801#endif
1802
1803 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1804
1805
1806 lp->ltvRecord.len = 2;
1807 lp->ltvRecord.typ = 0xFC31;
1808 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ownBeaconInterval );
1809 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1810
1811
1812 lp->ltvRecord.len = 2;
1813 lp->ltvRecord.typ = 0xFCC7;
1814 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->coexistence );
1815 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1816
1817#ifdef USE_WDS
1818
1819
1820 lp->ltvRecord.len = 2;
1821 lp->ltvRecord.typ = CFG_RTS_THRH1;
1822 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[0].rtsThreshold );
1823 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1824
1825
1826 lp->ltvRecord.len = 2;
1827 lp->ltvRecord.typ = CFG_RTS_THRH2;
1828 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[1].rtsThreshold );
1829 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1830
1831
1832
1833 lp->ltvRecord.len = 2;
1834 lp->ltvRecord.typ = CFG_RTS_THRH3;
1835 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[2].rtsThreshold );
1836 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1837
1838
1839
1840 lp->ltvRecord.len = 2;
1841 lp->ltvRecord.typ = CFG_RTS_THRH4;
1842 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[3].rtsThreshold );
1843 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1844
1845
1846
1847 lp->ltvRecord.len = 2;
1848 lp->ltvRecord.typ = CFG_RTS_THRH5;
1849 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[4].rtsThreshold );
1850 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1851
1852
1853 lp->ltvRecord.len = 2;
1854 lp->ltvRecord.typ = CFG_RTS_THRH6;
1855 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[5].rtsThreshold );
1856 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1857#if 0
1858
1859 lp->ltvRecord.len = 2;
1860 lp->ltvRecord.typ = CFG_TX_RATE_CNTL1;
1861 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[0].txRateCntl );
1862 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1863
1864
1865 lp->ltvRecord.len = 2;
1866 lp->ltvRecord.typ = CFG_TX_RATE_CNTL2;
1867 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[1].txRateCntl );
1868 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1869
1870
1871 lp->ltvRecord.len = 2;
1872 lp->ltvRecord.typ = CFG_TX_RATE_CNTL3;
1873 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[2].txRateCntl );
1874 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1875
1876
1877 lp->ltvRecord.len = 2;
1878 lp->ltvRecord.typ = CFG_TX_RATE_CNTL4;
1879 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[3].txRateCntl );
1880 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1881
1882
1883 lp->ltvRecord.len = 2;
1884 lp->ltvRecord.typ = CFG_TX_RATE_CNTL5;
1885 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[4].txRateCntl );
1886 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1887
1888
1889 lp->ltvRecord.len = 2;
1890 lp->ltvRecord.typ = CFG_TX_RATE_CNTL6;
1891 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->wds_port[5].txRateCntl );
1892 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1893
1894#endif
1895
1896
1897
1898
1899
1900 lp->ltvRecord.len = 4;
1901 lp->ltvRecord.typ = CFG_CNF_WDS_ADDR1;
1902
1903 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[0].wdsAddress, ETH_ALEN );
1904 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1905
1906
1907 lp->ltvRecord.len = 4;
1908 lp->ltvRecord.typ = CFG_CNF_WDS_ADDR2;
1909
1910 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[1].wdsAddress, ETH_ALEN );
1911 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1912
1913
1914 lp->ltvRecord.len = 4;
1915 lp->ltvRecord.typ = CFG_CNF_WDS_ADDR3;
1916
1917 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[2].wdsAddress, ETH_ALEN );
1918 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1919
1920
1921 lp->ltvRecord.len = 4;
1922 lp->ltvRecord.typ = CFG_CNF_WDS_ADDR4;
1923
1924 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[3].wdsAddress, ETH_ALEN );
1925 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1926
1927
1928 lp->ltvRecord.len = 4;
1929 lp->ltvRecord.typ = CFG_CNF_WDS_ADDR5;
1930
1931 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[4].wdsAddress, ETH_ALEN );
1932 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1933
1934
1935 lp->ltvRecord.len = 4;
1936 lp->ltvRecord.typ = CFG_CNF_WDS_ADDR6;
1937
1938 memcpy( &lp->ltvRecord.u.u8[0], lp->wds_port[5].wdsAddress, ETH_ALEN );
1939 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1940#endif
1941#endif
1942 }
1943
1944
1945
1946
1947
1948
1949
1950 if ( WVLAN_VALID_MAC_ADDRESS( lp->MACAddress )) {
1951
1952
1953
1954
1955
1956
1957
1958 lp->ltvRecord.len = 1 + ( ETH_ALEN / sizeof( hcf_16 ));
1959 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
1960
1961 lp->ltvRecord.typ = CFG_NIC_MAC_ADDR;
1962 } else {
1963
1964 lp->ltvRecord.typ = CFG_CNF_OWN_MAC_ADDR;
1965 }
1966
1967 memcpy( &( lp->ltvRecord.u.u8[0] ), lp->MACAddress, ETH_ALEN );
1968 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1969
1970
1971
1972
1973 memcpy( lp->dev->dev_addr, lp->MACAddress, ETH_ALEN );
1974 }
1975
1976 if ((( len = ( strlen( lp->NetworkName ) + 1 ) & ~0x01 ) != 0 ) &&
1977 ( strcmp( lp->NetworkName, "ANY" ) != 0 ) &&
1978 ( strcmp( lp->NetworkName, "any" ) != 0 )) {
1979
1980
1981 lp->ltvRecord.len = 2 + (len / sizeof(hcf_16));
1982 lp->ltvRecord.typ = CFG_CNF_OWN_SSID;
1983 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( strlen( lp->NetworkName ));
1984
1985 memcpy( &( lp->ltvRecord.u.u8[2] ), lp->NetworkName, len );
1986 } else {
1987
1988 lp->ltvRecord.len = 2;
1989 lp->ltvRecord.typ = CFG_CNF_OWN_SSID;
1990 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( 0 );
1991 }
1992
1993 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
1994
1995
1996
1997
1998 lp->ltvRecord.len = 2;
1999 lp->ltvRecord.typ = CFG_CNF_ENCRYPTION;
2000 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->EnableEncryption );
2001 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
2002
2003
2004 lp->ltvRecord.len = 2;
2005 lp->ltvRecord.typ = CFG_SET_WPA_AUTH_KEY_MGMT_SUITE;
2006 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->AuthKeyMgmtSuite );
2007 hcf_status = hcf_put_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
2008
2009
2010 if (lp->wext_enc != IW_ENCODE_ALG_TKIP)
2011 wl_set_wep_keys(lp);
2012
2013
2014
2015
2016 DBG_LEAVE( DbgInfo );
2017 return hcf_status;
2018}
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040static int __init wl_module_init( void )
2041{
2042 int result;
2043
2044
2045 DBG_FUNC( "wl_module_init" );
2046
2047#if DBG
2048
2049
2050 DbgInfo->DebugFlag = 0;
2051 DbgInfo->DebugFlag = DBG_TRACE_ON;
2052 if ( pc_debug ) switch( pc_debug ) {
2053 case 8:
2054 DbgInfo->DebugFlag |= DBG_DS_ON;
2055 case 7:
2056 DbgInfo->DebugFlag |= DBG_RX_ON | DBG_TX_ON;
2057 case 6:
2058 DbgInfo->DebugFlag |= DBG_PARAM_ON;
2059 case 5:
2060 DbgInfo->DebugFlag |= DBG_TRACE_ON;
2061 case 4:
2062 DbgInfo->DebugFlag |= DBG_VERBOSE_ON;
2063 case 1:
2064 DbgInfo->DebugFlag |= DBG_DEFAULTS;
2065 default:
2066 break;
2067 }
2068#endif
2069
2070 DBG_ENTER( DbgInfo );
2071 printk(KERN_INFO "%s\n", VERSION_INFO);
2072 printk(KERN_INFO "*** Modified for kernel 2.6 by Henk de Groot <pe1dnn@amsat.org>\n");
2073 printk(KERN_INFO "*** Based on 7.18 version by Andrey Borzenkov <arvidjaar@mail.ru> $Revision: 39 $\n");
2074
2075
2076
2077
2078
2079
2080
2081
2082 result = wl_adapter_init_module( );
2083 DBG_LEAVE( DbgInfo );
2084 return result;
2085}
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106static void __exit wl_module_exit( void )
2107{
2108 DBG_FUNC( "wl_module_exit" );
2109 DBG_ENTER(DbgInfo);
2110
2111 wl_adapter_cleanup_module( );
2112#if 0
2113 remove_proc_entry( "wlags", NULL );
2114#endif
2115
2116 DBG_LEAVE( DbgInfo );
2117 return;
2118}
2119
2120
2121module_init(wl_module_init);
2122module_exit(wl_module_exit);
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143irqreturn_t wl_isr( int irq, void *dev_id, struct pt_regs *regs )
2144{
2145 int events;
2146 struct net_device *dev = (struct net_device *) dev_id;
2147 struct wl_private *lp = NULL;
2148
2149 if (( dev == NULL ) || ( !netif_device_present( dev ))) {
2150 return IRQ_NONE;
2151 }
2152
2153
2154 lp = wl_priv(dev);
2155
2156#ifdef USE_RTS
2157 if ( lp->useRTS == 1 ) {
2158 DBG_PRINT( "EXITING ISR, IN RTS MODE...\n" );
2159 return;
2160 }
2161#endif
2162
2163
2164
2165 events = hcf_action( &lp->hcfCtx, HCF_ACT_INT_OFF );
2166
2167 if ( events == HCF_INT_PENDING ) {
2168
2169
2170 tasklet_schedule(&lp->task);
2171 } else {
2172
2173 hcf_action( &lp->hcfCtx, HCF_ACT_INT_ON );
2174 }
2175
2176 return IRQ_RETVAL(events == HCF_INT_PENDING);
2177}
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199#define WVLAN_MAX_INT_SERVICES 50
2200
2201void wl_isr_handler( unsigned long p )
2202{
2203 struct net_device *dev;
2204 unsigned long flags;
2205 bool_t stop = TRUE;
2206 int count;
2207 int result;
2208 struct wl_private *lp = (struct wl_private *)p;
2209
2210
2211 if ( lp == NULL ) {
2212 DBG_PRINT( "wl_isr_handler lp adapter pointer is NULL!!!\n" );
2213 } else {
2214 wl_lock( lp, &flags );
2215
2216 dev = (struct net_device *)lp->dev;
2217 if ( dev != NULL && netif_device_present( dev ) ) stop = FALSE;
2218 for( count = 0; stop == FALSE && count < WVLAN_MAX_INT_SERVICES; count++ ) {
2219 stop = TRUE;
2220 result = hcf_service_nic( &lp->hcfCtx,
2221 (wci_bufp)lp->lookAheadBuf,
2222 sizeof( lp->lookAheadBuf ));
2223 if ( result == HCF_ERR_MIC ) {
2224 wl_wext_event_mic_failed( dev );
2225
2226
2227 }
2228
2229#ifndef USE_MBOX_SYNC
2230 if ( lp->hcfCtx.IFB_MBInfoLen != 0 ) {
2231 wl_mbx( lp );
2232 stop = FALSE;
2233 }
2234#endif
2235
2236 if ( ( lp->hcfCtx.IFB_LinkStat & CFG_LINK_STAT_FW ) != 0 ) {
2237 wl_process_link_status( lp );
2238 stop = FALSE;
2239 }
2240
2241 if ( lp->ProbeResp.infoType != 0 &&
2242 lp->ProbeResp.infoType != 0xFFFF ) {
2243 wl_process_probe_response( lp );
2244 memset( &lp->ProbeResp, 0, sizeof( lp->ProbeResp ));
2245 lp->ProbeResp.infoType = 0xFFFF;
2246 stop = FALSE;
2247 }
2248
2249 if ( lp->updatedRecord.len != 0xFFFF ) {
2250 wl_process_updated_record( lp );
2251 lp->updatedRecord.len = 0xFFFF;
2252 stop = FALSE;
2253 }
2254
2255 if ( lp->assoc_stat.len != 0xFFFF ) {
2256 wl_process_assoc_status( lp );
2257 lp->assoc_stat.len = 0xFFFF;
2258 stop = FALSE;
2259 }
2260
2261 if ( lp->sec_stat.len != 0xFFFF ) {
2262 wl_process_security_status( lp );
2263 lp->sec_stat.len = 0xFFFF;
2264 stop = FALSE;
2265 }
2266
2267#ifdef ENABLE_DMA
2268 if ( lp->use_dma ) {
2269
2270 if ( lp->hcfCtx.IFB_DmaPackets & HREG_EV_RDMAD ) {
2271 wl_rx_dma( dev );
2272 stop = FALSE;
2273 }
2274
2275 if ( lp->hcfCtx.IFB_DmaPackets & HREG_EV_TDMAD ) {
2276 wl_pci_dma_hcf_reclaim_tx( lp );
2277 stop = FALSE;
2278 }
2279 }
2280 else
2281#endif
2282 {
2283
2284 if ( lp->hcfCtx.IFB_RxLen != 0 ) {
2285 wl_rx( dev );
2286 stop = FALSE;
2287 }
2288
2289 if ( wl_send( lp )) {
2290 stop = FALSE;
2291 }
2292 }
2293 }
2294
2295 hcf_action( &lp->hcfCtx, HCF_ACT_INT_ON );
2296 wl_unlock( lp, &flags );
2297 }
2298 return;
2299}
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321void wl_remove( struct net_device *dev )
2322{
2323 struct wl_private *lp = wl_priv(dev);
2324 unsigned long flags;
2325
2326 DBG_FUNC( "wl_remove" );
2327 DBG_ENTER( DbgInfo );
2328
2329 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2330
2331 wl_lock( lp, &flags );
2332
2333
2334 wl_act_int_off( lp );
2335 lp->is_handling_int = WL_NOT_HANDLING_INT;
2336
2337
2338
2339
2340
2341
2342
2343 lp->portState = WVLAN_PORT_STATE_DISABLED;
2344
2345#if 0
2346#ifdef USE_WDS
2347
2348#endif
2349#endif
2350
2351
2352 lp->is_registered = FALSE;
2353
2354
2355 WL_WDS_NETDEV_DEREGISTER( lp );
2356#ifdef USE_RTS
2357 if ( lp->useRTS == 1 ) {
2358 wl_unlock( lp, &flags );
2359
2360 DBG_LEAVE( DbgInfo );
2361 return;
2362 }
2363#endif
2364
2365
2366 hcf_connect( &lp->hcfCtx, HCF_DISCONNECT );
2367
2368 wl_unlock( lp, &flags );
2369
2370 DBG_LEAVE( DbgInfo );
2371 return;
2372}
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393void wl_suspend( struct net_device *dev )
2394{
2395 struct wl_private *lp = wl_priv(dev);
2396 unsigned long flags;
2397
2398 DBG_FUNC( "wl_suspend" );
2399 DBG_ENTER( DbgInfo );
2400
2401 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2402
2403
2404
2405
2406
2407 wl_lock( lp, &flags );
2408
2409
2410 wl_act_int_off( lp );
2411
2412
2413 wl_disconnect( lp );
2414
2415
2416 wl_disable( lp );
2417
2418
2419 hcf_connect( &lp->hcfCtx, HCF_DISCONNECT );
2420
2421
2422 lp->portState = WVLAN_PORT_STATE_DISABLED;
2423
2424 wl_unlock( lp, &flags );
2425
2426 DBG_LEAVE( DbgInfo );
2427 return;
2428}
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449void wl_resume(struct net_device *dev)
2450{
2451 struct wl_private *lp = wl_priv(dev);
2452 unsigned long flags;
2453
2454 DBG_FUNC( "wl_resume" );
2455 DBG_ENTER( DbgInfo );
2456
2457 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2458
2459 wl_lock( lp, &flags );
2460
2461
2462 hcf_connect( &lp->hcfCtx, dev->base_addr );
2463
2464
2465 lp->portState = WVLAN_PORT_STATE_DISABLED;
2466
2467
2468 lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
2469
2470
2471 wl_reset( dev );
2472
2473
2474 wl_act_int_on( lp );
2475
2476 wl_unlock( lp, &flags );
2477
2478 DBG_LEAVE( DbgInfo );
2479 return;
2480}
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504void wl_release( struct net_device *dev )
2505{
2506 struct wl_private *lp = wl_priv(dev);
2507
2508 DBG_FUNC( "wl_release" );
2509 DBG_ENTER( DbgInfo );
2510
2511 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2512
2513
2514 if ( lp->is_registered == TRUE ) {
2515 DBG_TRACE( DbgInfo, "Calling unregister_netdev(), as it wasn't called yet\n" );
2516 wl_remove( dev );
2517
2518 lp->is_registered = FALSE;
2519 }
2520
2521 DBG_LEAVE( DbgInfo );
2522 return;
2523}
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544p_u16 wl_get_irq_mask( void )
2545{
2546 return irq_mask;
2547}
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568p_s8 * wl_get_irq_list( void )
2569{
2570 return irq_list;
2571}
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593int wl_enable( struct wl_private *lp )
2594{
2595 int hcf_status = HCF_SUCCESS;
2596
2597 DBG_FUNC( "wl_enable" );
2598 DBG_ENTER( DbgInfo );
2599
2600 if ( lp->portState == WVLAN_PORT_STATE_ENABLED ) {
2601 DBG_TRACE( DbgInfo, "No action: Card already enabled\n" );
2602 } else if ( lp->portState == WVLAN_PORT_STATE_CONNECTED ) {
2603
2604 DBG_TRACE( DbgInfo, "No action: Card already connected\n" );
2605 } else {
2606 hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_ENABLE );
2607 if ( hcf_status == HCF_SUCCESS ) {
2608
2609 lp->portState = WVLAN_PORT_STATE_ENABLED;
2610#ifdef ENABLE_DMA
2611 if ( lp->use_dma ) {
2612 wl_pci_dma_hcf_supply( lp );
2613 }
2614#endif
2615 }
2616 }
2617 if ( hcf_status != HCF_SUCCESS ) {
2618 DBG_TRACE( DbgInfo, "failed: 0x%x\n", hcf_status );
2619 }
2620 DBG_LEAVE( DbgInfo );
2621 return hcf_status;
2622}
2623
2624
2625
2626#ifdef USE_WDS
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644void wl_enable_wds_ports( struct wl_private * lp )
2645{
2646
2647 DBG_FUNC( "wl_enable_wds_ports" );
2648 DBG_ENTER( DbgInfo );
2649 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ){
2650 DBG_ERROR( DbgInfo, "!!!!;? someone misunderstood something !!!!!\n" );
2651 }
2652 DBG_LEAVE( DbgInfo );
2653 return;
2654}
2655#endif
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676int wl_connect( struct wl_private *lp )
2677{
2678 int hcf_status;
2679
2680
2681 DBG_FUNC( "wl_connect" );
2682 DBG_ENTER( DbgInfo );
2683
2684 if ( lp->portState != WVLAN_PORT_STATE_ENABLED ) {
2685 DBG_TRACE( DbgInfo, "No action: Not in enabled state\n" );
2686 DBG_LEAVE( DbgInfo );
2687 return HCF_SUCCESS;
2688 }
2689 hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_CONNECT );
2690 if ( hcf_status == HCF_SUCCESS ) {
2691 lp->portState = WVLAN_PORT_STATE_CONNECTED;
2692 }
2693 DBG_LEAVE( DbgInfo );
2694 return hcf_status;
2695}
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716int wl_disconnect( struct wl_private *lp )
2717{
2718 int hcf_status;
2719
2720
2721 DBG_FUNC( "wl_disconnect" );
2722 DBG_ENTER( DbgInfo );
2723
2724 if ( lp->portState != WVLAN_PORT_STATE_CONNECTED ) {
2725 DBG_TRACE( DbgInfo, "No action: Not in connected state\n" );
2726 DBG_LEAVE( DbgInfo );
2727 return HCF_SUCCESS;
2728 }
2729 hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_DISCONNECT );
2730 if ( hcf_status == HCF_SUCCESS ) {
2731 lp->portState = WVLAN_PORT_STATE_ENABLED;
2732 }
2733 DBG_LEAVE( DbgInfo );
2734 return hcf_status;
2735}
2736
2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757int wl_disable( struct wl_private *lp )
2758{
2759 int hcf_status = HCF_SUCCESS;
2760
2761 DBG_FUNC( "wl_disable" );
2762 DBG_ENTER( DbgInfo );
2763
2764 if ( lp->portState == WVLAN_PORT_STATE_DISABLED ) {
2765 DBG_TRACE( DbgInfo, "No action: Port state is disabled\n" );
2766 } else {
2767 hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_DISABLE );
2768 if ( hcf_status == HCF_SUCCESS ) {
2769
2770 lp->portState = WVLAN_PORT_STATE_DISABLED;
2771
2772#ifdef ENABLE_DMA
2773 if ( lp->use_dma ) {
2774 wl_pci_dma_hcf_reclaim( lp );
2775 }
2776#endif
2777 }
2778 }
2779 if ( hcf_status != HCF_SUCCESS ) {
2780 DBG_TRACE( DbgInfo, "failed: 0x%x\n", hcf_status );
2781 }
2782 DBG_LEAVE( DbgInfo );
2783 return hcf_status;
2784}
2785
2786
2787
2788#ifdef USE_WDS
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806void wl_disable_wds_ports( struct wl_private * lp )
2807{
2808
2809 DBG_FUNC( "wl_disable_wds_ports" );
2810 DBG_ENTER( DbgInfo );
2811
2812 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ){
2813 DBG_ERROR( DbgInfo, "!!!!;? someone misunderstood something !!!!!\n" );
2814 }
2815
2816
2817
2818
2819
2820
2821
2822
2823 DBG_LEAVE( DbgInfo );
2824 return;
2825}
2826#endif
2827
2828
2829
2830#ifndef USE_MBOX_SYNC
2831
2832
2833
2834
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848int wl_mbx( struct wl_private *lp )
2849{
2850 int hcf_status = HCF_SUCCESS;
2851
2852 DBG_FUNC( "wl_mbx" );
2853 DBG_ENTER( DbgInfo );
2854 DBG_TRACE( DbgInfo, "Mailbox Info: IFB_MBInfoLen: %d\n",
2855 lp->hcfCtx.IFB_MBInfoLen );
2856
2857 memset( &( lp->ltvRecord ), 0, sizeof( ltv_t ));
2858
2859 lp->ltvRecord.len = MB_SIZE;
2860 lp->ltvRecord.typ = CFG_MB_INFO;
2861 hcf_status = hcf_get_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
2862
2863 if ( hcf_status != HCF_SUCCESS ) {
2864 DBG_ERROR( DbgInfo, "hcf_get_info returned 0x%x\n", hcf_status );
2865
2866 DBG_LEAVE( DbgInfo );
2867 return hcf_status;
2868 }
2869
2870 if ( lp->ltvRecord.typ == CFG_MB_INFO ) {
2871 DBG_LEAVE( DbgInfo );
2872 return hcf_status;
2873 }
2874
2875 wl_endian_translate_mailbox( &( lp->ltvRecord ));
2876 wl_process_mailbox( lp );
2877 DBG_LEAVE( DbgInfo );
2878 return hcf_status;
2879}
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901void wl_endian_translate_mailbox( ltv_t *ltv )
2902{
2903
2904 DBG_FUNC( "wl_endian_translate_mailbox" );
2905 DBG_ENTER( DbgInfo );
2906 switch( ltv->typ ) {
2907 case CFG_TALLIES:
2908 break;
2909
2910 case CFG_SCAN:
2911 {
2912 int num_aps;
2913 SCAN_RS_STRCT *aps = (SCAN_RS_STRCT *)<v->u.u8[0];
2914
2915 num_aps = (hcf_16)(( (size_t)(ltv->len - 1 ) * 2 ) /
2916 ( sizeof( SCAN_RS_STRCT )));
2917
2918 while( num_aps >= 1 ) {
2919 num_aps--;
2920
2921 aps[num_aps].channel_id =
2922 CNV_LITTLE_TO_INT( aps[num_aps].channel_id );
2923
2924 aps[num_aps].noise_level =
2925 CNV_LITTLE_TO_INT( aps[num_aps].noise_level );
2926
2927 aps[num_aps].signal_level =
2928 CNV_LITTLE_TO_INT( aps[num_aps].signal_level );
2929
2930 aps[num_aps].beacon_interval_time =
2931 CNV_LITTLE_TO_INT( aps[num_aps].beacon_interval_time );
2932
2933 aps[num_aps].capability =
2934 CNV_LITTLE_TO_INT( aps[num_aps].capability );
2935
2936 aps[num_aps].ssid_len =
2937 CNV_LITTLE_TO_INT( aps[num_aps].ssid_len );
2938
2939 aps[num_aps].ssid_val[aps[num_aps].ssid_len] = 0;
2940 }
2941 }
2942 break;
2943
2944 case CFG_ACS_SCAN:
2945 {
2946 PROBE_RESP *probe_resp = (PROBE_RESP *)ltv;
2947
2948 probe_resp->frameControl = CNV_LITTLE_TO_INT( probe_resp->frameControl );
2949 probe_resp->durID = CNV_LITTLE_TO_INT( probe_resp->durID );
2950 probe_resp->sequence = CNV_LITTLE_TO_INT( probe_resp->sequence );
2951 probe_resp->dataLength = CNV_LITTLE_TO_INT( probe_resp->dataLength );
2952#ifndef WARP
2953 probe_resp->lenType = CNV_LITTLE_TO_INT( probe_resp->lenType );
2954#endif
2955 probe_resp->beaconInterval = CNV_LITTLE_TO_INT( probe_resp->beaconInterval );
2956 probe_resp->capability = CNV_LITTLE_TO_INT( probe_resp->capability );
2957 probe_resp->flags = CNV_LITTLE_TO_INT( probe_resp->flags );
2958 }
2959 break;
2960
2961 case CFG_LINK_STAT:
2962#define ls ((LINK_STATUS_STRCT *)ltv)
2963 ls->linkStatus = CNV_LITTLE_TO_INT( ls->linkStatus );
2964 break;
2965#undef ls
2966
2967 case CFG_ASSOC_STAT:
2968 {
2969 ASSOC_STATUS_STRCT *as = (ASSOC_STATUS_STRCT *)ltv;
2970
2971 as->assocStatus = CNV_LITTLE_TO_INT( as->assocStatus );
2972 }
2973 break;
2974
2975 case CFG_SECURITY_STAT:
2976 {
2977 SECURITY_STATUS_STRCT *ss = (SECURITY_STATUS_STRCT *)ltv;
2978
2979 ss->securityStatus = CNV_LITTLE_TO_INT( ss->securityStatus );
2980 ss->reason = CNV_LITTLE_TO_INT( ss->reason );
2981 }
2982 break;
2983
2984 case CFG_WMP:
2985 break;
2986
2987 case CFG_NULL:
2988 break;
2989
2990 default:
2991 break;
2992 }
2993
2994 DBG_LEAVE( DbgInfo );
2995 return;
2996}
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016void wl_process_mailbox( struct wl_private *lp )
3017{
3018 ltv_t *ltv;
3019 hcf_16 ltv_val = 0xFFFF;
3020
3021 DBG_FUNC( "wl_process_mailbox" );
3022 DBG_ENTER( DbgInfo );
3023 ltv = &( lp->ltvRecord );
3024
3025 switch( ltv->typ ) {
3026
3027 case CFG_TALLIES:
3028 DBG_TRACE( DbgInfo, "CFG_TALLIES\n" );
3029 break;
3030 case CFG_SCAN:
3031 DBG_TRACE( DbgInfo, "CFG_SCAN\n" );
3032
3033 {
3034 int num_aps;
3035 SCAN_RS_STRCT *aps = (SCAN_RS_STRCT *)<v->u.u8[0];
3036
3037 num_aps = (hcf_16)(( (size_t)(ltv->len - 1 ) * 2 ) /
3038 ( sizeof( SCAN_RS_STRCT )));
3039
3040 lp->scan_results.num_aps = num_aps;
3041
3042 DBG_TRACE( DbgInfo, "Number of APs: %d\n", num_aps );
3043
3044 while( num_aps >= 1 ) {
3045 num_aps--;
3046
3047 DBG_TRACE( DbgInfo, "AP : %d\n", num_aps );
3048 DBG_TRACE( DbgInfo, "=========================\n" );
3049 DBG_TRACE( DbgInfo, "Channel ID : 0x%04x\n",
3050 aps[num_aps].channel_id );
3051 DBG_TRACE( DbgInfo, "Noise Level : 0x%04x\n",
3052 aps[num_aps].noise_level );
3053 DBG_TRACE( DbgInfo, "Signal Level : 0x%04x\n",
3054 aps[num_aps].signal_level );
3055 DBG_TRACE( DbgInfo, "Beacon Interval : 0x%04x\n",
3056 aps[num_aps].beacon_interval_time );
3057 DBG_TRACE( DbgInfo, "Capability : 0x%04x\n",
3058 aps[num_aps].capability );
3059 DBG_TRACE( DbgInfo, "SSID Length : 0x%04x\n",
3060 aps[num_aps].ssid_len );
3061 DBG_TRACE(DbgInfo, "BSSID : %pM\n",
3062 aps[num_aps].bssid);
3063
3064 if ( aps[num_aps].ssid_len != 0 ) {
3065 DBG_TRACE( DbgInfo, "SSID : %s.\n",
3066 aps[num_aps].ssid_val );
3067 } else {
3068 DBG_TRACE( DbgInfo, "SSID : %s.\n", "ANY" );
3069 }
3070
3071 DBG_TRACE( DbgInfo, "\n" );
3072
3073
3074
3075 memcpy( &( lp->scan_results.APTable[num_aps]), &( aps[num_aps] ),
3076 sizeof( SCAN_RS_STRCT ));
3077 }
3078
3079
3080
3081 lp->scan_results.scan_complete = TRUE;
3082 }
3083
3084 break;
3085 case CFG_ACS_SCAN:
3086 DBG_TRACE( DbgInfo, "CFG_ACS_SCAN\n" );
3087
3088 {
3089 PROBE_RESP *probe_rsp = (PROBE_RESP *)ltv;
3090 hcf_8 *wpa_ie = NULL;
3091 hcf_16 wpa_ie_len = 0;
3092
3093 DBG_TRACE( DbgInfo, "(%s) =========================\n",
3094 lp->dev->name );
3095
3096 DBG_TRACE( DbgInfo, "(%s) length : 0x%04x.\n",
3097 lp->dev->name, probe_rsp->length );
3098
3099 if ( probe_rsp->length > 1 ) {
3100 DBG_TRACE( DbgInfo, "(%s) infoType : 0x%04x.\n",
3101 lp->dev->name, probe_rsp->infoType );
3102
3103 DBG_TRACE( DbgInfo, "(%s) signal : 0x%02x.\n",
3104 lp->dev->name, probe_rsp->signal );
3105
3106 DBG_TRACE( DbgInfo, "(%s) silence : 0x%02x.\n",
3107 lp->dev->name, probe_rsp->silence );
3108
3109 DBG_TRACE( DbgInfo, "(%s) rxFlow : 0x%02x.\n",
3110 lp->dev->name, probe_rsp->rxFlow );
3111
3112 DBG_TRACE( DbgInfo, "(%s) rate : 0x%02x.\n",
3113 lp->dev->name, probe_rsp->rate );
3114
3115 DBG_TRACE( DbgInfo, "(%s) frame cntl : 0x%04x.\n",
3116 lp->dev->name, probe_rsp->frameControl );
3117
3118 DBG_TRACE( DbgInfo, "(%s) durID : 0x%04x.\n",
3119 lp->dev->name, probe_rsp->durID );
3120
3121 DBG_TRACE(DbgInfo, "(%s) address1 : %pM\n",
3122 lp->dev->name, probe_rsp->address1);
3123
3124 DBG_TRACE(DbgInfo, "(%s) address2 : %pM\n",
3125 lp->dev->name, probe_rsp->address2);
3126
3127 DBG_TRACE(DbgInfo, "(%s) BSSID : %pM\n",
3128 lp->dev->name, probe_rsp->BSSID);
3129
3130 DBG_TRACE( DbgInfo, "(%s) sequence : 0x%04x.\n",
3131 lp->dev->name, probe_rsp->sequence );
3132
3133 DBG_TRACE(DbgInfo, "(%s) address4 : %pM\n",
3134 lp->dev->name, probe_rsp->address4);
3135
3136 DBG_TRACE( DbgInfo, "(%s) datalength : 0x%04x.\n",
3137 lp->dev->name, probe_rsp->dataLength );
3138
3139 DBG_TRACE(DbgInfo, "(%s) DA : %pM\n",
3140 lp->dev->name, probe_rsp->DA);
3141
3142 DBG_TRACE(DbgInfo, "(%s) SA : %pM\n",
3143 lp->dev->name, probe_rsp->SA);
3144
3145
3146
3147
3148 DBG_TRACE(DbgInfo, "(%s) timeStamp : "
3149 "%d.%d.%d.%d.%d.%d.%d.%d\n",
3150 lp->dev->name,
3151 probe_rsp->timeStamp[0],
3152 probe_rsp->timeStamp[1],
3153 probe_rsp->timeStamp[2],
3154 probe_rsp->timeStamp[3],
3155 probe_rsp->timeStamp[4],
3156 probe_rsp->timeStamp[5],
3157 probe_rsp->timeStamp[6],
3158 probe_rsp->timeStamp[7]);
3159
3160 DBG_TRACE( DbgInfo, "(%s) beaconInt : 0x%04x.\n",
3161 lp->dev->name, probe_rsp->beaconInterval );
3162
3163 DBG_TRACE( DbgInfo, "(%s) capability : 0x%04x.\n",
3164 lp->dev->name, probe_rsp->capability );
3165
3166 DBG_TRACE( DbgInfo, "(%s) SSID len : 0x%04x.\n",
3167 lp->dev->name, probe_rsp->rawData[1] );
3168
3169 if ( probe_rsp->rawData[1] > 0 ) {
3170 char ssid[HCF_MAX_NAME_LEN];
3171
3172 memset( ssid, 0, sizeof( ssid ));
3173 strncpy( ssid, &probe_rsp->rawData[2],
3174 min_t(u8,
3175 probe_rsp->rawData[1],
3176 HCF_MAX_NAME_LEN - 1));
3177
3178 DBG_TRACE( DbgInfo, "(%s) SSID : %s\n",
3179 lp->dev->name, ssid );
3180 }
3181
3182
3183 wpa_ie = wl_parse_wpa_ie( probe_rsp, &wpa_ie_len );
3184 if ( wpa_ie != NULL ) {
3185 DBG_TRACE( DbgInfo, "(%s) WPA-IE : %s\n",
3186 lp->dev->name, wl_print_wpa_ie( wpa_ie, wpa_ie_len ));
3187 }
3188
3189 DBG_TRACE( DbgInfo, "(%s) flags : 0x%04x.\n",
3190 lp->dev->name, probe_rsp->flags );
3191 }
3192
3193 DBG_TRACE( DbgInfo, "\n\n" );
3194
3195 if ( probe_rsp->length == 1 ) {
3196 DBG_TRACE( DbgInfo, "SCAN COMPLETE\n" );
3197 lp->probe_results.num_aps = lp->probe_num_aps;
3198 lp->probe_results.scan_complete = TRUE;
3199
3200
3201 lp->probe_num_aps = 0;
3202
3203
3204 wl_wext_event_scan_complete( lp->dev );
3205 } else {
3206
3207
3208 if ( lp->probe_num_aps == 0 ) {
3209
3210
3211 memcpy( &( lp->probe_results.ProbeTable[lp->probe_num_aps] ),
3212 probe_rsp, sizeof( PROBE_RESP ));
3213
3214
3215 lp->probe_num_aps++;
3216 } else {
3217 int count;
3218 int unique = 1;
3219
3220 for( count = 0; count < lp->probe_num_aps; count++ ) {
3221 if ( memcmp( &( probe_rsp->BSSID ),
3222 lp->probe_results.ProbeTable[count].BSSID,
3223 ETH_ALEN ) == 0 ) {
3224 unique = 0;
3225 }
3226 }
3227
3228 if ( unique ) {
3229
3230
3231
3232 if ( lp->probe_num_aps < MAX_NAPS )
3233 {
3234 memcpy( &( lp->probe_results.ProbeTable[lp->probe_num_aps] ),
3235 probe_rsp, sizeof( PROBE_RESP ));
3236 }
3237 else
3238 {
3239 DBG_WARNING( DbgInfo, "Num of scan results exceeds storage, truncating\n" );
3240 }
3241
3242
3243
3244
3245 lp->probe_num_aps++;
3246 }
3247 }
3248 }
3249 }
3250
3251 break;
3252
3253 case CFG_LINK_STAT:
3254#define ls ((LINK_STATUS_STRCT *)ltv)
3255 DBG_TRACE( DbgInfo, "CFG_LINK_STAT\n" );
3256
3257 switch( ls->linkStatus ) {
3258 case 1:
3259 DBG_TRACE( DbgInfo, "Link Status : Connected\n" );
3260 wl_wext_event_ap( lp->dev );
3261 break;
3262
3263 case 2:
3264 DBG_TRACE( DbgInfo, "Link Status : Disconnected\n" );
3265 break;
3266
3267 case 3:
3268 DBG_TRACE( DbgInfo, "Link Status : Access Point Change\n" );
3269 break;
3270
3271 case 4:
3272 DBG_TRACE( DbgInfo, "Link Status : Access Point Out of Range\n" );
3273 break;
3274
3275 case 5:
3276 DBG_TRACE( DbgInfo, "Link Status : Access Point In Range\n" );
3277 break;
3278
3279 default:
3280 DBG_TRACE( DbgInfo, "Link Status : UNKNOWN (0x%04x)\n",
3281 ls->linkStatus );
3282 break;
3283 }
3284
3285 break;
3286#undef ls
3287
3288 case CFG_ASSOC_STAT:
3289 DBG_TRACE( DbgInfo, "CFG_ASSOC_STAT\n" );
3290
3291 {
3292 ASSOC_STATUS_STRCT *as = (ASSOC_STATUS_STRCT *)ltv;
3293
3294 switch( as->assocStatus ) {
3295 case 1:
3296 DBG_TRACE( DbgInfo, "Association Status : STA Associated\n" );
3297 break;
3298
3299 case 2:
3300 DBG_TRACE( DbgInfo, "Association Status : STA Reassociated\n" );
3301 break;
3302
3303 case 3:
3304 DBG_TRACE( DbgInfo, "Association Status : STA Disassociated\n" );
3305 break;
3306
3307 default:
3308 DBG_TRACE( DbgInfo, "Association Status : UNKNOWN (0x%04x)\n",
3309 as->assocStatus );
3310 break;
3311 }
3312
3313 DBG_TRACE(DbgInfo, "STA Address : %pM\n",
3314 as->staAddr);
3315
3316 if (( as->assocStatus == 2 ) && ( as->len == 8 )) {
3317 DBG_TRACE(DbgInfo, "Old AP Address : %pM\n",
3318 as->oldApAddr);
3319 }
3320 }
3321
3322 break;
3323
3324 case CFG_SECURITY_STAT:
3325 DBG_TRACE( DbgInfo, "CFG_SECURITY_STAT\n" );
3326
3327 {
3328 SECURITY_STATUS_STRCT *ss = (SECURITY_STATUS_STRCT *)ltv;
3329
3330 switch( ss->securityStatus ) {
3331 case 1:
3332 DBG_TRACE( DbgInfo, "Security Status : Dissassociate [AP]\n" );
3333 break;
3334
3335 case 2:
3336 DBG_TRACE( DbgInfo, "Security Status : Deauthenticate [AP]\n" );
3337 break;
3338
3339 case 3:
3340 DBG_TRACE( DbgInfo, "Security Status : Authenticate Fail [STA] or [AP]\n" );
3341 break;
3342
3343 case 4:
3344 DBG_TRACE( DbgInfo, "Security Status : MIC Fail\n" );
3345 break;
3346
3347 case 5:
3348 DBG_TRACE( DbgInfo, "Security Status : Associate Fail\n" );
3349 break;
3350
3351 default:
3352 DBG_TRACE( DbgInfo, "Security Status : UNKNOWN %d\n",
3353 ss->securityStatus );
3354 break;
3355 }
3356
3357 DBG_TRACE(DbgInfo, "STA Address : %pM\n",
3358 ss->staAddr);
3359
3360 DBG_TRACE(DbgInfo, "Reason : 0x%04x\n",
3361 ss->reason);
3362 }
3363
3364 break;
3365
3366 case CFG_WMP:
3367 DBG_TRACE( DbgInfo, "CFG_WMP, size is %d bytes\n", ltv->len );
3368 {
3369 WMP_RSP_STRCT *wmp_rsp = (WMP_RSP_STRCT *)ltv;
3370
3371 DBG_TRACE( DbgInfo, "CFG_WMP, pdu type is 0x%x\n",
3372 wmp_rsp->wmpRsp.wmpHdr.type );
3373
3374 switch( wmp_rsp->wmpRsp.wmpHdr.type ) {
3375 case WVLAN_WMP_PDU_TYPE_LT_RSP:
3376 {
3377#if DBG
3378 LINKTEST_RSP_STRCT *lt_rsp = (LINKTEST_RSP_STRCT *)ltv;
3379#endif
3380 DBG_TRACE( DbgInfo, "LINK TEST RESULT\n" );
3381 DBG_TRACE( DbgInfo, "================\n" );
3382 DBG_TRACE( DbgInfo, "Length : %d.\n", lt_rsp->len );
3383
3384 DBG_TRACE( DbgInfo, "Name : %s.\n", lt_rsp->ltRsp.ltRsp.name );
3385 DBG_TRACE( DbgInfo, "Signal Level : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.signal );
3386 DBG_TRACE( DbgInfo, "Noise Level : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.noise );
3387 DBG_TRACE( DbgInfo, "Receive Flow : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.rxFlow );
3388 DBG_TRACE( DbgInfo, "Data Rate : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.dataRate );
3389 DBG_TRACE( DbgInfo, "Protocol : 0x%04x.\n", lt_rsp->ltRsp.ltRsp.protocol );
3390 DBG_TRACE( DbgInfo, "Station : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.station );
3391 DBG_TRACE( DbgInfo, "Data Rate Cap : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.dataRateCap );
3392
3393 DBG_TRACE( DbgInfo, "Power Mgmt : 0x%02x 0x%02x 0x%02x 0x%02x.\n",
3394 lt_rsp->ltRsp.ltRsp.powerMgmt[0],
3395 lt_rsp->ltRsp.ltRsp.powerMgmt[1],
3396 lt_rsp->ltRsp.ltRsp.powerMgmt[2],
3397 lt_rsp->ltRsp.ltRsp.powerMgmt[3] );
3398
3399 DBG_TRACE( DbgInfo, "Robustness : 0x%02x 0x%02x 0x%02x 0x%02x.\n",
3400 lt_rsp->ltRsp.ltRsp.robustness[0],
3401 lt_rsp->ltRsp.ltRsp.robustness[1],
3402 lt_rsp->ltRsp.ltRsp.robustness[2],
3403 lt_rsp->ltRsp.ltRsp.robustness[3] );
3404
3405 DBG_TRACE( DbgInfo, "Scaling : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.scaling );
3406 }
3407
3408 break;
3409
3410 default:
3411 break;
3412 }
3413 }
3414
3415 break;
3416
3417 case CFG_NULL:
3418 DBG_TRACE( DbgInfo, "CFG_NULL\n" );
3419 break;
3420
3421 case CFG_UPDATED_INFO_RECORD:
3422 DBG_TRACE( DbgInfo, "UPDATED INFORMATION RECORD\n" );
3423
3424 ltv_val = CNV_INT_TO_LITTLE( ltv->u.u16[0] );
3425
3426
3427 switch( ltv_val ) {
3428 case CFG_CUR_COUNTRY_INFO:
3429 DBG_TRACE( DbgInfo, "Updated country info\n" );
3430
3431
3432
3433 wl_connect( lp );
3434 break;
3435
3436 case CFG_PORT_STAT:
3437
3438
3439 break;
3440
3441 default:
3442 DBG_WARNING( DbgInfo, "Unknown RID: 0x%04x\n", ltv_val );
3443 }
3444
3445 break;
3446
3447 default:
3448 DBG_TRACE( DbgInfo, "UNKNOWN MESSAGE: 0x%04x\n", ltv->typ );
3449 break;
3450 }
3451 DBG_LEAVE( DbgInfo );
3452 return;
3453}
3454
3455#endif
3456
3457#ifdef USE_WDS
3458
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477void wl_wds_netdev_register( struct wl_private *lp )
3478{
3479 int count;
3480
3481 DBG_FUNC( "wl_wds_netdev_register" );
3482 DBG_ENTER( DbgInfo );
3483
3484 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
3485 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
3486 if ( WVLAN_VALID_MAC_ADDRESS( lp->wds_port[count].wdsAddress )) {
3487 if ( register_netdev( lp->wds_port[count].dev ) != 0 ) {
3488 DBG_WARNING( DbgInfo, "net device for WDS port %d could not be registered\n",
3489 ( count + 1 ));
3490 }
3491 lp->wds_port[count].is_registered = TRUE;
3492
3493
3494 memcpy( lp->wds_port[count].dev->dev_addr, lp->MACAddress, ETH_ALEN );
3495 lp->wds_port[count].dev->addr_len = ETH_ALEN;
3496 }
3497 }
3498 }
3499 DBG_LEAVE( DbgInfo );
3500 return;
3501}
3502
3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
3514
3515
3516
3517
3518
3519
3520
3521
3522
3523
3524void wl_wds_netdev_deregister( struct wl_private *lp )
3525{
3526 int count;
3527
3528 DBG_FUNC( "wl_wds_netdev_deregister" );
3529 DBG_ENTER( DbgInfo );
3530 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
3531 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
3532 if ( WVLAN_VALID_MAC_ADDRESS( lp->wds_port[count].wdsAddress )) {
3533 unregister_netdev( lp->wds_port[count].dev );
3534 }
3535 lp->wds_port[count].is_registered = FALSE;
3536 }
3537 }
3538 DBG_LEAVE( DbgInfo );
3539 return;
3540}
3541
3542#endif
3543
3544
3545#if 0
3546
3547
3548
3549static void printf_hcf_16(struct seq_file *m, const char *s, hcf_16 *p, int n)
3550{
3551 int i, len;
3552
3553 seq_printf(m, "%-20.20s: ", s);
3554 len = 22;
3555
3556 for (i = 0; i < n; i++) {
3557 if (len % 80 > 75)
3558 seq_putc(m, '\n');
3559 seq_printf(m, "%04X ", p[i]);
3560 }
3561 seq_putc(m, '\n');
3562}
3563
3564static void printf_hcf_8(struct seq_file *m, const char *s, hcf_8 *p, int n)
3565{
3566 int i, len;
3567
3568 seq_printf(m, "%-20.20s: ", s);
3569 len = 22;
3570
3571 for (i = 0; i <= n; i++) {
3572 if (len % 80 > 77)
3573 seq_putc(m, '\n');
3574 seq_printf(m, "%02X ", p[i]);
3575 }
3576 seq_putc(m, '\n');
3577}
3578
3579static void printf_strct(struct seq_file *m, const char *s, hcf_16 *p)
3580{
3581 int i, len;
3582
3583 seq_printf(m, "%-20.20s: ", s);
3584 len = 22;
3585
3586 for ( i = 0; i <= *p; i++ ) {
3587 if (len % 80 > 75)
3588 seq_putc(m, '\n');
3589 seq_printf(m,"%04X ", p[i]);
3590 }
3591 seq_putc(m, '\n');
3592}
3593
3594int scull_read_procmem(struct seq_file *m, void *v)
3595{
3596 struct wl_private *lp = m->private;
3597 IFBP ifbp;
3598 CFG_HERMES_TALLIES_STRCT *p;
3599
3600 if (lp == NULL) {
3601 seq_puts(m, "No wl_private in scull_read_procmem\n" );
3602 } else if ( lp->wlags49_type == 0 ){
3603 ifbp = &lp->hcfCtx;
3604 seq_printf(m, "Magic: 0x%04X\n", ifbp->IFB_Magic );
3605 seq_printf(m, "IOBase: 0x%04X\n", ifbp->IFB_IOBase );
3606 seq_printf(m, "LinkStat: 0x%04X\n", ifbp->IFB_LinkStat );
3607 seq_printf(m, "DSLinkStat: 0x%04X\n", ifbp->IFB_DSLinkStat );
3608 seq_printf(m, "TickIni: 0x%08lX\n", ifbp->IFB_TickIni );
3609 seq_printf(m, "TickCnt: 0x%04X\n", ifbp->IFB_TickCnt );
3610 seq_printf(m, "IntOffCnt: 0x%04X\n", ifbp->IFB_IntOffCnt );
3611 printf_hcf_16(m, "IFB_FWIdentity",
3612 &ifbp->IFB_FWIdentity.len, ifbp->IFB_FWIdentity.len + 1 );
3613 } else if ( lp->wlags49_type == 1 ) {
3614 seq_printf(m, "Channel: 0x%04X\n", lp->Channel );
3615
3616
3617
3618#ifdef WIRELESS_EXT
3619
3620
3621
3622
3623#endif
3624 seq_printf(m, "IFB: 0x%p\n", &lp->hcfCtx );
3625 seq_printf(m, "flags: %#.8lX\n", lp->flags );
3626 seq_printf(m, "DebugFlag(wl_private) 0x%04X\n", lp->DebugFlag );
3627#if DBG
3628 seq_printf(m, "DebugFlag (DbgInfo): 0x%08lX\n", DbgInfo->DebugFlag );
3629#endif
3630 seq_printf(m, "is_registered: 0x%04X\n", lp->is_registered );
3631
3632 printf_strct( m, "driverInfo", (hcf_16*)&lp->driverInfo );
3633
3634 printf_strct( m, "driverIdentity", (hcf_16*)&lp->driverIdentity );
3635
3636 printf_strct( m, "StationIdentity", (hcf_16*)&lp->StationIdentity );
3637
3638 printf_strct( m, "PrimaryIdentity", (hcf_16*)&lp->hcfCtx.IFB_PRIIdentity );
3639 printf_strct( m, "PrimarySupplier", (hcf_16*)&lp->hcfCtx.IFB_PRISup );
3640
3641 printf_strct( m, "NICIdentity", (hcf_16*)&lp->NICIdentity );
3642
3643 seq_printf(m, "txBytes: 0x%08lX\n", lp->txBytes );
3644 seq_printf(m, "maxPort: 0x%04X\n", lp->maxPort );
3645
3646
3647
3648
3649
3650
3651
3652 seq_printf(m, "PortType: 0x%04X\n", lp->PortType );
3653 seq_printf(m, "Channel: 0x%04X\n", lp->Channel );
3654
3655 seq_printf(m, "TxRateControl[2]: 0x%04X 0x%04X\n",
3656 lp->TxRateControl[0], lp->TxRateControl[1] );
3657 seq_printf(m, "DistanceBetweenAPs: 0x%04X\n", lp->DistanceBetweenAPs );
3658 seq_printf(m, "RTSThreshold: 0x%04X\n", lp->RTSThreshold );
3659 seq_printf(m, "PMEnabled: 0x%04X\n", lp->PMEnabled );
3660 seq_printf(m, "MicrowaveRobustness: 0x%04X\n", lp->MicrowaveRobustness );
3661 seq_printf(m, "CreateIBSS: 0x%04X\n", lp->CreateIBSS );
3662 seq_printf(m, "MulticastReceive: 0x%04X\n", lp->MulticastReceive );
3663 seq_printf(m, "MaxSleepDuration: 0x%04X\n", lp->MaxSleepDuration );
3664
3665 printf_hcf_8(m, "MACAddress", lp->MACAddress, ETH_ALEN );
3666
3667 seq_printf(m, "NetworkName: %.32s\n", lp->NetworkName );
3668
3669 seq_printf(m, "EnableEncryption: 0x%04X\n", lp->EnableEncryption );
3670
3671 printf_hcf_8( m, "Key1", lp->Key1, MAX_KEY_LEN );
3672
3673
3674
3675 seq_printf(m, "TransmitKeyID: 0x%04X\n", lp->TransmitKeyID );
3676
3677
3678
3679 seq_printf(m, "driverEnable: 0x%04X\n", lp->driverEnable );
3680 seq_printf(m, "wolasEnable: 0x%04X\n", lp->wolasEnable );
3681 seq_printf(m, "atimWindow: 0x%04X\n", lp->atimWindow );
3682 seq_printf(m, "holdoverDuration: 0x%04X\n", lp->holdoverDuration );
3683
3684 seq_printf(m, "authentication: 0x%04X\n", lp->authentication );
3685 seq_printf(m, "promiscuousMode: 0x%04X\n", lp->promiscuousMode );
3686 seq_printf(m, "DownloadFirmware: 0x%04X\n", lp->DownloadFirmware );
3687 seq_printf(m, "AuthKeyMgmtSuite: 0x%04X\n", lp->AuthKeyMgmtSuite );
3688 seq_printf(m, "loadBalancing: 0x%04X\n", lp->loadBalancing );
3689 seq_printf(m, "mediumDistribution: 0x%04X\n", lp->mediumDistribution );
3690 seq_printf(m, "txPowLevel: 0x%04X\n", lp->txPowLevel );
3691
3692
3693
3694
3695 seq_printf(m, "connectionControl: 0x%04X\n", lp->connectionControl );
3696
3697 seq_printf(m, "ownBeaconInterval: 0x%04X\n", lp->ownBeaconInterval );
3698 seq_printf(m, "coexistence: 0x%04X\n", lp->coexistence );
3699
3700
3701
3702
3703 seq_printf(m, "netif_queue_on: 0x%04X\n", lp->netif_queue_on );
3704 seq_printf(m, "txQ_count: 0x%04X\n", lp->txQ_count );
3705
3706
3707
3708
3709
3710 seq_printf(m, "probe_num_aps: 0x%04X\n", lp->probe_num_aps );
3711 seq_printf(m, "use_dma: 0x%04X\n", lp->use_dma );
3712
3713#ifdef USE_RTS
3714 seq_printf(m, "useRTS: 0x%04X\n", lp->useRTS );
3715#endif
3716#if 1
3717
3718
3719 seq_printf(m, "DTIMPeriod: 0x%04X\n", lp->DTIMPeriod );
3720 seq_printf(m, "multicastPMBuffering: 0x%04X\n", lp->multicastPMBuffering );
3721 seq_printf(m, "RejectAny: 0x%04X\n", lp->RejectAny );
3722 seq_printf(m, "ExcludeUnencrypted: 0x%04X\n", lp->ExcludeUnencrypted );
3723 seq_printf(m, "intraBSSRelay: 0x%04X\n", lp->intraBSSRelay );
3724 seq_printf(m, "wlags49_type: 0x%08lX\n", lp->wlags49_type );
3725#ifdef USE_WDS
3726
3727#endif
3728#endif
3729 } else if ( lp->wlags49_type == 2 ){
3730 seq_printf(m, "tallies to be added\n" );
3731
3732 p = &lp->hcfCtx.IFB_NIC_Tallies;
3733 seq_printf(m, "TxUnicastFrames: %08lX\n", p->TxUnicastFrames );
3734 seq_printf(m, "TxMulticastFrames: %08lX\n", p->TxMulticastFrames );
3735 seq_printf(m, "TxFragments: %08lX\n", p->TxFragments );
3736 seq_printf(m, "TxUnicastOctets: %08lX\n", p->TxUnicastOctets );
3737 seq_printf(m, "TxMulticastOctets: %08lX\n", p->TxMulticastOctets );
3738 seq_printf(m, "TxDeferredTransmissions: %08lX\n", p->TxDeferredTransmissions );
3739 seq_printf(m, "TxSingleRetryFrames: %08lX\n", p->TxSingleRetryFrames );
3740 seq_printf(m, "TxMultipleRetryFrames: %08lX\n", p->TxMultipleRetryFrames );
3741 seq_printf(m, "TxRetryLimitExceeded: %08lX\n", p->TxRetryLimitExceeded );
3742 seq_printf(m, "TxDiscards: %08lX\n", p->TxDiscards );
3743 seq_printf(m, "RxUnicastFrames: %08lX\n", p->RxUnicastFrames );
3744 seq_printf(m, "RxMulticastFrames: %08lX\n", p->RxMulticastFrames );
3745 seq_printf(m, "RxFragments: %08lX\n", p->RxFragments );
3746 seq_printf(m, "RxUnicastOctets: %08lX\n", p->RxUnicastOctets );
3747 seq_printf(m, "RxMulticastOctets: %08lX\n", p->RxMulticastOctets );
3748 seq_printf(m, "RxFCSErrors: %08lX\n", p->RxFCSErrors );
3749 seq_printf(m, "RxDiscardsNoBuffer: %08lX\n", p->RxDiscardsNoBuffer );
3750 seq_printf(m, "TxDiscardsWrongSA: %08lX\n", p->TxDiscardsWrongSA );
3751 seq_printf(m, "RxWEPUndecryptable: %08lX\n", p->RxWEPUndecryptable );
3752 seq_printf(m, "RxMsgInMsgFragments: %08lX\n", p->RxMsgInMsgFragments );
3753 seq_printf(m, "RxMsgInBadMsgFragments: %08lX\n", p->RxMsgInBadMsgFragments );
3754 seq_printf(m, "RxDiscardsWEPICVError: %08lX\n", p->RxDiscardsWEPICVError );
3755 seq_printf(m, "RxDiscardsWEPExcluded: %08lX\n", p->RxDiscardsWEPExcluded );
3756#if (HCF_EXT) & HCF_EXT_TALLIES_FW
3757
3758#endif
3759 } else if ( lp->wlags49_type & 0x8000 ) {
3760#if DBG
3761 DbgInfo->DebugFlag = lp->wlags49_type & 0x7FFF;
3762#endif
3763 lp->wlags49_type = 0;
3764 } else {
3765 seq_printf(m, "unknown value for wlags49_type: 0x%08lX\n", lp->wlags49_type );
3766 seq_puts(m,
3767 "0x0000 - IFB\n"
3768 "0x0001 - wl_private\n"
3769 "0x0002 - Tallies\n"
3770 "0x8xxx - Change debufflag\n"
3771 "ERROR 0001\nWARNING 0002\nNOTICE 0004\nTRACE 0008\n"
3772 "VERBOSE 0010\nPARAM 0020\nBREAK 0040\nRX 0100\n"
3773 "TX 0200\nDS 0400\n");
3774 }
3775 return 0;
3776}
3777
3778static int write_int(struct file *file, const char *buffer, unsigned long count, void *data)
3779{
3780 static char proc_number[11];
3781 unsigned int nr = 0;
3782
3783 DBG_FUNC( "write_int" );
3784 DBG_ENTER( DbgInfo );
3785
3786 if (count > 9) {
3787 count = -EINVAL;
3788 } else if ( copy_from_user(proc_number, buffer, count) ) {
3789 count = -EFAULT;
3790 }
3791 if (count > 0 ) {
3792 proc_number[count] = 0;
3793 nr = simple_strtoul(proc_number , NULL, 0);
3794 *(unsigned int *)data = nr;
3795 if ( nr & 0x8000 ) {
3796#if DBG
3797 DbgInfo->DebugFlag = nr & 0x7FFF;
3798#endif
3799 }
3800 }
3801 DBG_PRINT( "value: %08X\n", nr );
3802 DBG_LEAVE( DbgInfo );
3803 return count;
3804}
3805
3806#endif
3807
3808#ifdef DN554
3809#define RUN_AT(x) (jiffies+(x))
3810#define DS_OOR 0x8000
3811
3812 lp->timer_oor_cnt = DS_OOR;
3813 init_timer( &lp->timer_oor );
3814 lp->timer_oor.function = timer_oor;
3815 lp->timer_oor.data = (unsigned long)lp;
3816 lp->timer_oor.expires = RUN_AT( 3 * HZ );
3817 add_timer( &lp->timer_oor );
3818 printk(KERN_NOTICE "wl_enable: %ld\n", jiffies );
3819#endif
3820#ifdef DN554
3821
3822
3823
3824
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834
3835
3836
3837
3838void timer_oor( u_long arg )
3839{
3840 struct wl_private *lp = (struct wl_private *)arg;
3841
3842
3843
3844 DBG_FUNC( "timer_oor" );
3845 DBG_ENTER( DbgInfo );
3846 DBG_PARAM( DbgInfo, "arg", "0x%08lx", arg );
3847
3848 printk(KERN_NOTICE "timer_oor: %ld 0x%04X\n", jiffies, lp->timer_oor_cnt );
3849 lp->timer_oor_cnt += 10;
3850 if ( (lp->timer_oor_cnt & ~DS_OOR) > 300 ) {
3851 lp->timer_oor_cnt = 300;
3852 }
3853 lp->timer_oor_cnt |= DS_OOR;
3854 init_timer( &lp->timer_oor );
3855 lp->timer_oor.function = timer_oor;
3856 lp->timer_oor.data = (unsigned long)lp;
3857 lp->timer_oor.expires = RUN_AT( (lp->timer_oor_cnt & ~DS_OOR) * HZ );
3858 add_timer( &lp->timer_oor );
3859
3860 DBG_LEAVE( DbgInfo );
3861}
3862#endif
3863
3864MODULE_LICENSE("Dual BSD/GPL");
3865
