wifi_hal_ip.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "nx_api.h"
#include "nx_ether_driver_c6.h"
#include "nxd_dhcp_client.h"
#include "ra8_c6link.h"
#include "ra8_err.h"
#include "ra8_wifi.h"
#include "tx_api.h"
#include "wifi_hal_join.h"

typedef enum : uint32_t {
  k_wifi_hal_pkt_payload = 1568U,  
  k_wifi_hal_pool_bytes  = 40960U, 
  k_wifi_hal_ip_stack    = 2048U,  
  k_wifi_hal_arp_bytes   = 1040U,  
  k_wifi_hal_ip_prio     = 3U,     
} wifi_hal_net_size_t;

static NX_PACKET_POOL s_pool;
alignas(4) static uint8_t s_pool_mem[k_wifi_hal_pool_bytes];
static NX_IP s_ip;
alignas(8) static uint8_t s_ip_stack[k_wifi_hal_ip_stack];
alignas(4) static uint8_t s_arp_cache[k_wifi_hal_arp_bytes];
static NX_DHCP s_dhcp;
static CHAR s_pool_name[] = "wifi_hal_pool";
static CHAR s_ip_name[] = "wifi_hal_ip";
static CHAR s_dhcp_name[] = "wifi_hal_dhcp";
 
/* Create the packet pool + IP instance and enable the protocols DHCP needs. */
static UINT priv_net_create_ip(void)
{
  UINT s = nx_packet_pool_create(&s_pool,
                                 s_pool_name,
                                 (ULONG)k_wifi_hal_pkt_payload,
                                 (VOID*)s_pool_mem,
                                 (ULONG)sizeof(s_pool_mem));
  if (s != NX_SUCCESS) {
    return s;
  }
  s = nx_ip_create(&s_ip,
                   s_ip_name,
                   IP_ADDRESS(0, 0, 0, 0),
                   IP_ADDRESS(0, 0, 0, 0),
                   &s_pool,
                   nx_ether_driver_c6,
                   (VOID*)s_ip_stack,
                   (ULONG)sizeof(s_ip_stack),
                   (UINT)k_wifi_hal_ip_prio);
  if (s != NX_SUCCESS) {
    return s;
  }
  s = nx_arp_enable(&s_ip, (VOID*)s_arp_cache, (ULONG)sizeof(s_arp_cache));
  if (s != NX_SUCCESS) {
    return s;
  }
  s = nx_udp_enable(&s_ip);
  if (s != NX_SUCCESS) {
    return s;
  }
  return nx_icmp_enable(&s_ip);
}
 
/* Run the DHCP client to a bound lease, then read the lease into out. */
static UINT priv_net_dhcp(ra8_wifi_lease_t* out)
{
  UINT s = nx_dhcp_create(&s_dhcp, &s_ip, s_dhcp_name);
  if (s != NX_SUCCESS) {
    return s;
  }
  s = nx_dhcp_start(&s_dhcp);
  if (s != NX_SUCCESS) {
    return s;
  }
  ULONG actual = 0U;
  s            = nx_ip_status_check(&s_ip,
                                    (ULONG)NX_IP_ADDRESS_RESOLVED,
                                    &actual,
                                    (ULONG)k_wifi_hal_dhcp_wait_ms);
  if (s != NX_SUCCESS) {
    return s;
  }
  ULONG ip     = 0U;
  ULONG mask   = 0U;
  ULONG gw     = 0U;
  ULONG server = 0U;
  (void)nx_ip_address_get(&s_ip, &ip, &mask);
  (void)nx_ip_gateway_address_get(&s_ip, &gw);
  (void)nx_dhcp_server_address_get(&s_dhcp, &server);
  out->ip          = (uint32_t)ip;
  out->mask        = (uint32_t)mask;
  out->gateway     = (uint32_t)gw;
  out->dhcp_server = (uint32_t)server;
  return NX_SUCCESS;
}
 
ra8_err_t wifi_hal_ip_bind(void* ip_ctx, const ra8_wifi_mac_t* mac, ra8_wifi_lease_t* out)
{
  if ((ip_ctx == nullptr) || (mac == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out               = (ra8_wifi_lease_t){};
  ra8_c6link_t* link = (ra8_c6link_t*)ip_ctx;
 
  nx_ether_driver_c6_bind(link);
  nx_ether_driver_c6_set_mac(mac->octet);
  nx_system_initialize();
 
  if (priv_net_create_ip() != NX_SUCCESS) {
    return k_ra8_err_not_initialized;
  }
  if (priv_net_dhcp(out) != NX_SUCCESS) {
    *out = (ra8_wifi_lease_t){};
    return k_ra8_err_timeout;
  }
  out->bound = (out->ip != 0U);
  return k_ra8_ok;
}