michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers: wifi: Convert to use new logging

Browse source 
Convert the wifi drivers to use the new logging system.

Signed-off-by: Jukka Rissanen <jukka.rissanen@linux.intel.com>
This commit is contained in:
Jukka Rissanen 2018-10-05 14:52:38 +03:00 • committed by Anas Nashif
commit 69eeddd8a9
6 changed files with 188 additions and 201 deletions
Download patch file Download diff file Expand all files Collapse all files

18
drivers/wifi/Kconfig
View file

@ -11,19 +11,11 @@ menuconfig WIFI
if WIFI if WIFI
config SYS_LOG_WIFI_LEVEL module = WIFI
int "WiFi driver log level" module-dep = LOG
depends on SYS_LOG module-str = Log level for WiFi driver
default 0 module-help = Sets log level for WiFi Device Drivers.
range 0 4 source "subsys/net/Kconfig.template.log_config.net"
help
Sets log level for WiFi Device Drivers.
Levels are:
0 OFF, do not write
1 ERROR, only write SYS_LOG_ERR
2 WARNING, write SYS_LOG_WRN in addition to previous level
3 INFO, write SYS_LOG_INF in addition to previous levels
4 DEBUG, write SYS_LOG_DBG in addition to previous levels
config WIFI_INIT_PRIORITY config WIFI_INIT_PRIORITY
int "WiFi driver init priority" int "WiFi driver init priority"

34
drivers/wifi/simplelink/simplelink.c
View file

