1 /*
2 * Copyright (C) 2015-2020 Alibaba Group Holding Limited
3 */
4
5 #include <drivers/u_ld.h>
6 #include <vfsdev/wifi_dev.h>
7 #include <uservice/uservice.h>
8 #include <uservice/eventid.h>
9 #include <aos/hal/wifi.h>
10 #if LWIP_ETHERNETIF && !LWIP_SUPPORT
11 #include <lwip/def.h>
12 #include <lwip/netdb.h>
13 #endif
14 #include "aos/vfs.h"
15 #include "fcntl.h"
16 #include "plat_types.h"
17 #include "bwifi_interface.h"
18 #include "bes_sniffer.h"
19
20 typedef enum {
21 SCAN_NORMAL,
22 SCAN_SPECIFIED
23 } scan_type_t;
24
25 static struct {
26 uint8_t wifi_started:1;
27 uint8_t resetting:1;
28 uint8_t sta_connected:1;
29 uint8_t sta_got_ip:1;
30 uint8_t sap_started:1;
31 uint8_t sap_connected:1;
32 uint8_t smart_config:1;
33 uint8_t zero_config:1;
34
35 struct {
36 int ap_num;
37 ap_list_t ap_list[3];
38 } scan_req;
39
40 struct {
41 uint8_t bssid[6];
42 wifi_ip_stat_t ip_stat;
43 } network;
44
45 netdev_t* dev;
46
47 } wifi_status;
48
49 static monitor_data_cb_t promisc_cb;
50 static monitor_data_cb_t mgnt_frame_cb;
51
wifi_get_netif(netdev_t * dev,wifi_mode_t mode)52 struct netif *wifi_get_netif(netdev_t *dev, wifi_mode_t mode)
53 {
54 #if LWIP_ETHERNETIF && !LWIP_SUPPORT
55 if (mode == WIFI_MODE_STA)
56 return bwifi_get_netif(WIFI_IF_STATION);
57 else if (mode == WIFI_MODE_AP)
58 return bwifi_get_netif(WIFI_IF_SOFTAP);
59 #endif
60 return NULL;
61 }
62
on_wifi_connect(WIFI_USER_EVT_ID event_id,void * arg)63 static void on_wifi_connect(WIFI_USER_EVT_ID event_id, void *arg)
64 {
65 printf("%s event_id:%d\n", __func__, event_id);
66
67 if (event_id == WIFI_USER_EVT_CONN_INTER_STATE) {
68 BWIFI_CONNECT_INTER_STATE state = *(BWIFI_CONNECT_INTER_STATE *)arg;
69 int event;
70
71 switch (state) {
72 case INTER_STATE_AUTHENTICATING:
73 event = EVENT_WIFI_AUTHENTICATING;
74 break;
75 case INTER_STATE_AUTH_REJECT:
76 event = EVENT_WIFI_AUTH_REJECT;
77 break;
78 case INTER_STATE_AUTH_TIMEOUT:
79 event = EVENT_WIFI_AUTH_TIMEOUT;
80 break;
81 case INTER_STATE_ASSOCIATING:
82 event = EVENT_WIFI_ASSOCIATING;
83 break;
84 case INTER_STATE_ASSOC_REJECT:
85 event = EVENT_WIFI_ASSOC_REJECT;
86 break;
87 case INTER_STATE_ASSOC_TIMEOUT:
88 event = EVENT_WIFI_ASSOC_TIMEOUT;
89 break;
90 case INTER_STATE_ASSOCIATED:
91 event = EVENT_WIFI_ASSOCIATED;
92 break;
93 case INTER_STATE_4WAY_HANDSHAKE:
94 event = EVENT_WIFI_4WAY_HANDSHAKE;
95 break;
96 case INTER_STATE_HANDSHAKE_FAIL:
97 event = EVENT_WIFI_HANDSHAKE_FAILED;
98 break;
99 case INTER_STATE_GROUP_HANDSHAKE:
100 event = EVENT_WIFI_GROUP_HANDSHAKE;
101 break;
102 default:
103 /* Unhandled intermediate states */
104 return;
105 }
106 #if 0
107 if (m->ev_cb && m->ev_cb->stat_chg) {
108 m->ev_cb->stat_chg(m, event, NULL);
109 }
110 #endif
111 event_publish(event, NULL);
112 } else if (event_id == WIFI_USER_EVT_CONNECTED) {
113 uint8_t *bssid = (uint8_t *)arg;
114
115 wifi_status.sta_connected = 1;
116 memcpy(wifi_status.network.bssid, bssid, 6);
117 #if 0
118 if (m->ev_cb && m->ev_cb->stat_chg) {
119 m->ev_cb->stat_chg(m, NOTIFY_WIFI_CONNECTED, NULL);
120 }
121 #endif
122 event_publish(EVENT_WIFI_CONNECTED, wifi_get_netif(wifi_status.dev, WIFI_MODE_STA));
123 #if LWIP_SUPPORT
124 } else if (event_id == WIFI_USER_EVT_GOT_IP) {
125 struct ip_info *ip = (struct ip_info *)arg;
126
127 wifi_status.sta_got_ip = 1;
128 snprintf(wifi_status.network.ip_stat.ip,
129 sizeof(wifi_status.network.ip_stat.ip),
130 "%s", inet_ntoa(ip->ip));
131 snprintf(wifi_status.network.ip_stat.mask,
132 sizeof(wifi_status.network.ip_stat.mask),
133 "%s", inet_ntoa(ip->netmask));
134 snprintf(wifi_status.network.ip_stat.gate,
135 sizeof(wifi_status.network.ip_stat.gate),
136 "%s", inet_ntoa(ip->gw));
137 #if 0
138 if (m->ev_cb && m->ev_cb->ip_got) {
139 m->ev_cb->ip_got(m, &wifi_status.network.ip_stat, NULL);
140 }
141 if (m->ev_cb && m->ev_cb->para_chg) {
142 memcpy(info.bssid, wifi_status.network.bssid, 6);
143 m->ev_cb->para_chg(m, &info, NULL, 0, NULL);
144 }
145 #endif
146 #endif
147 }
148 }
149
on_wifi_disconnect(WIFI_USER_EVT_ID event_id,void * arg)150 static void on_wifi_disconnect(WIFI_USER_EVT_ID event_id, void *arg)
151 {
152 printf("%s event_id:%d\n", __func__, event_id);
153 if (event_id == WIFI_USER_EVT_DISCONNECTED) {
154 uint8_t reason = *(uint8_t *)arg;
155
156 wifi_status.sta_connected = 0;
157 wifi_status.sta_got_ip = 0;
158 printf("wifi disconnected (reason=%d, locally_generated=%d)\n",
159 reason & 0x7F, (reason & BIT(7)) >> 7);
160 #if 0
161 if (m->ev_cb && m->ev_cb->stat_chg) {
162 m->ev_cb->stat_chg(m, NOTIFY_WIFI_DISCONNECTED, &reason);
163 }
164 #endif
165 event_publish(EVENT_WIFI_DISCONNECTED, &reason);
166 }
167 }
168
on_fatal_error(WIFI_USER_EVT_ID event_id,void * arg)169 static void on_fatal_error(WIFI_USER_EVT_ID event_id, void *arg)
170 {
171 printf("%s event_id:%d\n", __func__, event_id);
172
173 if (event_id == WIFI_USER_EVT_FATAL_ERROR) {
174 uint8 rst_flag = ((BWIFI_FATAL_ERROR_RESET_T *)arg)->rst_flag;
175 uint16 error = ((BWIFI_FATAL_ERROR_RESET_T *)arg)->error_cause;
176 BWIFI_LMAC_STATUS_DUMP_T dump_info =
177 ((BWIFI_FATAL_ERROR_RESET_T *)arg)->dump_info;
178 char str_buf[300];
179 size_t nbytes;
180 ssize_t written_bytes;
181 const char *pfile = "/data/wifi_reset_reports";
182 int fd;
183
184 if (rst_flag == 1) {
185 wifi_status.resetting = 1;
186 printf("Bottom layer crashed, wifi card will be reset...\n");
187 #if 0
188 if (m->ev_cb && m->ev_cb->fatal_err) {
189 m->ev_cb->fatal_err(m, NULL);
190 }
191 #endif
192 nbytes = snprintf(str_buf, sizeof(str_buf),
193 "errorCode=0x%04x\ndumpInfo=0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x",
194 error,
195 dump_info.pac_rxc_rx_buf_in_ptr,
196 dump_info.pac_rxc_rx_buf_out_ptr,
197 dump_info.scheduler_events,
198 dump_info.lmac_pc0,
199 dump_info.lmac_pc1,
200 dump_info.lmac_lr,
201 dump_info.lmac_sp,
202 dump_info.pac_ntd_status_peek,
203 dump_info.pac_txc_status,
204 dump_info.QUEUE_0_CONTROL,
205 dump_info.QUEUE_1_CONTROL,
206 dump_info.QUEUE_2_CONTROL,
207 dump_info.QUEUE_3_CONTROL,
208 dump_info.wlan_sw_override_1,
209 dump_info.tsq_in_prog,
210 dump_info.tsq_in_cmpl);
211
212 if (nbytes <= 0) {
213 printf("snprintf fail, return %d", nbytes);
214 return;
215 }
216
217 aos_vfs_init();
218 fd = aos_open(pfile, O_CREAT | O_RDWR);
219 if (fd < 0) {
220 printf("Failed to open file %s (%d)\n", pfile, fd);
221 return;
222 }
223 written_bytes = aos_write(fd, str_buf, nbytes);
224 if (written_bytes < 0) {
225 printf("Failed to write file %s\n", pfile);
226 } else if (written_bytes != nbytes) {
227 printf("Incompletely write file %s, nbytes:%d, written_bytes:%d\n",
228 pfile, nbytes, written_bytes);
229 }
230 aos_close(fd);
231 } else if (rst_flag == 2) {
232 wifi_status.resetting = 0;
233 printf("wifi card is completely reset !!!\n");
234 #if 0
235 if (m->ev_cb && m->ev_cb->fatal_err) {
236 m->ev_cb->fatal_err(m, NULL);
237 }
238 #endif
239 }
240 }
241 }
242
haas1000_wifi_init(netdev_t * dev)243 static int haas1000_wifi_init(netdev_t *dev)
244 {
245 static int inited;
246 int ret;
247
248 if (inited)
249 return 0;
250
251 ret = bwifi_init();
252 if (ret) {
253 printf("bwifi init fail\n");
254 return -1;
255 }
256
257 /* Register event callbacks */
258 bwifi_reg_user_evt_handler(WIFI_USER_EVT_CONN_INTER_STATE, on_wifi_connect);
259 bwifi_reg_user_evt_handler(WIFI_USER_EVT_CONNECTED, on_wifi_connect);
260 bwifi_reg_user_evt_handler(WIFI_USER_EVT_GOT_IP, on_wifi_connect);
261 bwifi_reg_user_evt_handler(WIFI_USER_EVT_DISCONNECTED, on_wifi_disconnect);
262 bwifi_reg_user_evt_handler(WIFI_USER_EVT_FATAL_ERROR, on_fatal_error);
263
264 inited = 1;
265 wifi_status.wifi_started = 1;
266 wifi_status.dev = dev;
267 printf("wifi init success!!\n");
268 return 0;
269 };
270
haas1000_wifi_deinit(netdev_t * dev)271 static int haas1000_wifi_deinit(netdev_t *dev)
272 {
273 return 0;
274 }
275
haas1000_wifi_get_mac_addr(netdev_t * dev,uint8_t * mac)276 static int haas1000_wifi_get_mac_addr(netdev_t *dev, uint8_t *mac)
277 {
278 if (!mac) {printf("%s: invalid argument!\n", __func__); return -1;}
279 bwifi_get_own_mac(mac);
280 return 0;
281 };
282
haas1000_wifi_set_mac_addr(netdev_t * dev,const uint8_t * mac)283 static int haas1000_wifi_set_mac_addr(netdev_t *dev, const uint8_t *mac)
284 {
285 printf("WiFi HAL %s not implemeted yet!\n", __func__);
286 return -1;
287 };
288
wifi_connect_task(void * arg)289 static void wifi_connect_task(void *arg)
290 {
291 int ret = 0;
292 wifi_config_t *init_para = (wifi_config_t*)arg;
293 if (!init_para)
294 return;
295 ret = bwifi_connect_to_ssid(init_para->ssid, init_para->password, 0, 0, NULL);
296 if (ret) {
297 printf("wifi connect to %s fail:%d\n", init_para->ssid, ret);
298 #if 0
299 if (m->ev_cb && m->ev_cb->connect_fail) {
300 m->ev_cb->connect_fail(m, ret, NULL);
301 }
302 #endif
303 }
304 aos_free(init_para);
305 //aos_task_exit(0);
306 osThreadExitPub();
307 }
308
309 __SRAMDATA osThreadDef(wifi_connect_task, osPriorityNormal, 1, (4096), "wifi_connect");
haas1000_wifi_connect(netdev_t * dev,wifi_config_t * config)310 static int haas1000_wifi_connect(netdev_t *dev, wifi_config_t* config)
311 {
312 if (!config) {
313 printf("%s: invalid argument!\n", __func__);
314 return -1;
315 }
316
317 if (WARN_ON(!wifi_status.wifi_started || wifi_status.resetting))
318 return -1;
319
320 if (config->mode == WIFI_MODE_STA) {
321 wifi_config_t *init_config_ptr = aos_malloc(sizeof(wifi_config_t));
322 if (!init_config_ptr) {
323 printf("Failed to alloc init para for wifi_connect_task\n");
324 return -1;
325 }
326 strcpy(init_config_ptr->ssid, config->ssid);
327 strcpy(init_config_ptr->password, config->password);
328 //if (aos_task_new("wifi_connect", wifi_connect_task, init_para_ptr, 4096)) {
329 if (osThreadCreate(osThread(wifi_connect_task), init_config_ptr) == NULL) {
330 printf("Failed to create wifi_connect_task\n");
331 aos_free(init_config_ptr);
332 return -1;
333 }
334 } else if (config->mode == WIFI_MODE_AP) {
335 /* TODO */
336 }
337
338 return 0;
339 }
340
haas1000_wifi_notify_ip_state2drv(netdev_t * dev,wifi_ip_stat_t * in_net_para,wifi_mode_t mode)341 static int haas1000_wifi_notify_ip_state2drv(netdev_t *dev,
342 wifi_ip_stat_t *in_net_para,
343 wifi_mode_t mode)
344 {
345 #if LWIP_ETHERNETIF && !LWIP_SUPPORT
346 struct ip_info ip;
347
348 if (!in_net_para) {
349 printf("%s: invalid argument!\n", __func__);
350 return -1;
351 }
352
353 if (mode == WIFI_MODE_STA&& wifi_status.sta_connected) {
354 memcpy(&wifi_status.network.ip_stat, in_net_para, sizeof(wifi_ip_stat_t));
355 printf("set ip: %s\n", in_net_para->ip);
356 printf("set mask: %s\n", in_net_para->mask);
357 printf("set gw: %s\n", in_net_para->gate);
358 inet_aton(in_net_para->ip, &ip.ip);
359 inet_aton(in_net_para->mask, &ip.netmask);
360 inet_aton(in_net_para->gate, &ip.gw);
361 return bwifi_set_ip_addr(WIFI_IF_STATION, &ip);
362 }
363 #endif
364 return -1;
365 }
366
get_ip_stat(netdev_t * dev,wifi_ip_stat_t * out_net_para,wifi_mode_t mode)367 static int get_ip_stat(netdev_t *dev,
368 wifi_ip_stat_t *out_net_para,
369 wifi_mode_t mode)
370 {
371 #if LWIP_SUPPORT
372 if (!out_net_para) {
373 printf("%s: invalid argument!\n", __func__);
374 return -1;
375 }
376
377 if (mode == WIFI_MODE_STA&& wifi_status.sta_got_ip) {
378 memcpy(out_net_para, &wifi_status.network.ip_stat, sizeof(wifi_ip_stat_t));
379 return 0;
380 }
381 #endif
382 return -1;
383 }
384
haas1000_wifi_sta_get_link_status(netdev_t * dev,wifi_ap_record_t * out_stat)385 static int haas1000_wifi_sta_get_link_status(netdev_t *dev, wifi_ap_record_t *out_stat)
386 {
387 if (!out_stat) {
388 printf("%s: invalid argument!\n", __func__);
389 return -1;
390 }
391
392 if (wifi_status.sta_connected) {
393 out_stat->link_status = WIFI_STATUS_LINK_UP;
394 out_stat->rssi = bwifi_get_current_rssi();
395 bwifi_get_current_ssid(out_stat->ssid);
396 bwifi_get_current_bssid(out_stat->bssid);
397 out_stat->channel = bwifi_get_current_channel();
398 } else {
399 out_stat->link_status = WIFI_STATUS_LINK_DOWN;
400 }
401
402 return 0;
403 }
404
find_index_by_value(int value,int * array,int size)405 static int find_index_by_value(int value, int *array, int size)
406 {
407 int i;
408
409 for( i=0; i<size; i++ ) {
410 if( array[i] == value )
411 break;
412 }
413 return i;
414 }
415
wifi_scan(netdev_t * dev,wifi_scan_config_t * config,bool block,scan_type_t t)416 static int wifi_scan(netdev_t *dev, wifi_scan_config_t* config, bool block, scan_type_t t)
417 {
418 int i, ret;
419 struct bwifi_ssid *scan_ssid, *prev_scan_ssid;
420 struct bwifi_scan_config scan_config;
421 struct bwifi_bss_info *scan_result;
422 static wifi_scan_result_t result = {0};
423 int index = 0, a_size = 0;
424 int scan_chs[] = {1, 6, 11, 2, 3, 4, 5, 7, 8, 9, 10, 12, 13, 0};
425
426 if (WARN_ON(!wifi_status.wifi_started || wifi_status.resetting))
427 return -1;
428
429 if (t == SCAN_SPECIFIED) {
430 prev_scan_ssid = NULL;
431 a_size = sizeof(scan_chs)/sizeof(scan_chs[0]) - 1;
432 for (i = 0; i < wifi_status.scan_req.ap_num; i++) {
433 index = find_index_by_value(wifi_status.scan_req.ap_list[i].channel, scan_chs, a_size);
434 if( index < a_size && index > i) {
435 scan_chs[index] = scan_chs[i];
436 scan_chs[i] = wifi_status.scan_req.ap_list[i].channel;
437 }
438 printf("Scan for specific SSID %s\n", wifi_status.scan_req.ap_list[i].ssid);
439 scan_ssid = (struct bwifi_ssid *)aos_malloc(sizeof(struct bwifi_ssid));
440 if (!scan_ssid) {
441 printf("Failed to malloc scan ssid struct\n");
442 break;
443 }
444 memcpy(scan_ssid->ssid,
445 wifi_status.scan_req.ap_list[i].ssid,
446 sizeof(scan_ssid->ssid));
447 scan_ssid->next = NULL;
448 if (prev_scan_ssid)
449 prev_scan_ssid->next = scan_ssid;
450 else
451 scan_config.ssids = scan_ssid;
452 prev_scan_ssid = scan_ssid;
453 }
454 scan_config.channels = scan_chs;
455 ret = bwifi_config_scan(&scan_config);
456
457 scan_ssid = scan_config.ssids;
458 while (scan_ssid) {
459 prev_scan_ssid = scan_ssid;
460 scan_ssid = scan_ssid->next;
461 aos_free(prev_scan_ssid);
462 }
463 } else {
464 ret = bwifi_scan();
465 }
466 if (ret <= 0) {
467 printf("wifi scan fail\n");
468 return -1;
469 }
470
471 scan_result = (struct bwifi_bss_info *)aos_malloc(ret * sizeof(struct bwifi_bss_info));
472 if (!scan_result) {
473 printf("Failed to malloc scan result buffer\n");
474 goto end;
475 }
476 ret = bwifi_get_scan_result(scan_result, ret);
477
478 result.ap_num = ret;
479 if (result.ap_list == NULL) {
480 result.ap_list = aos_malloc(ret * sizeof(ap_list_t));
481 } else {
482 result.ap_list = aos_realloc(result.ap_list, ret * sizeof(ap_list_t));
483 }
484 if (!result.ap_list) {
485 printf("Failed to malloc the returned ap list\n");
486 result.ap_num = 0; goto end;
487 }
488
489 for (i = 0; i < ret; i++) {
490 struct bwifi_bss_info *r = scan_result + i;
491
492 ap_list_t *res = result.ap_list + i;
493 memcpy(res->ssid, r->ssid, sizeof(res->ssid));
494 res->ap_power = r->rssi;
495 memcpy(res->bssid, r->bssid, sizeof(res->bssid));
496 }
497
498 end:
499 event_publish(EVENT_WIFI_SCAN_DONE, &result);
500
501 if (scan_result)
502 aos_free(scan_result);
503
504 return 0;
505 }
506
haas1000_wifi_start_scan(netdev_t * dev,wifi_scan_config_t * config,bool block)507 static int haas1000_wifi_start_scan(netdev_t *dev, wifi_scan_config_t* config, bool block)
508 {
509 return wifi_scan(dev, config, block, SCAN_NORMAL);
510 }
511
haas1000_wifi_start_specified_scan(netdev_t * dev,ap_list_t * ap_list,int ap_num)512 static int haas1000_wifi_start_specified_scan(netdev_t *dev, ap_list_t *ap_list, int ap_num)
513 {
514 int i = 0;
515
516 if (ap_num > 3)
517 ap_num = 3;
518 wifi_status.scan_req.ap_num = ap_num;
519 while (i < ap_num) {
520 wifi_status.scan_req.ap_list[i] = *(ap_list + i);
521 i++;
522 }
523
524 int ret = wifi_scan(dev, NULL, false, SCAN_SPECIFIED);
525
526 printf("haas start scan:%d", ret);
527 return ret;
528 }
529
disconnect_station(netdev_t * dev)530 static int disconnect_station(netdev_t *dev)
531 {
532 if (wifi_status.wifi_started && wifi_status.sta_connected && !wifi_status.resetting)
533 return bwifi_disconnect();
534
535 return 0;
536 }
537
disconnect_soft_ap(netdev_t * dev)538 static int disconnect_soft_ap(netdev_t *dev)
539 {
540 return 0;
541 }
542
haas1000_wifi_disconnect(netdev_t * dev)543 static int haas1000_wifi_disconnect(netdev_t *dev)
544 {
545 int ret = 0;
546
547 ret = disconnect_station(dev);
548 if (wifi_status.sap_started)
549 ret += disconnect_soft_ap(dev);
550 return ret;
551 }
552
haas1000_wifi_cancel_connect(netdev_t * dev)553 static int haas1000_wifi_cancel_connect(netdev_t *dev)
554 {
555 if (wifi_status.wifi_started && !wifi_status.sta_connected && !wifi_status.resetting)
556 return bwifi_disconnect();
557
558 return -1;
559 }
560
haas1000_wifi_set_channel(netdev_t * dev,int ch)561 static int haas1000_wifi_set_channel(netdev_t *dev, int ch)
562 {
563 if (WARN_ON(!wifi_status.wifi_started ||
564 wifi_status.sta_connected))
565 return -1;
566
567 return bes_sniffer_set_channel((u8)ch);
568 }
569
haas1000_wifi_get_channel(netdev_t * dev,int * ch)570 static int haas1000_wifi_get_channel(netdev_t *dev, int* ch)
571 {
572 if(ch != NULL) {
573 *ch = bwifi_get_current_channel();
574 return 0;
575 }
576 return -1;
577 }
578
579 /* Wi-Fi Smart Config */
580
wifi_sniffer_handler(unsigned short data_len,void * data)581 static int wifi_sniffer_handler(unsigned short data_len, void *data)
582 {
583 uint8_t *frame = (uint8_t *)data;
584
585 if (data == NULL) {
586 printf("%s ldpc:%d\n", __func__, data_len);
587 return 0;
588 }
589
590 printf("%s data:%p, len:%d\n", __func__, data, data_len);
591 #if 0
592 printf(" %02x %02x %02x %02x\n",
593 frame[0], frame[1], frame[2], frame[3]);
594 printf(" %02x %02x %02x %02x %02x %02x\n",
595 frame[4], frame[5], frame[6], frame[7], frame[8], frame[9]);
596 printf(" %02x %02x %02x %02x %02x %02x\n",
597 frame[10], frame[11], frame[12], frame[13], frame[14], frame[15]);
598 printf(" %02x %02x %02x %02x %02x %02x\n",
599 frame[16], frame[17], frame[18], frame[19], frame[20], frame[21]);
600 printf(" %02x %02x\n", frame[22], frame[23]);
601 #endif
602
603 if (wifi_status.smart_config && promisc_cb)
604 promisc_cb(frame, data_len, NULL);
605 else if (wifi_status.zero_config && mgnt_frame_cb) {
606 uint8_t type = frame[0] & 0xFC;
607 if (type == PROBE_REQ) {
608 printf("%s: probe request received!\n", __func__);
609 mgnt_frame_cb(frame, data_len, NULL);
610 }
611 }
612 return 0;
613 }
614
haas1000_wifi_start_monitor(netdev_t * dev)615 static int haas1000_wifi_start_monitor(netdev_t *dev)
616 {
617 if (WARN_ON(!wifi_status.wifi_started ||
618 wifi_status.sta_connected))
619 return -1;
620
621 if (bes_sniffer_start(wifi_sniffer_handler) ||
622 bes_sniffer_set_filter(0,1,1,0,0,0,0))
623 return -2;
624
625 wifi_status.smart_config = 1;
626 return 0;
627 }
628
haas1000_wifi_stop_monitor(netdev_t * dev)629 static int haas1000_wifi_stop_monitor(netdev_t *dev)
630 {
631 wifi_status.smart_config = 0;
632 return bes_sniffer_stop();
633 }
634
haas1000_wifi_register_monitor_cb(netdev_t * dev,monitor_data_cb_t fn)635 static void haas1000_wifi_register_monitor_cb(netdev_t *dev, monitor_data_cb_t fn)
636 {
637 promisc_cb = fn;
638 }
639
640 /* Wi-Fi Zero Config */
641
haas1000_wifi_start_mgnt_monitor(netdev_t * dev)642 static int haas1000_wifi_start_mgnt_monitor(netdev_t *dev)
643 {
644 if (WARN_ON(!wifi_status.sta_connected ||
645 wifi_status.resetting))
646 return -1;
647
648 if (bes_sniffer_start(wifi_sniffer_handler) ||
649 bes_sniffer_set_filter(1,0,0,0,0,0,0))
650 return -2;
651
652 wifi_status.zero_config = 1;
653 return 0;
654 }
655
haas1000_wifi_stop_mgnt_monitor(netdev_t * dev)656 static int haas1000_wifi_stop_mgnt_monitor(netdev_t *dev)
657 {
658 wifi_status.zero_config = 0;
659 return bes_sniffer_stop();
660 }
661
haas1000_wifi_register_mgnt_monitor_cb(netdev_t * dev,monitor_data_cb_t fn)662 static void haas1000_wifi_register_mgnt_monitor_cb(netdev_t *dev, monitor_data_cb_t fn)
663 {
664 mgnt_frame_cb = fn;
665 }
666
haas1000_wifi_send_80211_raw_frame(netdev_t * dev,uint8_t * buf,int len)667 static int haas1000_wifi_send_80211_raw_frame(netdev_t *dev, uint8_t *buf, int len)
668 {
669 if (WARN_ON(!wifi_status.sta_connected ||
670 wifi_status.resetting))
671 return -1;
672
673 return bes_sniffer_send_mgmt_frame(bwifi_get_current_channel(), buf, len);
674 }
675
start_ap(netdev_t * dev,const char * ssid,const char * passwd,int interval,int hide)676 static int start_ap(netdev_t *dev,
677 const char *ssid,
678 const char *passwd, int interval, int hide)
679 {
680 #ifdef __AP_MODE__
681
682 BWIFI_SEC_TYPE_T sec;
683
684 printf("start_ap ssid:%s, pwd:%s, beacon_int:%d, hidden:%d\n", ssid, passwd, interval, hide);
685
686 if (!passwd || !strlen(passwd))
687 sec = SECURITY_NONE;
688 else
689 sec = SECURITY_WPA2;
690
691 if (bwifi_set_softap_config(ssid, 0, hide, sec, passwd)) {
692 printf("Softap %s config failed\n", ssid);
693 return -1;
694 }
695
696 if (bwifi_softap_start()) {
697 printf("Softap %s start failed\n", ssid);
698 return -2;
699 }
700
701 printf("Softap %s start success!!\n", ssid);
702 wifi_status.sap_started = 1;
703 if (m->ev_cb && m->ev_cb->stat_chg) {
704 m->ev_cb->stat_chg(m, NOTIFY_AP_UP, NULL);
705 }
706 #endif
707 return 0;
708 }
709
stop_ap(netdev_t * dev)710 static int stop_ap(netdev_t *dev)
711 {
712 #ifdef __AP_MODE__
713
714 printf("stop_ap\n");
715
716 bwifi_softap_stop();
717 wifi_status.sap_started = 0;
718 if (m->ev_cb && m->ev_cb->stat_chg) {
719 m->ev_cb->stat_chg(m, NOTIFY_AP_DOWN, NULL);
720 }
721 #endif
722 return 0;
723 }
724
725 static wifi_driver_t haas1000_wifi_driver = {
726
727 /** driver info */
728 .base.os = "rtos",
729 .base.type = "solo",
730 .base.partner = "AliOS Things Team",
731 .base.app_net = "rtsp+rtp+rtcp",
732 .base.project = "HAAS100",
733 .base.cloud = "aliyun",
734
735 /** common APIs */
736 .init = haas1000_wifi_init,
737 .deinit = haas1000_wifi_deinit,
738 // .set_mode = haas1000_wifi_set_mode,
739 // .get_mode = haas1000_wifi_get_mode,
740
741 /** conf APIs */
742 .set_mac_addr = haas1000_wifi_set_mac_addr,
743 .get_mac_addr = haas1000_wifi_get_mac_addr,
744 // .set_lpm = haas1000_wifi_set_lpm,
745 // .get_lpm = haas1000_wifi_get_lpm,
746 .notify_ip_state2drv = haas1000_wifi_notify_ip_state2drv,
747
748 /** connection APIs */
749 .start_scan = haas1000_wifi_start_scan,
750 .start_specified_scan = haas1000_wifi_start_specified_scan,
751 .connect = haas1000_wifi_connect,
752 .cancel_connect = haas1000_wifi_cancel_connect,
753 .disconnect = haas1000_wifi_disconnect,
754 .sta_get_link_status = haas1000_wifi_sta_get_link_status,
755 // .ap_get_sta_list = haas1000_wifi_ap_get_sta_list,
756
757
758 /** promiscuous APIs */
759 .start_monitor = haas1000_wifi_start_monitor,
760 .stop_monitor = haas1000_wifi_stop_monitor,
761 .send_80211_raw_frame = haas1000_wifi_send_80211_raw_frame,
762 .set_channel = haas1000_wifi_set_channel,
763 .get_channel = haas1000_wifi_get_channel,
764 .register_monitor_cb = haas1000_wifi_register_monitor_cb,
765 .start_mgnt_monitor = haas1000_wifi_start_mgnt_monitor,
766 .stop_mgnt_monitor = haas1000_wifi_stop_mgnt_monitor,
767 .register_mgnt_monitor_cb = haas1000_wifi_register_mgnt_monitor_cb,
768
769 .set_smartcfg = NULL,
770 };
771
haas1000_wifi_register(void)772 int haas1000_wifi_register(void)
773 {
774 vfs_wifi_dev_register(&haas1000_wifi_driver, 0);
775 }
776
777 VFS_DRIVER_ENTRY(haas1000_wifi_register)
778
779