c6_fwver_rpc.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "c6_fwver.h"
#include "esp_hosted_host_fw_ver.h"
#include "esp_hosted_interface.h"
#include "esp_hosted_os_abstraction.h"
#include "esp_hosted_rpc.pb-c.h"
#include "esp_hosted_transport.h"
#include "protobuf-c/protobuf-c.h"
#include "transport_drv.h"

typedef enum : uint16_t {
  k_c6_fwver_tlv_t_epname = 0x01U, 
  k_c6_fwver_tlv_t_data   = 0x02U, 
  k_c6_fwver_tlv_type     = 0U,    
  k_c6_fwver_tlv_len_lo   = 1U,    
  k_c6_fwver_tlv_len_hi   = 2U,    
  k_c6_fwver_tlv_value    = 3U,    
  k_c6_fwver_tlv_ep_len   = (uint16_t)(sizeof(RPC_EP_NAME_RSP) - 1U),
  k_c6_fwver_tlv_overhead =
    (uint16_t)((uint16_t)k_c6_fwver_tlv_value + (uint16_t)(sizeof(RPC_EP_NAME_RSP) - 1U) +
               (uint16_t)k_c6_fwver_tlv_value),
  k_c6_fwver_tlv_shift = 8U,    
  k_c6_fwver_tlv_mask  = 0xFFU, 
} c6_fwver_tlv_t;

typedef struct c6_fwver_rsp {
  uint32_t uid;                         
  int32_t  resp;                        
  uint32_t major;                       
  uint32_t minor;                       
  uint32_t patch;                       
  uint32_t chip_id;                     
  uint8_t  target[k_c6_fwver_text_max]; 
  uint8_t  target_len;                  
  bool     seen;                        
} c6_fwver_rsp_t;

static c6_fwver_rsp_t s_c6_fwver_rsp;

static void* c6_fwver_rpc_pool_alloc(void* allocator_data, size_t size)
{
  (void)allocator_data;
  return g_h.funcs->_h_malloc(size);
}

static void c6_fwver_rpc_pool_free(void* allocator_data, void* pointer)
{
  (void)allocator_data;
  if (pointer != nullptr) {
    g_h.funcs->_h_free(pointer);
  }
}

static ProtobufCAllocator s_c6_fwver_allocator = {
  .alloc          = c6_fwver_rpc_pool_alloc,
  .free           = c6_fwver_rpc_pool_free,
  .allocator_data = nullptr,
};

static uint16_t c6_fwver_tlv_head(uint8_t* out, uint16_t at, uint8_t type, uint16_t len)
{
  out[at + (uint16_t)k_c6_fwver_tlv_type]   = type;
  out[at + (uint16_t)k_c6_fwver_tlv_len_lo] = (uint8_t)(len & (uint16_t)k_c6_fwver_tlv_mask);
  out[at + (uint16_t)k_c6_fwver_tlv_len_hi] =
    (uint8_t)((len >> (uint16_t)k_c6_fwver_tlv_shift) & (uint16_t)k_c6_fwver_tlv_mask);
  return (uint16_t)(at + (uint16_t)k_c6_fwver_tlv_value);
}
 
