1 /*
2 * Copyright (c) 2022 Winner Microelectronics Co., Ltd. All rights reserved.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 /*****************************************************************************
17 *
18 * File Name : wm_param.c
19 *
20 * Description: param manager Module
21 *
22 * Copyright (c) 2014 Winner Micro Electronic Design Co., Ltd.
23 * All rights reserved.
24 *
25 * Author : dave
26 *
27 * Date : 2014-6-12
28 *****************************************************************************/
29 #include <string.h>
30 #include "wm_debug.h"
31 #include "wm_efuse.h"
32 #include "wm_flash.h"
33 #include "wm_internal_flash.h"
34 #include "wm_params.h"
35 #include "wm_mem.h"
36 #include "utils.h"
37 #include "wm_flash_map.h"
38 #include "wm_crypto_hard.h"
39 #include "wm_param.h"
40
41 #define USE_TWO_RAM_FOR_PARAMETER 0
42 static struct tls_param_flash flash_param;
43 #if USE_TWO_RAM_FOR_PARAMETER
44 static struct tls_sys_param sram_param;
45 #endif
46
47 struct tls_sys_param *user_default_param = NULL;
48 struct tls_sys_param *tls_param_user_param_init(void);
49
50 static tls_os_sem_t *sys_param_lock = NULL;
51 static const u8 factory_default_hardware[8] = {'H', 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
52 u8 updp_mode; // upadate default parameters mode, 0:not updating or up finish; 1:updating
53
param_flash_verify(u32 data_addr,u8 * data_buffer,u32 len)54 static int param_flash_verify(u32 data_addr, u8 *data_buffer, u32 len)
55 {
56 int err;
57 u8 *buffer;
58
59 buffer = tls_mem_alloc(len);
60 if (buffer == NULL) {return 0;}
61
62 do {
63 err = tls_fls_read(data_addr, buffer, len);
64 if (err != TLS_FLS_STATUS_OK) {
65 err = 0;
66 break;
67 }
68
69 if (memcmp(buffer, data_buffer, len) == 0) {
70 err = 1;
71 } else {
72 err = 0;
73 }
74 } while (0);
75
76 tls_mem_free(buffer);
77
78 return err;
79 }
80
param_to_flash(int id,int modify_count,int partition_num)81 static int param_to_flash(int id, int modify_count, int partition_num)
82 {
83 int err;
84 #if USE_TWO_RAM_FOR_PARAMETER
85 struct tls_sys_param *src;
86 struct tls_sys_param *dest;
87 #endif
88
89 if ((id < TLS_PARAM_ID_ALL) || (id >= TLS_PARAM_ID_MAX)) {return TLS_PARAM_STATUS_EINVALID;}
90
91 err = TLS_PARAM_STATUS_OK;
92
93 #if USE_TWO_RAM_FOR_PARAMETER
94 src = &sram_param;
95 dest = &flash_param.parameters;
96
97 switch (id) {
98 case TLS_PARAM_ID_ALL:
99 MEMCPY(dest, src, sizeof(struct tls_sys_param));
100 break;
101
102 case TLS_PARAM_ID_SSID:
103 MEMCPY(&dest->ssid, &src->ssid, sizeof(struct tls_param_ssid));
104 break;
105
106 case TLS_PARAM_ID_ENCRY:
107 dest->encry = src->encry;
108 break;
109
110 case TLS_PARAM_ID_KEY:
111 MEMCPY(&dest->key, &src->key, sizeof(struct tls_param_key));
112 break;
113
114 case TLS_PARAM_ID_IP:
115 MEMCPY(&dest->ipcfg, &src->ipcfg, sizeof(struct tls_param_ip));
116 break;
117
118 case TLS_PARAM_ID_AUTOMODE:
119 dest->auto_mode = src->auto_mode;
120 break;
121
122 case TLS_PARAM_ID_DEFSOCKET:
123 MEMCPY(&dest->remote_socket_cfg, &src->remote_socket_cfg, sizeof(struct tls_param_socket));
124 break;
125
126 case TLS_PARAM_ID_BSSID:
127 MEMCPY(&dest->bssid, &src->bssid, sizeof(struct tls_param_bssid));
128 break;
129
130 case TLS_PARAM_ID_CHANNEL:
131 dest->channel = src->channel;
132 break;
133
134 case TLS_PARAM_ID_CHANNEL_EN:
135 dest->channel_enable = src->channel_enable;
136 break;
137
138 case TLS_PARAM_ID_COUNTRY_REGION:
139 dest->wireless_region = src->wireless_region;
140 break;
141
142 case TLS_PARAM_ID_WPROTOCOL:
143 dest->wireless_protocol = src->wireless_protocol;
144 break;
145
146 case TLS_PARAM_ID_ADHOC_AUTOCREATE:
147 dest->auto_create_adhoc = src->auto_create_adhoc;
148 break;
149
150 case TLS_PARAM_ID_ROAMING:
151 dest->auto_roam = src->auto_roam;
152 break;
153
154 case TLS_PARAM_ID_AUTO_RETRY_CNT:
155 dest->auto_retrycnt = src->auto_retrycnt;
156 break;
157
158 case TLS_PARAM_ID_WBGR:
159 MEMCPY(&dest->wbgr, &src->wbgr, sizeof(struct tls_param_bgr));
160 break;
161
162 case TLS_PARAM_ID_USRINTF:
163 dest->user_port_mode = src->user_port_mode;
164 break;
165 case TLS_PARAM_ID_ESCAPE_CHAR:
166 dest->EscapeChar = src->EscapeChar;
167 break;
168
169 case TLS_PARAM_ID_ESCAPE_PERIOD:
170 dest->EscapePeriod = src->EscapePeriod;
171 break;
172
173 case TLS_PARAM_ID_AUTO_TRIGGER_LENGTH:
174 dest->transparent_trigger_length = src->transparent_trigger_length;
175 break;
176
177 case TLS_PARAM_ID_AUTO_TRIGGER_PERIOD:
178 dest->transparent_trigger_period = src->transparent_trigger_period;
179 break;
180
181 case TLS_PARAM_ID_DEBUG_MODE:
182 dest->debug_mode = src->debug_mode;
183 break;
184
185 case TLS_PARAM_ID_HARDVERSION:
186 MEMCPY(&dest->hardware_version, &src->hardware_version, sizeof(struct tls_param_hardware_version));
187 break;
188
189 case TLS_PARAM_ID_BRDSSID:
190 dest->ssid_broadcast_enable = src->ssid_broadcast_enable;
191 break;
192
193 case TLS_PARAM_ID_DNSNAME:
194 MEMCPY(dest->local_dnsname, src->local_dnsname, 32);
195 break;
196
197 case TLS_PARAM_ID_DEVNAME:
198 MEMCPY(dest->local_device_name, src->local_device_name, 32);
199 break;
200
201 case TLS_PARAM_ID_PSM:
202 dest->auto_powersave = src->auto_powersave;
203 break;
204
205 case TLS_PARAM_ID_ORAY_CLIENT:
206 MEMCPY(&dest->oray_client_setting, &src->oray_client_setting, sizeof(struct tls_param_oray_client));
207 break;
208
209 case TLS_PARAM_ID_UPNP:
210 dest->upnp_enable = src->upnp_enable;
211 break;
212
213 case TLS_PARAM_ID_UART:
214 MEMCPY(&dest->uart_cfg, &src->uart_cfg, sizeof(struct tls_param_uart));
215 break;
216 #if TLS_CONFIG_WPS
217 case TLS_PARAM_ID_WPS:
218 MEMCPY(&dest->wps, &src->wps, sizeof(struct tls_param_wps));
219 break;
220 #endif
221 case TLS_PARAM_ID_CHANNEL_LIST:
222 dest->channellist = src->channellist;
223 break;
224 case TLS_PARAM_ID_ONESHOT_CFG:
225 dest->oneshotflag = src->oneshotflag;
226 break;
227 case TLS_PARAM_ID_SHA1:
228 MEMCPY(&dest->psk, &src->psk, sizeof(struct tls_param_sha1));
229 break;
230 case TLS_PARAM_ID_ORIGIN_KEY:
231 MEMCPY(&dest->original_key, &src->original_key, sizeof(struct tls_param_original_key));
232 break;
233 case TLS_PARAM_ID_ORIGIN_SSID:
234 MEMCPY(&dest->original_ssid, &src->original_ssid, sizeof(struct tls_param_ssid));
235 break;
236 case TLS_PARAM_ID_AUTO_RECONNECT:
237 dest->auto_reconnect = src->auto_reconnect;
238 break;
239
240 case TLS_PARAM_ID_IO_MODE:
241 dest->IoMode = src->IoMode;
242 break;
243
244 case TLS_PARAM_ID_CMD_MODE:
245 dest->CmdMode = src->CmdMode;
246 break;
247
248 case TLS_PARAM_ID_PASSWORD:
249 MEMCPY(dest->PassWord, src->PassWord, sizeof(src->PassWord));
250 break;
251
252 case TLS_PARAM_ID_WEBS_CONFIG:
253 dest->WebsCfg = src->WebsCfg;
254 break;
255 case TLS_PARAM_ID_QUICK_CONNECT:
256 MEMCPY(&dest->quick_connect, &src->quick_connect, sizeof(struct tls_param_quick_connect));
257 break;
258 case TLS_PARAM_ID_KEY_CHANGE:
259 dest->key_changed = src->key_changed;
260 break;
261 case TLS_PARAM_ID_SSID_CHANGE:
262 dest->ssid_changed = src->ssid_changed;
263 break;
264 #if TLS_CONFIG_AP
265 case TLS_PARAM_ID_SOFTAP_SSID:
266 MEMCPY(&dest->apsta_ssid, &src->apsta_ssid, sizeof(struct tls_param_ssid));
267 break;
268 case TLS_PARAM_ID_SOFTAP_PSK:
269 MEMCPY(&dest->apsta_psk, &src->apsta_psk, sizeof(struct tls_param_sha1));
270 break;
271 case TLS_PARAM_ID_SOFTAP_ENCRY:
272 dest->encry4softap = src->encry4softap;
273 break;
274 case TLS_PARAM_ID_SOFTAP_KEY:
275 MEMCPY(&dest->key4softap, &src->key4softap, sizeof(struct tls_param_key));
276 break;
277 case TLS_PARAM_ID_SOFTAP_IP:
278 MEMCPY(&dest->ipcfg4softap, &src->ipcfg4softap, sizeof(struct tls_param_ip));
279 break;
280 case TLS_PARAM_ID_SOFTAP_CHANNEL:
281 dest->channel4softap = src->channel4softap;
282 break;
283 case TLS_PARAM_ID_SOFTAP_WBGR:
284 MEMCPY(&dest->wbgr4softap, &src->wbgr4softap, sizeof(struct tls_param_bgr));
285 break;
286 #endif
287 case TLS_PARAM_ID_SNTP_SERVER1:
288 strncpy(dest->sntp_service1, src->sntp_service1, strlen(src->sntp_service1) + 1);
289 break;
290 case TLS_PARAM_ID_SNTP_SERVER2:
291 strncpy_s(dest->sntp_service2, sizeof(dest->sntp_service2), src->sntp_service2,
292 strlen(src->sntp_service2) + 1);
293 break;
294 case TLS_PARAM_ID_SNTP_SERVER3:
295 strncpy(dest->sntp_service3, src->sntp_service3, strlen(src->sntp_service3) + 1);
296 break;
297 case TLS_PARAM_ID_TEM_OFFSET:
298 MEMCPY(&dest->params_tem, &src->params_tem, sizeof(struct tls_param_tem_offset));
299 break;
300
301 case TLS_PARAM_ID_BT_ADAPTER:
302 MEMCPY(&dest->adapter_t, &src->adapter_t, sizeof(bt_adapter_t));
303 break;
304 case TLS_PARAM_ID_BT_REMOTE_DEVICE_1:
305 MEMCPY(&dest->remote_device1, &src->remote_device1, sizeof(bt_remote_device_t));
306 break;
307 case TLS_PARAM_ID_BT_REMOTE_DEVICE_2:
308 MEMCPY(&dest->remote_device2, &src->remote_device2, sizeof(bt_remote_device_t));
309 break;
310 case TLS_PARAM_ID_BT_REMOTE_DEVICE_3:
311 MEMCPY(&dest->remote_device3, &src->remote_device3, sizeof(bt_remote_device_t));
312 break;
313 case TLS_PARAM_ID_BT_REMOTE_DEVICE_4:
314 MEMCPY(&dest->remote_device4, &src->remote_device4, sizeof(bt_remote_device_t));
315 break;
316 case TLS_PARAM_ID_BT_REMOTE_DEVICE_5:
317 MEMCPY(&dest->remote_device5, &src->remote_device5, sizeof(bt_remote_device_t));
318 break;
319 default:
320 err = TLS_PARAM_STATUS_EINVALIDID;
321 goto exit;
322 }
323 #endif
324 flash_param.magic = TLS_PARAM_MAGIC;
325 flash_param.length = sizeof(flash_param);
326
327 if (modify_count < 0) {
328 flash_param.modify_count ++;
329 TLS_DBGPRT_INFO("update the \"modify count(%d)\".\n", flash_param.modify_count);
330 } else {
331 flash_param.modify_count = modify_count;
332 TLS_DBGPRT_INFO("initialize the \"modify count(%d)\".\n", flash_param.modify_count);
333 }
334
335 if (partition_num < 0) {
336 flash_param.partition_num = (flash_param.partition_num + 1) & 0x01;
337 TLS_DBGPRT_INFO("switch the parameter patition number(%d).\n", flash_param.partition_num);
338 } else {
339 flash_param.partition_num = partition_num;
340 TLS_DBGPRT_INFO("initialize the parameter patition number(%d).\n", flash_param.partition_num);
341 }
342 flash_param.resv_1 = flash_param.resv_2 = 0;
343 flash_param.crc32 = get_crc32((u8 *)&flash_param, sizeof(flash_param) - 4);
344
345 TLS_DBGPRT_INFO("update the parameters to parameter patition(%d) in spi flash.\n", flash_param.partition_num);
346
347 err = tls_fls_write((flash_param.partition_num == 0) ? TLS_FLASH_PARAM1_ADDR : TLS_FLASH_PARAM2_ADDR,
348 (u8 *)&flash_param, sizeof(flash_param));
349 if (err != TLS_FLS_STATUS_OK) {
350 TLS_DBGPRT_ERR("write to spi flash fail(%d)!\n", err);
351 err = TLS_PARAM_STATUS_EIO;
352 goto exit;
353 }
354 if (param_flash_verify((flash_param.partition_num == 0) ? TLS_FLASH_PARAM1_ADDR : TLS_FLASH_PARAM2_ADDR,
355 (u8 *)&flash_param, sizeof(flash_param)) == 1) {
356 err = TLS_PARAM_STATUS_OK;
357 } else {
358 TLS_DBGPRT_ERR("verify the parameters in spi flash fail(%d)!\n", err);
359 err = TLS_PARAM_STATUS_EIO;
360 }
361 exit:
362
363 return err;
364 }
365
366 /**********************************************************************************************************
367 * Description: This function is used to initial system param.
368 *
369 * Arguments : sys_param is the system param addr
370 *
371
372 * Returns : TLS_PARAM_STATUS_OK init success
373 * TLS_PARAM_STATUS_EMEM memory error
374 * TLS_PARAM_STATUS_EIO io error
375 * TLS_PARAM_STATUS_EPERM
376 **********************************************************************************************************/
tls_param_init(void)377 int tls_param_init(void)
378 {
379 bool is_damage[TLS_PARAM_PARTITION_NUM];
380 u8 damaged;
381 int err;
382 signed short i;
383 u16 tryrestore = 0;
384 u32 crckey = 0xFFFFFFFF;
385 psCrcContext_t ctx;
386 u32 crcvalue = 0;
387
388 struct tls_param_flash *flash;
389
390 if (flash_param.magic == TLS_PARAM_MAGIC) {
391 TLS_DBGPRT_ERR("parameter management module has been initialized!\n");
392 return TLS_PARAM_STATUS_EPERM;
393 }
394
395 err = tls_os_sem_create(&sys_param_lock, 1);
396 if (err != TLS_OS_SUCCESS) {
397 TLS_DBGPRT_ERR("create semaphore @sys_param_lock fail!\n");
398 return TLS_PARAM_STATUS_EMEM;
399 }
400
401 tls_os_sem_acquire(sys_param_lock, 0);
402 err = TLS_PARAM_STATUS_OK;
403 i = 0;
404 damaged= 0;
405 is_damage[0] = is_damage[1] = FALSE;
406 flash = NULL;
407 memset_s(&flash_param, sizeof(flash_param), 0, sizeof(flash_param));
408 #if USE_TWO_RAM_FOR_PARAMETER
409 memset_s(&sram_param, sizeof(sram_param), 0, sizeof(sram_param));
410 #endif
411 tryrestore = 0;
412 do {
413 flash = tls_mem_alloc(sizeof(*flash));
414 if (flash == NULL) {
415 TLS_DBGPRT_ERR("allocate \"struct tls_param_flash\" fail!\n");
416 err = TLS_PARAM_STATUS_EMEM;
417 break;
418 }
419 memset_s(flash, sizeof(flash), 0, sizeof(*flash));
420
421 for (i = 0; i < TLS_PARAM_PARTITION_NUM; i++) {
422 TLS_DBGPRT_INFO("read parameter partition - %d.\n", i);
423 tls_fls_read((i == 0) ? TLS_FLASH_PARAM1_ADDR : TLS_FLASH_PARAM2_ADDR, (u8 *)flash, sizeof(*flash));
424 TLS_DBGPRT_INFO("patition %d magic - 0x%x, crc -0x%x .\n", i, flash->magic, flash->crc32);
425
426 if (flash->magic == TLS_PARAM_MAGIC) {
427 crckey = 0xFFFFFFFF;
428 tls_crypto_crc_init(&ctx, crckey, CRYPTO_CRC_TYPE_32, 3);
429 tls_crypto_crc_update(&ctx, (u8 *)flash, flash->length - 4);
430 tls_crypto_crc_final(&ctx, &crcvalue);
431 }
432
433 if (flash->magic != TLS_PARAM_MAGIC) {
434 TLS_DBGPRT_WARNING("parameter partition - %d has been damaged.\n", i);
435 is_damage[i] = TRUE;
436 damaged++;
437 continue;
438 } else if ((~crcvalue) != *(u32*)((u8*)flash + flash->length - 4)) { // 4:byte alignment
439 is_damage[i] = TRUE;
440 damaged++;
441 continue;
442 } else {
443 /* Load the latest parameters */
444 TLS_DBGPRT_INFO("read parameter partition modify count - %d.\n", flash->modify_count);
445 TLS_DBGPRT_INFO("current parameter partition modify count - %d.\n", flash_param.modify_count);
446 if ((flash_param.magic == 0) || (flash_param.modify_count < flash->modify_count)) {
447 TLS_DBGPRT_INFO("update the parameter in sram using partition - %d,%d,%d.\n",
448 i, flash->length, sizeof(*flash));
449 if (flash->length != sizeof(*flash)) {
450 MEMCPY(&flash_param, flash, (flash->length-4));
451 #if USE_TWO_RAM_FOR_PARAMETER
452 MEMCPY(&sram_param, &flash_param.parameters, sizeof(sram_param));
453 #endif
454 } else {
455 MEMCPY(&flash_param, flash, sizeof(*flash));
456 #if USE_TWO_RAM_FOR_PARAMETER
457 MEMCPY(&sram_param, &flash_param.parameters, sizeof(sram_param));
458 #endif
459 }
460 }
461 memset_s(flash, sizeof(flash), 0, sizeof(*flash));
462 }
463
464 /* try to erase one sector at the same block to restore parameter area */
465 if ((tryrestore == 0)&&(damaged >= TLS_PARAM_PARTITION_NUM)) {
466 damaged= 0;
467 is_damage[0] = is_damage[1] = FALSE;
468 memset_s(&flash_param, sizeof(&flash_param), 0, sizeof(flash_param));
469 #if USE_TWO_RAM_FOR_PARAMETER
470 memset_s(&sram_param, sizeof(&sram_param), 0, sizeof(sram_param));
471 #endif
472 tls_fls_erase(TLS_FLASH_PARAM_RESTORE_ADDR / INSIDE_FLS_SECTOR_SIZE);
473 tryrestore = 1;
474 i = -1;
475 }
476 }
477
478 if (damaged >= TLS_PARAM_PARTITION_NUM) {
479 TLS_DBGPRT_INFO("all the parameter partitions has been demaged and load the default parameters.\n");
480 tls_param_load_factory_default();
481
482 TLS_DBGPRT_INFO("write the default parameters to all the partitions.\n");
483 err = param_to_flash(TLS_PARAM_ID_ALL, 1, 0);
484 if (err != TLS_PARAM_STATUS_OK) {
485 TLS_DBGPRT_ERR("write the default parameters to the partitions - 0 fail!\n");
486 err = TLS_PARAM_STATUS_EIO;
487 break;
488 }
489
490 err = param_to_flash(TLS_PARAM_ID_ALL, 1, 1);
491 if (err != TLS_PARAM_STATUS_OK) {
492 TLS_DBGPRT_ERR("write the default parameters to the partitions - 1 fail!\n");
493 err = TLS_PARAM_STATUS_EIO;
494 break;
495 }
496 } else {
497 /* restore damaged partitions */
498 for (i = 0; i < TLS_PARAM_PARTITION_NUM; i++) {
499 if (is_damage[i]) {
500 TLS_DBGPRT_INFO(" restore damaged partitions - %d.\n", i);
501 err = param_to_flash(TLS_PARAM_ID_ALL, -1, i);
502 if (err != TLS_PARAM_STATUS_OK) {
503 TLS_DBGPRT_ERR("write the default parameters to the partitions - %d fail!\n", i);
504 err = TLS_PARAM_STATUS_EIO;
505 break;
506 }
507 }
508 }
509
510 if (err == TLS_PARAM_STATUS_OK) {
511 break;
512 }
513 }
514 }while (0);
515
516 tls_os_sem_release(sys_param_lock);
517
518 if (flash) {
519 tls_mem_free(flash);
520 }
521 return err;
522 }
523
524 #define TLS_USER_MAGIC 0x574D3031 // WM01
tls_param_load_user(struct tls_sys_param * param)525 int tls_param_load_user(struct tls_sys_param *param)
526 {
527 u32 magic, crc32, offset;
528
529 offset = TLS_FLASH_PARAM_DEFAULT;
530 tls_fls_read(offset, (u8 *)&magic, 4);
531 if (magic != TLS_USER_MAGIC) {
532 TLS_DBGPRT_INFO("no user default param = %x!!!\r\n", magic);
533 return TLS_PARAM_STATUS_EINVALID;
534 }
535 offset += 4;
536 memset_s(param, sizeof(param), 0, sizeof(*param));
537 tls_fls_read(offset, (u8 *)param, sizeof(struct tls_sys_param));
538 offset += sizeof(struct tls_sys_param);
539 tls_fls_read(offset, (u8 *)&crc32, 4);
540 if (crc32 != get_crc32((u8 *)param, sizeof(struct tls_sys_param))) {
541 TLS_DBGPRT_INFO("user default param crc err =%x!!!\r\n", crc32);
542 return TLS_PARAM_STATUS_EINVALID;
543 }
544 return TLS_PARAM_STATUS_OK;
545 }
546
547 /**********************************************************************************************************
548 * Description: This function is used to load the system default parameters.
549 *
550 * Arguments : param is the param point
551 *
552
553 * Returns
554 *
555 * Notes : This function read user defined parameters first, if wrong, all the parameters restore factory settings.
556 **********************************************************************************************************/
tls_param_load_factory_default(void)557 void tls_param_load_factory_default(void)
558 {
559 #if USE_TWO_RAM_FOR_PARAMETER
560 struct tls_sys_param *param = &sram_param;
561 #else
562 struct tls_sys_param *param = &flash_param.parameters;
563 #endif
564
565 if (param == NULL) {return;}
566
567 TLS_DBGPRT_INFO("load the default parameters.\n");
568
569 memset_s(param, sizeof(param), 0, sizeof(*param));
570 MEMCPY(¶m->hardware_version, factory_default_hardware, 8);
571
572 param->wireless_region = TLS_PARAM_REGION_1_BG_BAND;
573 param->channel = 1;
574 param->channellist = 0x3FFF;
575 #if TLS_CONFIG_11N
576 param->wbgr.bg = TLS_PARAM_PHY_11BGN_MIXED;
577 param->wbgr.max_rate = TLS_PARAM_TX_RATEIDX_MCS13;
578 #else
579 param->wbgr.bg = TLS_PARAM_PHY_11BG_MIXED;
580 param->wbgr.max_rate = TLS_PARAM_TX_RATEIDX_36M;
581 #endif
582 param->ssid_broadcast_enable = TLS_PARAM_SSIDBRD_ENABLE;
583 param->encry = TLS_PARAM_ENCRY_OPEN;
584
585 param->wireless_protocol = TLS_PARAM_IEEE80211_INFRA;
586
587 param->auto_retrycnt = 255;
588 param->auto_roam = TLS_PARAM_ROAM_DISABLE;
589 param->auto_powersave = TLS_PARAM_PSM_DISABLE;
590 param->auto_reconnect = 0;
591
592 param->auto_mode = TLS_PARAM_MANUAL_MODE;
593 param->transparent_trigger_length = 512;
594
595 param->uart_cfg.baudrate = TLS_PARAM_UART_BAUDRATE_B115200;
596 param->uart_cfg.stop_bits = TLS_PARAM_UART_STOPBITS_1BITS;
597 param->uart_cfg.parity = TLS_PARAM_UART_PARITY_NONE;
598
599 param->user_port_mode = TLS_PARAM_USR_INTF_LUART;
600
601 param->ipcfg.dhcp_enable = TLS_PARAM_DHCP_ENABLE;
602 param->ipcfg.ip[0] = 192;
603 param->ipcfg.ip[1] = 168;
604 param->ipcfg.ip[2] = 1;
605 param->ipcfg.ip[3] = 1;
606 param->ipcfg.netmask[0] = 255;
607 param->ipcfg.netmask[1] = 255;
608 param->ipcfg.netmask[2] = 255;
609 param->ipcfg.netmask[3] = 0;
610 param->ipcfg.gateway[0] = 192;
611 param->ipcfg.gateway[1] = 168;
612 param->ipcfg.gateway[2] = 1;
613 param->ipcfg.gateway[3] = 1;
614 param->ipcfg.dns1[0] = 192;
615 param->ipcfg.dns1[1] = 168;
616 param->ipcfg.dns1[2] = 1;
617 param->ipcfg.dns1[3] = 1;
618 param->ipcfg.dns2[0] = 192;
619 param->ipcfg.dns2[1] = 168;
620 param->ipcfg.dns2[2] = 1;
621 param->ipcfg.dns2[3] = 1;
622
623 strcpy_s((char *)param->local_dnsname, sizeof(param->local_dnsname), "local.winnermicro");
624 strcpy_s((char *)param->local_device_name, sizeof(param->local_device_name), "w800");
625
626 param->remote_socket_cfg.protocol = TLS_PARAM_SOCKET_TCP;
627 param->remote_socket_cfg.client_or_server = TLS_PARAM_SOCKET_SERVER;
628 param->remote_socket_cfg.port_num = TLS_PARAM_SOCKET_DEFAULT_PORT;
629 memset_s(param->remote_socket_cfg.host, sizeof(param->remote_socket_cfg.host), 0, 32); // 32:size
630
631 param->EscapeChar = 0x2b;
632 param->EscapePeriod = 200;
633
634 param->WebsCfg.AutoRun = 1;
635 param->WebsCfg.PortNum = 80;
636
637 param->debug_mode = 0;
638 memset_s(param->PassWord, sizeof(param->PassWord), '0', 6);
639
640 param->channel4softap = 11; // 11:byte alignment
641 param->encry4softap = TLS_PARAM_ENCRY_OPEN;
642 param->ipcfg4softap.dhcp_enable = TLS_PARAM_DHCP_ENABLE;
643 param->ipcfg4softap.ip[0] = 192;
644 param->ipcfg4softap.ip[1] = 168;
645 param->ipcfg4softap.ip[2] = 0;
646 param->ipcfg4softap.ip[3] = 1;
647 param->ipcfg4softap.netmask[0] = 255;
648 param->ipcfg4softap.netmask[1] = 255;
649 param->ipcfg4softap.netmask[2] = 255;
650 param->ipcfg4softap.netmask[3] = 0;
651 param->ipcfg4softap.gateway[0] = 192;
652 param->ipcfg4softap.gateway[1] = 168;
653 param->ipcfg4softap.gateway[2] = 0;
654 param->ipcfg4softap.gateway[3] = 1;
655 param->ipcfg4softap.dns1[0] = 192;
656 param->ipcfg4softap.dns1[1] = 168;
657 param->ipcfg4softap.dns1[2] = 0;
658 param->ipcfg4softap.dns1[3] = 1;
659 param->ipcfg4softap.dns2[0] = 0;
660 param->ipcfg4softap.dns2[1] = 0;
661 param->ipcfg4softap.dns2[2] = 0;
662 param->ipcfg4softap.dns2[3] = 0;
663 #if TLS_CONFIG_SOFTAP_11N
664 param->wbgr4softap.bg = TLS_PARAM_PHY_11BGN_MIXED;
665 param->wbgr4softap.max_rate = TLS_PARAM_TX_RATEIDX_36M;
666 #else
667 param->wbgr4softap.bg = TLS_PARAM_PHY_11BG_MIXED;
668 param->wbgr4softap.max_rate = TLS_PARAM_TX_RATEIDX_36M;
669 #endif
670
671 strcpy_s(param->sntp_service1, sizeof(param->sntp_service1), "cn.ntp.org.cn");
672 strcpy_s(param->sntp_service2, sizeof(param->sntp_service2), "ntp.sjtu.edu.cn");
673 strcpy_s(param->sntp_service3, sizeof(param->sntp_service3), "us.pool.ntp.org");
674 }
675
676 /**********************************************************************************************************
677 * Description: This function is used to set system parameter.
678 *
679 * Arguments : id param id,from TLS_PARAM_ID_SSID to (TLS_PARAM_ID_MAX - 1)
680 * argc store parameters
681 * to_flash whether the parameter is written to flash,1 write
682
683 * Returns : TLS_PARAM_STATUS_OK set success
684 * TLS_PARAM_STATUS_EINVALID invalid param
685 **********************************************************************************************************/
tls_param_set(int id,void * argv,bool to_flash)686 int tls_param_set(int id, void *argv, bool to_flash)
687 {
688 int err = 0;
689 #if USE_TWO_RAM_FOR_PARAMETER
690 struct tls_sys_param *param = &sram_param;
691 #else
692 struct tls_sys_param *param = &flash_param.parameters;
693 #endif
694 if ((id < TLS_PARAM_ID_ALL) || (id >= TLS_PARAM_ID_MAX) || (argv == NULL)) {return TLS_PARAM_STATUS_EINVALID;}
695
696 if (updp_mode) {
697 param = tls_param_user_param_init();
698 if (param == NULL) {
699 return TLS_PARAM_STATUS_EMEM;
700 }
701 }
702 tls_os_sem_acquire(sys_param_lock, 0);
703
704 err = TLS_PARAM_STATUS_OK;
705 switch (id) {
706 case TLS_PARAM_ID_ALL:
707 MEMCPY(param, argv, sizeof(struct tls_sys_param));
708 break;
709
710 case TLS_PARAM_ID_SSID:
711 MEMCPY(¶m->ssid, argv, sizeof(struct tls_param_ssid));
712 break;
713
714 case TLS_PARAM_ID_ENCRY:
715 param->encry = *((u8 *)argv);
716 break;
717
718 case TLS_PARAM_ID_KEY:
719 MEMCPY(¶m->key, argv, sizeof(struct tls_param_key));
720 break;
721
722 case TLS_PARAM_ID_IP:
723 MEMCPY(¶m->ipcfg, argv, sizeof(struct tls_param_ip));
724 break;
725
726 case TLS_PARAM_ID_AUTOMODE:
727 param->auto_mode = *((u8 *)argv);
728 break;
729
730 case TLS_PARAM_ID_DEFSOCKET:
731 MEMCPY(¶m->remote_socket_cfg, argv, sizeof(struct tls_param_socket));
732 break;
733
734 case TLS_PARAM_ID_BSSID:
735 MEMCPY(¶m->bssid, argv, sizeof(struct tls_param_bssid));
736 break;
737
738 case TLS_PARAM_ID_CHANNEL:
739 param->channel = *((u8 *)argv);
740 break;
741
742 case TLS_PARAM_ID_CHANNEL_LIST:
743 param->channellist = *((u16*)argv);
744 break;
745
746 case TLS_PARAM_ID_CHANNEL_EN:
747 param->channel_enable = *((u8 *)argv);
748 break;
749
750 case TLS_PARAM_ID_COUNTRY_REGION:
751 param->wireless_region = *((u8 *)argv);
752 break;
753
754 case TLS_PARAM_ID_WPROTOCOL:
755 param->wireless_protocol = *((u8 *)argv);;
756 break;
757
758 case TLS_PARAM_ID_ADHOC_AUTOCREATE:
759 param->auto_create_adhoc = *((u8 *)argv);
760 break;
761
762 case TLS_PARAM_ID_ROAMING:
763 param->auto_roam = *((u8 *)argv);
764 break;
765
766 case TLS_PARAM_ID_AUTO_RETRY_CNT:
767 param->auto_retrycnt = *((u8 *)argv);
768 break;
769
770 case TLS_PARAM_ID_WBGR:
771 MEMCPY(¶m->wbgr, argv, sizeof(struct tls_param_bgr));
772 break;
773
774 case TLS_PARAM_ID_USRINTF:
775 param->user_port_mode = *((u8 *)argv);
776 break;
777
778 case TLS_PARAM_ID_AUTO_TRIGGER_LENGTH:
779 param->transparent_trigger_length = *((u16 *)argv);
780 break;
781
782 case TLS_PARAM_ID_AUTO_TRIGGER_PERIOD:
783 param->transparent_trigger_period = *((u16 *)argv);
784 break;
785
786 case TLS_PARAM_ID_ESCAPE_CHAR:
787 param->EscapeChar = *((u8 *)argv);
788 break;
789
790 case TLS_PARAM_ID_ESCAPE_PERIOD:
791 param->EscapePeriod = *((u16 *)argv);
792 break;
793
794 case TLS_PARAM_ID_IO_MODE:
795 param->IoMode = *((u8 *)argv);
796 break;
797
798 case TLS_PARAM_ID_CMD_MODE:
799 param->CmdMode = *((u8 *)argv);
800 break;
801
802 case TLS_PARAM_ID_PASSWORD:
803 MEMCPY(param->PassWord, (u8 *)argv, sizeof(param->PassWord));
804 break;
805 case TLS_PARAM_ID_WEBS_CONFIG:
806 param->WebsCfg = *((struct tls_webs_cfg *)argv);
807 break;
808 case TLS_PARAM_ID_DEBUG_MODE:
809 param->debug_mode = *((u32 *)argv);;
810 break;
811
812 case TLS_PARAM_ID_HARDVERSION:
813 MEMCPY(¶m->hardware_version, argv, sizeof(struct tls_param_hardware_version));
814 break;
815
816 case TLS_PARAM_ID_BRDSSID:
817 param->ssid_broadcast_enable = *((u8 *)argv);
818 break;
819
820 case TLS_PARAM_ID_DNSNAME:
821 strcpy_s((char *)param->local_dnsname, sizeof(param->local_dnsname), (char *)argv);
822 break;
823
824 case TLS_PARAM_ID_DEVNAME:
825 strcpy_s((char *)param->local_device_name, sizeof(param->local_device_name), argv);
826 break;
827
828 case TLS_PARAM_ID_PSM:
829 param->auto_powersave = *((u8 *)argv);
830 break;
831
832 case TLS_PARAM_ID_ORAY_CLIENT:
833 MEMCPY(¶m->oray_client_setting, argv, sizeof(struct tls_param_oray_client));
834 break;
835
836 case TLS_PARAM_ID_UPNP:
837 param->upnp_enable = *((u8 *)argv);
838 break;
839
840 case TLS_PARAM_ID_UART:
841 MEMCPY(¶m->uart_cfg, argv, sizeof(struct tls_param_uart));
842 break;
843 #if TLS_CONFIG_WPS
844 case TLS_PARAM_ID_WPS:
845 MEMCPY(¶m->wps, argv, sizeof(struct tls_param_wps));
846 break;
847 #endif
848 case TLS_PARAM_ID_ONESHOT_CFG:
849 param->oneshotflag = *((u8 *)argv);
850 break;
851 case TLS_PARAM_ID_SHA1:
852 MEMCPY(¶m->psk, (u8 *)argv, sizeof(struct tls_param_sha1));
853
854 break;
855 case TLS_PARAM_ID_ORIGIN_KEY:
856 MEMCPY(¶m->original_key, (u8*)argv, sizeof(struct tls_param_original_key));
857 break;
858 case TLS_PARAM_ID_ORIGIN_SSID:
859 MEMCPY(¶m->original_ssid, (u8*)argv, sizeof(struct tls_param_ssid));
860 break;
861 case TLS_PARAM_ID_AUTO_RECONNECT:
862 param->auto_reconnect = *((u8 *)argv);
863 break;
864 case TLS_PARAM_ID_QUICK_CONNECT:
865 MEMCPY(¶m->quick_connect, argv, sizeof(struct tls_param_quick_connect));
866 break;
867 case TLS_PARAM_ID_KEY_CHANGE:
868 param->key_changed = *((u8 *)argv);
869 break;
870 case TLS_PARAM_ID_SSID_CHANGE:
871 param->ssid_changed = *((u8 *)argv);
872 break;
873 #if TLS_CONFIG_AP
874 case TLS_PARAM_ID_SOFTAP_SSID:
875 MEMCPY(¶m->apsta_ssid, argv, sizeof(struct tls_param_ssid));
876 break;
877 case TLS_PARAM_ID_SOFTAP_PSK:
878 MEMCPY(¶m->apsta_psk, argv, sizeof(struct tls_param_sha1));
879 break;
880 case TLS_PARAM_ID_SOFTAP_ENCRY:
881 param->encry4softap = *((u8 *)argv);
882 break;
883 case TLS_PARAM_ID_SOFTAP_KEY:
884 MEMCPY(¶m->key4softap, argv, sizeof(struct tls_param_key));
885 break;
886 case TLS_PARAM_ID_SOFTAP_IP:
887 MEMCPY(¶m->ipcfg4softap, argv, sizeof(struct tls_param_ip));
888 break;
889 case TLS_PARAM_ID_SOFTAP_CHANNEL:
890 param->channel4softap = *((u8 *)argv);
891 break;
892 case TLS_PARAM_ID_SOFTAP_WBGR:
893 MEMCPY(¶m->wbgr4softap, argv, sizeof(struct tls_param_bgr));
894 break;
895 #endif
896 case TLS_PARAM_ID_SNTP_SERVER1:
897 strncpy_s(param->sntp_service1, sizeof(param->sntp_service1), (const char *)argv, strlen(argv) + 1);
898 break;
899 case TLS_PARAM_ID_SNTP_SERVER2:
900 strncpy_s(param->sntp_service2, sizeof(param->sntp_service2), (const char *)argv, strlen(argv) + 1);
901 break;
902 case TLS_PARAM_ID_SNTP_SERVER3:
903 strncpy_s(param->sntp_service3, sizeof(param->sntp_service3), (const char *)argv, strlen(argv) + 1);
904 break;
905 case TLS_PARAM_ID_TEM_OFFSET:
906 MEMCPY(¶m->params_tem, argv, sizeof(struct tls_param_tem_offset));
907 break;
908
909 case TLS_PARAM_ID_BT_ADAPTER:
910 MEMCPY(¶m->adapter_t, argv, sizeof(bt_adapter_t));
911 break;
912 case TLS_PARAM_ID_BT_REMOTE_DEVICE_1:
913 MEMCPY(¶m->remote_device1, argv, sizeof(bt_remote_device_t));
914 break;
915 case TLS_PARAM_ID_BT_REMOTE_DEVICE_2:
916 MEMCPY(¶m->remote_device2, argv, sizeof(bt_remote_device_t));
917 break;
918 case TLS_PARAM_ID_BT_REMOTE_DEVICE_3:
919 MEMCPY(¶m->remote_device3, argv, sizeof(bt_remote_device_t));
920 break;
921 case TLS_PARAM_ID_BT_REMOTE_DEVICE_4:
922 MEMCPY(¶m->remote_device4, argv, sizeof(bt_remote_device_t));
923 break;
924 case TLS_PARAM_ID_BT_REMOTE_DEVICE_5:
925 MEMCPY(¶m->remote_device5, argv, sizeof(bt_remote_device_t));
926 break;
927 default:
928 TLS_DBGPRT_WARNING("invalid parameter id - %d!\n", id);
929 err = TLS_PARAM_STATUS_EINVALIDID;
930 goto exit;
931 }
932
933 if (to_flash && !updp_mode) {
934 err = param_to_flash(id, -1, -1);
935 TLS_DBGPRT_INFO("write the parameter to spi flash - %d.\n", err);
936 }
937 exit:
938 tls_os_sem_release(sys_param_lock);
939
940 return err;
941 }
942
943 /**********************************************************************************************************
944 * Description: This function is used to get system parameter.
945 *
946 * Arguments : id param id,from TLS_PARAM_ID_SSID to (TLS_PARAM_ID_MAX - 1)
947 * argc store parameters
948 * from_flash whether the parameter is readed from flash,1 read from flash
949
950 * Returns : TLS_PARAM_STATUS_OK success
951 * TLS_PARAM_STATUS_EINVALID invalid param
952 **********************************************************************************************************/
tls_param_get(int id,void * argv,bool from_flash)953 int tls_param_get(int id, void *argv, bool from_flash)
954 {
955 int err;
956 struct tls_sys_param *src = NULL;
957
958 if ((id < TLS_PARAM_ID_ALL) || (id >= TLS_PARAM_ID_MAX)) {return TLS_PARAM_STATUS_EINVALID;}
959
960 err = TLS_PARAM_STATUS_OK;
961 #if USE_TWO_RAM_FOR_PARAMETER
962 if (from_flash) {
963 src = &flash_param.parameters;
964 } else {src = &sram_param;}
965 #else
966 struct tls_param_flash *curflashparm = NULL;
967 if (from_flash) {
968 curflashparm = tls_mem_alloc(sizeof(struct tls_param_flash));
969 if (curflashparm) {
970 if (TLS_FLS_STATUS_OK == tls_fls_read((flash_param.partition_num == 0) ? TLS_FLASH_PARAM1_ADDR : \
971 TLS_FLASH_PARAM2_ADDR, (u8 *)curflashparm, sizeof(struct tls_param_flash))) {
972 src = &curflashparm->parameters;
973 }
974 }
975 }
976
977 if (src == NULL) {
978 src = &flash_param.parameters;
979 }
980 #endif
981
982 tls_os_sem_acquire(sys_param_lock, 0);
983
984 switch (id) {
985 case TLS_PARAM_ID_ALL:
986 MEMCPY(argv, src, sizeof(struct tls_sys_param));
987 break;
988
989 case TLS_PARAM_ID_SSID:
990 MEMCPY(argv, &src->ssid, sizeof(struct tls_param_ssid));
991 break;
992
993 case TLS_PARAM_ID_ENCRY:
994 *((u8 *)argv) = src->encry;
995 break;
996
997 case TLS_PARAM_ID_KEY:
998 MEMCPY(argv, &src->key, sizeof(struct tls_param_key));
999 break;
1000
1001 case TLS_PARAM_ID_IP:
1002 MEMCPY(argv, &src->ipcfg, sizeof(struct tls_param_ip));
1003 break;
1004
1005 case TLS_PARAM_ID_AUTOMODE:
1006 *((u8 *)argv) = src->auto_mode;
1007 break;
1008
1009 case TLS_PARAM_ID_DEFSOCKET:
1010 MEMCPY(argv, &src->remote_socket_cfg, sizeof(struct tls_param_socket));
1011 break;
1012
1013 case TLS_PARAM_ID_BSSID:
1014 MEMCPY(argv, &src->bssid, sizeof(struct tls_param_bssid));
1015 break;
1016
1017 case TLS_PARAM_ID_CHANNEL:
1018 *((u8 *)argv) = src->channel;
1019 break;
1020 case TLS_PARAM_ID_CHANNEL_LIST:
1021 *((u16*)argv) = src->channellist;
1022 break;
1023
1024 case TLS_PARAM_ID_CHANNEL_EN:
1025 *((u8 *)argv) = src->channel_enable;
1026 break;
1027
1028 case TLS_PARAM_ID_COUNTRY_REGION:
1029 *((u8 *)argv) = src->wireless_region;
1030 break;
1031
1032 case TLS_PARAM_ID_WPROTOCOL:
1033 *((u8 *)argv) = src->wireless_protocol;
1034 break;
1035
1036 case TLS_PARAM_ID_ADHOC_AUTOCREATE:
1037 *((u8 *)argv) = src->auto_create_adhoc;
1038 break;
1039
1040 case TLS_PARAM_ID_ROAMING:
1041 *((u8 *)argv) = src->auto_roam;
1042 break;
1043
1044 case TLS_PARAM_ID_AUTO_RETRY_CNT:
1045 *((u8 *)argv) = src->auto_retrycnt;
1046 break;
1047
1048 case TLS_PARAM_ID_WBGR:
1049 MEMCPY(argv, &src->wbgr, sizeof(struct tls_param_bgr));
1050 break;
1051
1052 case TLS_PARAM_ID_USRINTF:
1053 *((u8 *)argv) = src->user_port_mode;
1054 break;
1055
1056 case TLS_PARAM_ID_AUTO_TRIGGER_LENGTH:
1057 *((u16 *)argv) = src->transparent_trigger_length;
1058 break;
1059 case TLS_PARAM_ID_AUTO_TRIGGER_PERIOD:
1060 *((u16 *)argv) = src->transparent_trigger_period;
1061 break;
1062
1063 case TLS_PARAM_ID_ESCAPE_CHAR:
1064 *((u8 *)argv) = src->EscapeChar;
1065 break;
1066
1067 case TLS_PARAM_ID_ESCAPE_PERIOD:
1068 *((u16 *)argv) = src->EscapePeriod;
1069 break;
1070 case TLS_PARAM_ID_IO_MODE:
1071 *((u8 *)argv) = src->IoMode;
1072 break;
1073 case TLS_PARAM_ID_CMD_MODE:
1074 *((u8 *)argv) = src->CmdMode;
1075 break;
1076
1077 case TLS_PARAM_ID_PASSWORD:
1078 MEMCPY((u8 *)argv, src->PassWord, sizeof(src->PassWord));
1079 break;
1080 case TLS_PARAM_ID_WEBS_CONFIG:
1081 *((struct tls_webs_cfg *)argv) = src->WebsCfg;
1082 break;
1083
1084 case TLS_PARAM_ID_DEBUG_MODE:
1085 *((u32 *)argv) = src->debug_mode;
1086 break;
1087
1088 case TLS_PARAM_ID_HARDVERSION:
1089 MEMCPY(argv, &src->hardware_version, sizeof(struct tls_param_hardware_version));
1090 break;
1091
1092 case TLS_PARAM_ID_BRDSSID:
1093 *((u8 *)argv) = src->ssid_broadcast_enable;
1094 break;
1095
1096 case TLS_PARAM_ID_DNSNAME:
1097 strcpy_s((char *)argv, sizeof(argv), (char *)src->local_dnsname);
1098 break;
1099
1100 case TLS_PARAM_ID_DEVNAME:
1101 strcpy_s((char *)argv, sizeof(argv), (char *)src->local_device_name);
1102 break;
1103
1104 case TLS_PARAM_ID_PSM:
1105 *((u8 *)argv) = src->auto_powersave;
1106 break;
1107
1108 case TLS_PARAM_ID_ORAY_CLIENT:
1109 MEMCPY(argv, &src->oray_client_setting, sizeof(struct tls_param_oray_client));
1110 break;
1111
1112 case TLS_PARAM_ID_UPNP:
1113 *((u8 *)argv) = src->upnp_enable;
1114 break;
1115
1116 case TLS_PARAM_ID_UART:
1117 MEMCPY(argv, &src->uart_cfg, sizeof(struct tls_param_uart));
1118 break;
1119 #if TLS_CONFIG_WPS
1120 case TLS_PARAM_ID_WPS:
1121 MEMCPY(argv, &src->wps, sizeof(struct tls_param_wps));
1122 break;
1123 #endif
1124 case TLS_PARAM_ID_ONESHOT_CFG:
1125 *((u8 *)argv) = src->oneshotflag;
1126 break;
1127 case TLS_PARAM_ID_SHA1:
1128 MEMCPY(argv, &src->psk, sizeof(struct tls_param_sha1));
1129
1130 break;
1131 case TLS_PARAM_ID_ORIGIN_KEY:
1132 MEMCPY(argv, &src->original_key, sizeof(struct tls_param_original_key));
1133 break;
1134 case TLS_PARAM_ID_ORIGIN_SSID:
1135 MEMCPY(argv, &src->original_ssid, sizeof(struct tls_param_ssid));
1136 break;
1137 case TLS_PARAM_ID_AUTO_RECONNECT:
1138 *((u8 *)argv) = src->auto_reconnect;
1139 break;
1140 case TLS_PARAM_ID_QUICK_CONNECT:
1141 MEMCPY(argv, &src->quick_connect, sizeof(struct tls_param_quick_connect));
1142 break;
1143 case TLS_PARAM_ID_KEY_CHANGE:
1144 *((u8 *)argv) = src->key_changed;
1145 break;
1146 case TLS_PARAM_ID_SSID_CHANGE:
1147 *((u8 *)argv) = src->ssid_changed;
1148 break;
1149 #if TLS_CONFIG_AP
1150 case TLS_PARAM_ID_SOFTAP_SSID:
1151 MEMCPY(argv, &src->apsta_ssid, sizeof(struct tls_param_ssid));
1152 break;
1153 case TLS_PARAM_ID_SOFTAP_PSK:
1154 MEMCPY(argv, &src->apsta_psk, sizeof(struct tls_param_sha1));
1155 break;
1156 case TLS_PARAM_ID_SOFTAP_ENCRY:
1157 *((u8 *)argv) = src->encry4softap;
1158 break;
1159 case TLS_PARAM_ID_SOFTAP_KEY:
1160 MEMCPY(argv, &src->key4softap, sizeof(struct tls_param_key));
1161 break;
1162 case TLS_PARAM_ID_SOFTAP_IP:
1163 MEMCPY(argv, &src->ipcfg4softap, sizeof(struct tls_param_ip));
1164 break;
1165 case TLS_PARAM_ID_SOFTAP_CHANNEL:
1166 *((u8 *)argv) = src->channel4softap;
1167 break;
1168 case TLS_PARAM_ID_SOFTAP_WBGR:
1169 MEMCPY(argv, &src->wbgr4softap, sizeof(struct tls_param_bgr));
1170 break;
1171 #endif
1172
1173 case TLS_PARAM_ID_SNTP_SERVER1:
1174 strncpy_s(argv, sizeof(argv), src->sntp_service1, strlen(src->sntp_service1)+1);
1175 break;
1176 case TLS_PARAM_ID_SNTP_SERVER2:
1177 strncpy_s(argv, sizeof(argv), src->sntp_service2, strlen(src->sntp_service2)+1);
1178 break;
1179 case TLS_PARAM_ID_SNTP_SERVER3:
1180 strncpy_s(argv, sizeof(argv), src->sntp_service3, strlen(src->sntp_service3)+1);
1181 break;
1182 case TLS_PARAM_ID_TEM_OFFSET:
1183 MEMCPY(argv, &src->params_tem, sizeof(struct tls_param_tem_offset));
1184 break;
1185
1186 case TLS_PARAM_ID_BT_ADAPTER:
1187 MEMCPY(argv, &src->adapter_t, sizeof(bt_adapter_t));
1188 break;
1189 case TLS_PARAM_ID_BT_REMOTE_DEVICE_1:
1190 MEMCPY(argv, &src->remote_device1, sizeof(bt_remote_device_t));
1191 break;
1192 case TLS_PARAM_ID_BT_REMOTE_DEVICE_2:
1193 MEMCPY(argv, &src->remote_device2, sizeof(bt_remote_device_t));
1194 break;
1195 case TLS_PARAM_ID_BT_REMOTE_DEVICE_3:
1196 MEMCPY(argv, &src->remote_device3, sizeof(bt_remote_device_t));
1197 break;
1198 case TLS_PARAM_ID_BT_REMOTE_DEVICE_4:
1199 MEMCPY(argv, &src->remote_device4, sizeof(bt_remote_device_t));
1200 break;
1201 case TLS_PARAM_ID_BT_REMOTE_DEVICE_5:
1202 MEMCPY(argv, &src->remote_device5, sizeof(bt_remote_device_t));
1203 break;
1204 default:
1205 TLS_DBGPRT_WARNING("invalid parameter id - %d!\n", id);
1206 err = TLS_PARAM_STATUS_EINVALIDID;
1207 break;
1208 }
1209 #if USE_TWO_RAM_FOR_PARAMETER
1210 #else
1211 if (curflashparm) {
1212 tls_mem_free(curflashparm);
1213 }
1214 #endif
1215
1216 tls_os_sem_release(sys_param_lock);
1217
1218 return err;
1219 }
1220
1221 /**********************************************************************************************************
1222 * Description: This function is used to write parameter to flash.
1223 *
1224 * Arguments : id param id,from TLS_PARAM_ID_ALL to (TLS_PARAM_ID_MAX - 1)
1225 *
1226 * Returns : * Returns : TLS_PARAM_STATUS_OK success
1227 * TLS_PARAM_STATUS_EINVALID invalid param
1228 * TLS_PARAM_STATUS_EIO error
1229 **********************************************************************************************************/
tls_param_to_flash(int id)1230 int tls_param_to_flash(int id)
1231 {
1232 int err = 0;
1233
1234 tls_os_sem_acquire(sys_param_lock, 0);
1235 #if USE_TWO_RAM_FOR_PARAMETER
1236 if (TLS_PARAM_ID_ALL == id) {
1237 if (memcmp(&sram_param, &flash_param.parameters, sizeof(sram_param) == 0)) {
1238 tls_os_sem_release(sys_param_lock);
1239 return TLS_FLS_STATUS_OK;
1240 }
1241 }
1242 err = param_to_flash(id, -1, -1);
1243 #else
1244 if (TLS_PARAM_ID_ALL == id) {
1245 struct tls_param_flash *sram_param;
1246 sram_param = tls_mem_alloc(sizeof(struct tls_param_flash));
1247 if (sram_param) {
1248 if (TLS_FLS_STATUS_OK != tls_fls_read((flash_param.partition_num == 0) ? TLS_FLASH_PARAM1_ADDR : \
1249 TLS_FLASH_PARAM2_ADDR, (u8 *)sram_param, sizeof(struct tls_param_flash))) {
1250 /* write anyway!!! */
1251 } else { /* if not same, write to flash */
1252 if (memcmp(&sram_param->parameters, &flash_param.parameters, sizeof(struct tls_sys_param)) == 0) {
1253 tls_mem_free(sram_param);
1254 tls_os_sem_release(sys_param_lock);
1255 return TLS_FLS_STATUS_OK;
1256 }
1257 }
1258 tls_mem_free(sram_param);
1259 }
1260 }
1261
1262 err = param_to_flash(id, -1, -1);
1263 #endif
1264 tls_os_sem_release(sys_param_lock);
1265
1266 return err;
1267 }
1268
1269 /**********************************************************************************************************
1270 * Description: This function is used to load default parametes to memory.
1271 *
1272 * Notes : This function read user defined parameters first, if wrong, all the parameters restore factory settings.
1273 **********************************************************************************************************/
tls_param_to_default(void)1274 int tls_param_to_default(void)
1275 {
1276 int err = 0;
1277 tls_param_load_factory_default();
1278 err = param_to_flash(TLS_PARAM_ID_ALL, 1, 0);
1279 if (err) {
1280 return err;
1281 }
1282 err = param_to_flash(TLS_PARAM_ID_ALL, 1, 1);
1283 flash_param.magic = 0;
1284
1285 return err;
1286 }
1287
tls_param_user_param_init(void)1288 struct tls_sys_param *tls_param_user_param_init(void)
1289 {
1290 if (user_default_param == NULL) {
1291 user_default_param = tls_mem_alloc(sizeof(*user_default_param));
1292 if (user_default_param) {
1293 memset_s(user_default_param, sizeof(user_default_param), 0, sizeof(*user_default_param));
1294 }
1295 }
1296
1297 return user_default_param;
1298 }
1299
1300 /**********************************************************************************************************
1301 * Description: This function is used to modify user default parameters,then write to flash.
1302 **********************************************************************************************************/
tls_param_save_user(struct tls_user_param * user_param)1303 int tls_param_save_user(struct tls_user_param *user_param)
1304 {
1305 struct tls_sys_param *param = tls_param_user_param_init();
1306 if (param == NULL) {
1307 return TLS_PARAM_STATUS_EMEM;
1308 }
1309
1310 param->wireless_protocol = user_param->wireless_protocol;
1311 param->auto_mode = user_param->auto_mode;
1312 param->uart_cfg.baudrate = user_param->baudrate;
1313 param->user_port_mode = user_param->user_port_mode;
1314 param->ipcfg.dhcp_enable = user_param->dhcp_enable;
1315 param->auto_powersave = user_param->auto_powersave;
1316
1317 MEMCPY(param->ipcfg.ip, user_param->ip, 4);
1318 MEMCPY(param->ipcfg.netmask, user_param->netmask, 4);
1319 MEMCPY(param->ipcfg.gateway, user_param->gateway, 4);
1320 MEMCPY(param->ipcfg.dns1, user_param->dns, 4);
1321 MEMCPY(param->ipcfg.dns2, user_param->dns, 4);
1322 param->remote_socket_cfg.protocol = user_param->socket_protocol;
1323 param->remote_socket_cfg.client_or_server = user_param->socket_client_or_server;
1324 param->remote_socket_cfg.port_num = user_param->socket_port_num;
1325 MEMCPY(param->remote_socket_cfg.host, user_param->socket_host, 32);
1326 MEMCPY(param->PassWord, user_param->PassWord, 6);
1327
1328 MEMCPY(¶m->hardware_version, factory_default_hardware, 8);
1329 param->wireless_region = TLS_PARAM_REGION_1_BG_BAND;
1330 param->channel = 1;
1331 param->channellist = 0x3FFF;
1332 param->wbgr.bg = TLS_PARAM_PHY_11BG_MIXED;
1333 param->wbgr.max_rate = TLS_PARAM_TX_RATEIDX_36M;
1334 param->ssid_broadcast_enable = TLS_PARAM_SSIDBRD_ENABLE;
1335 param->encry = TLS_PARAM_ENCRY_OPEN;
1336
1337 param->auto_retrycnt = 255;
1338 param->auto_roam = TLS_PARAM_ROAM_DISABLE;
1339
1340 param->transparent_trigger_length = 512;
1341
1342 param->uart_cfg.stop_bits = TLS_PARAM_UART_STOPBITS_1BITS;
1343 param->uart_cfg.parity = TLS_PARAM_UART_PARITY_NONE;
1344
1345 strcpy_s((char *)param->local_dnsname, sizeof(param->local_dnsname), "local.winnermicro");
1346 strcpy_s((char *)param->local_device_name, sizeof(param->local_device_name), "w800");
1347
1348 param->EscapeChar = 0x2b;
1349 param->EscapePeriod = 200;
1350
1351 param->debug_mode = 0;
1352
1353 tls_param_save_user_default();
1354
1355 return TLS_PARAM_STATUS_OK;
1356 }
1357
1358 /**********************************************************************************************************
1359 * Description: This function is used to save user parameters to the flash.
1360 **********************************************************************************************************/
tls_param_save_user_default(void)1361 int tls_param_save_user_default(void)
1362 {
1363 u32 magic, crc32, offset;
1364 if (user_default_param == NULL) {
1365 return TLS_PARAM_STATUS_EMEM;
1366 }
1367
1368 offset = TLS_FLASH_PARAM_DEFAULT;
1369 magic = TLS_USER_MAGIC;
1370 TLS_DBGPRT_INFO("=====>\n");
1371 tls_fls_write(offset, (u8 *)&magic, 4);
1372 offset += 4;
1373 tls_fls_write(offset, (u8 *)user_default_param, sizeof(struct tls_sys_param));
1374 offset += sizeof(struct tls_sys_param);
1375 crc32 = get_crc32((u8 *)user_default_param, sizeof(struct tls_sys_param));
1376 tls_fls_write(offset, (u8 *)&crc32, 4);
1377
1378 return TLS_PARAM_STATUS_OK;
1379 }
1380
tls_param_get_updp_mode(void)1381 u8 tls_param_get_updp_mode(void)
1382 {
1383 return updp_mode;
1384 }
1385
tls_param_set_updp_mode(u8 mode)1386 void tls_param_set_updp_mode(u8 mode)
1387 {
1388 updp_mode = mode;
1389 }
1390
1391