ra8_c6link_frame.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_c6link.h"
#include "ra8_c6link_internal.h"

typedef enum : uint8_t {
  k_ra8_c6link_hdr_nibble  = 0x0FU, 
  k_ra8_c6link_hdr_seq     = 0U,    
  k_ra8_c6link_hdr_csum_at = 6U,    
  k_ra8_c6link_hdr_csum_sz = 2U,    
} ra8_c6link_hdr_t;
 
/* The public header restates these so consumers need no esp-hosted include
   path. If upstream ever changes either, the build stops here rather than
   mis-framing on the wire. */
static_assert((uint16_t)k_ra8_c6link_header_bytes == (uint16_t)sizeof(struct esp_payload_header),
              "k_ra8_c6link_header_bytes must equal sizeof(struct esp_payload_header)");
static_assert((uint16_t)k_ra8_c6link_frame_bytes == (uint16_t)ESP_TRANSPORT_SPI_MAX_BUF_SIZE,
              "k_ra8_c6link_frame_bytes must equal ESP_TRANSPORT_SPI_MAX_BUF_SIZE");
static_assert((uint16_t)k_ra8_c6link_max_payload ==
                ((uint16_t)k_ra8_c6link_frame_bytes - (uint16_t)k_ra8_c6link_header_bytes),
              "k_ra8_c6link_max_payload must be the frame size less the header");

RA8_INTERNAL static void internal_c6link_frame_clear(uint8_t* frame, uint16_t from)
{
  for (uint16_t i = from; i < (uint16_t)k_ra8_c6link_frame_bytes; i++) {
    frame[i] = 0U;
  }
}

RA8_INTERNAL static uint16_t internal_c6link_frame_sum(uint8_t* frame, uint16_t span)
{
  uint16_t sum = compute_checksum(frame, span);
  for (uint8_t i = 0U; i < (uint8_t)k_ra8_c6link_hdr_csum_sz; i++) {
    sum = (uint16_t)(sum - frame[(uint8_t)k_ra8_c6link_hdr_csum_at + i]);
  }
  return sum;
}
 
RA8_PRIV void priv_c6link_frame_filler(uint8_t* tx)
{
  if (tx == nullptr) {
    return;
  }
  struct esp_payload_header hdr = {};
  hdr.if_type                   = (uint8_t)((uint8_t)ESP_MAX_IF & (uint8_t)k_ra8_c6link_hdr_nibble);
 
  internal_c6link_frame_clear(tx, 0U);
  (void)memcpy(tx, &hdr, sizeof hdr);
}
 
RA8_PRIV void priv_c6link_frame_seal(uint8_t* tx, uint8_t if_type, uint8_t if_num, uint16_t len)
{
  if ((tx == nullptr) || (len > (uint16_t)k_ra8_c6link_max_payload)) {
    return;
  }
  const uint16_t span = (uint16_t)((uint16_t)k_ra8_c6link_header_bytes + len);
 
  struct esp_payload_header hdr = {};
  hdr.if_type                   = (uint8_t)(if_type & (uint8_t)k_ra8_c6link_hdr_nibble);
  hdr.if_num                    = (uint8_t)(if_num & (uint8_t)k_ra8_c6link_hdr_nibble);
  hdr.len                       = len;
  hdr.offset                    = (uint16_t)k_ra8_c6link_header_bytes;
  hdr.seq_num                   = (uint16_t)k_ra8_c6link_hdr_seq;
 
  internal_c6link_frame_clear(tx, span);
  (void)memcpy(tx, &hdr, sizeof hdr);
  hdr.checksum = compute_checksum(tx, span);
  (void)memcpy(tx, &hdr, sizeof hdr);
}

RA8_INTERNAL static uint8_t
internal_c6link_caps_tlv(uint8_t* out, uint8_t at, uint8_t tag, uint8_t value)
{
  out[at]      = tag;
  out[at + 1U] = (uint8_t)k_ra8_c6link_caps_value_len;
  out[at + 2U] = value;
  return (uint8_t)(at + (uint8_t)k_ra8_c6link_caps_stride);
}
 
RA8_PRIV uint8_t priv_c6link_caps(uint8_t* out, uint8_t cap)
{
  if ((out == nullptr) || (cap < (uint8_t)k_ra8_c6link_caps_bytes)) {
    return 0U;
  }
  const uint8_t tlv_bytes =
    (uint8_t)((uint8_t)k_ra8_c6link_caps_tags * (uint8_t)k_ra8_c6link_caps_stride);
 
  out[k_ra8_c6link_caps_type] = (uint8_t)ESP_PRIV_EVENT_INIT;
  out[k_ra8_c6link_caps_len]  = tlv_bytes;
 
  uint8_t at = (uint8_t)k_ra8_c6link_caps_hdr;
  at =
    internal_c6link_caps_tlv(out, at, (uint8_t)HOST_CAPABILITIES, (uint8_t)k_ra8_c6link_caps_host);
  at = internal_c6link_caps_tlv(out,
                                at,
                                (uint8_t)RCVD_ESP_FIRMWARE_CHIP_ID,
                                (uint8_t)k_ra8_c6link_caps_chip);
  at = internal_c6link_caps_tlv(out,
                                at,
                                (uint8_t)SLV_CONFIG_TEST_RAW_TP,
                                (uint8_t)k_ra8_c6link_caps_raw_tp);
  at = internal_c6link_caps_tlv(out,
                                at,
                                (uint8_t)SLV_CONFIG_THROTTLE_HIGH_THRESHOLD,
                                (uint8_t)k_ra8_c6link_caps_throttle_high);
  at = internal_c6link_caps_tlv(out,
                                at,
                                (uint8_t)SLV_CONFIG_THROTTLE_LOW_THRESHOLD,
                                (uint8_t)k_ra8_c6link_caps_throttle_low);
  return at;
}
 
RA8_PRIV ra8_c6link_frame_class_t priv_c6link_frame_classify(uint8_t*              rx,
                                                             ra8_c6link_rx_view_t* view)
{
  if ((rx == nullptr) || (view == nullptr)) {
    return k_ra8_c6link_frame_malformed;
  }
  struct esp_payload_header hdr = {};
  (void)memcpy(&hdr, rx, sizeof hdr);
 
  if (hdr.len == 0U) {
    return k_ra8_c6link_frame_idle;
  }
  if ((hdr.offset != (uint16_t)k_ra8_c6link_header_bytes) ||
      (hdr.len > (uint16_t)k_ra8_c6link_max_payload)) {
    return k_ra8_c6link_frame_malformed;
  }
  if (internal_c6link_frame_sum(rx, (uint16_t)(hdr.offset + hdr.len)) != hdr.checksum) {
    return k_ra8_c6link_frame_bad_checksum;
  }
 
  view->offset  = hdr.offset;
  view->len     = hdr.len;
  view->if_type = (uint8_t)hdr.if_type;
  view->if_num  = (uint8_t)hdr.if_num;
  return k_ra8_c6link_frame_data;
}