@ -4,9 +4,11 @@
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
#define SYS_LOG_LEVEL CONFIG_SYS_LOG_WIFI_LEVEL #define LOG_MODULE_NAME wifi_simplelink
#define SYS_LOG_DOMAIN "dev/simplelink" #define LOG_LEVEL CONFIG_WIFI_LOG_LEVEL
#include <logging/sys_log.h>
#include <logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#include <zephyr.h> #include <zephyr.h>
#include <kernel.h> #include <kernel.h>
@ -72,7 +74,7 @@ static void simplelink_wifi_cb(u32_t event, struct sl_connect_state *conn)
break; break;
default: default:
SYS_LOG_DBG("Unrecognized mgmt event: 0x%x", event); LOG_DBG("Unrecognized mgmt event: 0x%x", event);
break; break;
} }
} }
@ -110,15 +112,15 @@ static void simplelink_scan_work_handler(struct k_work *work)
delay = (simplelink_data.num_results_or_err > 0 ? 0 : delay = (simplelink_data.num_results_or_err > 0 ? 0 :
SCAN_RETRY_DELAY); SCAN_RETRY_DELAY);
if (delay > 0) { if (delay > 0) {
SYS_LOG_DBG("Retrying scan..."); LOG_DBG("Retrying scan...");
} }
k_delayed_work_submit(&simplelink_data.work, delay); k_delayed_work_submit(&simplelink_data.work, delay);
} else { } else {
/* Encountered an error, or max retries exceeded: */ /* Encountered an error, or max retries exceeded: */
SYS_LOG_ERR("Scan failed: retries: %d; err: %d", LOG_ERR("Scan failed: retries: %d; err: %d",
simplelink_data.scan_retries, simplelink_data.scan_retries,
simplelink_data.num_results_or_err); simplelink_data.num_results_or_err);
simplelink_data.cb(simplelink_data.iface, -EIO, NULL); simplelink_data.cb(simplelink_data.iface, -EIO, NULL);
} }
} }
@ -180,7 +182,7 @@ static int simplelink_dummy_get(sa_family_t family,
struct net_context **context) struct net_context **context)
{ {
SYS_LOG_ERR("NET_SOCKET_OFFLOAD must be configured for this driver"); LOG_ERR("NET_SOCKET_OFFLOAD must be configured for this driver");
return -1; return -1;
} }
@ -200,11 +202,11 @@ static struct net_offload simplelink_offload = {
static void simplelink_iface_init(struct net_if *iface) static void simplelink_iface_init(struct net_if *iface)
{ {
SYS_LOG_DBG("MAC Address %02X:%02X:%02X:%02X:%02X:%02X", LOG_DBG("MAC Address %02X:%02X:%02X:%02X:%02X:%02X",
simplelink_data.mac[0], simplelink_data.mac[1], simplelink_data.mac[0], simplelink_data.mac[1],
simplelink_data.mac[2], simplelink_data.mac[2],
simplelink_data.mac[3], simplelink_data.mac[4], simplelink_data.mac[3], simplelink_data.mac[4],
simplelink_data.mac[5]); simplelink_data.mac[5]);
net_if_set_link_addr(iface, simplelink_data.mac, net_if_set_link_addr(iface, simplelink_data.mac,
sizeof(simplelink_data.mac), sizeof(simplelink_data.mac),
@ -232,7 +234,7 @@ static int simplelink_init(struct device *dev)
/* Initialize and configure NWP to defaults: */ /* Initialize and configure NWP to defaults: */
ret = _simplelink_init(simplelink_wifi_cb); ret = _simplelink_init(simplelink_wifi_cb);
if (ret) { if (ret) {
SYS_LOG_ERR("_simplelink_init failed!"); LOG_ERR("_simplelink_init failed!");
return(-EIO); return(-EIO);
} }
@ -248,7 +250,7 @@ static int simplelink_init(struct device *dev)
socket_offload_register(&simplelink_ops); socket_offload_register(&simplelink_ops);
#endif #endif
SYS_LOG_DBG("SimpleLink driver Initialized"); LOG_DBG("SimpleLink driver Initialized");
return 0; return 0;
} }

166
drivers/wifi/simplelink/simplelink_support.c
View file

@ -5,9 +5,11 @@
* *
*/ */
#define SYS_LOG_LEVEL CONFIG_SYS_LOG_WIFI_LEVEL #define LOG_MODULE_NAME wifi_simplelink_support
#define SYS_LOG_DOMAIN "dev/simplelink" #define LOG_LEVEL CONFIG_WIFI_LOG_LEVEL
#include <logging/sys_log.h>
#include <logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -96,7 +98,7 @@ static s32_t configure_simplelink(void)
} }
if (mode != ROLE_STA) { if (mode != ROLE_STA) {
SYS_LOG_ERR("Failed to configure NWP to default state"); LOG_ERR("Failed to configure NWP to default state");
return -1; return -1;
} }
@ -180,7 +182,7 @@ static s32_t configure_simplelink(void)
ASSERT_ON_ERROR(mode, DEVICE_ERROR); ASSERT_ON_ERROR(mode, DEVICE_ERROR);
if (mode != ROLE_STA) { if (mode != ROLE_STA) {
SYS_LOG_ERR("Failed to configure device to it's default state"); LOG_ERR("Failed to configure device to it's default state");
retval = -1; retval = -1;
} else { } else {
nwp.role = ROLE_STA; nwp.role = ROLE_STA;
@ -218,12 +220,12 @@ void SimpleLinkWlanEventHandler(SlWlanEvent_t *wlan_event)
memcpy(sl_conn.bssid, wlan_event->Data.Connect.Bssid, memcpy(sl_conn.bssid, wlan_event->Data.Connect.Bssid,
BSSID_LEN_MAX); BSSID_LEN_MAX);
SYS_LOG_INF("\n[WLAN EVENT] STA Connected to the AP: %s, " LOG_INF("\n[WLAN EVENT] STA Connected to the AP: %s, "
"BSSID: %x:%x:%x:%x:%x:%x", "BSSID: %x:%x:%x:%x:%x:%x",
sl_conn.ssid, sl_conn.bssid[0], sl_conn.ssid, sl_conn.bssid[0],
sl_conn.bssid[1], sl_conn.bssid[2], sl_conn.bssid[1], sl_conn.bssid[2],
sl_conn.bssid[3], sl_conn.bssid[4], sl_conn.bssid[3], sl_conn.bssid[4],
sl_conn.bssid[5]); sl_conn.bssid[5]);
/* Continue the notification callback chain... */ /* Continue the notification callback chain... */
sl_conn.error = 0; sl_conn.error = 0;
@ -242,24 +244,24 @@ void SimpleLinkWlanEventHandler(SlWlanEvent_t *wlan_event)
*/ */
if (SL_WLAN_DISCONNECT_USER_INITIATED == if (SL_WLAN_DISCONNECT_USER_INITIATED ==
event_data->ReasonCode) { event_data->ReasonCode) {
SYS_LOG_INF("\n[WLAN EVENT] " LOG_INF("\n[WLAN EVENT] "
"Device disconnected from the AP: %s,\n\r" "Device disconnected from the AP: %s,\n\r"
"BSSID: %x:%x:%x:%x:%x:%x on application's" "BSSID: %x:%x:%x:%x:%x:%x on application's"
" request", " request",
event_data->SsidName, event_data->Bssid[0], event_data->SsidName, event_data->Bssid[0],
event_data->Bssid[1], event_data->Bssid[2], event_data->Bssid[1], event_data->Bssid[2],
event_data->Bssid[3], event_data->Bssid[4], event_data->Bssid[3], event_data->Bssid[4],
event_data->Bssid[5]); event_data->Bssid[5]);
sl_conn.error = 0; sl_conn.error = 0;
} else { } else {
SYS_LOG_ERR("\n[WLAN ERROR] " LOG_ERR("\n[WLAN ERROR] "
"Device disconnected from the AP: %s,\n\r" "Device disconnected from the AP: %s,\n\r"
"BSSID: %x:%x:%x:%x:%x:%x on error: %d", "BSSID: %x:%x:%x:%x:%x:%x on error: %d",
event_data->SsidName, event_data->Bssid[0], event_data->SsidName, event_data->Bssid[0],
event_data->Bssid[1], event_data->Bssid[2], event_data->Bssid[1], event_data->Bssid[2],
event_data->Bssid[3], event_data->Bssid[4], event_data->Bssid[3], event_data->Bssid[4],
event_data->Bssid[5], event_data->Bssid[5],
event_data->ReasonCode); event_data->ReasonCode);
sl_conn.error = event_data->ReasonCode; sl_conn.error = event_data->ReasonCode;
} }
@ -273,26 +275,26 @@ void SimpleLinkWlanEventHandler(SlWlanEvent_t *wlan_event)
case SL_WLAN_EVENT_STA_ADDED: case SL_WLAN_EVENT_STA_ADDED:
memcpy(&(sl_conn.bssid), wlan_event->Data.STAAdded.Mac, memcpy(&(sl_conn.bssid), wlan_event->Data.STAAdded.Mac,
SL_WLAN_BSSID_LENGTH); SL_WLAN_BSSID_LENGTH);
SYS_LOG_INF("\n[WLAN EVENT] STA was added to AP: " LOG_INF("\n[WLAN EVENT] STA was added to AP: "
"BSSID: %x:%x:%x:%x:%x:%x", "BSSID: %x:%x:%x:%x:%x:%x",
sl_conn.bssid[0], sl_conn.bssid[1], sl_conn.bssid[0], sl_conn.bssid[1],
sl_conn.bssid[2], sl_conn.bssid[3], sl_conn.bssid[2], sl_conn.bssid[3],
sl_conn.bssid[4], sl_conn.bssid[5]); sl_conn.bssid[4], sl_conn.bssid[5]);
break; break;
case SL_WLAN_EVENT_STA_REMOVED: case SL_WLAN_EVENT_STA_REMOVED:
memcpy(&(sl_conn.bssid), wlan_event->Data.STAAdded.Mac, memcpy(&(sl_conn.bssid), wlan_event->Data.STAAdded.Mac,
SL_WLAN_BSSID_LENGTH); SL_WLAN_BSSID_LENGTH);
SYS_LOG_INF("\n[WLAN EVENT] STA was removed from AP: " LOG_INF("\n[WLAN EVENT] STA was removed from AP: "
"BSSID: %x:%x:%x:%x:%x:%x", "BSSID: %x:%x:%x:%x:%x:%x",
sl_conn.bssid[0], sl_conn.bssid[1], sl_conn.bssid[0], sl_conn.bssid[1],
sl_conn.bssid[2], sl_conn.bssid[3], sl_conn.bssid[2], sl_conn.bssid[3],
sl_conn.bssid[4], sl_conn.bssid[5]); sl_conn.bssid[4], sl_conn.bssid[5]);
(void)memset(&(sl_conn.bssid), 0x0, sizeof(sl_conn.bssid)); (void)memset(&(sl_conn.bssid), 0x0, sizeof(sl_conn.bssid));
break; break;
default: default:
SYS_LOG_ERR("\n[WLAN EVENT] Unexpected event [0x%lx]", LOG_ERR("\n[WLAN EVENT] Unexpected event [0x%lx]",
wlan_event->Id); wlan_event->Id);
break; break;
} }
} }
@ -326,17 +328,17 @@ void SimpleLinkNetAppEventHandler(SlNetAppEvent_t *netapp_event)
/* Gateway IP address */ /* Gateway IP address */
sl_conn.gateway_ip = event_data->Gateway; sl_conn.gateway_ip = event_data->Gateway;
SYS_LOG_INF("\n[NETAPP EVENT] IP set to: IPv4=%d.%d.%d.%d, " LOG_INF("\n[NETAPP EVENT] IP set to: IPv4=%d.%d.%d.%d, "
"Gateway=%d.%d.%d.%d", "Gateway=%d.%d.%d.%d",
SL_IPV4_BYTE(sl_conn.ip_addr, 3), SL_IPV4_BYTE(sl_conn.ip_addr, 3),
SL_IPV4_BYTE(sl_conn.ip_addr, 2), SL_IPV4_BYTE(sl_conn.ip_addr, 2),
SL_IPV4_BYTE(sl_conn.ip_addr, 1), SL_IPV4_BYTE(sl_conn.ip_addr, 1),
SL_IPV4_BYTE(sl_conn.ip_addr, 0), SL_IPV4_BYTE(sl_conn.ip_addr, 0),
SL_IPV4_BYTE(sl_conn.gateway_ip, 3), SL_IPV4_BYTE(sl_conn.gateway_ip, 3),
SL_IPV4_BYTE(sl_conn.gateway_ip, 2), SL_IPV4_BYTE(sl_conn.gateway_ip, 2),
SL_IPV4_BYTE(sl_conn.gateway_ip, 1), SL_IPV4_BYTE(sl_conn.gateway_ip, 1),
SL_IPV4_BYTE(sl_conn.gateway_ip, 0)); SL_IPV4_BYTE(sl_conn.gateway_ip, 0));
nwp.cb(SIMPLELINK_WIFI_CB_IPACQUIRED, &sl_conn); nwp.cb(SIMPLELINK_WIFI_CB_IPACQUIRED, &sl_conn);
break; break;
@ -349,13 +351,13 @@ void SimpleLinkNetAppEventHandler(SlNetAppEvent_t *netapp_event)
netapp_event->Data.IpAcquiredV6.Ip[i]; netapp_event->Data.IpAcquiredV6.Ip[i];
} }
if (SYS_LOG_LEVEL >= SYS_LOG_LEVEL_INFO) { if (LOG_LEVEL >= LOG_LEVEL_INF) {
char ipv6_addr[NET_IPV6_ADDR_LEN]; char ipv6_addr[NET_IPV6_ADDR_LEN];
net_addr_ntop(AF_INET6, sl_conn.ipv6_addr, net_addr_ntop(AF_INET6, sl_conn.ipv6_addr,
ipv6_addr, ipv6_addr,
sizeof(ipv6_addr)); sizeof(ipv6_addr));
SYS_LOG_INF("\n[NETAPP EVENT] IP Acquired: IPv6= %s", LOG_INF("\n[NETAPP EVENT] IP Acquired: IPv6= %s",
ipv6_addr); ipv6_addr);
} }
@ -366,22 +368,22 @@ void SimpleLinkNetAppEventHandler(SlNetAppEvent_t *netapp_event)
SET_STATUS_BIT(nwp.status, STATUS_BIT_IP_ACQUIRED); SET_STATUS_BIT(nwp.status, STATUS_BIT_IP_ACQUIRED);
sl_conn.sta_ip = netapp_event->Data.IpLeased.IpAddress; sl_conn.sta_ip = netapp_event->Data.IpLeased.IpAddress;
SYS_LOG_INF("\n[NETAPP EVENT] IP Leased to Client: " LOG_INF("\n[NETAPP EVENT] IP Leased to Client: "
"IP=%d.%d.%d.%d", "IP=%d.%d.%d.%d",
SL_IPV4_BYTE(sl_conn.sta_ip, 3), SL_IPV4_BYTE(sl_conn.sta_ip, 3),
SL_IPV4_BYTE(sl_conn.sta_ip, 2), SL_IPV4_BYTE(sl_conn.sta_ip, 2),
SL_IPV4_BYTE(sl_conn.sta_ip, 1), SL_IPV4_BYTE(sl_conn.sta_ip, 1),
SL_IPV4_BYTE(sl_conn.sta_ip, 0)); SL_IPV4_BYTE(sl_conn.sta_ip, 0));
break; break;
case SL_DEVICE_EVENT_DROPPED_NETAPP_IP_RELEASED: case SL_DEVICE_EVENT_DROPPED_NETAPP_IP_RELEASED:
SYS_LOG_INF("\n[NETAPP EVENT] IP is released."); LOG_INF("\n[NETAPP EVENT] IP is released.");
break; break;
default: default:
SYS_LOG_ERR("\n[NETAPP EVENT] Unexpected event [0x%lx]", LOG_ERR("\n[NETAPP EVENT] Unexpected event [0x%lx]",
netapp_event->Id); netapp_event->Id);
break; break;
} }
} }
@ -402,9 +404,9 @@ void SimpleLinkGeneralEventHandler(SlDeviceEvent_t *dev_event)
return; return;
} }
SYS_LOG_INF("\n[GENERAL EVENT] - ID=[%d] Sender=[%d]", LOG_INF("\n[GENERAL EVENT] - ID=[%d] Sender=[%d]",
dev_event->Data.Error.Code, dev_event->Data.Error.Code,
dev_event->Data.Error.Source); dev_event->Data.Error.Source);
} }
/** /**
@ -418,37 +420,37 @@ void SimpleLinkFatalErrorEventHandler(SlDeviceFatal_t *fatal_err_event)
switch (fatal_err_event->Id) { switch (fatal_err_event->Id) {
case SL_DEVICE_EVENT_FATAL_DEVICE_ABORT: case SL_DEVICE_EVENT_FATAL_DEVICE_ABORT:
SYS_LOG_ERR("\n[ERROR] - FATAL ERROR: " LOG_ERR("\n[ERROR] - FATAL ERROR: "
"Abort NWP event detected: " "Abort NWP event detected: "
"AbortType=%ld, AbortData=0x%lx", "AbortType=%ld, AbortData=0x%lx",
fatal_err_event->Data.DeviceAssert.Code, fatal_err_event->Data.DeviceAssert.Code,
fatal_err_event->Data.DeviceAssert.Value); fatal_err_event->Data.DeviceAssert.Value);
break; break;
case SL_DEVICE_EVENT_FATAL_DRIVER_ABORT: case SL_DEVICE_EVENT_FATAL_DRIVER_ABORT:
SYS_LOG_ERR("\n[ERROR] - FATAL ERROR: Driver Abort detected."); LOG_ERR("\n[ERROR] - FATAL ERROR: Driver Abort detected.");
break; break;
case SL_DEVICE_EVENT_FATAL_NO_CMD_ACK: case SL_DEVICE_EVENT_FATAL_NO_CMD_ACK:
SYS_LOG_ERR("\n[ERROR] - FATAL ERROR: No Cmd Ack detected " LOG_ERR("\n[ERROR] - FATAL ERROR: No Cmd Ack detected "
"[cmd opcode = 0x%lx]", "[cmd opcode = 0x%lx]",
fatal_err_event->Data.NoCmdAck.Code); fatal_err_event->Data.NoCmdAck.Code);
break; break;
case SL_DEVICE_EVENT_FATAL_SYNC_LOSS: case SL_DEVICE_EVENT_FATAL_SYNC_LOSS:
SYS_LOG_ERR("\n[ERROR] - FATAL ERROR: Sync loss detected"); LOG_ERR("\n[ERROR] - FATAL ERROR: Sync loss detected");
break; break;
case SL_DEVICE_EVENT_FATAL_CMD_TIMEOUT: case SL_DEVICE_EVENT_FATAL_CMD_TIMEOUT:
SYS_LOG_ERR("\n[ERROR] - FATAL ERROR: " LOG_ERR("\n[ERROR] - FATAL ERROR: "
"Async event timeout detected " "Async event timeout detected "
"[event opcode =0x%lx]", "[event opcode =0x%lx]",
fatal_err_event->Data.CmdTimeout.Code); fatal_err_event->Data.CmdTimeout.Code);
break; break;
default: default:
SYS_LOG_ERR("\n[ERROR] - FATAL ERROR: " LOG_ERR("\n[ERROR] - FATAL ERROR: "
"Unspecified error detected"); "Unspecified error detected");
break; break;
} }
} }
@ -527,7 +529,7 @@ int _simplelink_start_scan(void)
*/ */
ret = sl_WlanGetNetworkList(0, CONFIG_WIFI_SIMPLELINK_SCAN_COUNT, ret = sl_WlanGetNetworkList(0, CONFIG_WIFI_SIMPLELINK_SCAN_COUNT,
&nwp.net_entries[0]); &nwp.net_entries[0]);
SYS_LOG_DBG("sl_WlanGetNetworkList: %d", ret); LOG_DBG("sl_WlanGetNetworkList: %d", ret);
return ret; return ret;
} }
@ -559,7 +561,7 @@ int _simplelink_connect(struct wifi_connect_req_params *params)
lretval = sl_WlanConnect((signed char *)params->ssid, lretval = sl_WlanConnect((signed char *)params->ssid,
params->ssid_length, 0, &secParams, 0); params->ssid_length, 0, &secParams, 0);
SYS_LOG_DBG("sl_WlanConnect: %ld", lretval); LOG_DBG("sl_WlanConnect: %ld", lretval);
return lretval; return lretval;
} }
@ -569,7 +571,7 @@ int _simplelink_disconnect(void)
long lretval; long lretval;
lretval = sl_WlanDisconnect(); lretval = sl_WlanDisconnect();
SYS_LOG_DBG("sl_WlanDisconnect: %ld", lretval); LOG_DBG("sl_WlanDisconnect: %ld", lretval);
return lretval; return lretval;
} }

