1 /*
2 * Customer HW 4 dependant file
3 *
4 * Copyright (C) 2020, Broadcom.
5 *
6 * Unless you and Broadcom execute a separate written software license
7 * agreement governing use of this software, this software is licensed to you
8 * under the terms of the GNU General Public License version 2 (the "GPL"),
9 * available at http://www.broadcom.com/licenses/GPLv2.php, with the
10 * following added to such license:
11 *
12 * As a special exception, the copyright holders of this software give you
13 * permission to link this software with independent modules, and to copy and
14 * distribute the resulting executable under terms of your choice, provided that
15 * you also meet, for each linked independent module, the terms and conditions of
16 * the license of that module. An independent module is a module which is not
17 * derived from this software. The special exception does not apply to any
18 * modifications of the software.
19 *
20 *
21 * <<Broadcom-WL-IPTag/Open:>>
22 *
23 * $Id: dhd_custom_sec.c 334946 2012-05-24 20:38:00Z chanyun $
24 */
25 #if defined(CUSTOMER_HW4) || defined(CUSTOMER_HW40)
26 #include <typedefs.h>
27 #include <linuxver.h>
28 #include <osl.h>
29
30 #include <ethernet.h>
31 #include <dngl_stats.h>
32 #include <bcmutils.h>
33 #include <dhd.h>
34 #include <dhd_dbg.h>
35 #include <dhd_linux.h>
36 #include <bcmdevs.h>
37 #include <bcmdevs_legacy.h> /* need to still support chips no longer in trunk firmware */
38
39 #include <linux/fcntl.h>
40 #include <linux/fs.h>
41
42 const struct cntry_locales_custom translate_custom_table[] = {
43 /* default ccode/regrev */
44 {"", "XZ", 11}, /* Universal if Country code is unknown or empty */
45 {"IR", "XZ", 11}, /* Universal if Country code is IRAN, (ISLAMIC REPUBLIC OF) */
46 {"SD", "XZ", 11}, /* Universal if Country code is SUDAN */
47 {"PS", "XZ", 11}, /* Universal if Country code is PALESTINIAN TERRITORY, OCCUPIED */
48 {"TL", "XZ", 11}, /* Universal if Country code is TIMOR-LESTE (EAST TIMOR) */
49 {"MH", "XZ", 11}, /* Universal if Country code is MARSHALL ISLANDS */
50 {"GL", "GP", 2},
51 {"AL", "AL", 2},
52 #ifdef DHD_SUPPORT_GB_999
53 {"DZ", "GB", 999},
54 #else
55 {"DZ", "GB", 6},
56 #endif /* DHD_SUPPORT_GB_999 */
57 {"AS", "AS", 12},
58 {"AI", "AI", 1},
59 {"AF", "AD", 0},
60 {"AG", "AG", 2},
61 {"AR", "AU", 6},
62 {"AW", "AW", 2},
63 {"AU", "AU", 6},
64 {"AT", "AT", 4},
65 {"AZ", "AZ", 2},
66 {"BS", "BS", 2},
67 {"BH", "BH", 4},
68 {"BD", "BD", 1},
69 {"BY", "BY", 3},
70 {"BE", "BE", 4},
71 {"BM", "BM", 12},
72 {"BA", "BA", 2},
73 {"BR", "BR", 2},
74 {"VG", "VG", 2},
75 {"BN", "BN", 4},
76 {"BG", "BG", 4},
77 {"KH", "KH", 2},
78 {"KY", "KY", 3},
79 {"CN", "CN", 38},
80 {"CO", "CO", 17},
81 {"CR", "CR", 17},
82 {"HR", "HR", 4},
83 {"CY", "CY", 4},
84 {"CZ", "CZ", 4},
85 {"DK", "DK", 4},
86 {"EE", "EE", 4},
87 {"ET", "ET", 2},
88 {"FI", "FI", 4},
89 {"FR", "FR", 5},
90 {"GF", "GF", 2},
91 {"DE", "DE", 7},
92 {"GR", "GR", 4},
93 {"GD", "GD", 2},
94 {"GP", "GP", 2},
95 {"GU", "GU", 30},
96 {"HK", "HK", 2},
97 {"HU", "HU", 4},
98 {"IS", "IS", 4},
99 {"IN", "IN", 3},
100 {"ID", "ID", 1},
101 {"IE", "IE", 5},
102 {"IL", "IL", 14},
103 {"IT", "IT", 4},
104 {"JP", "JP", 45},
105 {"JO", "JO", 3},
106 {"KE", "SA", 0},
107 {"KW", "KW", 5},
108 {"LA", "LA", 2},
109 {"LV", "LV", 4},
110 {"LB", "LB", 5},
111 {"LS", "LS", 2},
112 {"LI", "LI", 4},
113 {"LT", "LT", 4},
114 {"LU", "LU", 3},
115 {"MO", "SG", 0},
116 {"MK", "MK", 2},
117 {"MW", "MW", 1},
118 {"MY", "MY", 3},
119 {"MV", "MV", 3},
120 {"MT", "MT", 4},
121 {"MQ", "MQ", 2},
122 {"MR", "MR", 2},
123 {"MU", "MU", 2},
124 {"YT", "YT", 2},
125 {"MX", "MX", 44},
126 {"MD", "MD", 2},
127 {"MC", "MC", 1},
128 {"ME", "ME", 2},
129 {"MA", "MA", 2},
130 {"NL", "NL", 4},
131 {"AN", "GD", 2},
132 {"NZ", "NZ", 4},
133 {"NO", "NO", 4},
134 {"OM", "OM", 4},
135 {"PA", "PA", 17},
136 {"PG", "AU", 6},
137 {"PY", "PY", 2},
138 {"PE", "PE", 20},
139 {"PH", "PH", 5},
140 {"PL", "PL", 4},
141 {"PT", "PT", 4},
142 {"PR", "PR", 38},
143 {"RE", "RE", 2},
144 {"RO", "RO", 4},
145 {"SN", "MA", 2},
146 {"RS", "RS", 2},
147 {"SK", "SK", 4},
148 {"SI", "SI", 4},
149 {"ES", "ES", 4},
150 {"LK", "LK", 1},
151 {"SE", "SE", 4},
152 {"CH", "CH", 4},
153 {"TW", "TW", 1},
154 {"TH", "TH", 5},
155 {"TT", "TT", 3},
156 {"TR", "TR", 7},
157 {"AE", "AE", 6},
158 #ifdef DHD_SUPPORT_GB_999
159 {"GB", "GB", 999},
160 #else
161 {"GB", "GB", 6},
162 #endif /* DHD_SUPPORT_GB_999 */
163 {"UY", "VE", 3},
164 {"VI", "PR", 38},
165 {"VA", "VA", 2},
166 {"VE", "VE", 3},
167 {"VN", "VN", 4},
168 {"ZM", "LA", 2},
169 {"EC", "EC", 21},
170 {"SV", "SV", 25},
171 #if defined(BCM4358_CHIP) || defined(BCM4359_CHIP)
172 {"KR", "KR", 70},
173 #else
174 {"KR", "KR", 48},
175 #endif
176 {"RU", "RU", 13},
177 {"UA", "UA", 8},
178 {"GT", "GT", 1},
179 {"MN", "MN", 1},
180 {"NI", "NI", 2},
181 {"UZ", "MA", 2},
182 {"ZA", "ZA", 6},
183 {"EG", "EG", 13},
184 {"TN", "TN", 1},
185 {"AO", "AD", 0},
186 {"BT", "BJ", 0},
187 {"BW", "BJ", 0},
188 {"LY", "LI", 4},
189 {"BO", "NG", 0},
190 {"UM", "PR", 38},
191 /* Support FCC 15.407 (Part 15E) Changes, effective June 2 2014 */
192 /* US/988, Q2/993 country codes with higher power on UNII-1 5G band */
193 {"US", "US", 988},
194 {"CU", "US", 988},
195 {"CA", "Q2", 993},
196 };
197
198 /* Customized Locale convertor
199 * input : ISO 3166-1 country abbreviation
200 * output: customized cspec
201 */
get_customized_country_code(void * adapter,char * country_iso_code,wl_country_t * cspec)202 void get_customized_country_code(void *adapter, char *country_iso_code, wl_country_t *cspec)
203 {
204 int size, i;
205
206 size = ARRAYSIZE(translate_custom_table);
207
208 if (cspec == 0)
209 return;
210
211 if (size == 0)
212 return;
213
214 for (i = 0; i < size; i++) {
215 if (strcmp(country_iso_code, translate_custom_table[i].iso_abbrev) == 0) {
216 memcpy(cspec->ccode,
217 translate_custom_table[i].custom_locale, WLC_CNTRY_BUF_SZ);
218 cspec->rev = translate_custom_table[i].custom_locale_rev;
219 return;
220 }
221 }
222 return;
223 }
224
225 #define PSMINFO PLATFORM_PATH".psm.info"
226 #define ANTINFO PLATFORM_PATH".ant.info"
227 #define WIFIVERINFO PLATFORM_PATH".wifiver.info"
228 #define LOGTRACEINFO PLATFORM_PATH".logtrace.info"
229 #define SOFTAPINFO PLATFORM_PATH".softap.info"
230
231 #ifdef DHD_PM_CONTROL_FROM_FILE
232 /* XXX This function used for setup PM related value control by read from file.
233 * Normally, PM related value Turn Offed for MFG process
234 */
235 extern bool g_pm_control;
236 #ifdef DHD_EXPORT_CNTL_FILE
237 extern uint32 pmmode_val;
238 #endif /* !DHD_EXPORT_CNTL_FILE */
sec_control_pm(dhd_pub_t * dhd,uint * power_mode)239 void sec_control_pm(dhd_pub_t *dhd, uint *power_mode)
240 {
241 #ifndef DHD_EXPORT_CNTL_FILE
242 struct file *fp = NULL;
243 char *filepath = PSMINFO;
244 #endif /* DHD_EXPORT_CNTL_FILE */
245 char power_val = 0;
246 int ret = 0;
247 #ifdef DHD_ENABLE_LPC
248 uint32 lpc = 0;
249 #endif /* DHD_ENABLE_LPC */
250
251 #ifndef DHD_EXPORT_CNTL_FILE
252 g_pm_control = FALSE;
253 fp = filp_open(filepath, O_RDONLY, 0);
254 if (IS_ERR(fp) || (fp == NULL)) {
255 /* Enable PowerSave Mode */
256 dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode,
257 sizeof(uint), TRUE, 0);
258 DHD_ERROR(("[WIFI_SEC] %s: %s doesn't exist"
259 " so set PM to %d\n",
260 __FUNCTION__, filepath, *power_mode));
261 return;
262 } else {
263 kernel_read_compat(fp, fp->f_pos, &power_val, 1);
264 DHD_ERROR(("[WIFI_SEC] %s: POWER_VAL = %c \r\n", __FUNCTION__, power_val));
265 filp_close(fp, NULL);
266 }
267 #else
268 g_pm_control = FALSE;
269 /* Not set from the framework side */
270 if (pmmode_val == 0xFFu) {
271 /* Enable PowerSave Mode */
272 dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode,
273 sizeof(uint), TRUE, 0);
274 DHD_ERROR(("[WIFI_SEC] %s: doesn't set from sysfs"
275 " so set PM to %d\n",
276 __FUNCTION__, *power_mode));
277 return;
278
279 } else {
280 power_val = (char)pmmode_val;
281 }
282 #endif /* !DHD_EXPORT_CNTL_FILE */
283
284 #ifdef DHD_EXPORT_CNTL_FILE
285 if (power_val == 0) {
286 #else
287 /* XXX: power_val is compared with character type read from .psm.info file */
288 if (power_val == '0') {
289 #endif /* DHD_EXPORT_CNTL_FILE */
290 #ifdef ROAM_ENABLE
291 uint roamvar = 1;
292 #endif
293 uint32 wl_updown = 1;
294
295 *power_mode = PM_OFF;
296 /* Disable PowerSave Mode */
297 dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode,
298 sizeof(uint), TRUE, 0);
299 #ifndef CUSTOM_SET_ANTNPM
300 /* Turn off MPC in AP mode */
301 ret = dhd_iovar(dhd, 0, "mpc", (char *)power_mode, sizeof(*power_mode),
302 NULL, 0, TRUE);
303 #endif /* !CUSTOM_SET_ANTNPM */
304 g_pm_control = TRUE;
305 #ifdef ROAM_ENABLE
306 /* Roaming off of dongle */
307 ret = dhd_iovar(dhd, 0, "roam_off", (char *)&roamvar, sizeof(roamvar), NULL,
308 0, TRUE);
309 #endif
310 #ifdef DHD_ENABLE_LPC
311 /* Set lpc 0 */
312 ret = dhd_iovar(dhd, 0, "lpc", (char *)&lpc, sizeof(lpc), NULL, 0, TRUE);
313 if (ret < 0) {
314 DHD_ERROR(("[WIFI_SEC] %s: Set lpc failed %d\n",
315 __FUNCTION__, ret));
316 }
317 #endif /* DHD_ENABLE_LPC */
318 #ifdef DHD_PCIE_RUNTIMEPM
319 DHD_ERROR(("[WIFI_SEC] %s : Turn Runtime PM off \n", __FUNCTION__));
320 /* Turn Runtime PM off */
321 dhdpcie_block_runtime_pm(dhd);
322 #endif /* DHD_PCIE_RUNTIMEPM */
323 /* Disable ocl */
324 if ((ret = dhd_wl_ioctl_cmd(dhd, WLC_UP, (char *)&wl_updown,
325 sizeof(wl_updown), TRUE, 0)) < 0) {
326 DHD_ERROR(("[WIFI_SEC] %s: WLC_UP faield %d\n", __FUNCTION__, ret));
327 }
328 #ifndef CUSTOM_SET_OCLOFF
329 {
330 uint32 ocl_enable = 0;
331 ret = dhd_iovar(dhd, 0, "ocl_enable", (char *)&ocl_enable,
332 sizeof(ocl_enable), NULL, 0, TRUE);
333 if (ret < 0) {
334 DHD_ERROR(("[WIFI_SEC] %s: Set ocl_enable %d failed %d\n",
335 __FUNCTION__, ocl_enable, ret));
336 } else {
337 DHD_ERROR(("[WIFI_SEC] %s: Set ocl_enable %d OK %d\n",
338 __FUNCTION__, ocl_enable, ret));
339 }
340 }
341 #else
342 dhd->ocl_off = TRUE;
343 #endif /* CUSTOM_SET_OCLOFF */
344 #ifdef WLADPS
345 if ((ret = dhd_enable_adps(dhd, ADPS_DISABLE)) < 0) {
346 DHD_ERROR(("[WIFI_SEC] %s: dhd_enable_adps failed %d\n",
347 __FUNCTION__, ret));
348 }
349 #endif /* WLADPS */
350
351 if ((ret = dhd_wl_ioctl_cmd(dhd, WLC_DOWN, (char *)&wl_updown,
352 sizeof(wl_updown), TRUE, 0)) < 0) {
353 DHD_ERROR(("[WIFI_SEC] %s: WLC_DOWN faield %d\n",
354 __FUNCTION__, ret));
355 }
356 } else {
357 dhd_wl_ioctl_cmd(dhd, WLC_SET_PM, (char *)power_mode,
358 sizeof(uint), TRUE, 0);
359 }
360 }
361 #endif /* DHD_PM_CONTROL_FROM_FILE */
362
363 #ifdef MIMO_ANT_SETTING
364 int get_ant_val_from_file(uint32 *read_val)
365 {
366 int ret = -1;
367 struct file *fp = NULL;
368 char *filepath = ANTINFO;
369 char *p_ant_val = NULL;
370 uint32 ant_val = 0;
371
372 /* Read antenna settings from the file */
373 fp = filp_open(filepath, O_RDONLY, 0);
374 if (IS_ERR(fp)) {
375 DHD_ERROR(("[WIFI_SEC] %s: File [%s] doesn't exist\n", __FUNCTION__, filepath));
376 ret = -ENOENT;
377 return ret;
378 } else {
379 ret = kernel_read_compat(fp, 0, (char *)&ant_val, sizeof(uint32));
380 if (ret < 0) {
381 DHD_ERROR(("[WIFI_SEC] %s: File read error, ret=%d\n", __FUNCTION__, ret));
382 filp_close(fp, NULL);
383 return ret;
384 }
385
386 p_ant_val = (char *)&ant_val;
387 p_ant_val[sizeof(uint32) - 1] = '\0';
388 ant_val = bcm_atoi(p_ant_val);
389
390 DHD_ERROR(("[WIFI_SEC]%s: ANT val = %d\n", __FUNCTION__, ant_val));
391 filp_close(fp, NULL);
392
393 /* Check value from the file */
394 if (ant_val < 1 || ant_val > 3) {
395 DHD_ERROR(("[WIFI_SEC] %s: Invalid value %d read from the file %s\n",
396 __FUNCTION__, ant_val, filepath));
397 return -1;
398 }
399 }
400 *read_val = ant_val;
401 return ret;
402 }
403
404 int dhd_sel_ant_from_file(dhd_pub_t *dhd)
405 {
406 int ret = -1;
407 uint32 ant_val = 0;
408 uint32 btc_mode = 0;
409 uint chip_id = dhd_bus_chip_id(dhd);
410 #ifndef CUSTOM_SET_ANTNPM
411 wl_config_t rsdb_mode;
412
413 memset(&rsdb_mode, 0, sizeof(rsdb_mode));
414 #endif /* !CUSTOM_SET_ANTNPM */
415
416 /* Check if this chip can support MIMO */
417 if (chip_id != BCM4350_CHIP_ID &&
418 chip_id != BCM4354_CHIP_ID &&
419 chip_id != BCM43569_CHIP_ID &&
420 chip_id != BCM4358_CHIP_ID &&
421 chip_id != BCM4359_CHIP_ID &&
422 chip_id != BCM4355_CHIP_ID &&
423 chip_id != BCM4347_CHIP_ID &&
424 chip_id != BCM4361_CHIP_ID &&
425 chip_id != BCM4375_CHIP_ID &&
426 chip_id != BCM4389_CHIP_ID) {
427 DHD_ERROR(("[WIFI_SEC] %s: This chipset does not support MIMO\n",
428 __FUNCTION__));
429 return ret;
430 }
431
432 #ifndef DHD_EXPORT_CNTL_FILE
433 ret = get_ant_val_from_file(&ant_val);
434 #else
435 ant_val = (uint32)antsel;
436 #endif /* !DHD_EXPORT_CNTL_FILE */
437 if (ant_val == 0) {
438 #ifdef CUSTOM_SET_ANTNPM
439 dhd->mimo_ant_set = 0;
440 #endif /* CUSTOM_SET_ANTNPM */
441 return ret;
442 }
443 DHD_ERROR(("[WIFI_SEC]%s: ANT val = %d\n", __FUNCTION__, ant_val));
444
445 /* bt coex mode off */
446 if (dhd_get_fw_mode(dhd->info) == DHD_FLAG_MFG_MODE) {
447 ret = dhd_iovar(dhd, 0, "btc_mode", (char *)&btc_mode, sizeof(btc_mode), NULL, 0,
448 TRUE);
449 if (ret) {
450 DHD_ERROR(("[WIFI_SEC] %s: Fail to execute dhd_wl_ioctl_cmd(): "
451 "btc_mode, ret=%d\n",
452 __FUNCTION__, ret));
453 return ret;
454 }
455 }
456
457 #ifndef CUSTOM_SET_ANTNPM
458 /* rsdb mode off */
459 DHD_ERROR(("[WIFI_SEC] %s: %s the RSDB mode!\n",
460 __FUNCTION__, rsdb_mode.config ? "Enable" : "Disable"));
461 ret = dhd_iovar(dhd, 0, "rsdb_mode", (char *)&rsdb_mode, sizeof(rsdb_mode), NULL, 0, TRUE);
462 if (ret) {
463 DHD_ERROR(("[WIFI_SEC] %s: Fail to execute dhd_wl_ioctl_cmd(): "
464 "rsdb_mode, ret=%d\n", __FUNCTION__, ret));
465 return ret;
466 }
467
468 /* Select Antenna */
469 ret = dhd_iovar(dhd, 0, "txchain", (char *)&ant_val, sizeof(ant_val), NULL, 0, TRUE);
470 if (ret) {
471 DHD_ERROR(("[WIFI_SEC] %s: Fail to execute dhd_wl_ioctl_cmd(): txchain, ret=%d\n",
472 __FUNCTION__, ret));
473 return ret;
474 }
475
476 ret = dhd_iovar(dhd, 0, "rxchain", (char *)&ant_val, sizeof(ant_val), NULL, 0, TRUE);
477 if (ret) {
478 DHD_ERROR(("[WIFI_SEC] %s: Fail to execute dhd_wl_ioctl_cmd(): rxchain, ret=%d\n",
479 __FUNCTION__, ret));
480 return ret;
481 }
482 #else
483 dhd->mimo_ant_set = ant_val;
484 DHD_ERROR(("[WIFI_SEC] %s: mimo_ant_set = %d\n", __FUNCTION__, dhd->mimo_ant_set));
485 #endif /* CUSTOM_SET_ANTNPM */
486
487 return 0;
488 }
489 #endif /* MIMO_ANTENNA_SETTING */
490
491 #ifdef LOGTRACE_FROM_FILE
492 /*
493 * LOGTRACEINFO = .logtrace.info
494 * - logtrace = 1 => Enable LOGTRACE Event
495 * - logtrace = 0 => Disable LOGTRACE Event
496 * - file not exist => Disable LOGTRACE Event
497 */
498 int dhd_logtrace_from_file(dhd_pub_t *dhd)
499 {
500 #ifndef DHD_EXPORT_CNTL_FILE
501 struct file *fp = NULL;
502 int ret = -1;
503 uint32 logtrace = 0;
504 char *filepath = LOGTRACEINFO;
505 char *p_logtrace = NULL;
506
507 /* Read LOGTRACE Event on/off request from the file */
508 fp = filp_open(filepath, O_RDONLY, 0);
509 if (IS_ERR(fp)) {
510 DHD_ERROR(("[WIFI_SEC] %s: File [%s] doesn't exist\n", __FUNCTION__, filepath));
511 return 0;
512 } else {
513 ret = kernel_read_compat(fp, 0, (char *)&logtrace, sizeof(uint32));
514 if (ret < 0) {
515 DHD_ERROR(("[WIFI_SEC] %s: File read error, ret=%d\n", __FUNCTION__, ret));
516 filp_close(fp, NULL);
517 return 0;
518 }
519
520 p_logtrace = (char *)&logtrace;
521 p_logtrace[sizeof(uint32) - 1] = '\0';
522 logtrace = bcm_atoi(p_logtrace);
523
524 DHD_ERROR(("[WIFI_SEC] %s: LOGTRACE On/Off from file = %d\n",
525 __FUNCTION__, logtrace));
526 filp_close(fp, NULL);
527
528 /* Check value from the file */
529 if (logtrace > 2) {
530 DHD_ERROR(("[WIFI_SEC] %s: Invalid value %d read from the file %s\n",
531 __FUNCTION__, logtrace, filepath));
532 return 0;
533 }
534 }
535
536 return (int)logtrace;
537 #else
538 DHD_ERROR(("[WIFI_SEC] %s : LOGTRACE On/Off from sysfs = %d\n",
539 __FUNCTION__, (int)logtrace_val));
540 return (int)logtrace_val;
541 #endif /* !DHD_EXPORT_CNTL_FILE */
542 }
543 #endif /* LOGTRACE_FROM_FILE */
544
545 #ifdef USE_WFA_CERT_CONF
546 #ifndef DHD_EXPORT_CNTL_FILE
547 int sec_get_param_wfa_cert(dhd_pub_t *dhd, int mode, uint* read_val)
548 {
549 struct file *fp = NULL;
550 char *filepath = NULL;
551 int val = 0;
552 char *p_val = NULL;
553
554 if (!dhd || (mode < SET_PARAM_BUS_TXGLOM_MODE) ||
555 (mode >= PARAM_LAST_VALUE)) {
556 DHD_ERROR(("[WIFI_SEC] %s: invalid argument\n", __FUNCTION__));
557 return BCME_ERROR;
558 }
559
560 switch (mode) {
561 #ifdef BCMSDIO
562 case SET_PARAM_BUS_TXGLOM_MODE:
563 filepath = PLATFORM_PATH".bustxglom.info";
564 break;
565 #endif /* BCMSDIO */
566 #if defined(ROAM_ENABLE) || defined(DISABLE_BUILTIN_ROAM)
567 case SET_PARAM_ROAMOFF:
568 filepath = PLATFORM_PATH".roamoff.info";
569 break;
570 #endif /* ROAM_ENABLE || DISABLE_BUILTIN_ROAM */
571 #ifdef USE_WL_FRAMEBURST
572 case SET_PARAM_FRAMEBURST:
573 filepath = PLATFORM_PATH".frameburst.info";
574 break;
575 #endif /* USE_WL_FRAMEBURST */
576 #ifdef USE_WL_TXBF
577 case SET_PARAM_TXBF:
578 filepath = PLATFORM_PATH".txbf.info";
579 break;
580 #endif /* USE_WL_TXBF */
581 #ifdef PROP_TXSTATUS
582 case SET_PARAM_PROPTX:
583 filepath = PLATFORM_PATH".proptx.info";
584 break;
585 #endif /* PROP_TXSTATUS */
586 default:
587 DHD_ERROR(("[WIFI_SEC] %s: File to find file name for index=%d\n",
588 __FUNCTION__, mode));
589 return BCME_ERROR;
590 }
591 fp = filp_open(filepath, O_RDONLY, 0);
592 if (IS_ERR(fp) || (fp == NULL)) {
593 DHD_ERROR(("[WIFI_SEC] %s: File open failed, file path=%s\n",
594 __FUNCTION__, filepath));
595 return BCME_ERROR;
596 } else {
597 if (kernel_read_compat(fp, fp->f_pos, (char *)&val, sizeof(uint32)) < 0) {
598 filp_close(fp, NULL);
599 /* File operation is failed so we will return error code */
600 DHD_ERROR(("[WIFI_SEC] %s: read failed, file path=%s\n",
601 __FUNCTION__, filepath));
602 return BCME_ERROR;
603 }
604 filp_close(fp, NULL);
605 }
606
607 p_val = (char *)&val;
608 p_val[sizeof(uint32) - 1] = '\0';
609 val = bcm_atoi(p_val);
610
611 switch (mode) {
612 #if defined(ROAM_ENABLE) || defined(DISABLE_BUILTIN_ROAM)
613 case SET_PARAM_ROAMOFF:
614 #endif /* ROAM_ENABLE || DISABLE_BUILTIN_ROAM */
615 #ifdef USE_WL_FRAMEBURST
616 case SET_PARAM_FRAMEBURST:
617 #endif /* USE_WL_FRAMEBURST */
618 #ifdef USE_WL_TXBF
619 case SET_PARAM_TXBF:
620 #endif /* USE_WL_TXBF */
621 #ifdef PROP_TXSTATUS
622 case SET_PARAM_PROPTX:
623 #endif /* PROP_TXSTATUS */
624 if (val < 0 || val > 1) {
625 DHD_ERROR(("[WIFI_SEC] %s: value[%d] is out of range\n",
626 __FUNCTION__, *read_val));
627 return BCME_ERROR;
628 }
629 break;
630 default:
631 return BCME_ERROR;
632 }
633 *read_val = (uint)val;
634 return BCME_OK;
635 }
636 #else
637 int sec_get_param_wfa_cert(dhd_pub_t *dhd, int mode, uint* read_val)
638 {
639 uint val = 0;
640
641 if (!dhd || (mode < SET_PARAM_BUS_TXGLOM_MODE) ||
642 (mode >= PARAM_LAST_VALUE)) {
643 DHD_ERROR(("[WIFI_SEC] %s: invalid argument\n", __FUNCTION__));
644 return BCME_ERROR;
645 }
646
647 switch (mode) {
648 #ifdef BCMSDIO
649 case SET_PARAM_BUS_TXGLOM_MODE:
650 if (bus_txglom == VALUENOTSET)
651 return BCME_ERROR;
652 else
653 val = (uint)bus_txglom;
654 break;
655 #endif /* BCMSDIO */
656 #if defined(ROAM_ENABLE) || defined(DISABLE_BUILTIN_ROAM)
657 case SET_PARAM_ROAMOFF:
658 if (roam_off == VALUENOTSET)
659 return BCME_ERROR;
660 else
661 val = (uint)roam_off;
662 break;
663 #endif /* ROAM_ENABLE || DISABLE_BUILTIN_ROAM */
664 #ifdef USE_WL_FRAMEBURST
665 case SET_PARAM_FRAMEBURST:
666 if (frameburst == VALUENOTSET)
667 return BCME_ERROR;
668 else
669 val = (uint)frameburst;
670 break;
671 #endif /* USE_WL_FRAMEBURST */
672 #ifdef USE_WL_TXBF
673 case SET_PARAM_TXBF:
674 if (txbf == VALUENOTSET)
675 return BCME_ERROR;
676 else
677 val = (uint)txbf;
678 break;
679 #endif /* USE_WL_TXBF */
680 #ifdef PROP_TXSTATUS
681 case SET_PARAM_PROPTX:
682 if (proptx == VALUENOTSET)
683 return BCME_ERROR;
684 else
685 val = (uint)proptx;
686 break;
687 #endif /* PROP_TXSTATUS */
688 default:
689 return BCME_ERROR;
690 }
691 *read_val = val;
692 return BCME_OK;
693 }
694 #endif /* !DHD_EXPORT_CNTL_FILE */
695 #endif /* USE_WFA_CERT_CONF */
696
697 #ifdef WRITE_WLANINFO
698 #define FIRM_PREFIX "Firm_ver:"
699 #define DHD_PREFIX "DHD_ver:"
700 #define NV_PREFIX "Nv_info:"
701 #define CLM_PREFIX "CLM_ver:"
702 #define max_len(a, b) ((sizeof(a)/(2)) - (strlen(b)) - (3))
703 #define tstr_len(a, b) ((strlen(a)) + (strlen(b)) + (3))
704
705 char version_info[MAX_VERSION_LEN];
706 char version_old_info[MAX_VERSION_LEN];
707
708 int write_filesystem(struct file *file, unsigned long long offset,
709 unsigned char* data, unsigned int size)
710 {
711 mm_segment_t oldfs;
712 int ret;
713
714 oldfs = get_fs();
715 set_fs(KERNEL_DS);
716
717 ret = vfs_write(file, data, size, &offset);
718
719 set_fs(oldfs);
720 return ret;
721 }
722
723 uint32 sec_save_wlinfo(char *firm_ver, char *dhd_ver, char *nvram_p, char *clm_ver)
724 {
725 #ifndef DHD_EXPORT_CNTL_FILE
726 struct file *fp = NULL;
727 char *filepath = WIFIVERINFO;
728 #endif /* DHD_EXPORT_CNTL_FILE */
729 struct file *nvfp = NULL;
730 int min_len, str_len = 0;
731 int ret = 0;
732 char* nvram_buf;
733 char temp_buf[256];
734
735 DHD_TRACE(("[WIFI_SEC] %s: Entered.\n", __FUNCTION__));
736
737 DHD_INFO(("[WIFI_SEC] firmware version : %s\n", firm_ver));
738 DHD_INFO(("[WIFI_SEC] dhd driver version : %s\n", dhd_ver));
739 DHD_INFO(("[WIFI_SEC] nvram path : %s\n", nvram_p));
740 DHD_INFO(("[WIFI_SEC] clm version : %s\n", clm_ver));
741
742 memset(version_info, 0, sizeof(version_info));
743
744 if (strlen(dhd_ver)) {
745 min_len = min(strlen(dhd_ver), max_len(temp_buf, DHD_PREFIX));
746 min_len += strlen(DHD_PREFIX) + 3;
747 DHD_INFO(("[WIFI_SEC] DHD ver length : %d\n", min_len));
748 snprintf(version_info+str_len, min_len, DHD_PREFIX " %s\n", dhd_ver);
749 str_len = strlen(version_info);
750
751 DHD_INFO(("[WIFI_SEC] Driver version_info len : %d\n", str_len));
752 DHD_INFO(("[WIFI_SEC] Driver version_info : %s\n", version_info));
753 } else {
754 DHD_ERROR(("[WIFI_SEC] Driver version is missing.\n"));
755 }
756
757 if (strlen(firm_ver)) {
758 min_len = min(strlen(firm_ver), max_len(temp_buf, FIRM_PREFIX));
759 min_len += strlen(FIRM_PREFIX) + 3;
760 DHD_INFO(("[WIFI_SEC] firmware ver length : %d\n", min_len));
761 snprintf(version_info+str_len, min_len, FIRM_PREFIX " %s\n", firm_ver);
762 str_len = strlen(version_info);
763
764 DHD_INFO(("[WIFI_SEC] Firmware version_info len : %d\n", str_len));
765 DHD_INFO(("[WIFI_SEC] Firmware version_info : %s\n", version_info));
766 } else {
767 DHD_ERROR(("[WIFI_SEC] Firmware version is missing.\n"));
768 }
769
770 if (nvram_p) {
771 memset(temp_buf, 0, sizeof(temp_buf));
772 nvfp = filp_open(nvram_p, O_RDONLY, 0);
773 if (IS_ERR(nvfp) || (nvfp == NULL)) {
774 DHD_ERROR(("[WIFI_SEC] %s: Nvarm File open failed.\n", __FUNCTION__));
775 return -1;
776 } else {
777 ret = kernel_read_compat(nvfp, nvfp->f_pos, temp_buf, sizeof(temp_buf));
778 filp_close(nvfp, NULL);
779 }
780
781 if (strlen(temp_buf)) {
782 nvram_buf = temp_buf;
783 bcmstrtok(&nvram_buf, "\n", 0);
784 DHD_INFO(("[WIFI_SEC] nvram tolkening : %s(%zu) \n",
785 temp_buf, strlen(temp_buf)));
786 snprintf(version_info+str_len, tstr_len(temp_buf, NV_PREFIX),
787 NV_PREFIX " %s\n", temp_buf);
788 str_len = strlen(version_info);
789 DHD_INFO(("[WIFI_SEC] NVRAM version_info : %s\n", version_info));
790 DHD_INFO(("[WIFI_SEC] NVRAM version_info len : %d, nvram len : %zu\n",
791 str_len, strlen(temp_buf)));
792 } else {
793 DHD_ERROR(("[WIFI_SEC] NVRAM info is missing.\n"));
794 }
795 } else {
796 DHD_ERROR(("[WIFI_SEC] Not exist nvram path\n"));
797 }
798
799 if (strlen(clm_ver)) {
800 min_len = min(strlen(clm_ver), max_len(temp_buf, CLM_PREFIX));
801 min_len += strlen(CLM_PREFIX) + 3;
802 DHD_INFO(("[WIFI_SEC] clm ver length : %d\n", min_len));
803 snprintf(version_info+str_len, min_len, CLM_PREFIX " %s\n", clm_ver);
804 str_len = strlen(version_info);
805
806 DHD_INFO(("[WIFI_SEC] CLM version_info len : %d\n", str_len));
807 DHD_INFO(("[WIFI_SEC] CLM version_info : %s\n", version_info));
808 } else {
809 DHD_ERROR(("[WIFI_SEC] CLM version is missing.\n"));
810 }
811
812 DHD_INFO(("[WIFI_SEC] version_info : %s, strlen : %zu\n",
813 version_info, strlen(version_info)));
814
815 #ifndef DHD_EXPORT_CNTL_FILE
816 fp = filp_open(filepath, O_RDONLY, 0);
817 if (IS_ERR(fp) || (fp == NULL)) {
818 DHD_ERROR(("[WIFI_SEC] %s: .wifiver.info File open failed.\n", __FUNCTION__));
819 } else {
820 memset(version_old_info, 0, sizeof(version_old_info));
821 ret = kernel_read_compat(fp, fp->f_pos, version_old_info, sizeof(version_info));
822 filp_close(fp, NULL);
823 DHD_INFO(("[WIFI_SEC] kernel_read ret : %d.\n", ret));
824 if (strcmp(version_info, version_old_info) == 0) {
825 DHD_ERROR(("[WIFI_SEC] .wifiver.info already saved.\n"));
826 return 0;
827 }
828 }
829
830 fp = filp_open(filepath, O_RDWR | O_CREAT, 0664);
831 if (IS_ERR(fp) || (fp == NULL)) {
832 DHD_ERROR(("[WIFI_SEC] %s: .wifiver.info File open failed.\n",
833 __FUNCTION__));
834 } else {
835 ret = write_filesystem(fp, fp->f_pos, version_info, sizeof(version_info));
836 DHD_INFO(("[WIFI_SEC] sec_save_wlinfo done. ret : %d\n", ret));
837 DHD_ERROR(("[WIFI_SEC] save .wifiver.info file.\n"));
838 filp_close(fp, NULL);
839 }
840 #endif /* DHD_EXPORT_CNTL_FILE */
841 return ret;
842 }
843 #endif /* WRITE_WLANINFO */
844
845 #ifdef SUPPORT_MULTIPLE_BOARD_REV_FROM_HW
846 unsigned int system_hw_rev;
847 static int
848 __init get_hw_rev(char *arg)
849 {
850 get_option(&arg, &system_hw_rev);
851 printk("dhd : hw_rev : %d\n", system_hw_rev);
852 return 0;
853 }
854
855 early_param("androidboot.hw_rev", get_hw_rev);
856 #endif /* SUPPORT_MULTIPLE_BOARD_REV_FROM_HW */
857
858 #ifdef GEN_SOFTAP_INFO_FILE
859 #define SOFTAP_INFO_FILE_FIRST_LINE "#.softap.info"
860 /*
861 * # Does RSDB Wifi sharing support?
862 * DualBandConcurrency
863 * # Both wifi and hotspot can be turned on at the same time?
864 * DualInterface
865 * # 5Ghz band support?
866 * 5G
867 * # How many clients can be connected?
868 * maxClient
869 * # Does hotspot support PowerSave mode?
870 * PowerSave
871 * # Does android_net_wifi_set_Country_Code_Hal feature supported?
872 * HalFn_setCountryCodeHal
873 * # Does android_net_wifi_getValidChannels supported?
874 * HalFn_getValidChannels
875 */
876 const char *softap_info_items[] = {
877 "DualBandConcurrency",
878 #ifdef DHD_SOFTAP_DUAL_IF_INFO
879 "DualInterface",
880 #endif /* DHD_SOFTAP_DUAL_IF_INFO */
881 "5G", "maxClient", "PowerSave",
882 "HalFn_setCountryCodeHal", "HalFn_getValidChannels", NULL
883 };
884 #if defined(BCM4361_CHIP) || defined(BCM4375_CHIP) || defined(BCM4389_CHIP_DEF)
885 const char *softap_info_values[] = {
886 "yes",
887 #ifdef DHD_SOFTAP_DUAL_IF_INFO
888 "yes",
889 #endif /* DHD_SOFTAP_DUAL_IF_INFO */
890 "yes", "10", "yes", "yes", "yes", NULL
891 };
892 #elif defined(BCM43455_CHIP)
893 const char *softap_info_values[] = {
894 "no",
895 #ifdef DHD_SOFTAP_DUAL_IF_INFO
896 "no",
897 #endif /* DHD_SOFTAP_DUAL_IF_INFO */
898 "yes", "10", "no", "yes", "yes", NULL
899 };
900 #elif defined(BCM43430_CHIP)
901 const char *softap_info_values[] = {
902 "no",
903 #ifdef DHD_SOFTAP_DUAL_IF_INFO
904 "no",
905 #endif /* DHD_SOFTAP_DUAL_IF_INFO */
906 "no", "10", "no", "yes", "yes", NULL
907 };
908 #else
909 const char *softap_info_values[] = {
910 "UNDEF",
911 #ifdef DHD_SOFTAP_DUAL_IF_INFO
912 "UNDEF",
913 #endif /* DHD_SOFTAP_DUAL_IF_INFO */
914 "UNDEF", "UNDEF", "UNDEF", "UNDEF", "UNDEF", NULL
915 };
916 #endif /* defined(BCM4361_CHIP) || defined(BCM4375_CHIP) || defined(BCM4389_CHIP_DEF) */
917 #endif /* GEN_SOFTAP_INFO_FILE */
918
919 #ifdef GEN_SOFTAP_INFO_FILE
920 uint32 sec_save_softap_info(void)
921 {
922 #ifndef DHD_EXPORT_CNTL_FILE
923 struct file *fp = NULL;
924 char *filepath = SOFTAPINFO;
925 #endif /* DHD_EXPORT_CNTL_FILE */
926 char temp_buf[SOFTAP_INFO_BUF_SZ];
927 int ret = -1, idx = 0, rem = 0, written = 0;
928 char *pos = NULL;
929
930 DHD_TRACE(("[WIFI_SEC] %s: Entered.\n", __FUNCTION__));
931 memset(temp_buf, 0, sizeof(temp_buf));
932
933 pos = temp_buf;
934 rem = sizeof(temp_buf);
935 written = snprintf(pos, sizeof(temp_buf), "%s\n",
936 SOFTAP_INFO_FILE_FIRST_LINE);
937 do {
938 int len = strlen(softap_info_items[idx]) +
939 strlen(softap_info_values[idx]) + 2;
940 pos += written;
941 rem -= written;
942 if (len > rem) {
943 break;
944 }
945 written = snprintf(pos, rem, "%s=%s\n",
946 softap_info_items[idx], softap_info_values[idx]);
947 } while (softap_info_items[++idx] != NULL);
948
949 #ifndef DHD_EXPORT_CNTL_FILE
950 fp = filp_open(filepath, O_RDWR | O_CREAT, 0664);
951 if (IS_ERR(fp) || (fp == NULL)) {
952 DHD_ERROR(("[WIFI_SEC] %s: %s File open failed.\n",
953 SOFTAPINFO, __FUNCTION__));
954 } else {
955 ret = write_filesystem(fp, fp->f_pos, temp_buf, strlen(temp_buf));
956 DHD_INFO(("[WIFI_SEC] %s done. ret : %d\n", __FUNCTION__, ret));
957 DHD_ERROR(("[WIFI_SEC] save %s file.\n", SOFTAPINFO));
958 filp_close(fp, NULL);
959 }
960 #else
961 strlcpy(softapinfostr, temp_buf, SOFTAP_INFO_BUF_SZ);
962
963 ret = BCME_OK;
964 #endif /* !DHD_EXPORT_CNTL_FILE */
965 return ret;
966 }
967 #endif /* GEN_SOFTAP_INFO_FILE */
968 #endif /* CUSTOMER_HW4 || CUSTOMER_HW40 */
969
970 /* XXX WAR: disable pm_bcnrx , scan_ps for BCM4354 WISOL module.
971 * WISOL module have ANT_1 Rx sensitivity issue.
972 */
973 #if defined(FORCE_DISABLE_SINGLECORE_SCAN)
974 void
975 dhd_force_disable_singlcore_scan(dhd_pub_t *dhd)
976 {
977 int ret = 0;
978 struct file *fp = NULL;
979 char *filepath = PLATFORM_PATH".cid.info";
980 char vender[10] = {0, };
981 uint32 pm_bcnrx = 0;
982 uint32 scan_ps = 0;
983
984 if (BCM4354_CHIP_ID != dhd_bus_chip_id(dhd))
985 return;
986
987 fp = filp_open(filepath, O_RDONLY, 0);
988 if (IS_ERR(fp)) {
989 DHD_ERROR(("%s file open error\n", filepath));
990 } else {
991 ret = kernel_read_compat(fp, 0, (char *)vender, 5);
992
993 if (ret > 0 && NULL != strstr(vender, "wisol")) {
994 DHD_ERROR(("wisol module : set pm_bcnrx=0, set scan_ps=0\n"));
995
996 ret = dhd_iovar(dhd, 0, "pm_bcnrx", (char *)&pm_bcnrx, sizeof(pm_bcnrx),
997 NULL, 0, TRUE);
998 if (ret < 0)
999 DHD_ERROR(("Set pm_bcnrx error (%d)\n", ret));
1000
1001 ret = dhd_iovar(dhd, 0, "scan_ps", (char *)&scan_ps, sizeof(scan_ps), NULL,
1002 0, TRUE);
1003 if (ret < 0)
1004 DHD_ERROR(("Set scan_ps error (%d)\n", ret));
1005 }
1006 filp_close(fp, NULL);
1007 }
1008 }
1009 #endif /* FORCE_DISABLE_SINGLECORE_SCAN */
1010
1011 #ifdef BCM4335_XTAL_WAR
1012 bool
1013 check_bcm4335_rev(void)
1014 {
1015 int ret = -1;
1016 struct file *fp = NULL;
1017 char *filepath = "/data/.rev";
1018 char chip_rev[10] = {0, };
1019 bool is_revb0 = TRUE;
1020
1021 DHD_ERROR(("check BCM4335, check_bcm4335_rev \n"));
1022 fp = filp_open(filepath, O_RDONLY, 0);
1023
1024 if (IS_ERR(fp)) {
1025 DHD_ERROR(("/data/.rev file open error\n"));
1026 is_revb0 = TRUE;
1027 } else {
1028 DHD_ERROR(("/data/.rev file Found\n"));
1029 ret = kernel_read_compat(fp, 0, (char *)chip_rev, 9);
1030 if (ret != -1 && NULL != strstr(chip_rev, "BCM4335B0")) {
1031 DHD_ERROR(("Found BCM4335B0\n"));
1032 is_revb0 = TRUE;
1033 } else {
1034 is_revb0 = FALSE;
1035 }
1036 filp_close(fp, NULL);
1037 }
1038 return is_revb0;
1039 }
1040 #endif /* BCM4335_XTAL_WAR */
1041