ra8_err_t c6_fwver_rpc_request(uint8_t* out, uint16_t cap, uint16_t* out_len)
{
  if ((out == nullptr) || (out_len == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  *out_len = 0U;
 
  RpcReqGetCoprocessorFwVersion body;
  rpc__req__get_coprocessor_fw_version__init(&body);
 
  Rpc req;
  rpc__init(&req);
  req.msg_type                      = RPC_TYPE__Req;
  req.msg_id                        = RPC_ID__Req_GetCoprocessorFwVersion;
  req.uid                           = (uint32_t)k_c6_fwver_rpc_uid;
  req.payload_case                  = RPC__PAYLOAD_REQ_GET_COPROCESSOR_FWVERSION;
  req.req_get_coprocessor_fwversion = &body;
 
  const size_t proto_len = rpc__get_packed_size(&req);
  if ((size_t)cap < (proto_len + (size_t)k_c6_fwver_tlv_overhead)) {
    return k_ra8_err_invalid_size;
  }
 
  uint16_t at =
    c6_fwver_tlv_head(out, 0U, (uint8_t)k_c6_fwver_tlv_t_epname, (uint16_t)k_c6_fwver_tlv_ep_len);
  for (uint16_t i = 0U; i < (uint16_t)k_c6_fwver_tlv_ep_len; i++) {
    out[at + i] = (uint8_t)RPC_EP_NAME_RSP[i];
  }
  at = (uint16_t)(at + (uint16_t)k_c6_fwver_tlv_ep_len);
  at = c6_fwver_tlv_head(out, at, (uint8_t)k_c6_fwver_tlv_t_data, (uint16_t)proto_len);
 
  if (rpc__pack(&req, &out[at]) != proto_len) {
    return k_ra8_err_validation_failed;
  }
  *out_len = (uint16_t)(at + (uint16_t)proto_len);
  return k_ra8_ok;
}

static const uint8_t* c6_fwver_tlv_body(const uint8_t* payload, uint16_t len, uint16_t* proto_len)
{
  *proto_len              = 0U;
  const uint16_t ep_len   = (uint16_t)k_c6_fwver_tlv_ep_len;
  const uint16_t data_tag = (uint16_t)((uint16_t)k_c6_fwver_tlv_value + ep_len);
 
  if ((len < (uint16_t)k_c6_fwver_tlv_overhead) ||
      (payload[k_c6_fwver_tlv_type] != (uint8_t)k_c6_fwver_tlv_t_epname) ||
      (payload[data_tag] != (uint8_t)k_c6_fwver_tlv_t_data)) {
    return nullptr;
  }
  const uint16_t seen_ep =
    (uint16_t)((uint16_t)payload[k_c6_fwver_tlv_len_lo] |
               ((uint16_t)payload[k_c6_fwver_tlv_len_hi] << (uint16_t)k_c6_fwver_tlv_shift));
  if (seen_ep != ep_len) {
    return nullptr;
  }
  bool named = true;
  for (uint16_t i = 0U; i < ep_len; i++) {
    const uint8_t got = payload[(uint16_t)k_c6_fwver_tlv_value + i];
    if ((got != (uint8_t)RPC_EP_NAME_RSP[i]) && (got != (uint8_t)RPC_EP_NAME_EVT[i])) {
      named = false;
    }
  }
  if (!named) {
    return nullptr;
  }
  const uint16_t body = (uint16_t)((uint16_t)payload[data_tag + (uint16_t)k_c6_fwver_tlv_len_lo] |
                                   ((uint16_t)payload[data_tag + (uint16_t)k_c6_fwver_tlv_len_hi]
                                    << (uint16_t)k_c6_fwver_tlv_shift));
  if ((body == 0U) || ((uint32_t)body + (uint32_t)k_c6_fwver_tlv_overhead > (uint32_t)len)) {
    return nullptr;
  }
  *proto_len = body;
  return &payload[k_c6_fwver_tlv_overhead];
}

static void c6_fwver_rpc_take_target(const ProtobufCBinaryData* target)
{
  s_c6_fwver_rsp.target_len = 0U;
  if ((target == nullptr) || (target->data == nullptr)) {
    return;
  }
  const size_t take =
    (target->len < (size_t)k_c6_fwver_text_max) ? target->len : (size_t)k_c6_fwver_text_max;
  for (size_t i = 0U; i < take; i++) {
    s_c6_fwver_rsp.target[i] = target->data[i];
  }
  s_c6_fwver_rsp.target_len = (uint8_t)take;
}

static bool c6_fwver_rpc_take(const Rpc* msg)
{
  if ((msg->msg_type != RPC_TYPE__Resp) || (msg->msg_id != RPC_ID__Resp_GetCoprocessorFwVersion) ||
      (msg->payload_case != RPC__PAYLOAD_RESP_GET_COPROCESSOR_FWVERSION) ||
      (msg->resp_get_coprocessor_fwversion == nullptr)) {
    return false;
  }
  const RpcRespGetCoprocessorFwVersion* body = msg->resp_get_coprocessor_fwversion;
  s_c6_fwver_rsp.uid                         = msg->uid;
  s_c6_fwver_rsp.resp                        = body->resp;
  s_c6_fwver_rsp.major                       = body->major1;
  s_c6_fwver_rsp.minor                       = body->minor1;
  s_c6_fwver_rsp.patch                       = body->patch1;
  s_c6_fwver_rsp.chip_id                     = body->chip_id;
  c6_fwver_rpc_take_target(&body->idf_target);
  s_c6_fwver_rsp.seen = true;
  return true;
}
 
bool c6_fwver_rpc_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_SERIAL_IF) || (payload == nullptr) || s_c6_fwver_rsp.seen) {
    return false;
  }
 
  uint16_t       proto_len = 0U;
  const uint8_t* proto     = c6_fwver_tlv_body(payload, len, &proto_len);
  if (proto == nullptr) {
    c6_fwver_puts("c6_fwver: serial frame is not an RPC envelope, len=");
    c6_fwver_put_u32((uint32_t)len);
    c6_fwver_puts("\r\n");
    return false;
  }
 
  Rpc* msg = rpc__unpack(&s_c6_fwver_allocator, (size_t)proto_len, proto);
  if (msg == nullptr) {
    c6_fwver_puts("c6_fwver: protobuf decode refused ");
    c6_fwver_put_u32((uint32_t)proto_len);
    c6_fwver_puts(" bytes\r\n");
    return false;
  }
 
  c6_fwver_puts("c6_fwver: rpc in type=");
  c6_fwver_put_u32((uint32_t)msg->msg_type);
  c6_fwver_puts(" id=");
  c6_fwver_put_u32((uint32_t)msg->msg_id);
  c6_fwver_puts(" uid=");
  c6_fwver_put_u32(msg->uid);
  c6_fwver_puts(" proto_bytes=");
  c6_fwver_put_u32((uint32_t)proto_len);
  c6_fwver_puts("\r\n");
 
  const bool matched = c6_fwver_rpc_take(msg);
  rpc__free_unpacked(msg, &s_c6_fwver_allocator);
  return matched;
}