159
drivers/wifi/winc1500/wifi_winc1500.c
View file

@ -4,13 +4,11 @@
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
#define SYS_LOG_LEVEL CONFIG_SYS_LOG_WIFI_LEVEL #define LOG_MODULE_NAME wifi_winc1500
#define SYS_LOG_DOMAIN "dev/winc1500" #define LOG_LEVEL CONFIG_WIFI_LOG_LEVEL
#if (SYS_LOG_LEVEL > SYS_LOG_LEVEL_OFF)
#define NET_LOG_ENABLED 1
#endif
#include <logging/sys_log.h> #include <logging/log.h>
LOG_MODULE_REGISTER(LOG_MODULE_NAME);
#include <zephyr.h> #include <zephyr.h>
#include <kernel.h> #include <kernel.h>
@ -159,7 +157,7 @@ struct winc1500_data {
static struct winc1500_data w1500_data; static struct winc1500_data w1500_data;
#if (SYS_LOG_LEVEL > SYS_LOG_LEVEL_OFF) #if LOG_LEVEL > LOG_LEVEL_OFF
static void stack_stats(void) static void stack_stats(void)
{ {
@ -289,7 +287,7 @@ static char *socket_message_to_string(u8_t message)
} }
} }
#endif /* (SYS_LOG_LEVEL > SYS_LOG_LEVEL_OFF) */ #endif /* LOG_LEVEL > LOG_LEVEL_OFF */
/** /**
* This function is called when the socket is to be opened. * This function is called when the socket is to be opened.
@ -302,13 +300,13 @@ static int winc1500_get(sa_family_t family,
struct socket_data *sd; struct socket_data *sd;
if (family != AF_INET) { if (family != AF_INET) {
SYS_LOG_ERR("Only AF_INET is supported!"); LOG_ERR("Only AF_INET is supported!");
return -1; return -1;
} }
(*context)->offload_context = (void *)(sint32)socket(family, type, 0); (*context)->offload_context = (void *)(sint32)socket(family, type, 0);
if ((*context)->offload_context < 0) { if ((*context)->offload_context < 0) {
SYS_LOG_ERR("socket error!"); LOG_ERR("socket error!");
return -1; return -1;
} }
@ -339,14 +337,14 @@ static int winc1500_bind(struct net_context *context,
ret = bind((int)context->offload_context, (struct sockaddr *)addr, ret = bind((int)context->offload_context, (struct sockaddr *)addr,
addrlen); addrlen);
if (ret) { if (ret) {
SYS_LOG_ERR("bind error %d %s!", LOG_ERR("bind error %d %s!",
ret, socket_message_to_string(ret)); ret, socket_message_to_string(ret));
return ret; return ret;
} }
if (k_sem_take(&w1500_data.socket_data[socket].wait_sem, if (k_sem_take(&w1500_data.socket_data[socket].wait_sem,
WINC1500_BIND_TIMEOUT)) { WINC1500_BIND_TIMEOUT)) {
SYS_LOG_ERR("bind error timeout expired"); LOG_ERR("bind error timeout expired");
return -ETIMEDOUT; return -ETIMEDOUT;
} }
@ -364,8 +362,8 @@ static int winc1500_listen(struct net_context *context, int backlog)
ret = listen((int)context->offload_context, backlog); ret = listen((int)context->offload_context, backlog);
if (ret) { if (ret) {
SYS_LOG_ERR("listen error %d %s!", LOG_ERR("listen error %d %s!",
ret, socket_error_string(ret)); ret, socket_error_string(ret));
return ret; return ret;
} }
@ -397,8 +395,8 @@ static int winc1500_connect(struct net_context *context,
ret = connect(socket, (struct sockaddr *)addr, addrlen); ret = connect(socket, (struct sockaddr *)addr, addrlen);
if (ret) { if (ret) {
SYS_LOG_ERR("connect error %d %s!", LOG_ERR("connect error %d %s!",
ret, socket_error_string(ret)); ret, socket_error_string(ret));
return ret; return ret;
} }
@ -426,8 +424,8 @@ static int winc1500_accept(struct net_context *context,
ret = accept(socket, NULL, 0); ret = accept(socket, NULL, 0);
if (ret) { if (ret) {
SYS_LOG_ERR("accept error %d %s!", LOG_ERR("accept error %d %s!",
ret, socket_error_string(ret)); ret, socket_error_string(ret));
return ret; return ret;
} }
@ -480,8 +478,8 @@ static int winc1500_send(struct net_pkt *pkt,
ret = send(socket, data_ptr, data_len, 0); ret = send(socket, data_ptr, data_len, 0);
if (ret) { if (ret) {
SYS_LOG_ERR("send error %d %s!", LOG_ERR("send error %d %s!",
ret, socket_error_string(ret)); ret, socket_error_string(ret));
return ret; return ret;
} }
} }
@ -529,8 +527,8 @@ static int winc1500_sendto(struct net_pkt *pkt,
ret = sendto(socket, data_ptr, data_len, 0, ret = sendto(socket, data_ptr, data_len, 0,
(struct sockaddr *)dst_addr, addrlen); (struct sockaddr *)dst_addr, addrlen);
if (ret) { if (ret) {
SYS_LOG_ERR("send error %d %s!", LOG_ERR("send error %d %s!",
ret, socket_error_string(ret)); ret, socket_error_string(ret));
return ret; return ret;
} }
} }
@ -547,14 +545,14 @@ static int prepare_pkt(struct socket_data *sock_data)
/* Get the frame from the buffer */ /* Get the frame from the buffer */
sock_data->rx_pkt = net_pkt_get_reserve_rx(0, K_NO_WAIT); sock_data->rx_pkt = net_pkt_get_reserve_rx(0, K_NO_WAIT);
if (!sock_data->rx_pkt) { if (!sock_data->rx_pkt) {
SYS_LOG_ERR("Could not allocate rx packet"); LOG_ERR("Could not allocate rx packet");
return -1; return -1;
} }
/* Reserve a data frag to receive the frame */ /* Reserve a data frag to receive the frame */
sock_data->pkt_buf = net_pkt_get_frag(sock_data->rx_pkt, K_NO_WAIT); sock_data->pkt_buf = net_pkt_get_frag(sock_data->rx_pkt, K_NO_WAIT);
if (!sock_data->pkt_buf) { if (!sock_data->pkt_buf) {
SYS_LOG_ERR("Could not allocate data frag"); LOG_ERR("Could not allocate data frag");
net_pkt_unref(sock_data->rx_pkt); net_pkt_unref(sock_data->rx_pkt);
return -1; return -1;
} }
@ -578,7 +576,7 @@ static int winc1500_recv(struct net_context *context,
ret = prepare_pkt(&w1500_data.socket_data[socket]); ret = prepare_pkt(&w1500_data.socket_data[socket]);
if (ret) { if (ret) {
SYS_LOG_ERR("Could not reserve packet buffer"); LOG_ERR("Could not reserve packet buffer");
return -ENOMEM; return -ENOMEM;
} }
@ -588,8 +586,8 @@ static int winc1500_recv(struct net_context *context,
ret = recv(socket, w1500_data.socket_data[socket].pkt_buf->data, ret = recv(socket, w1500_data.socket_data[socket].pkt_buf->data,
CONFIG_WIFI_WINC1500_MAX_PACKET_SIZE, timeout); CONFIG_WIFI_WINC1500_MAX_PACKET_SIZE, timeout);
if (ret) { if (ret) {
SYS_LOG_ERR("recv error %d %s!", LOG_ERR("recv error %d %s!",
ret, socket_error_string(ret)); ret, socket_error_string(ret));
return ret; return ret;
} }
@ -623,7 +621,7 @@ static void handle_wifi_con_state_changed(void *pvMsg)
switch (pstrWifiState->u8CurrState) { switch (pstrWifiState->u8CurrState) {
case M2M_WIFI_DISCONNECTED: case M2M_WIFI_DISCONNECTED:
SYS_LOG_DBG("Disconnected (%u)", pstrWifiState->u8ErrCode); LOG_DBG("Disconnected (%u)", pstrWifiState->u8ErrCode);
if (w1500_data.connecting) { if (w1500_data.connecting) {
wifi_mgmt_raise_connect_result_event(w1500_data.iface, wifi_mgmt_raise_connect_result_event(w1500_data.iface,
@ -638,7 +636,7 @@ static void handle_wifi_con_state_changed(void *pvMsg)
break; break;
case M2M_WIFI_CONNECTED: case M2M_WIFI_CONNECTED:
SYS_LOG_DBG("Connected (%u)", pstrWifiState->u8ErrCode); LOG_DBG("Connected (%u)", pstrWifiState->u8ErrCode);
w1500_data.connected = true; w1500_data.connected = true;
wifi_mgmt_raise_connect_result_event(w1500_data.iface, 0); wifi_mgmt_raise_connect_result_event(w1500_data.iface, 0);
@ -646,7 +644,7 @@ static void handle_wifi_con_state_changed(void *pvMsg)
break; break;
case M2M_WIFI_UNDEF: case M2M_WIFI_UNDEF:
/* TODO status undefined*/ /* TODO status undefined*/
SYS_LOG_DBG("Undefined?"); LOG_DBG("Undefined?");
break; break;
} }
} }
@ -658,9 +656,9 @@ static void handle_wifi_dhcp_conf(void *pvMsg)
u8_t i; u8_t i;
/* Connected and got IP address*/ /* Connected and got IP address*/
SYS_LOG_DBG("Wi-Fi connected, IP is %u.%u.%u.%u", LOG_DBG("Wi-Fi connected, IP is %u.%u.%u.%u",
pu8IPAddress[0], pu8IPAddress[1], pu8IPAddress[0], pu8IPAddress[1],
pu8IPAddress[2], pu8IPAddress[3]); pu8IPAddress[2], pu8IPAddress[3]);
/* TODO at this point the standby mode should be enable /* TODO at this point the standby mode should be enable
* status = WiFi connected IP assigned * status = WiFi connected IP assigned
@ -694,8 +692,8 @@ static void handle_scan_result(void *pvMsg)
} else if (pstrScanResult->u8AuthType == M2M_WIFI_SEC_WPA_PSK) { } else if (pstrScanResult->u8AuthType == M2M_WIFI_SEC_WPA_PSK) {
result.security = WIFI_SECURITY_TYPE_PSK; result.security = WIFI_SECURITY_TYPE_PSK;
} else { } else {
SYS_LOG_DBG("Security %u not supported", LOG_DBG("Security %u not supported",
pstrScanResult->u8AuthType); pstrScanResult->u8AuthType);
goto out; goto out;
} }
@ -731,7 +729,7 @@ static void handle_scan_done(void *pvMsg)
w1500_data.scan_cb(w1500_data.iface, -EIO, NULL); w1500_data.scan_cb(w1500_data.iface, -EIO, NULL);
reset_scan_data(); reset_scan_data();
SYS_LOG_ERR("Scan failed."); LOG_ERR("Scan failed.");
return; return;
} }
@ -739,13 +737,13 @@ static void handle_scan_done(void *pvMsg)
w1500_data.scan_result = 0; w1500_data.scan_result = 0;
if (pstrInfo->u8NumofCh >= 1) { if (pstrInfo->u8NumofCh >= 1) {
SYS_LOG_DBG("Requesting results (%u)", LOG_DBG("Requesting results (%u)",
m2m_wifi_get_num_ap_found()); m2m_wifi_get_num_ap_found());
m2m_wifi_req_scan_result(w1500_data.scan_result); m2m_wifi_req_scan_result(w1500_data.scan_result);
w1500_data.scan_result++; w1500_data.scan_result++;
} else { } else {
SYS_LOG_DBG("No AP found"); LOG_DBG("No AP found");
w1500_data.scan_cb(w1500_data.iface, 0, NULL); w1500_data.scan_cb(w1500_data.iface, 0, NULL);
reset_scan_data(); reset_scan_data();
@ -754,8 +752,8 @@ static void handle_scan_done(void *pvMsg)
static void winc1500_wifi_cb(u8_t message_type, void *pvMsg) static void winc1500_wifi_cb(u8_t message_type, void *pvMsg)
{ {
SYS_LOG_DBG("Msg Type %d %s", LOG_DBG("Msg Type %d %s",
message_type, wifi_cb_msg_2_str(message_type)); message_type, wifi_cb_msg_2_str(message_type));
switch (message_type) { switch (message_type) {
case M2M_WIFI_RESP_CON_STATE_CHANGED: case M2M_WIFI_RESP_CON_STATE_CHANGED:
@ -781,8 +779,8 @@ static void handle_socket_msg_connect(struct socket_data *sd, void *pvMsg)
{ {
tstrSocketConnectMsg *strConnMsg = (tstrSocketConnectMsg *)pvMsg; tstrSocketConnectMsg *strConnMsg = (tstrSocketConnectMsg *)pvMsg;
SYS_LOG_ERR("CONNECT: socket %d error %d", LOG_ERR("CONNECT: socket %d error %d",
strConnMsg->sock, strConnMsg->s8Error); strConnMsg->sock, strConnMsg->s8Error);
if (sd->connect_cb) { if (sd->connect_cb) {
sd->connect_cb(sd->context, sd->connect_cb(sd->context,
@ -820,7 +818,7 @@ static bool handle_socket_msg_recv(SOCKET sock,
} }
if (prepare_pkt(sd)) { if (prepare_pkt(sd)) {
SYS_LOG_ERR("Could not reserve packet buffer"); LOG_ERR("Could not reserve packet buffer");
return false; return false;
} }
@ -839,9 +837,9 @@ static void handle_socket_msg_bind(struct socket_data *sd, void *pvMsg)
*/ */
if (bind_msg->status) { if (bind_msg->status) {
SYS_LOG_ERR("BIND: error %d %s", LOG_ERR("BIND: error %d %s",
bind_msg->status, bind_msg->status,
socket_message_to_string(bind_msg->status)); socket_message_to_string(bind_msg->status));
sd->ret_code = bind_msg->status; sd->ret_code = bind_msg->status;
} }
} }
@ -855,9 +853,9 @@ static void handle_socket_msg_listen(struct socket_data *sd, void *pvMsg)
*/ */
if (listen_msg->status) { if (listen_msg->status) {
SYS_LOG_ERR("winc1500_socket_cb:LISTEN: error %d %s", LOG_ERR("winc1500_socket_cb:LISTEN: error %d %s",
listen_msg->status, listen_msg->status,
socket_message_to_string(listen_msg->status)); socket_message_to_string(listen_msg->status));
sd->ret_code = listen_msg->status; sd->ret_code = listen_msg->status;
} }
} }
@ -872,18 +870,18 @@ static void handle_socket_msg_accept(struct socket_data *sd, void *pvMsg)
* of the accept operation. * of the accept operation.
*/ */
SYS_LOG_DBG("ACCEPT: from %d.%d.%d.%d:%d, new socket is %d", LOG_DBG("ACCEPT: from %d.%d.%d.%d:%d, new socket is %d",
accept_msg->strAddr.sin_addr.s4_addr[0], accept_msg->strAddr.sin_addr.s4_addr[0],
accept_msg->strAddr.sin_addr.s4_addr[1], accept_msg->strAddr.sin_addr.s4_addr[1],
accept_msg->strAddr.sin_addr.s4_addr[2], accept_msg->strAddr.sin_addr.s4_addr[2],
accept_msg->strAddr.sin_addr.s4_addr[3], accept_msg->strAddr.sin_addr.s4_addr[3],
ntohs(accept_msg->strAddr.sin_port), ntohs(accept_msg->strAddr.sin_port),
accept_msg->sock); accept_msg->sock);
if (accept_msg->sock < 0) { if (accept_msg->sock < 0) {
SYS_LOG_ERR("ACCEPT: error %d %s", LOG_ERR("ACCEPT: error %d %s",
accept_msg->sock, accept_msg->sock,
socket_message_to_string(accept_msg->sock)); socket_message_to_string(accept_msg->sock));
sd->ret_code = accept_msg->sock; sd->ret_code = accept_msg->sock;
} }
@ -898,7 +896,7 @@ static void handle_socket_msg_accept(struct socket_data *sd, void *pvMsg)
ret = net_context_get(AF_INET, SOCK_STREAM, ret = net_context_get(AF_INET, SOCK_STREAM,
IPPROTO_TCP, &a_sd->context); IPPROTO_TCP, &a_sd->context);
if (ret < 0) { if (ret < 0) {
SYS_LOG_ERR("Cannot get new net context for ACCEPT"); LOG_ERR("Cannot get new net context for ACCEPT");
} else { } else {
a_sd->context->offload_context = a_sd->context->offload_context =
(void *)((int)accept_msg->sock); (void *)((int)accept_msg->sock);
@ -918,8 +916,8 @@ static void winc1500_socket_cb(SOCKET sock, uint8 message, void *pvMsg)
struct socket_data *sd = &w1500_data.socket_data[sock]; struct socket_data *sd = &w1500_data.socket_data[sock];
if (message != 6) { if (message != 6) {
SYS_LOG_DBG(": sock %d Msg %d %s", LOG_DBG("sock %d Msg %d %s",
sock, message, socket_message_to_string(message)); sock, message, socket_message_to_string(message));
} }
sd->ret_code = 0; sd->ret_code = 0;
@ -1013,11 +1011,12 @@ static int winc1500_mgmt_connect(struct device *dev,
channel = params->channel; channel = params->channel;
} }
SYS_LOG_DBG("Connecting to %s (%u) on channel %u %s security (%s)", LOG_DBG("Connecting to %s (%u) on %s %u %s security (%s)",
ssid, params->ssid_length, ssid, params->ssid_length,
channel == M2M_WIFI_CH_ALL ? "unknown" : channel, channel == M2M_WIFI_CH_ALL ? "channel unknown" : "channel",
security == M2M_WIFI_SEC_OPEN ? "without" : "with", channel,
params->psk ? (char *)psk.au8PSK : ""); security == M2M_WIFI_SEC_OPEN ? "without" : "with",
params->psk ? (char *)psk.au8PSK : "");
if (m2m_wifi_connect((char *)ssid, params->ssid_length, if (m2m_wifi_connect((char *)ssid, params->ssid_length,
security, auth, channel)) { security, auth, channel)) {
@ -1044,10 +1043,10 @@ static int winc1500_mgmt_disconnect(struct device *device)
static void winc1500_iface_init(struct net_if *iface) static void winc1500_iface_init(struct net_if *iface)
{ {
SYS_LOG_DBG("eth_init:net_if_set_link_addr:" LOG_DBG("eth_init:net_if_set_link_addr:"
"MAC Address %02X:%02X:%02X:%02X:%02X:%02X", "MAC Address %02X:%02X:%02X:%02X:%02X:%02X",
w1500_data.mac[0], w1500_data.mac[1], w1500_data.mac[2], w1500_data.mac[0], w1500_data.mac[1], w1500_data.mac[2],
w1500_data.mac[3], w1500_data.mac[4], w1500_data.mac[5]); w1500_data.mac[3], w1500_data.mac[4], w1500_data.mac[5]);
net_if_set_link_addr(iface, w1500_data.mac, sizeof(w1500_data.mac), net_if_set_link_addr(iface, w1500_data.mac, sizeof(w1500_data.mac),
NET_LINK_ETHERNET); NET_LINK_ETHERNET);
@ -1079,7 +1078,7 @@ static int winc1500_init(struct device *dev)
ret = m2m_wifi_init(&param); ret = m2m_wifi_init(&param);
if (ret) { if (ret) {
SYS_LOG_ERR("m2m_wifi_init return error!(%d)", ret); LOG_ERR("m2m_wifi_init return error!(%d)", ret);
return -EIO; return -EIO;
} }
@ -1089,11 +1088,11 @@ static int winc1500_init(struct device *dev)
registerSocketCallback(winc1500_socket_cb, NULL); registerSocketCallback(winc1500_socket_cb, NULL);
m2m_wifi_get_otp_mac_address(w1500_data.mac, &is_valid); m2m_wifi_get_otp_mac_address(w1500_data.mac, &is_valid);
SYS_LOG_DBG("WINC1500 MAC Address from OTP (%d) " LOG_DBG("WINC1500 MAC Address from OTP (%d) "
"%02X:%02X:%02X:%02X:%02X:%02X", "%02X:%02X:%02X:%02X:%02X:%02X",
is_valid, is_valid,
w1500_data.mac[0], w1500_data.mac[1], w1500_data.mac[2], w1500_data.mac[0], w1500_data.mac[1], w1500_data.mac[2],
w1500_data.mac[3], w1500_data.mac[4], w1500_data.mac[5]); w1500_data.mac[3], w1500_data.mac[4], w1500_data.mac[5]);
m2m_wifi_set_power_profile(PWR_LOW1); m2m_wifi_set_power_profile(PWR_LOW1);
m2m_wifi_set_tx_power(TX_PWR_LOW); m2m_wifi_set_tx_power(TX_PWR_LOW);
@ -1105,7 +1104,7 @@ static int winc1500_init(struct device *dev)
K_PRIO_COOP(CONFIG_WIFI_WINC1500_THREAD_PRIO), K_PRIO_COOP(CONFIG_WIFI_WINC1500_THREAD_PRIO),
0, K_NO_WAIT); 0, K_NO_WAIT);
SYS_LOG_DBG("WINC1500 driver Initialized"); LOG_DBG("WINC1500 driver Initialized");
return 0; return 0;
} }

2
samples/net/wifi/boards/cc3220sf_launchxl.conf
View file

@ -2,5 +2,5 @@
# cmake .. -DBOARD=cc3220sf_launchxl # cmake .. -DBOARD=cc3220sf_launchxl
CONFIG_WIFI_SIMPLELINK=y CONFIG_WIFI_SIMPLELINK=y
# Debugging # Debugging
CONFIG_SYS_LOG_WIFI_LEVEL=4 CONFIG_WIFI_LOG_LEVEL_DBG=y
CONFIG_DEBUG=y CONFIG_DEBUG=y

10
samples/net/wifi/prj_base.conf
View file

@ -16,21 +16,13 @@ CONFIG_NET_IPV4=y
CONFIG_NET_IPV6=n CONFIG_NET_IPV6=n
CONFIG_NET_LOG=y CONFIG_NET_LOG=y
CONFIG_SYS_LOG_NET_LEVEL=1
CONFIG_SYS_LOG_SHOW_COLOR=y
CONFIG_INIT_STACKS=y CONFIG_INIT_STACKS=y
CONFIG_NET_SHELL=y CONFIG_NET_SHELL=y
CONFIG_NET_DEBUG_CORE=n
CONFIG_NET_DEBUG_CONTEXT=n
CONFIG_NET_DEBUG_NET_PKT=n
CONFIG_NET_DEBUG_UTILS=n
CONFIG_NET_DEBUG_IF=n
CONFIG_NET_DEBUG_CONN=n
CONFIG_NET_STATISTICS=y CONFIG_NET_STATISTICS=y
CONFIG_NET_STATISTICS_PERIODIC_OUTPUT=n CONFIG_NET_STATISTICS_PERIODIC_OUTPUT=n
CONFIG_WIFI=y CONFIG_WIFI=y
CONFIG_SYS_LOG_WIFI_LEVEL=1 CONFIG_WIFI_LOG_LEVEL_ERR=y
CONFIG_NET_L2_WIFI_SHELL=y CONFIG_NET_L2_WIFI_SHELL=y