1 /*
2 * Copyright (c) 2022 FuZhou Lockzhiner Electronic 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 #include <stddef.h>
16 #include <string.h>
17 #include <stdlib.h>
18 #include <stdio.h>
19 #include <fcntl.h>
20 #include <sys/stat.h>
21 #include <sys/types.h>
22 #include <sys/socket.h>
23 #include <netinet/in.h>
24
25 #include "los_tick.h"
26 #include "los_task.h"
27 #include "los_config.h"
28 #include "los_interrupt.h"
29 #include "los_debug.h"
30 #include "los_compiler.h"
31
32 #include "lz_hardware.h"
33 #include "los_mux.h"
34 #include "config_network.h"
35
36 #ifdef __cplusplus
37 #if __cplusplus
38 extern "C" {
39 #endif /* __cpluscplus */
40 #endif /* __cpluscplus */
41
42 /* 定义无线模块功能 */
43 enum enum_network_mode {
44 ENETWORK_MODE_AP = 0,
45 ENETWORK_MODE_WIFI,
46 ENETWORK_MODE_MAX
47 } network_mode_e;
48
49 /* 定义bssid数组位移 */
50 enum enum_b_ssid {
51 EBSSID_0 = 0,
52 EBSSID_1,
53 EBSSID_2,
54 EBSSID_3,
55 EBSSID_4,
56 EBSSID_5,
57 EBSSID_MAX
58 } b_ssid_e;
59
60 /* 定义mac地址数组位移 */
61 enum enum_mac_address {
62 EMAC_ADDRESS_0 = 0,
63 EMAC_ADDRESS_1,
64 EMAC_ADDRESS_2,
65 EMAC_ADDRESS_3,
66 EMAC_ADDRESS_4,
67 EMAC_ADDRESS_5,
68 EMAC_ADDRESS_MAX
69 }mac_address_e;
70
71 /* 定义网络AP模式的任务优先级 */
72 #define TASK_PRIO_AP_MODE 5
73 /* 定义网络WiFi模式的任务优先级 */
74 #define TASK_PRIO_WIFI_MODE 15
75
76 #define OS_SLEEP_S(val) ((val) * 1000)
77 #define OS_TASK_STACK_SIZE 0x2000
78 #define OS_PORT 9997
79 #define RKNC_HEAD "rknc"
80 #define RKBC_HEAD "rkbc"
81
82 #define LOG_TAG "config_network"
83
84 #define SSID "凌智电子"
85 #define PASSWORD "88888888"
86
87 STATIC RKWifiConfig g_wificonfig = {0};
88
89 STATIC UINT32 g_wifiTask;
90 STATIC UINT32 g_softbusliteTask;
91 STATIC UINT32 g_apTask;
92
93 typedef struct {
94 bool init;
95 bool ap_on;
96 bool sta_on;
97 UINT32 muxlock;
98 } wifi_mode_lock_t;
99
100 wifi_mode_lock_t m_wml = {
101 .init = false,
102 .ap_on = false,
103 .sta_on = false,
104 };
105
106 #define MUX_LOCK_TO_TIME 30000
107
108 /* 定义SN字符串长度 */
109 #define SN_STRING_MAXSIZE 100
110 /* 定义MAC地址长度 */
111 #define MAC_ADDRESS_MAXSIZE (EMAC_ADDRESS_MAX)
112 /* 定义IP地址长度 */
113 #define IP_ADDRESS_MAXSIZE 4
114 /* 定义bssid字符串长度 */
115 #define BSSID_MAXSIZE 18
116 /* 定义SSID字符串长度 */
117 #define SSID_MAXSIZE 33
118
SetApModeOn(void)119 WifiErrorCode SetApModeOn(void)
120 {
121 if (!m_wml.init) {
122 if (LOS_MuxCreate(&m_wml.muxlock) == LOS_OK) {
123 m_wml.init = true;
124 } else {
125 printf("%s muxcreate err\n", __FUNCTION__);
126 }
127 }
128 LOS_MuxPend(m_wml.muxlock, MUX_LOCK_TO_TIME);
129
130 WifiErrorCode error;
131 HotspotConfig config = {0};
132 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork SetApModeOn start ...\n");
133
134 memcpy_s(config.ssid, WIFI_MAX_SSID_LEN, SSID, sizeof(SSID));
135 memcpy_s(config.preSharedKey, WIFI_MAX_KEY_LEN, PASSWORD, sizeof(PASSWORD));
136 config.channelNum = 1;
137 error = SetHotspotConfig(&config);
138 if (error != WIFI_SUCCESS) {
139 LZ_HARDWARE_LOGE(LOG_TAG, "rknetwork SetHotspotConfig ...error: %d\n", error);
140 LOS_MuxPost(m_wml.muxlock);
141 return error;
142 }
143
144 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork EnableHotspot ...\n");
145
146 error = EnableHotspot();
147 if (error != WIFI_SUCCESS) {
148 LZ_HARDWARE_LOGE(LOG_TAG, "rknetwork EnableHotspot ...error: %d\n", error);
149 LOS_MuxPost(m_wml.muxlock);
150 return error;
151 }
152
153 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork EnableHotspot done");
154 FlashSetResidentFlag(1);
155 m_wml.ap_on = true;
156
157 LOS_MuxPost(m_wml.muxlock);
158 return error;
159 }
160
SetApModeOff(void)161 WifiErrorCode SetApModeOff(void)
162 {
163 if (!m_wml.init) {
164 if (LOS_MuxCreate(&m_wml.muxlock) == LOS_OK) {
165 m_wml.init = true;
166 } else {
167 printf("%s muxcreate err\n", __FUNCTION__);
168 }
169 }
170 LOS_MuxPend(m_wml.muxlock, MUX_LOCK_TO_TIME);
171
172 WifiErrorCode error;
173 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork SetApModeOff start ...\n");
174 // check AP stat
175 error = IsHotspotActive();
176 if (error == WIFI_HOTSPOT_ACTIVE) {
177 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork AP is active, disable now...\n");
178 error = DisableHotspot();
179 if (error == WIFI_SUCCESS) {
180 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork disable AP success\n");
181 } else {
182 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork disable AP fail, please disable ap, error: %d\n", error);
183 LOS_MuxPost(m_wml.muxlock);
184 return error;
185 }
186 } else {
187 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork AP is inactive\n");
188 }
189
190 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork SetApModeOff end ...\n");
191 m_wml.ap_on = false;
192 if (!m_wml.sta_on) {
193 FlashSetResidentFlag(0);
194 }
195
196 LOS_MuxPost(m_wml.muxlock);
197 return error;
198 }
199
SetWifiModeOff(void)200 WifiErrorCode SetWifiModeOff(void)
201 {
202 if (!m_wml.init) {
203 if (LOS_MuxCreate(&m_wml.muxlock) == LOS_OK) {
204 m_wml.init = true;
205 } else {
206 printf("%s muxcreate err\n", __FUNCTION__);
207 }
208 }
209 LOS_MuxPend(m_wml.muxlock, MUX_LOCK_TO_TIME);
210
211 WifiErrorCode error;
212 // check wifi stat
213 int ret = IsWifiActive();
214 if (ret == WIFI_STATE_AVAILABLE) {
215 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork wifi is active, disable now...\n");
216 error = DisableWifi();
217 if (error == WIFI_SUCCESS) {
218 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork disable wifi success\n");
219 } else {
220 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork disable wifi fail, please disable wifi, error: %d\n", error);
221 LOS_MuxPost(m_wml.muxlock);
222 return error;
223 }
224 } else {
225 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork wifi is inactive\n");
226 }
227
228 m_wml.sta_on = false;
229 if (!m_wml.ap_on) {
230 FlashSetResidentFlag(0);
231 }
232
233 LOS_MuxPost(m_wml.muxlock);
234 return error;
235 }
236
SetWifiScan(void)237 static WifiErrorCode SetWifiScan(void)
238 {
239 #if WIFI_SCAN_ON
240 #define RETRY_SLEEP_MSEC 1000
241 WifiErrorCode error;
242 WifiScanInfo *infoList;
243 unsigned int retry = 15;
244 unsigned int size = WIFI_SCAN_HOTSPOT_LIMIT;
245
246 error = Scan();
247 if (error != WIFI_SUCCESS) {
248 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork Scan error: %d\n", error);
249 return error;
250 }
251
252 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork Scan done\n");
253
254 infoList = malloc(sizeof(WifiScanInfo) * WIFI_SCAN_HOTSPOT_LIMIT);
255 while (retry) {
256 error = GetScanInfoList(infoList, &size);
257 if (error != WIFI_SUCCESS || size == 0) {
258 LOS_TaskDelay(RETRY_SLEEP_MSEC);
259 retry--;
260 continue;
261 }
262
263 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork GetScanResult done\n");
264 break;
265 }
266
267 if (retry == 0) {
268 free(infoList);
269 return;
270 }
271
272 if (size > 0) {
273 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork BSSID SSID RSSI Channel\n");
274 LZ_HARDWARE_LOGD(LOG_TAG, "========================================\n");
275 for (int i = 0; i < size; i++) {
276 char bssid[BSSID_MAXSIZE];
277 char ssid[SSID_MAXSIZE];
278
279 snprintf_s(bssid,
280 BSSID_MAXSIZE,
281 SSID_MAXSIZE - 1,
282 "%02x:%02x:%02x:%02x:%02x:%02x",
283 infoList[i].bssid[EBSSID_0],
284 infoList[i].bssid[EBSSID_1],
285 infoList[i].bssid[EBSSID_2],
286 infoList[i].bssid[EBSSID_3],
287 infoList[i].bssid[EBSSID_4],
288 infoList[i].bssid[EBSSID_5]);
289 snprintf_s(ssid, SSID_MAXSIZE, SSID_MAXSIZE - 1, "%-32s", infoList[i].ssid);
290 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork %s %s %d %u\n",
291 bssid,
292 ssid,
293 infoList[i].rssi,
294 infoList[i].frequency);
295 if (strncmp(ssid, g_wificonfig.ssid) == 0) {
296 snprintf_s(g_wificonfig.bssid,
297 sizeof(g_wificonfig.bssid),
298 sizeof(g_wificonfig.bssid) - 1,
299 "%s",
300 bssid);
301 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork g_wificonfig.bssid: %s\n", g_wificonfig.bssid);
302 }
303 }
304 LZ_HARDWARE_LOGD(LOG_TAG, "========================================\n");
305 }
306 free(infoList);
307 return error;
308 #endif /* WIFI_SCAN_ON */
309 return WIFI_SUCCESS;
310 }
311
SetWifiModeOn(void)312 WifiErrorCode SetWifiModeOn(void)
313 {
314 uint8_t hwaddr[MAC_ADDRESS_MAXSIZE] = {0x10, 0xdc, 0xb6, 0x90, 0x00, 0x00};
315 uint8_t ip[IP_ADDRESS_MAXSIZE] = {192, 168, 2, 10};
316 uint8_t gateway[IP_ADDRESS_MAXSIZE] = {192, 168, 2, 1};
317 uint8_t mask[IP_ADDRESS_MAXSIZE] = {255, 255, 255, 0};
318 char temp[SN_STRING_MAXSIZE];
319 UINT32 poll_msec = 1000;
320
321 if (!m_wml.init) {
322 if (LOS_MuxCreate(&m_wml.muxlock) == LOS_OK) {
323 m_wml.init = true;
324 } else {
325 printf("%s muxcreate err\n", __FUNCTION__);
326 }
327 }
328 LOS_MuxPend(m_wml.muxlock, MUX_LOCK_TO_TIME);
329
330 WifiErrorCode error = WIFI_SUCCESS;
331 int netId = 0;
332 WifiDeviceConfig config = {0};
333
334 memcpy_s(g_wificonfig.ssid, sizeof(g_wificonfig.ssid), SSID, sizeof(SSID));
335 memcpy_s(g_wificonfig.psk, sizeof(g_wificonfig.psk), PASSWORD, sizeof(PASSWORD));
336
337 FlashInit();
338 memset_s(temp, sizeof(temp), 0, sizeof(temp));
339
340 if (LZ_HARDWARE_SUCCESS == VendorGet(VENDOR_ID_SN, temp, SN_STRING_MAXSIZE)) {
341 if (strcmp(temp, "LZ01") != 0) {
342 VendorSet(VENDOR_ID_SN, "LZ01", sizeof("LZ01"));
343 VendorSet(VENDOR_ID_PRODUCT, "小凌派", sizeof("小凌派"));
344 VendorSet(VENDOR_ID_FACTORY, "凌睿智捷", sizeof("凌睿智捷"));
345 VendorSet(VENDOR_ID_MAC, hwaddr, MAC_ADDRESS_MAXSIZE);
346 VendorSet(VENDOR_ID_NET_IP, ip, IP_ADDRESS_MAXSIZE);
347 VendorSet(VENDOR_ID_NET_GW, gateway, IP_ADDRESS_MAXSIZE);
348 VendorSet(VENDOR_ID_NET_MASK, mask, IP_ADDRESS_MAXSIZE);
349 VendorSet(VENDOR_ID_WIFI_SSID, SSID, sizeof(SSID));
350 VendorSet(VENDOR_ID_WIFI_PASSWD, PASSWORD, sizeof(PASSWORD));
351 }
352 }
353
354 VendorGet(VENDOR_ID_MAC, hwaddr, MAC_ADDRESS_MAXSIZE);
355 LZ_HARDWARE_LOGD(LOG_TAG, "%02x:%02x:%02x:%02x:%02x:%02x\n",
356 hwaddr[EMAC_ADDRESS_0], hwaddr[EMAC_ADDRESS_1], hwaddr[EMAC_ADDRESS_2],
357 hwaddr[EMAC_ADDRESS_3], hwaddr[EMAC_ADDRESS_4], hwaddr[EMAC_ADDRESS_5]);
358
359 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork SetWifiModeOn\n");
360 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork g_wificonfig.ssid %s\n", g_wificonfig.ssid);
361 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork g_wificonfig.psk %s\n", g_wificonfig.psk);
362 error = EnableWifi();
363 if (error != WIFI_SUCCESS) {
364 LZ_HARDWARE_LOGE(LOG_TAG, "rknetwork EnableWifi error: %d\n", error);
365 LOS_MuxPost(m_wml.muxlock);
366 return error;
367 }
368
369 FlashSetResidentFlag(1);
370 m_wml.sta_on = true;
371
372 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork EnableWifi done\n");
373
374 SetWifiScan();
375 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork SetWifiScan after g_wificonfig.bssid: %s\n", g_wificonfig.bssid);
376
377 config.freq = 1;
378 config.securityType = WIFI_SEC_TYPE_PSK;
379 config.wapiPskType = WIFI_PSK_TYPE_ASCII;
380
381 memcpy_s(config.ssid, WIFI_MAX_SSID_LEN, g_wificonfig.ssid, sizeof(g_wificonfig.ssid));
382 memcpy_s(config.bssid, WIFI_MAC_LEN, g_wificonfig.bssid, sizeof(g_wificonfig.bssid));
383 memcpy_s(config.preSharedKey, WIFI_MAX_KEY_LEN, g_wificonfig.psk, sizeof(g_wificonfig.psk));
384
385 if (WifiConnect(config.ssid, config.preSharedKey) != LZ_HARDWARE_SUCCESS) {
386 LZ_HARDWARE_LOGE(LOG_TAG, "WifiConnect error");
387 error = LZ_HARDWARE_FAILURE;
388 LOS_MuxPost(m_wml.muxlock);
389 return error;
390 }
391
392 LZ_HARDWARE_LOGI(LOG_TAG, "ConnectTo (%s) done", config.ssid);
393
394 WifiLinkedInfo info;
395 struct in_addr ipaddr, gw, netmask;
396 unsigned int retry = 15;
397
398 memset_s(&info, sizeof(WifiLinkedInfo), 0, sizeof(WifiLinkedInfo));
399
400 while (retry) {
401 if (GetLinkedInfo(&info) == WIFI_SUCCESS) {
402 if (info.connState == WIFI_CONNECTED) {
403 if (info.ipAddress != 0) {
404 ipaddr.s_addr = info.ipAddress;
405 LZ_HARDWARE_LOGD(LOG_TAG, "rknetwork IP (%s)", inet_ntoa(ipaddr));
406 if (WIFI_SUCCESS == GetLocalWifiGw(&gw.s_addr)) {
407 LZ_HARDWARE_LOGD(LOG_TAG, "network GW (%s)", inet_ntoa(gw));
408 }
409 if (WIFI_SUCCESS == GetLocalWifiNetmask(&netmask.s_addr)) {
410 LZ_HARDWARE_LOGD(LOG_TAG, "network NETMASK (%s)", inet_ntoa(netmask));
411 }
412 if (WIFI_SUCCESS == SetLocalWifiGw()) {
413 LZ_HARDWARE_LOGD(LOG_TAG, "set network GW");
414 }
415 if (WIFI_SUCCESS == GetLocalWifiGw(&gw.s_addr)) {
416 LZ_HARDWARE_LOGD(LOG_TAG, "network GW (%s)", inet_ntoa(gw));
417 }
418 if (WIFI_SUCCESS == GetLocalWifiNetmask(&netmask.s_addr)) {
419 LZ_HARDWARE_LOGD(LOG_TAG, "network NETMASK (%s)", inet_ntoa(netmask));
420 }
421 LOS_MuxPost(m_wml.muxlock);
422 return error;
423 }
424 }
425 }
426
427 LOS_Msleep(poll_msec);
428 retry--;
429 }
430
431 LOS_MuxPost(m_wml.muxlock);
432 return error;
433 }
434
TaskConfigApModeEntry(void)435 static void TaskConfigApModeEntry(void)
436 {
437 SetWifiModeOff();
438 SetApModeOn();
439 }
440
TaskConfigWifiModeEntry(void)441 static void TaskConfigWifiModeEntry(void)
442 {
443 SetApModeOff();
444 SetWifiModeOn();
445 }
446
TaskConfigApMode(VOID)447 UINT32 TaskConfigApMode(VOID)
448 {
449 UINT32 ret;
450 TSK_INIT_PARAM_S task = { 0 };
451
452 task.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskConfigApModeEntry;
453 task.uwStackSize = OS_TASK_STACK_SIZE;
454 task.pcName = "taskConfigApModeEntry";
455 task.usTaskPrio = TASK_PRIO_AP_MODE;
456 ret = LOS_TaskCreate(&g_apTask, &task);
457 if (ret != LOS_OK) {
458 LZ_HARDWARE_LOGE(LOG_TAG, "rknetwork LOS_TaskCreate taskConfigApModeEntry error: %d\n", ret);
459 return ret;
460 }
461
462 return LOS_OK;
463 }
464
TaskConfigWifiMode(VOID)465 UINT32 TaskConfigWifiMode(VOID)
466 {
467 UINT32 ret;
468 TSK_INIT_PARAM_S task = { 0 };
469
470 task.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskConfigWifiModeEntry;
471 task.uwStackSize = OS_TASK_STACK_SIZE;
472 task.pcName = "taskConfigWifiModeEntry";
473 task.usTaskPrio = TASK_PRIO_WIFI_MODE;
474 ret = LOS_TaskCreate(&g_wifiTask, &task);
475 if (ret != LOS_OK) {
476 LZ_HARDWARE_LOGE(LOG_TAG, "rknetwork LOS_TaskCreate taskConfigWifiModeEntry error: %d\n", ret);
477 return ret;
478 }
479
480 return LOS_OK;
481 }
482
ExternalTaskConfigNetwork(VOID)483 UINT32 ExternalTaskConfigNetwork(VOID)
484 {
485 int enable_mode = ENETWORK_MODE_WIFI;
486 UINT32 ret = LOS_OK;
487
488 if (enable_mode == ENETWORK_MODE_AP) {
489 ret = TaskConfigApMode();
490 } else if (enable_mode == ENETWORK_MODE_WIFI) {
491 ret = TaskConfigWifiMode();
492 } else {
493 LZ_HARDWARE_LOGE(LOG_TAG, "rknetwork LOS_TaskCreate taskConfigWifiModeEntry error: %d\n", ret);
494 }
495
496 return ret;
497 }
498
499 #ifdef __cplusplus
500 #if __cplusplus
501 }
502 #endif /* __cpluscplus */
503 #endif /* __cpluscplus */