static void c6_fwver_rpc_print_response(void)
{
  c6_fwver_puts("c6_fwver: rsp uid=");
  c6_fwver_put_u32(s_c6_fwver_rsp.uid);
  c6_fwver_puts(" resp=");
  c6_fwver_put_i32(s_c6_fwver_rsp.resp);
  c6_fwver_puts(" fw=");
  c6_fwver_put_u32(s_c6_fwver_rsp.major);
  c6_fwver_puts(".");
  c6_fwver_put_u32(s_c6_fwver_rsp.minor);
  c6_fwver_puts(".");
  c6_fwver_put_u32(s_c6_fwver_rsp.patch);
  c6_fwver_puts(" chip_id=0x");
  c6_fwver_put_hex(s_c6_fwver_rsp.chip_id, (uint8_t)k_c6_fwver_hex_byte);
  c6_fwver_puts(" idf_target=");
  c6_fwver_put_text(s_c6_fwver_rsp.target, (size_t)s_c6_fwver_rsp.target_len);
  c6_fwver_puts("\r\n");
}

static void c6_fwver_rpc_print_crosscheck(void)
{
  const uint32_t seen = c6_fwver_priv_init_version();
  c6_fwver_puts("c6_fwver: crosscheck priv_init_event=");
  if (seen == 0U) {
    c6_fwver_puts("absent -- either the co-processor has not been power-cycled since its "
                  "last drain, or its INIT event was dropped (read ifnum_defect on the "
                  "caps pump line)\r\n");
    return;
  }
  c6_fwver_put_u32(ESP_HOSTED_VERSION_MAJOR(seen));
  c6_fwver_puts(".");
  c6_fwver_put_u32(ESP_HOSTED_VERSION_MINOR(seen));
  c6_fwver_puts(".");
  c6_fwver_put_u32(ESP_HOSTED_VERSION_PATCH(seen));
  const bool agrees = (ESP_HOSTED_VERSION_MAJOR(seen) == s_c6_fwver_rsp.major) &&
                      (ESP_HOSTED_VERSION_MINOR(seen) == s_c6_fwver_rsp.minor) &&
                      (ESP_HOSTED_VERSION_PATCH(seen) == s_c6_fwver_rsp.patch);
  c6_fwver_puts(agrees ? " agrees with the RPC answer\r\n" : " DISAGREES with the RPC answer\r\n");
}

