nx_ether_driver_ra8_eth.c

Go to the documentation of this file.

 
#include "nx_ether_driver_ra8_eth.h"
 
#include <stdint.h>
#include <string.h>
 
#include "nx_api.h"
#include "nx_arp.h"
#include "nx_ip.h"
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_eth.h"
#include "tx_api.h"
 
#ifndef NX_DISABLE_IPV4
#include "nx_rarp.h"
#endif

typedef enum : uint16_t {
  k_nx_ra8_eth_max_frame      = 1514U, 
  k_nx_ra8_eth_min_frame      = 60U,   
  k_nx_ra8_eth_mac_len        = 6U,    
  k_nx_ra8_eth_phys_addr_len  = 6U,    
  k_nx_ra8_eth_mtu            = 128U,  
  k_nx_ra8_eth_phys_msw_shift = 8U,    
} nx_ra8_eth_constants_t;

typedef enum : uint8_t {
  k_nx_ra8_eth_mac_byte_0 = 0U, 
  k_nx_ra8_eth_mac_byte_1 = 1U, 
  k_nx_ra8_eth_mac_byte_2 = 2U, 
  k_nx_ra8_eth_mac_byte_3 = 3U, 
  k_nx_ra8_eth_mac_byte_4 = 4U, 
  k_nx_ra8_eth_mac_byte_5 = 5U, 
} nx_ra8_eth_mac_byte_idx_t;

typedef enum : uint8_t {
  k_nx_ra8_eth_msw_shift_byte0 = 8U,  
  k_nx_ra8_eth_lsw_shift_byte2 = 24U, 
  k_nx_ra8_eth_lsw_shift_byte3 = 16U, 
  k_nx_ra8_eth_lsw_shift_byte4 = 8U,  
  k_nx_ra8_eth_lsw_shift_byte5 = 0U,  
} nx_ra8_eth_mac_word_shift_t;

typedef enum : uint8_t {
  k_nx_ra8_eth_byte_mask = 0xFFU, 
} nx_ra8_eth_byte_mask_t;

typedef enum : uint8_t {
  k_nx_ra8_eth_hdr_src_mac_byte1 = 7U,  
  k_nx_ra8_eth_hdr_src_mac_byte3 = 9U,  
  k_nx_ra8_eth_hdr_src_mac_byte4 = 10U, 
  k_nx_ra8_eth_hdr_src_mac_byte5 = 11U, 
  k_nx_ra8_eth_hdr_ethertype_hi  = 12U, 
  k_nx_ra8_eth_hdr_ethertype_lo  = 13U, 
} nx_ra8_eth_hdr_offset_t;

static uint8_t s_tx_staging[k_nx_ra8_eth_max_frame];

static uint8_t s_rx_staging[k_nx_ra8_eth_max_frame];

static UCHAR s_ra8_eth_open;

static UCHAR s_link_up;

static uint8_t s_local_mac[k_nx_ra8_eth_mac_len];

static uint8_t s_local_mac_user_set;
 
/* nx_ether_driver_ra8_eth_set_mac -- see header for full description. */
void nx_ether_driver_ra8_eth_set_mac(const uint8_t mac[6])
{
  if (mac == nullptr) {
    return;
  }
  for (uint8_t i = 0U; i < (uint8_t)k_nx_ra8_eth_mac_len; ++i) {
    s_local_mac[i] = mac[i];
  }
  s_local_mac_user_set = 1U;
}

typedef struct {
  uint32_t dispatch_total;        
  uint32_t init_total;            
  uint32_t enable_total;          
  uint32_t send_total;            
  uint32_t rx_total;              
  uint32_t status_total;          
  uint32_t last_cmd;              
  uint32_t init_last_status;      
  uint32_t send_last_status;      
  uint32_t enable_last_link_up;   
  uint32_t init_ra8_eth_open_err; 
  uint32_t init_iface_null_hits;  
} nx_ether_diag_t;

volatile nx_ether_diag_t g_nx_ether_diag = {};

