c6_fwver_priv.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "c6_fwver.h"
#include "esp_hosted_host_fw_ver.h"
#include "esp_hosted_interface.h"
#include "esp_hosted_transport.h"
#include "esp_hosted_transport_init.h"
#include "port_esp_hosted_host_config_features.h"
#include "transport_drv.h"

typedef enum : uint8_t {
  k_c6_fwver_priv_evt_type   = 0U, 
  k_c6_fwver_priv_evt_len    = 1U, 
  k_c6_fwver_priv_evt_hdr    = 2U, 
  k_c6_fwver_priv_tlv_tag    = 0U, 
  k_c6_fwver_priv_tlv_size   = 1U, 
  k_c6_fwver_priv_tlv_value  = 2U, 
  k_c6_fwver_priv_tlv_len    = 1U, 
  k_c6_fwver_priv_tlv_stride = 3U, 
  k_c6_fwver_priv_tag_count  = 5U, 
  k_c6_fwver_priv_host_cap   = 0U, 
} c6_fwver_priv_t;

typedef enum : uint8_t {
  k_c6_fwver_priv_ver_b0    = 0U,  
  k_c6_fwver_priv_ver_b1    = 1U,  
  k_c6_fwver_priv_ver_b2    = 2U,  
  k_c6_fwver_priv_ver_b3    = 3U,  
  k_c6_fwver_priv_ver_bytes = 4U,  
  k_c6_fwver_priv_shift_1   = 8U,  
  k_c6_fwver_priv_shift_2   = 16U, 
  k_c6_fwver_priv_shift_3   = 24U, 
} c6_fwver_priv_ver_t;

static uint32_t s_c6_fwver_priv_version;

static uint16_t c6_fwver_priv_put_tlv(uint8_t* out, uint16_t at, uint8_t tag, uint8_t value)
{
  out[at + (uint16_t)k_c6_fwver_priv_tlv_tag]   = tag;
  out[at + (uint16_t)k_c6_fwver_priv_tlv_size]  = (uint8_t)k_c6_fwver_priv_tlv_len;
  out[at + (uint16_t)k_c6_fwver_priv_tlv_value] = value;
  return (uint16_t)(at + (uint16_t)k_c6_fwver_priv_tlv_stride);
}
 
