2 #include <typedefs.h>
\r
5 #include <bcmutils.h>
\r
7 #include <bcmsdbus.h>
\r
8 #if defined(HW_OOB) || defined(FORCE_WOWLAN)
12 #include <sbchipc.h>
\r
15 #include <dhd_config.h>
\r
16 #include <dhd_dbg.h>
\r
19 #define CONFIG_ERROR_LEVEL 0x0001
\r
20 #define CONFIG_TRACE_LEVEL 0x0002
\r
22 uint config_msg_level = CONFIG_ERROR_LEVEL;
\r
24 #define CONFIG_ERROR(x) \
\r
26 if (config_msg_level & CONFIG_ERROR_LEVEL) { \
\r
27 printk(KERN_ERR "CONFIG-ERROR) "); \
\r
31 #define CONFIG_TRACE(x) \
\r
33 if (config_msg_level & CONFIG_TRACE_LEVEL) { \
\r
34 printk(KERN_ERR "CONFIG-TRACE) "); \
\r
39 #define MAXSZ_BUF 1000
\r
40 #define MAXSZ_CONFIG 4096
\r
42 #define FW_TYPE_STA 0
\r
43 #define FW_TYPE_APSTA 1
\r
44 #define FW_TYPE_P2P 2
\r
45 #define FW_TYPE_ES 3
\r
46 #define FW_TYPE_MFG 4
\r
48 #define FW_TYPE_AG 1
\r
50 #ifdef CONFIG_PATH_AUTO_SELECT
\r
51 #define BCM4330B2_CONF_NAME "config_40183b2.txt"
\r
52 #define BCM43362A0_CONF_NAME "config_40181a0.txt"
\r
53 #define BCM43362A2_CONF_NAME "config_40181a2.txt"
\r
54 #define BCM43438A0_CONF_NAME "config_43438a0.txt"
\r
55 #define BCM43438A1_CONF_NAME "config_43438a1.txt"
\r
56 #define BCM4334B1_CONF_NAME "config_4334b1.txt"
\r
57 #define BCM43341B0_CONF_NAME "config_43341b0.txt"
\r
58 #define BCM43241B4_CONF_NAME "config_43241b4.txt"
\r
59 #define BCM4339A0_CONF_NAME "config_4339a0.txt"
\r
60 #define BCM43455C0_CONF_NAME "config_43455c0.txt"
\r
61 #define BCM4354A1_CONF_NAME "config_4354a1.txt"
\r
62 #define BCM4356A2_CONF_NAME "config_4356a2.txt"
\r
63 #define BCM4359B1_CONF_NAME "config_4359b1.txt"
\r
67 #define SBSDIO_CIS_SIZE_LIMIT 0x200 /* maximum bytes in one CIS */
\r
69 const static char *bcm4330b2_fw_name[] = {
\r
70 "fw_bcm40183b2.bin",
\r
71 "fw_bcm40183b2_apsta.bin",
\r
72 "fw_bcm40183b2_p2p.bin",
\r
73 "fw_bcm40183b2_es.bin",
\r
74 "fw_bcm40183b2_mfg.bin"
\r
77 const static char *bcm4330b2_ag_fw_name[] = {
\r
78 "fw_bcm40183b2_ag.bin",
\r
79 "fw_bcm40183b2_ag_apsta.bin",
\r
80 "fw_bcm40183b2_ag_p2p.bin",
\r
81 "fw_bcm40183b2_ag_es.bin",
\r
82 "fw_bcm40183b2_ag_mfg.bin"
\r
85 const static char *bcm43362a0_fw_name[] = {
\r
86 "fw_bcm40181a0.bin",
\r
87 "fw_bcm40181a0_apsta.bin",
\r
88 "fw_bcm40181a0_p2p.bin",
\r
89 "fw_bcm40181a0_es.bin",
\r
90 "fw_bcm40181a0_mfg.bin"
\r
93 const static char *bcm43362a2_fw_name[] = {
\r
94 "fw_bcm40181a2.bin",
\r
95 "fw_bcm40181a2_apsta.bin",
\r
96 "fw_bcm40181a2_p2p.bin",
\r
97 "fw_bcm40181a2_es.bin",
\r
98 "fw_bcm40181a2_mfg.bin"
\r
101 const static char *bcm4334b1_ag_fw_name[] = {
\r
102 "fw_bcm4334b1_ag.bin",
\r
103 "fw_bcm4334b1_ag_apsta.bin",
\r
104 "fw_bcm4334b1_ag_p2p.bin",
\r
105 "fw_bcm4334b1_ag_es.bin",
\r
106 "fw_bcm4334b1_ag_mfg.bin"
\r
109 const static char *bcm43438a0_fw_name[] = {
\r
110 "fw_bcm43438a0.bin",
\r
111 "fw_bcm43438a0_apsta.bin",
\r
112 "fw_bcm43438a0_p2p.bin",
\r
113 "fw_bcm43438a0_es.bin",
\r
114 "fw_bcm43438a0_mfg.bin"
\r
117 const static char *bcm43438a1_fw_name[] = {
\r
118 "fw_bcm43438a1.bin",
\r
119 "fw_bcm43438a1_apsta.bin",
\r
120 "fw_bcm43438a1_p2p.bin",
\r
121 "fw_bcm43438a1_es.bin",
\r
122 "fw_bcm43438a1_mfg.bin"
\r
125 const static char *bcm43341b0_ag_fw_name[] = {
\r
126 "fw_bcm43341b0_ag.bin",
\r
127 "fw_bcm43341b0_ag_apsta.bin",
\r
128 "fw_bcm43341b0_ag_p2p.bin",
\r
129 "fw_bcm43341b0_ag_es.bin",
\r
130 "fw_bcm43341b0_ag_mfg.bin"
\r
133 const static char *bcm43241b4_ag_fw_name[] = {
\r
134 "fw_bcm43241b4_ag.bin",
\r
135 "fw_bcm43241b4_ag_apsta.bin",
\r
136 "fw_bcm43241b4_ag_p2p.bin",
\r
137 "fw_bcm43241b4_ag_es.bin",
\r
138 "fw_bcm43241b4_ag_mfg.bin"
\r
141 const static char *bcm4339a0_ag_fw_name[] = {
\r
142 "fw_bcm4339a0_ag.bin",
\r
143 "fw_bcm4339a0_ag_apsta.bin",
\r
144 "fw_bcm4339a0_ag_p2p.bin",
\r
145 "fw_bcm4339a0_ag_es.bin",
\r
146 "fw_bcm4339a0_ag_mfg.bin"
\r
149 const static char *bcm43455c0_ag_fw_name[] = {
\r
150 "fw_bcm43455c0_ag.bin",
\r
151 "fw_bcm43455c0_ag_apsta.bin",
\r
152 "fw_bcm43455c0_ag_p2p.bin",
\r
153 "fw_bcm43455c0_ag_es.bin",
\r
154 "fw_bcm43455c0_ag_mfg.bin"
\r
157 const static char *bcm4354a1_ag_fw_name[] = {
\r
158 "fw_bcm4354a1_ag.bin",
\r
159 "fw_bcm4354a1_ag_apsta.bin",
\r
160 "fw_bcm4354a1_ag_p2p.bin",
\r
161 "fw_bcm4354a1_ag_es.bin",
\r
162 "fw_bcm4354a1_ag_mfg.bin"
\r
165 const static char *bcm4356a2_ag_fw_name[] = {
\r
166 "fw_bcm4356a2_ag.bin",
\r
167 "fw_bcm4356a2_ag_apsta.bin",
\r
168 "fw_bcm4356a2_ag_p2p.bin",
\r
169 "fw_bcm4356a2_ag_es.bin",
\r
170 "fw_bcm4356a2_ag_mfg.bin"
\r
173 const static char *bcm4359b1_ag_fw_name[] = {
\r
174 "fw_bcm4359b1_ag.bin",
\r
175 "fw_bcm4359b1_ag_apsta.bin",
\r
176 "fw_bcm4359b1_ag_p2p.bin",
\r
177 "fw_bcm4359b1_ag_es.bin",
\r
178 "fw_bcm4359b1_ag_mfg.bin"
\r
182 const static char *bcm4356a2_pcie_ag_fw_name[] = {
\r
183 "fw_bcm4356a2_pcie_ag.bin",
\r
184 "fw_bcm4356a2_pcie_ag_apsta.bin",
\r
185 "fw_bcm4356a2_pcie_ag_p2p.bin",
\r
186 "fw_bcm4356a2_pcie_ag_es.bin",
\r
187 "fw_bcm4356a2_pcie_ag_mfg.bin"
\r
195 #define htodchanspec(i) i
196 #define dtohchanspec(i) i
\r
200 dhd_conf_free_mac_list(wl_mac_list_ctrl_t *mac_list)
\r
204 CONFIG_TRACE(("%s called\n", __FUNCTION__));
\r
205 if (mac_list->m_mac_list_head) {
\r
206 for (i=0; i<mac_list->count; i++) {
\r
207 if (mac_list->m_mac_list_head[i].mac) {
\r
208 CONFIG_TRACE(("%s Free mac %p\n", __FUNCTION__, mac_list->m_mac_list_head[i].mac));
\r
209 kfree(mac_list->m_mac_list_head[i].mac);
\r
212 CONFIG_TRACE(("%s Free m_mac_list_head %p\n", __FUNCTION__, mac_list->m_mac_list_head));
\r
213 kfree(mac_list->m_mac_list_head);
\r
215 mac_list->count = 0;
\r
219 dhd_conf_free_chip_nv_path_list(wl_chip_nv_path_list_ctrl_t *chip_nv_list)
\r
221 CONFIG_TRACE(("%s called\n", __FUNCTION__));
\r
223 if (chip_nv_list->m_chip_nv_path_head) {
\r
224 CONFIG_TRACE(("%s Free %p\n", __FUNCTION__, chip_nv_list->m_chip_nv_path_head));
\r
225 kfree(chip_nv_list->m_chip_nv_path_head);
\r
227 chip_nv_list->count = 0;
\r
230 #if defined(HW_OOB) || defined(FORCE_WOWLAN)
\r
232 dhd_conf_set_hw_oob_intr(bcmsdh_info_t *sdh, uint chip)
\r
234 uint32 gpiocontrol, addr;
\r
236 if (CHIPID(chip) == BCM43362_CHIP_ID) {
\r
237 printf("%s: Enable HW OOB for 43362\n", __FUNCTION__);
\r
238 addr = SI_ENUM_BASE + OFFSETOF(chipcregs_t, gpiocontrol);
\r
239 gpiocontrol = bcmsdh_reg_read(sdh, addr, 4);
\r
240 gpiocontrol |= 0x2;
\r
241 bcmsdh_reg_write(sdh, addr, 4, gpiocontrol);
\r
242 bcmsdh_cfg_write(sdh, SDIO_FUNC_1, 0x10005, 0xf, NULL);
\r
243 bcmsdh_cfg_write(sdh, SDIO_FUNC_1, 0x10006, 0x0, NULL);
\r
244 bcmsdh_cfg_write(sdh, SDIO_FUNC_1, 0x10007, 0x2, NULL);
\r
250 dhd_conf_get_mac(dhd_pub_t *dhd, bcmsdh_info_t *sdh, uint8 *mac)
\r
254 unsigned char tpl_code, tpl_link='\0';
\r
255 uint8 header[3] = {0x80, 0x07, 0x19};
\r
258 if (!(cis = MALLOC(dhd->osh, SBSDIO_CIS_SIZE_LIMIT))) {
\r
259 CONFIG_ERROR(("%s: cis malloc failed\n", __FUNCTION__));
\r
262 bzero(cis, SBSDIO_CIS_SIZE_LIMIT);
\r
264 if ((err = bcmsdh_cis_read(sdh, 0, cis, SBSDIO_CIS_SIZE_LIMIT))) {
\r
265 CONFIG_ERROR(("%s: cis read err %d\n", __FUNCTION__, err));
\r
266 MFREE(dhd->osh, cis, SBSDIO_CIS_SIZE_LIMIT);
\r
269 err = -1; // reset err;
\r
272 /* 0xff means we're done */
\r
275 if (tpl_code == 0xff)
\r
278 /* null entries have no link field or data */
\r
279 if (tpl_code == 0x00)
\r
284 /* a size of 0xff also means we're done */
\r
285 if (tpl_link == 0xff)
\r
287 if (config_msg_level & CONFIG_TRACE_LEVEL) {
\r
288 printf("%s: tpl_code=0x%02x, tpl_link=0x%02x, tag=0x%02x\n",
\r
289 __FUNCTION__, tpl_code, tpl_link, *ptr);
\r
290 printk("%s: value:", __FUNCTION__);
\r
291 for (i=0; i<tpl_link-1; i++) {
\r
292 printk("%02x ", ptr[i+1]);
\r
293 if ((i+1) % 16 == 0)
\r
299 if (tpl_code == 0x80 && tpl_link == 0x07 && *ptr == 0x19)
\r
305 if (tpl_code == 0x80 && tpl_link == 0x07 && *ptr == 0x19) {
\r
307 memcpy(mac, ptr+1, 6);
\r
312 if (bcmsdh_reg_read(sdh, SI_ENUM_BASE, 4) == 0x16044330) {
\r
313 for (i=0; i<SBSDIO_CIS_SIZE_LIMIT; i++) {
\r
314 if (!memcmp(header, ptr, 3)) {
\r
315 memcpy(mac, ptr+1, 6);
\r
325 MFREE(dhd->osh, cis, SBSDIO_CIS_SIZE_LIMIT);
\r
331 dhd_conf_set_fw_name_by_mac(dhd_pub_t *dhd, bcmsdh_info_t *sdh, char *fw_path)
\r
335 int fw_num=0, mac_num=0;
\r
337 wl_mac_list_t *mac_list;
\r
338 wl_mac_range_t *mac_range;
\r
340 int fw_type, fw_type_new;
\r
342 mac_list = dhd->conf->fw_by_mac.m_mac_list_head;
\r
343 fw_num = dhd->conf->fw_by_mac.count;
\r
344 if (!mac_list || !fw_num)
\r
347 if (dhd_conf_get_mac(dhd, sdh, mac)) {
\r
348 CONFIG_ERROR(("%s: Can not read MAC address\n", __FUNCTION__));
\r
351 oui = (mac[0] << 16) | (mac[1] << 8) | (mac[2]);
\r
352 nic = (mac[3] << 16) | (mac[4] << 8) | (mac[5]);
\r
354 /* find out the last '/' */
\r
355 i = strlen(fw_path);
\r
357 if (fw_path[i] == '/') break;
\r
360 pfw_name = &fw_path[i+1];
\r
361 fw_type = (strstr(pfw_name, "_mfg") ?
\r
362 FW_TYPE_MFG : (strstr(pfw_name, "_apsta") ?
\r
363 FW_TYPE_APSTA : (strstr(pfw_name, "_p2p") ?
\r
364 FW_TYPE_P2P : FW_TYPE_STA)));
\r
366 for (i=0; i<fw_num; i++) {
\r
367 mac_num = mac_list[i].count;
\r
368 mac_range = mac_list[i].mac;
\r
369 fw_type_new = (strstr(mac_list[i].name, "_mfg") ?
\r
370 FW_TYPE_MFG : (strstr(mac_list[i].name, "_apsta") ?
\r
371 FW_TYPE_APSTA : (strstr(mac_list[i].name, "_p2p") ?
\r
372 FW_TYPE_P2P : FW_TYPE_STA)));
\r
373 if (fw_type != fw_type_new) {
\r
374 printf("%s: fw_typ=%d != fw_type_new=%d\n", __FUNCTION__, fw_type, fw_type_new);
\r
377 for (j=0; j<mac_num; j++) {
\r
378 if (oui == mac_range[j].oui) {
\r
379 if (nic >= mac_range[j].nic_start && nic <= mac_range[j].nic_end) {
\r
380 strcpy(pfw_name, mac_list[i].name);
\r
381 printf("%s: matched oui=0x%06X, nic=0x%06X\n",
\r
382 __FUNCTION__, oui, nic);
\r
383 printf("%s: fw_path=%s\n", __FUNCTION__, fw_path);
\r
392 dhd_conf_set_nv_name_by_mac(dhd_pub_t *dhd, bcmsdh_info_t *sdh, char *nv_path)
\r
396 int nv_num=0, mac_num=0;
\r
398 wl_mac_list_t *mac_list;
\r
399 wl_mac_range_t *mac_range;
\r
402 mac_list = dhd->conf->nv_by_mac.m_mac_list_head;
\r
403 nv_num = dhd->conf->nv_by_mac.count;
\r
404 if (!mac_list || !nv_num)
\r
407 if (dhd_conf_get_mac(dhd, sdh, mac)) {
\r
408 CONFIG_ERROR(("%s: Can not read MAC address\n", __FUNCTION__));
\r
411 oui = (mac[0] << 16) | (mac[1] << 8) | (mac[2]);
\r
412 nic = (mac[3] << 16) | (mac[4] << 8) | (mac[5]);
\r
414 /* find out the last '/' */
\r
415 i = strlen(nv_path);
\r
417 if (nv_path[i] == '/') break;
\r
420 pnv_name = &nv_path[i+1];
\r
422 for (i=0; i<nv_num; i++) {
\r
423 mac_num = mac_list[i].count;
\r
424 mac_range = mac_list[i].mac;
\r
425 for (j=0; j<mac_num; j++) {
\r
426 if (oui == mac_range[j].oui) {
\r
427 if (nic >= mac_range[j].nic_start && nic <= mac_range[j].nic_end) {
\r
428 strcpy(pnv_name, mac_list[i].name);
\r
429 printf("%s: matched oui=0x%06X, nic=0x%06X\n",
\r
430 __FUNCTION__, oui, nic);
\r
431 printf("%s: nv_path=%s\n", __FUNCTION__, nv_path);
\r
441 dhd_conf_set_fw_name_by_chip(dhd_pub_t *dhd, char *fw_path)
\r
443 int fw_type, ag_type;
\r
444 uint chip, chiprev;
\r
447 chip = dhd->conf->chip;
\r
448 chiprev = dhd->conf->chiprev;
\r
450 if (fw_path[0] == '\0') {
\r
451 #ifdef CONFIG_BCMDHD_FW_PATH
\r
452 bcm_strncpy_s(fw_path, MOD_PARAM_PATHLEN-1, CONFIG_BCMDHD_FW_PATH, MOD_PARAM_PATHLEN-1);
\r
453 if (fw_path[0] == '\0')
\r
456 printf("firmware path is null\n");
\r
460 #ifndef FW_PATH_AUTO_SELECT
\r
464 /* find out the last '/' */
\r
465 i = strlen(fw_path);
\r
467 if (fw_path[i] == '/') break;
\r
471 ag_type = FW_TYPE_AG;
\r
473 ag_type = strstr(&fw_path[i], "_ag") ? FW_TYPE_AG : FW_TYPE_G;
\r
475 fw_type = (strstr(&fw_path[i], "_mfg") ? FW_TYPE_MFG :
\r
476 (strstr(&fw_path[i], "_apsta") ? FW_TYPE_APSTA :
\r
477 (strstr(&fw_path[i], "_p2p") ? FW_TYPE_P2P :
\r
478 (strstr(&fw_path[i], "_es") ? FW_TYPE_ES :
\r
483 case BCM4330_CHIP_ID:
\r
484 if (ag_type == FW_TYPE_G) {
\r
485 if (chiprev == BCM4330B2_CHIP_REV)
\r
486 strcpy(&fw_path[i+1], bcm4330b2_fw_name[fw_type]);
\r
489 if (chiprev == BCM4330B2_CHIP_REV)
\r
490 strcpy(&fw_path[i+1], bcm4330b2_ag_fw_name[fw_type]);
\r
493 case BCM43362_CHIP_ID:
\r
494 if (chiprev == BCM43362A0_CHIP_REV)
\r
495 strcpy(&fw_path[i+1], bcm43362a0_fw_name[fw_type]);
\r
497 strcpy(&fw_path[i+1], bcm43362a2_fw_name[fw_type]);
\r
499 case BCM43430_CHIP_ID:
\r
500 if (chiprev == BCM43430A0_CHIP_REV)
\r
501 strcpy(&fw_path[i+1], bcm43438a0_fw_name[fw_type]);
\r
502 else if (chiprev == BCM43430A1_CHIP_REV)
\r
503 strcpy(&fw_path[i+1], bcm43438a1_fw_name[fw_type]);
\r
505 case BCM4334_CHIP_ID:
\r
506 if (chiprev == BCM4334B1_CHIP_REV)
\r
507 strcpy(&fw_path[i+1], bcm4334b1_ag_fw_name[fw_type]);
\r
509 case BCM43340_CHIP_ID:
\r
510 case BCM43341_CHIP_ID:
\r
511 if (chiprev == BCM43341B0_CHIP_REV)
\r
512 strcpy(&fw_path[i+1], bcm43341b0_ag_fw_name[fw_type]);
\r
514 case BCM4324_CHIP_ID:
\r
515 if (chiprev == BCM43241B4_CHIP_REV)
\r
516 strcpy(&fw_path[i+1], bcm43241b4_ag_fw_name[fw_type]);
\r
518 case BCM4335_CHIP_ID:
\r
519 if (chiprev == BCM4335A0_CHIP_REV)
\r
520 strcpy(&fw_path[i+1], bcm4339a0_ag_fw_name[fw_type]);
\r
522 case BCM4345_CHIP_ID:
\r
523 case BCM43454_CHIP_ID:
\r
524 if (chiprev == BCM43455C0_CHIP_REV)
\r
525 strcpy(&fw_path[i+1], bcm43455c0_ag_fw_name[fw_type]);
\r
527 case BCM4339_CHIP_ID:
\r
528 if (chiprev == BCM4339A0_CHIP_REV)
\r
529 strcpy(&fw_path[i+1], bcm4339a0_ag_fw_name[fw_type]);
\r
531 case BCM4354_CHIP_ID:
\r
532 if (chiprev == BCM4354A1_CHIP_REV)
\r
533 strcpy(&fw_path[i+1], bcm4354a1_ag_fw_name[fw_type]);
\r
534 else if (chiprev == BCM4356A2_CHIP_REV)
\r
535 strcpy(&fw_path[i+1], bcm4356a2_ag_fw_name[fw_type]);
\r
537 case BCM4356_CHIP_ID:
\r
538 case BCM4371_CHIP_ID:
\r
539 if (chiprev == BCM4356A2_CHIP_REV)
\r
540 strcpy(&fw_path[i+1], bcm4356a2_ag_fw_name[fw_type]);
\r
542 case BCM4359_CHIP_ID:
\r
543 if (chiprev == BCM4359B1_CHIP_REV)
\r
544 strcpy(&fw_path[i+1], bcm4359b1_ag_fw_name[fw_type]);
\r
548 case BCM4354_CHIP_ID:
\r
549 if (chiprev == BCM4356A2_CHIP_REV)
\r
550 strcpy(&fw_path[i+1], bcm4356a2_pcie_ag_fw_name[fw_type]);
\r
552 case BCM4356_CHIP_ID:
\r
553 if (chiprev == BCM4356A2_CHIP_REV)
\r
554 strcpy(&fw_path[i+1], bcm4356a2_pcie_ag_fw_name[fw_type]);
\r
559 printf("%s: firmware_path=%s\n", __FUNCTION__, fw_path);
\r
563 dhd_conf_set_nv_name_by_chip(dhd_pub_t *dhd, char *nv_path)
\r
566 uint chip, chiprev;
\r
569 chip = dhd->conf->chip;
\r
570 chiprev = dhd->conf->chiprev;
\r
572 for (i=0; i<dhd->conf->nv_by_chip.count; i++) {
\r
573 if (chip==dhd->conf->nv_by_chip.m_chip_nv_path_head[i].chip &&
\r
574 chiprev==dhd->conf->nv_by_chip.m_chip_nv_path_head[i].chiprev) {
\r
582 if (nv_path[0] == '\0') {
\r
583 #ifdef CONFIG_BCMDHD_NVRAM_PATH
\r
584 bcm_strncpy_s(nv_path, MOD_PARAM_PATHLEN-1, CONFIG_BCMDHD_NVRAM_PATH, MOD_PARAM_PATHLEN-1);
\r
585 if (nv_path[0] == '\0')
\r
588 printf("nvram path is null\n");
\r
593 /* find out the last '/' */
\r
594 i = strlen(nv_path);
\r
596 if (nv_path[i] == '/') break;
\r
600 strcpy(&nv_path[i+1], dhd->conf->nv_by_chip.m_chip_nv_path_head[matched].name);
\r
602 printf("%s: nvram_path=%s\n", __FUNCTION__, nv_path);
\r
606 dhd_conf_set_conf_path_by_nv_path(dhd_pub_t *dhd, char *conf_path, char *nv_path)
\r
610 if (nv_path[0] == '\0') {
\r
611 #ifdef CONFIG_BCMDHD_NVRAM_PATH
\r
612 bcm_strncpy_s(conf_path, MOD_PARAM_PATHLEN-1, CONFIG_BCMDHD_NVRAM_PATH, MOD_PARAM_PATHLEN-1);
\r
613 if (nv_path[0] == '\0')
\r
616 printf("nvram path is null\n");
\r
620 strcpy(conf_path, nv_path);
\r
622 /* find out the last '/' */
\r
623 i = strlen(conf_path);
\r
625 if (conf_path[i] == '/') break;
\r
628 strcpy(&conf_path[i+1], "config.txt");
\r
630 printf("%s: config_path=%s\n", __FUNCTION__, conf_path);
\r
633 #ifdef CONFIG_PATH_AUTO_SELECT
\r
635 dhd_conf_set_conf_name_by_chip(dhd_pub_t *dhd, char *conf_path)
\r
637 uint chip, chiprev;
\r
640 chip = dhd->conf->chip;
\r
641 chiprev = dhd->conf->chiprev;
\r
643 if (conf_path[0] == '\0') {
\r
644 printf("config path is null\n");
\r
648 /* find out the last '/' */
\r
649 i = strlen(conf_path);
\r
651 if (conf_path[i] == '/') break;
\r
657 case BCM4330_CHIP_ID:
\r
658 if (chiprev == BCM4330B2_CHIP_REV)
\r
659 strcpy(&conf_path[i+1], BCM4330B2_CONF_NAME);
\r
661 case BCM43362_CHIP_ID:
\r
662 if (chiprev == BCM43362A0_CHIP_REV)
\r
663 strcpy(&conf_path[i+1], BCM43362A0_CONF_NAME);
\r
665 strcpy(&conf_path[i+1], BCM43362A2_CONF_NAME);
\r
667 case BCM43430_CHIP_ID:
\r
668 if (chiprev == BCM43430A0_CHIP_REV)
\r
669 strcpy(&conf_path[i+1], BCM43438A0_CONF_NAME);
\r
670 else if (chiprev == BCM43430A1_CHIP_REV)
\r
671 strcpy(&conf_path[i+1], BCM43438A1_CONF_NAME);
\r
673 case BCM4334_CHIP_ID:
\r
674 if (chiprev == BCM4334B1_CHIP_REV)
\r
675 strcpy(&conf_path[i+1], BCM4334B1_CONF_NAME);
\r
677 case BCM43340_CHIP_ID:
\r
678 case BCM43341_CHIP_ID:
\r
679 if (chiprev == BCM43341B0_CHIP_REV)
\r
680 strcpy(&conf_path[i+1], BCM43341B0_CONF_NAME);
\r
682 case BCM4324_CHIP_ID:
\r
683 if (chiprev == BCM43241B4_CHIP_REV)
\r
684 strcpy(&conf_path[i+1], BCM43241B4_CONF_NAME);
\r
686 case BCM4335_CHIP_ID:
\r
687 if (chiprev == BCM4335A0_CHIP_REV)
\r
688 strcpy(&conf_path[i+1], BCM4339A0_CONF_NAME);
\r
690 case BCM4345_CHIP_ID:
\r
691 case BCM43454_CHIP_ID:
\r
692 if (chiprev == BCM43455C0_CHIP_REV)
\r
693 strcpy(&conf_path[i+1], BCM43455C0_CONF_NAME);
\r
695 case BCM4339_CHIP_ID:
\r
696 if (chiprev == BCM4339A0_CHIP_REV)
\r
697 strcpy(&conf_path[i+1], BCM4339A0_CONF_NAME);
\r
699 case BCM4354_CHIP_ID:
\r
700 if (chiprev == BCM4354A1_CHIP_REV)
\r
701 strcpy(&conf_path[i+1], BCM4354A1_CONF_NAME);
\r
702 else if (chiprev == BCM4356A2_CHIP_REV)
\r
703 strcpy(&conf_path[i+1], BCM4356A2_CONF_NAME);
\r
705 case BCM4356_CHIP_ID:
\r
706 case BCM4371_CHIP_ID:
\r
707 if (chiprev == BCM4356A2_CHIP_REV)
\r
708 strcpy(&conf_path[i+1], BCM4356A2_CONF_NAME);
\r
710 case BCM4359_CHIP_ID:
\r
711 if (chiprev == BCM4359B1_CHIP_REV)
\r
712 strcpy(&conf_path[i+1], BCM4359B1_CONF_NAME);
\r
716 case BCM4356_CHIP_ID:
\r
717 if (chiprev == BCM4356A2_CHIP_REV)
\r
718 strcpy(&conf_path[i+1], BCM4356A2_CONF_NAME);
\r
723 printf("%s: config_path=%s\n", __FUNCTION__, conf_path);
\r
728 dhd_conf_set_fw_int_cmd(dhd_pub_t *dhd, char *name, uint cmd, int val,
\r
729 int def, bool down)
\r
735 if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_DOWN, NULL, 0, TRUE, 0)) < 0)
\r
736 CONFIG_ERROR(("%s: WLC_DOWN setting failed %d\n", __FUNCTION__, bcmerror));
\r
738 printf("%s: set %s %d %d\n", __FUNCTION__, name, cmd, val);
\r
739 if ((bcmerror = dhd_wl_ioctl_cmd(dhd, cmd, &val, sizeof(val), TRUE, 0)) < 0)
\r
740 CONFIG_ERROR(("%s: %s setting failed %d\n", __FUNCTION__, name, bcmerror));
\r
746 dhd_conf_set_fw_int_struct_cmd(dhd_pub_t *dhd, char *name, uint cmd,
\r
747 int *val, int len, bool down)
\r
752 if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_DOWN, NULL, 0, TRUE, 0)) < 0)
\r
753 CONFIG_ERROR(("%s: WLC_DOWN setting failed %d\n", __FUNCTION__, bcmerror));
\r
755 if ((bcmerror = dhd_wl_ioctl_cmd(dhd, cmd, val, len, TRUE, 0)) < 0)
\r
756 CONFIG_ERROR(("%s: %s setting failed %d\n", __FUNCTION__, name, bcmerror));
\r
762 dhd_conf_set_fw_string_cmd(dhd_pub_t *dhd, char *cmd, int val, int def,
\r
766 char iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" + '\0' + bitvec */
\r
770 if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_DOWN, NULL, 0, TRUE, 0)) < 0)
\r
771 CONFIG_ERROR(("%s: WLC_DOWN setting failed %d\n", __FUNCTION__, bcmerror));
\r
773 printf("%s: set %s %d\n", __FUNCTION__, cmd, val);
\r
774 bcm_mkiovar(cmd, (char *)&val, 4, iovbuf, sizeof(iovbuf));
\r
775 if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0)) < 0)
\r
776 CONFIG_ERROR(("%s: %s setting failed %d\n", __FUNCTION__, cmd, bcmerror));
\r
782 dhd_conf_set_fw_string_struct_cmd(dhd_pub_t *dhd, char *cmd, char *val,
\r
783 int len, bool down)
\r
786 char iovbuf[WLC_IOCTL_SMLEN];
\r
789 if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_DOWN, NULL, 0, TRUE, 0)) < 0)
\r
790 CONFIG_ERROR(("%s: WLC_DOWN setting failed %d\n", __FUNCTION__, bcmerror));
\r
792 printf("%s: set %s\n", __FUNCTION__, cmd);
\r
793 bcm_mkiovar(cmd, val, len, iovbuf, sizeof(iovbuf));
\r
794 if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_SET_VAR, iovbuf, sizeof(iovbuf), TRUE, 0)) < 0)
\r
795 CONFIG_ERROR(("%s: %s setting failed %d\n", __FUNCTION__, cmd, bcmerror));
\r
801 dhd_conf_get_band(dhd_pub_t *dhd)
\r
803 uint band = WLC_BAND_AUTO;
\r
805 if (dhd && dhd->conf)
\r
806 band = dhd->conf->band;
\r
808 CONFIG_ERROR(("%s: dhd or conf is NULL\n", __FUNCTION__));
\r
814 dhd_conf_set_country(dhd_pub_t *dhd)
\r
818 memset(&dhd->dhd_cspec, 0, sizeof(wl_country_t));
\r
819 printf("%s: set country %s, revision %d\n", __FUNCTION__,
\r
820 dhd->conf->cspec.ccode, dhd->conf->cspec.rev);
\r
821 dhd_conf_set_fw_string_struct_cmd(dhd, "country", (char *)&dhd->conf->cspec, sizeof(wl_country_t), FALSE);
\r
827 dhd_conf_get_country(dhd_pub_t *dhd, wl_country_t *cspec)
\r
831 memset(cspec, 0, sizeof(wl_country_t));
\r
832 bcm_mkiovar("country", NULL, 0, (char*)cspec, sizeof(wl_country_t));
\r
833 if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, cspec, sizeof(wl_country_t), FALSE, 0)) < 0)
\r
834 CONFIG_ERROR(("%s: country code getting failed %d\n", __FUNCTION__, bcmerror));
\r
836 printf("Country code: %s (%s/%d)\n", cspec->country_abbrev, cspec->ccode, cspec->rev);
\r
842 dhd_conf_get_country_from_config(dhd_pub_t *dhd, wl_country_t *cspec)
\r
844 int bcmerror = -1, i;
\r
845 struct dhd_conf *conf = dhd->conf;
\r
847 for (i = 0; i < conf->country_list.count; i++) {
\r
848 if (strcmp(cspec->country_abbrev, conf->country_list.cspec[i].country_abbrev) == 0) {
\r
849 memcpy(cspec->ccode,
\r
850 conf->country_list.cspec[i].ccode, WLC_CNTRY_BUF_SZ);
\r
851 cspec->rev = conf->country_list.cspec[i].rev;
\r
852 printf("%s: %s/%d\n", __FUNCTION__, cspec->ccode, cspec->rev);
\r
861 dhd_conf_fix_country(dhd_pub_t *dhd)
\r
865 wl_uint32_list_t *list;
\r
866 u8 valid_chan_list[sizeof(u32)*(WL_NUMCHANNELS + 1)];
\r
868 if (!(dhd && dhd->conf)) {
\r
872 memset(valid_chan_list, 0, sizeof(valid_chan_list));
\r
873 list = (wl_uint32_list_t *)(void *) valid_chan_list;
874 list->count = htod32(WL_NUMCHANNELS);
875 if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_GET_VALID_CHANNELS, valid_chan_list, sizeof(valid_chan_list), FALSE, 0)) < 0) {
\r
876 CONFIG_ERROR(("%s: get channels failed with %d\n", __FUNCTION__, bcmerror));
\r
879 band = dhd_conf_get_band(dhd);
\r
881 if (bcmerror || ((band==WLC_BAND_AUTO || band==WLC_BAND_2G) &&
\r
882 dtoh32(list->count)<11)) {
\r
883 CONFIG_ERROR(("%s: bcmerror=%d, # of channels %d\n",
\r
884 __FUNCTION__, bcmerror, dtoh32(list->count)));
\r
885 if ((bcmerror = dhd_conf_set_country(dhd)) < 0) {
\r
886 strcpy(dhd->conf->cspec.country_abbrev, "US");
\r
887 dhd->conf->cspec.rev = 0;
\r
888 strcpy(dhd->conf->cspec.ccode, "US");
\r
889 dhd_conf_set_country(dhd);
\r
897 dhd_conf_match_channel(dhd_pub_t *dhd, uint32 channel)
\r
900 bool match = false;
\r
902 if (dhd && dhd->conf) {
\r
903 if (dhd->conf->channels.count == 0)
\r
905 for (i=0; i<dhd->conf->channels.count; i++) {
\r
906 if (channel == dhd->conf->channels.channel[i])
\r
911 CONFIG_ERROR(("%s: dhd or conf is NULL\n", __FUNCTION__));
\r
918 dhd_conf_set_roam(dhd_pub_t *dhd)
\r
921 struct dhd_conf *conf = dhd->conf;
\r
923 dhd_roam_disable = conf->roam_off;
\r
924 dhd_conf_set_fw_string_cmd(dhd, "roam_off", dhd->conf->roam_off, 0, FALSE);
\r
926 if (!conf->roam_off || !conf->roam_off_suspend) {
\r
927 printf("%s: set roam_trigger %d\n", __FUNCTION__, conf->roam_trigger[0]);
\r
928 dhd_conf_set_fw_int_struct_cmd(dhd, "WLC_SET_ROAM_TRIGGER", WLC_SET_ROAM_TRIGGER,
\r
929 conf->roam_trigger, sizeof(conf->roam_trigger), FALSE);
\r
931 printf("%s: set roam_scan_period %d\n", __FUNCTION__, conf->roam_scan_period[0]);
\r
932 dhd_conf_set_fw_int_struct_cmd(dhd, "WLC_SET_ROAM_SCAN_PERIOD", WLC_SET_ROAM_SCAN_PERIOD,
\r
933 conf->roam_scan_period, sizeof(conf->roam_scan_period), FALSE);
\r
935 printf("%s: set roam_delta %d\n", __FUNCTION__, conf->roam_delta[0]);
\r
936 dhd_conf_set_fw_int_struct_cmd(dhd, "WLC_SET_ROAM_DELTA", WLC_SET_ROAM_DELTA,
\r
937 conf->roam_delta, sizeof(conf->roam_delta), FALSE);
\r
939 dhd_conf_set_fw_string_cmd(dhd, "fullroamperiod", dhd->conf->fullroamperiod, 1, FALSE);
\r
946 dhd_conf_get_wme(dhd_pub_t *dhd, edcf_acparam_t *acp)
\r
949 char iovbuf[WLC_IOCTL_SMLEN];
\r
950 edcf_acparam_t *acparam;
\r
952 bzero(iovbuf, sizeof(iovbuf));
\r
955 * Get current acparams, using buf as an input buffer.
\r
956 * Return data is array of 4 ACs of wme params.
\r
958 bcm_mkiovar("wme_ac_sta", NULL, 0, iovbuf, sizeof(iovbuf));
\r
959 if ((bcmerror = dhd_wl_ioctl_cmd(dhd, WLC_GET_VAR, iovbuf, sizeof(iovbuf), FALSE, 0)) < 0) {
\r
960 CONFIG_ERROR(("%s: wme_ac_sta getting failed %d\n", __FUNCTION__, bcmerror));
\r
963 memcpy((char*)acp, iovbuf, sizeof(edcf_acparam_t)*AC_COUNT);
\r
965 acparam = &acp[AC_BK];
\r
966 CONFIG_TRACE(("%s: BK: aci %d aifsn %d ecwmin %d ecwmax %d size %d\n", __FUNCTION__,
\r
967 acparam->ACI, acparam->ACI&EDCF_AIFSN_MASK,
\r
968 acparam->ECW&EDCF_ECWMIN_MASK, (acparam->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT,
\r
969 (int)sizeof(acp)));
\r
970 acparam = &acp[AC_BE];
\r
971 CONFIG_TRACE(("%s: BE: aci %d aifsn %d ecwmin %d ecwmax %d size %d\n", __FUNCTION__,
\r
972 acparam->ACI, acparam->ACI&EDCF_AIFSN_MASK,
\r
973 acparam->ECW&EDCF_ECWMIN_MASK, (acparam->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT,
\r
974 (int)sizeof(acp)));
\r
975 acparam = &acp[AC_VI];
\r
976 CONFIG_TRACE(("%s: VI: aci %d aifsn %d ecwmin %d ecwmax %d size %d\n", __FUNCTION__,
\r
977 acparam->ACI, acparam->ACI&EDCF_AIFSN_MASK,
\r
978 acparam->ECW&EDCF_ECWMIN_MASK, (acparam->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT,
\r
979 (int)sizeof(acp)));
\r
980 acparam = &acp[AC_VO];
\r
981 CONFIG_TRACE(("%s: VO: aci %d aifsn %d ecwmin %d ecwmax %d size %d\n", __FUNCTION__,
\r
982 acparam->ACI, acparam->ACI&EDCF_AIFSN_MASK,
\r
983 acparam->ECW&EDCF_ECWMIN_MASK, (acparam->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT,
\r
984 (int)sizeof(acp)));
\r
990 dhd_conf_update_wme(dhd_pub_t *dhd, edcf_acparam_t *acparam_cur, int aci)
\r
992 int aifsn, ecwmin, ecwmax;
\r
993 edcf_acparam_t *acp;
\r
994 struct dhd_conf *conf = dhd->conf;
\r
996 /* Default value */
\r
997 aifsn = acparam_cur->ACI&EDCF_AIFSN_MASK;
\r
998 ecwmin = acparam_cur->ECW&EDCF_ECWMIN_MASK;
\r
999 ecwmax = (acparam_cur->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT;
\r
1001 /* Modified value */
\r
1002 if (conf->wme.aifsn[aci] > 0)
\r
1003 aifsn = conf->wme.aifsn[aci];
\r
1004 if (conf->wme.cwmin[aci] > 0)
\r
1005 ecwmin = conf->wme.cwmin[aci];
\r
1006 if (conf->wme.cwmax[aci] > 0)
\r
1007 ecwmax = conf->wme.cwmax[aci];
\r
1010 acp = acparam_cur;
\r
1011 acp->ACI = (acp->ACI & ~EDCF_AIFSN_MASK) | (aifsn & EDCF_AIFSN_MASK);
\r
1012 acp->ECW = ((ecwmax << EDCF_ECWMAX_SHIFT) & EDCF_ECWMAX_MASK) | (acp->ECW & EDCF_ECWMIN_MASK);
\r
1013 acp->ECW = ((acp->ECW & EDCF_ECWMAX_MASK) | (ecwmin & EDCF_ECWMIN_MASK));
\r
1015 CONFIG_TRACE(("%s: mod aci %d aifsn %d ecwmin %d ecwmax %d size %d\n", __FUNCTION__,
\r
1016 acp->ACI, acp->ACI&EDCF_AIFSN_MASK,
\r
1017 acp->ECW&EDCF_ECWMIN_MASK, (acp->ECW&EDCF_ECWMAX_MASK)>>EDCF_ECWMAX_SHIFT,
\r
1018 (int)sizeof(edcf_acparam_t)));
\r
1021 * Now use buf as an output buffer.
\r
1022 * Put WME acparams after "wme_ac\0" in buf.
\r
1023 * NOTE: only one of the four ACs can be set at a time.
\r
1025 dhd_conf_set_fw_string_struct_cmd(dhd, "wme_ac_sta", (char *)acp, sizeof(edcf_acparam_t), FALSE);
\r
1030 dhd_conf_set_wme(dhd_pub_t *dhd)
\r
1032 edcf_acparam_t acparam_cur[AC_COUNT];
\r
1034 if (dhd && dhd->conf) {
\r
1035 if (!dhd->conf->force_wme_ac) {
\r
1036 CONFIG_TRACE(("%s: force_wme_ac is not enabled %d\n",
\r
1037 __FUNCTION__, dhd->conf->force_wme_ac));
\r
1041 CONFIG_TRACE(("%s: Before change:\n", __FUNCTION__));
\r
1042 dhd_conf_get_wme(dhd, acparam_cur);
\r
1044 dhd_conf_update_wme(dhd, &acparam_cur[AC_BK], AC_BK);
\r
1045 dhd_conf_update_wme(dhd, &acparam_cur[AC_BE], AC_BE);
\r
1046 dhd_conf_update_wme(dhd, &acparam_cur[AC_VI], AC_VI);
\r
1047 dhd_conf_update_wme(dhd, &acparam_cur[AC_VO], AC_VO);
\r
1049 CONFIG_TRACE(("%s: After change:\n", __FUNCTION__));
\r
1050 dhd_conf_get_wme(dhd, acparam_cur);
\r
1052 CONFIG_ERROR(("%s: dhd or conf is NULL\n", __FUNCTION__));
\r
1058 #ifdef PKT_FILTER_SUPPORT
\r
1060 dhd_conf_add_pkt_filter(dhd_pub_t *dhd)
\r
1064 #define MACS "%02x%02x%02x%02x%02x%02x"
\r
1067 * All pkt: pkt_filter_add=99 0 0 0 0x000000000000 0x000000000000
\r
1068 * Netbios pkt: 120 0 0 12 0xFFFF000000000000000000FF000000000000000000000000FFFF 0x0800000000000000000000110000000000000000000000000089
\r
1070 for(i=0; i<dhd->conf->pkt_filter_add.count; i++) {
\r
1071 dhd->pktfilter[i+dhd->pktfilter_count] = dhd->conf->pkt_filter_add.filter[i];
\r
1072 printf("%s: %s\n", __FUNCTION__, dhd->pktfilter[i+dhd->pktfilter_count]);
\r
1074 dhd->pktfilter_count += i;
\r
1076 if (dhd->conf->pkt_filter_magic) {
\r
1077 strcpy(&dhd->conf->pkt_filter_add.filter[dhd->conf->pkt_filter_add.count][0], "256 0 1 0 0x");
\r
1078 for (i=0; i<16; i++)
\r
1079 strcat(&dhd->conf->pkt_filter_add.filter[dhd->conf->pkt_filter_add.count][0], "FFFFFFFFFFFF");
\r
1080 strcat(&dhd->conf->pkt_filter_add.filter[dhd->conf->pkt_filter_add.count][0], " 0x");
\r
1081 sprintf(str, MACS, MAC2STRDBG(dhd->mac.octet));
\r
1082 for (i=0; i<16; i++)
\r
1083 strcat(&dhd->conf->pkt_filter_add.filter[dhd->conf->pkt_filter_add.count][0], str);
\r
1084 dhd->pktfilter[dhd->pktfilter_count] = dhd->conf->pkt_filter_add.filter[dhd->conf->pkt_filter_add.count];
\r
1085 dhd->pktfilter_count += 1;
\r
1090 dhd_conf_del_pkt_filter(dhd_pub_t *dhd, uint32 id)
\r
1094 if (dhd && dhd->conf) {
\r
1095 for (i=0; i<dhd->conf->pkt_filter_del.count; i++) {
\r
1096 if (id == dhd->conf->pkt_filter_del.id[i]) {
\r
1097 printf("%s: %d\n", __FUNCTION__, dhd->conf->pkt_filter_del.id[i]);
\r
1107 dhd_conf_discard_pkt_filter(dhd_pub_t *dhd)
\r
1109 dhd->pktfilter_count = 6;
\r
1110 dhd->pktfilter[DHD_UNICAST_FILTER_NUM] = NULL;
\r
1111 dhd->pktfilter[DHD_BROADCAST_FILTER_NUM] = "101 0 0 0 0xFFFFFFFFFFFF 0xFFFFFFFFFFFF";
\r
1112 dhd->pktfilter[DHD_MULTICAST4_FILTER_NUM] = "102 0 0 0 0xFFFFFF 0x01005E";
\r
1113 dhd->pktfilter[DHD_MULTICAST6_FILTER_NUM] = "103 0 0 0 0xFFFF 0x3333";
\r
1114 dhd->pktfilter[DHD_MDNS_FILTER_NUM] = NULL;
\r
1115 /* Do not enable ARP to pkt filter if dhd_master_mode is false.*/
\r
1116 dhd->pktfilter[DHD_ARP_FILTER_NUM] = NULL;
\r
1118 /* IPv4 broadcast address XXX.XXX.XXX.255 */
\r
1119 dhd->pktfilter[dhd->pktfilter_count] = "110 0 0 12 0xFFFF00000000000000000000000000000000000000FF 0x080000000000000000000000000000000000000000FF";
\r
1120 dhd->pktfilter_count++;
\r
1121 /* discard IPv4 multicast address 224.0.0.0/4 */
\r
1122 dhd->pktfilter[dhd->pktfilter_count] = "111 0 0 12 0xFFFF00000000000000000000000000000000F0 0x080000000000000000000000000000000000E0";
\r
1123 dhd->pktfilter_count++;
\r
1124 /* discard IPv6 multicast address FF00::/8 */
\r
1125 dhd->pktfilter[dhd->pktfilter_count] = "112 0 0 12 0xFFFF000000000000000000000000000000000000000000000000FF 0x86DD000000000000000000000000000000000000000000000000FF";
\r
1126 dhd->pktfilter_count++;
\r
1127 /* discard Netbios pkt */
\r
1128 dhd->pktfilter[dhd->pktfilter_count] = "120 0 0 12 0xFFFF000000000000000000FF000000000000000000000000FFFF 0x0800000000000000000000110000000000000000000000000089";
\r
1129 dhd->pktfilter_count++;
\r
1132 #endif /* PKT_FILTER_SUPPORT */
\r
1135 dhd_conf_set_disable_proptx(dhd_pub_t *dhd)
\r
1137 printf("%s: set disable_proptx %d\n", __FUNCTION__, dhd->conf->disable_proptx);
\r
1138 disable_proptx = dhd->conf->disable_proptx;
\r
1142 dhd_conf_get_pm(dhd_pub_t *dhd)
\r
1144 if (dhd && dhd->conf)
\r
1145 return dhd->conf->pm;
\r
1150 dhd_conf_get_tcpack_sup_mode(dhd_pub_t *dhd)
\r
1152 if (dhd && dhd->conf)
\r
1153 return dhd->conf->tcpack_sup_mode;
\r
1158 process_config_vars(char *varbuf, unsigned int len, char *pickbuf, char *param)
\r
1160 bool findNewline, changenewline=FALSE, pick=FALSE;
\r
1162 unsigned int n, pick_column=0;
\r
1164 findNewline = FALSE;
\r
1167 for (n = 0; n < len; n++) {
\r
1168 if (varbuf[n] == '\r')
\r
1170 if ((findNewline || changenewline) && varbuf[n] != '\n')
\r
1172 findNewline = FALSE;
\r
1173 if (varbuf[n] == '#') {
\r
1174 findNewline = TRUE;
\r
1177 if (varbuf[n] == '\\') {
\r
1178 changenewline = TRUE;
\r
1181 if (!changenewline && varbuf[n] == '\n') {
\r
1187 if (changenewline && varbuf[n] == '\n') {
\r
1188 changenewline = FALSE;
\r
1191 if (!memcmp(&varbuf[n], param, strlen(param)) && column==0) {
\r
1193 column = strlen(param);
\r
1197 if (pick && column==0)
\r
1203 if (varbuf[n] == 0x9)
\r
1205 if (pick_column>0 && pickbuf[pick_column-1]==' ' && varbuf[n]==' ')
\r
1207 pickbuf[pick_column] = varbuf[n];
\r
1212 return pick_column;
\r
1216 dhd_conf_read_log_level(dhd_pub_t *dhd, char *bufp, uint len)
\r
1221 pick = MALLOC(dhd->osh, MAXSZ_BUF);
\r
1223 CONFIG_ERROR(("%s: Failed to allocate memory %d bytes\n",
\r
1224 __FUNCTION__, MAXSZ_BUF));
\r
1228 /* Process dhd_msglevel */
\r
1229 memset(pick, 0, MAXSZ_BUF);
\r
1230 len_val = process_config_vars(bufp, len, pick, "msglevel=");
\r
1232 dhd_msg_level = (int)simple_strtol(pick, NULL, 0);
\r
1233 printf("%s: dhd_msg_level = 0x%X\n", __FUNCTION__, dhd_msg_level);
\r
1236 /* Process sd_msglevel */
\r
1237 memset(pick, 0, MAXSZ_BUF);
\r
1238 len_val = process_config_vars(bufp, len, pick, "sd_msglevel=");
\r
1240 sd_msglevel = (int)simple_strtol(pick, NULL, 0);
\r
1241 printf("%s: sd_msglevel = 0x%X\n", __FUNCTION__, sd_msglevel);
\r
1244 /* Process android_msg_level */
\r
1245 memset(pick, 0, MAXSZ_BUF);
\r
1246 len_val = process_config_vars(bufp, len, pick, "android_msg_level=");
\r
1248 android_msg_level = (int)simple_strtol(pick, NULL, 0);
\r
1249 printf("%s: android_msg_level = 0x%X\n", __FUNCTION__, android_msg_level);
\r
1251 /* Process config_msg_level */
\r
1252 memset(pick, 0, MAXSZ_BUF);
\r
1253 len_val = process_config_vars(bufp, len, pick, "config_msg_level=");
\r
1255 config_msg_level = (int)simple_strtol(pick, NULL, 0);
\r
1256 printf("%s: config_msg_level = 0x%X\n", __FUNCTION__, config_msg_level);
\r
1258 #ifdef WL_CFG80211
\r
1259 /* Process wl_dbg_level */
\r
1260 memset(pick, 0, MAXSZ_BUF);
\r
1261 len_val = process_config_vars(bufp, len, pick, "wl_dbg_level=");
\r
1263 wl_dbg_level = (int)simple_strtol(pick, NULL, 0);
\r
1264 printf("%s: wl_dbg_level = 0x%X\n", __FUNCTION__, wl_dbg_level);
\r
1267 #if defined(WL_WIRELESS_EXT)
\r
1268 /* Process iw_msg_level */
\r
1269 memset(pick, 0, MAXSZ_BUF);
\r
1270 len_val = process_config_vars(bufp, len, pick, "iw_msg_level=");
\r
1272 iw_msg_level = (int)simple_strtol(pick, NULL, 0);
\r
1273 printf("%s: iw_msg_level = 0x%X\n", __FUNCTION__, iw_msg_level);
\r
1277 #if defined(DHD_DEBUG)
\r
1278 /* Process dhd_console_ms */
\r
1279 memset(pick, 0, MAXSZ_BUF);
\r
1280 len_val = process_config_vars(bufp, len, pick, "dhd_console_ms=");
\r
1282 dhd_console_ms = (int)simple_strtol(pick, NULL, 0);
\r
1283 printf("%s: dhd_console_ms = 0x%X\n", __FUNCTION__, dhd_console_ms);
\r
1288 MFREE(dhd->osh, pick, MAXSZ_BUF);
\r
1292 dhd_conf_read_wme_ac_params(dhd_pub_t *dhd, char *bufp, uint len)
\r
1296 struct dhd_conf *conf = dhd->conf;
\r
1298 pick = MALLOC(dhd->osh, MAXSZ_BUF);
\r
1300 CONFIG_ERROR(("%s: Failed to allocate memory %d bytes\n",
\r
1301 __FUNCTION__, MAXSZ_BUF));
\r
1305 /* Process WMM parameters */
\r
1306 memset(pick, 0, MAXSZ_BUF);
\r
1307 len_val = process_config_vars(bufp, len, pick, "force_wme_ac=");
\r
1309 conf->force_wme_ac = (int)simple_strtol(pick, NULL, 10);
\r
1310 printf("%s: force_wme_ac = %d\n", __FUNCTION__, conf->force_wme_ac);
\r
1313 if (conf->force_wme_ac) {
\r
1314 memset(pick, 0, MAXSZ_BUF);
\r
1315 len_val = process_config_vars(bufp, len, pick, "bk_aifsn=");
\r
1317 conf->wme.aifsn[AC_BK] = (int)simple_strtol(pick, NULL, 10);
\r
1318 printf("%s: AC_BK aifsn = %d\n", __FUNCTION__, conf->wme.aifsn[AC_BK]);
\r
1321 memset(pick, 0, MAXSZ_BUF);
\r
1322 len_val = process_config_vars(bufp, len, pick, "bk_cwmin=");
\r
1324 conf->wme.cwmin[AC_BK] = (int)simple_strtol(pick, NULL, 10);
\r
1325 printf("%s: AC_BK cwmin = %d\n", __FUNCTION__, conf->wme.cwmin[AC_BK]);
\r
1328 memset(pick, 0, MAXSZ_BUF);
\r
1329 len_val = process_config_vars(bufp, len, pick, "bk_cwmax=");
\r
1331 conf->wme.cwmax[AC_BK] = (int)simple_strtol(pick, NULL, 10);
\r
1332 printf("%s: AC_BK cwmax = %d\n", __FUNCTION__, conf->wme.cwmax[AC_BK]);
\r
1335 memset(pick, 0, MAXSZ_BUF);
\r
1336 len_val = process_config_vars(bufp, len, pick, "be_aifsn=");
\r
1338 conf->wme.aifsn[AC_BE] = (int)simple_strtol(pick, NULL, 10);
\r
1339 printf("%s: AC_BE aifsn = %d\n", __FUNCTION__, conf->wme.aifsn[AC_BE]);
\r
1342 memset(pick, 0, MAXSZ_BUF);
\r
1343 len_val = process_config_vars(bufp, len, pick, "be_cwmin=");
\r
1345 conf->wme.cwmin[AC_BE] = (int)simple_strtol(pick, NULL, 10);
\r
1346 printf("%s: AC_BE cwmin = %d\n", __FUNCTION__, conf->wme.cwmin[AC_BE]);
\r
1349 memset(pick, 0, MAXSZ_BUF);
\r
1350 len_val = process_config_vars(bufp, len, pick, "be_cwmax=");
\r
1352 conf->wme.cwmax[AC_BE] = (int)simple_strtol(pick, NULL, 10);
\r
1353 printf("%s: AC_BE cwmax = %d\n", __FUNCTION__, conf->wme.cwmax[AC_BE]);
\r
1356 memset(pick, 0, MAXSZ_BUF);
\r
1357 len_val = process_config_vars(bufp, len, pick, "vi_aifsn=");
\r
1359 conf->wme.aifsn[AC_VI] = (int)simple_strtol(pick, NULL, 10);
\r
1360 printf("%s: AC_VI aifsn = %d\n", __FUNCTION__, conf->wme.aifsn[AC_VI]);
\r
1363 memset(pick, 0, MAXSZ_BUF);
\r
1364 len_val = process_config_vars(bufp, len, pick, "vi_cwmin=");
\r
1366 conf->wme.cwmin[AC_VI] = (int)simple_strtol(pick, NULL, 10);
\r
1367 printf("%s: AC_VI cwmin = %d\n", __FUNCTION__, conf->wme.cwmin[AC_VI]);
\r
1370 memset(pick, 0, MAXSZ_BUF);
\r
1371 len_val = process_config_vars(bufp, len, pick, "vi_cwmax=");
\r
1373 conf->wme.cwmax[AC_VI] = (int)simple_strtol(pick, NULL, 10);
\r
1374 printf("%s: AC_VI cwmax = %d\n", __FUNCTION__, conf->wme.cwmax[AC_VI]);
\r
1377 memset(pick, 0, MAXSZ_BUF);
\r
1378 len_val = process_config_vars(bufp, len, pick, "vo_aifsn=");
\r
1380 conf->wme.aifsn[AC_VO] = (int)simple_strtol(pick, NULL, 10);
\r
1381 printf("%s: AC_VO aifsn = %d\n", __FUNCTION__, conf->wme.aifsn[AC_VO]);
\r
1384 memset(pick, 0, MAXSZ_BUF);
\r
1385 len_val = process_config_vars(bufp, len, pick, "vo_cwmin=");
\r
1387 conf->wme.cwmin[AC_VO] = (int)simple_strtol(pick, NULL, 10);
\r
1388 printf("%s: AC_VO cwmin = %d\n", __FUNCTION__, conf->wme.cwmin[AC_VO]);
\r
1391 memset(pick, 0, MAXSZ_BUF);
\r
1392 len_val = process_config_vars(bufp, len, pick, "vo_cwmax=");
\r
1394 conf->wme.cwmax[AC_VO] = (int)simple_strtol(pick, NULL, 10);
\r
1395 printf("%s: AC_VO cwmax = %d\n", __FUNCTION__, conf->wme.cwmax[AC_VO]);
\r
1400 MFREE(dhd->osh, pick, MAXSZ_BUF);
\r
1405 dhd_conf_read_fw_by_mac(dhd_pub_t *dhd, char *bufp, uint len)
\r
1410 char *pch, *pick_tmp;
\r
1411 wl_mac_list_t *mac_list;
\r
1412 wl_mac_range_t *mac_range;
\r
1413 struct dhd_conf *conf = dhd->conf;
\r
1415 pick = MALLOC(dhd->osh, MAXSZ_BUF);
\r
1417 CONFIG_ERROR(("%s: Failed to allocate memory %d bytes\n",
\r
1418 __FUNCTION__, MAXSZ_BUF));
\r
1422 /* Process fw_by_mac:
\r
1423 * fw_by_mac=[fw_mac_num] \
\r
1424 * [fw_name1] [mac_num1] [oui1-1] [nic_start1-1] [nic_end1-1] \
\r
1425 * [oui1-1] [nic_start1-1] [nic_end1-1]... \
\r
1426 * [oui1-n] [nic_start1-n] [nic_end1-n] \
\r
1427 * [fw_name2] [mac_num2] [oui2-1] [nic_start2-1] [nic_end2-1] \
\r
1428 * [oui2-1] [nic_start2-1] [nic_end2-1]... \
\r
1429 * [oui2-n] [nic_start2-n] [nic_end2-n] \
\r
1430 * Ex: fw_by_mac=2 \
\r
1431 * fw_bcmdhd1.bin 2 0x0022F4 0xE85408 0xE8549D 0x983B16 0x3557A9 0x35582A \
\r
1432 * fw_bcmdhd2.bin 3 0x0022F4 0xE85408 0xE8549D 0x983B16 0x3557A9 0x35582A \
\r
1433 * 0x983B16 0x916157 0x916487
\r
1435 memset(pick, 0, MAXSZ_BUF);
\r
1436 len_val = process_config_vars(bufp, len, pick, "fw_by_mac=");
\r
1439 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1440 conf->fw_by_mac.count = (uint32)simple_strtol(pch, NULL, 0);
\r
1441 if (!(mac_list = kmalloc(sizeof(wl_mac_list_t)*conf->fw_by_mac.count, GFP_KERNEL))) {
\r
1442 conf->fw_by_mac.count = 0;
\r
1443 CONFIG_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
\r
1445 printf("%s: fw_count=%d\n", __FUNCTION__, conf->fw_by_mac.count);
\r
1446 conf->fw_by_mac.m_mac_list_head = mac_list;
\r
1447 for (i=0; i<conf->fw_by_mac.count; i++) {
\r
1448 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1449 strcpy(mac_list[i].name, pch);
\r
1450 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1451 mac_list[i].count = (uint32)simple_strtol(pch, NULL, 0);
\r
1452 printf("%s: name=%s, mac_count=%d\n", __FUNCTION__,
\r
1453 mac_list[i].name, mac_list[i].count);
\r
1454 if (!(mac_range = kmalloc(sizeof(wl_mac_range_t)*mac_list[i].count, GFP_KERNEL))) {
\r
1455 mac_list[i].count = 0;
\r
1456 CONFIG_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
\r
1459 mac_list[i].mac = mac_range;
\r
1460 for (j=0; j<mac_list[i].count; j++) {
\r
1461 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1462 mac_range[j].oui = (uint32)simple_strtol(pch, NULL, 0);
\r
1463 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1464 mac_range[j].nic_start = (uint32)simple_strtol(pch, NULL, 0);
\r
1465 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1466 mac_range[j].nic_end = (uint32)simple_strtol(pch, NULL, 0);
\r
1467 printf("%s: oui=0x%06X, nic_start=0x%06X, nic_end=0x%06X\n",
\r
1468 __FUNCTION__, mac_range[j].oui,
\r
1469 mac_range[j].nic_start, mac_range[j].nic_end);
\r
1475 MFREE(dhd->osh, pick, MAXSZ_BUF);
\r
1479 dhd_conf_read_nv_by_mac(dhd_pub_t *dhd, char *bufp, uint len)
\r
1484 char *pch, *pick_tmp;
\r
1485 wl_mac_list_t *mac_list;
\r
1486 wl_mac_range_t *mac_range;
\r
1487 struct dhd_conf *conf = dhd->conf;
\r
1489 pick = MALLOC(dhd->osh, MAXSZ_BUF);
\r
1491 CONFIG_ERROR(("%s: Failed to allocate memory %d bytes\n",
\r
1492 __FUNCTION__, MAXSZ_BUF));
\r
1496 /* Process nv_by_mac:
\r
1497 * [nv_by_mac]: The same format as fw_by_mac
\r
1499 memset(pick, 0, MAXSZ_BUF);
\r
1500 len_val = process_config_vars(bufp, len, pick, "nv_by_mac=");
\r
1503 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1504 conf->nv_by_mac.count = (uint32)simple_strtol(pch, NULL, 0);
\r
1505 if (!(mac_list = kmalloc(sizeof(wl_mac_list_t)*conf->nv_by_mac.count, GFP_KERNEL))) {
\r
1506 conf->nv_by_mac.count = 0;
\r
1507 CONFIG_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
\r
1509 printf("%s: nv_count=%d\n", __FUNCTION__, conf->nv_by_mac.count);
\r
1510 conf->nv_by_mac.m_mac_list_head = mac_list;
\r
1511 for (i=0; i<conf->nv_by_mac.count; i++) {
\r
1512 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1513 strcpy(mac_list[i].name, pch);
\r
1514 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1515 mac_list[i].count = (uint32)simple_strtol(pch, NULL, 0);
\r
1516 printf("%s: name=%s, mac_count=%d\n", __FUNCTION__,
\r
1517 mac_list[i].name, mac_list[i].count);
\r
1518 if (!(mac_range = kmalloc(sizeof(wl_mac_range_t)*mac_list[i].count, GFP_KERNEL))) {
\r
1519 mac_list[i].count = 0;
\r
1520 CONFIG_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
\r
1523 mac_list[i].mac = mac_range;
\r
1524 for (j=0; j<mac_list[i].count; j++) {
\r
1525 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1526 mac_range[j].oui = (uint32)simple_strtol(pch, NULL, 0);
\r
1527 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1528 mac_range[j].nic_start = (uint32)simple_strtol(pch, NULL, 0);
\r
1529 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1530 mac_range[j].nic_end = (uint32)simple_strtol(pch, NULL, 0);
\r
1531 printf("%s: oui=0x%06X, nic_start=0x%06X, nic_end=0x%06X\n",
\r
1532 __FUNCTION__, mac_range[j].oui,
\r
1533 mac_range[j].nic_start, mac_range[j].nic_end);
\r
1539 MFREE(dhd->osh, pick, MAXSZ_BUF);
\r
1543 dhd_conf_read_nv_by_chip(dhd_pub_t *dhd, char *bufp, uint len)
\r
1548 char *pch, *pick_tmp;
\r
1549 wl_chip_nv_path_t *chip_nv_path;
\r
1550 struct dhd_conf *conf = dhd->conf;
\r
1552 pick = MALLOC(dhd->osh, MAXSZ_BUF);
\r
1554 CONFIG_ERROR(("%s: Failed to allocate memory %d bytes\n",
\r
1555 __FUNCTION__, MAXSZ_BUF));
\r
1559 /* Process nv_by_chip:
\r
1560 * nv_by_chip=[nv_chip_num] \
\r
1561 * [chip1] [chiprev1] [nv_name1] [chip2] [chiprev2] [nv_name2] \
\r
1562 * Ex: nv_by_chip=2 \
\r
1563 * 43430 0 nvram_ap6212.txt 43430 1 nvram_ap6212a.txt \
\r
1565 memset(pick, 0, MAXSZ_BUF);
\r
1566 len_val = process_config_vars(bufp, len, pick, "nv_by_chip=");
\r
1569 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1570 conf->nv_by_chip.count = (uint32)simple_strtol(pch, NULL, 0);
\r
1571 if (!(chip_nv_path = kmalloc(sizeof(wl_mac_list_t)*conf->nv_by_chip.count, GFP_KERNEL))) {
\r
1572 conf->nv_by_chip.count = 0;
\r
1573 CONFIG_ERROR(("%s: kmalloc failed\n", __FUNCTION__));
\r
1575 printf("%s: nv_by_chip_count=%d\n", __FUNCTION__, conf->nv_by_chip.count);
\r
1576 conf->nv_by_chip.m_chip_nv_path_head = chip_nv_path;
\r
1577 for (i=0; i<conf->nv_by_chip.count; i++) {
\r
1578 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1579 chip_nv_path[i].chip = (uint32)simple_strtol(pch, NULL, 0);
\r
1580 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1581 chip_nv_path[i].chiprev = (uint32)simple_strtol(pch, NULL, 0);
\r
1582 pch = bcmstrtok(&pick_tmp, " ", 0);
\r
1583 strcpy(chip_nv_path[i].name, pch);
\r
1584 printf("%s: chip=0x%x, chiprev=%d, name=%s\n", __FUNCTION__,
\r
1585 chip_nv_path[i].chip, chip_nv_path[i].chiprev, chip_nv_path[i].name);
\r
1590 MFREE(dhd->osh, pick, MAXSZ_BUF);
\r
1594 dhd_conf_read_roam_params(dhd_pub_t *dhd, char *bufp, uint len)
\r
1598 struct dhd_conf *conf = dhd->conf;
\r
1600 pick = MALLOC(dhd->osh, MAXSZ_BUF);
\r
1602 CONFIG_ERROR(("%s: Failed to allocate memory %d bytes\n",
\r
1603 __FUNCTION__, MAXSZ_BUF));
\r
1607 /* Process roam */
\r
1608 memset(pick, 0, MAXSZ_BUF);
\r
1609 len_val = process_config_vars(bufp, len, pick, "roam_off=");
\r
1611 if (!strncmp(pick, "0", len_val))
\r
1612 conf->roam_off = 0;
\r
1614 conf->roam_off = 1;
\r
1615 printf("%s: roam_off = %d\n", __FUNCTION__, conf->roam_off);
\r
1618 memset(pick, 0, MAXSZ_BUF);
\r
1619 len_val = process_config_vars(bufp, len, pick, "roam_off_suspend=");
\r
1621 if (!strncmp(pick, "0", len_val))
\r
1622 conf->roam_off_suspend = 0;
\r
1624 conf->roam_off_suspend = 1;
\r
1625 printf("%s: roam_off_suspend = %d\n", __FUNCTION__,
\r
1626 conf->roam_off_suspend);
\r
1629 if (!conf->roam_off || !conf->roam_off_suspend) {
\r
1630 memset(pick, 0, MAXSZ_BUF);
\r
1631 len_val = process_config_vars(bufp, len, pick, "roam_trigger=");
\r
1633 conf->roam_trigger[0] = (int)simple_strtol(pick, NULL, 10);
\r
1634 printf("%s: roam_trigger = %d\n", __FUNCTION__,
\r
1635 conf->roam_trigger[0]);
\r
1637 memset(pick, 0, MAXSZ_BUF);
\r
1638 len_val = process_config_vars(bufp, len, pick, "roam_scan_period=");
\r
1640 conf->roam_scan_period[0] = (int)simple_strtol(pick, NULL, 10);
\r
1641 printf("%s: roam_scan_period = %d\n", __FUNCTION__,
\r
1642 conf->roam_scan_period[0]);
\r
1644 memset(pick, 0, MAXSZ_BUF);
\r
1645 len_val = process_config_vars(bufp, len, pick, "roam_delta=");
\r
1647 conf->roam_delta[0] = (int)simple_strtol(pick, NULL, 10);
\r
1648 printf("%s: roam_delta = %d\n", __FUNCTION__, conf->roam_delta[0]);
\r
1650 memset(pick, 0, MAXSZ_BUF);
\r
1651 len_val = process_config_vars(bufp, len, pick, "fullroamperiod=");
\r
1653 conf->fullroamperiod = (int)simple_strtol(pick, NULL, 10);
\r
1654 printf("%s: fullroamperiod = %d\n", __FUNCTION__,
\r
1655 conf->fullroamperiod);
\r
1659 MFREE(dhd->osh, pick, MAXSZ_BUF);
\r
1664 dhd_conf_read_country_list(dhd_pub_t *dhd, char *bufp, uint len)
\r
1668 char *pick, *pch, *pick_tmp;
\r
1669 struct dhd_conf *conf = dhd->conf;
\r
1671 pick = MALLOC(dhd->osh, MAXSZ_BUF);
\r
1673 CONFIG_ERROR(("%s: Failed to allocate memory %d bytes\n",
\r
1674 __FUNCTION__, MAXSZ_BUF));
\r
1678 /* Process country_list:
\r
1679 * country_list=[country1]:[ccode1]/[regrev1],
\r
1680 * [country2]:[ccode2]/[regrev2] \
\r
1681 * Ex: country_list=US:US/0, TW:TW/1
\r
1683 memset(pick, 0, MAXSZ_BUF);
\r
1684 len_val = process_config_vars(bufp, len, pick, "country_list=");
\r
1687 for (i=0; i<CONFIG_COUNTRY_LIST_SIZE; i++) {
\r
1688 /* Process country code */
\r
1689 pch = bcmstrtok(&pick_tmp, ":", 0);
\r
1692 strcpy(conf->country_list.cspec[i].country_abbrev, pch);
\r
1693 pch = bcmstrtok(&pick_tmp, "/", 0);
\r
1696 memcpy(conf->country_list.cspec[i].ccode, pch, 2);
\r
1697 pch = bcmstrtok(&pick_tmp, ", ", 0);
\r
1700 conf->country_list.cspec[i].rev = (int32)simple_strtol(pch, NULL, 10);
\r
1701 conf->country_list.count ++;
\r
1702 CONFIG_TRACE(("%s: country_list abbrev=%s, ccode=%s, regrev=%d\n", __FUNCTION__,
\r
1703 conf->country_list.cspec[i].country_abbrev,
\r
1704 conf->country_list.cspec[i].ccode,
\r
1705 conf->country_list.cspec[i].rev));
\r
1707 printf("%s: %d country in list\n", __FUNCTION__, conf->country_list.count);
\r
1711 MFREE(dhd->osh, pick, MAXSZ_BUF);
\r
1715 dhd_conf_read_config(dhd_pub_t *dhd, char *conf_path)
\r
1717 int bcmerror = -1, i;
\r
1718 uint len, len_val;
\r
1719 void * image = NULL;
\r
1720 char * memblock = NULL;
\r
1721 char *bufp, *pick = NULL, *pch, *pick_tmp;
\r
1722 bool conf_file_exists;
\r
1723 struct dhd_conf *conf = dhd->conf;
\r
1725 conf_file_exists = ((conf_path != NULL) && (conf_path[0] != '\0'));
\r
1726 if (!conf_file_exists) {
\r
1727 printf("%s: config path %s\n", __FUNCTION__, conf_path);
\r
1731 if (conf_file_exists) {
\r
1732 image = dhd_os_open_image(conf_path);
\r
1733 if (image == NULL) {
\r
1734 printf("%s: Ignore config file %s\n", __FUNCTION__, conf_path);
\r
1739 memblock = MALLOC(dhd->osh, MAXSZ_CONFIG);
\r
1740 if (memblock == NULL) {
\r
1741 CONFIG_ERROR(("%s: Failed to allocate memory %d bytes\n",
\r
1742 __FUNCTION__, MAXSZ_CONFIG));
\r
1746 pick = MALLOC(dhd->osh, MAXSZ_BUF);
\r
1748 CONFIG_ERROR(("%s: Failed to allocate memory %d bytes\n",
\r
1749 __FUNCTION__, MAXSZ_BUF));
\r
1753 /* Read variables */
\r
1754 if (conf_file_exists) {
\r
1755 len = dhd_os_get_image_block(memblock, MAXSZ_CONFIG, image);
\r
1757 if (len > 0 && len < MAXSZ_CONFIG) {
\r
1758 bufp = (char *)memblock;
\r
1761 /* Process log_level */
\r
1762 dhd_conf_read_log_level(dhd, bufp, len);
\r
1763 dhd_conf_read_roam_params(dhd, bufp, len);
\r
1764 dhd_conf_read_wme_ac_params(dhd, bufp, len);
1765 dhd_conf_read_fw_by_mac(dhd, bufp, len);
\r
1766 dhd_conf_read_nv_by_mac(dhd, bufp, len);
\r
1767 dhd_conf_read_nv_by_chip(dhd, bufp, len);
\r
1768 dhd_conf_read_country_list(dhd, bufp, len);
\r
1771 * band=a for 5GHz only and band=b for 2.4GHz only
\r
1773 memset(pick, 0, MAXSZ_BUF);
\r
1774 len_val = process_config_vars(bufp, len, pick, "band=");
\r
1776 if (!strncmp(pick, "b", len_val))
\r
1777 conf->band = WLC_BAND_2G;
\r
1778 else if (!strncmp(pick, "a", len_val))
\r
1779 conf->band = WLC_BAND_5G;
\r
1781 conf->band = WLC_BAND_AUTO;
\r
1782 printf("%s: band = %d\n", __FUNCTION__, conf->band);
\r
1785 /* Process mimo_bw_cap */
\r
1786 memset(pick, 0, MAXSZ_BUF);
\r
1787 len_val = process_config_vars(bufp, len, pick, "mimo_bw_cap=");
\r
1789 conf->mimo_bw_cap = (uint)simple_strtol(pick, NULL, 10);
\r
1790 printf("%s: mimo_bw_cap = %d\n", __FUNCTION__, conf->mimo_bw_cap);
\r
1793 /* Process country code */
\r
1794 memset(pick, 0, MAXSZ_BUF);
\r
1795 len_val = process_config_vars(bufp, len, pick, "ccode=");
\r
1797 memset(&conf->cspec, 0, sizeof(wl_country_t));
\r
1798 memcpy(conf->cspec.country_abbrev, pick, len_val);
\r
1799 memcpy(conf->cspec.ccode, pick, len_val);
\r
1800 memset(pick, 0, MAXSZ_BUF);
\r
1801 len_val = process_config_vars(bufp, len, pick, "regrev=");
\r
1803 conf->cspec.rev = (int32)simple_strtol(pick, NULL, 10);
\r
1806 /* Process channels */
\r
1807 memset(pick, 0, MAXSZ_BUF);
\r
1808 len_val = process_config_vars(bufp, len, pick, "channels=");
\r
1811 pch = bcmstrtok(&pick_tmp, " ,.-", 0);
\r
1813 while (pch != NULL && i<WL_NUMCHANNELS) {
\r
1814 conf->channels.channel[i] = (uint32)simple_strtol(pch, NULL, 10);
\r
1815 pch = bcmstrtok(&pick_tmp, " ,.-", 0);
\r
1818 conf->channels.count = i;
\r
1819 printf("%s: channels = ", __FUNCTION__);
\r
1820 for (i=0; i<conf->channels.count; i++)
\r
1821 printf("%d ", conf->channels.channel[i]);
\r
1825 /* Process keep alive period */
\r
1826 memset(pick, 0, MAXSZ_BUF);
\r
1827 len_val = process_config_vars(bufp, len, pick, "keep_alive_period=");
\r
1829 conf->keep_alive_period = (uint)simple_strtol(pick, NULL, 10);
\r
1830 printf("%s: keep_alive_period = %d\n", __FUNCTION__,
\r
1831 conf->keep_alive_period);
\r
1834 /* Process STBC parameters */
\r
1835 memset(pick, 0, MAXSZ_BUF);
\r
1836 len_val = process_config_vars(bufp, len, pick, "stbc=");
\r
1838 conf->stbc = (int)simple_strtol(pick, NULL, 10);
\r
1839 printf("%s: stbc = %d\n", __FUNCTION__, conf->stbc);
\r
1842 /* Process phy_oclscdenable parameters */
\r
1843 memset(pick, 0, MAXSZ_BUF);
\r
1844 len_val = process_config_vars(bufp, len, pick, "phy_oclscdenable=");
\r
1846 conf->phy_oclscdenable = (int)simple_strtol(pick, NULL, 10);
\r
1847 printf("%s: phy_oclscdenable = %d\n", __FUNCTION__, conf->phy_oclscdenable);
\r
1851 /* Process dhd_doflow parameters */
\r
1852 memset(pick, 0, MAXSZ_BUF);
\r
1853 len_val = process_config_vars(bufp, len, pick, "dhd_doflow=");
\r
1855 if (!strncmp(pick, "0", len_val))
\r
1856 dhd_doflow = FALSE;
\r
1858 dhd_doflow = TRUE;
\r
1859 printf("%s: dhd_doflow = %d\n", __FUNCTION__, dhd_doflow);
\r
1862 /* Process dhd_slpauto parameters */
\r
1863 memset(pick, 0, MAXSZ_BUF);
\r
1864 len_val = process_config_vars(bufp, len, pick, "dhd_slpauto=");
\r
1866 if (!strncmp(pick, "0", len_val))
\r
1867 dhd_slpauto = FALSE;
\r
1869 dhd_slpauto = TRUE;
\r
1870 printf("%s: dhd_slpauto = %d\n", __FUNCTION__, dhd_slpauto);
\r
1874 /* Process dhd_master_mode parameters */
\r
1875 memset(pick, 0, MAXSZ_BUF);
\r
1876 len_val = process_config_vars(bufp, len, pick, "dhd_master_mode=");
\r
1878 if (!strncmp(pick, "0", len_val))
\r
1879 dhd_master_mode = FALSE;
\r
1881 dhd_master_mode = TRUE;
\r
1882 printf("%s: dhd_master_mode = %d\n", __FUNCTION__, dhd_master_mode);
\r
1885 #ifdef PKT_FILTER_SUPPORT
\r
1886 /* Process pkt_filter_add:
\r
1887 * All pkt: pkt_filter_add=99 0 0 0 0x000000000000 0x000000000000
\r
1889 memset(pick, 0, MAXSZ_BUF);
\r
1890 len_val = process_config_vars(bufp, len, pick, "pkt_filter_add=");
\r
1893 pch = bcmstrtok(&pick_tmp, ",.-", 0);
\r
1895 while (pch != NULL && i<DHD_CONF_FILTER_MAX) {
\r
1896 strcpy(&conf->pkt_filter_add.filter[i][0], pch);
\r
1897 printf("%s: pkt_filter_add[%d][] = %s\n", __FUNCTION__, i, &conf->pkt_filter_add.filter[i][0]);
\r
1898 pch = bcmstrtok(&pick_tmp, ",.-", 0);
\r
1901 conf->pkt_filter_add.count = i;
\r
1904 /* Process pkt_filter_del */
\r
1905 memset(pick, 0, MAXSZ_BUF);
\r
1906 len_val = process_config_vars(bufp, len, pick, "pkt_filter_del=");
\r
1909 pch = bcmstrtok(&pick_tmp, " ,.-", 0);
\r
1911 while (pch != NULL && i<DHD_CONF_FILTER_MAX) {
\r
1912 conf->pkt_filter_del.id[i] = (uint32)simple_strtol(pch, NULL, 10);
\r
1913 pch = bcmstrtok(&pick_tmp, " ,.-", 0);
\r
1916 conf->pkt_filter_del.count = i;
\r
1917 printf("%s: pkt_filter_del id = ", __FUNCTION__);
\r
1918 for (i=0; i<conf->pkt_filter_del.count; i++)
\r
1919 printf("%d ", conf->pkt_filter_del.id[i]);
\r
1924 /* Process srl parameters */
\r
1925 memset(pick, 0, MAXSZ_BUF);
\r
1926 len_val = process_config_vars(bufp, len, pick, "srl=");
\r
1928 conf->srl = (int)simple_strtol(pick, NULL, 10);
\r
1929 printf("%s: srl = %d\n", __FUNCTION__, conf->srl);
\r
1932 /* Process lrl parameters */
\r
1933 memset(pick, 0, MAXSZ_BUF);
\r
1934 len_val = process_config_vars(bufp, len, pick, "lrl=");
\r
1936 conf->lrl = (int)simple_strtol(pick, NULL, 10);
\r
1937 printf("%s: lrl = %d\n", __FUNCTION__, conf->lrl);
\r
1940 /* Process beacon timeout parameters */
\r
1941 memset(pick, 0, MAXSZ_BUF);
\r
1942 len_val = process_config_vars(bufp, len, pick, "bcn_timeout=");
\r
1944 conf->bcn_timeout= (uint)simple_strtol(pick, NULL, 10);
\r
1945 printf("%s: bcn_timeout = %d\n", __FUNCTION__, conf->bcn_timeout);
\r
1948 /* Process bus:txglom */
\r
1949 memset(pick, 0, MAXSZ_BUF);
\r
1950 len_val = process_config_vars(bufp, len, pick, "bus:txglom=");
\r
1952 conf->bus_txglom = (int)simple_strtol(pick, NULL, 10);
\r
1953 printf("%s: bus:txglom = %d\n", __FUNCTION__, conf->bus_txglom);
1956 /* Process ampdu_ba_wsize parameters */
\r
1957 memset(pick, 0, MAXSZ_BUF);
\r
1958 len_val = process_config_vars(bufp, len, pick, "ampdu_ba_wsize=");
\r
1960 conf->ampdu_ba_wsize = (int)simple_strtol(pick, NULL, 10);
\r
1961 printf("%s: ampdu_ba_wsize = %d\n", __FUNCTION__, conf->ampdu_ba_wsize);
\r
1964 /* Process kso_enable parameters */
\r
1965 memset(pick, 0, MAXSZ_BUF);
\r
1966 len_val = process_config_vars(bufp, len, pick, "kso_enable=");
\r
1968 if (!strncmp(pick, "0", len_val))
\r
1969 conf->kso_enable = FALSE;
\r
1971 conf->kso_enable = TRUE;
\r
1972 printf("%s: kso_enable = %d\n", __FUNCTION__, conf->kso_enable);
\r
1975 /* Process spect parameters */
\r
1976 memset(pick, 0, MAXSZ_BUF);
\r
1977 len_val = process_config_vars(bufp, len, pick, "spect=");
\r
1979 conf->spect = (int)simple_strtol(pick, NULL, 10);
\r
1980 printf("%s: spect = %d\n", __FUNCTION__, conf->spect);
\r
1983 /* Process txbf parameters */
\r
1984 memset(pick, 0, MAXSZ_BUF);
\r
1985 len_val = process_config_vars(bufp, len, pick, "txbf=");
\r
1987 conf->txbf = (int)simple_strtol(pick, NULL, 10);
\r
1988 printf("%s: txbf = %d\n", __FUNCTION__, conf->txbf);
\r
1991 /* Process frameburst parameters */
\r
1992 memset(pick, 0, MAXSZ_BUF);
\r
1993 len_val = process_config_vars(bufp, len, pick, "frameburst=");
\r
1995 conf->frameburst = (int)simple_strtol(pick, NULL, 10);
\r
1996 printf("%s: frameburst = %d\n", __FUNCTION__, conf->frameburst);
\r
1999 /* Process lpc parameters */
\r
2000 memset(pick, 0, MAXSZ_BUF);
\r
2001 len_val = process_config_vars(bufp, len, pick, "lpc=");
\r
2003 conf->lpc = (int)simple_strtol(pick, NULL, 10);
\r
2004 printf("%s: lpc = %d\n", __FUNCTION__, conf->lpc);
\r
2007 /* Process use_rxchain parameters */
\r
2008 memset(pick, 0, MAXSZ_BUF);
\r
2009 len_val = process_config_vars(bufp, len, pick, "use_rxchain=");
\r
2011 conf->use_rxchain = (int)simple_strtol(pick, NULL, 10);
\r
2012 printf("%s: use_rxchain = %d\n", __FUNCTION__, conf->use_rxchain);
\r
2015 #if defined(BCMSDIOH_TXGLOM)
2016 /* Process txglomsize parameters */
\r
2017 memset(pick, 0, MAXSZ_BUF);
\r
2018 len_val = process_config_vars(bufp, len, pick, "txglomsize=");
\r
2020 conf->txglomsize = (uint)simple_strtol(pick, NULL, 10);
\r
2021 if (conf->txglomsize > SDPCM_MAXGLOM_SIZE)
\r
2022 conf->txglomsize = SDPCM_MAXGLOM_SIZE;
\r
2023 printf("%s: txglomsize = %d\n", __FUNCTION__, conf->txglomsize);
\r
2026 /* Process swtxglom parameters */
\r
2027 memset(pick, 0, MAXSZ_BUF);
2028 len_val = process_config_vars(bufp, len, pick, "swtxglom=");
\r
2030 if (!strncmp(pick, "0", len_val))
2031 conf->swtxglom = FALSE;
\r
2033 conf->swtxglom = TRUE;
\r
2034 printf("%s: swtxglom = %d\n", __FUNCTION__, conf->swtxglom);
\r
2037 /* Process txglom_ext parameters */
2038 memset(pick, 0, MAXSZ_BUF);
2039 len_val = process_config_vars(bufp, len, pick, "txglom_ext=");
2041 if (!strncmp(pick, "0", len_val))
2042 conf->txglom_ext = FALSE;
2044 conf->txglom_ext = TRUE;
2045 printf("%s: txglom_ext = %d\n", __FUNCTION__, conf->txglom_ext);
2046 if (conf->txglom_ext) {
2047 if ((conf->chip == BCM43362_CHIP_ID) || (conf->chip == BCM4330_CHIP_ID))
2048 conf->txglom_bucket_size = 1680;
2049 else if (conf->chip == BCM43340_CHIP_ID || conf->chip == BCM43341_CHIP_ID ||
2050 conf->chip == BCM4334_CHIP_ID || conf->chip == BCM4324_CHIP_ID)
\r
2051 conf->txglom_bucket_size = 1684;
2053 printf("%s: txglom_bucket_size = %d\n", __FUNCTION__, conf->txglom_bucket_size);
2057 /* Process disable_proptx parameters */
\r
2058 memset(pick, 0, MAXSZ_BUF);
\r
2059 len_val = process_config_vars(bufp, len, pick, "disable_proptx=");
\r
2061 conf->disable_proptx = (int)simple_strtol(pick, NULL, 10);
2062 printf("%s: disable_proptx = %d\n", __FUNCTION__, conf->disable_proptx);
2065 /* Process dpc_cpucore parameters */
\r
2066 memset(pick, 0, MAXSZ_BUF);
\r
2067 len_val = process_config_vars(bufp, len, pick, "dpc_cpucore=");
\r
2069 conf->dpc_cpucore = (int)simple_strtol(pick, NULL, 10);
\r
2070 printf("%s: dpc_cpucore = %d\n", __FUNCTION__, conf->dpc_cpucore);
\r
2073 /* Process bus:rxglom parameters */
\r
2074 memset(pick, 0, MAXSZ_BUF);
\r
2075 len_val = process_config_vars(bufp, len, pick, "bus:rxglom=");
\r
2077 if (!strncmp(pick, "0", len_val))
\r
2078 conf->bus_rxglom = FALSE;
\r
2080 conf->bus_rxglom = TRUE;
\r
2081 printf("%s: bus:rxglom = %d\n", __FUNCTION__, conf->bus_rxglom);
\r
2084 /* Process deepsleep parameters */
\r
2085 memset(pick, 0, MAXSZ_BUF);
\r
2086 len_val = process_config_vars(bufp, len, pick, "deepsleep=");
\r
2088 if (!strncmp(pick, "1", len_val))
\r
2089 conf->deepsleep = TRUE;
\r
2091 conf->deepsleep = FALSE;
\r
2092 printf("%s: deepsleep = %d\n", __FUNCTION__, conf->deepsleep);
\r
2095 /* Process PM parameters */
\r
2096 memset(pick, 0, MAXSZ_BUF);
\r
2097 len_val = process_config_vars(bufp, len, pick, "PM=");
\r
2099 conf->pm = (int)simple_strtol(pick, NULL, 10);
\r
2100 printf("%s: PM = %d\n", __FUNCTION__, conf->pm);
\r
2103 /* Process tcpack_sup_mode parameters */
\r
2104 memset(pick, 0, MAXSZ_BUF);
\r
2105 len_val = process_config_vars(bufp, len, pick, "tcpack_sup_mode=");
\r
2107 conf->tcpack_sup_mode = (uint)simple_strtol(pick, NULL, 10);
\r
2108 printf("%s: tcpack_sup_mode = %d\n", __FUNCTION__, conf->tcpack_sup_mode);
\r
2111 /* Process dhd_poll parameters */
\r
2112 memset(pick, 0, MAXSZ_BUF);
\r
2113 len_val = process_config_vars(bufp, len, pick, "dhd_poll=");
\r
2115 if (!strncmp(pick, "0", len_val))
\r
2116 conf->dhd_poll = 0;
\r
2118 conf->dhd_poll = 1;
\r
2119 printf("%s: dhd_poll = %d\n", __FUNCTION__, conf->dhd_poll);
\r
2122 /* Process deferred_tx_len parameters */
\r
2123 memset(pick, 0, MAXSZ_BUF);
\r
2124 len_val = process_config_vars(bufp, len, pick, "deferred_tx_len=");
\r
2126 conf->deferred_tx_len = (int)simple_strtol(pick, NULL, 10);
\r
2127 printf("%s: deferred_tx_len = %d\n", __FUNCTION__, conf->deferred_tx_len);
\r
2130 /* Process pktprio8021x parameters */
\r
2131 memset(pick, 0, MAXSZ_BUF);
\r
2132 len_val = process_config_vars(bufp, len, pick, "pktprio8021x=");
\r
2134 conf->pktprio8021x = (int)simple_strtol(pick, NULL, 10);
\r
2135 printf("%s: pktprio8021x = %d\n", __FUNCTION__, conf->pktprio8021x);
\r
2138 /* Process txctl_tmo_fix parameters */
2139 memset(pick, 0, MAXSZ_BUF);
2140 len_val = process_config_vars(bufp, len, pick, "txctl_tmo_fix=");
2142 if (!strncmp(pick, "0", len_val))
2143 conf->txctl_tmo_fix = FALSE;
2145 conf->txctl_tmo_fix = TRUE;
2146 printf("%s: txctl_tmo_fix = %d\n", __FUNCTION__, conf->txctl_tmo_fix);
2149 /* Process tx_in_rx parameters */
2150 memset(pick, 0, MAXSZ_BUF);
2151 len_val = process_config_vars(bufp, len, pick, "tx_in_rx=");
2153 if (!strncmp(pick, "0", len_val))
2154 conf->tx_in_rx = FALSE;
2156 conf->tx_in_rx = TRUE;
2157 printf("%s: tx_in_rx = %d\n", __FUNCTION__, conf->tx_in_rx);
2160 /* Process dhd_txbound parameters */
2161 memset(pick, 0, MAXSZ_BUF);
2162 len_val = process_config_vars(bufp, len, pick, "dhd_txbound=");
2164 dhd_txbound = (uint)simple_strtol(pick, NULL, 10);
2165 printf("%s: dhd_txbound = %d\n", __FUNCTION__, dhd_txbound);
2168 /* Process dhd_rxbound parameters */
2169 memset(pick, 0, MAXSZ_BUF);
2170 len_val = process_config_vars(bufp, len, pick, "dhd_rxbound=");
2172 dhd_rxbound = (uint)simple_strtol(pick, NULL, 10);
2173 printf("%s: dhd_rxbound = %d\n", __FUNCTION__, dhd_rxbound);
2176 /* Process tx_max_offset parameters */
\r
2177 memset(pick, 0, MAXSZ_BUF);
\r
2178 len_val = process_config_vars(bufp, len, pick, "tx_max_offset=");
\r
2180 conf->tx_max_offset = (int)simple_strtol(pick, NULL, 10);
\r
2181 printf("%s: tx_max_offset = %d\n", __FUNCTION__, conf->tx_max_offset);
\r
2184 /* Process rsdb_mode parameters */
\r
2185 memset(pick, 0, MAXSZ_BUF);
\r
2186 len_val = process_config_vars(bufp, len, pick, "rsdb_mode=");
\r
2188 conf->rsdb_mode = (int)simple_strtol(pick, NULL, 10);
\r
2189 printf("%s: rsdb_mode = %d\n", __FUNCTION__, conf->rsdb_mode);
\r
2192 /* Process txglom_mode parameters */
\r
2193 memset(pick, 0, MAXSZ_BUF);
2194 len_val = process_config_vars(bufp, len, pick, "txglom_mode=");
\r
2196 if (!strncmp(pick, "0", len_val))
2197 conf->txglom_mode = FALSE;
\r
2199 conf->txglom_mode = TRUE;
\r
2200 printf("%s: txglom_mode = %d\n", __FUNCTION__, conf->txglom_mode);
\r
2205 CONFIG_ERROR(("%s: error reading config file: %d\n", __FUNCTION__, len));
\r
2206 bcmerror = BCME_SDIO_ERROR;
\r
2211 MFREE(dhd->osh, pick, MAXSZ_BUF);
\r
2214 MFREE(dhd->osh, memblock, MAXSZ_CONFIG);
\r
2217 dhd_os_close_image(image);
\r
2223 dhd_conf_set_chiprev(dhd_pub_t *dhd, uint chip, uint chiprev)
\r
2225 printf("%s: chip=0x%x, chiprev=%d\n", __FUNCTION__, chip, chiprev);
\r
2226 dhd->conf->chip = chip;
\r
2227 dhd->conf->chiprev = chiprev;
\r
2232 dhd_conf_get_chip(void *context)
\r
2234 dhd_pub_t *dhd = context;
\r
2236 if (dhd && dhd->conf)
\r
2237 return dhd->conf->chip;
\r
2242 dhd_conf_get_chiprev(void *context)
\r
2244 dhd_pub_t *dhd = context;
\r
2246 if (dhd && dhd->conf)
\r
2247 return dhd->conf->chiprev;
\r
2252 dhd_conf_set_txglom_params(dhd_pub_t *dhd, bool enable)
\r
2254 struct dhd_conf *conf = dhd->conf;
\r
2257 #if defined(SWTXGLOM)
\r
2258 if (conf->chip == BCM43362_CHIP_ID || conf->chip == BCM4330_CHIP_ID ||
\r
2259 conf->chip == BCM43340_CHIP_ID || conf->chip == BCM43341_CHIP_ID ||
\r
2260 conf->chip == BCM4334_CHIP_ID || conf->chip == BCM4324_CHIP_ID) {
\r
2261 // 43362/4330/4334/43340/43341/43241 must use 1.88.45.x swtxglom if txglom_ext is true, since 1.201.59 not support swtxglom
\r
2262 conf->swtxglom = TRUE;
\r
2263 conf->txglom_ext = TRUE;
\r
2265 if (conf->chip == BCM43362_CHIP_ID && conf->bus_txglom == 0) {
\r
2266 conf->bus_txglom = 1; // improve tcp tx tput. and cpu idle for 43362 only
\r
2269 // other parameters set in preinit or config.txt
\r
2271 // clear txglom parameters, but don't change swtxglom since it's possible enabled in config.txt
\r
2272 conf->txglom_ext = FALSE;
\r
2273 conf->txglom_bucket_size = 0;
\r
2274 conf->tx_in_rx = TRUE;
\r
2275 conf->tx_max_offset = 0;
\r
2276 conf->txglomsize = 0;
\r
2277 conf->deferred_tx_len = 0;
\r
2279 printf("%s: swtxglom=%d, txglom_ext=%d\n", __FUNCTION__,
\r
2280 conf->swtxglom, conf->txglom_ext);
\r
2281 printf("%s: txglom_bucket_size=%d\n", __FUNCTION__, conf->txglom_bucket_size);
\r
2282 printf("%s: txglomsize=%d, deferred_tx_len=%d, bus_txglom=%d\n", __FUNCTION__,
\r
2283 conf->txglomsize, conf->deferred_tx_len, conf->bus_txglom);
\r
2284 printf("%s: tx_in_rx=%d, tx_max_offset=%d\n", __FUNCTION__,
\r
2285 conf->tx_in_rx, conf->tx_max_offset);
\r
2290 dhd_conf_preinit(dhd_pub_t *dhd)
\r
2292 struct dhd_conf *conf = dhd->conf;
\r
2294 CONFIG_TRACE(("%s: Enter\n", __FUNCTION__));
\r
2297 dhd_conf_free_mac_list(&conf->fw_by_mac);
\r
2298 dhd_conf_free_mac_list(&conf->nv_by_mac);
\r
2299 dhd_conf_free_chip_nv_path_list(&conf->nv_by_chip);
\r
2301 memset(&conf->country_list, 0, sizeof(conf_country_list_t));
\r
2302 conf->band = WLC_BAND_AUTO;
\r
2303 conf->mimo_bw_cap = -1;
\r
2304 if (conf->chip == BCM43362_CHIP_ID || conf->chip == BCM4330_CHIP_ID) {
\r
2305 strcpy(conf->cspec.country_abbrev, "ALL");
\r
2306 strcpy(conf->cspec.ccode, "ALL");
\r
2307 conf->cspec.rev = 0;
\r
2308 } else if (conf->chip == BCM4335_CHIP_ID || conf->chip == BCM4339_CHIP_ID ||
\r
2309 conf->chip == BCM4354_CHIP_ID || conf->chip == BCM4356_CHIP_ID ||
\r
2310 conf->chip == BCM4345_CHIP_ID || conf->chip == BCM4371_CHIP_ID ||
\r
2311 conf->chip == BCM4359_CHIP_ID) {
\r
2312 strcpy(conf->cspec.country_abbrev, "CN");
\r
2313 strcpy(conf->cspec.ccode, "CN");
\r
2314 conf->cspec.rev = 38;
\r
2316 strcpy(conf->cspec.country_abbrev, "CN");
\r
2317 strcpy(conf->cspec.ccode, "CN");
\r
2318 conf->cspec.rev = 0;
\r
2320 memset(&conf->channels, 0, sizeof(wl_channel_list_t));
\r
2321 conf->roam_off = 1;
\r
2322 conf->roam_off_suspend = 1;
\r
2323 #ifdef CUSTOM_ROAM_TRIGGER_SETTING
\r
2324 conf->roam_trigger[0] = CUSTOM_ROAM_TRIGGER_SETTING;
\r
2326 conf->roam_trigger[0] = -65;
\r
2328 conf->roam_trigger[1] = WLC_BAND_ALL;
\r
2329 conf->roam_scan_period[0] = 10;
\r
2330 conf->roam_scan_period[1] = WLC_BAND_ALL;
\r
2331 #ifdef CUSTOM_ROAM_DELTA_SETTING
\r
2332 conf->roam_delta[0] = CUSTOM_ROAM_DELTA_SETTING;
\r
2334 conf->roam_delta[0] = 15;
\r
2336 conf->roam_delta[1] = WLC_BAND_ALL;
\r
2337 #ifdef FULL_ROAMING_SCAN_PERIOD_60_SEC
2338 conf->fullroamperiod = 60;
\r
2339 #else /* FULL_ROAMING_SCAN_PERIOD_60_SEC */
2340 conf->fullroamperiod = 120;
\r
2341 #endif /* FULL_ROAMING_SCAN_PERIOD_60_SEC */
\r
2342 #ifdef CUSTOM_KEEP_ALIVE_SETTING
\r
2343 conf->keep_alive_period = CUSTOM_KEEP_ALIVE_SETTING;
\r
2345 conf->keep_alive_period = 28000;
\r
2347 conf->force_wme_ac = 0;
\r
2349 conf->phy_oclscdenable = -1;
\r
2350 #ifdef PKT_FILTER_SUPPORT
\r
2351 memset(&conf->pkt_filter_add, 0, sizeof(conf_pkt_filter_add_t));
\r
2352 memset(&conf->pkt_filter_del, 0, sizeof(conf_pkt_filter_del_t));
\r
2353 conf->pkt_filter_magic = FALSE;
\r
2357 conf->bcn_timeout = 15;
\r
2358 conf->kso_enable = TRUE;
\r
2362 conf->disable_proptx = 0;
\r
2363 conf->bus_txglom = 0;
\r
2364 conf->use_rxchain = 0;
\r
2365 conf->bus_rxglom = TRUE;
\r
2366 conf->txglom_ext = FALSE;
\r
2367 conf->tx_max_offset = 0;
\r
2368 conf->deferred_tx_len = 0;
\r
2369 conf->txglomsize = SDPCM_DEFGLOM_SIZE;
\r
2370 conf->ampdu_ba_wsize = 0;
\r
2371 conf->dpc_cpucore = 0;
\r
2372 conf->frameburst = -1;
\r
2373 conf->deepsleep = FALSE;
\r
2375 #ifdef DHDTCPACK_SUPPRESS
2376 conf->tcpack_sup_mode = TCPACK_SUP_OFF;
\r
2378 conf->dhd_poll = -1;
\r
2379 conf->pktprio8021x = -1;
2380 conf->txctl_tmo_fix = FALSE;
2381 conf->tx_in_rx = TRUE;
\r
2382 conf->rsdb_mode = -2;
\r
2383 conf->txglom_mode = SDPCM_TXGLOM_MDESC;
\r
2384 if ((conf->chip == BCM43362_CHIP_ID) || (conf->chip == BCM4330_CHIP_ID)) {
\r
2385 conf->disable_proptx = 1;
\r
2386 conf->use_rxchain = 0;
\r
2388 if (conf->chip == BCM43430_CHIP_ID) {
\r
2389 conf->bus_rxglom = FALSE;
\r
2390 conf->use_rxchain = 0;
\r
2392 if (conf->chip == BCM4339_CHIP_ID) {
\r
2395 if (conf->chip == BCM4345_CHIP_ID) {
\r
2398 if (conf->chip == BCM4354_CHIP_ID) {
\r
2401 if (conf->chip == BCM4356_CHIP_ID) {
\r
2404 if (conf->chip == BCM4371_CHIP_ID) {
\r
2407 if (conf->chip == BCM4359_CHIP_ID) {
\r
2409 conf->rsdb_mode = 0;
\r
2412 if (conf->chip == BCM4356_CHIP_ID) {
\r
2415 #elif defined(BCMPCIE)
\r
2416 if (conf->chip == BCM4356_CHIP_ID) {
\r
2421 #if defined(SWTXGLOM)
\r
2422 if (conf->chip == BCM43362_CHIP_ID || conf->chip == BCM4330_CHIP_ID ||
\r
2423 conf->chip == BCM43340_CHIP_ID || conf->chip == BCM43341_CHIP_ID ||
\r
2424 conf->chip == BCM4334_CHIP_ID || conf->chip == BCM4324_CHIP_ID) {
\r
2425 conf->swtxglom = FALSE; // disabled by default
\r
2426 conf->txglom_ext = TRUE; // enabled by default
\r
2427 conf->use_rxchain = 0; // use_rxchain have been disabled if swtxglom enabled
\r
2428 conf->txglomsize = 16;
\r
2430 conf->swtxglom = FALSE; // use 1.201.59.x txglom by default
\r
2431 conf->txglom_ext = FALSE;
\r
2434 if (conf->chip == BCM43362_CHIP_ID) {
\r
2435 conf->txglom_bucket_size = 1680; // fixed value, don't change
\r
2436 conf->tx_in_rx = FALSE;
\r
2437 conf->tx_max_offset = 1;
\r
2439 if (conf->chip == BCM4330_CHIP_ID) {
\r
2440 conf->txglom_bucket_size = 1680; // fixed value, don't change
\r
2441 conf->tx_in_rx = FALSE;
\r
2442 conf->tx_max_offset = 0;
\r
2444 if (conf->chip == BCM4334_CHIP_ID) {
\r
2445 conf->txglom_bucket_size = 1684; // fixed value, don't change
\r
2446 conf->tx_in_rx = TRUE; // improve tcp tx tput. and cpu idle
\r
2447 conf->tx_max_offset = 0; // reduce udp tx: dhdsdio_readframes: got unlikely tx max 109 with tx_seq 110
\r
2449 if (conf->chip == BCM43340_CHIP_ID || conf->chip == BCM43341_CHIP_ID) {
\r
2450 conf->txglom_bucket_size = 1684; // fixed value, don't change
\r
2451 conf->tx_in_rx = TRUE; // improve tcp tx tput. and cpu idle
\r
2452 conf->tx_max_offset = 1;
\r
2454 if (conf->chip == BCM4324_CHIP_ID) {
\r
2455 conf->txglom_bucket_size = 1684; // fixed value, don't change
\r
2456 conf->tx_in_rx = TRUE; // improve tcp tx tput. and cpu idle
\r
2457 conf->tx_max_offset = 0;
\r
2460 #if defined(BCMSDIOH_TXGLOM_EXT)
\r
2461 conf->txglom_mode = SDPCM_TXGLOM_CPY;
\r
2462 if (conf->chip == BCM43362_CHIP_ID || conf->chip == BCM4330_CHIP_ID ||
\r
2463 conf->chip == BCM43340_CHIP_ID || conf->chip == BCM43341_CHIP_ID ||
\r
2464 conf->chip == BCM4334_CHIP_ID || conf->chip == BCM4324_CHIP_ID) {
\r
2465 conf->txglom_ext = TRUE;
\r
2466 conf->use_rxchain = 0;
\r
2467 conf->tx_in_rx = TRUE;
\r
2468 conf->tx_max_offset = 1;
\r
2470 conf->txglom_ext = FALSE;
\r
2472 if (conf->chip == BCM43362_CHIP_ID || conf->chip == BCM4330_CHIP_ID) {
\r
2473 conf->txglom_bucket_size = 1680; // fixed value, don't change
\r
2474 conf->txglomsize = 6;
\r
2476 if (conf->chip == BCM4334_CHIP_ID || conf->chip == BCM43340_CHIP_ID ||
\r
2477 conf->chip == BCM43341_CHIP_ID || conf->chip == BCM4324_CHIP_ID) {
\r
2478 conf->txglom_bucket_size = 1684; // fixed value, don't change
\r
2479 conf->txglomsize = 16;
\r
2482 if (conf->txglomsize > SDPCM_MAXGLOM_SIZE)
\r
2483 conf->txglomsize = SDPCM_MAXGLOM_SIZE;
\r
2484 conf->deferred_tx_len = conf->txglomsize;
\r
2490 dhd_conf_reset(dhd_pub_t *dhd)
\r
2493 dhd_conf_free_mac_list(&dhd->conf->fw_by_mac);
\r
2494 dhd_conf_free_mac_list(&dhd->conf->nv_by_mac);
\r
2495 dhd_conf_free_chip_nv_path_list(&dhd->conf->nv_by_chip);
\r
2497 memset(dhd->conf, 0, sizeof(dhd_conf_t));
\r
2502 dhd_conf_attach(dhd_pub_t *dhd)
\r
2506 CONFIG_TRACE(("%s: Enter\n", __FUNCTION__));
\r
2508 if (dhd->conf != NULL) {
\r
2509 printf("%s: config is attached before!\n", __FUNCTION__);
\r
2512 /* Allocate private bus interface state */
\r
2513 if (!(conf = MALLOC(dhd->osh, sizeof(dhd_conf_t)))) {
\r
2514 CONFIG_ERROR(("%s: MALLOC failed\n", __FUNCTION__));
\r
2517 memset(conf, 0, sizeof(dhd_conf_t));
\r
2525 MFREE(dhd->osh, conf, sizeof(dhd_conf_t));
\r
2526 return BCME_NOMEM;
\r
2530 dhd_conf_detach(dhd_pub_t *dhd)
\r
2532 CONFIG_TRACE(("%s: Enter\n", __FUNCTION__));
\r
2536 dhd_conf_free_mac_list(&dhd->conf->fw_by_mac);
\r
2537 dhd_conf_free_mac_list(&dhd->conf->nv_by_mac);
\r
2538 dhd_conf_free_chip_nv_path_list(&dhd->conf->nv_by_chip);
\r
2540 MFREE(dhd->osh, dhd->conf, sizeof(dhd_conf_t));
\r