typedef enum : uint32_t {
  k_nx_ra8_eth_worker_stack_bytes  = 4096U, 
  k_nx_ra8_eth_worker_priority     = 4U,    
  k_nx_ra8_eth_worker_period_ticks = 1U,    
} nx_ra8_eth_worker_t;
 
static TX_THREAD s_rx_thread;
alignas(8) static uint8_t s_rx_thread_stack[k_nx_ra8_eth_worker_stack_bytes];
static NX_IP*        s_rx_ip          = NX_NULL;
static NX_INTERFACE* s_rx_iface       = NX_NULL;
static uint8_t       s_rx_thread_made = 0U;

RA8_INTERNAL static void internal_rx_worker_entry(ULONG arg);

RA8_INTERNAL static void internal_spawn_rx_worker(NX_IP* ip, NX_INTERFACE* iface)
{
  static CHAR s_thread_name[] = {'r', 'a', '8', '_', 'e', 't', 'h', '_', 'r', 'x', '\0'};
  if (s_rx_thread_made != 0U) {
    return;
  }
  s_rx_ip    = ip;
  s_rx_iface = iface;
  UINT t     = tx_thread_create(&s_rx_thread,
                                s_thread_name,
                                internal_rx_worker_entry,
                                0,
                                (VOID*)s_rx_thread_stack,
                                (ULONG)k_nx_ra8_eth_worker_stack_bytes,
                                (UINT)k_nx_ra8_eth_worker_priority,
                                (UINT)k_nx_ra8_eth_worker_priority,
                                (ULONG)TX_NO_TIME_SLICE,
                                (UINT)TX_AUTO_START);
  if (t == TX_SUCCESS) {
    s_rx_thread_made = 1U;
  }
}

typedef enum : uint16_t {
  k_nx_ra8_eth_ethertype_ipv4 = 0x0800U, 
  k_nx_ra8_eth_ethertype_arp  = 0x0806U, 
  k_nx_ra8_eth_ethertype_rarp = 0x8035U, 
  k_nx_ra8_eth_ethertype_ipv6 = 0x86DDU, 
} nx_ra8_eth_ethertype_t;
 
typedef enum : uint16_t {
  k_nx_ra8_eth_hdr_bytes = 14U, 
  k_nx_ra8_eth_etype_off = 12U, 
} nx_ra8_eth_hdr_t;

RA8_INTERNAL static void internal_dispatch_to_netx(NX_PACKET* pkt)
{
  if (pkt->nx_packet_length < (ULONG)k_nx_ra8_eth_hdr_bytes) {
    (void)nx_packet_release(pkt);
    return;
  }
  const UCHAR*   p           = (const UCHAR*)pkt->nx_packet_prepend_ptr;
  const uint16_t et          = (uint16_t)(((uint16_t)p[k_nx_ra8_eth_etype_off] << 8) |
                                          (uint16_t)p[(uint16_t)k_nx_ra8_eth_etype_off + 1U]);
  pkt->nx_packet_prepend_ptr = pkt->nx_packet_prepend_ptr + (ULONG)k_nx_ra8_eth_hdr_bytes;
  pkt->nx_packet_length      = pkt->nx_packet_length - (ULONG)k_nx_ra8_eth_hdr_bytes;
  if (et == (uint16_t)k_nx_ra8_eth_ethertype_ipv4) {
    _nx_ip_packet_deferred_receive(s_rx_ip, pkt);
    return;
  }
#ifndef NX_DISABLE_IPV4
  if (et == (uint16_t)k_nx_ra8_eth_ethertype_arp) {
    _nx_arp_packet_deferred_receive(s_rx_ip, pkt);
    return;
  }
  if (et == (uint16_t)k_nx_ra8_eth_ethertype_rarp) {
    _nx_rarp_packet_deferred_receive(s_rx_ip, pkt);
    return;
  }
#endif
  (void)nx_packet_release(pkt);
}