ra8_err_t c6_fwver_priv_host_caps(uint8_t* out, uint16_t cap, uint16_t* out_len)
{
  if ((out == nullptr) || (out_len == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  const uint16_t tlv_bytes =
    (uint16_t)((uint16_t)k_c6_fwver_priv_tag_count * (uint16_t)k_c6_fwver_priv_tlv_stride);
  const uint16_t total = (uint16_t)(tlv_bytes + (uint16_t)k_c6_fwver_priv_evt_hdr);
  if (cap < total) {
    *out_len = 0U;
    return k_ra8_err_invalid_size;
  }
 
  out[k_c6_fwver_priv_evt_type] = (uint8_t)ESP_PRIV_EVENT_INIT;
  out[k_c6_fwver_priv_evt_len]  = (uint8_t)tlv_bytes;
 
  uint16_t at = (uint16_t)k_c6_fwver_priv_evt_hdr;
  at =
    c6_fwver_priv_put_tlv(out, at, (uint8_t)HOST_CAPABILITIES, (uint8_t)k_c6_fwver_priv_host_cap);
  at = c6_fwver_priv_put_tlv(out,
                             at,
                             (uint8_t)RCVD_ESP_FIRMWARE_CHIP_ID,
                             (uint8_t)ESP_PRIV_FIRMWARE_CHIP_ESP32C6);
  at = c6_fwver_priv_put_tlv(out, at, (uint8_t)SLV_CONFIG_TEST_RAW_TP, (uint8_t)H_TEST_RAW_TP_DIR);
  at = c6_fwver_priv_put_tlv(out,
                             at,
                             (uint8_t)SLV_CONFIG_THROTTLE_HIGH_THRESHOLD,
                             (uint8_t)H_WIFI_TX_DATA_THROTTLE_HIGH_THRESHOLD);
  at = c6_fwver_priv_put_tlv(out,
                             at,
                             (uint8_t)SLV_CONFIG_THROTTLE_LOW_THRESHOLD,
                             (uint8_t)H_WIFI_TX_DATA_THROTTLE_LOW_THRESHOLD);
 
  *out_len = at;
  return k_ra8_ok;
}

static void c6_fwver_priv_tlv(uint8_t tag, const uint8_t* value, uint8_t len)
{
  c6_fwver_puts("c6_fwver: priv tlv tag=0x");
  c6_fwver_put_hex((uint32_t)tag, (uint8_t)k_c6_fwver_hex_byte);
 
  if ((tag == (uint8_t)ESP_PRIV_FIRMWARE_VERSION) && (len == (uint8_t)k_c6_fwver_priv_ver_bytes)) {
    s_c6_fwver_priv_version =
      (uint32_t)value[k_c6_fwver_priv_ver_b0] |
      ((uint32_t)value[k_c6_fwver_priv_ver_b1] << (uint32_t)k_c6_fwver_priv_shift_1) |
      ((uint32_t)value[k_c6_fwver_priv_ver_b2] << (uint32_t)k_c6_fwver_priv_shift_2) |
      ((uint32_t)value[k_c6_fwver_priv_ver_b3] << (uint32_t)k_c6_fwver_priv_shift_3);
    c6_fwver_puts(" firmware_version=");
    c6_fwver_put_u32(ESP_HOSTED_VERSION_MAJOR(s_c6_fwver_priv_version));
    c6_fwver_puts(".");
    c6_fwver_put_u32(ESP_HOSTED_VERSION_MINOR(s_c6_fwver_priv_version));
    c6_fwver_puts(".");
    c6_fwver_put_u32(ESP_HOSTED_VERSION_PATCH(s_c6_fwver_priv_version));
  } else if (len == (uint8_t)k_c6_fwver_priv_tlv_len) {
    c6_fwver_puts(" value=0x");
    c6_fwver_put_hex((uint32_t)value[0], (uint8_t)k_c6_fwver_hex_byte);
  } else {
    c6_fwver_puts(" len=");
    c6_fwver_put_u32((uint32_t)len);
  }
  c6_fwver_puts("\r\n");
}
 
bool c6_fwver_priv_consume(uint8_t if_type, uint8_t if_num, const uint8_t* payload, uint16_t len)
{
  (void)if_num;
  if ((if_type != (uint8_t)ESP_PRIV_IF) || (payload == nullptr) ||
      (len < (uint16_t)k_c6_fwver_priv_evt_hdr)) {
    return false;
  }
 
  const uint8_t  event_type = payload[k_c6_fwver_priv_evt_type];
  const uint16_t event_len  = (uint16_t)payload[k_c6_fwver_priv_evt_len];
  c6_fwver_puts("c6_fwver: priv event type=0x");
  c6_fwver_put_hex((uint32_t)event_type, (uint8_t)k_c6_fwver_hex_byte);
  c6_fwver_puts(" tlv_bytes=");
  c6_fwver_put_u32((uint32_t)event_len);
  c6_fwver_puts("\r\n");
 
  if ((event_type != (uint8_t)ESP_PRIV_EVENT_INIT) ||
      (event_len > (uint16_t)(len - (uint16_t)k_c6_fwver_priv_evt_hdr))) {
    return false;
  }
 
  uint16_t at = (uint16_t)k_c6_fwver_priv_evt_hdr;
  for (uint16_t seen = 0U; seen < event_len; seen++) {
    if ((uint16_t)(at + (uint16_t)k_c6_fwver_priv_tlv_value) > len) {
      break;
    }
    const uint8_t  tag     = payload[at + (uint16_t)k_c6_fwver_priv_tlv_tag];
    const uint8_t  tag_len = payload[at + (uint16_t)k_c6_fwver_priv_tlv_size];
    const uint16_t next    = (uint16_t)(at + (uint16_t)k_c6_fwver_priv_tlv_value + tag_len);
    if (next > len) {
      break;
    }
    c6_fwver_priv_tlv(tag, &payload[at + (uint16_t)k_c6_fwver_priv_tlv_value], tag_len);
    at = next;
    if (at >= (uint16_t)(event_len + (uint16_t)k_c6_fwver_priv_evt_hdr)) {
      break;
    }
  }
  return false;
}
 
uint32_t c6_fwver_priv_init_version(void)
{
  return s_c6_fwver_priv_version;
}