board_periph_riic_devices.c

Go to the documentation of this file.

 
#include "board_periph_riic_devices_internal.h"
#include "emu_host_io_internal.h"

typedef enum : uint32_t {
  k_riic_dev_max     = 4U,    
  k_pi4ioe_addr_7b   = 0x43U, 
  k_pi4ioe_reg_max   = 0x10U, 
  k_pi4ioe_reg_devid = 0x01U, 
  k_pi4ioe_devid_val = 0xA0U, 
} riic_device_const_t;

typedef struct {
  uint8_t  reg_ptr;                
  bool     ptr_set;                
  uint8_t  file[k_pi4ioe_reg_max]; 
  uint32_t writes;                 
} pi4ioe_state_t;

typedef enum : uint16_t {
  k_ov5640_addr_7b     = 0x3CU,   
  k_ov5640_reg_id_hi   = 0x300AU, 
  k_ov5640_reg_id_lo   = 0x300BU, 
  k_ov5640_reg_format  = 0x4300U, 
  k_ov5640_reg_isp_mux = 0x501FU, 
  k_ov5640_reg_test    = 0x503DU, 
  k_ov5640_id_hi       = 0x56U,   
  k_ov5640_id_lo       = 0x40U,   
  k_ov5640_ptr_bytes   = 2U,      
} ov5640_const_t;

typedef struct {
  uint16_t reg_ptr;     
  uint8_t  ptr_bytes;   
  uint8_t  reg_format;  
  uint8_t  reg_isp_mux; 
  uint8_t  reg_test;    
  uint32_t writes;      
  uint32_t id_reads;    
} ov5640_state_t;

static riic_device_t  s_riic_dev[k_riic_dev_max];
static pi4ioe_state_t s_pi4ioe;
static ov5640_state_t s_ov5640;

RA8_INTERNAL static void internal_riic_device_register(riic_device_t device)
{
  for (uint32_t i = 0U; i < (uint32_t)k_riic_dev_max; i++) {
    if (!s_riic_dev[i].present) {
      s_riic_dev[i] = device;
      return;
    }
  }
}

RA8_INTERNAL static void internal_pi4ioe_write(void* ctx, uint8_t byte)
{
  pi4ioe_state_t* p = (pi4ioe_state_t*)ctx;
  if (!p->ptr_set) {
    p->reg_ptr = (uint8_t)(byte % (uint8_t)k_pi4ioe_reg_max);
    p->ptr_set = true;
    return;
  }
  p->file[p->reg_ptr] = byte;
  p->reg_ptr          = (uint8_t)((p->reg_ptr + 1U) % (uint8_t)k_pi4ioe_reg_max);
  p->writes++;
}

RA8_INTERNAL static uint32_t internal_pi4ioe_read(void* ctx, uint8_t* buf, uint32_t max)
{
  pi4ioe_state_t* p = (pi4ioe_state_t*)ctx;
  if (max == 0U) {
    return 0U;
  }
  const uint32_t n = (max < (uint32_t)k_pi4ioe_reg_max) ? max : (uint32_t)k_pi4ioe_reg_max;
  for (uint32_t i = 0U; i < n; i++) {
    const uint8_t reg = (uint8_t)((p->reg_ptr + i) % (uint8_t)k_pi4ioe_reg_max);
    buf[i]            = p->file[reg];
  }
  return n;
}

RA8_INTERNAL static void internal_pi4ioe_stop(void* ctx)
{
  ((pi4ioe_state_t*)ctx)->ptr_set = false;
}