RA8_INTERNAL static void internal_rx_drain(void)
{
  NX_PACKET_POOL* pool = s_rx_ip->nx_ip_default_packet_pool;
  if (pool == NX_NULL) {
    return;
  }
  while (1) {
    uint32_t  got = 0U;
    ra8_err_t err = ra8_eth_read(s_rx_staging, (uint32_t)sizeof(s_rx_staging), &got);
    if (err != k_ra8_ok) {
      break;
    }
    if (got == 0U) {
      break;
    }
    NX_PACKET* pkt = NX_NULL;
    UINT       a   = nx_packet_allocate(pool, &pkt, NX_RECEIVE_PACKET, NX_NO_WAIT);
    if (a != NX_SUCCESS) {
      continue;
    }
    if (pkt == NX_NULL) {
      continue;
    }
    /* Slide prepend by 2 bytes so the IP header lands 4-byte aligned
     * after the driver strips the 14-byte ethernet header. NetX's IP
     * receive path word-accesses the IP header and silently drops
     * misaligned frames on Cortex-M parts. */
    pkt->nx_packet_prepend_ptr = pkt->nx_packet_prepend_ptr + 2U;
    pkt->nx_packet_append_ptr  = pkt->nx_packet_prepend_ptr;
    UINT app = nx_packet_data_append(pkt, (VOID*)s_rx_staging, (ULONG)got, pool, (ULONG)NX_NO_WAIT);
    if (app != NX_SUCCESS) {
      (void)nx_packet_release(pkt);
      continue;
    }
    pkt->nx_packet_ip_interface = s_rx_iface;
    internal_dispatch_to_netx(pkt);
    g_nx_ether_diag.rx_total += 1U;
  }
}

RA8_INTERNAL static void internal_rx_worker_entry(ULONG arg)
{
  (void)arg;
  while (1) {
    if (s_rx_ip != NX_NULL) {
      if (s_ra8_eth_open != 0U) {
        internal_rx_drain();
      }
    }
    tx_thread_sleep((ULONG)k_nx_ra8_eth_worker_period_ticks);
  }
}
 
/* Pull the 6-byte MAC out of the NetX interface descriptor -- see implementation for details. */
RA8_INTERNAL static void internal_unpack_mac(const NX_INTERFACE* iface, uint8_t* mac)
{
  ULONG msw = iface->nx_interface_physical_address_msw;
  ULONG lsw = iface->nx_interface_physical_address_lsw;
  mac[k_nx_ra8_eth_mac_byte_0] =
    (uint8_t)((msw >> (ULONG)k_nx_ra8_eth_msw_shift_byte0) & (ULONG)k_nx_ra8_eth_byte_mask);
  mac[k_nx_ra8_eth_mac_byte_1] = (uint8_t)(msw & (ULONG)k_nx_ra8_eth_byte_mask);
  mac[k_nx_ra8_eth_mac_byte_2] =
    (uint8_t)((lsw >> (ULONG)k_nx_ra8_eth_lsw_shift_byte2) & (ULONG)k_nx_ra8_eth_byte_mask);
  mac[k_nx_ra8_eth_mac_byte_3] =
    (uint8_t)((lsw >> (ULONG)k_nx_ra8_eth_lsw_shift_byte3) & (ULONG)k_nx_ra8_eth_byte_mask);
  mac[k_nx_ra8_eth_mac_byte_4] =
    (uint8_t)((lsw >> (ULONG)k_nx_ra8_eth_lsw_shift_byte4) & (ULONG)k_nx_ra8_eth_byte_mask);
  mac[k_nx_ra8_eth_mac_byte_5] = (uint8_t)(lsw & (ULONG)k_nx_ra8_eth_byte_mask);
}
 
/* Linearise a (possibly-chained) NX_PACKET into the staging buffer -- see implementation for details. */
RA8_INTERNAL static UCHAR
internal_packet_to_buffer(const NX_PACKET* packet, uint8_t* dst, uint32_t cap, uint32_t* out_len)
{
  uint32_t         total = 0U;
  const NX_PACKET* cur   = packet;
  while (cur != NX_NULL) {
    const uint8_t* seg     = (const uint8_t*)cur->nx_packet_prepend_ptr;
    uint32_t       seg_len = (uint32_t)(cur->nx_packet_append_ptr - cur->nx_packet_prepend_ptr);
    if ((total + seg_len) > cap) {
      return 0U;
    }
    /* Copy payload bytes into the linear staging buffer. */
    (void)memcpy((void*)(dst + total), (const void*)seg, (size_t)seg_len);
    total += seg_len;
#ifndef NX_DISABLE_PACKET_CHAIN
    cur = cur->nx_packet_next;
#else
    cur = NX_NULL;
#endif
  }
  *out_len = total;
  return 1U;
}
 