static void c6_fwver_rpc_print_expectation(void)
{
  c6_fwver_puts("c6_fwver: expect uid=");
  c6_fwver_put_u32((uint32_t)k_c6_fwver_rpc_uid);
  c6_fwver_puts(" resp=0 fw=");
  c6_fwver_put_u32((uint32_t)ESP_HOSTED_VERSION_MAJOR_1);
  c6_fwver_puts(".");
  c6_fwver_put_u32((uint32_t)ESP_HOSTED_VERSION_MINOR_1);
  c6_fwver_puts(".");
  c6_fwver_put_u32((uint32_t)ESP_HOSTED_VERSION_PATCH_1);
  c6_fwver_puts(" (the vendored host driver's own version) chip_id=0x");
  c6_fwver_put_hex((uint32_t)ESP_PRIV_FIRMWARE_CHIP_ESP32C6, (uint8_t)k_c6_fwver_hex_byte);
  c6_fwver_puts("\r\n");
}
 
bool c6_fwver_rpc_report(void)
{
  c6_fwver_rpc_print_expectation();
 
  if (!s_c6_fwver_rsp.seen) {
    c6_fwver_puts("c6_fwver: FAIL no RPC response -- the co-processor never answered\r\n");
    return false;
  }
  c6_fwver_rpc_print_response();
  c6_fwver_rpc_print_crosscheck();
 
  if (s_c6_fwver_rsp.uid != (uint32_t)k_c6_fwver_rpc_uid) {
    c6_fwver_puts("c6_fwver: FAIL response UID does not match the request\r\n");
    return false;
  }
  if (s_c6_fwver_rsp.resp != 0) {
    c6_fwver_puts("c6_fwver: FAIL co-processor reported an error result\r\n");
    return false;
  }
  if ((s_c6_fwver_rsp.major != (uint32_t)ESP_HOSTED_VERSION_MAJOR_1) ||
      (s_c6_fwver_rsp.minor != (uint32_t)ESP_HOSTED_VERSION_MINOR_1) ||
      (s_c6_fwver_rsp.patch != (uint32_t)ESP_HOSTED_VERSION_PATCH_1)) {
    c6_fwver_puts("c6_fwver: FAIL co-processor firmware version is not the one this host "
                  "was built against\r\n");
    return false;
  }
  if (s_c6_fwver_rsp.chip_id != (uint32_t)ESP_PRIV_FIRMWARE_CHIP_ESP32C6) {
    c6_fwver_puts("c6_fwver: FAIL the answering co-processor is not an ESP32-C6\r\n");
    return false;
  }
  c6_fwver_puts("c6_fwver: PASS esp-hosted RPC round-trip, co-processor firmware ");
  c6_fwver_put_u32(s_c6_fwver_rsp.major);
  c6_fwver_puts(".");
  c6_fwver_put_u32(s_c6_fwver_rsp.minor);
  c6_fwver_puts(".");
  c6_fwver_put_u32(s_c6_fwver_rsp.patch);
  c6_fwver_puts("\r\n");
  return true;
}
 
bool c6_fwver_dispatch(uint8_t if_type, uint8_t if_num, const uint8_t* payload, uint16_t len)
{
  c6_fwver_puts("c6_fwver: frame if_type=");
  c6_fwver_put_u32((uint32_t)if_type);
  c6_fwver_puts(" if_num=");
  c6_fwver_put_u32((uint32_t)if_num);
  c6_fwver_puts(" len=");
  c6_fwver_put_u32((uint32_t)len);
  c6_fwver_puts("\r\n");
 
  if (if_type == (uint8_t)ESP_PRIV_IF) {
    return c6_fwver_priv_consume(if_type, if_num, payload, len);
  }
  if (if_type == (uint8_t)ESP_SERIAL_IF) {
    return c6_fwver_rpc_consume(if_type, if_num, payload, len);
  }
  c6_fwver_puts("c6_fwver: frame on an interface this app does not use\r\n");
  return false;
}