RA8_INTERNAL static void internal_ov5640_write(void* ctx, uint8_t byte)
{
  ov5640_state_t* sensor = (ov5640_state_t*)ctx;
  if (sensor->ptr_bytes < (uint8_t)k_ov5640_ptr_bytes) {
    if (sensor->ptr_bytes == 0U) {
      sensor->reg_ptr = 0U;
    }
    sensor->reg_ptr = (uint16_t)(((uint16_t)(sensor->reg_ptr << 8U)) | (uint16_t)byte);
    sensor->ptr_bytes++;
    return;
  }
  if (sensor->reg_ptr == (uint16_t)k_ov5640_reg_format) {
    sensor->reg_format = byte;
  } else if (sensor->reg_ptr == (uint16_t)k_ov5640_reg_isp_mux) {
    sensor->reg_isp_mux = byte;
  } else if (sensor->reg_ptr == (uint16_t)k_ov5640_reg_test) {
    sensor->reg_test = byte;
  }
  sensor->writes++;
}

RA8_INTERNAL static uint32_t internal_ov5640_read(void* ctx, uint8_t* buf, uint32_t max)
{
  ov5640_state_t* sensor = (ov5640_state_t*)ctx;
  if (max == 0U) {
    return 0U;
  }
  uint8_t value = 0U;
  if (sensor->reg_ptr == (uint16_t)k_ov5640_reg_id_hi) {
    value = (uint8_t)k_ov5640_id_hi;
    sensor->id_reads++;
  } else if (sensor->reg_ptr == (uint16_t)k_ov5640_reg_id_lo) {
    value = (uint8_t)k_ov5640_id_lo;
    sensor->id_reads++;
  } else if (sensor->reg_ptr == (uint16_t)k_ov5640_reg_format) {
    value = sensor->reg_format;
  } else if (sensor->reg_ptr == (uint16_t)k_ov5640_reg_isp_mux) {
    value = sensor->reg_isp_mux;
  } else if (sensor->reg_ptr == (uint16_t)k_ov5640_reg_test) {
    value = sensor->reg_test;
  }
  buf[0] = value;
  return 1U;
}

RA8_INTERNAL static void internal_ov5640_stop(void* ctx)
{
  ((ov5640_state_t*)ctx)->ptr_bytes = 0U;
}
 
RA8_PRIV riic_device_t* priv_riic_device_find(uint8_t addr_7b)
{
  for (uint32_t i = 0U; i < (uint32_t)k_riic_dev_max; i++) {
    if (s_riic_dev[i].present && (s_riic_dev[i].addr_7b == addr_7b)) {
      return &s_riic_dev[i];
    }
  }
  return nullptr;
}
 
RA8_PRIV void priv_riic_devices_reset(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_riic_dev_max; i++) {
    s_riic_dev[i] = (riic_device_t){};
  }
  s_pi4ioe                          = (pi4ioe_state_t){};
  s_pi4ioe.file[k_pi4ioe_reg_devid] = (uint8_t)k_pi4ioe_devid_val;
  internal_riic_device_register((riic_device_t){.present = true,
                                                .addr_7b = (uint8_t)k_pi4ioe_addr_7b,
                                                .write   = internal_pi4ioe_write,
                                                .read    = internal_pi4ioe_read,
                                                .stop    = internal_pi4ioe_stop,
                                                .ctx     = &s_pi4ioe});
 
  s_ov5640 = (ov5640_state_t){};
  internal_riic_device_register((riic_device_t){.present = true,
                                                .addr_7b = (uint8_t)k_ov5640_addr_7b,
                                                .write   = internal_ov5640_write,
                                                .read    = internal_ov5640_read,
                                                .stop    = internal_ov5640_stop,
                                                .ctx     = &s_ov5640});
}
 
RA8_PRIV void priv_riic_devices_report(void)
{
  if (s_pi4ioe.writes > 0U) {
    (void)priv_emu_io_errf("  RIIC PI4IOE   : U15 expander 0x%02X acked %u register write(s)\n",
                           (unsigned)k_pi4ioe_addr_7b,
                           s_pi4ioe.writes);
  }
  if ((s_ov5640.id_reads > 0U) || (s_ov5640.writes > 0U)) {
    (void)priv_emu_io_errf(
      "  RIIC OV5640   : SCCB 0x%02X chip-id 0x5640 (%u id read(s), %u cfg write(s))\n",
      (unsigned)k_ov5640_addr_7b,
      s_ov5640.id_reads,
      s_ov5640.writes);
  }
}