/* Handle ``NX_LINK_INITIALIZE``: capture MAC + open the NIC -- see implementation for details. */
RA8_INTERNAL static void internal_handle_init(NX_IP_DRIVER* req)
{
  NX_INTERFACE* iface = req->nx_ip_driver_interface;
  if (iface == NX_NULL) {
    g_nx_ether_diag.init_iface_null_hits += 1U;
    req->nx_ip_driver_status = NX_NOT_SUCCESSFUL;
    return;
  }
  /* Prefer the app-supplied MAC from nx_ether_driver_ra8_eth_set_mac.
   * If the app did not call it, fall back to the interface struct
   * (typically zero during INITIALIZE -- nx_ip_create fires this
   * callback BEFORE the app can call
   * nx_ip_interface_physical_address_set). */
  if (s_local_mac_user_set == 0U) {
    internal_unpack_mac(iface, s_local_mac);
  }
  /* Push the MAC into the interface struct so NetX subsystems that
   * read it later (ARP, sender-MAC stamping) see the right value. */
  {
    ULONG msw =
      ((ULONG)s_local_mac[k_nx_ra8_eth_mac_byte_0] << (ULONG)k_nx_ra8_eth_msw_shift_byte0) |
      (ULONG)s_local_mac[k_nx_ra8_eth_mac_byte_1];
    ULONG lsw =
      ((ULONG)s_local_mac[k_nx_ra8_eth_mac_byte_2] << (ULONG)k_nx_ra8_eth_lsw_shift_byte2) |
      ((ULONG)s_local_mac[k_nx_ra8_eth_mac_byte_3] << (ULONG)k_nx_ra8_eth_lsw_shift_byte3) |
      ((ULONG)s_local_mac[k_nx_ra8_eth_mac_byte_4] << (ULONG)k_nx_ra8_eth_msw_shift_byte0) |
      (ULONG)s_local_mac[k_nx_ra8_eth_mac_byte_5];
    iface->nx_interface_physical_address_msw = msw;
    iface->nx_interface_physical_address_lsw = lsw;
  }
 
  /* EK-RA8D2 wires its RJ45 to ETHA1 / RMAC1 -- channel 0 is unused
   * on this board. Bench-confirmed: with channel=0 the GWCA goes
   * to OPERATION and ra8_eth_open reports k_ra8_ok but the on-silicon
   * MRGFCE/MTGFCE counters on RMAC1 stay zero because frames go to
   * the unwired ETHA0/RMAC0 port instead. Issue #1 trail. */
  ra8_eth_cfg_t cfg = {
    .mac_address        = {0U, 0U, 0U, 0U, 0U, 0U},
    .channel            = 1U,
    .num_tx_descriptors = 0U,
    .num_rx_descriptors = 0U,
    .buffer_size        = 0U,
  };
  (void)memcpy((void*)cfg.mac_address, (const void*)s_local_mac, (size_t)k_nx_ra8_eth_mac_len);
 
  ra8_err_t err                         = ra8_eth_open(&cfg);
  g_nx_ether_diag.init_ra8_eth_open_err = (uint32_t)err;
  if (err != k_ra8_ok) {
    req->nx_ip_driver_status = NX_NOT_SUCCESSFUL;
    return;
  }
  s_ra8_eth_open = 1U;
  /* Advertise NetX's framing capabilities for this interface. */
  iface->nx_interface_ip_mtu_size            = (ULONG)k_nx_ra8_eth_mtu;
  iface->nx_interface_address_mapping_needed = NX_TRUE;
 
  internal_spawn_rx_worker(req->nx_ip_driver_ptr, iface);
  req->nx_ip_driver_status = NX_SUCCESS;
}
 
