1 /*
2 * Copyright (c) 2019 Winner Microelectronics Co., Ltd.
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2018-09-15 flyingcys 1st version
9 */
10
11 #include <rtthread.h>
12 #include <dev_wlan.h>
13 #include "wm_type_def.h"
14 #include "wm_wifi.h"
15 #include "drv_wifi.h"
16
17 #define DBG_ENABLE
18 #define DBG_LEVEL DBG_INFO
19 #define DBG_SECTION_NAME "WIFI"
20 #define DBG_COLOR
21 #include <rtdbg.h>
22
23 #include "wm_ram_config.h"
24 #include "wm_efuse.h"
25 #include "wm_params.h"
26 #include "wm_debug.h"
27 #include "tls_ieee80211.h"
28
29 //#define ETH_RX_DUMP
30 //#define ETH_TX_DUMP
31 //#define MINI_DUMP
32
33 #define MAX_ADDR_LEN (6)
34
35 struct drv_wifi
36 {
37 struct rt_wlan_device *wlan;
38 rt_uint8_t dev_addr[MAX_ADDR_LEN];
39 };
40
41 static const struct rt_wlan_dev_ops ops;
42 static struct drv_wifi wifi_sta;
43 static struct drv_wifi wifi_ap;
44
45 extern int hed_rf_current_channel;
46
47 extern u8 *wpa_supplicant_get_mac(void);
48 extern u8 *hostapd_get_mac(void);
49 extern uint8_t* tls_wifi_buffer_acquire(int total_len);
50 extern void *tls_wl_init(u8 *tx_gain, u8* mac_addr, u8 *hwver);
51 extern int wpa_supplicant_init(u8 *mac_addr);
52 extern void wpa_supplicant_set_mac(u8 *mac);
53 extern void tls_wifi_buffer_release(rt_bool_t is_apsta, rt_uint8_t* buffer);
54
55 #if defined(ETH_RX_DUMP) || defined(ETH_TX_DUMP)
packet_dump(const char * msg,const void * ptr,rt_uint32_t len)56 static void packet_dump(const char *msg, const void *ptr, rt_uint32_t len)
57 {
58 rt_uint32_t j;
59 rt_uint8_t *p = (rt_uint8_t *)ptr;
60 rt_kprintf("%s %d byte\n", msg, len);
61
62 #ifdef MINI_DUMP
63 return;
64 #endif
65
66 for (j = 0; j < len; j++)
67 {
68 if ((j % 8) == 0)
69 {
70 rt_kprintf(" ");
71 }
72
73 if ((j % 16) == 0)
74 {
75 rt_kprintf("\r\n");
76 }
77 rt_kprintf("%02x ", *p ++);
78 }
79
80 rt_kprintf("\n\n");
81 }
82 #endif /* dump */
83
tls_netif_set_addr(void * ipaddr,void * netmask,void * gw)84 err_t tls_netif_set_addr(void *ipaddr, void *netmask, void *gw)
85 {
86 LOG_D("%s %d\r\n", __FUNCTION__, __LINE__);
87 return 0;
88 }
89
wm_ethernetif_input(const rt_uint8_t * bssid,rt_uint8_t * buf,rt_uint32_t buf_len)90 static int wm_ethernetif_input(const rt_uint8_t *bssid, rt_uint8_t *buf, rt_uint32_t buf_len)
91 {
92 rt_err_t err = -RT_ERROR;
93
94 if (0 == compare_ether_addr(bssid, wifi_ap.dev_addr))
95 err = rt_wlan_dev_report_data(wifi_ap.wlan, (void *)buf, buf_len);
96 else
97 err = rt_wlan_dev_report_data(wifi_sta.wlan, (void *)buf, buf_len);
98
99 return err ? -1 : 0;
100 }
101
wm_wlan_client_event(u8 * mac,enum tls_wifi_client_event_type event)102 static void wm_wlan_client_event(u8 *mac, enum tls_wifi_client_event_type event)
103 {
104 struct rt_wlan_buff buff;
105 struct rt_wlan_info sta;
106 rt_memcpy(sta.bssid, mac, MAX_ADDR_LEN);
107 buff.data = &sta;
108 buff.len = sizeof(sta);
109 if (WM_WIFI_CLIENT_EVENT_ONLINE == event)
110 {
111 rt_wlan_dev_indicate_event_handle(wifi_ap.wlan, RT_WLAN_DEV_EVT_AP_ASSOCIATED, &buff);
112 }
113 else
114 {
115 rt_wlan_dev_indicate_event_handle(wifi_ap.wlan, RT_WLAN_DEV_EVT_AP_DISASSOCIATED, &buff);
116 }
117 }
118
wm_wlan_status_changed(rt_uint8_t status)119 static void wm_wlan_status_changed(rt_uint8_t status)
120 {
121 LOG_D("status:%d", status);
122 switch (status)
123 {
124 case WIFI_JOIN_SUCCESS:
125 LOG_D("NETIF_WIFI_JOIN_SUCCESS");
126 rt_wlan_dev_indicate_event_handle(wifi_sta.wlan, RT_WLAN_DEV_EVT_CONNECT, RT_NULL);
127 break;
128
129 case WIFI_JOIN_FAILED:
130 LOG_D("NETIF_WIFI_JOIN_FAILED");
131 rt_wlan_dev_indicate_event_handle(wifi_sta.wlan, RT_WLAN_DEV_EVT_CONNECT_FAIL, RT_NULL);
132 break;
133
134 case WIFI_DISCONNECTED:
135 LOG_D("NETIF_WIFI_DISCONNECTED");
136 rt_wlan_dev_indicate_event_handle(wifi_sta.wlan, RT_WLAN_DEV_EVT_DISCONNECT, RT_NULL);
137 break;
138
139 case WIFI_SOFTAP_SUCCESS:
140 LOG_D("WIFI_SOFTAP_SUCCESS");
141 rt_wlan_dev_indicate_event_handle(wifi_ap.wlan, RT_WLAN_DEV_EVT_AP_START, RT_NULL);
142 break;
143
144 case WIFI_SOFTAP_CLOSED:
145 LOG_D("WIFI_SOFTAP_CLOSED");
146 rt_wlan_dev_indicate_event_handle(wifi_ap.wlan, RT_WLAN_DEV_EVT_AP_STOP, RT_NULL);
147 break;
148
149 default:
150 break;
151 }
152 }
153
wm_wlan_init(void)154 static rt_err_t wm_wlan_init(void)
155 {
156 extern rt_uint8_t tx_gain_group[];
157 rt_uint8_t mac_addr[6] = {0x00, 0x25, 0x08, 0x09, 0x01, 0x0F};
158
159 /*PARAM GAIN,MAC default*/
160 tls_ft_param_init();
161 tls_param_load_factory_default();
162 tls_param_init(); /*add param to init sysparam_lock sem*/
163
164 tls_get_tx_gain(&tx_gain_group[0]);
165 TLS_DBGPRT_INFO("tx gain ");
166 TLS_DBGPRT_DUMP((char *)(&tx_gain_group[0]), 12);
167
168 if (tls_wifi_mem_cfg(WIFI_MEM_START_ADDR, 7, 7)) /*wifi tx&rx mem customized interface*/
169 {
170 LOG_E("wl mem initial failured\n");
171 }
172
173 tls_get_mac_addr(&mac_addr[0]);
174 TLS_DBGPRT_INFO("mac addr ");
175 TLS_DBGPRT_DUMP((char *)(&mac_addr[0]), 6);
176
177 if (tls_wl_init(NULL, &mac_addr[0], NULL) == NULL)
178 {
179 LOG_I("wl driver initial failured\n");
180 }
181 if (wpa_supplicant_init(mac_addr))
182 {
183 LOG_I("supplicant initial failured\n");
184 }
185 rt_memcpy(wifi_sta.dev_addr, wpa_supplicant_get_mac(), MAX_ADDR_LEN);
186 LOG_D("sta_mac:%02x-%02x-%02x-%02x-%02x-%02x\r\n", wifi_sta.dev_addr[0], wifi_sta.dev_addr[1], wifi_sta.dev_addr[2], wifi_sta.dev_addr[3], wifi_sta.dev_addr[4], wifi_sta.dev_addr[5]);
187 rt_memcpy(wifi_ap.dev_addr, hostapd_get_mac(), MAX_ADDR_LEN);
188 LOG_D("ap_mac:%02x-%02x-%02x-%02x-%02x-%02x\r\n", wifi_ap.dev_addr[0], wifi_ap.dev_addr[1], wifi_ap.dev_addr[2], wifi_ap.dev_addr[3], wifi_ap.dev_addr[4], wifi_ap.dev_addr[5]);
189 return RT_EOK;
190 }
191
wm_wlan_promisc_dataframe_callback(u8 * data,u32 data_len)192 static void wm_wlan_promisc_dataframe_callback(u8 *data, u32 data_len)
193 {
194 rt_wlan_dev_promisc_handler(wifi_sta.wlan, data, data_len);
195 }
196
drv_wlan_init(struct rt_wlan_device * wlan)197 static rt_err_t drv_wlan_init(struct rt_wlan_device *wlan)
198 {
199 static int inited = 0;
200 if (inited)
201 return RT_EOK;
202
203 wm_wlan_init();
204
205 tls_ethernet_data_rx_callback(wm_ethernetif_input);
206 tls_wifi_status_change_cb_register(wm_wlan_status_changed);
207 tls_wifi_softap_client_event_register(wm_wlan_client_event);
208 inited = 1;
209 return RT_EOK;
210 }
211
drv_wlan_mode(struct rt_wlan_device * wlan,rt_wlan_mode_t mode)212 static rt_err_t drv_wlan_mode(struct rt_wlan_device *wlan, rt_wlan_mode_t mode)
213 {
214 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
215 u8 wmode = IEEE80211_MODE_INFRA;
216 if (mode == RT_WLAN_AP)
217 wmode = IEEE80211_MODE_AP;
218 tls_param_set(TLS_PARAM_ID_WPROTOCOL, (void *)&wmode, TRUE);
219
220 return RT_EOK;
221 }
222
wm_wlan_scan_callback(void)223 static void wm_wlan_scan_callback(void)
224 {
225 int buflen = 2000;
226 char *buf = RT_NULL;
227 int err;
228
229 struct rt_wlan_info wlan_info;
230 struct rt_wlan_buff buff;
231
232 buf = rt_malloc(buflen);
233 if (RT_NULL == buf)
234 {
235 LOG_E("rt_malloc failed...\r\n");
236 return;
237 }
238
239 err = tls_wifi_get_scan_rslt((u8 *)buf, buflen);
240 if (err != WM_SUCCESS)
241 {
242 rt_free(buf);
243 return;
244 }
245
246 struct tls_scan_bss_t *scan_res = (struct tls_scan_bss_t *)buf;
247 struct tls_bss_info_t *bss_info = (struct tls_bss_info_t *)scan_res->bss;
248 if (scan_res->count <= 0)
249 {
250 rt_free(buf);
251 return;
252 }
253
254 int i;
255 for (i = 0; i < scan_res->count; i ++)
256 {
257 rt_memset(&wlan_info, 0, sizeof(wlan_info));
258
259 rt_memcpy(&wlan_info.bssid[0], bss_info->bssid, 6);
260 rt_memcpy(wlan_info.ssid.val, bss_info->ssid, bss_info->ssid_len);
261 wlan_info.ssid.len = bss_info->ssid_len;
262 if (bss_info->ssid_len)
263 wlan_info.hidden = 0;
264 else
265 wlan_info.hidden = 1;
266
267 wlan_info.channel = (rt_int16_t)bss_info->channel;
268 wlan_info.rssi = -(char)(0x100 - bss_info->rssi);
269
270 wlan_info.datarate = bss_info->max_data_rate * 1000000;
271
272 wlan_info.band = RT_802_11_BAND_2_4GHZ;
273
274 wlan_info.security = SECURITY_OPEN;
275 if (WM_WIFI_AUTH_MODE_WEP_AUTO & bss_info->privacy)
276 wlan_info.security |= WEP_ENABLED;
277 if (WM_WIFI_AUTH_MODE_WPA_PSK_TKIP & bss_info->privacy)
278 wlan_info.security |= WPA_SECURITY | TKIP_ENABLED;
279 if (WM_WIFI_AUTH_MODE_WPA_PSK_CCMP & bss_info->privacy)
280 wlan_info.security |= WPA_SECURITY | AES_ENABLED;
281 if (WM_WIFI_AUTH_MODE_WPA2_PSK_CCMP & bss_info->privacy)
282 wlan_info.security |= WPA2_SECURITY | AES_ENABLED;
283 if (WM_WIFI_AUTH_MODE_WPA2_PSK_TKIP & bss_info->privacy)
284 wlan_info.security |= WPA2_SECURITY | TKIP_ENABLED;
285 if (bss_info->wps_support)
286 wlan_info.security |= WPS_ENABLED;
287 if (WM_WIFI_AUTH_MODE_UNKNOWN == bss_info->privacy)
288 wlan_info.security = SECURITY_UNKNOWN;
289
290 /* rtt incompleted... */
291 if (wlan_info.security & SECURITY_WPA2_MIXED_PSK)
292 wlan_info.security = SECURITY_WPA2_MIXED_PSK;
293 else if (wlan_info.security & SECURITY_WPA2_TKIP_PSK)
294 wlan_info.security = SECURITY_WPA2_TKIP_PSK;
295 else if (wlan_info.security & SECURITY_WPA2_AES_PSK)
296 wlan_info.security = SECURITY_WPA2_AES_PSK;
297 else if (wlan_info.security & SECURITY_WPA_AES_PSK)
298 wlan_info.security = SECURITY_WPA_AES_PSK;
299 else if (wlan_info.security & SECURITY_WPA_TKIP_PSK)
300 wlan_info.security = SECURITY_WPA_TKIP_PSK;
301 else if (wlan_info.security & SECURITY_WEP_PSK)
302 wlan_info.security = SECURITY_WEP_PSK;
303 else if ((SECURITY_UNKNOWN == wlan_info.security) && bss_info->wps_support)
304 wlan_info.security = SECURITY_WPS_SECURE;
305
306 LOG_D("%s-%x", wlan_info.ssid.val, wlan_info.security);
307
308 bss_info ++;
309
310 buff.data = &wlan_info;
311 buff.len = sizeof(wlan_info);
312 rt_wlan_dev_indicate_event_handle(wifi_sta.wlan, RT_WLAN_DEV_EVT_SCAN_REPORT, &buff);
313
314 }
315 rt_free(buf);
316 rt_wlan_dev_indicate_event_handle(wifi_sta.wlan, RT_WLAN_DEV_EVT_SCAN_DONE, RT_NULL);
317 }
318
drv_wlan_scan(struct rt_wlan_device * wlan,struct rt_scan_info * scan_info)319 static rt_err_t drv_wlan_scan(struct rt_wlan_device *wlan, struct rt_scan_info *scan_info)
320 {
321 int ret;
322
323 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
324 /* register scan complt callback*/
325 tls_wifi_scan_result_cb_register(wm_wlan_scan_callback);
326
327 /* trigger the scan */
328 ret = tls_wifi_scan();
329 if ((ret == WM_WIFI_SCANNING_BUSY) || (ret == WM_FAILED))
330 return -RT_ERROR;
331
332 return RT_EOK;
333 }
334
drv_wlan_join(struct rt_wlan_device * wlan,struct rt_sta_info * sta_info)335 static rt_err_t drv_wlan_join(struct rt_wlan_device *wlan, struct rt_sta_info *sta_info)
336 {
337 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
338
339 tls_wifi_disconnect();
340
341 tls_wifi_connect((u8 *)sta_info->ssid.val, sta_info->ssid.len, (u8 *)sta_info->key.val, sta_info->key.len);
342
343 return RT_EOK;
344 }
345
drv_wlan_softap(struct rt_wlan_device * wlan,struct rt_ap_info * ap_info)346 static rt_err_t drv_wlan_softap(struct rt_wlan_device *wlan, struct rt_ap_info *ap_info)
347 {
348 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
349 struct tls_softap_info_t apinfo;
350 struct tls_ip_info_t ipinfo;
351 rt_memset(&apinfo, 0, sizeof(apinfo));
352 rt_memcpy(apinfo.ssid, ap_info->ssid.val, ap_info->ssid.len);
353 apinfo.channel = ap_info->channel;
354 switch (ap_info->security) /* only support wpa2-psk and open */
355 {
356 case SECURITY_WEP_PSK:
357 apinfo.encrypt = IEEE80211_ENCRYT_WEP40;
358 break;
359 case SECURITY_WPA_TKIP_PSK:
360 apinfo.encrypt = IEEE80211_ENCRYT_TKIP_WPA;
361 break;
362 case SECURITY_WPA_AES_PSK:
363 apinfo.encrypt = IEEE80211_ENCRYT_CCMP_WPA;
364 break;
365 case SECURITY_WPA2_TKIP_PSK:
366 apinfo.encrypt = IEEE80211_ENCRYT_TKIP_WPA2;
367 break;
368 case SECURITY_WPA2_AES_PSK:
369 case SECURITY_WPA2_MIXED_PSK:
370 apinfo.encrypt = IEEE80211_ENCRYT_CCMP_WPA2;
371 break;
372 default:
373 apinfo.encrypt = IEEE80211_ENCRYT_NONE;
374 break;
375 }
376 apinfo.keyinfo.format = 1; /* ascii */
377 apinfo.keyinfo.index = 1; /* index */
378 apinfo.keyinfo.key_len = ap_info->key.len;
379 rt_memcpy(apinfo.keyinfo.key, ap_info->key.val, ap_info->key.len);
380 LOG_D("ch=%d, hd=%d, key=%s, sec=%x, ssid=%s", ap_info->channel, ap_info->hidden, ap_info->key.val, ap_info->security, ap_info->ssid.val);
381 rt_memset(&ipinfo, 0, sizeof(ipinfo));
382 ipinfo.ip_addr[0] = 192;
383 ipinfo.ip_addr[1] = 168;
384 ipinfo.ip_addr[2] = 48;
385 ipinfo.ip_addr[3] = 1;
386 ipinfo.netmask[0] = 255;
387 ipinfo.netmask[1] = 255;
388 ipinfo.netmask[2] = 255;
389 ipinfo.netmask[3] = 0;
390 u8 ssid_set = ap_info->hidden ? 0 : 1;
391 tls_param_set(TLS_PARAM_ID_BRDSSID, (void *)&ssid_set, FALSE);
392 rt_memcpy(ipinfo.dnsname, "local.w60x", sizeof("local.w60x"));
393 int ret = tls_wifi_softap_create(&apinfo, &ipinfo);
394
395 return (ret == WM_SUCCESS) ? RT_EOK : -RT_ERROR;
396 }
397
drv_wlan_disconnect(struct rt_wlan_device * wlan)398 static rt_err_t drv_wlan_disconnect(struct rt_wlan_device *wlan)
399 {
400 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
401 tls_wifi_disconnect();
402
403 return RT_EOK;
404 }
405
drv_wlan_ap_stop(struct rt_wlan_device * wlan)406 static rt_err_t drv_wlan_ap_stop(struct rt_wlan_device *wlan)
407 {
408 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
409 tls_wifi_softap_destroy();
410
411 return RT_EOK;
412 }
413
drv_wlan_ap_deauth(struct rt_wlan_device * wlan,rt_uint8_t mac[])414 static rt_err_t drv_wlan_ap_deauth(struct rt_wlan_device *wlan, rt_uint8_t mac[])
415 {
416 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
417 struct tls_wifi_hdr_mac_t machdr;
418 struct tls_wifi_tx_rate_t tx;
419 rt_memset(&machdr, 0, sizeof(machdr));
420 rt_memcpy(machdr.da_addr, mac, MAX_ADDR_LEN);
421 rt_memcpy(machdr.sa_addr, hostapd_get_mac(), MAX_ADDR_LEN);
422 rt_memcpy(machdr.bssid, hostapd_get_mac(), MAX_ADDR_LEN);
423 rt_memset(&tx, 0, sizeof(tx));
424 tx.tx_rate = WM_WIFI_TX_RATEIDX_1M;
425 tx.tx_gain = tls_wifi_get_tx_gain_max(WM_WIFI_TX_RATEIDX_1M);
426 unsigned short reason = WLAN_REASON_UNSPECIFIED;/* htons */
427 int ret = tls_wifi_send_mgmt(WM_WIFI_MGMT_TYPE_DEAUTH, &machdr, (u8 *)&reason, sizeof(reason), &tx);
428
429 return (0 == ret) ? RT_EOK : -RT_ERROR;
430 }
431
drv_wlan_scan_stop(struct rt_wlan_device * wlan)432 static rt_err_t drv_wlan_scan_stop(struct rt_wlan_device *wlan)
433 {
434 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
435
436 return RT_EOK;
437 }
438
drv_wlan_get_rssi(struct rt_wlan_device * wlan)439 static int drv_wlan_get_rssi(struct rt_wlan_device *wlan)
440 {
441 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
442
443 struct tls_curr_bss_t bss;
444 rt_memset(&bss, 0, sizeof(bss));
445 tls_wifi_get_current_bss(&bss);
446
447 return -bss.rssi - 1;
448 }
449
drv_wlan_set_powersave(struct rt_wlan_device * wlan,int level)450 static rt_err_t drv_wlan_set_powersave(struct rt_wlan_device *wlan, int level)
451 {
452 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
453
454 tls_wifi_set_psflag(level ? TRUE : FALSE, FALSE);
455
456 return RT_EOK;
457 }
458
drv_wlan_get_powersave(struct rt_wlan_device * wlan)459 static int drv_wlan_get_powersave(struct rt_wlan_device *wlan)
460 {
461 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
462
463 return tls_wifi_get_psflag();
464 }
465
drv_wlan_cfg_promisc(struct rt_wlan_device * wlan,rt_bool_t start)466 static rt_err_t drv_wlan_cfg_promisc(struct rt_wlan_device *wlan, rt_bool_t start)
467 {
468 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
469
470 if (RT_TRUE == start)
471 {
472 tls_wifi_set_listen_mode(1);
473 tls_wifi_data_recv_cb_register(wm_wlan_promisc_dataframe_callback);
474 }
475 else
476 {
477 tls_wifi_set_listen_mode(0);
478 tls_wifi_data_recv_cb_register(RT_NULL);
479 }
480
481 return RT_EOK;
482 }
483
drv_wlan_cfg_filter(struct rt_wlan_device * wlan,struct rt_wlan_filter * filter)484 static rt_err_t drv_wlan_cfg_filter(struct rt_wlan_device *wlan, struct rt_wlan_filter *filter)
485 {
486 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
487
488 return -RT_EINVAL;/* not support */
489 }
490
drv_wlan_set_channel(struct rt_wlan_device * wlan,int channel)491 static rt_err_t drv_wlan_set_channel(struct rt_wlan_device *wlan, int channel)
492 {
493 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
494
495 tls_wifi_change_chanel(channel - 1);
496
497 return RT_EOK;
498 }
499
drv_wlan_get_channel(struct rt_wlan_device * wlan)500 static int drv_wlan_get_channel(struct rt_wlan_device *wlan)
501 {
502 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
503
504 return hed_rf_current_channel;
505 }
506
drv_wlan_set_country(struct rt_wlan_device * wlan,rt_country_code_t country_code)507 static rt_err_t drv_wlan_set_country(struct rt_wlan_device *wlan, rt_country_code_t country_code)
508 {
509 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
510
511 u8 region = (u8)country_code;
512 tls_param_set(TLS_PARAM_ID_COUNTRY_REGION, (void *)®ion, TRUE);
513
514 return RT_EOK;
515 }
516
drv_wlan_get_country(struct rt_wlan_device * wlan)517 static rt_country_code_t drv_wlan_get_country(struct rt_wlan_device *wlan)
518 {
519 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
520
521 u8 region = RT_COUNTRY_CHINA;
522 tls_param_get(TLS_PARAM_ID_COUNTRY_REGION, (void *)®ion, FALSE);
523
524 return (rt_country_code_t)region; //RT_EOK;
525 }
526
drv_wlan_set_mac(struct rt_wlan_device * wlan,rt_uint8_t mac[])527 static rt_err_t drv_wlan_set_mac(struct rt_wlan_device *wlan, rt_uint8_t mac[])
528 {
529 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
530
531 if (wlan->user_data == &wifi_sta) /* ap don't support */
532 {
533 wpa_supplicant_set_mac(mac);
534 tls_set_mac_addr(mac);
535 }
536
537 return RT_EOK;
538 }
539
drv_wlan_get_mac(struct rt_wlan_device * wlan,rt_uint8_t mac[])540 static rt_err_t drv_wlan_get_mac(struct rt_wlan_device *wlan, rt_uint8_t mac[])
541 {
542 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
543
544 if (wlan->user_data == &wifi_sta)
545 rt_memcpy(mac, wpa_supplicant_get_mac(), MAX_ADDR_LEN);
546 else
547 rt_memcpy(mac, hostapd_get_mac(), MAX_ADDR_LEN);
548
549 return RT_EOK;
550 }
551
drv_wlan_recv(struct rt_wlan_device * wlan,void * buff,int len)552 static int drv_wlan_recv(struct rt_wlan_device *wlan, void *buff, int len)
553 {
554 return RT_EOK;
555 }
556
drv_wlan_send(struct rt_wlan_device * wlan,void * buff,int len)557 static int drv_wlan_send(struct rt_wlan_device *wlan, void *buff, int len)
558 {
559 rt_uint8_t *dst = tls_wifi_buffer_acquire(len);
560 if (dst == NULL)
561 return -RT_ENOMEM;
562
563 #if ETH_PAD_SIZE
564 pbuf_header(p, -ETH_PAD_SIZE); /* Drop the padding word */
565 #endif
566
567 #if defined(ETH_TX_DUMP)
568 packet_dump("Tx", buff, len);
569 #endif
570
571 rt_memcpy(dst, buff, len);
572
573 #if TLS_CONFIG_AP
574 if (netif != tls_get_netif())
575 tls_wifi_buffer_release(true, dst);
576 else
577 #endif
578 tls_wifi_buffer_release(false, dst);
579
580 #if ETH_PAD_SIZE
581 pbuf_header(p, ETH_PAD_SIZE); /* Reclaim the padding word */
582 #endif
583
584 return RT_EOK;
585 }
586
587 static const struct rt_wlan_dev_ops ops =
588 {
589 .wlan_init = drv_wlan_init,
590 .wlan_mode = drv_wlan_mode,
591 .wlan_scan = drv_wlan_scan,
592 .wlan_join = drv_wlan_join,
593 .wlan_softap = drv_wlan_softap,
594 .wlan_disconnect = drv_wlan_disconnect,
595 .wlan_ap_stop = drv_wlan_ap_stop,
596 .wlan_ap_deauth = drv_wlan_ap_deauth,
597 .wlan_scan_stop = drv_wlan_scan_stop,
598 .wlan_get_rssi = drv_wlan_get_rssi,
599 .wlan_set_powersave = drv_wlan_set_powersave,
600 .wlan_get_powersave = drv_wlan_get_powersave,
601 .wlan_cfg_promisc = drv_wlan_cfg_promisc,
602 .wlan_cfg_filter = drv_wlan_cfg_filter,
603 .wlan_set_channel = drv_wlan_set_channel,
604 .wlan_get_channel = drv_wlan_get_channel,
605 .wlan_set_country = drv_wlan_set_country,
606 .wlan_get_country = drv_wlan_get_country,
607 .wlan_set_mac = drv_wlan_set_mac,
608 .wlan_get_mac = drv_wlan_get_mac,
609 .wlan_recv = drv_wlan_recv,
610 .wlan_send = drv_wlan_send,
611 };
612
wm_hw_wifi_init(void)613 int wm_hw_wifi_init(void)
614 {
615 static struct rt_wlan_device wlan;
616 static struct rt_wlan_device wlan2;
617
618 LOG_D("F:%s L:%d", __FUNCTION__, __LINE__);
619
620 rt_memset(&wifi_sta, 0, sizeof(wifi_sta));
621 rt_err_t ret = rt_wlan_dev_register(&wlan, RT_WLAN_DEVICE_STA_NAME, &ops, 0, &wifi_sta);
622 wifi_sta.wlan = &wlan;
623
624 rt_memset(&wifi_ap, 0, sizeof(wifi_ap));
625 ret |= rt_wlan_dev_register(&wlan2, RT_WLAN_DEVICE_AP_NAME, &ops, 0, &wifi_ap);
626 wifi_ap.wlan = &wlan2;
627
628 return ret; //RT_EOK;
629 }
630 INIT_DEVICE_EXPORT(wm_hw_wifi_init);
631