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 “AS IS” 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
wl_insert(struct net_device * dev)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 ******************************************************************************/
wl_reset(struct net_device * dev)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 ******************************************************************************/
wl_go(struct wl_private * lp)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 ******************************************************************************/
wl_set_wep_keys(struct wl_private * lp)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 ******************************************************************************/
wl_apply(struct wl_private * lp)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 ******************************************************************************/
wl_put_ltv_init(struct wl_private * lp)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 ******************************************************************************/
wl_put_ltv(struct wl_private * lp)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
1997 /* If WEP (or no) keys are being used, write (or clear) them */
1998 if (lp->wext_enc != IW_ENCODE_ALG_TKIP)
1999 wl_set_wep_keys(lp);
2000
2001 /* Country Code */
2002 /* countryInfo, ltvCountryInfo, CFG_CNF_COUNTRY_INFO */
2003
2004 DBG_LEAVE( DbgInfo );
2005 return hcf_status;
2006 } // wl_put_ltv
2007 /*============================================================================*/
2008
2009
2010 /*******************************************************************************
2011 * init_module()
2012 *******************************************************************************
2013 *
2014 * DESCRIPTION:
2015 *
2016 * Load the kernel module.
2017 *
2018 * PARAMETERS:
2019 *
2020 * N/A
2021 *
2022 * RETURNS:
2023 *
2024 * 0 on success
2025 * an errno value otherwise
2026 *
2027 ******************************************************************************/
wl_module_init(void)2028 static int __init wl_module_init( void )
2029 {
2030 int result;
2031 /*------------------------------------------------------------------------*/
2032
2033 DBG_FUNC( "wl_module_init" );
2034
2035 #if DBG
2036 /* Convert "standard" PCMCIA parameter pc_debug to a reasonable DebugFlag value.
2037 * NOTE: The values all fall through to the lower values. */
2038 DbgInfo->DebugFlag = 0;
2039 DbgInfo->DebugFlag = DBG_TRACE_ON; //;?get this mess resolved one day
2040 if ( pc_debug ) switch( pc_debug ) {
2041 case 8:
2042 DbgInfo->DebugFlag |= DBG_DS_ON;
2043 case 7:
2044 DbgInfo->DebugFlag |= DBG_RX_ON | DBG_TX_ON;
2045 case 6:
2046 DbgInfo->DebugFlag |= DBG_PARAM_ON;
2047 case 5:
2048 DbgInfo->DebugFlag |= DBG_TRACE_ON;
2049 case 4:
2050 DbgInfo->DebugFlag |= DBG_VERBOSE_ON;
2051 case 1:
2052 DbgInfo->DebugFlag |= DBG_DEFAULTS;
2053 default:
2054 break;
2055 }
2056 #endif /* DBG */
2057
2058 DBG_ENTER( DbgInfo );
2059 printk(KERN_INFO "%s\n", VERSION_INFO);
2060 printk(KERN_INFO "*** Modified for kernel 2.6 by Henk de Groot <pe1dnn@amsat.org>\n");
2061 printk(KERN_INFO "*** Based on 7.18 version by Andrey Borzenkov <arvidjaar@mail.ru> $Revision: 39 $\n");
2062
2063
2064 // ;?#if (HCF_TYPE) & HCF_TYPE_AP
2065 // DBG_PRINT( "Access Point Mode (AP) Support: YES\n" );
2066 // #else
2067 // DBG_PRINT( "Access Point Mode (AP) Support: NO\n" );
2068 // #endif /* (HCF_TYPE) & HCF_TYPE_AP */
2069
2070 result = wl_adapter_init_module( );
2071 DBG_LEAVE( DbgInfo );
2072 return result;
2073 } // init_module
2074 /*============================================================================*/
2075
2076
2077 /*******************************************************************************
2078 * cleanup_module()
2079 *******************************************************************************
2080 *
2081 * DESCRIPTION:
2082 *
2083 * Unload the kernel module.
2084 *
2085 * PARAMETERS:
2086 *
2087 * N/A
2088 *
2089 * RETURNS:
2090 *
2091 * N/A
2092 *
2093 ******************************************************************************/
wl_module_exit(void)2094 static void __exit wl_module_exit( void )
2095 {
2096 DBG_FUNC( "wl_module_exit" );
2097 DBG_ENTER(DbgInfo);
2098
2099 wl_adapter_cleanup_module( );
2100 #if 0 //SCULL_USE_PROC /* don't waste space if unused */
2101 remove_proc_entry( "wlags", NULL ); //;?why so a-symmetric compared to location of create_proc_read_entry
2102 #endif
2103
2104 DBG_LEAVE( DbgInfo );
2105 return;
2106 } // cleanup_module
2107 /*============================================================================*/
2108
2109 module_init(wl_module_init);
2110 module_exit(wl_module_exit);
2111
2112 /*******************************************************************************
2113 * wl_isr()
2114 *******************************************************************************
2115 *
2116 * DESCRIPTION:
2117 *
2118 * The Interrupt Service Routine for the driver.
2119 *
2120 * PARAMETERS:
2121 *
2122 * irq - the irq the interrupt came in on
2123 * dev_id - a buffer containing information about the request
2124 * regs -
2125 *
2126 * RETURNS:
2127 *
2128 * N/A
2129 *
2130 ******************************************************************************/
wl_isr(int irq,void * dev_id,struct pt_regs * regs)2131 irqreturn_t wl_isr( int irq, void *dev_id, struct pt_regs *regs )
2132 {
2133 int events;
2134 struct net_device *dev = (struct net_device *) dev_id;
2135 struct wl_private *lp = NULL;
2136 /*------------------------------------------------------------------------*/
2137 if (( dev == NULL ) || ( !netif_device_present( dev ))) {
2138 return IRQ_NONE;
2139 }
2140
2141 /* Set the wl_private pointer (lp), now that we know that dev is non-null */
2142 lp = wl_priv(dev);
2143
2144 #ifdef USE_RTS
2145 if ( lp->useRTS == 1 ) {
2146 DBG_PRINT( "EXITING ISR, IN RTS MODE...\n" );
2147 return;
2148 }
2149 #endif /* USE_RTS */
2150
2151 /* If we have interrupts pending, then put them on a system task
2152 queue. Otherwise turn interrupts back on */
2153 events = hcf_action( &lp->hcfCtx, HCF_ACT_INT_OFF );
2154
2155 if ( events == HCF_INT_PENDING ) {
2156 /* Schedule the ISR handler as a bottom-half task in the
2157 tq_immediate queue */
2158 tasklet_schedule(&lp->task);
2159 } else {
2160 //DBG_PRINT( "NOT OUR INTERRUPT\n" );
2161 hcf_action( &lp->hcfCtx, HCF_ACT_INT_ON );
2162 }
2163
2164 return IRQ_RETVAL(events == HCF_INT_PENDING);
2165 } // wl_isr
2166 /*============================================================================*/
2167
2168
2169 /*******************************************************************************
2170 * wl_isr_handler()
2171 *******************************************************************************
2172 *
2173 * DESCRIPTION:
2174 *
2175 * The ISR handler, scheduled to run in a deferred context by the ISR. This
2176 * is where the ISR's work actually gets done.
2177 *
2178 * PARAMETERS:
2179 *
2180 * lp - a pointer to the device's private adapter structure
2181 *
2182 * RETURNS:
2183 *
2184 * N/A
2185 *
2186 ******************************************************************************/
2187 #define WVLAN_MAX_INT_SERVICES 50
2188
wl_isr_handler(unsigned long p)2189 void wl_isr_handler( unsigned long p )
2190 {
2191 struct net_device *dev;
2192 unsigned long flags;
2193 bool_t stop = TRUE;
2194 int count;
2195 int result;
2196 struct wl_private *lp = (struct wl_private *)p;
2197 /*------------------------------------------------------------------------*/
2198
2199 if ( lp == NULL ) {
2200 DBG_PRINT( "wl_isr_handler lp adapter pointer is NULL!!!\n" );
2201 } else {
2202 wl_lock( lp, &flags );
2203
2204 dev = (struct net_device *)lp->dev;
2205 if ( dev != NULL && netif_device_present( dev ) ) stop = FALSE;
2206 for( count = 0; stop == FALSE && count < WVLAN_MAX_INT_SERVICES; count++ ) {
2207 stop = TRUE;
2208 result = hcf_service_nic( &lp->hcfCtx,
2209 (wci_bufp)lp->lookAheadBuf,
2210 sizeof( lp->lookAheadBuf ));
2211 if ( result == HCF_ERR_MIC ) {
2212 wl_wext_event_mic_failed( dev ); /* Send an event that MIC failed */
2213 //;?this seems wrong if HCF_ERR_MIC coincides with another event, stop gets FALSE
2214 //so why not do it always ;?
2215 }
2216
2217 #ifndef USE_MBOX_SYNC
2218 if ( lp->hcfCtx.IFB_MBInfoLen != 0 ) { /* anything in the mailbox */
2219 wl_mbx( lp );
2220 stop = FALSE;
2221 }
2222 #endif
2223 /* Check for a Link status event */
2224 if ( ( lp->hcfCtx.IFB_LinkStat & CFG_LINK_STAT_FW ) != 0 ) {
2225 wl_process_link_status( lp );
2226 stop = FALSE;
2227 }
2228 /* Check for probe response events */
2229 if ( lp->ProbeResp.infoType != 0 &&
2230 lp->ProbeResp.infoType != 0xFFFF ) {
2231 wl_process_probe_response( lp );
2232 memset( &lp->ProbeResp, 0, sizeof( lp->ProbeResp ));
2233 lp->ProbeResp.infoType = 0xFFFF;
2234 stop = FALSE;
2235 }
2236 /* Check for updated record events */
2237 if ( lp->updatedRecord.len != 0xFFFF ) {
2238 wl_process_updated_record( lp );
2239 lp->updatedRecord.len = 0xFFFF;
2240 stop = FALSE;
2241 }
2242 /* Check for association status events */
2243 if ( lp->assoc_stat.len != 0xFFFF ) {
2244 wl_process_assoc_status( lp );
2245 lp->assoc_stat.len = 0xFFFF;
2246 stop = FALSE;
2247 }
2248 /* Check for security status events */
2249 if ( lp->sec_stat.len != 0xFFFF ) {
2250 wl_process_security_status( lp );
2251 lp->sec_stat.len = 0xFFFF;
2252 stop = FALSE;
2253 }
2254
2255 #ifdef ENABLE_DMA
2256 if ( lp->use_dma ) {
2257 /* Check for DMA Rx packets */
2258 if ( lp->hcfCtx.IFB_DmaPackets & HREG_EV_RDMAD ) {
2259 wl_rx_dma( dev );
2260 stop = FALSE;
2261 }
2262 /* Return Tx DMA descriptors to host */
2263 if ( lp->hcfCtx.IFB_DmaPackets & HREG_EV_TDMAD ) {
2264 wl_pci_dma_hcf_reclaim_tx( lp );
2265 stop = FALSE;
2266 }
2267 }
2268 else
2269 #endif // ENABLE_DMA
2270 {
2271 /* Check for Rx packets */
2272 if ( lp->hcfCtx.IFB_RxLen != 0 ) {
2273 wl_rx( dev );
2274 stop = FALSE;
2275 }
2276 /* Make sure that queued frames get sent */
2277 if ( wl_send( lp )) {
2278 stop = FALSE;
2279 }
2280 }
2281 }
2282 /* We're done, so turn interrupts which were turned off in wl_isr, back on */
2283 hcf_action( &lp->hcfCtx, HCF_ACT_INT_ON );
2284 wl_unlock( lp, &flags );
2285 }
2286 return;
2287 } // wl_isr_handler
2288 /*============================================================================*/
2289
2290
2291 /*******************************************************************************
2292 * wl_remove()
2293 *******************************************************************************
2294 *
2295 * DESCRIPTION:
2296 *
2297 * Notify the adapter that it has been removed. Since the adapter is gone,
2298 * we should no longer try to talk to it.
2299 *
2300 * PARAMETERS:
2301 *
2302 * dev - a pointer to the device's net_device structure
2303 *
2304 * RETURNS:
2305 *
2306 * N/A
2307 *
2308 ******************************************************************************/
wl_remove(struct net_device * dev)2309 void wl_remove( struct net_device *dev )
2310 {
2311 struct wl_private *lp = wl_priv(dev);
2312 unsigned long flags;
2313 /*------------------------------------------------------------------------*/
2314 DBG_FUNC( "wl_remove" );
2315 DBG_ENTER( DbgInfo );
2316
2317 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2318
2319 wl_lock( lp, &flags );
2320
2321 /* stop handling interrupts */
2322 wl_act_int_off( lp );
2323 lp->is_handling_int = WL_NOT_HANDLING_INT;
2324
2325 /*
2326 * Disable the ports: just change state: since the
2327 * card is gone it is useless to talk to it and at
2328 * disconnect all state information is lost anyway.
2329 */
2330 /* Reset portState */
2331 lp->portState = WVLAN_PORT_STATE_DISABLED;
2332
2333 #if 0 //;? (HCF_TYPE) & HCF_TYPE_AP
2334 #ifdef USE_WDS
2335 //wl_disable_wds_ports( lp );
2336 #endif // USE_WDS
2337 #endif /* (HCF_TYPE) & HCF_TYPE_AP */
2338
2339 /* Mark the device as unregistered */
2340 lp->is_registered = FALSE;
2341
2342 /* Deregister the WDS ports as well */
2343 WL_WDS_NETDEV_DEREGISTER( lp );
2344 #ifdef USE_RTS
2345 if ( lp->useRTS == 1 ) {
2346 wl_unlock( lp, &flags );
2347
2348 DBG_LEAVE( DbgInfo );
2349 return;
2350 }
2351 #endif /* USE_RTS */
2352
2353 /* Inform the HCF that the card has been removed */
2354 hcf_connect( &lp->hcfCtx, HCF_DISCONNECT );
2355
2356 wl_unlock( lp, &flags );
2357
2358 DBG_LEAVE( DbgInfo );
2359 return;
2360 } // wl_remove
2361 /*============================================================================*/
2362
2363
2364 /*******************************************************************************
2365 * wl_suspend()
2366 *******************************************************************************
2367 *
2368 * DESCRIPTION:
2369 *
2370 * Power-down and halt the adapter.
2371 *
2372 * PARAMETERS:
2373 *
2374 * dev - a pointer to the device's net_device structure
2375 *
2376 * RETURNS:
2377 *
2378 * N/A
2379 *
2380 ******************************************************************************/
wl_suspend(struct net_device * dev)2381 void wl_suspend( struct net_device *dev )
2382 {
2383 struct wl_private *lp = wl_priv(dev);
2384 unsigned long flags;
2385 /*------------------------------------------------------------------------*/
2386 DBG_FUNC( "wl_suspend" );
2387 DBG_ENTER( DbgInfo );
2388
2389 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2390
2391 /* The adapter is suspended:
2392 Stop the adapter
2393 Power down
2394 */
2395 wl_lock( lp, &flags );
2396
2397 /* Disable interrupt handling */
2398 wl_act_int_off( lp );
2399
2400 /* Disconnect */
2401 wl_disconnect( lp );
2402
2403 /* Disable */
2404 wl_disable( lp );
2405
2406 /* Disconnect from the adapter */
2407 hcf_connect( &lp->hcfCtx, HCF_DISCONNECT );
2408
2409 /* Reset portState to be sure (should have been done by wl_disable */
2410 lp->portState = WVLAN_PORT_STATE_DISABLED;
2411
2412 wl_unlock( lp, &flags );
2413
2414 DBG_LEAVE( DbgInfo );
2415 return;
2416 } // wl_suspend
2417 /*============================================================================*/
2418
2419
2420 /*******************************************************************************
2421 * wl_resume()
2422 *******************************************************************************
2423 *
2424 * DESCRIPTION:
2425 *
2426 * Resume a previously suspended adapter.
2427 *
2428 * PARAMETERS:
2429 *
2430 * dev - a pointer to the device's net_device structure
2431 *
2432 * RETURNS:
2433 *
2434 * N/A
2435 *
2436 ******************************************************************************/
wl_resume(struct net_device * dev)2437 void wl_resume(struct net_device *dev)
2438 {
2439 struct wl_private *lp = wl_priv(dev);
2440 unsigned long flags;
2441 /*------------------------------------------------------------------------*/
2442 DBG_FUNC( "wl_resume" );
2443 DBG_ENTER( DbgInfo );
2444
2445 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2446
2447 wl_lock( lp, &flags );
2448
2449 /* Connect to the adapter */
2450 hcf_connect( &lp->hcfCtx, dev->base_addr );
2451
2452 /* Reset portState */
2453 lp->portState = WVLAN_PORT_STATE_DISABLED;
2454
2455 /* Power might have been off, assume the card lost the firmware*/
2456 lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
2457
2458 /* Reload the firmware and restart */
2459 wl_reset( dev );
2460
2461 /* Resume interrupt handling */
2462 wl_act_int_on( lp );
2463
2464 wl_unlock( lp, &flags );
2465
2466 DBG_LEAVE( DbgInfo );
2467 return;
2468 } // wl_resume
2469 /*============================================================================*/
2470
2471
2472 /*******************************************************************************
2473 * wl_release()
2474 *******************************************************************************
2475 *
2476 * DESCRIPTION:
2477 *
2478 * This function perfroms a check on the device and calls wl_remove() if
2479 * necessary. This function can be used for all bus types, but exists mostly
2480 * for the benefit of the Card Services driver, as there are times when
2481 * wl_remove() does not get called.
2482 *
2483 * PARAMETERS:
2484 *
2485 * dev - a pointer to the device's net_device structure
2486 *
2487 * RETURNS:
2488 *
2489 * N/A
2490 *
2491 ******************************************************************************/
wl_release(struct net_device * dev)2492 void wl_release( struct net_device *dev )
2493 {
2494 struct wl_private *lp = wl_priv(dev);
2495 /*------------------------------------------------------------------------*/
2496 DBG_FUNC( "wl_release" );
2497 DBG_ENTER( DbgInfo );
2498
2499 DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
2500 /* If wl_remove() hasn't been called (i.e. when Card Services is shut
2501 down with the card in the slot), then call it */
2502 if ( lp->is_registered == TRUE ) {
2503 DBG_TRACE( DbgInfo, "Calling unregister_netdev(), as it wasn't called yet\n" );
2504 wl_remove( dev );
2505
2506 lp->is_registered = FALSE;
2507 }
2508
2509 DBG_LEAVE( DbgInfo );
2510 return;
2511 } // wl_release
2512 /*============================================================================*/
2513
2514
2515 /*******************************************************************************
2516 * wl_get_irq_mask()
2517 *******************************************************************************
2518 *
2519 * DESCRIPTION:
2520 *
2521 * Accessor function to retrieve the irq_mask module parameter
2522 *
2523 * PARAMETERS:
2524 *
2525 * N/A
2526 *
2527 * RETURNS:
2528 *
2529 * The irq_mask module parameter
2530 *
2531 ******************************************************************************/
wl_get_irq_mask(void)2532 p_u16 wl_get_irq_mask( void )
2533 {
2534 return irq_mask;
2535 } // wl_get_irq_mask
2536 /*============================================================================*/
2537
2538
2539 /*******************************************************************************
2540 * wl_get_irq_list()
2541 *******************************************************************************
2542 *
2543 * DESCRIPTION:
2544 *
2545 * Accessor function to retrieve the irq_list module parameter
2546 *
2547 * PARAMETERS:
2548 *
2549 * N/A
2550 *
2551 * RETURNS:
2552 *
2553 * The irq_list module parameter
2554 *
2555 ******************************************************************************/
wl_get_irq_list(void)2556 p_s8 * wl_get_irq_list( void )
2557 {
2558 return irq_list;
2559 } // wl_get_irq_list
2560 /*============================================================================*/
2561
2562
2563
2564 /*******************************************************************************
2565 * wl_enable()
2566 *******************************************************************************
2567 *
2568 * DESCRIPTION:
2569 *
2570 * Used to enable MAC ports
2571 *
2572 * PARAMETERS:
2573 *
2574 * lp - pointer to the device's private adapter structure
2575 *
2576 * RETURNS:
2577 *
2578 * N/A
2579 *
2580 ******************************************************************************/
wl_enable(struct wl_private * lp)2581 int wl_enable( struct wl_private *lp )
2582 {
2583 int hcf_status = HCF_SUCCESS;
2584 /*------------------------------------------------------------------------*/
2585 DBG_FUNC( "wl_enable" );
2586 DBG_ENTER( DbgInfo );
2587
2588 if ( lp->portState == WVLAN_PORT_STATE_ENABLED ) {
2589 DBG_TRACE( DbgInfo, "No action: Card already enabled\n" );
2590 } else if ( lp->portState == WVLAN_PORT_STATE_CONNECTED ) {
2591 //;?suspicuous logic, how can you be connected without being enabled so this is probably dead code
2592 DBG_TRACE( DbgInfo, "No action: Card already connected\n" );
2593 } else {
2594 hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_ENABLE );
2595 if ( hcf_status == HCF_SUCCESS ) {
2596 /* Set the status of the NIC to enabled */
2597 lp->portState = WVLAN_PORT_STATE_ENABLED; //;?bad mnemonic, NIC iso PORT
2598 #ifdef ENABLE_DMA
2599 if ( lp->use_dma ) {
2600 wl_pci_dma_hcf_supply( lp ); //;?always succes?
2601 }
2602 #endif
2603 }
2604 }
2605 if ( hcf_status != HCF_SUCCESS ) { //;?make this an assert
2606 DBG_TRACE( DbgInfo, "failed: 0x%x\n", hcf_status );
2607 }
2608 DBG_LEAVE( DbgInfo );
2609 return hcf_status;
2610 } // wl_enable
2611 /*============================================================================*/
2612
2613
2614 #ifdef USE_WDS
2615 /*******************************************************************************
2616 * wl_enable_wds_ports()
2617 *******************************************************************************
2618 *
2619 * DESCRIPTION:
2620 *
2621 * Used to enable the WDS MAC ports 1-6
2622 *
2623 * PARAMETERS:
2624 *
2625 * lp - pointer to the device's private adapter structure
2626 *
2627 * RETURNS:
2628 *
2629 * N/A
2630 *
2631 ******************************************************************************/
wl_enable_wds_ports(struct wl_private * lp)2632 void wl_enable_wds_ports( struct wl_private * lp )
2633 {
2634
2635 DBG_FUNC( "wl_enable_wds_ports" );
2636 DBG_ENTER( DbgInfo );
2637 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ){
2638 DBG_ERROR( DbgInfo, "!!!!;? someone misunderstood something !!!!!\n" );
2639 }
2640 DBG_LEAVE( DbgInfo );
2641 return;
2642 } // wl_enable_wds_ports
2643 #endif /* USE_WDS */
2644 /*============================================================================*/
2645
2646
2647 /*******************************************************************************
2648 * wl_connect()
2649 *******************************************************************************
2650 *
2651 * DESCRIPTION:
2652 *
2653 * Used to connect a MAC port
2654 *
2655 * PARAMETERS:
2656 *
2657 * lp - pointer to the device's private adapter structure
2658 *
2659 * RETURNS:
2660 *
2661 * N/A
2662 *
2663 ******************************************************************************/
wl_connect(struct wl_private * lp)2664 int wl_connect( struct wl_private *lp )
2665 {
2666 int hcf_status;
2667 /*------------------------------------------------------------------------*/
2668
2669 DBG_FUNC( "wl_connect" );
2670 DBG_ENTER( DbgInfo );
2671
2672 if ( lp->portState != WVLAN_PORT_STATE_ENABLED ) {
2673 DBG_TRACE( DbgInfo, "No action: Not in enabled state\n" );
2674 DBG_LEAVE( DbgInfo );
2675 return HCF_SUCCESS;
2676 }
2677 hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_CONNECT );
2678 if ( hcf_status == HCF_SUCCESS ) {
2679 lp->portState = WVLAN_PORT_STATE_CONNECTED;
2680 }
2681 DBG_LEAVE( DbgInfo );
2682 return hcf_status;
2683 } // wl_connect
2684 /*============================================================================*/
2685
2686
2687 /*******************************************************************************
2688 * wl_disconnect()
2689 *******************************************************************************
2690 *
2691 * DESCRIPTION:
2692 *
2693 * Used to disconnect a MAC port
2694 *
2695 * PARAMETERS:
2696 *
2697 * lp - pointer to the device's private adapter structure
2698 *
2699 * RETURNS:
2700 *
2701 * N/A
2702 *
2703 ******************************************************************************/
wl_disconnect(struct wl_private * lp)2704 int wl_disconnect( struct wl_private *lp )
2705 {
2706 int hcf_status;
2707 /*------------------------------------------------------------------------*/
2708
2709 DBG_FUNC( "wl_disconnect" );
2710 DBG_ENTER( DbgInfo );
2711
2712 if ( lp->portState != WVLAN_PORT_STATE_CONNECTED ) {
2713 DBG_TRACE( DbgInfo, "No action: Not in connected state\n" );
2714 DBG_LEAVE( DbgInfo );
2715 return HCF_SUCCESS;
2716 }
2717 hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_DISCONNECT );
2718 if ( hcf_status == HCF_SUCCESS ) {
2719 lp->portState = WVLAN_PORT_STATE_ENABLED;
2720 }
2721 DBG_LEAVE( DbgInfo );
2722 return hcf_status;
2723 } // wl_disconnect
2724 /*============================================================================*/
2725
2726
2727 /*******************************************************************************
2728 * wl_disable()
2729 *******************************************************************************
2730 *
2731 * DESCRIPTION:
2732 *
2733 * Used to disable MAC ports
2734 *
2735 * PARAMETERS:
2736 *
2737 * lp - pointer to the device's private adapter structure
2738 * port - the MAC port to disable
2739 *
2740 * RETURNS:
2741 *
2742 * N/A
2743 *
2744 ******************************************************************************/
wl_disable(struct wl_private * lp)2745 int wl_disable( struct wl_private *lp )
2746 {
2747 int hcf_status = HCF_SUCCESS;
2748 /*------------------------------------------------------------------------*/
2749 DBG_FUNC( "wl_disable" );
2750 DBG_ENTER( DbgInfo );
2751
2752 if ( lp->portState == WVLAN_PORT_STATE_DISABLED ) {
2753 DBG_TRACE( DbgInfo, "No action: Port state is disabled\n" );
2754 } else {
2755 hcf_status = hcf_cntl( &lp->hcfCtx, HCF_CNTL_DISABLE );
2756 if ( hcf_status == HCF_SUCCESS ) {
2757 /* Set the status of the port to disabled */ //;?bad mnemonic use NIC iso PORT
2758 lp->portState = WVLAN_PORT_STATE_DISABLED;
2759
2760 #ifdef ENABLE_DMA
2761 if ( lp->use_dma ) {
2762 wl_pci_dma_hcf_reclaim( lp );
2763 }
2764 #endif
2765 }
2766 }
2767 if ( hcf_status != HCF_SUCCESS ) {
2768 DBG_TRACE( DbgInfo, "failed: 0x%x\n", hcf_status );
2769 }
2770 DBG_LEAVE( DbgInfo );
2771 return hcf_status;
2772 } // wl_disable
2773 /*============================================================================*/
2774
2775
2776 #ifdef USE_WDS
2777 /*******************************************************************************
2778 * wl_disable_wds_ports()
2779 *******************************************************************************
2780 *
2781 * DESCRIPTION:
2782 *
2783 * Used to disable the WDS MAC ports 1-6
2784 *
2785 * PARAMETERS:
2786 *
2787 * lp - pointer to the device's private adapter structure
2788 *
2789 * RETURNS:
2790 *
2791 * N/A
2792 *
2793 ******************************************************************************/
wl_disable_wds_ports(struct wl_private * lp)2794 void wl_disable_wds_ports( struct wl_private * lp )
2795 {
2796
2797 DBG_FUNC( "wl_disable_wds_ports" );
2798 DBG_ENTER( DbgInfo );
2799
2800 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ){
2801 DBG_ERROR( DbgInfo, "!!!!;? someone misunderstood something !!!!!\n" );
2802 }
2803 // if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
2804 // wl_disable( lp, HCF_PORT_1 );
2805 // wl_disable( lp, HCF_PORT_2 );
2806 // wl_disable( lp, HCF_PORT_3 );
2807 // wl_disable( lp, HCF_PORT_4 );
2808 // wl_disable( lp, HCF_PORT_5 );
2809 // wl_disable( lp, HCF_PORT_6 );
2810 // }
2811 DBG_LEAVE( DbgInfo );
2812 return;
2813 } // wl_disable_wds_ports
2814 #endif // USE_WDS
2815 /*============================================================================*/
2816
2817
2818 #ifndef USE_MBOX_SYNC
2819 /*******************************************************************************
2820 * wl_mbx()
2821 *******************************************************************************
2822 *
2823 * DESCRIPTION:
2824 * This function is used to read and process a mailbox message.
2825 *
2826 *
2827 * PARAMETERS:
2828 *
2829 * lp - pointer to the device's private adapter structure
2830 *
2831 * RETURNS:
2832 *
2833 * an HCF status code
2834 *
2835 ******************************************************************************/
wl_mbx(struct wl_private * lp)2836 int wl_mbx( struct wl_private *lp )
2837 {
2838 int hcf_status = HCF_SUCCESS;
2839 /*------------------------------------------------------------------------*/
2840 DBG_FUNC( "wl_mbx" );
2841 DBG_ENTER( DbgInfo );
2842 DBG_TRACE( DbgInfo, "Mailbox Info: IFB_MBInfoLen: %d\n",
2843 lp->hcfCtx.IFB_MBInfoLen );
2844
2845 memset( &( lp->ltvRecord ), 0, sizeof( ltv_t ));
2846
2847 lp->ltvRecord.len = MB_SIZE;
2848 lp->ltvRecord.typ = CFG_MB_INFO;
2849 hcf_status = hcf_get_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
2850
2851 if ( hcf_status != HCF_SUCCESS ) {
2852 DBG_ERROR( DbgInfo, "hcf_get_info returned 0x%x\n", hcf_status );
2853
2854 DBG_LEAVE( DbgInfo );
2855 return hcf_status;
2856 }
2857
2858 if ( lp->ltvRecord.typ == CFG_MB_INFO ) {
2859 DBG_LEAVE( DbgInfo );
2860 return hcf_status;
2861 }
2862 /* Endian translate the mailbox data, then process the message */
2863 wl_endian_translate_mailbox( &( lp->ltvRecord ));
2864 wl_process_mailbox( lp );
2865 DBG_LEAVE( DbgInfo );
2866 return hcf_status;
2867 } // wl_mbx
2868 /*============================================================================*/
2869
2870
2871 /*******************************************************************************
2872 * wl_endian_translate_mailbox()
2873 *******************************************************************************
2874 *
2875 * DESCRIPTION:
2876 *
2877 * This function will perform the tedious task of endian translating all
2878 * fields withtin a mailbox message which need translating.
2879 *
2880 * PARAMETERS:
2881 *
2882 * ltv - pointer to the LTV to endian translate
2883 *
2884 * RETURNS:
2885 *
2886 * none
2887 *
2888 ******************************************************************************/
wl_endian_translate_mailbox(ltv_t * ltv)2889 void wl_endian_translate_mailbox( ltv_t *ltv )
2890 {
2891
2892 DBG_FUNC( "wl_endian_translate_mailbox" );
2893 DBG_ENTER( DbgInfo );
2894 switch( ltv->typ ) {
2895 case CFG_TALLIES:
2896 break;
2897
2898 case CFG_SCAN:
2899 {
2900 int num_aps;
2901 SCAN_RS_STRCT *aps = (SCAN_RS_STRCT *)<v->u.u8[0];
2902
2903 num_aps = (hcf_16)(( (size_t)(ltv->len - 1 ) * 2 ) /
2904 ( sizeof( SCAN_RS_STRCT )));
2905
2906 while( num_aps >= 1 ) {
2907 num_aps--;
2908
2909 aps[num_aps].channel_id =
2910 CNV_LITTLE_TO_INT( aps[num_aps].channel_id );
2911
2912 aps[num_aps].noise_level =
2913 CNV_LITTLE_TO_INT( aps[num_aps].noise_level );
2914
2915 aps[num_aps].signal_level =
2916 CNV_LITTLE_TO_INT( aps[num_aps].signal_level );
2917
2918 aps[num_aps].beacon_interval_time =
2919 CNV_LITTLE_TO_INT( aps[num_aps].beacon_interval_time );
2920
2921 aps[num_aps].capability =
2922 CNV_LITTLE_TO_INT( aps[num_aps].capability );
2923
2924 aps[num_aps].ssid_len =
2925 CNV_LITTLE_TO_INT( aps[num_aps].ssid_len );
2926
2927 aps[num_aps].ssid_val[aps[num_aps].ssid_len] = 0;
2928 }
2929 }
2930 break;
2931
2932 case CFG_ACS_SCAN:
2933 {
2934 PROBE_RESP *probe_resp = (PROBE_RESP *)ltv;
2935
2936 probe_resp->frameControl = CNV_LITTLE_TO_INT( probe_resp->frameControl );
2937 probe_resp->durID = CNV_LITTLE_TO_INT( probe_resp->durID );
2938 probe_resp->sequence = CNV_LITTLE_TO_INT( probe_resp->sequence );
2939 probe_resp->dataLength = CNV_LITTLE_TO_INT( probe_resp->dataLength );
2940 #ifndef WARP
2941 probe_resp->lenType = CNV_LITTLE_TO_INT( probe_resp->lenType );
2942 #endif // WARP
2943 probe_resp->beaconInterval = CNV_LITTLE_TO_INT( probe_resp->beaconInterval );
2944 probe_resp->capability = CNV_LITTLE_TO_INT( probe_resp->capability );
2945 probe_resp->flags = CNV_LITTLE_TO_INT( probe_resp->flags );
2946 }
2947 break;
2948
2949 case CFG_LINK_STAT:
2950 #define ls ((LINK_STATUS_STRCT *)ltv)
2951 ls->linkStatus = CNV_LITTLE_TO_INT( ls->linkStatus );
2952 break;
2953 #undef ls
2954
2955 case CFG_ASSOC_STAT:
2956 {
2957 ASSOC_STATUS_STRCT *as = (ASSOC_STATUS_STRCT *)ltv;
2958
2959 as->assocStatus = CNV_LITTLE_TO_INT( as->assocStatus );
2960 }
2961 break;
2962
2963 case CFG_SECURITY_STAT:
2964 {
2965 SECURITY_STATUS_STRCT *ss = (SECURITY_STATUS_STRCT *)ltv;
2966
2967 ss->securityStatus = CNV_LITTLE_TO_INT( ss->securityStatus );
2968 ss->reason = CNV_LITTLE_TO_INT( ss->reason );
2969 }
2970 break;
2971
2972 case CFG_WMP:
2973 break;
2974
2975 case CFG_NULL:
2976 break;
2977
2978 default:
2979 break;
2980 }
2981
2982 DBG_LEAVE( DbgInfo );
2983 return;
2984 } // wl_endian_translate_mailbox
2985 /*============================================================================*/
2986
2987 /*******************************************************************************
2988 * wl_process_mailbox()
2989 *******************************************************************************
2990 *
2991 * DESCRIPTION:
2992 *
2993 * This function will process the mailbox data.
2994 *
2995 * PARAMETERS:
2996 *
2997 * ltv - pointer to the LTV to be processed.
2998 *
2999 * RETURNS:
3000 *
3001 * none
3002 *
3003 ******************************************************************************/
wl_process_mailbox(struct wl_private * lp)3004 void wl_process_mailbox( struct wl_private *lp )
3005 {
3006 ltv_t *ltv;
3007 hcf_16 ltv_val = 0xFFFF;
3008 /*------------------------------------------------------------------------*/
3009 DBG_FUNC( "wl_process_mailbox" );
3010 DBG_ENTER( DbgInfo );
3011 ltv = &( lp->ltvRecord );
3012
3013 switch( ltv->typ ) {
3014
3015 case CFG_TALLIES:
3016 DBG_TRACE( DbgInfo, "CFG_TALLIES\n" );
3017 break;
3018 case CFG_SCAN:
3019 DBG_TRACE( DbgInfo, "CFG_SCAN\n" );
3020
3021 {
3022 int num_aps;
3023 SCAN_RS_STRCT *aps = (SCAN_RS_STRCT *)<v->u.u8[0];
3024
3025 num_aps = (hcf_16)(( (size_t)(ltv->len - 1 ) * 2 ) /
3026 ( sizeof( SCAN_RS_STRCT )));
3027
3028 lp->scan_results.num_aps = num_aps;
3029
3030 DBG_TRACE( DbgInfo, "Number of APs: %d\n", num_aps );
3031
3032 while( num_aps >= 1 ) {
3033 num_aps--;
3034
3035 DBG_TRACE( DbgInfo, "AP : %d\n", num_aps );
3036 DBG_TRACE( DbgInfo, "=========================\n" );
3037 DBG_TRACE( DbgInfo, "Channel ID : 0x%04x\n",
3038 aps[num_aps].channel_id );
3039 DBG_TRACE( DbgInfo, "Noise Level : 0x%04x\n",
3040 aps[num_aps].noise_level );
3041 DBG_TRACE( DbgInfo, "Signal Level : 0x%04x\n",
3042 aps[num_aps].signal_level );
3043 DBG_TRACE( DbgInfo, "Beacon Interval : 0x%04x\n",
3044 aps[num_aps].beacon_interval_time );
3045 DBG_TRACE( DbgInfo, "Capability : 0x%04x\n",
3046 aps[num_aps].capability );
3047 DBG_TRACE( DbgInfo, "SSID Length : 0x%04x\n",
3048 aps[num_aps].ssid_len );
3049 DBG_TRACE(DbgInfo, "BSSID : %pM\n",
3050 aps[num_aps].bssid);
3051
3052 if ( aps[num_aps].ssid_len != 0 ) {
3053 DBG_TRACE( DbgInfo, "SSID : %s.\n",
3054 aps[num_aps].ssid_val );
3055 } else {
3056 DBG_TRACE( DbgInfo, "SSID : %s.\n", "ANY" );
3057 }
3058
3059 DBG_TRACE( DbgInfo, "\n" );
3060
3061 /* Copy the info to the ScanResult structure in the private
3062 adapter struct */
3063 memcpy( &( lp->scan_results.APTable[num_aps]), &( aps[num_aps] ),
3064 sizeof( SCAN_RS_STRCT ));
3065 }
3066
3067 /* Set scan result to true so that any scan requests will
3068 complete */
3069 lp->scan_results.scan_complete = TRUE;
3070 }
3071
3072 break;
3073 case CFG_ACS_SCAN:
3074 DBG_TRACE( DbgInfo, "CFG_ACS_SCAN\n" );
3075
3076 {
3077 PROBE_RESP *probe_rsp = (PROBE_RESP *)ltv;
3078 hcf_8 *wpa_ie = NULL;
3079 hcf_16 wpa_ie_len = 0;
3080
3081 DBG_TRACE( DbgInfo, "(%s) =========================\n",
3082 lp->dev->name );
3083
3084 DBG_TRACE( DbgInfo, "(%s) length : 0x%04x.\n",
3085 lp->dev->name, probe_rsp->length );
3086
3087 if ( probe_rsp->length > 1 ) {
3088 DBG_TRACE( DbgInfo, "(%s) infoType : 0x%04x.\n",
3089 lp->dev->name, probe_rsp->infoType );
3090
3091 DBG_TRACE( DbgInfo, "(%s) signal : 0x%02x.\n",
3092 lp->dev->name, probe_rsp->signal );
3093
3094 DBG_TRACE( DbgInfo, "(%s) silence : 0x%02x.\n",
3095 lp->dev->name, probe_rsp->silence );
3096
3097 DBG_TRACE( DbgInfo, "(%s) rxFlow : 0x%02x.\n",
3098 lp->dev->name, probe_rsp->rxFlow );
3099
3100 DBG_TRACE( DbgInfo, "(%s) rate : 0x%02x.\n",
3101 lp->dev->name, probe_rsp->rate );
3102
3103 DBG_TRACE( DbgInfo, "(%s) frame cntl : 0x%04x.\n",
3104 lp->dev->name, probe_rsp->frameControl );
3105
3106 DBG_TRACE( DbgInfo, "(%s) durID : 0x%04x.\n",
3107 lp->dev->name, probe_rsp->durID );
3108
3109 DBG_TRACE(DbgInfo, "(%s) address1 : %pM\n",
3110 lp->dev->name, probe_rsp->address1);
3111
3112 DBG_TRACE(DbgInfo, "(%s) address2 : %pM\n",
3113 lp->dev->name, probe_rsp->address2);
3114
3115 DBG_TRACE(DbgInfo, "(%s) BSSID : %pM\n",
3116 lp->dev->name, probe_rsp->BSSID);
3117
3118 DBG_TRACE( DbgInfo, "(%s) sequence : 0x%04x.\n",
3119 lp->dev->name, probe_rsp->sequence );
3120
3121 DBG_TRACE(DbgInfo, "(%s) address4 : %pM\n",
3122 lp->dev->name, probe_rsp->address4);
3123
3124 DBG_TRACE( DbgInfo, "(%s) datalength : 0x%04x.\n",
3125 lp->dev->name, probe_rsp->dataLength );
3126
3127 DBG_TRACE(DbgInfo, "(%s) DA : %pM\n",
3128 lp->dev->name, probe_rsp->DA);
3129
3130 DBG_TRACE(DbgInfo, "(%s) SA : %pM\n",
3131 lp->dev->name, probe_rsp->SA);
3132
3133 //DBG_TRACE( DbgInfo, "(%s) lenType : 0x%04x.\n",
3134 // lp->dev->name, probe_rsp->lenType );
3135
3136 DBG_TRACE(DbgInfo, "(%s) timeStamp : "
3137 "%d.%d.%d.%d.%d.%d.%d.%d\n",
3138 lp->dev->name,
3139 probe_rsp->timeStamp[0],
3140 probe_rsp->timeStamp[1],
3141 probe_rsp->timeStamp[2],
3142 probe_rsp->timeStamp[3],
3143 probe_rsp->timeStamp[4],
3144 probe_rsp->timeStamp[5],
3145 probe_rsp->timeStamp[6],
3146 probe_rsp->timeStamp[7]);
3147
3148 DBG_TRACE( DbgInfo, "(%s) beaconInt : 0x%04x.\n",
3149 lp->dev->name, probe_rsp->beaconInterval );
3150
3151 DBG_TRACE( DbgInfo, "(%s) capability : 0x%04x.\n",
3152 lp->dev->name, probe_rsp->capability );
3153
3154 DBG_TRACE( DbgInfo, "(%s) SSID len : 0x%04x.\n",
3155 lp->dev->name, probe_rsp->rawData[1] );
3156
3157 if ( probe_rsp->rawData[1] > 0 ) {
3158 char ssid[HCF_MAX_NAME_LEN];
3159
3160 memset( ssid, 0, sizeof( ssid ));
3161 strncpy( ssid, &probe_rsp->rawData[2],
3162 probe_rsp->rawData[1] );
3163
3164 DBG_TRACE( DbgInfo, "(%s) SSID : %s\n",
3165 lp->dev->name, ssid );
3166 }
3167
3168 /* Parse out the WPA-IE, if one exists */
3169 wpa_ie = wl_parse_wpa_ie( probe_rsp, &wpa_ie_len );
3170 if ( wpa_ie != NULL ) {
3171 DBG_TRACE( DbgInfo, "(%s) WPA-IE : %s\n",
3172 lp->dev->name, wl_print_wpa_ie( wpa_ie, wpa_ie_len ));
3173 }
3174
3175 DBG_TRACE( DbgInfo, "(%s) flags : 0x%04x.\n",
3176 lp->dev->name, probe_rsp->flags );
3177 }
3178
3179 DBG_TRACE( DbgInfo, "\n\n" );
3180 /* If probe response length is 1, then the scan is complete */
3181 if ( probe_rsp->length == 1 ) {
3182 DBG_TRACE( DbgInfo, "SCAN COMPLETE\n" );
3183 lp->probe_results.num_aps = lp->probe_num_aps;
3184 lp->probe_results.scan_complete = TRUE;
3185
3186 /* Reset the counter for the next scan request */
3187 lp->probe_num_aps = 0;
3188
3189 /* Send a wireless extensions event that the scan completed */
3190 wl_wext_event_scan_complete( lp->dev );
3191 } else {
3192 /* Only copy to the table if the entry is unique; APs sometimes
3193 respond more than once to a probe */
3194 if ( lp->probe_num_aps == 0 ) {
3195 /* Copy the info to the ScanResult structure in the private
3196 adapter struct */
3197 memcpy( &( lp->probe_results.ProbeTable[lp->probe_num_aps] ),
3198 probe_rsp, sizeof( PROBE_RESP ));
3199
3200 /* Increment the number of APs detected */
3201 lp->probe_num_aps++;
3202 } else {
3203 int count;
3204 int unique = 1;
3205
3206 for( count = 0; count < lp->probe_num_aps; count++ ) {
3207 if ( memcmp( &( probe_rsp->BSSID ),
3208 lp->probe_results.ProbeTable[count].BSSID,
3209 ETH_ALEN ) == 0 ) {
3210 unique = 0;
3211 }
3212 }
3213
3214 if ( unique ) {
3215 /* Copy the info to the ScanResult structure in the
3216 private adapter struct. Only copy if there's room in the
3217 table */
3218 if ( lp->probe_num_aps < MAX_NAPS )
3219 {
3220 memcpy( &( lp->probe_results.ProbeTable[lp->probe_num_aps] ),
3221 probe_rsp, sizeof( PROBE_RESP ));
3222 }
3223 else
3224 {
3225 DBG_WARNING( DbgInfo, "Num of scan results exceeds storage, truncating\n" );
3226 }
3227
3228 /* Increment the number of APs detected. Note I do this
3229 here even when I don't copy the probe response to the
3230 buffer in order to detect the overflow condition */
3231 lp->probe_num_aps++;
3232 }
3233 }
3234 }
3235 }
3236
3237 break;
3238
3239 case CFG_LINK_STAT:
3240 #define ls ((LINK_STATUS_STRCT *)ltv)
3241 DBG_TRACE( DbgInfo, "CFG_LINK_STAT\n" );
3242
3243 switch( ls->linkStatus ) {
3244 case 1:
3245 DBG_TRACE( DbgInfo, "Link Status : Connected\n" );
3246 wl_wext_event_ap( lp->dev );
3247 break;
3248
3249 case 2:
3250 DBG_TRACE( DbgInfo, "Link Status : Disconnected\n" );
3251 break;
3252
3253 case 3:
3254 DBG_TRACE( DbgInfo, "Link Status : Access Point Change\n" );
3255 break;
3256
3257 case 4:
3258 DBG_TRACE( DbgInfo, "Link Status : Access Point Out of Range\n" );
3259 break;
3260
3261 case 5:
3262 DBG_TRACE( DbgInfo, "Link Status : Access Point In Range\n" );
3263 break;
3264
3265 default:
3266 DBG_TRACE( DbgInfo, "Link Status : UNKNOWN (0x%04x)\n",
3267 ls->linkStatus );
3268 break;
3269 }
3270
3271 break;
3272 #undef ls
3273
3274 case CFG_ASSOC_STAT:
3275 DBG_TRACE( DbgInfo, "CFG_ASSOC_STAT\n" );
3276
3277 {
3278 ASSOC_STATUS_STRCT *as = (ASSOC_STATUS_STRCT *)ltv;
3279
3280 switch( as->assocStatus ) {
3281 case 1:
3282 DBG_TRACE( DbgInfo, "Association Status : STA Associated\n" );
3283 break;
3284
3285 case 2:
3286 DBG_TRACE( DbgInfo, "Association Status : STA Reassociated\n" );
3287 break;
3288
3289 case 3:
3290 DBG_TRACE( DbgInfo, "Association Status : STA Disassociated\n" );
3291 break;
3292
3293 default:
3294 DBG_TRACE( DbgInfo, "Association Status : UNKNOWN (0x%04x)\n",
3295 as->assocStatus );
3296 break;
3297 }
3298
3299 DBG_TRACE(DbgInfo, "STA Address : %pM\n",
3300 as->staAddr);
3301
3302 if (( as->assocStatus == 2 ) && ( as->len == 8 )) {
3303 DBG_TRACE(DbgInfo, "Old AP Address : %pM\n",
3304 as->oldApAddr);
3305 }
3306 }
3307
3308 break;
3309
3310 case CFG_SECURITY_STAT:
3311 DBG_TRACE( DbgInfo, "CFG_SECURITY_STAT\n" );
3312
3313 {
3314 SECURITY_STATUS_STRCT *ss = (SECURITY_STATUS_STRCT *)ltv;
3315
3316 switch( ss->securityStatus ) {
3317 case 1:
3318 DBG_TRACE( DbgInfo, "Security Status : Dissassociate [AP]\n" );
3319 break;
3320
3321 case 2:
3322 DBG_TRACE( DbgInfo, "Security Status : Deauthenticate [AP]\n" );
3323 break;
3324
3325 case 3:
3326 DBG_TRACE( DbgInfo, "Security Status : Authenticate Fail [STA] or [AP]\n" );
3327 break;
3328
3329 case 4:
3330 DBG_TRACE( DbgInfo, "Security Status : MIC Fail\n" );
3331 break;
3332
3333 case 5:
3334 DBG_TRACE( DbgInfo, "Security Status : Associate Fail\n" );
3335 break;
3336
3337 default:
3338 DBG_TRACE( DbgInfo, "Security Status : UNKNOWN %d\n",
3339 ss->securityStatus );
3340 break;
3341 }
3342
3343 DBG_TRACE(DbgInfo, "STA Address : %pM\n",
3344 ss->staAddr);
3345
3346 DBG_TRACE(DbgInfo, "Reason : 0x%04x\n",
3347 ss->reason);
3348 }
3349
3350 break;
3351
3352 case CFG_WMP:
3353 DBG_TRACE( DbgInfo, "CFG_WMP, size is %d bytes\n", ltv->len );
3354 {
3355 WMP_RSP_STRCT *wmp_rsp = (WMP_RSP_STRCT *)ltv;
3356
3357 DBG_TRACE( DbgInfo, "CFG_WMP, pdu type is 0x%x\n",
3358 wmp_rsp->wmpRsp.wmpHdr.type );
3359
3360 switch( wmp_rsp->wmpRsp.wmpHdr.type ) {
3361 case WVLAN_WMP_PDU_TYPE_LT_RSP:
3362 {
3363 #if DBG
3364 LINKTEST_RSP_STRCT *lt_rsp = (LINKTEST_RSP_STRCT *)ltv;
3365 #endif // DBG
3366 DBG_TRACE( DbgInfo, "LINK TEST RESULT\n" );
3367 DBG_TRACE( DbgInfo, "================\n" );
3368 DBG_TRACE( DbgInfo, "Length : %d.\n", lt_rsp->len );
3369
3370 DBG_TRACE( DbgInfo, "Name : %s.\n", lt_rsp->ltRsp.ltRsp.name );
3371 DBG_TRACE( DbgInfo, "Signal Level : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.signal );
3372 DBG_TRACE( DbgInfo, "Noise Level : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.noise );
3373 DBG_TRACE( DbgInfo, "Receive Flow : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.rxFlow );
3374 DBG_TRACE( DbgInfo, "Data Rate : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.dataRate );
3375 DBG_TRACE( DbgInfo, "Protocol : 0x%04x.\n", lt_rsp->ltRsp.ltRsp.protocol );
3376 DBG_TRACE( DbgInfo, "Station : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.station );
3377 DBG_TRACE( DbgInfo, "Data Rate Cap : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.dataRateCap );
3378
3379 DBG_TRACE( DbgInfo, "Power Mgmt : 0x%02x 0x%02x 0x%02x 0x%02x.\n",
3380 lt_rsp->ltRsp.ltRsp.powerMgmt[0],
3381 lt_rsp->ltRsp.ltRsp.powerMgmt[1],
3382 lt_rsp->ltRsp.ltRsp.powerMgmt[2],
3383 lt_rsp->ltRsp.ltRsp.powerMgmt[3] );
3384
3385 DBG_TRACE( DbgInfo, "Robustness : 0x%02x 0x%02x 0x%02x 0x%02x.\n",
3386 lt_rsp->ltRsp.ltRsp.robustness[0],
3387 lt_rsp->ltRsp.ltRsp.robustness[1],
3388 lt_rsp->ltRsp.ltRsp.robustness[2],
3389 lt_rsp->ltRsp.ltRsp.robustness[3] );
3390
3391 DBG_TRACE( DbgInfo, "Scaling : 0x%02x.\n", lt_rsp->ltRsp.ltRsp.scaling );
3392 }
3393
3394 break;
3395
3396 default:
3397 break;
3398 }
3399 }
3400
3401 break;
3402
3403 case CFG_NULL:
3404 DBG_TRACE( DbgInfo, "CFG_NULL\n" );
3405 break;
3406
3407 case CFG_UPDATED_INFO_RECORD: // Updated Information Record
3408 DBG_TRACE( DbgInfo, "UPDATED INFORMATION RECORD\n" );
3409
3410 ltv_val = CNV_INT_TO_LITTLE( ltv->u.u16[0] );
3411
3412 /* Check and see which RID was updated */
3413 switch( ltv_val ) {
3414 case CFG_CUR_COUNTRY_INFO: // Indicate Passive Scan Completion
3415 DBG_TRACE( DbgInfo, "Updated country info\n" );
3416
3417 /* Do I need to hold off on updating RIDs until the process is
3418 complete? */
3419 wl_connect( lp );
3420 break;
3421
3422 case CFG_PORT_STAT: // Wait for Connect Event
3423 //wl_connect( lp );
3424
3425 break;
3426
3427 default:
3428 DBG_WARNING( DbgInfo, "Unknown RID: 0x%04x\n", ltv_val );
3429 }
3430
3431 break;
3432
3433 default:
3434 DBG_TRACE( DbgInfo, "UNKNOWN MESSAGE: 0x%04x\n", ltv->typ );
3435 break;
3436 }
3437 DBG_LEAVE( DbgInfo );
3438 return;
3439 } // wl_process_mailbox
3440 /*============================================================================*/
3441 #endif /* ifndef USE_MBOX_SYNC */
3442
3443 #ifdef USE_WDS
3444 /*******************************************************************************
3445 * wl_wds_netdev_register()
3446 *******************************************************************************
3447 *
3448 * DESCRIPTION:
3449 *
3450 * This function registers net_device structures with the system's network
3451 * layer for use with the WDS ports.
3452 *
3453 *
3454 * PARAMETERS:
3455 *
3456 * lp - pointer to the device's private adapter structure
3457 *
3458 * RETURNS:
3459 *
3460 * N/A
3461 *
3462 ******************************************************************************/
wl_wds_netdev_register(struct wl_private * lp)3463 void wl_wds_netdev_register( struct wl_private *lp )
3464 {
3465 int count;
3466 /*------------------------------------------------------------------------*/
3467 DBG_FUNC( "wl_wds_netdev_register" );
3468 DBG_ENTER( DbgInfo );
3469 //;?why is there no USE_WDS clause like in wl_enable_wds_ports
3470 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
3471 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
3472 if ( WVLAN_VALID_MAC_ADDRESS( lp->wds_port[count].wdsAddress )) {
3473 if ( register_netdev( lp->wds_port[count].dev ) != 0 ) {
3474 DBG_WARNING( DbgInfo, "net device for WDS port %d could not be registered\n",
3475 ( count + 1 ));
3476 }
3477 lp->wds_port[count].is_registered = TRUE;
3478
3479 /* Fill out the net_device structs with the MAC addr */
3480 memcpy( lp->wds_port[count].dev->dev_addr, lp->MACAddress, ETH_ALEN );
3481 lp->wds_port[count].dev->addr_len = ETH_ALEN;
3482 }
3483 }
3484 }
3485 DBG_LEAVE( DbgInfo );
3486 return;
3487 } // wl_wds_netdev_register
3488 /*============================================================================*/
3489
3490
3491 /*******************************************************************************
3492 * wl_wds_netdev_deregister()
3493 *******************************************************************************
3494 *
3495 * DESCRIPTION:
3496 *
3497 * This function deregisters the WDS net_device structures used by the
3498 * system's network layer.
3499 *
3500 *
3501 * PARAMETERS:
3502 *
3503 * lp - pointer to the device's private adapter structure
3504 *
3505 * RETURNS:
3506 *
3507 * N/A
3508 *
3509 ******************************************************************************/
wl_wds_netdev_deregister(struct wl_private * lp)3510 void wl_wds_netdev_deregister( struct wl_private *lp )
3511 {
3512 int count;
3513 /*------------------------------------------------------------------------*/
3514 DBG_FUNC( "wl_wds_netdev_deregister" );
3515 DBG_ENTER( DbgInfo );
3516 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
3517 for( count = 0; count < NUM_WDS_PORTS; count++ ) {
3518 if ( WVLAN_VALID_MAC_ADDRESS( lp->wds_port[count].wdsAddress )) {
3519 unregister_netdev( lp->wds_port[count].dev );
3520 }
3521 lp->wds_port[count].is_registered = FALSE;
3522 }
3523 }
3524 DBG_LEAVE( DbgInfo );
3525 return;
3526 } // wl_wds_netdev_deregister
3527 /*============================================================================*/
3528 #endif /* USE_WDS */
3529
3530
3531 #if 0 //SCULL_USE_PROC /* don't waste space if unused */
3532 /*
3533 * The proc filesystem: function to read and entry
3534 */
3535 int printf_hcf_16( char *s, char *buf, hcf_16* p, int n );
3536 int printf_hcf_16( char *s, char *buf, hcf_16* p, int n ) {
3537
3538 int i, len;
3539
3540 len = sprintf(buf, "%s", s );
3541 while ( len < 20 ) len += sprintf(buf+len, " " );
3542 len += sprintf(buf+len,": " );
3543 for ( i = 0; i < n; i++ ) {
3544 if ( len % 80 > 75 ) {
3545 len += sprintf(buf+len,"\n" );
3546 }
3547 len += sprintf(buf+len,"%04X ", p[i] );
3548 }
3549 len += sprintf(buf+len,"\n" );
3550 return len;
3551 } // printf_hcf_16
3552
3553 int printf_hcf_8( char *s, char *buf, hcf_8* p, int n );
3554 int printf_hcf_8( char *s, char *buf, hcf_8* p, int n ) {
3555
3556 int i, len;
3557
3558 len = sprintf(buf, "%s", s );
3559 while ( len < 20 ) len += sprintf(buf+len, " " );
3560 len += sprintf(buf+len,": " );
3561 for ( i = 0; i <= n; i++ ) {
3562 if ( len % 80 > 77 ) {
3563 len += sprintf(buf+len,"\n" );
3564 }
3565 len += sprintf(buf+len,"%02X ", p[i] );
3566 }
3567 len += sprintf(buf+len,"\n" );
3568 return len;
3569 } // printf_hcf8
3570
3571 int printf_strct( char *s, char *buf, hcf_16* p );
3572 int printf_strct( char *s, char *buf, hcf_16* p ) {
3573
3574 int i, len;
3575
3576 len = sprintf(buf, "%s", s );
3577 while ( len < 20 ) len += sprintf(buf+len, " " );
3578 len += sprintf(buf+len,": " );
3579 for ( i = 0; i <= *p; i++ ) {
3580 if ( len % 80 > 75 ) {
3581 len += sprintf(buf+len,"\n" );
3582 }
3583 len += sprintf(buf+len,"%04X ", p[i] );
3584 }
3585 len += sprintf(buf+len,"\n" );
3586 return len;
3587 } // printf_strct
3588
3589 int scull_read_procmem(char *buf, char **start, off_t offset, int len, int *eof, void *data )
3590 {
3591 struct wl_private *lp = NULL;
3592 IFBP ifbp;
3593 CFG_HERMES_TALLIES_STRCT *p;
3594
3595 #define LIMIT (PAGE_SIZE-80) /* don't print any more after this size */
3596
3597 len=0;
3598
3599 lp = ((struct net_device *)data)->priv;
3600 if (lp == NULL) {
3601 len += sprintf(buf+len,"No wl_private in scull_read_procmem\n" );
3602 } else if ( lp->wlags49_type == 0 ){
3603 ifbp = &lp->hcfCtx;
3604 len += sprintf(buf+len,"Magic: 0x%04X\n", ifbp->IFB_Magic );
3605 len += sprintf(buf+len,"IOBase: 0x%04X\n", ifbp->IFB_IOBase );
3606 len += sprintf(buf+len,"LinkStat: 0x%04X\n", ifbp->IFB_LinkStat );
3607 len += sprintf(buf+len,"DSLinkStat: 0x%04X\n", ifbp->IFB_DSLinkStat );
3608 len += sprintf(buf+len,"TickIni: 0x%08lX\n", ifbp->IFB_TickIni );
3609 len += sprintf(buf+len,"TickCnt: 0x%04X\n", ifbp->IFB_TickCnt );
3610 len += sprintf(buf+len,"IntOffCnt: 0x%04X\n", ifbp->IFB_IntOffCnt );
3611 len += printf_hcf_16( "IFB_FWIdentity", &buf[len],
3612 &ifbp->IFB_FWIdentity.len, ifbp->IFB_FWIdentity.len + 1 );
3613 } else if ( lp->wlags49_type == 1 ) {
3614 len += sprintf(buf+len,"Channel: 0x%04X\n", lp->Channel );
3615 /****** len += sprintf(buf+len,"slock: %d\n", lp->slock ); */
3616 //x struct tq_struct "task: 0x%04X\n", lp->task );
3617 //x struct net_device_stats "stats: 0x%04X\n", lp->stats );
3618 #ifdef WIRELESS_EXT
3619 //x struct iw_statistics "wstats: 0x%04X\n", lp->wstats );
3620 //x len += sprintf(buf+len,"spy_number: 0x%04X\n", lp->spy_number );
3621 //x u_char spy_address[IW_MAX_SPY][ETH_ALEN];
3622 //x struct iw_quality spy_stat[IW_MAX_SPY];
3623 #endif // WIRELESS_EXT
3624 len += sprintf(buf+len,"IFB: 0x%p\n", &lp->hcfCtx );
3625 len += sprintf(buf+len,"flags: %#.8lX\n", lp->flags ); //;?use this format from now on
3626 len += sprintf(buf+len,"DebugFlag(wl_private) 0x%04X\n", lp->DebugFlag );
3627 #if DBG
3628 len += sprintf(buf+len,"DebugFlag (DbgInfo): 0x%08lX\n", DbgInfo->DebugFlag );
3629 #endif // DBG
3630 len += sprintf(buf+len,"is_registered: 0x%04X\n", lp->is_registered );
3631 //x CFG_DRV_INFO_STRCT "driverInfo: 0x%04X\n", lp->driverInfo );
3632 len += printf_strct( "driverInfo", &buf[len], (hcf_16*)&lp->driverInfo );
3633 //x CFG_IDENTITY_STRCT "driverIdentity: 0x%04X\n", lp->driverIdentity );
3634 len += printf_strct( "driverIdentity", &buf[len], (hcf_16*)&lp->driverIdentity );
3635 //x CFG_FW_IDENTITY_STRCT "StationIdentity: 0x%04X\n", lp->StationIdentity );
3636 len += printf_strct( "StationIdentity", &buf[len], (hcf_16*)&lp->StationIdentity );
3637 //x CFG_PRI_IDENTITY_STRCT "PrimaryIdentity: 0x%04X\n", lp->PrimaryIdentity );
3638 len += printf_strct( "PrimaryIdentity", &buf[len], (hcf_16*)&lp->hcfCtx.IFB_PRIIdentity );
3639 len += printf_strct( "PrimarySupplier", &buf[len], (hcf_16*)&lp->hcfCtx.IFB_PRISup );
3640 //x CFG_PRI_IDENTITY_STRCT "NICIdentity: 0x%04X\n", lp->NICIdentity );
3641 len += printf_strct( "NICIdentity", &buf[len], (hcf_16*)&lp->NICIdentity );
3642 //x ltv_t "ltvRecord: 0x%04X\n", lp->ltvRecord );
3643 len += sprintf(buf+len,"txBytes: 0x%08lX\n", lp->txBytes );
3644 len += sprintf(buf+len,"maxPort: 0x%04X\n", lp->maxPort ); /* 0 for STA, 6 for AP */
3645 /* Elements used for async notification from hardware */
3646 //x RID_LOG_STRCT RidList[10];
3647 //x ltv_t "updatedRecord: 0x%04X\n", lp->updatedRecord );
3648 //x PROBE_RESP "ProbeResp: 0x%04X\n", lp->ProbeResp );
3649 //x ASSOC_STATUS_STRCT "assoc_stat: 0x%04X\n", lp->assoc_stat );
3650 //x SECURITY_STATUS_STRCT "sec_stat: 0x%04X\n", lp->sec_stat );
3651 //x u_char lookAheadBuf[WVLAN_MAX_LOOKAHEAD];
3652 len += sprintf(buf+len,"PortType: 0x%04X\n", lp->PortType ); // 1 - 3 (1 [Normal] | 3 [AdHoc])
3653 len += sprintf(buf+len,"Channel: 0x%04X\n", lp->Channel ); // 0 - 14 (0)
3654 //x hcf_16 TxRateControl[2];
3655 len += sprintf(buf+len,"TxRateControl[2]: 0x%04X 0x%04X\n",
3656 lp->TxRateControl[0], lp->TxRateControl[1] );
3657 len += sprintf(buf+len,"DistanceBetweenAPs: 0x%04X\n", lp->DistanceBetweenAPs ); // 1 - 3 (1)
3658 len += sprintf(buf+len,"RTSThreshold: 0x%04X\n", lp->RTSThreshold ); // 0 - 2347 (2347)
3659 len += sprintf(buf+len,"PMEnabled: 0x%04X\n", lp->PMEnabled ); // 0 - 2, 8001 - 8002 (0)
3660 len += sprintf(buf+len,"MicrowaveRobustness: 0x%04X\n", lp->MicrowaveRobustness );// 0 - 1 (0)
3661 len += sprintf(buf+len,"CreateIBSS: 0x%04X\n", lp->CreateIBSS ); // 0 - 1 (0)
3662 len += sprintf(buf+len,"MulticastReceive: 0x%04X\n", lp->MulticastReceive ); // 0 - 1 (1)
3663 len += sprintf(buf+len,"MaxSleepDuration: 0x%04X\n", lp->MaxSleepDuration ); // 0 - 65535 (100)
3664 //x hcf_8 MACAddress[ETH_ALEN];
3665 len += printf_hcf_8( "MACAddress", &buf[len], lp->MACAddress, ETH_ALEN );
3666 //x char NetworkName[HCF_MAX_NAME_LEN+1];
3667 len += sprintf(buf+len,"NetworkName: %.32s\n", lp->NetworkName );
3668 //x char StationName[HCF_MAX_NAME_LEN+1];
3669 len += sprintf(buf+len,"EnableEncryption: 0x%04X\n", lp->EnableEncryption ); // 0 - 1 (0)
3670 //x char Key1[MAX_KEY_LEN+1];
3671 len += printf_hcf_8( "Key1", &buf[len], lp->Key1, MAX_KEY_LEN );
3672 //x char Key2[MAX_KEY_LEN+1];
3673 //x char Key3[MAX_KEY_LEN+1];
3674 //x char Key4[MAX_KEY_LEN+1];
3675 len += sprintf(buf+len,"TransmitKeyID: 0x%04X\n", lp->TransmitKeyID ); // 1 - 4 (1)
3676 //x CFG_DEFAULT_KEYS_STRCT "DefaultKeys: 0x%04X\n", lp->DefaultKeys );
3677 //x u_char mailbox[MB_SIZE];
3678 //x char szEncryption[MAX_ENC_LEN];
3679 len += sprintf(buf+len,"driverEnable: 0x%04X\n", lp->driverEnable );
3680 len += sprintf(buf+len,"wolasEnable: 0x%04X\n", lp->wolasEnable );
3681 len += sprintf(buf+len,"atimWindow: 0x%04X\n", lp->atimWindow );
3682 len += sprintf(buf+len,"holdoverDuration: 0x%04X\n", lp->holdoverDuration );
3683 //x hcf_16 MulticastRate[2];
3684 len += sprintf(buf+len,"authentication: 0x%04X\n", lp->authentication ); // is this AP specific?
3685 len += sprintf(buf+len,"promiscuousMode: 0x%04X\n", lp->promiscuousMode );
3686 len += sprintf(buf+len,"DownloadFirmware: 0x%04X\n", lp->DownloadFirmware ); // 0 - 2 (0 [None] | 1 [STA] | 2 [AP])
3687 len += sprintf(buf+len,"AuthKeyMgmtSuite: 0x%04X\n", lp->AuthKeyMgmtSuite );
3688 len += sprintf(buf+len,"loadBalancing: 0x%04X\n", lp->loadBalancing );
3689 len += sprintf(buf+len,"mediumDistribution: 0x%04X\n", lp->mediumDistribution );
3690 len += sprintf(buf+len,"txPowLevel: 0x%04X\n", lp->txPowLevel );
3691 // len += sprintf(buf+len,"shortRetryLimit: 0x%04X\n", lp->shortRetryLimit );
3692 // len += sprintf(buf+len,"longRetryLimit: 0x%04X\n", lp->longRetryLimit );
3693 //x hcf_16 srsc[2];
3694 //x hcf_16 brsc[2];
3695 len += sprintf(buf+len,"connectionControl: 0x%04X\n", lp->connectionControl );
3696 //x //hcf_16 probeDataRates[2];
3697 len += sprintf(buf+len,"ownBeaconInterval: 0x%04X\n", lp->ownBeaconInterval );
3698 len += sprintf(buf+len,"coexistence: 0x%04X\n", lp->coexistence );
3699 //x WVLAN_FRAME "txF: 0x%04X\n", lp->txF );
3700 //x WVLAN_LFRAME txList[DEFAULT_NUM_TX_FRAMES];
3701 //x struct list_head "txFree: 0x%04X\n", lp->txFree );
3702 //x struct list_head txQ[WVLAN_MAX_TX_QUEUES];
3703 len += sprintf(buf+len,"netif_queue_on: 0x%04X\n", lp->netif_queue_on );
3704 len += sprintf(buf+len,"txQ_count: 0x%04X\n", lp->txQ_count );
3705 //x DESC_STRCT "desc_rx: 0x%04X\n", lp->desc_rx );
3706 //x DESC_STRCT "desc_tx: 0x%04X\n", lp->desc_tx );
3707 //x WVLAN_PORT_STATE "portState: 0x%04X\n", lp->portState );
3708 //x ScanResult "scan_results: 0x%04X\n", lp->scan_results );
3709 //x ProbeResult "probe_results: 0x%04X\n", lp->probe_results );
3710 len += sprintf(buf+len,"probe_num_aps: 0x%04X\n", lp->probe_num_aps );
3711 len += sprintf(buf+len,"use_dma: 0x%04X\n", lp->use_dma );
3712 //x DMA_STRCT "dma: 0x%04X\n", lp->dma );
3713 #ifdef USE_RTS
3714 len += sprintf(buf+len,"useRTS: 0x%04X\n", lp->useRTS );
3715 #endif // USE_RTS
3716 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
3717 //;?should we restore this to allow smaller memory footprint
3718 //;?I guess not. This should be brought under Debug mode only
3719 len += sprintf(buf+len,"DTIMPeriod: 0x%04X\n", lp->DTIMPeriod ); // 1 - 255 (1)
3720 len += sprintf(buf+len,"multicastPMBuffering: 0x%04X\n", lp->multicastPMBuffering );
3721 len += sprintf(buf+len,"RejectAny: 0x%04X\n", lp->RejectAny ); // 0 - 1 (0)
3722 len += sprintf(buf+len,"ExcludeUnencrypted: 0x%04X\n", lp->ExcludeUnencrypted ); // 0 - 1 (1)
3723 len += sprintf(buf+len,"intraBSSRelay: 0x%04X\n", lp->intraBSSRelay );
3724 len += sprintf(buf+len,"wlags49_type: 0x%08lX\n", lp->wlags49_type );
3725 #ifdef USE_WDS
3726 //x WVLAN_WDS_IF wds_port[NUM_WDS_PORTS];
3727 #endif // USE_WDS
3728 #endif // HCF_AP
3729 } else if ( lp->wlags49_type == 2 ){
3730 len += sprintf(buf+len,"tallies to be added\n" );
3731 //Hermes Tallies (IFB substructure) {
3732 p = &lp->hcfCtx.IFB_NIC_Tallies;
3733 len += sprintf(buf+len,"TxUnicastFrames: %08lX\n", p->TxUnicastFrames );
3734 len += sprintf(buf+len,"TxMulticastFrames: %08lX\n", p->TxMulticastFrames );
3735 len += sprintf(buf+len,"TxFragments: %08lX\n", p->TxFragments );
3736 len += sprintf(buf+len,"TxUnicastOctets: %08lX\n", p->TxUnicastOctets );
3737 len += sprintf(buf+len,"TxMulticastOctets: %08lX\n", p->TxMulticastOctets );
3738 len += sprintf(buf+len,"TxDeferredTransmissions: %08lX\n", p->TxDeferredTransmissions );
3739 len += sprintf(buf+len,"TxSingleRetryFrames: %08lX\n", p->TxSingleRetryFrames );
3740 len += sprintf(buf+len,"TxMultipleRetryFrames: %08lX\n", p->TxMultipleRetryFrames );
3741 len += sprintf(buf+len,"TxRetryLimitExceeded: %08lX\n", p->TxRetryLimitExceeded );
3742 len += sprintf(buf+len,"TxDiscards: %08lX\n", p->TxDiscards );
3743 len += sprintf(buf+len,"RxUnicastFrames: %08lX\n", p->RxUnicastFrames );
3744 len += sprintf(buf+len,"RxMulticastFrames: %08lX\n", p->RxMulticastFrames );
3745 len += sprintf(buf+len,"RxFragments: %08lX\n", p->RxFragments );
3746 len += sprintf(buf+len,"RxUnicastOctets: %08lX\n", p->RxUnicastOctets );
3747 len += sprintf(buf+len,"RxMulticastOctets: %08lX\n", p->RxMulticastOctets );
3748 len += sprintf(buf+len,"RxFCSErrors: %08lX\n", p->RxFCSErrors );
3749 len += sprintf(buf+len,"RxDiscardsNoBuffer: %08lX\n", p->RxDiscardsNoBuffer );
3750 len += sprintf(buf+len,"TxDiscardsWrongSA: %08lX\n", p->TxDiscardsWrongSA );
3751 len += sprintf(buf+len,"RxWEPUndecryptable: %08lX\n", p->RxWEPUndecryptable );
3752 len += sprintf(buf+len,"RxMsgInMsgFragments: %08lX\n", p->RxMsgInMsgFragments );
3753 len += sprintf(buf+len,"RxMsgInBadMsgFragments: %08lX\n", p->RxMsgInBadMsgFragments );
3754 len += sprintf(buf+len,"RxDiscardsWEPICVError: %08lX\n", p->RxDiscardsWEPICVError );
3755 len += sprintf(buf+len,"RxDiscardsWEPExcluded: %08lX\n", p->RxDiscardsWEPExcluded );
3756 #if (HCF_EXT) & HCF_EXT_TALLIES_FW
3757 //to be added ;?
3758 #endif // HCF_EXT_TALLIES_FW
3759 } else if ( lp->wlags49_type & 0x8000 ) { //;?kludgy but it is unclear to me were else to place this
3760 #if DBG
3761 DbgInfo->DebugFlag = lp->wlags49_type & 0x7FFF;
3762 #endif // DBG
3763 lp->wlags49_type = 0; //default to IFB again ;?
3764 } else {
3765 len += sprintf(buf+len,"unknown value for wlags49_type: 0x%08lX\n", lp->wlags49_type );
3766 len += sprintf(buf+len,"0x0000 - IFB\n" );
3767 len += sprintf(buf+len,"0x0001 - wl_private\n" );
3768 len += sprintf(buf+len,"0x0002 - Tallies\n" );
3769 len += sprintf(buf+len,"0x8xxx - Change debufflag\n" );
3770 len += sprintf(buf+len,"ERROR 0001\nWARNING 0002\nNOTICE 0004\nTRACE 0008\n" );
3771 len += sprintf(buf+len,"VERBOSE 0010\nPARAM 0020\nBREAK 0040\nRX 0100\n" );
3772 len += sprintf(buf+len,"TX 0200\nDS 0400\n" );
3773 }
3774 return len;
3775 } // scull_read_procmem
3776
3777 static void proc_write(const char *name, write_proc_t *w, void *data)
3778 {
3779 struct proc_dir_entry * entry = create_proc_entry(name, S_IFREG | S_IWUSR, NULL);
3780 if (entry) {
3781 entry->write_proc = w;
3782 entry->data = data;
3783 }
3784 } // proc_write
3785
3786 static int write_int(struct file *file, const char *buffer, unsigned long count, void *data)
3787 {
3788 static char proc_number[11];
3789 unsigned int nr = 0;
3790
3791 DBG_FUNC( "write_int" );
3792 DBG_ENTER( DbgInfo );
3793
3794 if (count > 9) {
3795 count = -EINVAL;
3796 } else if ( copy_from_user(proc_number, buffer, count) ) {
3797 count = -EFAULT;
3798 }
3799 if (count > 0 ) {
3800 proc_number[count] = 0;
3801 nr = simple_strtoul(proc_number , NULL, 0);
3802 *(unsigned int *)data = nr;
3803 if ( nr & 0x8000 ) { //;?kludgy but it is unclear to me were else to place this
3804 #if DBG
3805 DbgInfo->DebugFlag = nr & 0x7FFF;
3806 #endif // DBG
3807 }
3808 }
3809 DBG_PRINT( "value: %08X\n", nr );
3810 DBG_LEAVE( DbgInfo );
3811 return count;
3812 } // write_int
3813
3814 #endif /* SCULL_USE_PROC */
3815
3816 #ifdef DN554
3817 #define RUN_AT(x) (jiffies+(x)) //"borrowed" from include/pcmcia/k_compat.h
3818 #define DS_OOR 0x8000 //Deepsleep OutOfRange Status
3819
3820 lp->timer_oor_cnt = DS_OOR;
3821 init_timer( &lp->timer_oor );
3822 lp->timer_oor.function = timer_oor;
3823 lp->timer_oor.data = (unsigned long)lp;
3824 lp->timer_oor.expires = RUN_AT( 3 * HZ );
3825 add_timer( &lp->timer_oor );
3826 printk( "<5>wl_enable: %ld\n", jiffies ); //;?remove me 1 day
3827 #endif //DN554
3828 #ifdef DN554
3829 /*******************************************************************************
3830 * timer_oor()
3831 *******************************************************************************
3832 *
3833 * DESCRIPTION:
3834 *
3835 *
3836 * PARAMETERS:
3837 *
3838 * arg - a u_long representing a pointer to a dev_link_t structure for the
3839 * device to be released.
3840 *
3841 * RETURNS:
3842 *
3843 * N/A
3844 *
3845 ******************************************************************************/
timer_oor(u_long arg)3846 void timer_oor( u_long arg )
3847 {
3848 struct wl_private *lp = (struct wl_private *)arg;
3849
3850 /*------------------------------------------------------------------------*/
3851
3852 DBG_FUNC( "timer_oor" );
3853 DBG_ENTER( DbgInfo );
3854 DBG_PARAM( DbgInfo, "arg", "0x%08lx", arg );
3855
3856 printk( "<5>timer_oor: %ld 0x%04X\n", jiffies, lp->timer_oor_cnt ); //;?remove me 1 day
3857 lp->timer_oor_cnt += 10;
3858 if ( (lp->timer_oor_cnt & ~DS_OOR) > 300 ) {
3859 lp->timer_oor_cnt = 300;
3860 }
3861 lp->timer_oor_cnt |= DS_OOR;
3862 init_timer( &lp->timer_oor );
3863 lp->timer_oor.function = timer_oor;
3864 lp->timer_oor.data = (unsigned long)lp;
3865 lp->timer_oor.expires = RUN_AT( (lp->timer_oor_cnt & ~DS_OOR) * HZ );
3866 add_timer( &lp->timer_oor );
3867
3868 DBG_LEAVE( DbgInfo );
3869 } // timer_oor
3870 #endif //DN554
3871
3872 MODULE_LICENSE("Dual BSD/GPL");
3873