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