/* Handle ``NX_LINK_UNINITIALIZE``: close the NIC -- see implementation for details. */
RA8_INTERNAL static void internal_handle_uninit(NX_IP_DRIVER* req)
{
  if (s_ra8_eth_open != 0U) {
    (void)ra8_eth_close();
    s_ra8_eth_open = 0U;
  }
  s_link_up                = 0U;
  req->nx_ip_driver_status = NX_SUCCESS;
}

RA8_INTERNAL static uint16_t internal_ethertype_for_cmd(UINT cmd)
{
  if (cmd == NX_LINK_ARP_SEND) {
    return (uint16_t)k_nx_ra8_eth_ethertype_arp;
  }
  if (cmd == NX_LINK_ARP_RESPONSE_SEND) {
    return (uint16_t)k_nx_ra8_eth_ethertype_arp;
  }
  if (cmd == NX_LINK_RARP_SEND) {
    return (uint16_t)k_nx_ra8_eth_ethertype_rarp;
  }
  return (uint16_t)k_nx_ra8_eth_ethertype_ipv4;
}

RA8_INTERNAL static void internal_handle_send(NX_IP_DRIVER* req)
{
  NX_PACKET* pkt = req->nx_ip_driver_packet;
  if (pkt == NX_NULL || s_ra8_eth_open == 0U || s_link_up == 0U) {
    if (pkt != NX_NULL) {
      (void)nx_packet_transmit_release(pkt);
    }
    req->nx_ip_driver_status = NX_NOT_SUCCESSFUL;
    return;
  }
 
  /* Build the 14-byte ethernet header in the staging buffer from the
   * destination MAC NetX puts in nx_ip_driver_physical_address_msw/lsw,
   * our local MAC, and the ethertype derived from the dispatch cmd.
   * NetX hands the link driver the L3 payload only -- the header is
   * the driver's responsibility (per `nx_arp_packet_send` and the
   * reference NetX driver). */
  const ULONG    msw = req->nx_ip_driver_physical_address_msw;
  const ULONG    lsw = req->nx_ip_driver_physical_address_lsw;
  const uint16_t et  = internal_ethertype_for_cmd(req->nx_ip_driver_command);
  s_tx_staging[k_nx_ra8_eth_mac_byte_0] =
    (uint8_t)((msw >> (ULONG)k_nx_ra8_eth_msw_shift_byte0) & (ULONG)k_nx_ra8_eth_byte_mask);
  s_tx_staging[k_nx_ra8_eth_mac_byte_1] = (uint8_t)(msw & (ULONG)k_nx_ra8_eth_byte_mask);
  s_tx_staging[k_nx_ra8_eth_mac_byte_2] =
    (uint8_t)((lsw >> (ULONG)k_nx_ra8_eth_lsw_shift_byte2) & (ULONG)k_nx_ra8_eth_byte_mask);
  s_tx_staging[k_nx_ra8_eth_mac_byte_3] =
    (uint8_t)((lsw >> (ULONG)k_nx_ra8_eth_lsw_shift_byte3) & (ULONG)k_nx_ra8_eth_byte_mask);
  s_tx_staging[k_nx_ra8_eth_mac_byte_4] =
    (uint8_t)((lsw >> (ULONG)k_nx_ra8_eth_lsw_shift_byte4) & (ULONG)k_nx_ra8_eth_byte_mask);
  s_tx_staging[k_nx_ra8_eth_mac_byte_5]        = (uint8_t)(lsw & (ULONG)k_nx_ra8_eth_byte_mask);
  s_tx_staging[6]                              = s_local_mac[k_nx_ra8_eth_mac_byte_0];
  s_tx_staging[k_nx_ra8_eth_hdr_src_mac_byte1] = s_local_mac[k_nx_ra8_eth_mac_byte_1];
  s_tx_staging[8]                              = s_local_mac[k_nx_ra8_eth_mac_byte_2];
  s_tx_staging[k_nx_ra8_eth_hdr_src_mac_byte3] = s_local_mac[k_nx_ra8_eth_mac_byte_3];
  s_tx_staging[k_nx_ra8_eth_hdr_src_mac_byte4] = s_local_mac[k_nx_ra8_eth_mac_byte_4];
  s_tx_staging[k_nx_ra8_eth_hdr_src_mac_byte5] = s_local_mac[k_nx_ra8_eth_mac_byte_5];
  s_tx_staging[k_nx_ra8_eth_hdr_ethertype_hi] =
    (uint8_t)((et >> (uint16_t)k_nx_ra8_eth_msw_shift_byte0) & (uint16_t)k_nx_ra8_eth_byte_mask);
  s_tx_staging[k_nx_ra8_eth_hdr_ethertype_lo] = (uint8_t)(et & (uint16_t)k_nx_ra8_eth_byte_mask);
 
  uint32_t body_len = 0U;
  if (internal_packet_to_buffer(pkt,
                                s_tx_staging + k_nx_ra8_eth_hdr_bytes,
                                (uint32_t)sizeof(s_tx_staging) - (uint32_t)k_nx_ra8_eth_hdr_bytes,
                                &body_len) == 0U) {
    (void)nx_packet_transmit_release(pkt);
    req->nx_ip_driver_status = NX_NOT_SUCCESSFUL;
    return;
  }
  uint32_t len = body_len + (uint32_t)k_nx_ra8_eth_hdr_bytes;
 
  /* Pad runt frames up to the 802.3 minimum. */
  if (len < (uint32_t)k_nx_ra8_eth_min_frame) {
    (void)memset((void*)(s_tx_staging + len), 0, (size_t)((uint32_t)k_nx_ra8_eth_min_frame - len));
    len = (uint32_t)k_nx_ra8_eth_min_frame;
  }
 
  ra8_err_t err = ra8_eth_write(s_tx_staging, len);
  (void)nx_packet_transmit_release(pkt);
  req->nx_ip_driver_status = (err == k_ra8_ok) ? (UINT)NX_SUCCESS : (UINT)NX_NOT_SUCCESSFUL;
}

