ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #2874 from 0xc0170/feature_wifi_ublox 

emac HAL API, WiFiInterface additions
pull/2915/merge
Sam Grove 2016-10-04 22:46:09 -05:00 committed by GitHub
parent 970c6551a1 4f1ededb58
commit 683d7b7d74
17 changed files with 782 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
features/FEATURE_LWIP/lwip-interface/EthernetInterface.cpp
View File

@ -41,7 +41,7 @@ int EthernetInterface::set_dhcp(bool dhcp)
int EthernetInterface::connect()
{
return lwip_bringup(_dhcp,
return mbed_lwip_bringup(_dhcp,
_ip_address[0] ? _ip_address : 0,
_netmask[0] ? _netmask : 0,
_gateway[0] ? _gateway : 0);
@ -49,17 +49,17 @@ int EthernetInterface::connect()
int EthernetInterface::disconnect()
{
return lwip_bringdown();
return mbed_lwip_bringdown();
}
const char *EthernetInterface::get_mac_address()
{
return lwip_get_mac_address();
return mbed_lwip_get_mac_address();
}
const char *EthernetInterface::get_ip_address()
{
if (lwip_get_ip_address(_ip_address, sizeof _ip_address)) {
if (mbed_lwip_get_ip_address(_ip_address, sizeof _ip_address)) {
return _ip_address;
}
@ -68,7 +68,7 @@ const char *EthernetInterface::get_ip_address()
const char *EthernetInterface::get_netmask()
{
if (lwip_get_netmask(_netmask, sizeof _netmask)) {
if (mbed_lwip_get_netmask(_netmask, sizeof _netmask)) {
return _netmask;
}
@ -77,7 +77,7 @@ const char *EthernetInterface::get_netmask()
const char *EthernetInterface::get_gateway()
{
if (lwip_get_gateway(_gateway, sizeof _gateway)) {
if (mbed_lwip_get_gateway(_gateway, sizeof _gateway)) {
return _gateway;
}

91
features/FEATURE_LWIP/lwip-interface/emac_lwip.c Normal file
View File

@ -0,0 +1,91 @@
/* mbed Microcontroller Library
* Copyright (c) 2016 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "platform.h"
#if DEVICE_EMAC
#include "emac_api.h"
#include "emac_stack_mem.h"
#include "lwip/tcpip.h"
#include "lwip/tcp.h"
#include "lwip/ip.h"
#include "netif/etharp.h"
static err_t emac_lwip_low_level_output(struct netif *netif, struct pbuf *p)
{
emac_interface_t *mac = (emac_interface_t *)netif->state;
bool ret = mac->ops.link_out(mac, (emac_stack_mem_t *)p);
return ret ? ERR_OK : ERR_IF;
}
static void emac_lwip_input(void *data, emac_stack_t *buf)
{
struct pbuf *p = (struct pbuf *)buf;
struct netif *netif = (struct netif *)data;
/* pass all packets to ethernet_input, which decides what packets it supports */
if (netif->input(p, netif) != ERR_OK) {
LWIP_DEBUGF(NETIF_DEBUG, ("Emac LWIP: IP input error\n"));
pbuf_free(p);
}
}
static void emac_lwip_state_change(void *data, bool up)
{
struct netif *netif = (struct netif *)data;
if (up) {
tcpip_callback_with_block((tcpip_callback_fn)netif_set_link_up, netif, 1);
} else {
tcpip_callback_with_block((tcpip_callback_fn)netif_set_link_down, netif, 1);
}
}
err_t emac_lwip_if_init(struct netif *netif)
{
int err = ERR_OK;
emac_interface_t *mac = (emac_interface_t *)netif->state;
mac->ops.set_link_input_cb(mac, emac_lwip_input, netif);
mac->ops.set_link_state_cb(mac, emac_lwip_state_change, netif);
netif->hwaddr_len = mac->ops.get_hwaddr_size(mac);
mac->ops.get_hwaddr(mac, netif->hwaddr);
netif->mtu = mac->ops.get_mtu_size(mac);
/* Interface capabilities */
netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET | NETIF_FLAG_IGMP;
mac->ops.get_ifname(mac, netif->name, 2);
#if LWIP_IPV4
netif->output = etharp_output;
#endif /* LWIP_IPV4 */
netif->linkoutput = emac_lwip_low_level_output;
if (!mac->ops.power_up(mac)) {
err = ERR_IF;
}
return err;
}
#endif /* DEVICE_EMAC */

88
features/FEATURE_LWIP/lwip-interface/emac_stack_lwip.cpp Normal file
View File

@ -0,0 +1,88 @@
/* mbed Microcontroller Library
* Copyright (c) 2016 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "platform.h"
#if DEVICE_EMAC
#include "emac_stack_mem.h"
#include "pbuf.h"
emac_stack_mem_t *emac_stack_mem_alloc(emac_stack_t* stack, uint32_t size, uint32_t align)
{
struct pbuf *pbuf = pbuf_alloc(PBUF_RAW, size + align, PBUF_RAM);
if (pbuf == NULL) {
return NULL;
}
if (align) {
uint32_t remainder = (uint32_t)pbuf->payload % align;
uint32_t offset = align - remainder;
if (offset >= align) {
offset = align;
}
pbuf->payload = (void*)((char*)pbuf->payload + offset);
pbuf->tot_len -= offset;
pbuf->len -= offset;
}
return (emac_stack_mem_t*)pbuf;
}
void emac_stack_mem_free(emac_stack_t* stack, emac_stack_mem_t *mem)
{
pbuf_free((struct pbuf*)mem);
}
void *emac_stack_mem_ptr(emac_stack_t* stack, emac_stack_mem_t *mem)
{
return ((struct pbuf*)mem)->payload;
}
uint32_t emac_stack_mem_len(emac_stack_t* stack, emac_stack_mem_t *mem)
{
return ((struct pbuf*)mem)->len;
}
void emac_stack_mem_set_len(emac_stack_t* stack, emac_stack_mem_t *mem, uint32_t len)
{
struct pbuf *pbuf = (struct pbuf*)mem;
pbuf->len = len;
}
emac_stack_mem_t *emac_stack_mem_chain_dequeue(emac_stack_t* stack, emac_stack_mem_chain_t **chain)
{
struct pbuf **list = (struct pbuf**)chain;
struct pbuf *head = *list;
*list = (*list)->next;
return (emac_stack_mem_t *)head;
}
uint32_t emac_stack_mem_chain_len(emac_stack_t* stack, emac_stack_mem_chain_t *chain)
{
return ((struct pbuf*)chain)->tot_len;
}
void emac_stack_mem_ref(emac_stack_t* stack, emac_stack_mem_t *mem)
{
pbuf_ref((struct pbuf*)mem);
}
#endif /* DEVICE_EMAC */

6
features/FEATURE_LWIP/lwip-interface/eth_arch.h
View File

@ -29,13 +29,17 @@
extern "C" {
#endif
#if DEVICE_EMAC
err_t emac_lwip_if_init(struct netif *netif);
#else /* DEVICE_EMAC */
void eth_arch_enable_interrupts(void);
void eth_arch_disable_interrupts(void);
err_t eth_arch_enetif_init(struct netif *netif);
#endif
#ifdef __cplusplus
}
#endif
#endif // #ifndef ETHARCHINTERFACE_H_

199
features/FEATURE_LWIP/lwip-interface/lwip_stack.c
View File

@ -33,6 +33,16 @@
#include "lwip/dns.h"
#include "lwip/udp.h"
#include "emac_api.h"
#if DEVICE_EMAC
#define MBED_NETIF_INIT_FN emac_lwip_if_init
#else
#define MBED_NETIF_INIT_FN eth_arch_enetif_init
#endif
#define DHCP_TIMEOUT 15000
/* Static arena of sockets */
static struct lwip_socket {
bool in_use;
@ -47,12 +57,12 @@ static struct lwip_socket {
static bool lwip_connected = false;
static void lwip_arena_init(void)
static void mbed_lwip_arena_init(void)
{
memset(lwip_arena, 0, sizeof lwip_arena);
}
static struct lwip_socket *lwip_arena_alloc(void)
static struct lwip_socket *mbed_lwip_arena_alloc(void)
{
sys_prot_t prot = sys_arch_protect();
@ -70,12 +80,12 @@ static struct lwip_socket *lwip_arena_alloc(void)
return 0;
}
static void lwip_arena_dealloc(struct lwip_socket *s)
static void mbed_lwip_arena_dealloc(struct lwip_socket *s)
{
s->in_use = false;
}
static void lwip_socket_callback(struct netconn *nc, enum netconn_evt eh, u16_t len)
static void mbed_lwip_socket_callback(struct netconn *nc, enum netconn_evt eh, u16_t len)
{
sys_prot_t prot = sys_arch_protect();
@ -164,7 +174,7 @@ static bool convert_lwip_addr_to_mbed(nsapi_addr_t *out, const ip_addr_t *in)
return false;
}
static const ip_addr_t *lwip_get_ipv4_addr(const struct netif *netif)
static const ip_addr_t *mbed_lwip_get_ipv4_addr(const struct netif *netif)
{
#if LWIP_IPV4
if (!netif_is_up(netif)) {
@ -179,7 +189,7 @@ static const ip_addr_t *lwip_get_ipv4_addr(const struct netif *netif)
return NULL;
}
static const ip_addr_t *lwip_get_ipv6_addr(const struct netif *netif)
static const ip_addr_t *mbed_lwip_get_ipv6_addr(const struct netif *netif)
{
#if LWIP_IPV6
if (!netif_is_up(netif)) {
@ -198,17 +208,17 @@ static const ip_addr_t *lwip_get_ipv6_addr(const struct netif *netif)
}
const ip_addr_t *lwip_get_ip_addr(bool any_addr, const struct netif *netif)
const ip_addr_t *mbed_lwip_get_ip_addr(bool any_addr, const struct netif *netif)
{
const ip_addr_t *pref_ip_addr = 0;
const ip_addr_t *npref_ip_addr = 0;
#if IP_VERSION_PREF == PREF_IPV4
pref_ip_addr = lwip_get_ipv4_addr(netif);
npref_ip_addr = lwip_get_ipv6_addr(netif);
pref_ip_addr = mbed_lwip_get_ipv4_addr(netif);
npref_ip_addr = mbed_lwip_get_ipv6_addr(netif);
#else
pref_ip_addr = lwip_get_ipv6_addr(netif);
npref_ip_addr = lwip_get_ipv4_addr(netif);
pref_ip_addr = mbed_lwip_get_ipv6_addr(netif);
npref_ip_addr = mbed_lwip_get_ipv4_addr(netif);
#endif
if (pref_ip_addr) {
@ -223,7 +233,7 @@ const ip_addr_t *lwip_get_ip_addr(bool any_addr, const struct netif *netif)
#if LWIP_IPV6
void add_dns_addr(struct netif *lwip_netif)
{
const ip_addr_t *ip_addr = lwip_get_ip_addr(true, lwip_netif);
const ip_addr_t *ip_addr = mbed_lwip_get_ip_addr(true, lwip_netif);
if (ip_addr) {
if (IP_IS_V6(ip_addr)) {
const ip_addr_t *dns_ip_addr;
@ -252,13 +262,13 @@ void add_dns_addr(struct netif *lwip_netif)
#endif
static sys_sem_t lwip_tcpip_inited;
static void lwip_tcpip_init_irq(void *eh)
static void mbed_lwip_tcpip_init_irq(void *eh)
{
sys_sem_signal(&lwip_tcpip_inited);
}
static sys_sem_t lwip_netif_linked;
static void lwip_netif_link_irq(struct netif *lwip_netif)
static void mbed_lwip_netif_link_irq(struct netif *lwip_netif)
{
if (netif_is_link_up(lwip_netif)) {
sys_sem_signal(&lwip_netif_linked);
@ -266,24 +276,24 @@ static void lwip_netif_link_irq(struct netif *lwip_netif)
}
static sys_sem_t lwip_netif_has_addr;
static void lwip_netif_status_irq(struct netif *lwip_netif)
static void mbed_lwip_netif_status_irq(struct netif *lwip_netif)
{
static bool any_addr = true;
// Indicates that has address
if (any_addr == true && lwip_get_ip_addr(true, lwip_netif)) {
if (any_addr == true && mbed_lwip_get_ip_addr(true, lwip_netif)) {
sys_sem_signal(&lwip_netif_has_addr);
any_addr = false;
return;
}
// Indicates that has preferred address
if (lwip_get_ip_addr(false, lwip_netif)) {
if (mbed_lwip_get_ip_addr(false, lwip_netif)) {
sys_sem_signal(&lwip_netif_has_addr);
}
}
static void lwip_set_mac_address(void)
static void mbed_lwip_set_mac_address(void)
{
#if (MBED_MAC_ADDRESS_SUM != MBED_MAC_ADDR_INTERFACE)
snprintf(lwip_mac_address, 19, "%02x:%02x:%02x:%02x:%02x:%02x",
@ -298,14 +308,14 @@ static void lwip_set_mac_address(void)
}
/* LWIP interface implementation */
const char *lwip_get_mac_address(void)
const char *mbed_lwip_get_mac_address(void)
{
return lwip_mac_address[0] ? lwip_mac_address : 0;
}
char *lwip_get_ip_address(char *buf, int buflen)
char *mbed_lwip_get_ip_address(char *buf, int buflen)
{
const ip_addr_t *addr = lwip_get_ip_addr(true, &lwip_netif);
const ip_addr_t *addr = mbed_lwip_get_ip_addr(true, &lwip_netif);
if (!addr) {
return NULL;
}
@ -322,12 +332,12 @@ char *lwip_get_ip_address(char *buf, int buflen)
return NULL;
}
const char *lwip_get_netmask(char *buf, int buflen)
const char *mbed_lwip_get_netmask(char *buf, int buflen)
{
#if LWIP_IPV4
const ip4_addr_t *addr = netif_ip4_netmask(&lwip_netif);
if (!ip4_addr_isany(addr)) {
return inet_ntoa_r(addr, buf, buflen);
return ip4addr_ntoa_r(addr, buf, buflen);
} else {
return NULL;
}
@ -336,12 +346,12 @@ const char *lwip_get_netmask(char *buf, int buflen)
#endif
}
char *lwip_get_gateway(char *buf, int buflen)
char *mbed_lwip_get_gateway(char *buf, int buflen)
{
#if LWIP_IPV4
const ip4_addr_t *addr = netif_ip4_gw(&lwip_netif);
if (!ip4_addr_isany(addr)) {
return inet_ntoa_r(addr, buf, buflen);
return ip4addr_ntoa_r(addr, buf, buflen);
} else {
return NULL;
}
@ -350,23 +360,18 @@ char *lwip_get_gateway(char *buf, int buflen)
#endif
}
int lwip_bringup(bool dhcp, const char *ip, const char *netmask, const char *gw)
int mbed_lwip_init(emac_interface_t *emac)
{
// Check if we've already connected
if (lwip_connected) {
return NSAPI_ERROR_PARAMETER;
}
// Check if we've already brought up lwip
if (!lwip_get_mac_address()) {
if (!mbed_lwip_get_mac_address()) {
// Set up network
lwip_set_mac_address();
mbed_lwip_set_mac_address();
sys_sem_new(&lwip_tcpip_inited, 0);
sys_sem_new(&lwip_netif_linked, 0);
sys_sem_new(&lwip_netif_has_addr, 0);
tcpip_init(lwip_tcpip_init_irq, NULL);
tcpip_init(mbed_lwip_tcpip_init_irq, NULL);
sys_arch_sem_wait(&lwip_tcpip_inited, 0);
memset(&lwip_netif, 0, sizeof lwip_netif);
@ -374,19 +379,36 @@ int lwip_bringup(bool dhcp, const char *ip, const char *netmask, const char *gw)
#if LWIP_IPV4
0, 0, 0,
#endif
NULL, eth_arch_enetif_init, tcpip_input)) {
return -1;
emac, MBED_NETIF_INIT_FN, tcpip_input)) {
return NSAPI_ERROR_DEVICE_ERROR;
}
netif_set_default(&lwip_netif);
netif_set_link_callback (&lwip_netif, lwip_netif_link_irq);
netif_set_status_callback(&lwip_netif, lwip_netif_status_irq);
netif_set_link_callback(&lwip_netif, mbed_lwip_netif_link_irq);
netif_set_status_callback(&lwip_netif, mbed_lwip_netif_status_irq);
#if !DEVICE_EMAC
eth_arch_enable_interrupts();
#endif
}
return NSAPI_ERROR_OK;
}
int mbed_lwip_bringup(bool dhcp, const char *ip, const char *netmask, const char *gw)
{
// Check if we've already connected
if (lwip_connected) {
return NSAPI_ERROR_PARAMETER;
}
if(mbed_lwip_init(NULL) != NSAPI_ERROR_OK) {
return NSAPI_ERROR_DEVICE_ERROR;
}
// Zero out socket set
lwip_arena_init();
mbed_lwip_arena_init();
#if LWIP_IPV6
netif_create_ip6_linklocal_address(&lwip_netif, 1/*from MAC*/);
@ -451,9 +473,8 @@ int lwip_bringup(bool dhcp, const char *ip, const char *netmask, const char *gw)
#endif
// If doesn't have address
if (!lwip_get_ip_addr(true, &lwip_netif)) {
//ret = sys_arch_sem_wait(&lwip_netif_has_addr, 15000);
ret = sys_arch_sem_wait(&lwip_netif_has_addr, 30000);
if (!mbed_lwip_get_ip_addr(true, &lwip_netif)) {
ret = sys_arch_sem_wait(&lwip_netif_has_addr, 15000);
if (ret == SYS_ARCH_TIMEOUT) {
return NSAPI_ERROR_DHCP_FAILURE;
}
@ -463,7 +484,7 @@ int lwip_bringup(bool dhcp, const char *ip, const char *netmask, const char *gw)
#if ADDR_TIMEOUT
// If address is not for preferred stack waits a while to see
// if preferred stack address is acquired
if (!lwip_get_ip_addr(false, &lwip_netif)) {
if (!mbed_lwip_get_ip_addr(false, &lwip_netif)) {
ret = sys_arch_sem_wait(&lwip_netif_has_addr, ADDR_TIMEOUT * 1000);
}
#endif
@ -475,7 +496,7 @@ int lwip_bringup(bool dhcp, const char *ip, const char *netmask, const char *gw)
return 0;
}
int lwip_bringdown(void)
int mbed_lwip_bringdown(void)
{
// Check if we've connected
if (!lwip_connected) {
@ -499,7 +520,7 @@ int lwip_bringdown(void)
}
/* LWIP error remapping */
static int lwip_err_remap(err_t err) {
static int mbed_lwip_err_remap(err_t err) {
switch (err) {
case ERR_OK:
case ERR_CLSD:
@ -525,7 +546,7 @@ static int lwip_err_remap(err_t err) {
}
/* LWIP network stack implementation */
static int lwip_gethostbyname(nsapi_stack_t *stack, const char *host, nsapi_addr_t *addr, nsapi_version_t version)
static int mbed_lwip_gethostbyname(nsapi_stack_t *stack, const char *host, nsapi_addr_t *addr, nsapi_version_t version)
{
ip_addr_t lwip_addr;
@ -533,7 +554,7 @@ static int lwip_gethostbyname(nsapi_stack_t *stack, const char *host, nsapi_addr
u8_t addr_type;
if (version == NSAPI_UNSPEC) {
const ip_addr_t *ip_addr;
ip_addr = lwip_get_ip_addr(true, &lwip_netif);
ip_addr = mbed_lwip_get_ip_addr(true, &lwip_netif);
if (IP_IS_V6(ip_addr)) {
addr_type = NETCONN_DNS_IPV6;
} else {
@ -566,7 +587,7 @@ static int lwip_gethostbyname(nsapi_stack_t *stack, const char *host, nsapi_addr
return 0;
}
static int lwip_socket_open(nsapi_stack_t *stack, nsapi_socket_t *handle, nsapi_protocol_t proto)
static int mbed_lwip_socket_open(nsapi_stack_t *stack, nsapi_socket_t *handle, nsapi_protocol_t proto)
{
// check if network is connected
if (!lwip_connected) {
@ -574,7 +595,7 @@ static int lwip_socket_open(nsapi_stack_t *stack, nsapi_socket_t *handle, nsapi_
}
// allocate a socket
struct lwip_socket *s = lwip_arena_alloc();
struct lwip_socket *s = mbed_lwip_arena_alloc();
if (!s) {
return NSAPI_ERROR_NO_SOCKET;
}
@ -583,7 +604,7 @@ static int lwip_socket_open(nsapi_stack_t *stack, nsapi_socket_t *handle, nsapi_
#if LWIP_IPV6 && LWIP_IPV4
const ip_addr_t *ip_addr;
ip_addr = lwip_get_ip_addr(true, &lwip_netif);
ip_addr = mbed_lwip_get_ip_addr(true, &lwip_netif);
if (IP_IS_V6(ip_addr)) {
// Enable IPv6 (or dual-stack). LWIP dual-stack support is
@ -597,10 +618,10 @@ static int lwip_socket_open(nsapi_stack_t *stack, nsapi_socket_t *handle, nsapi_
lwip_proto |= NETCONN_TYPE_IPV6;
#endif
s->conn = netconn_new_with_callback(lwip_proto, lwip_socket_callback);
s->conn = netconn_new_with_callback(lwip_proto, mbed_lwip_socket_callback);
if (!s->conn) {
lwip_arena_dealloc(s);
mbed_lwip_arena_dealloc(s);
return NSAPI_ERROR_NO_SOCKET;
}
@ -609,16 +630,16 @@ static int lwip_socket_open(nsapi_stack_t *stack, nsapi_socket_t *handle, nsapi_
return 0;
}
static int lwip_socket_close(nsapi_stack_t *stack, nsapi_socket_t handle)
static int mbed_lwip_socket_close(nsapi_stack_t *stack, nsapi_socket_t handle)
{
struct lwip_socket *s = (struct lwip_socket *)handle;
err_t err = netconn_delete(s->conn);
lwip_arena_dealloc(s);
return lwip_err_remap(err);
mbed_lwip_arena_dealloc(s);
return mbed_lwip_err_remap(err);
}
static int lwip_socket_bind(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port)
static int mbed_lwip_socket_bind(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port)
{
struct lwip_socket *s = (struct lwip_socket *)handle;
ip_addr_t ip_addr;
@ -633,18 +654,18 @@ static int lwip_socket_bind(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_a
}
err_t err = netconn_bind(s->conn, &ip_addr, port);
return lwip_err_remap(err);
return mbed_lwip_err_remap(err);
}
static int lwip_socket_listen(nsapi_stack_t *stack, nsapi_socket_t handle, int backlog)
static int mbed_lwip_socket_listen(nsapi_stack_t *stack, nsapi_socket_t handle, int backlog)
{
struct lwip_socket *s = (struct lwip_socket *)handle;
err_t err = netconn_listen_with_backlog(s->conn, backlog);
return lwip_err_remap(err);
return mbed_lwip_err_remap(err);
}
static int lwip_socket_connect(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port)
static int mbed_lwip_socket_connect(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port)
{
struct lwip_socket *s = (struct lwip_socket *)handle;
ip_addr_t ip_addr;
@ -657,21 +678,21 @@ static int lwip_socket_connect(nsapi_stack_t *stack, nsapi_socket_t handle, nsap
err_t err = netconn_connect(s->conn, &ip_addr, port);
netconn_set_nonblocking(s->conn, true);
return lwip_err_remap(err);
return mbed_lwip_err_remap(err);
}
static int lwip_socket_accept(nsapi_stack_t *stack, nsapi_socket_t server, nsapi_socket_t *handle, nsapi_addr_t *addr, uint16_t *port)
static int mbed_lwip_socket_accept(nsapi_stack_t *stack, nsapi_socket_t server, nsapi_socket_t *handle, nsapi_addr_t *addr, uint16_t *port)
{
struct lwip_socket *s = (struct lwip_socket *)server;
struct lwip_socket *ns = lwip_arena_alloc();
struct lwip_socket *ns = mbed_lwip_arena_alloc();
if (!ns) {
return NSAPI_ERROR_NO_SOCKET;
}
err_t err = netconn_accept(s->conn, &ns->conn);
if (err != ERR_OK) {
lwip_arena_dealloc(ns);
return lwip_err_remap(err);
mbed_lwip_arena_dealloc(ns);
return mbed_lwip_err_remap(err);
}
netconn_set_recvtimeout(ns->conn, 1);
@ -683,20 +704,20 @@ static int lwip_socket_accept(nsapi_stack_t *stack, nsapi_socket_t server, nsapi
return 0;
}
static int lwip_socket_send(nsapi_stack_t *stack, nsapi_socket_t handle, const void *data, unsigned size)
static int mbed_lwip_socket_send(nsapi_stack_t *stack, nsapi_socket_t handle, const void *data, unsigned size)
{
struct lwip_socket *s = (struct lwip_socket *)handle;
size_t bytes_written = 0;
err_t err = netconn_write_partly(s->conn, data, size, NETCONN_COPY, &bytes_written);
if (err != ERR_OK) {
return lwip_err_remap(err);
return mbed_lwip_err_remap(err);
}
return (int)bytes_written;
}
static int lwip_socket_recv(nsapi_stack_t *stack, nsapi_socket_t handle, void *data, unsigned size)
static int mbed_lwip_socket_recv(nsapi_stack_t *stack, nsapi_socket_t handle, void *data, unsigned size)
{
struct lwip_socket *s = (struct lwip_socket *)handle;
@ -705,7 +726,7 @@ static int lwip_socket_recv(nsapi_stack_t *stack, nsapi_socket_t handle, void *d
s->offset = 0;
if (err != ERR_OK) {
return lwip_err_remap(err);
return mbed_lwip_err_remap(err);
}
}
@ -720,7 +741,7 @@ static int lwip_socket_recv(nsapi_stack_t *stack, nsapi_socket_t handle, void *d
return recv;
}
static int lwip_socket_sendto(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port, const void *data, unsigned size)
static int mbed_lwip_socket_sendto(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port, const void *data, unsigned size)
{
struct lwip_socket *s = (struct lwip_socket *)handle;
ip_addr_t ip_addr;
@ -733,26 +754,26 @@ static int lwip_socket_sendto(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi
err_t err = netbuf_ref(buf, data, (u16_t)size);
if (err != ERR_OK) {
netbuf_free(buf);
return lwip_err_remap(err);
return mbed_lwip_err_remap(err);
}
err = netconn_sendto(s->conn, buf, &ip_addr, port);
netbuf_delete(buf);
if (err != ERR_OK) {
return lwip_err_remap(err);
return mbed_lwip_err_remap(err);
}
return size;
}
static int lwip_socket_recvfrom(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t *addr, uint16_t *port, void *data, unsigned size)
static int mbed_lwip_socket_recvfrom(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t *addr, uint16_t *port, void *data, unsigned size)
{
struct lwip_socket *s = (struct lwip_socket *)handle;
struct netbuf *buf;
err_t err = netconn_recv(s->conn, &buf);
if (err != ERR_OK) {
return lwip_err_remap(err);
return mbed_lwip_err_remap(err);
}
convert_lwip_addr_to_mbed(addr, netbuf_fromaddr(buf));
@ -764,7 +785,7 @@ static int lwip_socket_recvfrom(nsapi_stack_t *stack, nsapi_socket_t handle, nsa
return recv;
}
static int lwip_setsockopt(nsapi_stack_t *stack, nsapi_socket_t handle, int level, int optname, const void *optval, unsigned optlen)
static int mbed_lwip_setsockopt(nsapi_stack_t *stack, nsapi_socket_t handle, int level, int optname, const void *optval, unsigned optlen)
{
struct lwip_socket *s = (struct lwip_socket *)handle;
@ -810,7 +831,7 @@ static int lwip_setsockopt(nsapi_stack_t *stack, nsapi_socket_t handle, int leve
}
}
static void lwip_socket_attach(nsapi_stack_t *stack, nsapi_socket_t handle, void (*callback)(void *), void *data)
static void mbed_lwip_socket_attach(nsapi_stack_t *stack, nsapi_socket_t handle, void (*callback)(void *), void *data)
{
struct lwip_socket *s = (struct lwip_socket *)handle;
@ -820,19 +841,19 @@ static void lwip_socket_attach(nsapi_stack_t *stack, nsapi_socket_t handle, void
/* LWIP network stack */
const nsapi_stack_api_t lwip_stack_api = {
.gethostbyname = lwip_gethostbyname,
.socket_open = lwip_socket_open,
.socket_close = lwip_socket_close,
.socket_bind = lwip_socket_bind,
.socket_listen = lwip_socket_listen,
.socket_connect = lwip_socket_connect,
.socket_accept = lwip_socket_accept,
.socket_send = lwip_socket_send,
.socket_recv = lwip_socket_recv,
.socket_sendto = lwip_socket_sendto,
.socket_recvfrom = lwip_socket_recvfrom,
.setsockopt = lwip_setsockopt,
.socket_attach = lwip_socket_attach,
.gethostbyname = mbed_lwip_gethostbyname,
.socket_open = mbed_lwip_socket_open,
.socket_close = mbed_lwip_socket_close,
.socket_bind = mbed_lwip_socket_bind,
.socket_listen = mbed_lwip_socket_listen,
.socket_connect = mbed_lwip_socket_connect,
.socket_accept = mbed_lwip_socket_accept,
.socket_send = mbed_lwip_socket_send,
.socket_recv = mbed_lwip_socket_recv,
.socket_sendto = mbed_lwip_socket_sendto,
.socket_recvfrom = mbed_lwip_socket_recvfrom,
.setsockopt = mbed_lwip_setsockopt,
.socket_attach = mbed_lwip_socket_attach,
};
nsapi_stack_t lwip_stack = {

15
features/FEATURE_LWIP/lwip-interface/lwip_stack.h
View File

@ -18,20 +18,21 @@
#define LWIP_STACK_H
#include "nsapi.h"
#include "emac_api.h"
#ifdef __cplusplus
extern "C" {
#endif
// Access to lwip through the nsapi
int lwip_bringup(bool dhcp, const char *ip, const char *netmask, const char *gw);
int lwip_bringdown(void);
int mbed_lwip_init(emac_interface_t *emac);
int mbed_lwip_bringup(bool dhcp, const char *ip, const char *netmask, const char *gw);
int mbed_lwip_bringdown(void);
const char *lwip_get_mac_address(void);
char *lwip_get_ip_address(char *buf, int buflen);
char *lwip_get_netmask(char *buf, int buflen);
char *lwip_get_gateway(char *buf, int buflen);
const char *mbed_lwip_get_mac_address(void);
char *mbed_lwip_get_ip_address(char *buf, int buflen);
char *mbed_lwip_get_netmask(char *buf, int buflen);
char *mbed_lwip_get_gateway(char *buf, int buflen);
extern nsapi_stack_t lwip_stack;

4
features/FEATURE_LWIP/lwip-interface/lwipopts.h
View File

@ -81,9 +81,9 @@
#define DEFAULT_ACCEPTMBOX_SIZE 8
#ifdef LWIP_DEBUG
#define TCPIP_THREAD_STACKSIZE 1024*2
#define TCPIP_THREAD_STACKSIZE 1200*2
#else
#define TCPIP_THREAD_STACKSIZE 1024
#define TCPIP_THREAD_STACKSIZE 1200
#endif
#define TCPIP_THREAD_PRIO (osPriorityNormal)

77
features/netsocket/CellularInterface.cpp
View File

@ -1,77 +0,0 @@
/* Socket
* Copyright (c) 2015 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "netsocket/CellularInterface.h"
#include <stdlib.h>
#include <string.h>
CellularInterface::CellularInterface()
: _apn(0), _user(0), _pass(0)
{
}
CellularInterface::~CellularInterface()
{
free(_apn);
free(_user);
free(_pass);
}
int CellularInterface::set_credentials(const char *apn, const char *user, const char *pass)
{
free(_apn);
_apn = 0;
free(_user);
_user = 0;
free(_pass);
_pass = 0;
if (apn) {
_apn = (char*)malloc(strlen(apn)+1);
if (!_apn) {
return NSAPI_ERROR_NO_MEMORY;
}
strcpy(_apn, apn);
}
if (user) {
_user = (char*)malloc(strlen(user)+1);
if (!_user) {
return NSAPI_ERROR_NO_MEMORY;
}
strcpy(_user, user);
}
if (pass) {
_pass = (char*)malloc(strlen(pass)+1);
if (!_pass) {
return NSAPI_ERROR_NO_MEMORY;
}
strcpy(_pass, pass);
}
return 0;
}
int CellularInterface::connect()
{
return connect(_apn, _user, _pass);
}

12
features/netsocket/CellularInterface.h
View File

@ -29,8 +29,7 @@ class CellularInterface : public NetworkInterface
public:
/** CellularInterface lifetime
*/
CellularInterface();
virtual ~CellularInterface();
virtual ~CellularInterface() {};
/** Set the cellular network APN and credentials
*
@ -38,7 +37,7 @@ public:
* @param user Optional username for the APN
* @param pass Optional password fot the APN
*/
virtual int set_credentials(const char *apn, const char *user = 0, const char *pass = 0);
virtual int set_credentials(const char *apn, const char *user = 0, const char *pass = 0) = 0;
/** Start the interface
*
@ -55,18 +54,13 @@ public:
*
* @return 0 on success, negative error code on failure
*/
virtual int connect();
virtual int connect() = 0;
/** Stop the interface
*
* @return 0 on success, negative error code on failure
*/
virtual int disconnect() = 0;
private:
char *_apn;
char *_user;
char *_pass;
};

37
features/netsocket/WiFiAccessPoint.cpp Normal file
View File

@ -0,0 +1,37 @@
#include "netsocket/WiFiAccessPoint.h"
WiFiAccessPoint::WiFiAccessPoint()
{
memset(&_ap, 0, sizeof(_ap));
}
WiFiAccessPoint::WiFiAccessPoint(nsapi_wifi_ap_t ap)
{
_ap = ap;
}
const char *WiFiAccessPoint::get_ssid() const
{
return _ap.ssid;
}
const uint8_t *WiFiAccessPoint::get_bssid() const
{
return _ap.bssid;
}
nsapi_security_t WiFiAccessPoint::get_security() const
{
return _ap.security;
}
int8_t WiFiAccessPoint::get_rssi() const
{
return _ap.rssi;
}
uint8_t WiFiAccessPoint::get_channel() const
{
return _ap.channel;
}

71
features/netsocket/WiFiAccessPoint.h Normal file
View File

@ -0,0 +1,71 @@
/* WiFiInterface
* Copyright (c) 2015 - 2016 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef WIFI_ACCESS_POINT_H
#define WIFI_ACCESS_POINT_H
#include <string.h>
#include "netsocket/nsapi_types.h"
/** WiFiAccessPoint class
*
* Class that represents a WiFi Access Point
* Common interface that is shared between WiFi devices
*/
class WiFiAccessPoint
{
/** WiFiAccessPoint lifetime
*/
public:
WiFiAccessPoint();
WiFiAccessPoint(nsapi_wifi_ap_t ap);
/** Get an access point's ssid
*
* @return The ssid of the access point
*/
const char *get_ssid() const;
/** Get an access point's bssid
*
* @return The bssid of the access point
*/
const uint8_t *get_bssid() const;
/** Get an access point's security
*
* @return The security type of the access point
*/
nsapi_security_t get_security() const;
/** Gets the radio signal strength for the access point
*
* @return Connection strength in dBm (negative value),
* or 0 if measurement impossible
*/
int8_t get_rssi() const;
/** Get the access point's channel
*
* @return The channel of the access point
*/
uint8_t get_channel() const;
private:
nsapi_wifi_ap_t _ap;
};
#endif

71
features/netsocket/WiFiInterface.cpp
View File

@ -1,71 +0,0 @@
/* Socket
* Copyright (c) 2015 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "netsocket/WiFiInterface.h"
#include <stdlib.h>
#include <string.h>
WiFiInterface::WiFiInterface()
: _ssid(0), _pass(0), _security(NSAPI_SECURITY_NONE)
{
}
WiFiInterface::~WiFiInterface()
{
free(_ssid);
free(_pass);
}
int WiFiInterface::set_credentials(const char *ssid, const char *pass, nsapi_security_t security)
{
free(_ssid);
_ssid = 0;
free(_pass);
_pass = 0;
if (ssid) {
_ssid = (char*)malloc(strlen(ssid)+1);
if (!_ssid) {
return NSAPI_ERROR_NO_MEMORY;
}
strcpy(_ssid, ssid);
}
if (pass) {
_pass = (char*)malloc(strlen(pass)+1);
if (!_pass) {
return NSAPI_ERROR_NO_MEMORY;
}
strcpy(_pass, pass);
}
_security = security;
return 0;
}
int WiFiInterface::connect()
{
if (!_ssid || !_pass) {
return NSAPI_ERROR_PARAMETER;
}
return connect(_ssid, _pass, _security);
}

91
features/netsocket/WiFiInterface.h
View File

@ -1,5 +1,5 @@
/* WiFiInterface
* Copyright (c) 2015 ARM Limited
* Copyright (c) 2015 - 2016 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -17,22 +17,10 @@
#ifndef WIFI_INTERFACE_H
#define WIFI_INTERFACE_H
#include <string.h>
#include "Callback.h"
#include "netsocket/NetworkInterface.h"
/** Enum of WiFi encryption types
*
* The security type specifies a particular security to use when
* connected to a WiFi network
*
* @enum nsapi_protocol_t
*/
enum nsapi_security_t {
NSAPI_SECURITY_NONE = 0, /*!< open access point */
NSAPI_SECURITY_WEP, /*!< phrase conforms to WEP */
NSAPI_SECURITY_WPA, /*!< phrase conforms to WPA */
NSAPI_SECURITY_WPA2, /*!< phrase conforms to WPA2 */
};
#include "netsocket/WiFiAccessPoint.h"
/** WiFiInterface class
*
@ -43,29 +31,45 @@ class WiFiInterface: public NetworkInterface
public:
/** WiFiInterface lifetime
*/
WiFiInterface();
virtual ~WiFiInterface();
virtual ~WiFiInterface() {};
/** Set the WiFi network credentials
*
* @param ssid Name of the network to connect to
* @param pass Security passphrase to connect to the network
* @param security Type of encryption for connection
* (defaults to NSAPI_SECURITY_NONE)
*/
virtual int set_credentials(const char *ssid, const char *pass, nsapi_security_t security = NSAPI_SECURITY_NONE);
/** Start the interface
*
* Attempts to connect to a WiFi network. If passphrase is invalid,
* NSAPI_ERROR_AUTH_ERROR is returned.
*
* @param ssid Name of the network to connect to
* @param pass Security passphrase to connect to the network
* @param security Type of encryption for connection
* @return 0 on success, negative error code on failure
* (defaults to NSAPI_SECURITY_NONE)
* @return 0 on success, or error code on failure
*/
virtual int connect(const char *ssid, const char *pass, nsapi_security_t security = NSAPI_SECURITY_NONE) = 0;
virtual int set_credentials(const char *ssid, const char *pass, nsapi_security_t security = NSAPI_SECURITY_NONE) = 0;
/** Set the WiFi network channel
*
* @param channel Channel on which the connection is to be made, or 0 for any (Default: 0)
* @return 0 on success, or error code on failure
*/
virtual int set_channel(uint8_t channel) = 0;
/** Gets the current radio signal strength for active connection
*
* @return Connection strength in dBm (negative value),
* or 0 if measurement impossible
*/
virtual int8_t get_rssi() = 0;
/** Start the interface
*
* Attempts to connect to a WiFi network.
*
* @param ssid Name of the network to connect to
* @param pass Security passphrase to connect to the network
* @param security Type of encryption for connection (Default: NSAPI_SECURITY_NONE)
* @param channel Channel on which the connection is to be made, or 0 for any (Default: 0)
* @return 0 on success, or error code on failure
*/
virtual int connect(const char *ssid, const char *pass,
nsapi_security_t security = NSAPI_SECURITY_NONE,
uint8_t channel = 0) = 0;
/** Start the interface
*
@ -74,19 +78,28 @@ public:
*
* @return 0 on success, negative error code on failure
*/
virtual int connect();
virtual int connect() = 0;
/** Stop the interface
*
* @return 0 on success, negative error code on failure
* @return 0 on success, or error code on failure
*/
virtual int disconnect() = 0;
private:
char *_ssid;
char *_pass;
nsapi_security_t _security;
/** Scan for available networks
*
* The scan will
* If the network interface is set to non-blocking mode, scan will attempt to scan
* for WiFi networks asynchronously and return NSAPI_ERROR_WOULD_BLOCK. If a callback
* is attached, the callback will be called when the operation has completed.
*
* @param ap Pointer to allocated array to store discovered AP
* @param count Size of allocated @a res array, or 0 to only count available AP
* @param timeout Timeout in milliseconds; 0 for no timeout (Default: 0)
* @return Number of entries in @a, or if @a count was 0 number of available networks, negative on error
* see @a nsapi_error
*/
virtual int scan(WiFiAccessPoint *res, unsigned count) = 0;
};
#endif

109
features/netsocket/emac_stack_mem.h Normal file
View File

@ -0,0 +1,109 @@
/* mbed Microcontroller Library
* Copyright (c) 2016 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MBED_EMAC_STACK_MEM_H
#define MBED_EMAC_STACK_MEM_H
#include "platform.h"
#if DEVICE_EMAC
#include <stdint.h>
/**
* Stack memory module
*
* This interface provides abstraction for memory modules used in different IP stacks (often to accommodate zero copy).
* Emac interface may be required to accept output packets and provide received data using this stack specific API.
* This header should be implemented for each IP stack, so that we keep emacs module independent.
*/
typedef void emac_stack_mem_t;
typedef void emac_stack_mem_chain_t;
typedef void emac_stack_t;
/**
* Allocates stack memory
*
* @param stack Emac stack context
* @param size Size of memory to allocate
* @param align Memory alignment requirements
* @return Allocated memory struct, or NULL in case of error
*/
emac_stack_mem_t *emac_stack_mem_alloc(emac_stack_t* stack, uint32_t size, uint32_t align);
/**
* Free memory allocated using @a stack_mem_alloc
*
* @param stack Emac stack context
* @param mem Memory to be freed
*/
void emac_stack_mem_free(emac_stack_t* stack, emac_stack_mem_t *mem);
/**
* Return pointer to the payload
*
* @param stack Emac stack context
* @param mem Memory structure
* @return Pointer to the payload
*/
void *emac_stack_mem_ptr(emac_stack_t* stack, emac_stack_mem_t *mem);
/**
* Return actual payload size
*
* @param stack Emac stack context
* @param mem Memory structure
* @return Size in bytes
*/
uint32_t emac_stack_mem_len(emac_stack_t* stack, emac_stack_mem_t *mem);
/**
* Sets the actual payload size (the allocated payload size will not change)
*
* @param stack Emac stack context
* @param mem Memory structure
* @param len Actual payload size
*/
void emac_stack_mem_set_len(emac_stack_t* stack, emac_stack_mem_t *mem, uint32_t len);
/**
* Returns first memory structure from the list and move the head to point to the next node
*
* @param stack Emac stack context
* @param list Pointer to the list
* @return First memory structure from the list
*/
emac_stack_mem_t *emac_stack_mem_chain_dequeue(emac_stack_t* stack, emac_stack_mem_chain_t **chain);
/**
* Return total length of the memory chain
*
* @param stack Emac stack context
* @param chain Memory chain
* @return Chain length
*/
uint32_t emac_stack_mem_chain_len(emac_stack_t* stack, emac_stack_mem_chain_t *chain);
/**
* Increases the reference counter for the memory
*
* @param stack Emac stack context
* @param mem Memory structure
*/
void emac_stack_mem_ref(emac_stack_t* stack, emac_stack_mem_t *mem);
#endif /* DEVICE_EMAC */
#endif /* EMAC_MBED_STACK_MEM_h */

37
features/netsocket/nsapi_types.h
View File

@ -24,7 +24,7 @@ extern "C" {
#endif
/** Enum of standardized error codes
/** Enum of standardized error codes
*
* Valid error codes have negative values and may
* be returned by any network operation.
@ -32,6 +32,7 @@ extern "C" {
* @enum nsapi_error_t
*/
typedef enum nsapi_error {
NSAPI_ERROR_OK = 0, /*!< no error */
NSAPI_ERROR_WOULD_BLOCK = -3001, /*!< no data is not available but call is non-blocking */
NSAPI_ERROR_UNSUPPORTED = -3002, /*!< unsupported functionality */
NSAPI_ERROR_PARAMETER = -3003, /*!< invalid configuration */
@ -39,12 +40,26 @@ typedef enum nsapi_error {
NSAPI_ERROR_NO_SOCKET = -3005, /*!< socket not available for use */
NSAPI_ERROR_NO_ADDRESS = -3006, /*!< IP address is not known */
NSAPI_ERROR_NO_MEMORY = -3007, /*!< memory resource not available */
NSAPI_ERROR_DNS_FAILURE = -3008, /*!< DNS failed to complete successfully */
NSAPI_ERROR_DHCP_FAILURE = -3009, /*!< DHCP failed to complete successfully */
NSAPI_ERROR_AUTH_FAILURE = -3010, /*!< connection to access point faield */
NSAPI_ERROR_DEVICE_ERROR = -3011, /*!< failure interfacing with the network procesor */
NSAPI_ERROR_NO_SSID = -3008, /*!< ssid not found */
NSAPI_ERROR_DNS_FAILURE = -3009, /*!< DNS failed to complete successfully */
NSAPI_ERROR_DHCP_FAILURE = -3010, /*!< DHCP failed to complete successfully */
NSAPI_ERROR_AUTH_FAILURE = -3011, /*!< connection to access point failed */
NSAPI_ERROR_DEVICE_ERROR = -3012, /*!< failure interfacing with the network processor */
} nsapi_error_t;
/** Enum of encryption types
*
* The security type specifies a particular security to use when
* connected to a WiFi network
*/
typedef enum nsapi_security {
NSAPI_SECURITY_NONE = 0x0, /*!< open access point */
NSAPI_SECURITY_WEP = 0x1, /*!< phrase conforms to WEP */
NSAPI_SECURITY_WPA = 0x2, /*!< phrase conforms to WPA */
NSAPI_SECURITY_WPA2 = 0x3, /*!< phrase conforms to WPA2 */
NSAPI_SECURITY_WPA_WPA2 = 0x4, /*!< phrase conforms to WPA/WPA2 */
NSAPI_SECURITY_UNKNOWN = 0xFF, /*!< unknown/unsupported security in scan results */
} nsapi_security_t;
/** Maximum size of IP address representation
*/
@ -148,6 +163,18 @@ typedef enum nsapi_option {
NSAPI_RCVBUF, /*!< Sets recv buffer size */
} nsapi_option_t;
/** nsapi_wifi_ap structure
*
* Structure representing a WiFi Access Point
*/
typedef struct nsapi_wifi_ap {
char ssid[33]; /* 32 is what 802.11 defines as longest possible name; +1 for the \0 */
uint8_t bssid[6];
nsapi_security_t security;
int8_t rssi;
uint8_t channel;
} nsapi_wifi_ap_t;
/** nsapi_stack structure
*

6
features/unsupported/net/eth/EthernetInterface/eth_arch.h
View File

@ -29,13 +29,17 @@
extern "C" {
#endif
#if DEVICE_EMAC
err_t emac_lwip_if_init(struct netif *netif);
#else /* DEVICE_EMAC */
void eth_arch_enable_interrupts(void);
void eth_arch_disable_interrupts(void);
err_t eth_arch_enetif_init(struct netif *netif);
#endif
#ifdef __cplusplus
}
#endif
#endif // #ifndef ETHARCHINTERFACE_H_

163
hal/hal/emac_api.h Normal file
View File

@ -0,0 +1,163 @@
/* mbed Microcontroller Library
* Copyright (c) 2016 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MBED_EMAC_API_H
#define MBED_EMAC_API_H
#include "platform.h"
#if DEVICE_EMAC
#include <stdbool.h>
#include "emac_stack_mem.h"
typedef struct emac_interface emac_interface_t;
/**
* EmacInterface
*
* This interface should be used to abstract low level access to networking hardware
*/
/**
* Callback to be register with Emac interface and to be called fore received packets
*
* @param data Arbitrary user data (IP stack)
* @param buf Received data
*/
typedef void (*emac_link_input_fn)(void *data, emac_stack_mem_chain_t *buf);
/**
* Callback to be register with Emac interface and to be called for link status changes
*
* @param data Arbitrary user data (IP stack)
* @param up Link status
*/
typedef void (*emac_link_state_change_fn)(void *data, bool up);
/**
* Return maximum transmission unit
*
* @param emac Emac interface
* @return MTU in bytes
*/
typedef uint32_t (*emac_get_mtu_size_fn)(emac_interface_t *emac);
/**
* Return interface name
*
* @param emac Emac interface
* @param name Pointer to where the name should be written
* @param size Maximum number of character to copy
*/
typedef void (*emac_get_ifname_fn)(emac_interface_t *emac, char *name, uint8_t size);
/**
* Returns size of the underlying interface HW address size
*
* @param emac Emac interface
* @return HW address size in bytes
*/
typedef uint8_t (*emac_get_hwaddr_size_fn)(emac_interface_t *emac);
/**
* Return interface hw address
*
* Copies HW address to provided memory, @param addr has to be of correct size see @a get_hwaddr_size
*
* @param emac Emac interface
* @param addr HW address for underlying interface
*/
typedef void (*emac_get_hwaddr_fn)(emac_interface_t *emac, uint8_t *addr);
/**
* Set HW address for interface
*
* Provided address has to be of correct size, see @a get_hwaddr_size
*
* @param emac Emac interface
* @param addr Address to be set
*/
typedef void (*emac_set_hwaddr_fn)(emac_interface_t *emac, uint8_t *addr);
/**
* Sends the packet over the link
*
* That can not be called from an interrupt context.
*
* @param emac Emac interface
* @param buf Packet to be send
* @return True if the packet was send successfully, False otherwise
*/
typedef bool (*emac_link_out_fn)(emac_interface_t *emac, emac_stack_mem_t *buf);
/**
* Initializes the HW
*
* @return True on success, False in case of an error.
*/
typedef bool (*emac_power_up_fn)(emac_interface_t *emac);
/**
* Deinitializes the HW
*
* @param emac Emac interface
*/
typedef void (*emac_power_down_fn)(emac_interface_t *emac);
/**
* Sets a callback that needs to be called for packets received for that interface
*
* @param emac Emac interface
* @param input_cb Function to be register as a callback
* @param data Arbitrary user data to be passed to the callback
*/
typedef void (*emac_set_link_input_cb_fn)(emac_interface_t *emac, emac_link_input_fn input_cb, void *data);
/**
* Sets a callback that needs to be called on link status changes for given interface
*
* @param emac Emac interface
* @param state_cb Function to be register as a callback
* @param data Arbitrary user data to be passed to the callback
*/
typedef void (*emac_set_link_state_cb_fn)(emac_interface_t *emac, emac_link_state_change_fn state_cb, void *data);
typedef struct emac_interface_ops {
emac_get_mtu_size_fn get_mtu_size;
emac_get_ifname_fn get_ifname;
emac_get_hwaddr_size_fn get_hwaddr_size;
emac_get_hwaddr_fn get_hwaddr;
emac_set_hwaddr_fn set_hwaddr;
emac_link_out_fn link_out;
emac_power_up_fn power_up;
emac_power_down_fn power_down;
emac_set_link_input_cb_fn set_link_input_cb;
emac_set_link_state_cb_fn set_link_state_cb;
} emac_interface_ops_t;
typedef struct emac_interface {
const emac_interface_ops_t ops;
void *hw;
} emac_interface_t;
#else
typedef void *emac_interface_t;
#endif /* DEVICE_EMAC */
#endif /* MBED_EMAC_API_H */