/drivers/staging/wlags49_h2/wl_main.c

https://bitbucket.org/slukk/jb-tsm-kernel-4.2 · C · 3870 lines · 2275 code · 523 blank · 1072 comment · 361 complexity · c3bd0e383eb30eee9671e4ec54fcf7cc MD5 · raw file

Large files are truncated click here to view the full file

  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. * constant definitions
  63. ******************************************************************************/
  64. /* Allow support for calling system fcns to access F/W iamge file */
  65. #define __KERNEL_SYSCALLS__
  66. /*******************************************************************************
  67. * include files
  68. ******************************************************************************/
  69. #include <wl_version.h>
  70. #include <linux/module.h>
  71. #include <linux/proc_fs.h>
  72. #include <linux/types.h>
  73. #include <linux/kernel.h>
  74. // #include <linux/sched.h>
  75. // #include <linux/ptrace.h>
  76. // #include <linux/slab.h>
  77. // #include <linux/ctype.h>
  78. // #include <linux/string.h>
  79. // #include <linux/timer.h>
  80. //#include <linux/interrupt.h>
  81. // #include <linux/tqueue.h>
  82. // #include <linux/in.h>
  83. // #include <linux/delay.h>
  84. // #include <asm/io.h>
  85. // #include <asm/system.h>
  86. // #include <asm/bitops.h>
  87. #include <linux/unistd.h>
  88. #include <asm/uaccess.h>
  89. #include <linux/netdevice.h>
  90. #include <linux/etherdevice.h>
  91. // #include <linux/skbuff.h>
  92. // #include <linux/if_arp.h>
  93. // #include <linux/ioport.h>
  94. #define BIN_DL 0
  95. #if BIN_DL
  96. #include <linux/vmalloc.h>
  97. #endif // BIN_DL
  98. #include <debug.h>
  99. #include <hcf.h>
  100. #include <dhf.h>
  101. //in order to get around:: wl_main.c:2229: `HREG_EV_RDMAD' undeclared (first use in this function)
  102. #include <hcfdef.h>
  103. #include <wl_if.h>
  104. #include <wl_internal.h>
  105. #include <wl_util.h>
  106. #include <wl_main.h>
  107. #include <wl_netdev.h>
  108. #include <wl_wext.h>
  109. #ifdef USE_PROFILE
  110. #include <wl_profile.h>
  111. #endif /* USE_PROFILE */
  112. #ifdef BUS_PCMCIA
  113. #include <wl_cs.h>
  114. #endif /* BUS_PCMCIA */
  115. #ifdef BUS_PCI
  116. #include <wl_pci.h>
  117. #endif /* BUS_PCI */
  118. /*******************************************************************************
  119. * macro defintions
  120. ******************************************************************************/
  121. #define VALID_PARAM(C) \
  122. { \
  123. if (!(C)) \
  124. { \
  125. printk(KERN_INFO "Wireless, parameter error: \"%s\"\n", #C); \
  126. goto failed; \
  127. } \
  128. }
  129. /*******************************************************************************
  130. * local functions
  131. ******************************************************************************/
  132. void wl_isr_handler( unsigned long p );
  133. #if 0 //SCULL_USE_PROC /* don't waste space if unused */
  134. //int scull_read_procmem(char *buf, char **start, off_t offset, int len, int unused);
  135. int scull_read_procmem(char *buf, char **start, off_t offset, int len, int *eof, void *data );
  136. static int write_int(struct file *file, const char *buffer, unsigned long count, void *data);
  137. static void proc_write(const char *name, write_proc_t *w, void *data);
  138. #endif /* SCULL_USE_PROC */
  139. /*******************************************************************************
  140. * module parameter definitions - set with 'insmod'
  141. ******************************************************************************/
  142. static p_u16 irq_mask = 0xdeb8; // IRQ3,4,5,7,9,10,11,12,14,15
  143. static p_s8 irq_list[4] = { -1 };
  144. #if 0
  145. MODULE_PARM(irq_mask, "h");
  146. MODULE_PARM_DESC(irq_mask, "IRQ mask [0xdeb8]");
  147. MODULE_PARM(irq_list, "1-4b");
  148. MODULE_PARM_DESC(irq_list, "IRQ list [<irq_mask>]");
  149. #endif
  150. static p_u8 PARM_AUTHENTICATION = PARM_DEFAULT_AUTHENTICATION;
  151. static p_u16 PARM_AUTH_KEY_MGMT_SUITE = PARM_DEFAULT_AUTH_KEY_MGMT_SUITE;
  152. static p_u16 PARM_BRSC_2GHZ = PARM_DEFAULT_BRSC_2GHZ;
  153. static p_u16 PARM_BRSC_5GHZ = PARM_DEFAULT_BRSC_5GHZ;
  154. static p_u16 PARM_COEXISTENCE = PARM_DEFAULT_COEXISTENCE;
  155. static p_u16 PARM_CONNECTION_CONTROL = PARM_DEFAULT_CONNECTION_CONTROL; //;?rename and move
  156. static p_char *PARM_CREATE_IBSS = PARM_DEFAULT_CREATE_IBSS_STR;
  157. static p_char *PARM_DESIRED_SSID = PARM_DEFAULT_SSID;
  158. static p_char *PARM_DOWNLOAD_FIRMWARE = "";
  159. static p_u16 PARM_ENABLE_ENCRYPTION = PARM_DEFAULT_ENABLE_ENCRYPTION;
  160. static p_char *PARM_EXCLUDE_UNENCRYPTED = PARM_DEFAULT_EXCLUDE_UNENCRYPTED_STR;
  161. static p_char *PARM_INTRA_BSS_RELAY = PARM_DEFAULT_INTRA_BSS_RELAY_STR;
  162. static p_char *PARM_KEY1 = "";
  163. static p_char *PARM_KEY2 = "";
  164. static p_char *PARM_KEY3 = "";
  165. static p_char *PARM_KEY4 = "";
  166. static p_char *PARM_LOAD_BALANCING = PARM_DEFAULT_LOAD_BALANCING_STR;
  167. static p_u16 PARM_MAX_SLEEP = PARM_DEFAULT_MAX_PM_SLEEP;
  168. static p_char *PARM_MEDIUM_DISTRIBUTION = PARM_DEFAULT_MEDIUM_DISTRIBUTION_STR;
  169. static p_char *PARM_MICROWAVE_ROBUSTNESS = PARM_DEFAULT_MICROWAVE_ROBUSTNESS_STR;
  170. static p_char *PARM_MULTICAST_PM_BUFFERING = PARM_DEFAULT_MULTICAST_PM_BUFFERING_STR;
  171. static p_u16 PARM_MULTICAST_RATE = PARM_DEFAULT_MULTICAST_RATE_2GHZ;
  172. static p_char *PARM_MULTICAST_RX = PARM_DEFAULT_MULTICAST_RX_STR;
  173. static p_u8 PARM_NETWORK_ADDR[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
  174. static p_u16 PARM_OWN_ATIM_WINDOW = PARM_DEFAULT_OWN_ATIM_WINDOW;
  175. static p_u16 PARM_OWN_BEACON_INTERVAL = PARM_DEFAULT_OWN_BEACON_INTERVAL;
  176. static p_u8 PARM_OWN_CHANNEL = PARM_DEFAULT_OWN_CHANNEL;
  177. static p_u8 PARM_OWN_DTIM_PERIOD = PARM_DEFAULT_OWN_DTIM_PERIOD;
  178. static p_char *PARM_OWN_NAME = PARM_DEFAULT_OWN_NAME;
  179. static p_char *PARM_OWN_SSID = PARM_DEFAULT_SSID;
  180. static p_u16 PARM_PM_ENABLED = WVLAN_PM_STATE_DISABLED;
  181. static p_u16 PARM_PM_HOLDOVER_DURATION = PARM_DEFAULT_PM_HOLDOVER_DURATION;
  182. static p_u8 PARM_PORT_TYPE = PARM_DEFAULT_PORT_TYPE;
  183. static p_char *PARM_PROMISCUOUS_MODE = PARM_DEFAULT_PROMISCUOUS_MODE_STR;
  184. static p_char *PARM_REJECT_ANY = PARM_DEFAULT_REJECT_ANY_STR;
  185. #ifdef USE_WDS
  186. static p_u16 PARM_RTS_THRESHOLD1 = PARM_DEFAULT_RTS_THRESHOLD;
  187. static p_u16 PARM_RTS_THRESHOLD2 = PARM_DEFAULT_RTS_THRESHOLD;
  188. static p_u16 PARM_RTS_THRESHOLD3 = PARM_DEFAULT_RTS_THRESHOLD;
  189. static p_u16 PARM_RTS_THRESHOLD4 = PARM_DEFAULT_RTS_THRESHOLD;
  190. static p_u16 PARM_RTS_THRESHOLD5 = PARM_DEFAULT_RTS_THRESHOLD;
  191. static p_u16 PARM_RTS_THRESHOLD6 = PARM_DEFAULT_RTS_THRESHOLD;
  192. #endif // USE_WDS
  193. static p_u16 PARM_RTS_THRESHOLD = PARM_DEFAULT_RTS_THRESHOLD;
  194. static p_u16 PARM_SRSC_2GHZ = PARM_DEFAULT_SRSC_2GHZ;
  195. static p_u16 PARM_SRSC_5GHZ = PARM_DEFAULT_SRSC_5GHZ;
  196. static p_u8 PARM_SYSTEM_SCALE = PARM_DEFAULT_SYSTEM_SCALE;
  197. static p_u8 PARM_TX_KEY = PARM_DEFAULT_TX_KEY;
  198. static p_u16 PARM_TX_POW_LEVEL = PARM_DEFAULT_TX_POW_LEVEL;
  199. #ifdef USE_WDS
  200. static p_u16 PARM_TX_RATE1 = PARM_DEFAULT_TX_RATE_2GHZ;
  201. static p_u16 PARM_TX_RATE2 = PARM_DEFAULT_TX_RATE_2GHZ;
  202. static p_u16 PARM_TX_RATE3 = PARM_DEFAULT_TX_RATE_2GHZ;
  203. static p_u16 PARM_TX_RATE4 = PARM_DEFAULT_TX_RATE_2GHZ;
  204. static p_u16 PARM_TX_RATE5 = PARM_DEFAULT_TX_RATE_2GHZ;
  205. static p_u16 PARM_TX_RATE6 = PARM_DEFAULT_TX_RATE_2GHZ;
  206. #endif // USE_WDS
  207. static p_u16 PARM_TX_RATE = PARM_DEFAULT_TX_RATE_2GHZ;
  208. #ifdef USE_WDS
  209. static p_u8 PARM_WDS_ADDRESS1[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
  210. static p_u8 PARM_WDS_ADDRESS2[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
  211. static p_u8 PARM_WDS_ADDRESS3[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
  212. static p_u8 PARM_WDS_ADDRESS4[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
  213. static p_u8 PARM_WDS_ADDRESS5[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
  214. static p_u8 PARM_WDS_ADDRESS6[ETH_ALEN] = PARM_DEFAULT_NETWORK_ADDR;
  215. #endif // USE_WDS
  216. #if 0
  217. MODULE_PARM(PARM_DESIRED_SSID, "s");
  218. MODULE_PARM_DESC(PARM_DESIRED_SSID, "Network Name (<string>) [ANY]");
  219. MODULE_PARM(PARM_OWN_SSID, "s");
  220. MODULE_PARM_DESC(PARM_OWN_SSID, "Network Name (<string>) [ANY]");
  221. MODULE_PARM(PARM_OWN_CHANNEL, "b");
  222. MODULE_PARM_DESC(PARM_OWN_CHANNEL, "Channel (0 - 14) [0]");
  223. MODULE_PARM(PARM_SYSTEM_SCALE, "b");
  224. MODULE_PARM_DESC(PARM_SYSTEM_SCALE, "Distance Between APs (1 - 3) [1]");
  225. MODULE_PARM(PARM_TX_RATE, "b");
  226. MODULE_PARM_DESC(PARM_TX_RATE, "Transmit Rate Control");
  227. MODULE_PARM(PARM_RTS_THRESHOLD, "h");
  228. MODULE_PARM_DESC(PARM_RTS_THRESHOLD, "Medium Reservation (RTS/CTS Fragment Length) (256 - 2347) [2347]");
  229. MODULE_PARM(PARM_MICROWAVE_ROBUSTNESS, "s");
  230. MODULE_PARM_DESC(PARM_MICROWAVE_ROBUSTNESS, "Microwave Oven Robustness Enabled (<string> N or Y) [N]");
  231. MODULE_PARM(PARM_OWN_NAME, "s");
  232. MODULE_PARM_DESC(PARM_OWN_NAME, "Station Name (<string>) [Linux]");
  233. MODULE_PARM(PARM_ENABLE_ENCRYPTION, "b");
  234. MODULE_PARM_DESC(PARM_ENABLE_ENCRYPTION, "Encryption Mode (0 - 7) [0]");
  235. MODULE_PARM(PARM_KEY1, "s");
  236. MODULE_PARM_DESC(PARM_KEY1, "Data Encryption Key 1 (<string>) []");
  237. MODULE_PARM(PARM_KEY2, "s");
  238. MODULE_PARM_DESC(PARM_KEY2, "Data Encryption Key 2 (<string>) []");
  239. MODULE_PARM(PARM_KEY3, "s");
  240. MODULE_PARM_DESC(PARM_KEY3, "Data Encryption Key 3 (<string>) []");
  241. MODULE_PARM(PARM_KEY4, "s");
  242. MODULE_PARM_DESC(PARM_KEY4, "Data Encryption Key 4 (<string>) []");
  243. MODULE_PARM(PARM_TX_KEY, "b");
  244. MODULE_PARM_DESC(PARM_TX_KEY, "Transmit Key ID (1 - 4) [1]");
  245. MODULE_PARM(PARM_MULTICAST_RATE, "b");
  246. MODULE_PARM_DESC(PARM_MULTICAST_RATE, "Multicast Rate");
  247. MODULE_PARM(PARM_DOWNLOAD_FIRMWARE, "s");
  248. MODULE_PARM_DESC(PARM_DOWNLOAD_FIRMWARE, "filename of firmware image");
  249. MODULE_PARM(PARM_AUTH_KEY_MGMT_SUITE, "b");
  250. MODULE_PARM_DESC(PARM_AUTH_KEY_MGMT_SUITE, "Authentication Key Management suite (0-4) [0]");
  251. MODULE_PARM(PARM_LOAD_BALANCING, "s");
  252. MODULE_PARM_DESC(PARM_LOAD_BALANCING, "Load Balancing Enabled (<string> N or Y) [Y]");
  253. MODULE_PARM(PARM_MEDIUM_DISTRIBUTION, "s");
  254. MODULE_PARM_DESC(PARM_MEDIUM_DISTRIBUTION, "Medium Distribution Enabled (<string> N or Y) [Y]");
  255. MODULE_PARM(PARM_TX_POW_LEVEL, "b");
  256. MODULE_PARM_DESC(PARM_TX_POW_LEVEL, "Transmit Power (0 - 6) [3]");
  257. MODULE_PARM(PARM_SRSC_2GHZ, "b");
  258. MODULE_PARM_DESC(PARM_SRSC_2GHZ, "Supported Rate Set Control 2.4 GHz");
  259. MODULE_PARM(PARM_SRSC_5GHZ, "b");
  260. MODULE_PARM_DESC(PARM_SRSC_5GHZ, "Supported Rate Set Control 5.0 GHz");
  261. MODULE_PARM(PARM_BRSC_2GHZ, "b");
  262. MODULE_PARM_DESC(PARM_BRSC_2GHZ, "Basic Rate Set Control 2.4 GHz");
  263. MODULE_PARM(PARM_BRSC_5GHZ, "b");
  264. MODULE_PARM_DESC(PARM_BRSC_5GHZ, "Basic Rate Set Control 5.0 GHz");
  265. #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
  266. //;?seems reasonable that even an AP-only driver could afford this small additional footprint
  267. MODULE_PARM(PARM_PM_ENABLED, "h");
  268. MODULE_PARM_DESC(PARM_PM_ENABLED, "Power Management State (0 - 2, 8001 - 8002) [0]");
  269. MODULE_PARM(PARM_PORT_TYPE, "b");
  270. MODULE_PARM_DESC(PARM_PORT_TYPE, "Port Type (1 - 3) [1]");
  271. //;?MODULE_PARM(PARM_CREATE_IBSS, "s");
  272. //;?MODULE_PARM_DESC(PARM_CREATE_IBSS, "Create IBSS (<string> N or Y) [N]");
  273. //;?MODULE_PARM(PARM_MULTICAST_RX, "s");
  274. //;?MODULE_PARM_DESC(PARM_MULTICAST_RX, "Multicast Receive Enable (<string> N or Y) [Y]");
  275. //;?MODULE_PARM(PARM_MAX_SLEEP, "h");
  276. //;?MODULE_PARM_DESC(PARM_MAX_SLEEP, "Maximum Power Management Sleep Duration (0 - 65535) [100]");
  277. //;?MODULE_PARM(PARM_NETWORK_ADDR, "6b");
  278. //;?MODULE_PARM_DESC(PARM_NETWORK_ADDR, "Hardware Ethernet Address ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [<factory value>]");
  279. //;?MODULE_PARM(PARM_AUTHENTICATION, "b");
  280. //
  281. //tracker 12448
  282. //;?MODULE_PARM_DESC(PARM_AUTHENTICATION, "Authentication Type (0-2) [0] 0=Open 1=SharedKey 2=LEAP");
  283. //;?MODULE_PARM_DESC(authentication, "Authentication Type (1-2) [1] 1=Open 2=SharedKey");
  284. //tracker 12448
  285. //
  286. //;?MODULE_PARM(PARM_OWN_ATIM_WINDOW, "b");
  287. //;?MODULE_PARM_DESC(PARM_OWN_ATIM_WINDOW, "ATIM Window time in TU for IBSS creation (0-100) [0]");
  288. //;?MODULE_PARM(PARM_PM_HOLDOVER_DURATION, "b");
  289. //;?MODULE_PARM_DESC(PARM_PM_HOLDOVER_DURATION, "Time station remains awake after MAC frame transfer when PM is on (0-65535) [100]");
  290. //;?MODULE_PARM(PARM_PROMISCUOUS_MODE, "s");
  291. //;?MODULE_PARM_DESC(PARM_PROMISCUOUS_MODE, "Promiscuous Mode Enable (<string> Y or N ) [N]" );
  292. //;?
  293. MODULE_PARM(PARM_CONNECTION_CONTROL, "b");
  294. MODULE_PARM_DESC(PARM_CONNECTION_CONTROL, "Connection Control (0 - 3) [2]");
  295. #endif /* HCF_STA */
  296. #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
  297. //;?should we restore this to allow smaller memory footprint
  298. MODULE_PARM(PARM_OWN_DTIM_PERIOD, "b");
  299. MODULE_PARM_DESC(PARM_OWN_DTIM_PERIOD, "DTIM Period (0 - 255) [1]");
  300. MODULE_PARM(PARM_REJECT_ANY, "s");
  301. MODULE_PARM_DESC(PARM_REJECT_ANY, "Closed System (<string> N or Y) [N]");
  302. MODULE_PARM(PARM_EXCLUDE_UNENCRYPTED, "s");
  303. MODULE_PARM_DESC(PARM_EXCLUDE_UNENCRYPTED, "Deny non-encrypted (<string> N or Y) [Y]");
  304. MODULE_PARM(PARM_MULTICAST_PM_BUFFERING,"s");
  305. MODULE_PARM_DESC(PARM_MULTICAST_PM_BUFFERING, "Buffer MAC frames for Tx after DTIM (<string> Y or N) [Y]");
  306. MODULE_PARM(PARM_INTRA_BSS_RELAY, "s");
  307. MODULE_PARM_DESC(PARM_INTRA_BSS_RELAY, "IntraBSS Relay (<string> N or Y) [Y]");
  308. MODULE_PARM(PARM_RTS_THRESHOLD1, "h");
  309. MODULE_PARM_DESC(PARM_RTS_THRESHOLD1, "RTS Threshold, WDS Port 1 (256 - 2347) [2347]");
  310. MODULE_PARM(PARM_RTS_THRESHOLD2, "h");
  311. MODULE_PARM_DESC(PARM_RTS_THRESHOLD2, "RTS Threshold, WDS Port 2 (256 - 2347) [2347]");
  312. MODULE_PARM(PARM_RTS_THRESHOLD3, "h");
  313. MODULE_PARM_DESC(PARM_RTS_THRESHOLD3, "RTS Threshold, WDS Port 3 (256 - 2347) [2347]");
  314. MODULE_PARM(PARM_RTS_THRESHOLD4, "h");
  315. MODULE_PARM_DESC(PARM_RTS_THRESHOLD4, "RTS Threshold, WDS Port 4 (256 - 2347) [2347]");
  316. MODULE_PARM(PARM_RTS_THRESHOLD5, "h");
  317. MODULE_PARM_DESC(PARM_RTS_THRESHOLD5, "RTS Threshold, WDS Port 5 (256 - 2347) [2347]");
  318. MODULE_PARM(PARM_RTS_THRESHOLD6, "h");
  319. MODULE_PARM_DESC(PARM_RTS_THRESHOLD6, "RTS Threshold, WDS Port 6 (256 - 2347) [2347]");
  320. MODULE_PARM(PARM_TX_RATE1, "b");
  321. MODULE_PARM_DESC(PARM_TX_RATE1, "Transmit Rate Control, WDS Port 1 (1 - 7) [3]");
  322. MODULE_PARM(PARM_TX_RATE2, "b");
  323. MODULE_PARM_DESC(PARM_TX_RATE2, "Transmit Rate Control, WDS Port 2 (1 - 7) [3]");
  324. MODULE_PARM(PARM_TX_RATE3, "b");
  325. MODULE_PARM_DESC(PARM_TX_RATE3, "Transmit Rate Control, WDS Port 3 (1 - 7) [3]");
  326. MODULE_PARM(PARM_TX_RATE4, "b");
  327. MODULE_PARM_DESC(PARM_TX_RATE4, "Transmit Rate Control, WDS Port 4 (1 - 7) [3]");
  328. MODULE_PARM(PARM_TX_RATE5, "b");
  329. MODULE_PARM_DESC(PARM_TX_RATE5, "Transmit Rate Control, WDS Port 5 (1 - 7) [3]");
  330. MODULE_PARM(PARM_TX_RATE6, "b");
  331. MODULE_PARM_DESC(PARM_TX_RATE6, "Transmit Rate Control, WDS Port 6 (1 - 7) [3]");
  332. MODULE_PARM(PARM_WDS_ADDRESS1, "6b");
  333. MODULE_PARM_DESC(PARM_WDS_ADDRESS1, "MAC Address, WDS Port 1 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
  334. MODULE_PARM(PARM_WDS_ADDRESS2, "6b");
  335. MODULE_PARM_DESC(PARM_WDS_ADDRESS2, "MAC Address, WDS Port 2 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
  336. MODULE_PARM(PARM_WDS_ADDRESS3, "6b");
  337. MODULE_PARM_DESC(PARM_WDS_ADDRESS3, "MAC Address, WDS Port 3 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
  338. MODULE_PARM(PARM_WDS_ADDRESS4, "6b");
  339. MODULE_PARM_DESC(PARM_WDS_ADDRESS4, "MAC Address, WDS Port 4 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
  340. MODULE_PARM(PARM_WDS_ADDRESS5, "6b");
  341. MODULE_PARM_DESC(PARM_WDS_ADDRESS5, "MAC Address, WDS Port 5 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
  342. MODULE_PARM(PARM_WDS_ADDRESS6, "6b");
  343. MODULE_PARM_DESC(PARM_WDS_ADDRESS6, "MAC Address, WDS Port 6 ([0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff],[0x00-0xff]) [{0}]");
  344. MODULE_PARM(PARM_OWN_BEACON_INTERVAL, "b");
  345. MODULE_PARM_DESC(PARM_OWN_BEACON_INTERVAL, "Own Beacon Interval (20 - 200) [100]");
  346. MODULE_PARM(PARM_COEXISTENCE, "b");
  347. MODULE_PARM_DESC(PARM_COEXISTENCE, "Coexistence (0-7) [0]");
  348. #endif /* HCF_AP */
  349. #endif
  350. /* END NEW PARAMETERS */
  351. /*******************************************************************************
  352. * debugging specifics
  353. ******************************************************************************/
  354. #if DBG
  355. static p_u32 pc_debug = DBG_LVL;
  356. //MODULE_PARM(pc_debug, "i");
  357. /*static ;?conflicts with my understanding of CL parameters and breaks now I moved
  358. * the correspondig logic to wl_profile
  359. */ p_u32 DebugFlag = ~0; //recognizable "undefined value" rather then DBG_DEFAULTS;
  360. //MODULE_PARM(DebugFlag, "l");
  361. dbg_info_t wl_info = { DBG_MOD_NAME, 0, 0 };
  362. dbg_info_t *DbgInfo = &wl_info;
  363. #endif /* DBG */
  364. #ifdef USE_RTS
  365. static p_char *useRTS = "N";
  366. MODULE_PARM( useRTS, "s" );
  367. MODULE_PARM_DESC( useRTS, "Use RTS test interface (<string> N or Y) [N]" );
  368. #endif /* USE_RTS */
  369. /*******************************************************************************
  370. * firmware download specifics
  371. ******************************************************************************/
  372. extern struct CFG_RANGE2_STRCT BASED
  373. cfg_drv_act_ranges_pri; // describes primary-actor range of HCF
  374. #if 0 //;? (HCF_TYPE) & HCF_TYPE_AP
  375. extern memimage ap; // AP firmware image to be downloaded
  376. #endif /* HCF_AP */
  377. #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
  378. //extern memimage station; // STA firmware image to be downloaded
  379. extern memimage fw_image; // firmware image to be downloaded
  380. #endif /* HCF_STA */
  381. int wl_insert( struct net_device *dev )
  382. {
  383. int result = 0;
  384. int hcf_status = HCF_SUCCESS;
  385. int i;
  386. unsigned long flags = 0;
  387. struct wl_private *lp = wl_priv(dev);
  388. /*------------------------------------------------------------------------*/
  389. DBG_FUNC( "wl_insert" );
  390. DBG_ENTER( DbgInfo );
  391. /* Initialize the adapter hardware. */
  392. memset( &( lp->hcfCtx ), 0, sizeof( IFB_STRCT ));
  393. /* Initialize the adapter parameters. */
  394. spin_lock_init( &( lp->slock ));
  395. /* Initialize states */
  396. //lp->lockcount = 0; //PE1DNN
  397. lp->is_handling_int = WL_NOT_HANDLING_INT;
  398. lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
  399. lp->dev = dev;
  400. DBG_PARAM( DbgInfo, "irq_mask", "0x%04x", irq_mask & 0x0FFFF );
  401. DBG_PARAM( DbgInfo, "irq_list", "0x%02x 0x%02x 0x%02x 0x%02x",
  402. irq_list[0] & 0x0FF, irq_list[1] & 0x0FF,
  403. irq_list[2] & 0x0FF, irq_list[3] & 0x0FF );
  404. DBG_PARAM( DbgInfo, PARM_NAME_DESIRED_SSID, "\"%s\"", PARM_DESIRED_SSID );
  405. DBG_PARAM( DbgInfo, PARM_NAME_OWN_SSID, "\"%s\"", PARM_OWN_SSID );
  406. DBG_PARAM( DbgInfo, PARM_NAME_OWN_CHANNEL, "%d", PARM_OWN_CHANNEL);
  407. DBG_PARAM( DbgInfo, PARM_NAME_SYSTEM_SCALE, "%d", PARM_SYSTEM_SCALE );
  408. DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE, "%d", PARM_TX_RATE );
  409. DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD, "%d", PARM_RTS_THRESHOLD );
  410. DBG_PARAM( DbgInfo, PARM_NAME_MICROWAVE_ROBUSTNESS, "\"%s\"", PARM_MICROWAVE_ROBUSTNESS );
  411. DBG_PARAM( DbgInfo, PARM_NAME_OWN_NAME, "\"%s\"", PARM_OWN_NAME );
  412. //;? DBG_PARAM( DbgInfo, PARM_NAME_ENABLE_ENCRYPTION, "\"%s\"", PARM_ENABLE_ENCRYPTION );
  413. DBG_PARAM( DbgInfo, PARM_NAME_KEY1, "\"%s\"", PARM_KEY1 );
  414. DBG_PARAM( DbgInfo, PARM_NAME_KEY2, "\"%s\"", PARM_KEY2 );
  415. DBG_PARAM( DbgInfo, PARM_NAME_KEY3, "\"%s\"", PARM_KEY3 );
  416. DBG_PARAM( DbgInfo, PARM_NAME_KEY4, "\"%s\"", PARM_KEY4 );
  417. DBG_PARAM( DbgInfo, PARM_NAME_TX_KEY, "%d", PARM_TX_KEY );
  418. DBG_PARAM( DbgInfo, PARM_NAME_MULTICAST_RATE, "%d", PARM_MULTICAST_RATE );
  419. DBG_PARAM( DbgInfo, PARM_NAME_DOWNLOAD_FIRMWARE, "\"%s\"", PARM_DOWNLOAD_FIRMWARE );
  420. DBG_PARAM( DbgInfo, PARM_NAME_AUTH_KEY_MGMT_SUITE, "%d", PARM_AUTH_KEY_MGMT_SUITE );
  421. //;?#if (HCF_TYPE) & HCF_TYPE_STA
  422. //;?should we make this code conditional depending on in STA mode
  423. //;? DBG_PARAM( DbgInfo, PARM_NAME_PORT_TYPE, "%d", PARM_PORT_TYPE );
  424. DBG_PARAM( DbgInfo, PARM_NAME_PM_ENABLED, "%04x", PARM_PM_ENABLED );
  425. //;? DBG_PARAM( DbgInfo, PARM_NAME_CREATE_IBSS, "\"%s\"", PARM_CREATE_IBSS );
  426. //;? DBG_PARAM( DbgInfo, PARM_NAME_MULTICAST_RX, "\"%s\"", PARM_MULTICAST_RX );
  427. //;? DBG_PARAM( DbgInfo, PARM_NAME_MAX_SLEEP, "%d", PARM_MAX_SLEEP );
  428. /*
  429. DBG_PARAM(DbgInfo, PARM_NAME_NETWORK_ADDR, "\"%pM\"",
  430. PARM_NETWORK_ADDR);
  431. */
  432. //;? DBG_PARAM( DbgInfo, PARM_NAME_AUTHENTICATION, "%d", PARM_AUTHENTICATION );
  433. //;? DBG_PARAM( DbgInfo, PARM_NAME_OWN_ATIM_WINDOW, "%d", PARM_OWN_ATIM_WINDOW );
  434. //;? DBG_PARAM( DbgInfo, PARM_NAME_PM_HOLDOVER_DURATION, "%d", PARM_PM_HOLDOVER_DURATION );
  435. //;? DBG_PARAM( DbgInfo, PARM_NAME_PROMISCUOUS_MODE, "\"%s\"", PARM_PROMISCUOUS_MODE );
  436. //;?#endif /* HCF_STA */
  437. #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
  438. //;?should we restore this to allow smaller memory footprint
  439. //;?I guess: no, since this is Debug mode only
  440. DBG_PARAM( DbgInfo, PARM_NAME_OWN_DTIM_PERIOD, "%d", PARM_OWN_DTIM_PERIOD );
  441. DBG_PARAM( DbgInfo, PARM_NAME_REJECT_ANY, "\"%s\"", PARM_REJECT_ANY );
  442. DBG_PARAM( DbgInfo, PARM_NAME_EXCLUDE_UNENCRYPTED, "\"%s\"", PARM_EXCLUDE_UNENCRYPTED );
  443. DBG_PARAM( DbgInfo, PARM_NAME_MULTICAST_PM_BUFFERING, "\"%s\"", PARM_MULTICAST_PM_BUFFERING );
  444. DBG_PARAM( DbgInfo, PARM_NAME_INTRA_BSS_RELAY, "\"%s\"", PARM_INTRA_BSS_RELAY );
  445. #ifdef USE_WDS
  446. DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD1, "%d", PARM_RTS_THRESHOLD1 );
  447. DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD2, "%d", PARM_RTS_THRESHOLD2 );
  448. DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD3, "%d", PARM_RTS_THRESHOLD3 );
  449. DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD4, "%d", PARM_RTS_THRESHOLD4 );
  450. DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD5, "%d", PARM_RTS_THRESHOLD5 );
  451. DBG_PARAM( DbgInfo, PARM_NAME_RTS_THRESHOLD6, "%d", PARM_RTS_THRESHOLD6 );
  452. DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE1, "%d", PARM_TX_RATE1 );
  453. DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE2, "%d", PARM_TX_RATE2 );
  454. DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE3, "%d", PARM_TX_RATE3 );
  455. DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE4, "%d", PARM_TX_RATE4 );
  456. DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE5, "%d", PARM_TX_RATE5 );
  457. DBG_PARAM( DbgInfo, PARM_NAME_TX_RATE6, "%d", PARM_TX_RATE6 );
  458. DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS1, "\"%pM\"",
  459. PARM_WDS_ADDRESS1);
  460. DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS2, "\"%pM\"",
  461. PARM_WDS_ADDRESS2);
  462. DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS3, "\"%pM\"",
  463. PARM_WDS_ADDRESS3);
  464. DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS4, "\"%pM\"",
  465. PARM_WDS_ADDRESS4);
  466. DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS5, "\"%pM\"",
  467. PARM_WDS_ADDRESS5);
  468. DBG_PARAM(DbgInfo, PARM_NAME_WDS_ADDRESS6, "\"%pM\"",
  469. PARM_WDS_ADDRESS6);
  470. #endif /* USE_WDS */
  471. #endif /* HCF_AP */
  472. VALID_PARAM( !PARM_DESIRED_SSID || ( strlen( PARM_DESIRED_SSID ) <= PARM_MAX_NAME_LEN ));
  473. VALID_PARAM( !PARM_OWN_SSID || ( strlen( PARM_OWN_SSID ) <= PARM_MAX_NAME_LEN ));
  474. VALID_PARAM(( PARM_OWN_CHANNEL <= PARM_MAX_OWN_CHANNEL ));
  475. VALID_PARAM(( PARM_SYSTEM_SCALE >= PARM_MIN_SYSTEM_SCALE ) && ( PARM_SYSTEM_SCALE <= PARM_MAX_SYSTEM_SCALE ));
  476. VALID_PARAM(( PARM_TX_RATE >= PARM_MIN_TX_RATE ) && ( PARM_TX_RATE <= PARM_MAX_TX_RATE ));
  477. VALID_PARAM(( PARM_RTS_THRESHOLD <= PARM_MAX_RTS_THRESHOLD ));
  478. VALID_PARAM( !PARM_MICROWAVE_ROBUSTNESS || strchr( "NnYy", PARM_MICROWAVE_ROBUSTNESS[0] ) != NULL );
  479. VALID_PARAM( !PARM_OWN_NAME || ( strlen( PARM_NAME_OWN_NAME ) <= PARM_MAX_NAME_LEN ));
  480. VALID_PARAM(( PARM_ENABLE_ENCRYPTION <= PARM_MAX_ENABLE_ENCRYPTION ));
  481. VALID_PARAM( is_valid_key_string( PARM_KEY1 ));
  482. VALID_PARAM( is_valid_key_string( PARM_KEY2 ));
  483. VALID_PARAM( is_valid_key_string( PARM_KEY3 ));
  484. VALID_PARAM( is_valid_key_string( PARM_KEY4 ));
  485. VALID_PARAM(( PARM_TX_KEY >= PARM_MIN_TX_KEY ) && ( PARM_TX_KEY <= PARM_MAX_TX_KEY ));
  486. VALID_PARAM(( PARM_MULTICAST_RATE >= PARM_MIN_MULTICAST_RATE ) &&
  487. ( PARM_MULTICAST_RATE <= PARM_MAX_MULTICAST_RATE ));
  488. VALID_PARAM( !PARM_DOWNLOAD_FIRMWARE || ( strlen( PARM_DOWNLOAD_FIRMWARE ) <= 255 /*;?*/ ));
  489. VALID_PARAM(( PARM_AUTH_KEY_MGMT_SUITE < PARM_MAX_AUTH_KEY_MGMT_SUITE ));
  490. VALID_PARAM( !PARM_LOAD_BALANCING || strchr( "NnYy", PARM_LOAD_BALANCING[0] ) != NULL );
  491. VALID_PARAM( !PARM_MEDIUM_DISTRIBUTION || strchr( "NnYy", PARM_MEDIUM_DISTRIBUTION[0] ) != NULL );
  492. VALID_PARAM(( PARM_TX_POW_LEVEL <= PARM_MAX_TX_POW_LEVEL ));
  493. VALID_PARAM(( PARM_PORT_TYPE >= PARM_MIN_PORT_TYPE ) && ( PARM_PORT_TYPE <= PARM_MAX_PORT_TYPE ));
  494. VALID_PARAM( PARM_PM_ENABLED <= WVLAN_PM_STATE_STANDARD ||
  495. ( PARM_PM_ENABLED & 0x7FFF ) <= WVLAN_PM_STATE_STANDARD );
  496. VALID_PARAM( !PARM_CREATE_IBSS || strchr( "NnYy", PARM_CREATE_IBSS[0] ) != NULL );
  497. VALID_PARAM( !PARM_MULTICAST_RX || strchr( "NnYy", PARM_MULTICAST_RX[0] ) != NULL );
  498. VALID_PARAM(( PARM_MAX_SLEEP <= PARM_MAX_MAX_PM_SLEEP ));
  499. VALID_PARAM(( PARM_AUTHENTICATION <= PARM_MAX_AUTHENTICATION ));
  500. VALID_PARAM(( PARM_OWN_ATIM_WINDOW <= PARM_MAX_OWN_ATIM_WINDOW ));
  501. VALID_PARAM(( PARM_PM_HOLDOVER_DURATION <= PARM_MAX_PM_HOLDOVER_DURATION ));
  502. VALID_PARAM( !PARM_PROMISCUOUS_MODE || strchr( "NnYy", PARM_PROMISCUOUS_MODE[0] ) != NULL );
  503. VALID_PARAM(( PARM_CONNECTION_CONTROL <= PARM_MAX_CONNECTION_CONTROL ));
  504. VALID_PARAM(( PARM_OWN_DTIM_PERIOD >= PARM_MIN_OWN_DTIM_PERIOD ));
  505. VALID_PARAM( !PARM_REJECT_ANY || strchr( "NnYy", PARM_REJECT_ANY[0] ) != NULL );
  506. VALID_PARAM( !PARM_EXCLUDE_UNENCRYPTED || strchr( "NnYy", PARM_EXCLUDE_UNENCRYPTED[0] ) != NULL );
  507. VALID_PARAM( !PARM_MULTICAST_PM_BUFFERING || strchr( "NnYy", PARM_MULTICAST_PM_BUFFERING[0] ) != NULL );
  508. VALID_PARAM( !PARM_INTRA_BSS_RELAY || strchr( "NnYy", PARM_INTRA_BSS_RELAY[0] ) != NULL );
  509. #ifdef USE_WDS
  510. VALID_PARAM(( PARM_RTS_THRESHOLD1 <= PARM_MAX_RTS_THRESHOLD ));
  511. VALID_PARAM(( PARM_RTS_THRESHOLD2 <= PARM_MAX_RTS_THRESHOLD ));
  512. VALID_PARAM(( PARM_RTS_THRESHOLD3 <= PARM_MAX_RTS_THRESHOLD ));
  513. VALID_PARAM(( PARM_RTS_THRESHOLD4 <= PARM_MAX_RTS_THRESHOLD ));
  514. VALID_PARAM(( PARM_RTS_THRESHOLD5 <= PARM_MAX_RTS_THRESHOLD ));
  515. VALID_PARAM(( PARM_RTS_THRESHOLD6 <= PARM_MAX_RTS_THRESHOLD ));
  516. VALID_PARAM(( PARM_TX_RATE1 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE1 <= PARM_MAX_TX_RATE ));
  517. VALID_PARAM(( PARM_TX_RATE2 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE2 <= PARM_MAX_TX_RATE ));
  518. VALID_PARAM(( PARM_TX_RATE3 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE3 <= PARM_MAX_TX_RATE ));
  519. VALID_PARAM(( PARM_TX_RATE4 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE4 <= PARM_MAX_TX_RATE ));
  520. VALID_PARAM(( PARM_TX_RATE5 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE5 <= PARM_MAX_TX_RATE ));
  521. VALID_PARAM(( PARM_TX_RATE6 >= PARM_MIN_TX_RATE ) && (PARM_TX_RATE6 <= PARM_MAX_TX_RATE ));
  522. #endif /* USE_WDS */
  523. VALID_PARAM(( PARM_OWN_BEACON_INTERVAL >= PARM_MIN_OWN_BEACON_INTERVAL ) && ( PARM_OWN_BEACON_INTERVAL <= PARM_MAX_OWN_BEACON_INTERVAL ));
  524. VALID_PARAM(( PARM_COEXISTENCE <= PARM_COEXISTENCE ));
  525. /* Set the driver parameters from the passed in parameters. */
  526. /* THESE MODULE PARAMETERS ARE TO BE DEPRECATED IN FAVOR OF A NAMING CONVENTION
  527. WHICH IS INLINE WITH THE FORTHCOMING WAVELAN API */
  528. /* START NEW PARAMETERS */
  529. lp->Channel = PARM_OWN_CHANNEL;
  530. lp->DistanceBetweenAPs = PARM_SYSTEM_SCALE;
  531. /* Need to determine how to handle the new bands for 5GHz */
  532. lp->TxRateControl[0] = PARM_DEFAULT_TX_RATE_2GHZ;
  533. lp->TxRateControl[1] = PARM_DEFAULT_TX_RATE_5GHZ;
  534. lp->RTSThreshold = PARM_RTS_THRESHOLD;
  535. /* Need to determine how to handle the new bands for 5GHz */
  536. lp->MulticastRate[0] = PARM_DEFAULT_MULTICAST_RATE_2GHZ;
  537. lp->MulticastRate[1] = PARM_DEFAULT_MULTICAST_RATE_5GHZ;
  538. if ( strchr( "Yy", PARM_MICROWAVE_ROBUSTNESS[0] ) != NULL ) {
  539. lp->MicrowaveRobustness = 1;
  540. } else {
  541. lp->MicrowaveRobustness = 0;
  542. }
  543. if ( PARM_DESIRED_SSID && ( strlen( PARM_DESIRED_SSID ) <= HCF_MAX_NAME_LEN )) {
  544. strcpy( lp->NetworkName, PARM_DESIRED_SSID );
  545. }
  546. if ( PARM_OWN_SSID && ( strlen( PARM_OWN_SSID ) <= HCF_MAX_NAME_LEN )) {
  547. strcpy( lp->NetworkName, PARM_OWN_SSID );
  548. }
  549. if ( PARM_OWN_NAME && ( strlen( PARM_OWN_NAME ) <= HCF_MAX_NAME_LEN )) {
  550. strcpy( lp->StationName, PARM_OWN_NAME );
  551. }
  552. lp->EnableEncryption = PARM_ENABLE_ENCRYPTION;
  553. if ( PARM_KEY1 && ( strlen( PARM_KEY1 ) <= MAX_KEY_LEN )) {
  554. strcpy( lp->Key1, PARM_KEY1 );
  555. }
  556. if ( PARM_KEY2 && ( strlen( PARM_KEY2 ) <= MAX_KEY_LEN )) {
  557. strcpy( lp->Key2, PARM_KEY2 );
  558. }
  559. if ( PARM_KEY3 && ( strlen( PARM_KEY3 ) <= MAX_KEY_LEN )) {
  560. strcpy( lp->Key3, PARM_KEY3 );
  561. }
  562. if ( PARM_KEY4 && ( strlen( PARM_KEY4 ) <= MAX_KEY_LEN )) {
  563. strcpy( lp->Key4, PARM_KEY4 );
  564. }
  565. lp->TransmitKeyID = PARM_TX_KEY;
  566. key_string2key( lp->Key1, &(lp->DefaultKeys.key[0] ));
  567. key_string2key( lp->Key2, &(lp->DefaultKeys.key[1] ));
  568. key_string2key( lp->Key3, &(lp->DefaultKeys.key[2] ));
  569. key_string2key( lp->Key4, &(lp->DefaultKeys.key[3] ));
  570. lp->DownloadFirmware = 1 ; //;?to be upgraded PARM_DOWNLOAD_FIRMWARE;
  571. lp->AuthKeyMgmtSuite = PARM_AUTH_KEY_MGMT_SUITE;
  572. if ( strchr( "Yy", PARM_LOAD_BALANCING[0] ) != NULL ) {
  573. lp->loadBalancing = 1;
  574. } else {
  575. lp->loadBalancing = 0;
  576. }
  577. if ( strchr( "Yy", PARM_MEDIUM_DISTRIBUTION[0] ) != NULL ) {
  578. lp->mediumDistribution = 1;
  579. } else {
  580. lp->mediumDistribution = 0;
  581. }
  582. lp->txPowLevel = PARM_TX_POW_LEVEL;
  583. lp->srsc[0] = PARM_SRSC_2GHZ;
  584. lp->srsc[1] = PARM_SRSC_5GHZ;
  585. lp->brsc[0] = PARM_BRSC_2GHZ;
  586. lp->brsc[1] = PARM_BRSC_5GHZ;
  587. #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
  588. //;?seems reasonable that even an AP-only driver could afford this small additional footprint
  589. lp->PortType = PARM_PORT_TYPE;
  590. lp->MaxSleepDuration = PARM_MAX_SLEEP;
  591. lp->authentication = PARM_AUTHENTICATION;
  592. lp->atimWindow = PARM_OWN_ATIM_WINDOW;
  593. lp->holdoverDuration = PARM_PM_HOLDOVER_DURATION;
  594. lp->PMEnabled = PARM_PM_ENABLED; //;?
  595. if ( strchr( "Yy", PARM_CREATE_IBSS[0] ) != NULL ) {
  596. lp->CreateIBSS = 1;
  597. } else {
  598. lp->CreateIBSS = 0;
  599. }
  600. if ( strchr( "Nn", PARM_MULTICAST_RX[0] ) != NULL ) {
  601. lp->MulticastReceive = 0;
  602. } else {
  603. lp->MulticastReceive = 1;
  604. }
  605. if ( strchr( "Yy", PARM_PROMISCUOUS_MODE[0] ) != NULL ) {
  606. lp->promiscuousMode = 1;
  607. } else {
  608. lp->promiscuousMode = 0;
  609. }
  610. for( i = 0; i < ETH_ALEN; i++ ) {
  611. lp->MACAddress[i] = PARM_NETWORK_ADDR[i];
  612. }
  613. lp->connectionControl = PARM_CONNECTION_CONTROL;
  614. #endif /* HCF_STA */
  615. #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
  616. //;?should we restore this to allow smaller memory footprint
  617. lp->DTIMPeriod = PARM_OWN_DTIM_PERIOD;
  618. if ( strchr( "Yy", PARM_REJECT_ANY[0] ) != NULL ) {
  619. lp->RejectAny = 1;
  620. } else {
  621. lp->RejectAny = 0;
  622. }
  623. if ( strchr( "Nn", PARM_EXCLUDE_UNENCRYPTED[0] ) != NULL ) {
  624. lp->ExcludeUnencrypted = 0;
  625. } else {
  626. lp->ExcludeUnencrypted = 1;
  627. }
  628. if ( strchr( "Yy", PARM_MULTICAST_PM_BUFFERING[0] ) != NULL ) {
  629. lp->multicastPMBuffering = 1;
  630. } else {
  631. lp->multicastPMBuffering = 0;
  632. }
  633. if ( strchr( "Yy", PARM_INTRA_BSS_RELAY[0] ) != NULL ) {
  634. lp->intraBSSRelay = 1;
  635. } else {
  636. lp->intraBSSRelay = 0;
  637. }
  638. lp->ownBeaconInterval = PARM_OWN_BEACON_INTERVAL;
  639. lp->coexistence = PARM_COEXISTENCE;
  640. #ifdef USE_WDS
  641. lp->wds_port[0].rtsThreshold = PARM_RTS_THRESHOLD1;
  642. lp->wds_port[1].rtsThreshold = PARM_RTS_THRESHOLD2;
  643. lp->wds_port[2].rtsThreshold = PARM_RTS_THRESHOLD3;
  644. lp->wds_port[3].rtsThreshold = PARM_RTS_THRESHOLD4;
  645. lp->wds_port[4].rtsThreshold = PARM_RTS_THRESHOLD5;
  646. lp->wds_port[5].rtsThreshold = PARM_RTS_THRESHOLD6;
  647. lp->wds_port[0].txRateCntl = PARM_TX_RATE1;
  648. lp->wds_port[1].txRateCntl = PARM_TX_RATE2;
  649. lp->wds_port[2].txRateCntl = PARM_TX_RATE3;
  650. lp->wds_port[3].txRateCntl = PARM_TX_RATE4;
  651. lp->wds_port[4].txRateCntl = PARM_TX_RATE5;
  652. lp->wds_port[5].txRateCntl = PARM_TX_RATE6;
  653. for( i = 0; i < ETH_ALEN; i++ ) {
  654. lp->wds_port[0].wdsAddress[i] = PARM_WDS_ADDRESS1[i];
  655. }
  656. for( i = 0; i < ETH_ALEN; i++ ) {
  657. lp->wds_port[1].wdsAddress[i] = PARM_WDS_ADDRESS2[i];
  658. }
  659. for( i = 0; i < ETH_ALEN; i++ ) {
  660. lp->wds_port[2].wdsAddress[i] = PARM_WDS_ADDRESS3[i];
  661. }
  662. for( i = 0; i < ETH_ALEN; i++ ) {
  663. lp->wds_port[3].wdsAddress[i] = PARM_WDS_ADDRESS4[i];
  664. }
  665. for( i = 0; i < ETH_ALEN; i++ ) {
  666. lp->wds_port[4].wdsAddress[i] = PARM_WDS_ADDRESS5[i];
  667. }
  668. for( i = 0; i < ETH_ALEN; i++ ) {
  669. lp->wds_port[5].wdsAddress[i] = PARM_WDS_ADDRESS6[i];
  670. }
  671. #endif /* USE_WDS */
  672. #endif /* HCF_AP */
  673. #ifdef USE_RTS
  674. if ( strchr( "Yy", useRTS[0] ) != NULL ) {
  675. lp->useRTS = 1;
  676. } else {
  677. lp->useRTS = 0;
  678. }
  679. #endif /* USE_RTS */
  680. /* END NEW PARAMETERS */
  681. wl_lock( lp, &flags );
  682. /* Initialize the portState variable */
  683. lp->portState = WVLAN_PORT_STATE_DISABLED;
  684. /* Initialize the ScanResult struct */
  685. memset( &( lp->scan_results ), 0, sizeof( lp->scan_results ));
  686. lp->scan_results.scan_complete = FALSE;
  687. /* Initialize the ProbeResult struct */
  688. memset( &( lp->probe_results ), 0, sizeof( lp->probe_results ));
  689. lp->probe_results.scan_complete = FALSE;
  690. lp->probe_num_aps = 0;
  691. /* Initialize Tx queue stuff */
  692. memset( lp->txList, 0, sizeof( lp->txList ));
  693. INIT_LIST_HEAD( &( lp->txFree ));
  694. lp->txF.skb = NULL;
  695. lp->txF.port = 0;
  696. for( i = 0; i < DEFAULT_NUM_TX_FRAMES; i++ ) {
  697. list_add_tail( &( lp->txList[i].node ), &( lp->txFree ));
  698. }
  699. for( i = 0; i < WVLAN_MAX_TX_QUEUES; i++ ) {
  700. INIT_LIST_HEAD( &( lp->txQ[i] ));
  701. }
  702. lp->netif_queue_on = TRUE;
  703. lp->txQ_count = 0;
  704. /* Initialize the use_dma element in the adapter structure. Not sure if
  705. this should be a compile-time or run-time configurable. So for now,
  706. implement as run-time and just define here */
  707. #ifdef WARP
  708. #ifdef ENABLE_DMA
  709. DBG_TRACE( DbgInfo, "HERMES 2.5 BUSMASTER DMA MODE\n" );
  710. lp->use_dma = 1;
  711. #else
  712. DBG_TRACE( DbgInfo, "HERMES 2.5 PORT I/O MODE\n" );
  713. lp->use_dma = 0;
  714. #endif // ENABLE_DMA
  715. #endif // WARP
  716. /* Register the ISR handler information here, so that it's not done
  717. repeatedly in the ISR */
  718. tasklet_init(&lp->task, wl_isr_handler, (unsigned long)lp);
  719. /* Connect to the adapter */
  720. DBG_TRACE( DbgInfo, "Calling hcf_connect()...\n" );
  721. hcf_status = hcf_connect( &lp->hcfCtx, dev->base_addr );
  722. //HCF_ERR_INCOMP_FW is acceptable, because download must still take place
  723. //HCF_ERR_INCOMP_PRI is not acceptable
  724. if ( hcf_status != HCF_SUCCESS && hcf_status != HCF_ERR_INCOMP_FW ) {
  725. DBG_ERROR( DbgInfo, "hcf_connect() failed, status: 0x%x\n", hcf_status );
  726. wl_unlock( lp, &flags );
  727. goto hcf_failed;
  728. }
  729. //;?should set HCF_version and how about driver_stat
  730. lp->driverInfo.IO_address = dev->base_addr;
  731. lp->driverInfo.IO_range = HCF_NUM_IO_PORTS; //;?conditionally 0x40 or 0x80 seems better
  732. lp->driverInfo.IRQ_number = dev->irq;
  733. lp->driverInfo.card_stat = lp->hcfCtx.IFB_CardStat;
  734. //;? what happened to frame_type
  735. /* Fill in the driver identity structure */
  736. lp->driverIdentity.len = ( sizeof( lp->driverIdentity ) / sizeof( hcf_16 )) - 1;
  737. lp->driverIdentity.typ = CFG_DRV_IDENTITY;
  738. lp->driverIdentity.comp_id = DRV_IDENTITY;
  739. lp->driverIdentity.variant = DRV_VARIANT;
  740. lp->driverIdentity.version_major = DRV_MAJOR_VERSION;
  741. lp->driverIdentity.version_minor = DRV_MINOR_VERSION;
  742. /* Start the card here - This needs to be done in order to get the
  743. MAC address for the network layer */
  744. DBG_TRACE( DbgInfo, "Calling wvlan_go() to perform a card reset...\n" );
  745. hcf_status = wl_go( lp );
  746. if ( hcf_status != HCF_SUCCESS ) {
  747. DBG_ERROR( DbgInfo, "wl_go() failed\n" );
  748. wl_unlock( lp, &flags );
  749. goto hcf_failed;
  750. }
  751. /* Certain RIDs must be set before enabling the ports */
  752. wl_put_ltv_init( lp );
  753. #if 0 //;?why was this already commented out in wl_lkm_720
  754. /* Enable the ports */
  755. if ( wl_adapter_is_open( lp->dev )) {
  756. /* Enable the ports */
  757. DBG_TRACE( DbgInfo, "Enabling Port 0\n" );
  758. hcf_status = wl_enable( lp );
  759. if ( hcf_status != HCF_SUCCESS ) {
  760. DBG_TRACE( DbgInfo, "Enable port 0 failed: 0x%x\n", hcf_status );
  761. }
  762. #if (HCF_TYPE) & HCF_TYPE_AP
  763. DBG_TRACE( DbgInfo, "Enabling WDS Ports\n" );
  764. //wl_enable_wds_ports( lp );
  765. #endif /* (HCF_TYPE) & HCF_TYPE_AP */
  766. }
  767. #endif
  768. /* Fill out the MAC address information in the net_device struct */
  769. memcpy( lp->dev->dev_addr, lp->MACAddress, ETH_ALEN );
  770. dev->addr_len = ETH_ALEN;
  771. lp->is_registered = TRUE;
  772. #ifdef USE_PROFILE
  773. /* Parse the config file for the sake of creating WDS ports if WDS is
  774. configured there but not in the module options */
  775. parse_config( dev );
  776. #endif /* USE_PROFILE */
  777. /* If we're going into AP Mode, register the "virtual" ethernet devices
  778. needed for WDS */
  779. WL_WDS_NETDEV_REGISTER( lp );
  780. /* Reset the DownloadFirmware variable in the private struct. If the
  781. config file is not used, this will not matter; if it is used, it
  782. will be reparsed in wl_open(). This is done because logic in wl_open
  783. used to check if a firmware download is needed is broken by parsing
  784. the file here; however, this parsing is needed to register WDS ports
  785. in AP mode, if they are configured */
  786. lp->DownloadFirmware = WVLAN_DRV_MODE_STA; //;?download_firmware;
  787. #ifdef USE_RTS
  788. if ( lp->useRTS == 1 ) {
  789. DBG_TRACE( DbgInfo, "ENTERING RTS MODE...\n" );
  790. wl_act_int_off( lp );
  791. lp->is_handling_int = WL_NOT_HANDLING_INT; // Not handling interrupts anymore
  792. wl_disable( lp );
  793. hcf_connect( &lp->hcfCtx, HCF_DISCONNECT);
  794. }
  795. #endif /* USE_RTS */
  796. wl_unlock( lp, &flags );
  797. DBG_TRACE( DbgInfo, "%s: Wireless, io_addr %#03lx, irq %d, ""mac_address ",
  798. dev->name, dev->base_addr, dev->irq );
  799. for( i = 0; i < ETH_ALEN; i++ ) {
  800. printk( "%02X%c", dev->dev_addr[i], (( i < ( ETH_ALEN-1 )) ? ':' : '\n' ));
  801. }
  802. #if 0 //SCULL_USE_PROC /* don't waste space if unused */
  803. create_proc_read_entry( "wlags", 0, NULL, scull_read_procmem, dev );
  804. proc_mkdir("driver/wlags49", 0);
  805. proc_write("driver/wlags49/wlags49_type", write_int, &lp->wlags49_type);
  806. #endif /* SCULL_USE_PROC */
  807. DBG_LEAVE( DbgInfo );
  808. return result;
  809. hcf_failed:
  810. wl_hcf_error( dev, hcf_status );
  811. failed:
  812. DBG_ERROR( DbgInfo, "wl_insert() FAILED\n" );
  813. if ( lp->is_registered == TRUE ) {
  814. lp->is_registered = FALSE;
  815. }
  816. WL_WDS_NETDEV_DEREGISTER( lp );
  817. result = -EFAULT;
  818. DBG_LEAVE( DbgInfo );
  819. return result;
  820. } // wl_insert
  821. /*============================================================================*/
  822. /*******************************************************************************
  823. * wl_reset()
  824. *******************************************************************************
  825. *
  826. * DESCRIPTION:
  827. *
  828. * Reset the adapter.
  829. *
  830. * PARAMETERS:
  831. *
  832. * dev - a pointer to the net_device struct of the wireless device
  833. *
  834. * RETURNS:
  835. *
  836. * an HCF status code
  837. *
  838. ******************************************************************************/
  839. int wl_reset(struct net_device *dev)
  840. {
  841. struct wl_private *lp = wl_priv(dev);
  842. int hcf_status = HCF_SUCCESS;
  843. /*------------------------------------------------------------------------*/
  844. DBG_FUNC( "wl_reset" );
  845. DBG_ENTER( DbgInfo );
  846. DBG_PARAM( DbgInfo, "dev", "%s (0x%p)", dev->name, dev );
  847. DBG_PARAM( DbgInfo, "dev->base_addr", "(%#03lx)", dev->base_addr );
  848. /*
  849. * The caller should already have a lock and
  850. * disable the interrupts, we do not lock here,
  851. * nor do we enable/disable interrupts!
  852. */
  853. DBG_TRACE( DbgInfo, "Device Base Address: %#03lx\n", dev->base_addr );
  854. if ( dev->base_addr ) {
  855. /* Shutdown the adapter. */
  856. hcf_connect( &lp->hcfCtx, HCF_DISCONNECT );
  857. /* Reset the driver information. */
  858. lp->txBytes = 0;
  859. /* Connect to the adapter. */
  860. hcf_status = hcf_connect( &lp->hcfCtx, dev->base_addr );
  861. if ( hcf_status != HCF_SUCCESS && hcf_status != HCF_ERR_INCOMP_FW ) {
  862. DBG_ERROR( DbgInfo, "hcf_connect() failed, status: 0x%x\n", hcf_status );
  863. goto out;
  864. }
  865. /* Check if firmware is present, if not change state */
  866. if ( hcf_status == HCF_ERR_INCOMP_FW ) {
  867. lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
  868. }
  869. /* Initialize the portState variable */
  870. lp->portState = WVLAN_PORT_STATE_DISABLED;
  871. /* Restart the adapter. */
  872. hcf_status = wl_go( lp );
  873. if ( hcf_status != HCF_SUCCESS ) {
  874. DBG_ERROR( DbgInfo, "wl_go() failed, status: 0x%x\n", hcf_status );
  875. goto out;
  876. }
  877. /* Certain RIDs must be set before enabling the ports */
  878. wl_put_ltv_init( lp );
  879. } else {
  880. DBG_ERROR( DbgInfo, "Device Base Address INVALID!!!\n" );
  881. }
  882. out:
  883. DBG_LEAVE( DbgInfo );
  884. return hcf_status;
  885. } // wl_reset
  886. /*============================================================================*/
  887. /*******************************************************************************
  888. * wl_go()
  889. *******************************************************************************
  890. *
  891. * DESCRIPTION:
  892. *
  893. * Reset the adapter.
  894. *
  895. * PARAMETERS:
  896. *
  897. * dev - a pointer to the net_device struct of the wireless device
  898. *
  899. * RETURNS:
  900. *
  901. * an HCF status code
  902. *
  903. ******************************************************************************/
  904. int wl_go( struct wl_private *lp )
  905. {
  906. int hcf_status = HCF_SUCCESS;
  907. char *cp = NULL; //fw_image
  908. int retries = 0;
  909. /*------------------------------------------------------------------------*/
  910. DBG_FUNC( "wl_go" );
  911. DBG_ENTER( DbgInfo );
  912. hcf_status = wl_disable( lp );
  913. if ( hcf_status != HCF_SUCCESS ) {
  914. DBG_TRACE( DbgInfo, "Disable port 0 failed: 0x%x\n", hcf_status );
  915. while (( hcf_status != HCF_SUCCESS ) && (retries < 10)) {
  916. retries++;
  917. hcf_status = wl_disable( lp );
  918. }
  919. if ( hcf_status == HCF_SUCCESS ) {
  920. DBG_TRACE( DbgInfo, "Disable port 0 succes : %d retries\n", retries );
  921. } else {
  922. DBG_TRACE( DbgInfo, "Disable port 0 failed after: %d retries\n", retries );
  923. }
  924. }
  925. #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
  926. //DBG_TRACE( DbgInfo, "Disabling WDS Ports\n" );
  927. //wl_disable_wds_ports( lp );
  928. #endif /* (HCF_TYPE) & HCF_TYPE_AP */
  929. //;?what was the purpose of this
  930. // /* load the appropriate firmware image, depending on driver mode */
  931. // lp->ltvRecord.len = ( sizeof( CFG_RANGE20_STRCT ) / sizeof( hcf_16 )) - 1;
  932. // lp->ltvRecord.typ = CFG_DRV_ACT_RANGES_PRI;
  933. // hcf_get_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
  934. #if BIN_DL
  935. if ( strlen( lp->fw_image_filename ) ) {
  936. mm_segment_t fs;
  937. int file_desc;
  938. int rc;
  939. DBG_TRACE( DbgInfo, "F/W image:%s:\n", lp->fw_image_filename );
  940. /* Obtain a user-space process context, storing the original context */
  941. fs = get_fs( );
  942. set_fs( get_ds( ));
  943. file_desc = open( lp->fw_image_filename, O_RDONLY, 0 );
  944. if ( file_desc == -1 ) {
  945. DBG_ERROR( DbgInfo, "No image file found\n" );
  946. } else {
  947. DBG_TRACE( DbgInfo, "F/W image file found\n" );
  948. #define DHF_ALLOC_SIZE 96000 //just below 96K, let's hope it suffices for now and for the future
  949. cp = (char*)vmalloc( DHF_ALLOC_SIZE );
  950. if ( cp == NULL ) {
  951. DBG_ERROR( DbgInfo, "error in vmalloc\n" );
  952. } else {
  953. rc = read( file_desc, cp, DHF_ALLOC_SIZE );
  954. if ( rc == DHF_ALLOC_SIZE ) {
  955. DBG_ERROR( DbgInfo, "buffer too small, %d\n", DHF_ALLOC_SIZE );
  956. } else if ( rc > 0 ) {
  957. DBG_TRACE( DbgInfo, "read O.K.: %d bytes %.12s\n", rc, cp );
  958. rc = read( file_desc, &cp[rc], 1 );
  959. if ( rc == 0 ) { //;/change to an until-loop at rc<=0
  960. DBG_TRACE( DbgInfo, "no more to read\n" );
  961. }
  962. }
  963. if ( rc != 0 ) {
  964. DBG_ERROR( DbgInfo, "file not read in one swoop or other error"\
  965. ", give up, too complicated, rc = %0X\n", rc );
  966. DBG_ERROR( DbgInfo, "still have to change code to get a real download now !!!!!!!!\n" );
  967. } else {
  968. DBG_TRACE( DbgInfo, "before dhf_download_binary\n" );
  969. hcf_status = dhf_download_binary( (memimage *)cp );
  970. DBG_TRACE( DbgInfo, "after dhf_download_binary, before dhf_download_fw\n" );
  971. //;?improve error flow/handling
  972. hcf_status = dhf_download_fw( &lp->hcfCtx, (memimage *)cp );
  973. DBG_TRACE( DbgInfo, "after dhf_download_fw\n" );
  974. }
  975. vfree( cp );
  976. }
  977. close( file_desc );
  978. }
  979. set_fs( fs ); /* Return to the original context */
  980. }
  981. #endif // BIN_DL
  982. /* If firmware is present but the type is unknown then download anyway */
  983. if ( (lp->firmware_present == WL_FRIMWARE_PRESENT)
  984. &&
  985. ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) != COMP_ID_FW_STA )
  986. &&
  987. ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) != COMP_ID_FW_AP ) ) {
  988. /* Unknown type, download needed. */
  989. lp->firmware_present = WL_FRIMWARE_NOT_PRESENT;
  990. }
  991. if(lp->firmware_present == WL_FRIMWARE_NOT_PRESENT)
  992. {
  993. if ( cp == NULL ) {
  994. DBG_TRACE( DbgInfo, "Downloading STA firmware...\n" );
  995. // hcf_status = dhf_download_fw( &lp->hcfCtx, &station );
  996. hcf_status = dhf_download_fw( &lp->hcfCtx, &fw_image );
  997. }
  998. if ( hcf_status != HCF_SUCCESS ) {
  999. DBG_ERROR( DbgInfo, "Firmware Download failed\n" );
  1000. DBG_LEAVE( DbgInfo );
  1001. return hcf_status;
  1002. }
  1003. }
  1004. /* Report the FW versions */
  1005. //;?obsolete, use the available IFB info:: wl_get_pri_records( lp );
  1006. if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA ) {
  1007. DBG_TRACE( DbgInfo, "downloaded station F/W\n" );
  1008. } else if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
  1009. DBG_TRACE( DbgInfo, "downloaded AP F/W\n" );
  1010. } else {
  1011. DBG_ERROR( DbgInfo, "unknown F/W type\n" );
  1012. }
  1013. /*
  1014. * Downloaded, no need to repeat this next time, assume the
  1015. * contents stays in the card until it is powered off. Note we
  1016. * do not switch firmware on the fly, the firmware is fixed in
  1017. * the driver for now.
  1018. */
  1019. lp->firmware_present = WL_FRIMWARE_PRESENT;
  1020. DBG_TRACE( DbgInfo, "ComponentID:%04x variant:%04x major:%04x minor:%04x\n",
  1021. CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ),
  1022. CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.variant ),
  1023. CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.version_major ),
  1024. CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.version_minor ));
  1025. /* now we wil get the MAC address of the card */
  1026. lp->ltvRecord.len = 4;
  1027. if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP ) {
  1028. lp->ltvRecord.typ = CFG_NIC_MAC_ADDR;
  1029. } else
  1030. {
  1031. lp->ltvRecord.typ = CFG_CNF_OWN_MAC_ADDR;
  1032. }
  1033. hcf_status = hcf_get_info( &lp->hcfCtx, (LTVP)&( lp->ltvRecord ));
  1034. if ( hcf_status != HCF_SUCCESS ) {
  1035. DBG_ERROR( DbgInfo, "Could not retrieve MAC address\n" );
  1036. DBG_LEAVE( DbgInfo );
  1037. return hcf_status;
  1038. }
  1039. memcpy( lp->MACAddress, &lp->ltvRecord.u.u8[0], ETH_ALEN );
  1040. DBG_TRACE(DbgInfo, "Card MAC Address: %pM\n", lp->MACAddress);
  1041. /* Write out configuration to the device, enable, and reconnect. However,
  1042. only reconn…