1 /*
2 * Copyright (C) 2021 HiSilicon (Shanghai) Technologies CO., LIMITED.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 */
18
19 /* ****************************************************************************
20 1 头文件包含
21 **************************************************************************** */
22 #include "plat_firmware.h"
23 #include "oal_file.h"
24 #include "oal_sdio_host_if.h"
25 #if (_PRE_OS_VERSION_LINUX == _PRE_OS_VERSION)
26 #include "plat_pm.h"
27 #elif (_PRE_OS_VERSION_LITEOS == _PRE_OS_VERSION)
28 #include "plat_sdio.h"
29 #include "los_event.h"
30 #include "los_typedef.h"
31 #include "stdio.h"
32 #include "stdlib.h"
33 #include "unistd.h"
34 #include "fcntl.h"
35 #include "los_exc.h"
36 #include "oal_util.h"
37 #include "oal_time.h"
38 #ifdef _PRE_HI113X_FS_DISABLE
39 #include "plat_wifi_cfg.h"
40 #ifndef _PRE_WLAN_FEATURE_MFG_FW
41 #include "plat_rw.h"
42 #else
43 #include "plat_rw_mfg.h"
44 #endif
45 #endif
46 #endif
47 #include "oal_channel_host_if.h"
48 #include "wal_customize.h"
49 #include "wal_hipriv.h"
50 #include "oam_ext_if.h"
51 #ifdef _PRE_WLAN_FEATURE_DATA_BACKUP
52 #include "data_process.h"
53 #include "plat_data_backup.h"
54 #endif
55
56 /* ****************************************************************************
57 2 全局变量
58 **************************************************************************** */
59 #ifdef _PRE_WLAN_FEATURE_DATA_BACKUP
60 extern unsigned int g_ul_wlan_resume_wifi_init_flag;
61 #endif
62
63 #ifdef _PRE_HI113X_FS_DISABLE
64 #if (_PRE_OS_VERSION_LINUX == _PRE_OS_VERSION)
65 static hi_u8 g_firmware_array_wifi_cfg_c01[] = {
66 #include "c01/plat_wifi_cfg.h"
67 };
68
69 static hi_u8 g_firmware_array_wifi_cfg_c02[] = {
70 #include "c02/plat_wifi_cfg.h"
71 };
72
73 static hi_u8 g_firmware_array_rw_bin_c01[] = {
74 #include "c01/plat_rw.h"
75 };
76
77 static hi_u8 g_firmware_array_rw_bin_c02[] = {
78 #include "c02/plat_rw.h"
79 };
80 #endif
81
82 DECLARE_FIRMWARE_FILE(wifi_cfg_c01);
83 DECLARE_FIRMWARE_FILE(wifi_cfg_c02);
84 DECLARE_FIRMWARE_FILE(rw_bin_c01);
85 DECLARE_FIRMWARE_FILE(rw_bin_c02);
86
87 static firmware_file_stru *g_st_wifi_cfg[SOFT_VER_BUTT] = {
88 &firmware_file_wifi_cfg_c01,
89 &firmware_file_wifi_cfg_c02
90 };
91
92 static firmware_file_stru *g_st_rw_bin[SOFT_VER_BUTT] = {
93 &firmware_file_rw_bin_c01,
94 &firmware_file_rw_bin_c02
95 };
96 #endif
97
98 #define WIFI_FIRMWARE_FILE_BIN "/vendor/firmware/hisilicon/hi1131h_demo_non_rom.bin"
99
100 /* ****************************************************************************
101 2 宏定义
102 **************************************************************************** */
103 #define WIFI_CFG_C01_PATH "/vendor/firmware/hi3881/wifi_cfg"
104 #define WIFI_CFG_C02_PATH HI_NULL
105 #define RAM_CHECK_CFG_PATH HI_NULL
106 #define STORE_WIFI_MEM HI_NULL
107
108 #define FILE_COUNT_PER_SEND 1
109 #define MIN_FIRMWARE_FILE_TX_BUF_LEN 4096
110 #define MAX_FIRMWARE_FILE_TX_BUF_LEN (4*1024*1024) /* 大小4M */
111
112 #define DEVICE_EFUSE_ADDR 0x50000764
113 #define DEVICE_EFUSE_LENGTH 16
114
115 #define CFG_CMD_NUM_MAX 10 /* 支持配置的最大命令（参数）个数 */
116
117 /* ****************************************************************************
118 3 全局变量定义
119 **************************************************************************** */
120 hi_u8 *g_auc_cfg_path[SOFT_VER_BUTT] = {
121 (hi_u8 *)WIFI_CFG_C01_PATH,
122 WIFI_CFG_C02_PATH,
123 };
124
125 /* 存储cfg文件信息，解析cfg文件时赋值，加载的时候使用该变量 */
126 firmware_globals_struct g_st_cfg_info;
127 cfg_cmd_struct g_cus_cfg_cmd[CFG_CMD_NUM_MAX]; /* 存储每个cfg文件的产测校准命令 */
128 hi_u32 g_ul_jump_cmd_result = CMD_JUMP_EXEC_RESULT_SUCC;
129 efuse_info_stru g_st_efuse_info = {
130 .soft_ver = SOFT_VER_CO1,
131 .mac_h = 0x0,
132 .mac_m = 0x0,
133 .mac_l = 0x0,
134 };
135
136 /* ****************************************************************************
137 4 函数实现
138 **************************************************************************** */
139 extern hi_u32 usb_max_req_size(void);
140 static void firmware_mem_free(firmware_mem_stru *firmware_mem);
141
142 #if (_PRE_OS_VERSION_LITEOS == _PRE_OS_VERSION)
143 extern int usleep(unsigned useconds);
144 extern int32_t plat_usb_init(void);
145 extern void plat_usb_destroy(void);
146 #endif
147
148 /* ****************************************************************************
149 功能描述 : host接收device发来的消息
150 输入参数 : data: 接收消息的buffer
151 len : 接收buffer的长度
152 输出参数 : 无
153 返 回 值 : -1表示失败，否则返回实际接收的长度
154 **************************************************************************** */
firmware_read_msg(hi_u8 *data, hi_s32 len)155 static hi_s32 firmware_read_msg(hi_u8 *data, hi_s32 len)
156 {
157 hi_s32 l_len;
158
159 if (oal_unlikely((data == HI_NULL))) {
160 oam_error_log0(0, 0, "data is HI_NULL\n ");
161 return -OAL_EFAIL;
162 }
163
164 l_len = oal_bus_patch_readsb(data, len, READ_MEG_TIMEOUT);
165
166 return l_len;
167 }
168
firmware_read_msg_timeout(hi_u8 *data, hi_s32 len, hi_u32 timeout)169 static hi_s32 firmware_read_msg_timeout(hi_u8 *data, hi_s32 len, hi_u32 timeout)
170 {
171 hi_s32 l_len;
172
173 if (oal_unlikely((data == HI_NULL))) {
174 oam_error_log0(0, 0, "data is HI_NULL\n ");
175 return -OAL_EFAIL;
176 }
177
178 l_len = oal_bus_patch_readsb(data, len, timeout);
179
180 return l_len;
181 }
182
183 /* ****************************************************************************
184 功能描述 : host往device发送消息
185 输入参数 : data: 发送buffer
186 len : 发送数据的长度
187 输出参数 : 无
188 返 回 值 : -1表示失败，否则返回实际发送的长度
189 **************************************************************************** */
firmware_send_msg(hi_u8 *data, hi_s32 len)190 static hi_s32 firmware_send_msg(hi_u8 *data, hi_s32 len)
191 {
192 hi_s32 l_ret;
193
194 #ifdef HW_DEBUG
195 print_hex_dump_bytes("firmware_send_msg :", DUMP_PREFIX_ADDRESS, data, (len < 128 ? len : 128)); /* len 128 */
196 #endif
197
198 l_ret = oal_bus_patch_writesb(data, len);
199 return l_ret;
200 }
201
firmware_mem_request(void)202 static firmware_mem_stru *firmware_mem_request(void)
203 {
204 firmware_mem_stru *firmware_mem = oal_kzalloc(sizeof(firmware_mem_stru), OAL_GFP_KERNEL);
205 if (firmware_mem == HI_NULL) {
206 oam_error_log0(0, 0, "g_st_firmware_mem KMALLOC failed\n");
207 goto nomem;
208 }
209
210 #if (_PRE_FEATURE_USB == _PRE_FEATURE_CHANNEL_TYPE)
211 #if (_PRE_OS_VERSION_LITEOS == _PRE_OS_VERSION)
212 if (plat_usb_init()) {
213 oam_warning_log0(0, 0, "plat_usb_init failed\n");
214 goto nomem;
215 }
216 #endif
217 firmware_mem->ul_data_buf_len = usb_max_req_size();
218 #elif (_PRE_FEATURE_SDIO == _PRE_FEATURE_CHANNEL_TYPE)
219 firmware_mem->ul_data_buf_len = oal_sdio_func_max_req_size(oal_get_bus_default_handler());
220 oam_warning_log1(0, 0, "sdio max transmit size is [%d]\n", firmware_mem->ul_data_buf_len);
221 if (firmware_mem->ul_data_buf_len < HISDIO_BLOCK_SIZE) {
222 oam_warning_log1(0, 0, "sdio max transmit size [%d] is error!\n", firmware_mem->ul_data_buf_len);
223 goto nomem;
224 }
225 #endif
226
227 do {
228 firmware_mem->puc_data_buf = (hi_u8 *)OS_KMALLOC_GFP(firmware_mem->ul_data_buf_len);
229 if (firmware_mem->puc_data_buf == HI_NULL) {
230 oam_warning_log1(0, 0, "malloc mem len [%d] fail, continue to try in a smaller size\n",
231 firmware_mem->ul_data_buf_len);
232 firmware_mem->ul_data_buf_len = firmware_mem->ul_data_buf_len >> 1;
233 }
234 } while ((firmware_mem->puc_data_buf == HI_NULL) &&
235 (firmware_mem->ul_data_buf_len >= MIN_FIRMWARE_FILE_TX_BUF_LEN) &&
236 (firmware_mem->ul_data_buf_len <= MAX_FIRMWARE_FILE_TX_BUF_LEN));
237
238 if (firmware_mem->puc_data_buf == HI_NULL) {
239 oam_info_log0(0, 0, "puc_data_buf KMALLOC failed\n");
240 goto nomem;
241 }
242
243 firmware_mem->puc_recv_cmd_buff = (hi_u8 *)OS_KMALLOC_GFP(CMD_BUFF_LEN);
244 if (firmware_mem->puc_recv_cmd_buff == HI_NULL) {
245 oam_info_log0(0, 0, "puc_recv_cmd_buff KMALLOC failed\n");
246 goto nomem;
247 }
248
249 firmware_mem->puc_send_cmd_buff = (hi_u8 *)OS_KMALLOC_GFP(CMD_BUFF_LEN);
250 if (firmware_mem->puc_send_cmd_buff == HI_NULL) {
251 oam_info_log0(0, 0, "puc_recv_cmd_buff KMALLOC failed\n");
252 goto nomem;
253 }
254
255 return firmware_mem;
256
257 nomem:
258 firmware_mem_free(firmware_mem);
259 return HI_NULL;
260 }
261
firmware_mem_free(firmware_mem_stru *firmware_mem)262 static void firmware_mem_free(firmware_mem_stru *firmware_mem)
263 {
264 if (firmware_mem == HI_NULL) {
265 oam_error_log0(0, 0, "g_firmware_mem_mutex is null\n");
266 return;
267 }
268 if (firmware_mem->puc_send_cmd_buff != HI_NULL) {
269 oal_free(firmware_mem->puc_send_cmd_buff);
270 }
271 if (firmware_mem->puc_recv_cmd_buff != HI_NULL) {
272 oal_free(firmware_mem->puc_recv_cmd_buff);
273 }
274 if (firmware_mem->puc_data_buf != HI_NULL) {
275 oal_free(firmware_mem->puc_data_buf);
276 }
277 oal_free(firmware_mem);
278 firmware_mem = HI_NULL;
279 #if (_PRE_FEATURE_USB == _PRE_FEATURE_CHANNEL_TYPE) && (_PRE_OS_VERSION_LITEOS == _PRE_OS_VERSION)
280 plat_usb_destroy();
281 #endif
282 }
283
284 /* ****************************************************************************
285 功能描述 : 接收host期望device正确返回的内容
286 输入参数 : expect: 期望device正确返回的内容
287 输出参数 : 无
288 返 回 值 : 0表示成功，-1表示失败
289 **************************************************************************** */
recv_expect_result(const hi_u8 *expect, const firmware_mem_stru *firmware_mem)290 static hi_s32 recv_expect_result(const hi_u8 *expect, const firmware_mem_stru *firmware_mem)
291 {
292 hi_s32 l_len;
293 hi_s32 i;
294 if (expect == HI_NULL) {
295 oam_error_log0(0, 0, "recv_expect_result:expect = HI_NULL \n");
296 return -OAL_EFAIL;
297 }
298
299 if (!strlen((const hi_char *)expect)) {
300 oam_info_log0(0, 0, "not wait device to respond!\n");
301 return HI_SUCCESS;
302 }
303 if (firmware_mem == HI_NULL || firmware_mem->puc_recv_cmd_buff == HI_NULL) {
304 oam_error_log0(0, 0, "puc_recv_cmd_buff = HI_NULL \n");
305 return -OAL_EFAIL;
306 }
307 memset_s(firmware_mem->puc_recv_cmd_buff, CMD_BUFF_LEN, 0, CMD_BUFF_LEN);
308 for (i = 0; i < HOST_DEV_TIMEOUT; i++) {
309 l_len = firmware_read_msg(firmware_mem->puc_recv_cmd_buff, CMD_BUFF_LEN);
310 if (l_len < 0) {
311 oam_error_log0(0, 0, "recv result fail\n");
312 return -OAL_EFAIL;
313 }
314 if (!memcmp(firmware_mem->puc_recv_cmd_buff, expect, strlen((const hi_char *)expect))) {
315 return HI_SUCCESS;
316 } else {
317 oam_error_log2(0, 0, " error result[%s], expect [%s], read result again",
318 (uintptr_t)firmware_mem->puc_recv_cmd_buff, (uintptr_t)expect);
319 }
320 }
321
322 return -OAL_EFAIL;
323 }
324
recv_expect_result_timeout(const hi_u8 *expect, const firmware_mem_stru *firmware_mem, hi_u32 timeout)325 static hi_s32 recv_expect_result_timeout(const hi_u8 *expect, const firmware_mem_stru *firmware_mem, hi_u32 timeout)
326 {
327 hi_s32 l_len;
328
329 if (expect == HI_NULL) {
330 oam_error_log0(0, 0, "recv_expect_result_timeout:expect = HI_NULL \n");
331 return -OAL_EFAIL;
332 }
333
334 if (!strlen((const hi_char *)expect)) {
335 oam_info_log0(0, 0, "not wait device to respond!\n");
336 return HI_SUCCESS;
337 }
338
339 memset_s(firmware_mem->puc_recv_cmd_buff, CMD_BUFF_LEN, 0, CMD_BUFF_LEN);
340 l_len = firmware_read_msg_timeout(firmware_mem->puc_recv_cmd_buff, CMD_BUFF_LEN, timeout);
341 if (l_len < 0) {
342 oam_error_log0(0, 0, "recv result fail\n");
343 return -OAL_EFAIL;
344 }
345
346 if (!memcmp(firmware_mem->puc_recv_cmd_buff, expect, strlen((const hi_char *)expect))) {
347 oam_info_log1(0, 0, " send HI_SUCCESS, expect [%s] ok\n", (uintptr_t)expect);
348 return HI_SUCCESS;
349 } else {
350 oam_error_log2(0, 0, " error result[%s], expect [%s], read result again\n", firmware_mem->puc_recv_cmd_buff,
351 expect);
352 }
353 return -OAL_EFAIL;
354 }
355
356 /* ****************************************************************************
357 功能描述 : host向device发送消息并等待device返回消息
358 输入参数 : data : 发送buffer
359 len : 发送内容的长度
360 expect: 期望device回复的内容
361 输出参数 : 无
362 返 回 值 : -1表示失败，0表示成功
363 **************************************************************************** */
msg_send_and_recv_except(hi_u8 *data, hi_s32 len, const hi_u8 *expect, const firmware_mem_stru *firmware_mem)364 static hi_s32 msg_send_and_recv_except(hi_u8 *data, hi_s32 len, const hi_u8 *expect,
365 const firmware_mem_stru *firmware_mem)
366 {
367 hi_s32 i;
368 hi_s32 l_ret;
369
370 for (i = 0; i < HOST_DEV_TIMEOUT; i++) {
371 l_ret = firmware_send_msg(data, len);
372 if (l_ret < 0) {
373 continue;
374 }
375
376 l_ret = recv_expect_result(expect, firmware_mem);
377 if (l_ret == 0) {
378 return HI_SUCCESS;
379 }
380 }
381 return -OAL_EFAIL;
382 }
383
384 /* ****************************************************************************
385 功能描述 : 解析cfg文件，将解析的结果保存在g_st_cfg_info全局变量中
386 输入参数 : puc_cfg_info_buf: 保存有cfg文件内容的buffer
387 ul_index : 保存解析结果的数组索引值
388 输出参数 : 无
389 返 回 值 : NULL表示分配内存失败，否则返回指向保存解析cfg文件命令数组的首地址
390 **************************************************************************** */
malloc_cmd_buf(hi_u8 *puc_cfg_info_buf, hi_u32 ul_index)391 static void *malloc_cmd_buf(hi_u8 *puc_cfg_info_buf, hi_u32 ul_index)
392 {
393 hi_u32 l_len;
394 hi_u8 *flag = HI_NULL;
395 hi_u8 *p_buf = HI_NULL;
396
397 if (puc_cfg_info_buf == HI_NULL) {
398 oam_error_log0(0, 0, "malloc_cmd_buf: buf is HI_NULL!\n");
399 return HI_NULL;
400 }
401
402 /* 统计命令个数 */
403 flag = puc_cfg_info_buf;
404 g_st_cfg_info.al_count[ul_index] = 0;
405 while (flag != HI_NULL) {
406 /* 一个正确的命令行结束符为 ; */
407 flag = (hi_u8 *)strchr((const hi_char *)flag, CMD_LINE_SIGN);
408 if (flag == HI_NULL) {
409 break;
410 }
411 g_st_cfg_info.al_count[ul_index]++;
412 flag++;
413 }
414 oam_info_log2(0, 0, "cfg file cmd count: al_count[%d] = %d", ul_index, g_st_cfg_info.al_count[ul_index]);
415
416 /* 申请存储命令空间 */
417 l_len = ((g_st_cfg_info.al_count[ul_index]) + CFG_INFO_RESERVE_LEN) * sizeof(struct cmd_type_st);
418
419 p_buf = OS_KMALLOC_GFP(l_len);
420 if (p_buf == HI_NULL) {
421 oam_error_log0(0, 0, "kmalloc cmd_type_st fail\n");
422 return HI_NULL;
423 }
424 memset_s((void *)p_buf, l_len, 0, l_len);
425
426 return p_buf;
427 }
428
429 /* ****************************************************************************
430 功能描述 : 删除字符串两边多余的空格
431 输入参数 : string: 原始字符串
432 len : 字符串的长度
433 输出参数 : 无
434 返 回 值 : 错误返回NULL，否则返回删除两边空格以后字符串的首地址
435 **************************************************************************** */
delete_space(hi_u8 *string, hi_s32 *len)436 static hi_u8 *delete_space(hi_u8 *string, hi_s32 *len)
437 {
438 int i;
439
440 if ((string == HI_NULL) || (len == HI_NULL)) {
441 return HI_NULL;
442 }
443
444 /* 删除尾部的空格 */
445 for (i = *len - 1; i >= 0; i--) {
446 if (string[i] != COMPART_KEYWORD) {
447 break;
448 }
449 string[i] = '\0';
450 }
451 /* 出错 */
452 if (i < 0) {
453 oam_error_log0(0, 0, " string is Space bar\n");
454 return HI_NULL;
455 }
456 /* 在for语句中减去1，这里加上1 */
457 *len = i + 1;
458
459 /* 删除头部的空格 */
460 for (i = 0; i < *len; i++) {
461 if (string[i] != COMPART_KEYWORD) {
462 /* 减去空格的个数 */
463 *len = *len - i;
464 return &string[i];
465 }
466 }
467
468 return HI_NULL;
469 }
470
471 /* ************************************************************************************
472 功能描述 : 打开文件，保存read mem读上来的内容
473 输入参数 : 无
474 输出参数 : 无
475 返 回 值 : 返回打开文件的描述符
476 ************************************************************************************ */
open_file_to_readm(hi_u8 *name)477 static oal_file_stru *open_file_to_readm(hi_u8 *name)
478 {
479 oal_file_stru *fp = HI_NULL;
480 hi_u8 *file_name = HI_NULL;
481
482 if (OAL_WARN_ON(name == HI_NULL)) {
483 file_name = (hi_u8 *)"/data/memdump/readm_wifi";
484 } else {
485 file_name = name;
486 }
487 fp = oal_file_open((const hi_char *)file_name, (OAL_O_CREAT | OAL_O_RDWR | OAL_O_TRUNC), 0);
488
489 return fp;
490 }
491
492 /* ************************************************************************************
493 功能描述 : 接收device发送上来的内存，保存到指定的文件中
494 输入参数 : fp : 保存内存的文件指针
495 len: 需要保存的内存的长度
496 输出参数 : 无
497 返 回 值 : -1表示失败，否则返回实际保存的内存的长度
498 ************************************************************************************ */
recv_device_mem(oal_file_stru *fp, hi_u8 *puc_data_buf, hi_s32 len)499 static hi_s32 recv_device_mem(oal_file_stru *fp, hi_u8 *puc_data_buf, hi_s32 len)
500 {
501 hi_s32 l_ret = 0;
502 hi_u8 retry = 3;
503 hi_s32 lenbuf = 0;
504
505 if (IS_ERR_OR_NULL(fp)) {
506 oam_error_log1(0, 0, "fp is error,fp = 0x%p\n", (uintptr_t)fp);
507 return -OAL_EFAIL;
508 }
509
510 if (puc_data_buf == HI_NULL) {
511 oam_error_log0(0, 0, "puc_data_buf is HI_NULL\n");
512 return -OAL_EFAIL;
513 }
514
515 oam_info_log1(0, 0, "expect recv len is [%d]\n", len);
516
517 while (len > lenbuf) {
518 l_ret = firmware_read_msg(puc_data_buf + lenbuf, len - lenbuf);
519 if (l_ret > 0) {
520 lenbuf += l_ret;
521 } else {
522 retry--;
523 lenbuf = 0;
524 if (0 == retry) {
525 l_ret = -OAL_EFAIL;
526 oam_error_log0(0, 0, "time out\n");
527 break;
528 }
529 }
530 }
531
532 if (len <= lenbuf) {
533 oal_file_write(fp, (hi_char *)puc_data_buf, len);
534 }
535
536 return l_ret;
537 }
538
539 /* ************************************************************************************
540 功能描述 : 发送命令读device版本号，并检查device上报的版本号和host的版本号是否匹配
541 输入参数 : 无
542 输出参数 : 无
543 返 回 值 : -1表示失败，0表示成功
544 ************************************************************************************ */
check_version(const firmware_mem_stru *firmware_mem)545 static hi_s32 check_version(const firmware_mem_stru *firmware_mem)
546 {
547 hi_s32 l_ret;
548 size_t l_len;
549 hi_s32 i;
550
551 if (firmware_mem == HI_NULL || firmware_mem->puc_recv_cmd_buff == HI_NULL ||
552 firmware_mem->puc_send_cmd_buff == HI_NULL) {
553 oam_error_log0(0, 0, "MEM IS HI_NULL \n");
554 return -OAL_EFAIL;
555 }
556
557 for (i = 0; i < HOST_DEV_TIMEOUT; i++) {
558 if ((memset_s(firmware_mem->puc_send_cmd_buff, CMD_BUFF_LEN, 0, CMD_BUFF_LEN) != EOK) ||
559 (memcpy_s(firmware_mem->puc_send_cmd_buff, strlen(VER_CMD_KEYWORD), (hi_u8 *)VER_CMD_KEYWORD,
560 strlen(VER_CMD_KEYWORD)) != EOK)) {
561 continue;
562 }
563 l_len = strlen(VER_CMD_KEYWORD);
564
565 firmware_mem->puc_send_cmd_buff[l_len] = COMPART_KEYWORD;
566 l_len++;
567
568 l_len = HISDIO_ALIGN_4_OR_BLK(l_len + 1);
569
570 l_ret = firmware_send_msg(firmware_mem->puc_send_cmd_buff, l_len);
571 if (l_ret < 0) {
572 oam_warning_log1(0, 0, "send version fail![%d]\n", i);
573 continue;
574 }
575 if (memset_s(g_st_cfg_info.auc_DevVersion, VERSION_LEN, 0, VERSION_LEN) != EOK ||
576 memset_s(firmware_mem->puc_recv_cmd_buff, CMD_BUFF_LEN, 0, CMD_BUFF_LEN) != EOK) {
577 continue;
578 }
579
580 l_ret = firmware_read_msg(firmware_mem->puc_recv_cmd_buff, CMD_BUFF_LEN);
581 if (l_ret < 0) {
582 oam_warning_log1(0, 0, "read version fail![%d]\n", i);
583 continue;
584 }
585 if (memcpy_s(g_st_cfg_info.auc_DevVersion, VERSION_LEN, firmware_mem->puc_recv_cmd_buff, VERSION_LEN) != EOK) {
586 continue;
587 }
588 if (!memcmp((hi_char *)g_st_cfg_info.auc_DevVersion, (hi_char *)g_st_cfg_info.auc_CfgVersion,
589 strlen((const hi_char *)g_st_cfg_info.auc_CfgVersion))) {
590 oam_warning_log2(0, 0, "HI_SUCCESS: Device Version=[%s], CfgVersion=[%s].",
591 (uintptr_t)g_st_cfg_info.auc_DevVersion, (uintptr_t)g_st_cfg_info.auc_CfgVersion);
592 return HI_SUCCESS;
593 } else {
594 oam_error_log2(0, 0, "ERROR version,Device Version=[%s], CfgVersion=[%s].", g_st_cfg_info.auc_DevVersion,
595 g_st_cfg_info.auc_CfgVersion);
596 return -OAL_EFAIL;
597 }
598 }
599
600 return -OAL_EFAIL;
601 }
602
603 /* ****************************************************************************
604 功能描述 : 处理number类型的命令，并发送到device
605 输入参数 : key : 命令的关键字
606 val: 命令的参数
607 输出参数 : 无
608 返 回 值 : -1表示失败，非零表示成功
609 **************************************************************************** */
number_type_cmd_send(hi_u8 *key, hi_u8 *val, const firmware_mem_stru *firmware_mem)610 static hi_s32 number_type_cmd_send(hi_u8 *key, hi_u8 *val, const firmware_mem_stru *firmware_mem)
611 {
612 hi_s32 l_ret;
613 hi_u32 data_len;
614 hi_u32 value_len;
615 hi_u32 i;
616 hi_u32 n;
617 #define RESERVED_BYTES 10
618
619 if (firmware_mem == HI_NULL || firmware_mem->puc_recv_cmd_buff == HI_NULL ||
620 firmware_mem->puc_send_cmd_buff == HI_NULL) {
621 oam_error_log0(0, 0, "MEM IS HI_NULL \n");
622 return -OAL_EFAIL;
623 }
624
625 if (CMD_BUFF_LEN < strlen((const hi_char *)key) + strlen((const hi_char *)val) + RESERVED_BYTES) {
626 oam_error_log2(0, 0, "the cmd string must be error, key=%s, vlaue=%s \n", (uintptr_t)key, (uintptr_t)val);
627 return -OAL_EFAIL;
628 }
629
630 value_len = strlen((hi_char *)val);
631
632 if (memset_s(firmware_mem->puc_recv_cmd_buff, CMD_BUFF_LEN, 0, CMD_BUFF_LEN) != EOK ||
633 memset_s(firmware_mem->puc_send_cmd_buff, CMD_BUFF_LEN, 0, CMD_BUFF_LEN) != EOK) {
634 return -OAL_EFAIL;
635 }
636
637 data_len = (hi_s32)strlen((const hi_char *)key);
638 if (memcpy_s(firmware_mem->puc_send_cmd_buff, data_len, key, data_len) != EOK) {
639 return -OAL_EFAIL;
640 }
641
642 firmware_mem->puc_send_cmd_buff[data_len] = COMPART_KEYWORD;
643 data_len = data_len + 1;
644
645 for (i = 0, n = 0; (i <= value_len) && (n < INT32_STR_LEN); i++) {
646 if ((val[i] == ',') || (i == value_len)) {
647 if (n == 0) {
648 continue;
649 }
650 if (memcpy_s((hi_u8 *)&firmware_mem->puc_send_cmd_buff[data_len], n,
651 firmware_mem->puc_recv_cmd_buff, n) != EOK) {
652 return -OAL_EFAIL;
653 }
654 data_len = data_len + n;
655
656 firmware_mem->puc_send_cmd_buff[data_len] = COMPART_KEYWORD;
657 data_len = data_len + 1;
658
659 memset_s(firmware_mem->puc_recv_cmd_buff, INT32_STR_LEN, 0, INT32_STR_LEN);
660 n = 0;
661 } else if (val[i] == COMPART_KEYWORD) {
662 continue;
663 } else {
664 firmware_mem->puc_recv_cmd_buff[n] = val[i];
665 n++;
666 }
667 }
668 firmware_mem->puc_send_cmd_buff[data_len + 1] = '\0';
669 l_ret = firmware_send_msg(firmware_mem->puc_send_cmd_buff, data_len);
670
671 return l_ret;
672 }
673
674 /* ****************************************************************************
675 功能描述 : 解析file命令参数
676 输入参数 : string : file命令的参数
677 addr : 发送的数据地址
678 file_path: 发送文件的路径
679 输出参数 : 无
680 返 回 值 : -1表示失败，0表示成功
681 **************************************************************************** */
parse_file_cmd(hi_u8 *string, unsigned long *addr, hi_char **file_path)682 static hi_s32 parse_file_cmd(hi_u8 *string, unsigned long *addr, hi_char **file_path)
683 {
684 hi_char *tmp = HI_NULL;
685 hi_size_t count;
686 hi_char *after = HI_NULL;
687 #define DECIMAL_ALGORITHM 10
688
689 if (string == HI_NULL || addr == HI_NULL || file_path == HI_NULL) {
690 oam_error_log0(0, 0, "param is error!\n");
691 return -OAL_EFAIL;
692 }
693
694 /* 获得发送的文件的个数，此处必须为1，string字符串的格式必须是"1,0xXXXXX,file_path" */
695 tmp = (hi_char *)string;
696 hi_u32 cnt = 0;
697 while ((cnt < DOWNLOAD_CMD_PARA_LEN) && (*tmp == COMPART_KEYWORD)) {
698 tmp++;
699 cnt++;
700 }
701 count = oal_simple_strtoul(tmp, HI_NULL, DECIMAL_ALGORITHM);
702 if (count != FILE_COUNT_PER_SEND) {
703 oam_error_log1(0, 0, "the count of send file must be 1, count = [%d]\n", count);
704 return -OAL_EFAIL;
705 }
706
707 /* 让tmp指向地址的首字母 */
708 tmp = strchr((const hi_char *)string, ',');
709 if (tmp == HI_NULL) {
710 oam_error_log0(0, 0, "param string is err!\n");
711 return -OAL_EFAIL;
712 } else {
713 tmp++;
714 while (((tmp - (hi_char *)string) < DOWNLOAD_CMD_PARA_LEN) && (*tmp == COMPART_KEYWORD)) {
715 tmp++;
716 }
717 }
718
719 *addr = oal_simple_strtoul((hi_char *)tmp, &after, 16); /* base 16 */
720 oam_info_log1(0, 0, "file to send addr:[0x%lx]", *addr);
721
722 /* "1,0xXXXX,file_path" */
723 /* ^ */
724 /* after */
725 after++;
726 while (((after - (hi_char *)string) < DOWNLOAD_CMD_PARA_LEN) && (*after == COMPART_KEYWORD)) {
727 after++;
728 }
729
730 *file_path = after;
731
732 return HI_SUCCESS;
733 }
734
735
736 /* ****************************************************************************
737 功能描述 : 当device处于bootloader时从DEVICE读取内存
738 输入参数 : 无
739 输出参数 : 无
740 返 回 值 : 小于0表示失败
741 **************************************************************************** */
read_device_mem(const wifi_dump_mem_info_stru *mem_dump_info, oal_file_stru *fp, const firmware_mem_stru *firmware_mem)742 static hi_s32 read_device_mem(const wifi_dump_mem_info_stru *mem_dump_info, oal_file_stru *fp,
743 const firmware_mem_stru *firmware_mem)
744 {
745 hi_s32 ret = 0;
746 hi_u32 size = 0;
747 hi_u32 remainder = mem_dump_info->size;
748
749 if (firmware_mem == HI_NULL || firmware_mem->puc_send_cmd_buff == HI_NULL) {
750 oam_error_log0(0, 0, "puc_send_cmd_buff = HI_NULL \n");
751 return -OAL_EFAIL;
752 }
753 while (remainder > 0) {
754 memset_s(firmware_mem->puc_send_cmd_buff, CMD_BUFF_LEN, 0, CMD_BUFF_LEN);
755
756 size = oal_min(remainder, firmware_mem->ul_data_buf_len);
757
758 oam_info_log1(0, 0, "read mem cmd:[%s]\n", (uintptr_t)firmware_mem->puc_send_cmd_buff);
759 ret = firmware_send_msg(firmware_mem->puc_send_cmd_buff,
760 strlen((const hi_char *)firmware_mem->puc_send_cmd_buff));
761 if (ret < 0) {
762 oam_warning_log2(0, 0, "wifi mem dump fail, mem_addr is [0x%lx],ret=%d\n", mem_dump_info->mem_addr, ret);
763 break;
764 }
765
766 ret = recv_device_mem(fp, firmware_mem->puc_data_buf, size);
767 if (ret < 0) {
768 oam_warning_log2(0, 0, "wifi mem dump fail, mem_addr is [0x%lx],ret=%d\n", mem_dump_info->mem_addr, ret);
769 break;
770 }
771
772 remainder -= size;
773 }
774
775 return ret;
776 }
777
read_mem(hi_u8 *key, const hi_u8 *val, const firmware_mem_stru *firmware_mem)778 static hi_s32 read_mem(hi_u8 *key, const hi_u8 *val, const firmware_mem_stru *firmware_mem)
779 {
780 hi_unref_param(key);
781 hi_s32 l_ret;
782 hi_size_t size;
783 hi_char *flag = HI_NULL;
784 oal_file_stru *fp = HI_NULL;
785 struct wifi_dump_mem_info_stru read_memory;
786 memset_s(&read_memory, sizeof(struct wifi_dump_mem_info_stru), 0, sizeof(struct wifi_dump_mem_info_stru));
787
788 flag = strchr((const hi_char *)val, ',');
789 if (flag == HI_NULL) {
790 oam_error_log0(0, 0, "RECV LEN ERROR..\n");
791 return -OAL_EFAIL;
792 }
793 if (firmware_mem == HI_NULL || firmware_mem->puc_data_buf == HI_NULL) {
794 oam_error_log0(0, 0, "MEM IS HI_NULL \n");
795 return -OAL_EFAIL;
796 }
797
798 flag++;
799 oam_info_log1(0, 0, "recv len [%s]\n", flag);
800 while (((flag - (hi_char *)key) < DOWNLOAD_CMD_LEN) && (*flag == COMPART_KEYWORD)) {
801 flag++;
802 }
803 size = oal_simple_strtoul(flag, HI_NULL, 10); /* base 10: DEC */
804
805 fp = open_file_to_readm(HI_NULL);
806 if (IS_ERR_OR_NULL(fp)) {
807 oam_error_log1(0, 0, "create file error,fp = 0x%p\n", (uintptr_t)fp);
808 return -OAL_EFAIL;
809 }
810
811 read_memory.mem_addr = oal_simple_strtoul((const hi_char *)val, HI_NULL, 16); /* base 16 */
812 read_memory.size = (hi_u32)size;
813 l_ret = read_device_mem(&read_memory, fp, firmware_mem);
814
815 oal_file_close(fp);
816
817 return l_ret;
818 }
819
820 /* ****************************************************************************
821 功能描述 : 执行number类型的命令
822 输入参数 : key : 命令的关键字
823 val: 命令的参数
824 输出参数 : 无
825 返 回 值 : -1表示失败，0表示成功
826 **************************************************************************** */
exec_number_type_cmd(hi_u8 *key, hi_u8 *val, firmware_mem_stru *firmware_mem)827 static hi_s32 exec_number_type_cmd(hi_u8 *key, hi_u8 *val, firmware_mem_stru *firmware_mem)
828 {
829 hi_s32 l_ret = -OAL_EFAIL;
830
831 if (key == HI_NULL) {
832 oam_error_log0(0, 0, "exec_number_type_cmd key null\n");
833 return -OAL_EFAIL;
834 }
835
836 if (!memcmp(key, VER_CMD_KEYWORD, strlen(VER_CMD_KEYWORD))) {
837 l_ret = check_version(firmware_mem);
838 if (l_ret < 0) {
839 oam_error_log1(0, 0, "check version FAIL [%d]\n", l_ret);
840 return -OAL_EFAIL;
841 }
842 }
843
844 if (!strcmp((hi_char *)key, WMEM_CMD_KEYWORD)) {
845 l_ret = number_type_cmd_send(key, val, firmware_mem);
846 if (l_ret < 0) {
847 goto ret_err;
848 }
849
850 l_ret = recv_expect_result((const hi_u8 *)MSG_FROM_DEV_WRITEM_OK, firmware_mem);
851 if (l_ret < 0) {
852 oam_error_log0(0, 0, "recv expect result fail!\n");
853 return l_ret;
854 }
855 } else if (!strcmp((hi_char *)key, CONFIG_CMD_KEYWORD)) {
856 l_ret = number_type_cmd_send(key, val, firmware_mem);
857 if (l_ret < 0) {
858 goto ret_err;
859 }
860
861 l_ret = recv_expect_result((const hi_u8 *)MSG_FROM_DEV_CONFIG_OK, firmware_mem);
862 if (l_ret < 0) {
863 oam_print_err("recv expect result fail!\n");
864 return l_ret;
865 }
866 } else if (!strcmp((hi_char *)key, JUMP_CMD_KEYWORD)) {
867 g_ul_jump_cmd_result = CMD_JUMP_EXEC_RESULT_SUCC;
868 l_ret = number_type_cmd_send(key, val, firmware_mem);
869 if (l_ret < 0) {
870 goto ret_err;
871 }
872
873 /* 100000ms timeout */
874 l_ret = recv_expect_result_timeout((const hi_u8 *)MSG_FROM_DEV_JUMP_OK, firmware_mem, READ_MEG_JUMP_TIMEOUT);
875 if (l_ret >= 0) {
876 return l_ret;
877 } else {
878 g_ul_jump_cmd_result = CMD_JUMP_EXEC_RESULT_FAIL;
879 return l_ret;
880 }
881 } else if (!strcmp((hi_char *)key, RMEM_CMD_KEYWORD)) {
882 l_ret = read_mem(key, val, firmware_mem);
883 }
884 return l_ret;
885 ret_err:
886 oam_error_log2(0, 0, "send key=[%s],value=[%s] fail\n", (uintptr_t)key, (uintptr_t)val);
887 return l_ret;
888 }
889
890
891 /* ****************************************************************************
892 功能描述 : 执行quit类型的命令
893 输入参数 : 无
894 输出参数 : 无
895 返 回 值 : -1表示失败，0表示成功
896 **************************************************************************** */
exec_quit_type_cmd(firmware_mem_stru *firmware_mem)897 static hi_s32 exec_quit_type_cmd(firmware_mem_stru *firmware_mem)
898 {
899 hi_s32 l_ret;
900 hi_u32 l_len;
901
902 if (firmware_mem == HI_NULL || firmware_mem->puc_send_cmd_buff == HI_NULL) {
903 oam_error_log0(0, 0, "puc_send_cmd_buff = HI_NULL \n");
904 return -OAL_EFAIL;
905 }
906
907 if (memset_s(firmware_mem->puc_send_cmd_buff, CMD_BUFF_LEN, 0, 8) != EOK) { /* 8: 清8个长度 */
908 return -OAL_EFAIL;
909 } /* buffer len 8 */
910
911 if (memcpy_s(firmware_mem->puc_send_cmd_buff, strlen(QUIT_CMD_KEYWORD), (hi_u8 *)QUIT_CMD_KEYWORD,
912 strlen(QUIT_CMD_KEYWORD)) != EOK) {
913 return -OAL_EFAIL;
914 }
915 l_len = strlen(QUIT_CMD_KEYWORD);
916
917 firmware_mem->puc_send_cmd_buff[l_len] = COMPART_KEYWORD;
918 l_len++;
919
920 l_ret = msg_send_and_recv_except(firmware_mem->puc_send_cmd_buff, l_len, (const hi_u8 *)MSG_FROM_DEV_QUIT_OK,
921 firmware_mem);
922
923 return l_ret;
924 }
925
926 #ifndef _PRE_HI113X_FS_DISABLE
927 int g_fw_mode = FIRMWARE_BIN; /* 默认业务bin */
928 module_param(g_fw_mode, int, 0644);
929 /* ****************************************************************************
930 功能描述 : 执行file类型的命令
931 输入参数 : key : 命令的关键字
932 val: 命令的参数
933 输出参数 : 无
934 返 回 值 : -1表示失败，0表示成功
935 **************************************************************************** */
exec_file_type_cmd(hi_u8 *key, hi_u8 *val, firmware_mem_stru *firmware_mem)936 static hi_s32 exec_file_type_cmd(hi_u8 *key, hi_u8 *val, firmware_mem_stru *firmware_mem)
937 {
938 hi_unref_param(key);
939 unsigned long addr;
940 hi_u32 addr_send;
941 hi_char *path = HI_NULL;
942 hi_s32 ret;
943 hi_u32 file_len;
944 hi_u32 per_send_len;
945 hi_u32 send_count;
946 hi_s32 rdlen;
947 hi_u32 i;
948 hi_u32 offset = 0;
949 oal_file_stru *fp = HI_NULL;
950 hi_s32 verify_stage = 0;
951
952 if (firmware_mem == HI_NULL || firmware_mem->puc_send_cmd_buff == HI_NULL ||
953 firmware_mem->puc_data_buf == HI_NULL) {
954 oam_error_log0(0, 0, "exec_file_type_cmd:: mem is HI_NULL");
955 return -OAL_EFAIL;
956 }
957
958 ret = parse_file_cmd(val, &addr, &path);
959 if (ret < 0) {
960 oam_error_log0(0, 0, "exec_file_type_cmd:: parse file cmd fail");
961 return ret;
962 }
963 if (g_fw_mode == MFG_FIRMWARE_BIN) {
964 path = "/vendor/firmware/hisilicon/hi3881_mfg_fw.bin";
965 }
966 fp = oal_file_open(path, (OAL_O_RDONLY), 0);
967 if (IS_ERR_OR_NULL(fp)) {
968 oam_error_log2(0, 0, "exec_file_type_cmd:: filp_open [%s] fail!!, fp=%p", path, fp);
969 return -OAL_EFAIL;
970 }
971 set_under_mfg(g_fw_mode); /* 保存当前firmware模式 */
972 /* 获取file文件大小 */
973 file_len = oal_file_lseek(fp, 0, OAL_SEEK_END);
974
975 /* 恢复fp->f_pos到文件开头 */
976 oal_file_lseek(fp, 0, OAL_SEEK_SET);
977
978 oam_info_log2(0, 0, "exec_file_type_cmd:: file len is [%d],firmware_mem->ul_data_buf_len=%d", file_len,
979 firmware_mem->ul_data_buf_len);
980
981 per_send_len = (firmware_mem->ul_data_buf_len > file_len) ? file_len : firmware_mem->ul_data_buf_len;
982 if (per_send_len == 0) {
983 oam_error_log0(0, 0, "per_send_len == 0");
984 oal_file_close(fp);
985 return -OAL_EFAIL;
986 }
987 send_count = (file_len + per_send_len - 1) / per_send_len;
988 oam_info_log1(0, 0, "exec_file_type_cmd:: send_count=%d", send_count);
989
990 for (i = 0; i < send_count; i++) {
991 rdlen = oal_file_read(fp, firmware_mem->puc_data_buf, per_send_len);
992 if (rdlen > 0) {
993 oam_info_log2(0, 0, "exec_file_type_cmd:: len of kernel_read is [%d], i=%d", rdlen, i);
994 #if (_PRE_OS_VERSION_LINUX == _PRE_OS_VERSION)
995 OAL_FILE_POS(fp) += rdlen;
996 #endif
997 } else {
998 oam_error_log2(0, 0, "exec_file_type_cmd:: len of kernel_read is error! ret=[%d], i=%d", rdlen, i);
999 oal_file_close(fp);
1000 return -OAL_EFAIL;
1001 }
1002
1003 addr_send = (hi_u32)(addr + offset);
1004 oam_info_log2(0, 0, "exec_file_type_cmd:: send addr is [0x%x], i=%d", addr_send, i);
1005
1006 if (offset == 0 && offset + rdlen == file_len) {
1007 verify_stage = 3; /* 3:start and end. */
1008 } else if (offset == 0) {
1009 verify_stage = 0; /* start trans. */
1010 } else if (offset + rdlen == file_len) {
1011 verify_stage = 2; /* 2:end trans. */
1012 } else {
1013 verify_stage = 1; /* transferring. */
1014 }
1015
1016 if (snprintf_s((hi_char *)firmware_mem->puc_send_cmd_buff, CMD_BUFF_LEN, CMD_BUFF_LEN - 1,
1017 "%s%c0x%x%c0x%x%c%d%c", FILES_CMD_KEYWORD, COMPART_KEYWORD, addr_send, COMPART_KEYWORD, rdlen,
1018 COMPART_KEYWORD, verify_stage, COMPART_KEYWORD) == -1) {
1019 return -OAL_EFAIL;
1020 }
1021
1022 /* 发送地址 */
1023 oam_info_log1(0, 0, "exec_file_type_cmd:: send file addr cmd is [%s]", firmware_mem->puc_send_cmd_buff);
1024 ret = msg_send_and_recv_except(firmware_mem->puc_send_cmd_buff,
1025 strlen((hi_char *)firmware_mem->puc_send_cmd_buff), (const hi_u8 *)MSG_FROM_DEV_READY_OK, firmware_mem);
1026 if (ret < 0) {
1027 oam_error_log1(0, 0, "exec_file_type_cmd:: SEND [%s] error", (uintptr_t)firmware_mem->puc_send_cmd_buff);
1028 oal_file_close(fp);
1029 return -OAL_EFAIL;
1030 }
1031 /* Wait at least 5 ms */
1032 #if (_PRE_OS_VERSION_LINUX == _PRE_OS_VERSION)
1033 usleep_range(FILE_CMD_WAIT_TIME_MIN, FILE_CMD_WAIT_TIME_MAX);
1034 #elif (_PRE_OS_VERSION_LITEOS == _PRE_OS_VERSION)
1035 usleep(FILE_CMD_WAIT_TIME_MIN);
1036 #endif
1037 /* 发送文件内容 */
1038 ret = msg_send_and_recv_except(firmware_mem->puc_data_buf, rdlen, (const hi_u8 *)MSG_FROM_DEV_FILES_OK,
1039 firmware_mem);
1040 if (ret < 0) {
1041 oam_error_log0(0, 0, "exec_file_type_cmd:: send data fail");
1042 oal_file_close(fp);
1043 return -OAL_EFAIL;
1044 }
1045
1046 offset += rdlen;
1047 }
1048 oal_file_close(fp);
1049 /* 发送的长度要和文件的长度一致 */
1050 if (offset != file_len) {
1051 oam_error_log2(0, 0, "exec_file_type_cmd:: send len[%d] is different with file_len[%d]", offset, file_len);
1052 return -OAL_EFAIL;
1053 }
1054
1055 return HI_SUCCESS;
1056 }
1057 #else
exec_file_type_cmd(hi_u8 *key, hi_u8 *val, firmware_mem_stru *firmware_mem)1058 static hi_s32 exec_file_type_cmd(hi_u8 *key, hi_u8 *val, firmware_mem_stru *firmware_mem)
1059 {
1060 hi_unref_param(key);
1061 unsigned long addr;
1062 hi_u32 addr_send;
1063 hi_char *path = HI_NULL;
1064 hi_s32 ret;
1065 hi_u32 file_len;
1066 hi_u32 per_send_len;
1067 hi_s32 rdlen;
1068 hi_u32 offset = 0;
1069 hi_u32 file_len_count;
1070 hi_u32 ul_soft_ver;
1071 hi_s32 verify_stage = 0;
1072
1073 if (firmware_mem == HI_NULL || firmware_mem->puc_data_buf == HI_NULL ||
1074 firmware_mem->puc_send_cmd_buff == HI_NULL) {
1075 oam_error_log0(0, 0, "mem is HI_NULL \n");
1076 return -OAL_EFAIL;
1077 }
1078
1079 ul_soft_ver = get_device_soft_version();
1080 if (ul_soft_ver >= SOFT_VER_BUTT) {
1081 oam_error_log0(0, 0, "device soft version is invalid!\n");
1082 return -OAL_EFAIL;
1083 }
1084
1085 ret = parse_file_cmd(val, &addr, &path);
1086 if (ret < 0) {
1087 oam_error_log0(0, 0, "parse file cmd fail!\n");
1088 return ret;
1089 }
1090
1091 oam_info_log1(0, 0, "download firmware:%s", path);
1092
1093 file_len = g_st_rw_bin[ul_soft_ver]->len;
1094 file_len_count = file_len;
1095
1096 oam_info_log2(0, 0, "file len is [%d],firmware_mem->ulDataBufLen=%d", file_len, firmware_mem->ul_data_buf_len);
1097
1098 per_send_len = (firmware_mem->ul_data_buf_len > file_len) ? file_len : firmware_mem->ul_data_buf_len;
1099
1100 while (file_len_count > 0) {
1101 rdlen = per_send_len < file_len_count ? per_send_len : file_len_count;
1102 if (memcpy_s(firmware_mem->puc_data_buf, rdlen, g_st_rw_bin[ul_soft_ver]->addr + offset, rdlen) != EOK) {
1103 return -OAL_EFAIL;
1104 };
1105
1106 addr_send = (hi_u32)(addr + offset);
1107
1108 #if (_PRE_OS_VERSION_LITEOS == _PRE_OS_VERSION)
1109 if (offset == 0 && offset + rdlen == file_len) {
1110 verify_stage = 3; /* start and end, verify_stage 3. */
1111 } else if (offset == 0) {
1112 verify_stage = 0; /* start trans. */
1113 } else if (offset + rdlen == file_len) {
1114 verify_stage = 2; /* end trans, verify_stage 2. */
1115 } else {
1116 verify_stage = 1; /* transferring. */
1117 }
1118
1119 ret = snprintf_s((hi_char *)firmware_mem->puc_send_cmd_buff, CMD_BUFF_LEN, CMD_BUFF_LEN - 1,
1120 "%s%c0x%x%c0x%x%c%d%c", FILES_CMD_KEYWORD, COMPART_KEYWORD, addr_send, COMPART_KEYWORD, rdlen,
1121 COMPART_KEYWORD, verify_stage, COMPART_KEYWORD);
1122 if (ret < 0) {
1123 return -OAL_EFAIL;
1124 }
1125 #endif
1126 /* 发送地址 */
1127 oam_info_log1(0, 0, "send file addr cmd is [%s]", firmware_mem->puc_send_cmd_buff);
1128 ret = msg_send_and_recv_except(firmware_mem->puc_send_cmd_buff,
1129 strlen((const hi_char *)firmware_mem->puc_send_cmd_buff), (const hi_u8 *)MSG_FROM_DEV_READY_OK,
1130 firmware_mem);
1131 if (ret < 0) {
1132 oam_error_log1(0, 0, "SEND [%s] error\n", firmware_mem->puc_send_cmd_buff);
1133 return -OAL_EFAIL;
1134 }
1135 /* Wait at least 5 ms */
1136 #if (_PRE_OS_VERSION_LINUX == _PRE_OS_VERSION)
1137 usleep_range(FILE_CMD_WAIT_TIME_MIN, FILE_CMD_WAIT_TIME_MAX);
1138 #elif (_PRE_OS_VERSION_LITEOS == _PRE_OS_VERSION)
1139 usleep(FILE_CMD_WAIT_TIME_MIN);
1140 #endif
1141 /* 发送文件内容 */
1142 ret = msg_send_and_recv_except(firmware_mem->puc_data_buf, rdlen, (const hi_u8 *)MSG_FROM_DEV_FILES_OK,
1143 firmware_mem);
1144 if (ret < 0) {
1145 oam_error_log0(0, 0, " send data fail");
1146 return -OAL_EFAIL;
1147 }
1148
1149 offset += rdlen;
1150 file_len_count -= rdlen;
1151 }
1152
1153 /* 发送的长度要和文件的长度一致 */
1154 if (offset != file_len) {
1155 oam_error_log2(0, 0, "file send len is err! send len is [%d], file len is [%d]", offset, file_len);
1156 return -OAL_EFAIL;
1157 }
1158
1159 return HI_SUCCESS;
1160 }
1161 #endif
1162
1163 /* ****************************************************************************
1164 功能描述 : 执行firmware download的命令
1165 输入参数 : cmd_type: 加载命令的类型
1166 cmd_name: 命令的关键字
1167 cmd_para: 命令的参数
1168 输出参数 : 无
1169 返 回 值 : -1表示失败，非负数表示成功
1170 **************************************************************************** */
execute_download_cmd(hi_s32 cmd_type, hi_u8 *cmd_name, hi_u8 *cmd_para, firmware_mem_stru *firmware_mem)1171 static hi_s32 execute_download_cmd(hi_s32 cmd_type, hi_u8 *cmd_name, hi_u8 *cmd_para, firmware_mem_stru *firmware_mem)
1172 {
1173 hi_s32 l_ret;
1174
1175 switch (cmd_type) {
1176 case FILE_TYPE_CMD:
1177 l_ret = exec_file_type_cmd(cmd_name, cmd_para, firmware_mem);
1178 break;
1179 case NUM_TYPE_CMD:
1180 l_ret = exec_number_type_cmd(cmd_name, cmd_para, firmware_mem);
1181 break;
1182 case QUIT_TYPE_CMD:
1183 l_ret = exec_quit_type_cmd(firmware_mem);
1184 break;
1185 default:
1186 oam_error_log1(0, 0, "command type error[%d]", cmd_type);
1187 l_ret = -OAL_EFAIL;
1188 break;
1189 }
1190
1191 return l_ret;
1192 }
1193
firmware_write_cfg(hi_u8 *key, hi_u8 *new_val, hi_u8 len)1194 hi_s32 firmware_write_cfg(hi_u8 *key, hi_u8 *new_val, hi_u8 len)
1195 {
1196 oal_file_stru *fp;
1197 hi_s32 idx;
1198 hi_s64 l_ret;
1199 hi_u8 *cfg_patch = (hi_u8 *)WIFI_CFG_C01_PATH;
1200
1201 /* 查找参数名是否缓存 */
1202 for (idx = 0; idx < CFG_CMD_NUM_MAX; ++idx) {
1203 if (strcmp((const hi_char *)key, (const hi_char *)g_cus_cfg_cmd[idx].cmd_name) == 0) {
1204 break;
1205 }
1206 }
1207 if (idx == CFG_CMD_NUM_MAX) {
1208 printk("cfg [%s] to write not found\n", key);
1209 return -OAL_EFAIL;
1210 }
1211 /* 校验新值的长度 */
1212 if (len > g_cus_cfg_cmd[idx].val_len - 3) { /* 3:预留的 ‘;’和“\r\n”的大小 */
1213 printk("new val [%s] length exceeds old val [%s]\n", new_val, g_cus_cfg_cmd[idx].cmd_para);
1214 return -OAL_EFAIL;
1215 }
1216 fp = oal_file_open((const hi_char *)cfg_patch, (OAL_O_RDWR), 0);
1217 if (IS_ERR_OR_NULL(fp)) {
1218 printk("open file %s fail, fp=%p\n", cfg_patch, fp);
1219 return -OAL_EFAIL;
1220 }
1221 /* 定位到目标位置 */
1222 l_ret = oal_file_lseek(fp, g_cus_cfg_cmd[idx].val_offset, OAL_SEEK_SET);
1223 hi_u8 *buf = (hi_u8 *)OS_KMALLOC_GFP(g_cus_cfg_cmd[idx].val_len);
1224 if (buf == HI_NULL) {
1225 printk("firmware_write_cfg:alloc buf failed\n");
1226 oal_file_close(fp);
1227 return -OAL_EFAIL;
1228 }
1229 if (memset_s(buf, g_cus_cfg_cmd[idx].val_len, ' ', g_cus_cfg_cmd[idx].val_len) != EOK) {
1230 return -OAL_EFAIL;
1231 }
1232
1233 if (memcpy_s(buf, g_cus_cfg_cmd[idx].val_len, new_val, len + 1) != EOK) {
1234 oam_warning_log0(0, 0, "firmware_write_cfg:: buf memcpy_s fail.\n");
1235 }
1236 if (len < g_cus_cfg_cmd[idx].val_len - 2) { /* 2:回车换行预留 */
1237 buf[len] = ';'; /* 重置结束符 */
1238 }
1239 buf[g_cus_cfg_cmd[idx].val_len - 2] = '\r'; /* 增加回车换行.2:回退值 */
1240 buf[g_cus_cfg_cmd[idx].val_len - 1] = '\n';
1241 l_ret = oal_file_write(fp, (hi_char *)buf, g_cus_cfg_cmd[idx].val_len);
1242 oal_file_close(fp);
1243
1244 if (l_ret == g_cus_cfg_cmd[idx].val_len) { /* 返回值为写入字节数表示成功 */
1245 /* 更新缓存 */
1246 if (memcpy_s(g_cus_cfg_cmd[idx].cmd_para, g_cus_cfg_cmd[idx].val_len, buf, g_cus_cfg_cmd[idx].val_len) != EOK) {
1247 oam_warning_log0(0, 0, "firmware_write_cfg:: g_cus_cfg_cmd memcpy_s fail.\n");
1248 }
1249 oal_free(buf);
1250 return HI_SUCCESS;
1251 }
1252 oal_free(buf);
1253 return HI_FAIL;
1254 }
1255
1256 /* ****************************************************************************
1257 功能描述 : 读取cfg文件的内容，放到驱动动态分配的buffer中
1258 输入参数 : cfg_patch : cfg文件的路径
1259 puc_read_buffer : 保存cfg文件内容的buffer
1260 输出参数 : 无
1261 返 回 值 : 0表示成功，-1表示失败
1262 **************************************************************************** */
firmware_read_cfg(const hi_u8 *cfg_patch, hi_u8 *puc_read_buffer)1263 hi_s32 firmware_read_cfg(const hi_u8 *cfg_patch, hi_u8 *puc_read_buffer)
1264 {
1265 oal_file_stru *fp = HI_NULL;
1266 hi_s32 l_ret;
1267
1268 if ((cfg_patch == HI_NULL) || (puc_read_buffer == HI_NULL)) {
1269 printk("para is HI_NULL\n");
1270 return -OAL_EFAIL;
1271 }
1272
1273 fp = oal_file_open((const hi_char *)cfg_patch, (OAL_O_RDONLY), 0);
1274 if (IS_ERR_OR_NULL(fp)) {
1275 printk("open file %s fail, fp=%p\n", cfg_patch, fp);
1276 return -OAL_EFAIL;
1277 }
1278
1279 memset_s(puc_read_buffer, READ_CFG_BUF_LEN, 0, READ_CFG_BUF_LEN);
1280 l_ret = oal_file_read(fp, puc_read_buffer, READ_CFG_BUF_LEN);
1281 *(puc_read_buffer + READ_CFG_BUF_LEN - 1) = '\0';
1282 oal_file_close(fp);
1283 fp = HI_NULL;
1284
1285 return l_ret;
1286 }
1287
firmware_param_check(hi_u8 **begin, hi_u8 **end, hi_u8 **link, hi_u8 *puc_cfg_buffer, hi_s32 *l_ret)1288 hi_u8 firmware_param_check(hi_u8 **begin, hi_u8 **end, hi_u8 **link, hi_u8 *puc_cfg_buffer, hi_s32 *l_ret)
1289 {
1290 *begin = puc_cfg_buffer;
1291
1292 /* 注释行 */
1293 if (puc_cfg_buffer[0] == '@') {
1294 *l_ret = ERROR_TYPE_CMD;
1295 return HI_FAIL;
1296 }
1297
1298 /* 错误行，或者退出命令行 */
1299 *link = (hi_u8 *)strchr((const hi_char *)(*begin), '=');
1300 if (*link == HI_NULL) {
1301 /* 退出命令行 */
1302 if (strstr((hi_char *)puc_cfg_buffer, QUIT_CMD_KEYWORD) != HI_NULL) {
1303 *l_ret = QUIT_TYPE_CMD;
1304 return HI_SUCCESS;
1305 }
1306 *l_ret = ERROR_TYPE_CMD;
1307 return HI_FAIL;
1308 }
1309 /* 错误行，没有结束符 */
1310 *end = (hi_u8 *)strchr((const hi_char *)(*link), ';');
1311 if (*end == HI_NULL) {
1312 *l_ret = ERROR_TYPE_CMD;
1313 return HI_FAIL;
1314 }
1315
1316 return HI_CONTINUE;
1317 }
1318
firmware_parse_cmd_type(hi_s32 *l_cmdlen, hi_u8 **handle, hi_s32 *l_ret)1319 hi_u8 firmware_parse_cmd_type(hi_s32 *l_cmdlen, hi_u8 **handle, hi_s32 *l_ret)
1320 {
1321 hi_u8 *handle_temp = HI_NULL;
1322
1323 /* 判断命令类型 */
1324 if (!memcmp(*handle, (hi_u8 *)FILE_TYPE_CMD_KEY, strlen((const hi_char *)FILE_TYPE_CMD_KEY))) {
1325 handle_temp = (hi_u8 *)strstr((const hi_char *)(*handle), (const hi_char *)FILE_TYPE_CMD_KEY);
1326 if (handle_temp == HI_NULL) {
1327 oam_error_log1(0, 0, "'ADDR_FILE_'is not handle child string, handle=%s", *handle);
1328 *l_ret = ERROR_TYPE_CMD;
1329 return HI_FAIL;
1330 }
1331 *handle = handle_temp + strlen(FILE_TYPE_CMD_KEY);
1332 *l_cmdlen = *l_cmdlen - strlen(FILE_TYPE_CMD_KEY);
1333 *l_ret = FILE_TYPE_CMD;
1334 } else if (!memcmp(*handle, (hi_u8 *)NUM_TYPE_CMD_KEY, strlen(NUM_TYPE_CMD_KEY))) {
1335 handle_temp = (hi_u8 *)strstr((const hi_char *)(*handle), (const hi_char *)NUM_TYPE_CMD_KEY);
1336 if (handle_temp == HI_NULL) {
1337 oam_error_log1(0, 0, "'PARA_' is not handle child string, handle=%s", (uintptr_t)*handle);
1338 *l_ret = ERROR_TYPE_CMD;
1339 return HI_FAIL;
1340 }
1341 *handle = handle_temp + strlen(NUM_TYPE_CMD_KEY);
1342 *l_cmdlen = *l_cmdlen - strlen(NUM_TYPE_CMD_KEY);
1343 *l_ret = NUM_TYPE_CMD;
1344 } else if (!memcmp(*handle, (hi_u8 *)CFG_TYPE_CMD_KEY, strlen(CFG_TYPE_CMD_KEY))) {
1345 handle_temp = (hi_u8 *)strstr((const hi_char *)(*handle), (const hi_char *)CFG_TYPE_CMD_KEY);
1346 if (handle_temp == HI_NULL) {
1347 *l_ret = CFG_TYPE_CMD;
1348 return HI_SUCCESS;
1349 }
1350 *handle = handle_temp + strlen(CFG_TYPE_CMD_KEY);
1351 *l_cmdlen = *l_cmdlen - strlen(CFG_TYPE_CMD_KEY);
1352 *l_ret = CFG_TYPE_CMD;
1353 } else {
1354 *l_ret = ERROR_TYPE_CMD;
1355 return HI_FAIL;
1356 }
1357
1358 return HI_CONTINUE;
1359 }
1360
1361 /* ****************************************************************************
1362 功能描述 : 解析cfg文件中的命令
1363 输入参数 : puc_cfg_buffer: 保存cfg文件内容的buffer
1364 puc_cmd_name : 保存解析以后命令关键字的buffer
1365 puc_cmd_para : 保存解析以后命令参数的buffer
1366 输出参数 : 无
1367 返 回 值 : 返回命令的类型
1368 **************************************************************************** */
firmware_parse_cmd(hi_u8 *puc_cfg_buffer, hi_u8 *puc_cmd_name, hi_u8 cmd_len, hi_u8 *puc_cmd_para, hi_u32 *val_begin)1369 static hi_s32 firmware_parse_cmd(hi_u8 *puc_cfg_buffer, hi_u8 *puc_cmd_name, hi_u8 cmd_len, hi_u8 *puc_cmd_para,
1370 hi_u32 *val_begin)
1371 {
1372 hi_s32 l_ret;
1373 hi_s32 l_cmdlen;
1374 hi_s32 l_paralen;
1375 hi_u8 *begin = HI_NULL;
1376 hi_u8 *end = HI_NULL;
1377 hi_u8 *link = HI_NULL;
1378 hi_u8 *handle = HI_NULL;
1379
1380 hi_unref_param(cmd_len);
1381
1382 if ((puc_cfg_buffer == HI_NULL) || (puc_cmd_name == HI_NULL) || (puc_cmd_para == HI_NULL)) {
1383 oam_error_log0(0, 0, "para is HI_NULL\n");
1384 return ERROR_TYPE_CMD;
1385 }
1386
1387 if (firmware_param_check(&begin, &end, &link, puc_cfg_buffer, &l_ret) != HI_CONTINUE) {
1388 return l_ret;
1389 }
1390
1391 *val_begin = (uintptr_t)(link + 1);
1392
1393 l_cmdlen = link - begin;
1394
1395 /* 删除关键字的两边空格 */
1396 handle = delete_space((hi_u8 *)begin, &l_cmdlen);
1397 if (handle == HI_NULL) {
1398 return ERROR_TYPE_CMD;
1399 }
1400
1401 if (firmware_parse_cmd_type(&l_cmdlen, &handle, &l_ret) != HI_CONTINUE) {
1402 return l_ret;
1403 }
1404
1405 if (l_cmdlen > DOWNLOAD_CMD_LEN || l_cmdlen < 0) {
1406 oam_error_log0(0, 0, "cmd len out of range!\n");
1407 return ERROR_TYPE_CMD;
1408 }
1409 memcpy_s(puc_cmd_name, l_cmdlen, handle, l_cmdlen);
1410
1411 /* 删除值两边空格 */
1412 begin = link + 1;
1413 l_paralen = end - begin;
1414 if (l_paralen > DOWNLOAD_CMD_PARA_LEN || l_paralen < 0) {
1415 oam_error_log0(0, 0, "para len out of range!\n");
1416 return ERROR_TYPE_CMD;
1417 }
1418
1419 handle = delete_space((hi_u8 *)begin, &l_paralen);
1420 if (handle == HI_NULL) {
1421 return ERROR_TYPE_CMD;
1422 }
1423 memcpy_s(puc_cmd_para, l_paralen, handle, l_paralen);
1424
1425 return l_ret;
1426 }
1427
1428 /* ****************************************************************************
1429 功能描述 : 解析cfg文件，将解析的结果保存在g_st_cfg_info全局变量中
1430 输入参数 : puc_cfg_info_buf: 保存了cfg文件内容的buffer
1431 l_buf_len : puc_cfg_info_buf的长度
1432 ul_index : 保存解析结果的数组索引值
1433 输出参数 : 无
1434 返 回 值 : 0表示成功，-1表示失败
1435 **************************************************************************** */
firmware_parse_cfg(hi_u8 *puc_cfg_info_buf, hi_s32 l_buf_len, hi_u32 ul_index)1436 static hi_s32 firmware_parse_cfg(hi_u8 *puc_cfg_info_buf, hi_s32 l_buf_len, hi_u32 ul_index)
1437 {
1438 hi_u32 cfg_idx = 0;
1439 hi_s32 i, l_len, cmd_type;
1440 hi_u8 *flag = HI_NULL;
1441 hi_u8 *begin = HI_NULL;
1442 hi_u8 *end = HI_NULL;
1443 hi_u8 cmd_name[DOWNLOAD_CMD_LEN];
1444 hi_u8 cmd_para[DOWNLOAD_CMD_PARA_LEN];
1445 hi_u32 cmd_para_len = 0;
1446 hi_u32 val_offset = 0;
1447 if (puc_cfg_info_buf == HI_NULL) {
1448 oam_error_log0(0, 0, "firmware_parse_cfg:: puc_cfg_info_buf is HI_NULL");
1449 return -OAL_EFAIL;
1450 }
1451
1452 g_st_cfg_info.apst_cmd[ul_index] = (struct cmd_type_st *)malloc_cmd_buf(puc_cfg_info_buf, ul_index);
1453 if (g_st_cfg_info.apst_cmd[ul_index] == HI_NULL) {
1454 oam_error_log0(0, 0, "firmware_parse_cfg:: malloc_cmd_buf fail");
1455 return -OAL_EFAIL;
1456 }
1457
1458 /* 解析CMD BUF */
1459 flag = puc_cfg_info_buf;
1460 l_len = l_buf_len;
1461 i = 0;
1462 while ((i < g_st_cfg_info.al_count[ul_index]) && (flag < &puc_cfg_info_buf[l_len])) {
1463 /*
1464 * 获取配置文件中的一行,配置文件必须是unix格式.
1465 * 配置文件中的某一行含有字符 @ 则认为该行为注释行
1466 */
1467 begin = flag;
1468 end = (hi_u8 *)strchr((const hi_char *)flag, '\n');
1469 if (end == HI_NULL) { /* 文件的最后一行，没有换行符 */
1470 end = &puc_cfg_info_buf[l_len];
1471 } else if (end == begin) { /* 该行只有一个换行符 */
1472 oam_error_log0(0, 0, "blank line\n");
1473 flag = end + 1;
1474 continue;
1475 }
1476 *end = '\0';
1477
1478 memset_s(cmd_name, DOWNLOAD_CMD_LEN, 0, DOWNLOAD_CMD_LEN);
1479 memset_s(cmd_para, DOWNLOAD_CMD_PARA_LEN, 0, DOWNLOAD_CMD_PARA_LEN);
1480
1481 cmd_type = firmware_parse_cmd(begin, cmd_name, DOWNLOAD_CMD_LEN, cmd_para, &val_offset);
1482
1483 if (cmd_type == CFG_TYPE_CMD) { /* 产测配置命令类型，增加到缓存 */
1484 if (cfg_idx == CFG_CMD_NUM_MAX) {
1485 oam_error_log1(0, 0, "firmware_parse_cfg:: Cus cfg items exceed limit %d, will omit", CFG_CMD_NUM_MAX);
1486 }
1487 memcpy_s(g_cus_cfg_cmd[cfg_idx].cmd_name, DOWNLOAD_CMD_LEN, cmd_name, DOWNLOAD_CMD_LEN);
1488 memcpy_s(g_cus_cfg_cmd[cfg_idx].cmd_para, DOWNLOAD_CMD_PARA_LEN, cmd_para, DOWNLOAD_CMD_PARA_LEN);
1489 g_cus_cfg_cmd[cfg_idx].cmd_name[DOWNLOAD_CMD_LEN - 1] = '\0';
1490 g_cus_cfg_cmd[cfg_idx].cmd_para[DOWNLOAD_CMD_PARA_LEN - 1] = '\0';
1491 g_cus_cfg_cmd[cfg_idx].val_offset = val_offset - (uintptr_t)puc_cfg_info_buf;
1492 g_cus_cfg_cmd[cfg_idx].val_len = (hi_u16)((uintptr_t)end - val_offset + 1);
1493 #ifdef CUSTOM_DBG
1494 oam_info_log0(0, 0, "firmware_parse_cfg:: cmd type=[%d],cmd_name=[%s],cmd_para=[%s], line len %d",
1495 cmd_type, cmd_name, cmd_para, g_cus_cfg_cmd[cfg_idx].val_len);
1496 #endif
1497 ++cfg_idx;
1498 } else if (cmd_type != ERROR_TYPE_CMD) { /* 正确的命令类型，增加 */
1499 g_st_cfg_info.apst_cmd[ul_index][i].cmd_type = cmd_type;
1500 if (memcpy_s(g_st_cfg_info.apst_cmd[ul_index][i].cmd_name, DOWNLOAD_CMD_LEN, cmd_name, DOWNLOAD_CMD_LEN) !=
1501 EOK || memcpy_s(g_st_cfg_info.apst_cmd[ul_index][i].cmd_para, DOWNLOAD_CMD_PARA_LEN, cmd_para,
1502 DOWNLOAD_CMD_PARA_LEN) != EOK) {
1503 return -OAL_EFAIL;
1504 }
1505 g_st_cfg_info.apst_cmd[ul_index][i].cmd_name[DOWNLOAD_CMD_LEN - 1] = '\0';
1506 g_st_cfg_info.apst_cmd[ul_index][i].cmd_para[DOWNLOAD_CMD_PARA_LEN - 1] = '\0';
1507
1508 /* 获取配置版本号 */
1509 if (!memcmp(g_st_cfg_info.apst_cmd[ul_index][i].cmd_name, VER_CMD_KEYWORD, strlen(VER_CMD_KEYWORD))) {
1510 cmd_para_len = strlen((const hi_char *)g_st_cfg_info.apst_cmd[ul_index][i].cmd_para);
1511 if (cmd_para_len <= VERSION_LEN) {
1512 if (memcpy_s(g_st_cfg_info.auc_CfgVersion, cmd_para_len,
1513 g_st_cfg_info.apst_cmd[ul_index][i].cmd_para, cmd_para_len) != EOK) {
1514 oam_warning_log0(0, 0, "firmware_parse_cfg::memcpy_s fail!");
1515 }
1516 } else {
1517 oam_error_log1(0, 0, "firmware_parse_cfg:: cmd_para_len = %d over auc_CfgVersion length",
1518 cmd_para_len);
1519 return -OAL_EFAIL;
1520 }
1521 oam_warning_log1(0, 0, "Hi3881 VERSION:: [%s]", (uintptr_t)g_st_cfg_info.auc_CfgVersion);
1522 }
1523 i++;
1524 }
1525 flag = end + 1;
1526 }
1527
1528 /* 根据实际命令个数，修改最终的命令个数 */
1529 g_st_cfg_info.al_count[ul_index] = i;
1530 oam_info_log2(0, 0, "firmware_parse_cfg:: effective cmd count: al_count[%d] = %d", ul_index,
1531 g_st_cfg_info.al_count[ul_index]);
1532
1533 return HI_SUCCESS;
1534 }
1535
1536
1537 /* ****************************************************************************
1538 功能描述 : 读取cfg文件并解析，将解析的结果保存在g_st_cfg_info全局变量中
1539 输入参数 : cfg_patch: cfg文件的路径
1540 ul_index : 保存解析结果的数组索引值
1541 输出参数 : 无
1542 返 回 值 : 0表示成功，-1表示失败
1543 **************************************************************************** */
firmware_get_cfg(const hi_u8 *cfg_patch, hi_u32 ul_index)1544 static hi_s32 firmware_get_cfg(const hi_u8 *cfg_patch, hi_u32 ul_index)
1545 {
1546 hi_u8 *read_cfg_buf = HI_NULL;
1547 hi_s32 l_readlen;
1548 hi_s32 l_ret;
1549 hi_u32 ul_soft_ver = 0;
1550
1551 if (cfg_patch == HI_NULL) {
1552 oam_warning_log0(0, 0, "firmware_get_cfg:: cfg file path is HI_NULL");
1553 return -OAL_EFAIL;
1554 }
1555
1556 /* cfg文件限定在小于2048,如果cfg文件的大小确实大于2048，可以修改READ_CFG_BUF_LEN的值 */
1557 read_cfg_buf = OS_KMALLOC_GFP(READ_CFG_BUF_LEN);
1558 if (read_cfg_buf == HI_NULL) {
1559 oam_warning_log0(0, 0, "firmware_get_cfg:: kmalloc READ_CFG_BUF fail");
1560 return -OAL_EFAIL;
1561 }
1562
1563 memset_s(read_cfg_buf, READ_CFG_BUF_LEN, 0, READ_CFG_BUF_LEN);
1564
1565 #ifndef _PRE_HI113X_FS_DISABLE
1566 (hi_void)ul_soft_ver;
1567 l_readlen = firmware_read_cfg(cfg_patch, read_cfg_buf);
1568 if (l_readlen < 0) {
1569 oam_warning_log1(0, 0, "firmware_get_cfg:: firmware_read_cfg failed[%d]", l_readlen);
1570 oal_free(read_cfg_buf);
1571 read_cfg_buf = HI_NULL;
1572 return -OAL_EFAIL;
1573 } else if (l_readlen > READ_CFG_BUF_LEN - 1) {
1574 /*
1575 * 减1是为了确保cfg文件的长度不超过READ_CFG_BUF_LEN，
1576 * 因为firmware_read_cfg最多只会读取READ_CFG_BUF_LEN长度的内容
1577 */
1578 oam_error_log2(0, 0, "firmware_get_cfg:: cfg file [%s] larger than %d", (uintptr_t)cfg_patch, READ_CFG_BUF_LEN);
1579 oal_free(read_cfg_buf);
1580 read_cfg_buf = HI_NULL;
1581 return -OAL_EFAIL;
1582 }
1583 #else
1584 ul_soft_ver = get_device_soft_version();
1585 if (ul_soft_ver >= SOFT_VER_BUTT) {
1586 oam_error_log1(0, 0, "firmware_get_cfg:: get_device_soft_version failed[%d]", ul_soft_ver);
1587 oal_free(read_cfg_buf);
1588 return -OAL_EFAIL;
1589 }
1590
1591 l_readlen = g_st_wifi_cfg[ul_soft_ver]->len;
1592 if (l_readlen > READ_CFG_BUF_LEN) {
1593 oam_error_log1(0, 0, "firmware_get_cfg:: read_wifi_cfg failed[%d]", l_readlen);
1594 oal_free(read_cfg_buf);
1595 read_cfg_buf = HI_NULL;
1596 return -OAL_EFAIL;
1597 }
1598
1599 if (memcpy_s(read_cfg_buf, l_readlen, g_st_wifi_cfg[ul_soft_ver]->addr, l_readlen) != EOK) {
1600 oal_free(read_cfg_buf);
1601 return -OAL_EFAIL;
1602 }
1603 #endif
1604
1605 l_ret = firmware_parse_cfg(read_cfg_buf, l_readlen, ul_index);
1606 if (l_ret < 0) {
1607 oam_error_log1(0, 0, "firmware_get_cfg:: firmware_parse_cfg failed[%d]", l_ret);
1608 }
1609
1610 oal_free(read_cfg_buf);
1611 read_cfg_buf = HI_NULL;
1612
1613 return l_ret;
1614 }
1615
1616 /* ****************************************************************************
1617 功能描述 : firmware加载
1618 输入参数 : ul_index: 有效加载命令数组的索引
1619 输出参数 : 无
1620 返 回 值 : 0表示成功，-1表示失败
1621 **************************************************************************** */
firmware_download(hi_u32 ul_index)1622 hi_s32 firmware_download(hi_u32 ul_index)
1623 {
1624 hi_s32 l_ret;
1625 hi_s32 i;
1626 hi_s32 l_cmd_type;
1627 hi_u8 *puc_cmd_name = HI_NULL;
1628 hi_u8 *puc_cmd_para = HI_NULL;
1629 firmware_mem_stru *firmware_mem = HI_NULL;
1630
1631 if (ul_index >= CFG_FILE_TOTAL) {
1632 oam_error_log1(0, 0, "firmware_download:: ul_index [%d] is error", ul_index);
1633 return -OAL_EFAIL;
1634 }
1635
1636 if (g_st_cfg_info.al_count[ul_index] == 0) {
1637 oam_error_log1(0, 0, "firmware_download:: firmware download cmd count is 0, ul_index = [%d]", ul_index);
1638 return -OAL_EFAIL;
1639 }
1640
1641 firmware_mem = firmware_mem_request();
1642 if (firmware_mem == HI_NULL) {
1643 oam_error_log0(0, 0, "firmware_download:: firmware_mem_request fail");
1644 return -OAL_EFAIL;
1645 }
1646
1647 for (i = 0; i < g_st_cfg_info.al_count[ul_index]; i++) {
1648 l_cmd_type = g_st_cfg_info.apst_cmd[ul_index][i].cmd_type;
1649 puc_cmd_name = g_st_cfg_info.apst_cmd[ul_index][i].cmd_name;
1650 puc_cmd_para = g_st_cfg_info.apst_cmd[ul_index][i].cmd_para;
1651 l_ret = execute_download_cmd(l_cmd_type, puc_cmd_name, puc_cmd_para, firmware_mem);
1652 if (l_ret < 0) {
1653 if (puc_cmd_name == HI_NULL) {
1654 continue;
1655 }
1656 if (ul_index == RAM_REG_TEST_CFG && ((!memcmp(puc_cmd_name, JUMP_CMD_KEYWORD, strlen(JUMP_CMD_KEYWORD))) &&
1657 (g_ul_jump_cmd_result == CMD_JUMP_EXEC_RESULT_FAIL))) {
1658 /* device mem check 返回失败，继续执行READM命令，将结果读上来 */
1659 oam_error_log0(0, 0, "firmware_download:: Device Mem Reg check result is fail");
1660 continue;
1661 }
1662 l_ret = -OAL_EFAIL;
1663 firmware_mem_free(firmware_mem);
1664 return l_ret;
1665 }
1666 }
1667 l_ret = HI_SUCCESS;
1668 firmware_mem_free(firmware_mem);
1669 return l_ret;
1670 }
1671
1672
1673 EXPORT_SYMBOL(firmware_download);
1674
get_efuse_info_handlernull1675 efuse_info_stru *get_efuse_info_handler(hi_void)
1676 {
1677 return &g_st_efuse_info;
1678 }
1679 EXPORT_SYMBOL(get_efuse_info_handler);
1680
get_device_soft_versionnull1681 hi_u32 get_device_soft_version(hi_void)
1682 {
1683 efuse_info_stru *pst_efuse_info;
1684 hi_u32 ul_soft_ver;
1685 pst_efuse_info = get_efuse_info_handler();
1686 if (pst_efuse_info == HI_NULL) {
1687 printk("***get_device_soft_version***[%d]\n", __LINE__);
1688 return SOFT_VER_BUTT;
1689 }
1690
1691 ul_soft_ver = pst_efuse_info->soft_ver;
1692 if (ul_soft_ver >= SOFT_VER_BUTT) {
1693 printk("***get_device_soft_version***[%d]\n", __LINE__);
1694 return SOFT_VER_BUTT;
1695 }
1696
1697 return ul_soft_ver;
1698 }
1699
firmware_read_efuse_infonull1700 hi_s32 firmware_read_efuse_info(hi_void)
1701 {
1702 firmware_mem_stru *firmware_mem = HI_NULL;
1703 const unsigned long ul_mac_addr = DEVICE_EFUSE_ADDR;
1704
1705 efuse_info_stru *pst_efuse_info = get_efuse_info_handler();
1706 if (pst_efuse_info == HI_NULL) {
1707 oam_error_log0(0, 0, "pst_efuse_info is HI_NULL!\n");
1708 goto failed;
1709 }
1710 if (memset_s(pst_efuse_info, sizeof(efuse_info_stru), 0, sizeof(efuse_info_stru)) != EOK) {
1711 goto failed;
1712 }
1713
1714 firmware_mem = firmware_mem_request();
1715 if (firmware_mem == HI_NULL) {
1716 oam_error_log0(0, 0, "firmware_mem_request fail\n");
1717 goto failed;
1718 }
1719
1720 hi_u32 ul_size = DEVICE_EFUSE_LENGTH;
1721 #if (_PRE_FEATURE_USB == _PRE_FEATURE_CHANNEL_TYPE)
1722 ul_size = hiusb_align_32(ul_size);
1723 #elif (_PRE_FEATURE_SDIO == _PRE_FEATURE_CHANNEL_TYPE)
1724 ul_size = HISDIO_ALIGN_4_OR_BLK(ul_size);
1725 #endif
1726 if (ul_size > firmware_mem->ul_data_buf_len) {
1727 oam_error_log0(0, 0, "device mac length is too long !\n");
1728 goto failed;
1729 }
1730
1731 if (snprintf_s((hi_char *)firmware_mem->puc_send_cmd_buff, CMD_BUFF_LEN, CMD_BUFF_LEN - 1, "%s%c0x%lx%c%d%c",
1732 RMEM_CMD_KEYWORD, COMPART_KEYWORD, ul_mac_addr, COMPART_KEYWORD, ul_size, COMPART_KEYWORD) == -1) {
1733 goto failed;
1734 }
1735 oam_info_log1(0, 0, "read mac cmd:[%s]\n", (uintptr_t)firmware_mem->puc_send_cmd_buff);
1736 hi_s32 l_ret = firmware_send_msg(firmware_mem->puc_send_cmd_buff,
1737 strlen((const hi_char *)firmware_mem->puc_send_cmd_buff));
1738 if (l_ret < 0) {
1739 oam_error_log1(0, 0, "read device mac cmd send fail![%d]\n", l_ret);
1740 goto failed;
1741 }
1742
1743 l_ret = firmware_read_msg(firmware_mem->puc_data_buf, ul_size);
1744 if (l_ret < 0) {
1745 oam_error_log1(0, 0, "read device mac fail![%d]\n", l_ret);
1746 goto failed;
1747 }
1748
1749 if (memcpy_s(pst_efuse_info, sizeof(efuse_info_stru), firmware_mem->puc_data_buf,
1750 sizeof(efuse_info_stru)) != EOK) {
1751 goto failed;
1752 }
1753
1754 firmware_mem_free(firmware_mem);
1755 return HI_SUCCESS;
1756
1757 failed:
1758 if (firmware_mem != HI_NULL) {
1759 firmware_mem_free(firmware_mem);
1760 }
1761 return -OAL_EFAIL;
1762 }
1763 /* ****************************************************************************
1764 功能描述 : firmware加载的cfg文件初始化，读取并解析cfg文件，将解析的结果保存在
1765 g_st_cfg_info全局变量中
1766 输入参数 : 无
1767 输出参数 : 无
1768 返 回 值 : 0表示成功，-1表示失败
1769 **************************************************************************** */
plat_firmware_init(void)1770 hi_u32 plat_firmware_init(void)
1771 {
1772 hi_s32 l_ret;
1773 hi_u32 ul_soft_ver;
1774
1775 #ifdef _PRE_WLAN_FEATURE_DATA_BACKUP
1776 if (g_ul_wlan_resume_wifi_init_flag) {
1777 l_ret = plat_data_recover();
1778 if (l_ret != HI_SUCCESS) {
1779 oam_error_log1(0, 0, "plat_firmware_init:: plat_data_recover failed[%d]", l_ret);
1780 return OAL_EFAIL;
1781 }
1782 }
1783 #endif
1784
1785 #ifdef _PRE_WLAN_FEATURE_DATA_BACKUP
1786 if (!g_ul_wlan_resume_wifi_init_flag) {
1787 #endif
1788 ul_soft_ver = get_device_soft_version();
1789 if (ul_soft_ver >= SOFT_VER_BUTT) {
1790 oam_error_log1(0, 0, "plat_firmware_init:: get_device_soft_version failed[%d]", ul_soft_ver);
1791 return OAL_EFAIL;
1792 }
1793
1794 /* 解析cfg文件 */
1795 l_ret = firmware_get_cfg(g_auc_cfg_path[ul_soft_ver], WIFI_CFG);
1796 if (l_ret < 0) {
1797 oam_error_log1(0, 0, "plat_firmware_init:: firware_get_cfg faile[%d]d", l_ret);
1798 plat_firmware_clear();
1799 return OAL_EFAIL;
1800 }
1801
1802 #ifdef _PRE_WLAN_FEATURE_DATA_BACKUP
1803 }
1804 #endif
1805
1806 #ifdef _PRE_WLAN_FEATURE_DATA_BACKUP
1807 l_ret = plat_data_backup();
1808 if (l_ret != HI_SUCCESS) {
1809 oam_error_log1(0, 0, "plat_firmware_init:: plat_data_backup failed[%d]", l_ret);
1810 plat_firmware_clear();
1811 return OAL_EFAIL;
1812 }
1813 #endif
1814
1815 printk("plat_firmware_init SUCCESSFULLY\r\n");
1816 return HI_SUCCESS;
1817 }
1818
1819 EXPORT_SYMBOL(plat_firmware_init);
1820
1821 /* ****************************************************************************
1822 功能描述 : 释放firmware_cfg_init时申请的内存
1823 输入参数 : 无
1824 输出参数 : 无
1825 返 回 值 : 总是返回0，表示成功
1826 **************************************************************************** */
plat_firmware_clear(void)1827 hi_s32 plat_firmware_clear(void)
1828 {
1829 hi_s32 i;
1830
1831 for (i = 0; i < CFG_FILE_TOTAL; i++) {
1832 g_st_cfg_info.al_count[i] = 0;
1833 if (g_st_cfg_info.apst_cmd[i] != HI_NULL) {
1834 oal_free(g_st_cfg_info.apst_cmd[i]);
1835 g_st_cfg_info.apst_cmd[i] = HI_NULL;
1836 }
1837 }
1838 return HI_SUCCESS;
1839 }
1840
char_2_hex(hi_u8 c, hi_u8 *val)1841 hi_bool char_2_hex(hi_u8 c, hi_u8 *val)
1842 {
1843 if ((c >= '0') && (c <= '9')) {
1844 *val = c - '0';
1845 return HI_TRUE;
1846 }
1847 if ((c >= 'a') && (c <= 'f')) {
1848 *val = 0x0a + c - 'a';
1849 return HI_TRUE;
1850 }
1851 if ((c >= 'A') && (c <= 'F')) {
1852 *val = 0x0a + c - 'A';
1853 return HI_TRUE;
1854 }
1855
1856 return HI_FALSE;
1857 }
1858
parse_mac_addr(const hi_u8 *str, hi_u8 str_len, hi_u8 *mac, hi_u8 size)1859 hi_bool parse_mac_addr(const hi_u8 *str, hi_u8 str_len, hi_u8 *mac, hi_u8 size)
1860 {
1861 hi_u8 i, temp;
1862 hi_u8 val = 0;
1863 hi_u8 idx = 0;
1864 hi_u8 offset = 0;
1865 hi_bool is_mac_valid = HI_FALSE;
1866 hi_bool ret;
1867
1868 for (i = 0; (i < str_len) && (idx < size); ++i) {
1869 ret = char_2_hex(str[i], &temp);
1870 if (ret) {
1871 if (offset == 2) { /* 2:连续有效字符.超过2个有效值 */
1872 return HI_FALSE;
1873 }
1874 val = (offset == 0) ? temp : ((val << 4) + temp); /* 4:位数 */
1875 if (offset == 1) {
1876 mac[idx] = val;
1877 is_mac_valid = (val != 0) ? HI_TRUE : is_mac_valid;
1878 ++idx;
1879 }
1880 ++offset;
1881 } else if (offset != 2) { /* 2:连续有效字符,少于2个有效值 */
1882 return HI_FALSE;
1883 } else if (str[i] == ':') {
1884 offset = 0;
1885 } else {
1886 return HI_FALSE;
1887 }
1888 }
1889
1890 return ((idx == size) && is_mac_valid) ? HI_TRUE : HI_FALSE;
1891 }
1892
split(hi_u8 *src, const hi_char *separator, hi_char **dest, hi_u8 num)1893 hi_bool split(hi_u8 *src, const hi_char *separator, hi_char **dest, hi_u8 num)
1894 {
1895 char *next = HI_NULL;
1896 int count = 0;
1897
1898 if ((src == HI_NULL) || (strlen((const hi_char *)src) == 0) || (separator == HI_NULL) || (strlen(separator) == 0)) {
1899 return HI_FALSE;
1900 }
1901 next = oal_strtok((char *)src, separator);
1902 while (next != HI_NULL) {
1903 *(dest++) = next;
1904 ++count;
1905 if (count == num) {
1906 break;
1907 }
1908 next = oal_strtok(HI_NULL, separator);
1909 }
1910 if (count < num) {
1911 return HI_FALSE;
1912 }
1913 return HI_TRUE;
1914 }
1915
split_cmd_paras(const hi_char *cmd_para, hi_u8 size, hi_u32 *data, hi_u8 data_size, hi_bool by_hex)1916 hi_bool split_cmd_paras(const hi_char *cmd_para, hi_u8 size, hi_u32 *data, hi_u8 data_size, hi_bool by_hex)
1917 {
1918 hi_u8 i;
1919 hi_char *stop = HI_NULL;
1920 hi_u8 src[DOWNLOAD_CMD_PARA_LEN + 1] = {0};
1921 hi_char *revbuf[CMD_SUB_PARA_CNT_MAX] = {0};
1922
1923 if (data_size > CMD_SUB_PARA_CNT_MAX) {
1924 return HI_FALSE;
1925 }
1926
1927 if (memcpy_s(src, sizeof(src), cmd_para, size) != EOK) {
1928 oam_error_log0(0, 0, "split_cmd_paras:: memcpy_s failed");
1929 return HI_FALSE;
1930 }
1931
1932 if (!split(src, ",", revbuf, data_size)) {
1933 return HI_FALSE;
1934 }
1935 for (i = 0; i < data_size; ++i) {
1936 if (by_hex) {
1937 data[i] = (hi_u32)oal_strtol(revbuf[i], &stop, 16); /* 16:按16进制解析 */
1938 } else {
1939 data[i] = (hi_u32)oal_strtol(revbuf[i], &stop, 10); /* 10:按10进制解析 */
1940 }
1941 }
1942 return HI_TRUE;
1943 }
1944
get_cfg_idx(const hi_char *cfg_name, hi_u8 *idx)1945 hi_bool get_cfg_idx(const hi_char *cfg_name, hi_u8 *idx)
1946 {
1947 hi_u8 i;
1948 /* 查找参数名是否缓存 */
1949 for (i = 0; i < CFG_CMD_NUM_MAX; ++i) {
1950 if (strcmp(cfg_name, (const hi_char *)g_cus_cfg_cmd[i].cmd_name) == 0) {
1951 break;
1952 }
1953 }
1954 *idx = i;
1955 return HI_TRUE;
1956 }
1957
cfg_get_mac(hi_u8 *mac_addr, hi_u8 size)1958 hi_bool cfg_get_mac(hi_u8 *mac_addr, hi_u8 size)
1959 {
1960 hi_u8 idx;
1961
1962 if (!get_cfg_idx((const hi_char *)WIFI_CFG_MAC, &idx)) {
1963 return HI_FALSE;
1964 }
1965
1966 return parse_mac_addr(g_cus_cfg_cmd[idx].cmd_para, strlen((const hi_char *)g_cus_cfg_cmd[idx].cmd_para), mac_addr,
1967 size);
1968 }
1969
cfg_dbbnull1970 hi_u32 cfg_dbb(hi_void)
1971 {
1972 const hi_u8 data_size = 7; /* 7:参数个数 */
1973 hi_u32 data[data_size];
1974 hi_u8 idx;
1975 hi_bool ret;
1976
1977 memset_s(data, sizeof(data), 0, sizeof(data));
1978 /* 查找配置索引 */
1979 if (!get_cfg_idx(WIFI_CFG_DBB_PARAMS, &idx)) {
1980 return HI_FAIL;
1981 }
1982 /* 解析参数 */
1983 ret = split_cmd_paras((const hi_char *)g_cus_cfg_cmd[idx].cmd_para,
1984 strlen((const hi_char *)g_cus_cfg_cmd[idx].cmd_para), data, data_size, HI_TRUE);
1985 if (ret != HI_FAIL) {
1986 oam_error_log0(0, 0, "cfg_dbb:: split_cmd_paras failed");
1987 return ret;
1988 }
1989
1990 return wal_cfg_dbb(data, data_size);
1991 }
1992
cfg_country_codenull1993 hi_u32 cfg_country_code(hi_void)
1994 {
1995 const hi_u8 size = 3;
1996 hi_char data[size];
1997 hi_u8 idx;
1998
1999 /* 查找配置索引 */
2000 if (!get_cfg_idx(WIFI_CFG_COUNTRY_CODE, &idx)) {
2001 return HI_FAIL;
2002 }
2003 if (strlen((const hi_char *)g_cus_cfg_cmd[idx].cmd_para) < size - 1) {
2004 return HI_FAIL;
2005 }
2006 /* 拷贝国家码,顺序交叉 */
2007 data[0] = g_cus_cfg_cmd[idx].cmd_para[1];
2008 data[1] = g_cus_cfg_cmd[idx].cmd_para[0];
2009 data[2] = '\0'; /* 下标2 */
2010
2011 return wal_cfg_country_code(data, size);
2012 }
2013
cfg_tx_pwr_offsetnull2014 hi_u32 cfg_tx_pwr_offset(hi_void)
2015 {
2016 hi_u8 idx;
2017 const hi_u8 data_size = 13; /* 13:参数个数 */
2018 hi_u32 data[data_size];
2019 hi_bool ret;
2020
2021 memset_s(data, sizeof(data), 0, sizeof(data));
2022 /* 查找配置索引 */
2023 if (!get_cfg_idx(WIFI_CFG_CH_TXPWR, &idx)) {
2024 return HI_FAIL;
2025 }
2026 /* 解析参数 */
2027 ret = split_cmd_paras((const hi_char *)g_cus_cfg_cmd[idx].cmd_para,
2028 strlen((const hi_char *)g_cus_cfg_cmd[idx].cmd_para), data, data_size, HI_TRUE);
2029 if (ret != HI_FAIL) {
2030 oam_error_log0(0, 0, "cfg_tx_pwr_offset:: split_cmd_paras failed");
2031 return ret;
2032 }
2033
2034 return wal_cfg_fcc_tx_pwr(data, data_size);
2035 }
2036
cfg_freq_comp_valnull2037 hi_u32 cfg_freq_comp_val(hi_void)
2038 {
2039 hi_u8 idx;
2040 const hi_u8 data_size = 3; /* 3:参数个数 */
2041 hi_u32 data[data_size];
2042 hi_bool ret;
2043
2044 memset_s(data, sizeof(data), 0, sizeof(data));
2045 /* 查找配置索引 */
2046 if (!get_cfg_idx(WIFI_CFG_FREQ_COMP, &idx)) {
2047 return HI_FAIL;
2048 }
2049 /* 解析参数 */
2050 ret = split_cmd_paras((const hi_char *)g_cus_cfg_cmd[idx].cmd_para,
2051 strlen((const hi_char *)g_cus_cfg_cmd[idx].cmd_para), data, data_size, HI_FALSE);
2052 if (ret != HI_FAIL) {
2053 oam_error_log0(0, 0, "cfg_freq_comp_val:: split_cmd_paras failed");
2054 return ret;
2055 }
2056
2057 return wal_cfg_freq_comp_val(data, data_size);
2058 }
2059
cfg_rssi_ofsetnull2060 hi_u32 cfg_rssi_ofset(hi_void)
2061 {
2062 hi_s32 data;
2063 hi_char *stop = HI_NULL;
2064 hi_u8 idx;
2065
2066 /* 查找配置索引 */
2067 if (!get_cfg_idx(WIFI_CFG_RSSI_OFFSET, &idx)) {
2068 return HI_FAIL;
2069 }
2070 data = oal_strtol((const hi_char *)g_cus_cfg_cmd[idx].cmd_para, &stop, 10); /* 10:按10进制解析 */
2071 return wal_cfg_rssi_ofset(data);
2072 }
2073
firmware_sync_cfg_paras_to_wal_customizenull2074 hi_u32 firmware_sync_cfg_paras_to_wal_customize(hi_void)
2075 {
2076 /* 同步dbb scale功率配置 */
2077 if (cfg_dbb() != HI_SUCCESS) {
2078 oam_error_log0(0, 0, "firmware_sync_cfg_paras_to_wal_customize:: cfg_dbb failed");
2079 return HI_FAIL;
2080 }
2081 /* 同步国家码 */
2082 if (cfg_country_code() != HI_SUCCESS) {
2083 oam_error_log0(0, 0, "firmware_sync_cfg_paras_to_wal_customize:: cfg_country_code failed");
2084 return HI_FAIL;
2085 }
2086 /* 同步FCC功率配置 */
2087 if (cfg_tx_pwr_offset() != HI_SUCCESS) {
2088 oam_error_log0(0, 0, "firmware_sync_cfg_paras_to_wal_customize:: cfg_tx_pwr_offset failed");
2089 return HI_FAIL;
2090 }
2091 /* 同步高温频偏补偿配置 */
2092 if (cfg_freq_comp_val() != HI_SUCCESS) {
2093 oam_error_log0(0, 0, "firmware_sync_cfg_paras_to_wal_customize:: cfg_dbb failed");
2094 return HI_FAIL;
2095 }
2096 /* 同步rssi补偿配置 */
2097 if (cfg_rssi_ofset() != HI_SUCCESS) {
2098 oam_error_log0(0, 0, "firmware_sync_cfg_paras_to_wal_customize:: cfg_rssi_ofset failed");
2099 return HI_FAIL;
2100 }
2101
2102 printk("firmware_sync_cfg_paras_to_wal_customize SUCCESSFULLY\r\n");
2103 return HI_SUCCESS;
2104 }
2105
2106 EXPORT_SYMBOL(plat_firmware_clear);
2107 EXPORT_SYMBOL(get_device_soft_version);
2108