OrgZephyr/zephyr
OrgZephyr
/
zephyr
mirror of https://github.com/zephyrproject-rtos/zephyr.git
1
0
Fork 0
Code Issues Releases Wiki Activity
zephyr/drivers/wifi/simplelink/simplelink_support.c

693 lines
19 KiB
C
Raw Permalink Blame History

/*
* Copyright (c) 2018, Texas Instruments Incorporated
*
* SPDX-License-Identifier: Apache-2.0
*
*/
#include <stdlib.h>
#include <string.h>
#include "simplelink_log.h"
LOG_MODULE_DECLARE(LOG_MODULE_NAME);
#include <zephyr/kernel.h>
#include <stdint.h>
#include <ti/drivers/net/wifi/simplelink.h>
#include <ti/net/slnetif.h>
#include <ti/net/slnetutils.h>
#include <ti/drivers/net/wifi/slnetifwifi.h>
#include <CC3220SF_LAUNCHXL.h>
#include "simplelink_support.h"
#define SET_STATUS_BIT(status, bit) {status |= (1 << (bit)); }
#define CLR_STATUS_BIT(status, bit) {status &= ~(1 << (bit)); }
#define GET_STATUS_BIT(status, bit) (0 != (status & (1 << (bit))))
#define SL_STOP_TIMEOUT (200)
#undef ASSERT_ON_ERROR
#define ASSERT_ON_ERROR(ret, e) __ASSERT(ret >= 0, e)
#define DEVICE_ERROR "See \"DEVICE ERRORS CODES\" in SimpleLink errors.h"
#define WLAN_ERROR "See \"WLAN ERRORS CODES\" in SimpleLink errors.h"
#define NETAPP_ERROR "See \"NETAPP ERRORS CODES\" in SimpleLink errors.h"
#define CHANNEL_MASK_ALL (0x1FFF)
#define RSSI_TH_MAX (-95)
#define SLNET_IF_WIFI_PRIO (5)
#define SLNET_IF_WIFI_NAME "CC32xx"
enum status_bits {
/* Network Processor is powered up */
STATUS_BIT_NWP_INIT = 0,
/* The device is connected to the AP */
STATUS_BIT_CONNECTION,
/* The device has leased IP to any connected client */
STATUS_BIT_IP_LEASED,
/* The device has acquired an IP */
STATUS_BIT_IP_ACQUIRED,
/* The device has acquired an IPv6 address */
STATUS_BIT_IPV6_ACQUIRED,
};
struct nwp_status {
/* Callback to notify net & wifi mgmt events from SL Event Handlers */
simplelink_wifi_cb_t cb;
/* Status Variables */
uint32_t status; /* The state of the NWP */
uint32_t role; /* The device's role (STA, P2P or AP) */
/* Scan results table: */
SlWlanNetworkEntry_t net_entries[CONFIG_WIFI_SIMPLELINK_SCAN_COUNT];
};
/* STA/AP mode state: shared with simplelink.c */
struct sl_connect_state sl_conn;
/* Network Coprocessor state, including role and connection state: */
static struct nwp_status nwp;
/* Minimal configuration of SlNetIfWifi for Zephyr */
static SlNetIf_Config_t slnetifwifi_config_zephyr = {
.sockCreate = SlNetIfWifi_socket,
.sockClose = SlNetIfWifi_close,
.sockSelect = SlNetIfWifi_select,
.sockSetOpt = SlNetIfWifi_setSockOpt,
.sockGetOpt = SlNetIfWifi_getSockOpt,
.sockRecvFrom = SlNetIfWifi_recvFrom,
.sockSendTo = SlNetIfWifi_sendTo,
.utilGetHostByName = SlNetIfWifi_getHostByName,
.ifGetIPAddr = SlNetIfWifi_getIPAddr,
.ifGetConnectionStatus = SlNetIfWifi_getConnectionStatus
};
/* Configure the device to a default state, resetting previous parameters .*/
static int32_t configure_simplelink(void)
{
int32_t retval = -1;
int32_t mode = -1;
uint32_t if_bitmap = 0U;
SlWlanScanParamCommand_t scan_default = { 0 };
SlWlanRxFilterOperationCommandBuff_t rx_filterid_mask = { { 0 } };
uint8_t config_opt;
uint8_t power;
#if defined(CONFIG_NET_IPV4) && defined(CONFIG_NET_CONFIG_MY_IPV4_ADDR)
struct in_addr addr4;
SlNetCfgIpV4Args_t ipV4;
memset(&ipV4, 0, sizeof(ipV4));
#endif
/* Turn on NWP */
mode = sl_Start(0, 0, 0);
ASSERT_ON_ERROR(mode, DEVICE_ERROR);
if (mode != ROLE_STA) {
/* Set NWP role as STA */
mode = sl_WlanSetMode(ROLE_STA);
ASSERT_ON_ERROR(mode, WLAN_ERROR);
/* For changes to take affect, we restart the NWP */
retval = sl_Stop(SL_STOP_TIMEOUT);
ASSERT_ON_ERROR(retval, DEVICE_ERROR);
mode = sl_Start(0, 0, 0);
ASSERT_ON_ERROR(mode, DEVICE_ERROR);
}
if (mode != ROLE_STA) {
LOG_ERR("Failed to configure NWP to default state");
return -1;
}
/* Use Fast Connect Policy, to automatically connect to last AP: */
retval = sl_WlanPolicySet(SL_WLAN_POLICY_CONNECTION,
SL_WLAN_CONNECTION_POLICY(1, 1, 0, 0),
NULL, 0);
ASSERT_ON_ERROR(retval, WLAN_ERROR);
/* Disable Auto Provisioning*/
retval = sl_WlanProvisioning(SL_WLAN_PROVISIONING_CMD_STOP, 0xFF, 0,
NULL, 0x0);
ASSERT_ON_ERROR(retval, WLAN_ERROR);
/* Delete existing profiles */
retval = sl_WlanProfileDel(0xFF);
ASSERT_ON_ERROR(retval, WLAN_ERROR);
#if defined(CONFIG_NET_IPV4) && defined(CONFIG_NET_CONFIG_MY_IPV4_ADDR)
if (net_addr_pton(AF_INET, CONFIG_NET_CONFIG_MY_IPV4_ADDR, &addr4)
< 0) {
LOG_ERR("Invalid CONFIG_NET_CONFIG_MY_IPV4_ADDR");
return -1;
}
ipV4.Ip = (_u32)SL_IPV4_VAL(addr4.s4_addr[0],
addr4.s4_addr[1],
addr4.s4_addr[2],
addr4.s4_addr[3]);
#if defined(CONFIG_NET_CONFIG_MY_IPV4_GW)
if (strcmp(CONFIG_NET_CONFIG_MY_IPV4_GW, "") != 0) {
if (net_addr_pton(AF_INET, CONFIG_NET_CONFIG_MY_IPV4_GW,
&addr4) < 0) {
LOG_ERR("Invalid CONFIG_NET_CONFIG_MY_IPV4_GW");
return -1;
}
ipV4.IpGateway = (_u32)SL_IPV4_VAL(addr4.s4_addr[0],
addr4.s4_addr[1],
addr4.s4_addr[2],
addr4.s4_addr[3]);
}
#endif
#if defined(CONFIG_NET_CONFIG_MY_IPV4_NETMASK)
if (strcmp(CONFIG_NET_CONFIG_MY_IPV4_NETMASK, "") != 0) {
if (net_addr_pton(AF_INET, CONFIG_NET_CONFIG_MY_IPV4_NETMASK,
&addr4) < 0) {
LOG_ERR("Invalid CONFIG_NET_CONFIG_MY_IPV4_NETMASK");
return -1;
}
ipV4.IpMask = (_u32)SL_IPV4_VAL(addr4.s4_addr[0],
addr4.s4_addr[1],
addr4.s4_addr[2],
addr4.s4_addr[3]);
}
#endif
retval = sl_NetCfgSet(SL_NETCFG_IPV4_STA_ADDR_MODE,
SL_NETCFG_ADDR_STATIC,
sizeof(SlNetCfgIpV4Args_t), (_u8 *)&ipV4);
ASSERT_ON_ERROR(retval, NETAPP_ERROR);
#else
/* enable DHCP client */
retval = sl_NetCfgSet(SL_NETCFG_IPV4_STA_ADDR_MODE,
SL_NETCFG_ADDR_DHCP, 0, 0);
ASSERT_ON_ERROR(retval, NETAPP_ERROR);
#endif
#if defined(CONFIG_NET_IPV6)
if_bitmap = ~0;
#else
/* Disable ipv6 */
if_bitmap = !(SL_NETCFG_IF_IPV6_STA_LOCAL |
SL_NETCFG_IF_IPV6_STA_GLOBAL);
#endif
retval = sl_NetCfgSet(SL_NETCFG_IF, SL_NETCFG_IF_STATE,
sizeof(if_bitmap),
(const unsigned char *)&if_bitmap);
ASSERT_ON_ERROR(retval, NETAPP_ERROR);
/* Configure scan parameters to default */
scan_default.ChannelsMask = CHANNEL_MASK_ALL;
scan_default.RssiThreshold = RSSI_TH_MAX;
retval = sl_WlanSet(SL_WLAN_CFG_GENERAL_PARAM_ID,
SL_WLAN_GENERAL_PARAM_OPT_SCAN_PARAMS,
sizeof(scan_default), (uint8_t *)&scan_default);
ASSERT_ON_ERROR(retval, WLAN_ERROR);
/* Disable scans: In other words, use "one-shot" scanning */
config_opt = SL_WLAN_SCAN_POLICY(0, 0);
retval = sl_WlanPolicySet(SL_WLAN_POLICY_SCAN, config_opt, NULL, 0);
ASSERT_ON_ERROR(retval, WLAN_ERROR);
/* Set TX power lvl to max */
power = 0U;
retval = sl_WlanSet(SL_WLAN_CFG_GENERAL_PARAM_ID,
SL_WLAN_GENERAL_PARAM_OPT_STA_TX_POWER, 1,
(uint8_t *)&power);
ASSERT_ON_ERROR(retval, WLAN_ERROR);
/* Set NWP Power policy to 'normal' */
retval = sl_WlanPolicySet(SL_WLAN_POLICY_PM, SL_WLAN_NORMAL_POLICY,
NULL, 0);
ASSERT_ON_ERROR(retval, WLAN_ERROR);
/* Unregister mDNS services */
retval = sl_NetAppMDNSUnRegisterService(0, 0, 0);
ASSERT_ON_ERROR(retval, NETAPP_ERROR);
/* Remove all 64 RX filters (8*8) */
(void)memset(rx_filterid_mask.FilterBitmap, 0xFF, 8);
retval = sl_WlanSet(SL_WLAN_RX_FILTERS_ID, SL_WLAN_RX_FILTER_REMOVE,
sizeof(SlWlanRxFilterOperationCommandBuff_t),
(uint8_t *)&rx_filterid_mask);
ASSERT_ON_ERROR(retval, WLAN_ERROR);
/* Set NWP role as STA */
retval = sl_WlanSetMode(ROLE_STA);
ASSERT_ON_ERROR(retval, WLAN_ERROR);
/* For changes to take affect, we restart the NWP */
retval = sl_Stop(0xFF);
ASSERT_ON_ERROR(retval, DEVICE_ERROR);
mode = sl_Start(0, 0, 0);
ASSERT_ON_ERROR(mode, DEVICE_ERROR);
if (mode != ROLE_STA) {
LOG_ERR("Failed to configure device to it's default state");
retval = -1;
} else {
nwp.role = ROLE_STA;
SET_STATUS_BIT(nwp.status, STATUS_BIT_NWP_INIT);
retval = 0;
}
return retval;
}
/**
* @brief SimpleLinkWlanEventHandler
*
* This handler gets called whenever a WLAN event is reported
* by the host driver / NWP.
*
* @note See the CC3120/CC3220 NWP programmer's guide (SWRU455)
* sections 4.3.4, 4.4.5 and 4.5.5.
*/
void SimpleLinkWlanEventHandler(SlWlanEvent_t *wlan_event)
{
SlWlanEventDisconnect_t *event_data = NULL;
if (!wlan_event) {
return;
}
switch (wlan_event->Id) {
case SL_WLAN_EVENT_CONNECT:
SET_STATUS_BIT(nwp.status, STATUS_BIT_CONNECTION);
/* Store new connection SSID and BSSID: */
memcpy(sl_conn.ssid, wlan_event->Data.Connect.SsidName,
wlan_event->Data.Connect.SsidLen);
memcpy(sl_conn.bssid, wlan_event->Data.Connect.Bssid,
BSSID_LEN_MAX);
LOG_INF("[WLAN EVENT] STA Connected to the AP: %s, "
"BSSID: %x:%x:%x:%x:%x:%x",
sl_conn.ssid, sl_conn.bssid[0],
sl_conn.bssid[1], sl_conn.bssid[2],
sl_conn.bssid[3], sl_conn.bssid[4],
sl_conn.bssid[5]);
/* Continue the notification callback chain... */
sl_conn.error = 0;
nwp.cb(SL_WLAN_EVENT_CONNECT, &sl_conn);
break;
case SL_WLAN_EVENT_DISCONNECT:
CLR_STATUS_BIT(nwp.status, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(nwp.status, STATUS_BIT_IP_ACQUIRED);
CLR_STATUS_BIT(nwp.status, STATUS_BIT_IPV6_ACQUIRED);
event_data = &wlan_event->Data.Disconnect;
/* If the user has initiated 'Disconnect' request,
* 'reason_code' is SL_WLAN_DISCONNECT_USER_INITIATED
*/
if (SL_WLAN_DISCONNECT_USER_INITIATED ==
event_data->ReasonCode) {
LOG_INF("[WLAN EVENT] "
"Device disconnected from the AP: %s",
event_data->SsidName);
LOG_INF("BSSID: %x:%x:%x:%x:%x:%x on application's"
" request", event_data->Bssid[0],
event_data->Bssid[1], event_data->Bssid[2],
event_data->Bssid[3], event_data->Bssid[4],
event_data->Bssid[5]);
sl_conn.error = 0;
} else {
LOG_ERR("[WLAN ERROR] "
"Device disconnected from the AP: %s",
event_data->SsidName);
LOG_ERR("BSSID: %x:%x:%x:%x:%x:%x on error: %d",
event_data->Bssid[0],
event_data->Bssid[1], event_data->Bssid[2],
event_data->Bssid[3], event_data->Bssid[4],
event_data->Bssid[5],
event_data->ReasonCode);
sl_conn.error = event_data->ReasonCode;
}
(void)memset(&(sl_conn.ssid), 0x0, sizeof(sl_conn.ssid));
(void)memset(&(sl_conn.bssid), 0x0, sizeof(sl_conn.bssid));
/* Continue the notification callback chain... */
nwp.cb(SL_WLAN_EVENT_DISCONNECT, &sl_conn);
break;
case SL_WLAN_EVENT_STA_ADDED:
memcpy(&(sl_conn.bssid), wlan_event->Data.STAAdded.Mac,
SL_WLAN_BSSID_LENGTH);
LOG_INF("[WLAN EVENT] STA was added to AP: "
"BSSID: %x:%x:%x:%x:%x:%x",
sl_conn.bssid[0], sl_conn.bssid[1],
sl_conn.bssid[2], sl_conn.bssid[3],
sl_conn.bssid[4], sl_conn.bssid[5]);
break;
case SL_WLAN_EVENT_STA_REMOVED:
memcpy(&(sl_conn.bssid), wlan_event->Data.STAAdded.Mac,
SL_WLAN_BSSID_LENGTH);
LOG_INF("[WLAN EVENT] STA was removed from AP: "
"BSSID: %x:%x:%x:%x:%x:%x",
sl_conn.bssid[0], sl_conn.bssid[1],
sl_conn.bssid[2], sl_conn.bssid[3],
sl_conn.bssid[4], sl_conn.bssid[5]);
(void)memset(&(sl_conn.bssid), 0x0, sizeof(sl_conn.bssid));
break;
default:
LOG_ERR("[WLAN EVENT] Unexpected event [0x%lx]",
wlan_event->Id);
break;
}
}
/**
* @brief SimpleLinkNetAppEventHandler
*
* This handler gets called whenever a Netapp event is reported
* by the host driver / NWP.
*
* @note See the CC3120/CC3220 NWP programmer's guide (SWRU455)
* section 5.7.
*/
void SimpleLinkNetAppEventHandler(SlNetAppEvent_t *netapp_event)
{
SlIpV4AcquiredAsync_t *event_data = NULL;
uint32_t i;
if (!netapp_event) {
return;
}
switch (netapp_event->Id) {
case SL_NETAPP_EVENT_IPV4_ACQUIRED:
SET_STATUS_BIT(nwp.status, STATUS_BIT_IP_ACQUIRED);
/* Ip Acquired Event Data */
event_data = &netapp_event->Data.IpAcquiredV4;
sl_conn.ip_addr = event_data->Ip;
/* Gateway IP address */
sl_conn.gateway_ip = event_data->Gateway;
LOG_INF("[NETAPP EVENT] IP set to: IPv4=%d.%d.%d.%d, "
"Gateway=%d.%d.%d.%d",
SL_IPV4_BYTE(sl_conn.ip_addr, 3),
SL_IPV4_BYTE(sl_conn.ip_addr, 2),
SL_IPV4_BYTE(sl_conn.ip_addr, 1),
SL_IPV4_BYTE(sl_conn.ip_addr, 0),
SL_IPV4_BYTE(sl_conn.gateway_ip, 3),
SL_IPV4_BYTE(sl_conn.gateway_ip, 2),
SL_IPV4_BYTE(sl_conn.gateway_ip, 1),
SL_IPV4_BYTE(sl_conn.gateway_ip, 0));
nwp.cb(SIMPLELINK_WIFI_CB_IPACQUIRED, &sl_conn);
break;
case SL_NETAPP_EVENT_IPV6_ACQUIRED:
SET_STATUS_BIT(nwp.status, STATUS_BIT_IPV6_ACQUIRED);
for (i = 0U; i < 4; i++) {
sl_conn.ipv6_addr[i] =
netapp_event->Data.IpAcquiredV6.Ip[i];
}
if (LOG_LEVEL >= LOG_LEVEL_INF) {
LOG_INF("[NETAPP EVENT] IP Acquired: "
"IPv6=%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
((sl_conn.ipv6_addr[0] >> 16) & 0xffff),
sl_conn.ipv6_addr[0] & 0xffff,
((sl_conn.ipv6_addr[1] >> 16) & 0xffff),
sl_conn.ipv6_addr[1] & 0xffff,
((sl_conn.ipv6_addr[2] >> 16) & 0xffff),
sl_conn.ipv6_addr[2] & 0xffff,
((sl_conn.ipv6_addr[3] >> 16) & 0xffff),
sl_conn.ipv6_addr[3] & 0xffff);
}
nwp.cb(SIMPLELINK_WIFI_CB_IPV6ACQUIRED, &sl_conn);
break;
case SL_DEVICE_EVENT_DROPPED_NETAPP_IP_LEASED:
SET_STATUS_BIT(nwp.status, STATUS_BIT_IP_LEASED);
SET_STATUS_BIT(nwp.status, STATUS_BIT_IP_ACQUIRED);
sl_conn.sta_ip = netapp_event->Data.IpLeased.IpAddress;
LOG_INF("[NETAPP EVENT] IP Leased to Client: "
"IP=%d.%d.%d.%d",
SL_IPV4_BYTE(sl_conn.sta_ip, 3),
SL_IPV4_BYTE(sl_conn.sta_ip, 2),
SL_IPV4_BYTE(sl_conn.sta_ip, 1),
SL_IPV4_BYTE(sl_conn.sta_ip, 0));
break;
case SL_DEVICE_EVENT_DROPPED_NETAPP_IP_RELEASED:
LOG_INF("[NETAPP EVENT] IP is released.");
break;
default:
LOG_ERR("[NETAPP EVENT] Unexpected event [0x%lx]",
netapp_event->Id);
break;
}
if ((netapp_event->Id == SL_NETAPP_EVENT_IPV4_ACQUIRED) ||
(netapp_event->Id == SL_NETAPP_EVENT_IPV6_ACQUIRED)) {
/* Initialize SlNetSock layer for getaddrinfo */
SlNetIf_init(0);
/*
* We are only using SlNetSock to support getaddrinfo()
* for the WiFi interface, so hardcoding the interface
* id to 1 here.
*/
SlNetIf_add(SLNETIF_ID_1, SLNET_IF_WIFI_NAME,
(const SlNetIf_Config_t *)&slnetifwifi_config_zephyr,
SLNET_IF_WIFI_PRIO);
SlNetSock_init(0);
SlNetUtil_init(0);
}
}
/**
* @brief SimpleLinkGeneralEventHandler
*
* This handler gets called whenever a general error is reported
* by the NWP / Host driver. Since these errors are not fatal,
* the application can handle them.
*
* @note See the CC3120/CC3220 NWP programmer's guide (SWRU455)
* section 17.9.
*/
void SimpleLinkGeneralEventHandler(SlDeviceEvent_t *dev_event)
{
if (!dev_event) {
return;
}
LOG_INF("[GENERAL EVENT] - ID=[%d] Sender=[%d]",
dev_event->Data.Error.Code,
dev_event->Data.Error.Source);
}
/**
* @brief SimpleLinkFatalErrorEventHandler
*
* This handler gets called whenever a driver error occurs requiring
* restart of the device in order to recover.
*/
void SimpleLinkFatalErrorEventHandler(SlDeviceFatal_t *fatal_err_event)
{
switch (fatal_err_event->Id) {
case SL_DEVICE_EVENT_FATAL_DEVICE_ABORT:
LOG_ERR("[ERROR] - FATAL ERROR: "
"Abort NWP event detected: "
"AbortType=%ld, AbortData=0x%lx",
fatal_err_event->Data.DeviceAssert.Code,
fatal_err_event->Data.DeviceAssert.Value);
break;
case SL_DEVICE_EVENT_FATAL_DRIVER_ABORT:
LOG_ERR("[ERROR] - FATAL ERROR: Driver Abort detected.");
break;
case SL_DEVICE_EVENT_FATAL_NO_CMD_ACK:
LOG_ERR("[ERROR] - FATAL ERROR: No Cmd Ack detected "
"[cmd opcode = 0x%lx]",
fatal_err_event->Data.NoCmdAck.Code);
break;
case SL_DEVICE_EVENT_FATAL_SYNC_LOSS:
LOG_ERR("[ERROR] - FATAL ERROR: Sync loss detected");
break;
case SL_DEVICE_EVENT_FATAL_CMD_TIMEOUT:
LOG_ERR("[ERROR] - FATAL ERROR: "
"Async event timeout detected "
"[event opcode =0x%lx]",
fatal_err_event->Data.CmdTimeout.Code);
break;
default:
LOG_ERR("[ERROR] - FATAL ERROR: "
"Unspecified error detected");
break;
}
}
/* Unused, but must be defined to link. */
void SimpleLinkSockEventHandler(SlSockEvent_t *psock)
{
ARG_UNUSED(psock);
}
/* Unused, but must be defined to link. */
void SimpleLinkHttpServerEventHandler(SlNetAppHttpServerEvent_t *http_event,
SlNetAppHttpServerResponse_t *http_resp)
{
ARG_UNUSED(http_event);
ARG_UNUSED(http_resp);
}
/* Unused, but must be defined to link. */
void SimpleLinkNetAppRequestEventHandler(SlNetAppRequest_t *netapp_request,
SlNetAppResponse_t *netapp_response)
{
ARG_UNUSED(netapp_request);
ARG_UNUSED(netapp_response);
}
/* Unused, but must be defined to link. */
void SimpleLinkNetAppRequestMemFreeEventHandler(uint8_t *buffer)
{
ARG_UNUSED(buffer);
}
/* Note: SimpleLink WiFi scan also can return the following:
* - BSSID
* - Whether network hidden or visible
* - Other types of security
*/
void z_simplelink_get_scan_result(int index,
struct wifi_scan_result *scan_result)
{
SlWlanNetworkEntry_t *net_entry;
int sec_bmp;
__ASSERT_NO_MSG(index <= CONFIG_WIFI_SIMPLELINK_SCAN_COUNT);
net_entry = &nwp.net_entries[index];
(void)memset(scan_result, 0x0, sizeof(struct wifi_scan_result));
__ASSERT_NO_MSG(net_entry->SsidLen <= WIFI_SSID_MAX_LEN);
memcpy(scan_result->ssid, net_entry->Ssid, net_entry->SsidLen);
scan_result->ssid_length = net_entry->SsidLen;
scan_result->channel = net_entry->Channel;
/* Parse security bitmap: */
sec_bmp = net_entry->SecurityInfo;
if (SL_WLAN_SCAN_RESULT_SEC_TYPE_BITMAP(sec_bmp) & 0x6) {
scan_result->security = WIFI_SECURITY_TYPE_PSK;
} else {
scan_result->security = WIFI_SECURITY_TYPE_NONE;
}
scan_result->rssi = net_entry->Rssi;
}
int z_simplelink_start_scan(void)
{
int32_t ret;
/* Clear the results buffer */
(void)memset(&nwp.net_entries, 0x0, sizeof(nwp.net_entries));
/* Attempt to get scan results from NWP
* Note: If scan policy isn't set, invoking 'sl_WlanGetNetworkList()'
* for the first time triggers 'one shot' scan.
*/
ret = sl_WlanGetNetworkList(0, CONFIG_WIFI_SIMPLELINK_SCAN_COUNT,
&nwp.net_entries[0]);
LOG_DBG("sl_WlanGetNetworkList: %d", ret);
return ret;
}
void z_simplelink_get_mac(unsigned char *mac)
{
uint16_t mac_len = SL_MAC_ADDR_LEN;
uint16_t config_opt = 0U;
sl_NetCfgGet(SL_NETCFG_MAC_ADDRESS_GET, &config_opt,
&mac_len, (uint8_t *)mac);
}
int z_simplelink_connect(struct wifi_connect_req_params *params)
{
SlWlanSecParams_t secParams = { 0 };
long lretval;
if (params->security == WIFI_SECURITY_TYPE_PSK) {
secParams.Key = (signed char *)params->psk;
secParams.KeyLen = params->psk_length;
/* This is only mapping handled for now: */
secParams.Type = SL_WLAN_SEC_TYPE_WPA_WPA2;
} else {
secParams.Key = (signed char *)NULL;
secParams.KeyLen = 0;
secParams.Type = SL_WLAN_SEC_TYPE_OPEN;
}
lretval = sl_WlanConnect((signed char *)params->ssid,
params->ssid_length, 0, &secParams, 0);
LOG_DBG("sl_WlanConnect: %ld", lretval);
return lretval;
}
int z_simplelink_disconnect(void)
{
long lretval;
lretval = sl_WlanDisconnect();
LOG_DBG("sl_WlanDisconnect: %ld", lretval);
return lretval;
}
int z_simplelink_init(simplelink_wifi_cb_t wifi_cb)
{
int retval;
__ASSERT(wifi_cb, "callback must be supplied");
/* Init the board: */
CC3220SF_LAUNCHXL_init();
/* Configure SimpleLink NWP: */
nwp.status = 0U;
nwp.role = ROLE_RESERVED;
nwp.cb = wifi_cb;
(void)memset(&sl_conn, 0x0, sizeof(sl_conn));
retval = configure_simplelink();
__ASSERT(retval >= 0, "Unable to configure SimpleLink");
return retval;
}
Reference in New Issue View Git Blame Copy Permalink