RA8_INTERNAL static void internal_handle_deferred_rx(NX_IP_DRIVER* req)
{
  NX_IP* ip_ptr = req->nx_ip_driver_ptr;
  if (ip_ptr == NX_NULL || s_ra8_eth_open == 0U) {
    req->nx_ip_driver_status = NX_NOT_SUCCESSFUL;
    return;
  }
 
  /* The default packet pool lives off the IP control block; NetX
   * expects RX-side allocation to come from it. */
  NX_PACKET_POOL* pool = ip_ptr->nx_ip_default_packet_pool;
  if (pool == NX_NULL) {
    req->nx_ip_driver_status = NX_NOT_SUCCESSFUL;
    return;
  }
 
  /* Drain the descriptor ring. ra8_eth_read returns k_ra8_err_no_data
   * when the ring is empty -- that is the loop exit. */
  while (1) {
    uint32_t  got = 0U;
    ra8_err_t err = ra8_eth_read(s_rx_staging, (uint32_t)sizeof(s_rx_staging), &got);
    if (err != k_ra8_ok || got == 0U) {
      break;
    }
    NX_PACKET* pkt = NX_NULL;
    UINT       a   = nx_packet_allocate(pool, &pkt, NX_RECEIVE_PACKET, NX_NO_WAIT);
    if (a != NX_SUCCESS || pkt == NX_NULL) {
      /* Packet pool exhausted; drop the frame and keep draining. */
      continue;
    }
    /* Append the bytes (this also bumps nx_packet_length). */
    UINT app = nx_packet_data_append(pkt, (VOID*)s_rx_staging, (ULONG)got, pool, (ULONG)NX_NO_WAIT);
    if (app != NX_SUCCESS) {
      (void)nx_packet_release(pkt);
      continue;
    }
    pkt->nx_packet_ip_interface = req->nx_ip_driver_interface;
    internal_dispatch_to_netx(pkt);
  }
  req->nx_ip_driver_status = NX_SUCCESS;
}
 
