c6_join_net.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "c6_join.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 "tx_api.h"

typedef enum : uint32_t {
  k_c6_join_pkt_payload = 1568U,  
  k_c6_join_pool_bytes  = 40960U, 
  k_c6_join_ip_stack    = 2048U,  
  k_c6_join_arp_bytes   = 1040U,  
  k_c6_join_ip_prio     = 3U,     
  k_c6_join_ping_len    = 12U,    
} c6_join_net_size_t;

static NX_PACKET_POOL s_pool;
alignas(4) static uint8_t s_pool_mem[k_c6_join_pool_bytes];
static NX_IP s_ip;
alignas(8) static uint8_t s_ip_stack[k_c6_join_ip_stack];
alignas(4) static uint8_t s_arp_cache[k_c6_join_arp_bytes];
static NX_DHCP s_dhcp;
static char s_ping_payload[k_c6_join_ping_len] = "ra8-c6-ping";
static CHAR s_pool_name[] = "c6_join_pool";
static CHAR s_ip_name[] = "c6_join_ip";
static CHAR s_dhcp_name[] = "c6_join_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_c6_join_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_c6_join_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(c6_join_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_c6_join_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;
}
 
/* Send bounded ICMP echoes to the gateway; true once one is answered. */
static bool priv_net_ping(uint32_t gateway)
{
  if (gateway == 0U) {
    return false;
  }
  for (uint32_t i = 0U; i < (uint32_t)k_c6_join_ping_tries; i++) {
    NX_PACKET* resp = NX_NULL;
    UINT       s    = nx_icmp_ping(&s_ip,
                                   (ULONG)gateway,
                                   s_ping_payload,
                                   (ULONG)k_c6_join_ping_len,
                                   &resp,
                                   (ULONG)k_c6_join_ping_wait_ms);
    if (s == NX_SUCCESS) {
      if (resp != NX_NULL) {
        (void)nx_packet_release(resp);
      }
      return true;
    }
    tx_thread_sleep((ULONG)k_c6_join_ping_gap_ms);
  }
  return false;
}
 
ra8_err_t c6_join_net_up(ra8_c6link_t* link, const ra8_c6link_mac_t* mac, c6_join_lease_t* out)
{
  if ((link == nullptr) || (mac == nullptr) || (out == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out = (c6_join_lease_t){};
 
  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 = (c6_join_lease_t){};
    return k_ra8_err_timeout;
  }
  out->ping_ok = priv_net_ping(out->gateway);
  return k_ra8_ok;
}