/* Handle ``NX_LINK_GET_STATUS``: report the PHY link bit -- see implementation for details. */
RA8_INTERNAL static void internal_handle_get_status(NX_IP_DRIVER* req)
{
  if (req->nx_ip_driver_return_ptr == NX_NULL) {
    req->nx_ip_driver_status = NX_NOT_SUCCESSFUL;
    return;
  }
  ra8_eth_link_t link = {.link_up = 0U, .speed_mbps = 0U, .full_duplex = 0U, .bmsr = 0U};
  if (s_ra8_eth_open == 0U) {
    *(req->nx_ip_driver_return_ptr) = (ULONG)NX_FALSE;
    req->nx_ip_driver_status        = NX_SUCCESS;
    return;
  }
  ra8_err_t err = ra8_eth_link_status(&link);
  if (err != k_ra8_ok) {
    *(req->nx_ip_driver_return_ptr) = (ULONG)NX_FALSE;
    req->nx_ip_driver_status        = NX_NOT_SUCCESSFUL;
    return;
  }
  *(req->nx_ip_driver_return_ptr) = (link.link_up != 0U) ? (ULONG)NX_TRUE : (ULONG)NX_FALSE;
  req->nx_ip_driver_status        = NX_SUCCESS;
}

RA8_INTERNAL static void internal_set_link_state(NX_IP_DRIVER* driver_req, UCHAR link_up)
{
  s_link_up                       = link_up;
  driver_req->nx_ip_driver_status = NX_SUCCESS;
  if (driver_req->nx_ip_driver_interface != NX_NULL) {
    driver_req->nx_ip_driver_interface->nx_interface_link_up = (link_up != 0U) ? NX_TRUE : NX_FALSE;
  }
}
 
/* Nx ether driver ra eth -- see implementation for details. */
void nx_ether_driver_ra8_eth(NX_IP_DRIVER* driver_req)
{
  /* NetX never invokes the driver with NULL but mirror the upstream
   * nx_link reference driver and guard anyway. */
  if (driver_req == NX_NULL) {
    return;
  }
 
  g_nx_ether_diag.dispatch_total += 1U;
  g_nx_ether_diag.last_cmd = (uint32_t)driver_req->nx_ip_driver_command;
 
  switch (driver_req->nx_ip_driver_command) {
    case NX_LINK_INITIALIZE:
      g_nx_ether_diag.init_total += 1U;
      internal_handle_init(driver_req);
      g_nx_ether_diag.init_last_status = (uint32_t)driver_req->nx_ip_driver_status;
      break;
    case NX_LINK_ENABLE:
      g_nx_ether_diag.enable_total += 1U;
      g_nx_ether_diag.enable_last_link_up = 1U;
      internal_set_link_state(driver_req, 1U);
      break;
    case NX_LINK_DISABLE:
      g_nx_ether_diag.enable_last_link_up = 0U;
      internal_set_link_state(driver_req, 0U);
      break;
    case NX_LINK_PACKET_SEND:
    case NX_LINK_PACKET_BROADCAST:
    case NX_LINK_ARP_SEND:
    case NX_LINK_ARP_RESPONSE_SEND:
    case NX_LINK_RARP_SEND:
      g_nx_ether_diag.send_total += 1U;
      internal_handle_send(driver_req);
      g_nx_ether_diag.send_last_status = (uint32_t)driver_req->nx_ip_driver_status;
      break;
    case NX_LINK_DEFERRED_PROCESSING:
      g_nx_ether_diag.rx_total += 1U;
      internal_handle_deferred_rx(driver_req);
      break;
    case NX_LINK_GET_STATUS:
      g_nx_ether_diag.status_total += 1U;
      internal_handle_get_status(driver_req);
      break;
    case NX_LINK_UNINITIALIZE:
      internal_handle_uninit(driver_req);
      break;
    case NX_LINK_MULTICAST_JOIN:
    case NX_LINK_MULTICAST_LEAVE:
    case NX_LINK_INTERFACE_ATTACH:
    case NX_LINK_INTERFACE_DETACH:
    case NX_LINK_SET_PHYSICAL_ADDRESS:
      driver_req->nx_ip_driver_status = NX_SUCCESS;
      break;
    default:
      driver_req->nx_ip_driver_status = NX_NOT_SUCCESSFUL;
      break;
  }
}