board_periph_eink.c

Go to the documentation of this file.

 
#include "board_periph_eink.h"
 
#include <stdint.h>
#include <stdio.h>
 
#include "board_periph.h"
#include "emu_host_io_internal.h"

typedef enum : uint16_t {
  k_eink_pre_cmd = 0x6000U, 
  k_eink_pre_wr  = 0x0000U, 
  k_eink_pre_rd  = 0x1000U, 
} eink_preamble_t;

typedef enum : uint16_t {
  k_eink_cmd_sys_run      = 0x0001U, 
  k_eink_cmd_sleep        = 0x0003U, 
  k_eink_cmd_reg_rd       = 0x0010U, 
  k_eink_cmd_reg_wr       = 0x0011U, 
  k_eink_cmd_ld_img_area  = 0x0021U, 
  k_eink_cmd_ld_img_end   = 0x0022U, 
  k_eink_cmd_dpy_area     = 0x0034U, 
  k_eink_cmd_vcom         = 0x0039U, 
  k_eink_cmd_get_dev_info = 0x0302U, 
} eink_cmd_t;

typedef enum : uint16_t {
  k_eink_vcom_get = 0x0000U, 
  k_eink_vcom_set = 0x0001U, 
} eink_vcom_arg_t;

typedef enum : uint16_t {
  k_eink_vcom_power_on_mv = 1530U, 
} eink_vcom_default_t;

typedef enum : uint16_t {
  k_eink_reg_lutafsr = 0x1224U, 
} eink_reg_t;

typedef enum : uint16_t {
  k_eink_panel_w = 128U, 
  k_eink_panel_h = 128U, 
} eink_geom_t;

typedef enum : uint16_t {
  k_eink_idx_reg_addr    = 0U, 
  k_eink_idx_ld_arg0     = 0U, 
  k_eink_idx_ld_w        = 3U, 
  k_eink_idx_ld_h        = 4U, 
  k_eink_idx_ld_px_start = 5U, 
  k_eink_idx_dpy_wf      = 4U, 
  k_eink_idx_vcom_dir    = 0U, 
  k_eink_idx_vcom_val    = 1U, 
} eink_datawr_idx_t;

typedef enum : uint16_t {
  k_eink_wire_pf_2bpp = 0U, 
  k_eink_wire_pf_3bpp = 1U, 
  k_eink_wire_pf_4bpp = 2U, 
  k_eink_wire_pf_8bpp = 3U, 
} eink_wire_pf_t;

typedef enum : uint8_t {
  k_eink_rd_dummy_hi = 0U, 
  k_eink_rd_dummy_lo = 1U, 
  k_eink_rd_val_hi   = 2U, 
  k_eink_rd_val_lo   = 3U, 
} eink_read_idx_t;

typedef enum : uint32_t {
  k_eink_byte_shift = 8U,    
  k_eink_byte_mask  = 0xFFU, 
  k_eink_read_bytes = 4U,    
  k_eink_dev_words  = 20U,   
  k_eink_word_bits  = 16U,   
  k_eink_pf_shift   = 4U,    
  k_eink_pf_mask    = 0x3U,  
  k_eink_idle_byte  = 0x00U, 
} eink_sizing_t;

typedef enum : uint8_t {
  k_eink_hrdy_port = 4U, 
  k_eink_hrdy_pin  = 1U, 
} eink_hrdy_pin_t;

typedef enum : uint8_t {
  k_eink_st_preamble = 0U, 
  k_eink_st_cmd      = 1U, 
  k_eink_st_datawr   = 2U, 
} eink_state_t;

typedef struct {
  bool         attached;                  
  eink_state_t st;                        
  bool         have_hi;                   
  uint8_t      hi;                        
  uint16_t     cur_cmd;                   
  uint16_t     datawr_idx;                
  uint16_t     reg_addr;                  
  uint16_t     dev_idx;                   
  uint16_t     vcom_mv;                   
  uint16_t     vcom_dir;                  
  uint16_t     px_per_word;               
  bool         reading;                   
  uint8_t      rd_pos;                    
  uint8_t      rd_len;                    
  uint8_t      rd_buf[k_eink_read_bytes]; 
  uint64_t     pixels;                    
  uint32_t     refreshes;                 
  uint16_t     last_wf;                   
} eink_model_t;

static eink_model_t s_eink;

RA8_INTERNAL static uint16_t internal_eink_reg_value(uint16_t reg)
{
  if (reg == (uint16_t)k_eink_reg_lutafsr) {
    return 0U; /* LUT idle -> ra8_epaper_display_area poll exits. */
  }
  return 0U;
}

RA8_INTERNAL static uint16_t internal_eink_dev_info_word(uint16_t idx)
{
  if (idx == 0U) {
    return (uint16_t)k_eink_panel_w;
  }
  if (idx == 1U) {
    return (uint16_t)k_eink_panel_h;
  }
  return 0U;
}

RA8_INTERNAL static uint16_t internal_eink_px_per_word(uint16_t wire_pf)
{
  if (wire_pf == (uint16_t)k_eink_wire_pf_2bpp) {
    return (uint16_t)((uint16_t)k_eink_word_bits / 2U);
  }
  if (wire_pf == (uint16_t)k_eink_wire_pf_3bpp) {
    return (uint16_t)((uint16_t)k_eink_word_bits / 3U);
  }
  if (wire_pf == (uint16_t)k_eink_wire_pf_4bpp) {
    return (uint16_t)((uint16_t)k_eink_word_bits / 4U);
  }
  return (uint16_t)((uint16_t)k_eink_word_bits / 8U); /* k_eink_wire_pf_8bpp */
}

RA8_INTERNAL static void internal_eink_begin_read(void)
{
  uint16_t value = 0U;
  if (s_eink.cur_cmd == (uint16_t)k_eink_cmd_reg_rd) {
    value = internal_eink_reg_value(s_eink.reg_addr);
  } else if (s_eink.cur_cmd == (uint16_t)k_eink_cmd_vcom) {
    /* Only a "get" reads back; the driver never reads after a set. */
    value = s_eink.vcom_mv;
  } else if (s_eink.cur_cmd == (uint16_t)k_eink_cmd_get_dev_info) {
    value          = internal_eink_dev_info_word(s_eink.dev_idx);
    s_eink.dev_idx = (uint16_t)(s_eink.dev_idx + 1U);
  }
  s_eink.rd_buf[k_eink_rd_dummy_hi] = (uint8_t)k_eink_idle_byte;
  s_eink.rd_buf[k_eink_rd_dummy_lo] = (uint8_t)k_eink_idle_byte;
  s_eink.rd_buf[k_eink_rd_val_hi] =
    (uint8_t)((value >> (uint16_t)k_eink_byte_shift) & (uint16_t)k_eink_byte_mask);
  s_eink.rd_buf[k_eink_rd_val_lo] = (uint8_t)(value & (uint16_t)k_eink_byte_mask);
  s_eink.rd_len                   = (uint8_t)k_eink_read_bytes;
  s_eink.rd_pos                   = 0U;
  s_eink.reading                  = true;
}

RA8_INTERNAL static void internal_eink_consume_data(uint16_t word)
{
  if ((s_eink.cur_cmd == (uint16_t)k_eink_cmd_reg_rd) ||
      (s_eink.cur_cmd == (uint16_t)k_eink_cmd_reg_wr)) {
    if (s_eink.datawr_idx == (uint16_t)k_eink_idx_reg_addr) {
      s_eink.reg_addr = word;
    }
  } else if (s_eink.cur_cmd == (uint16_t)k_eink_cmd_vcom) {
    if (s_eink.datawr_idx == (uint16_t)k_eink_idx_vcom_dir) {
      s_eink.vcom_dir = word;
    } else if ((s_eink.datawr_idx == (uint16_t)k_eink_idx_vcom_val) &&
               (s_eink.vcom_dir == (uint16_t)k_eink_vcom_set)) {
      s_eink.vcom_mv = word;
    } else {
      /* A get takes no value word; nothing further to consume. */
    }
  } else if (s_eink.cur_cmd == (uint16_t)k_eink_cmd_ld_img_area) {
    if (s_eink.datawr_idx == (uint16_t)k_eink_idx_ld_arg0) {
      const uint16_t wire_pf =
        (uint16_t)((word >> (uint16_t)k_eink_pf_shift) & (uint16_t)k_eink_pf_mask);
      s_eink.px_per_word = internal_eink_px_per_word(wire_pf);
    } else if (s_eink.datawr_idx >= (uint16_t)k_eink_idx_ld_px_start) {
      s_eink.pixels += (uint64_t)s_eink.px_per_word;
    } else {
      /* Geometry args: no pixel accounting. */
    }
  } else if (s_eink.cur_cmd == (uint16_t)k_eink_cmd_dpy_area) {
    if (s_eink.datawr_idx == (uint16_t)k_eink_idx_dpy_wf) {
      s_eink.last_wf   = word;
      s_eink.refreshes = (uint32_t)(s_eink.refreshes + 1U);
    }
  }
}

RA8_INTERNAL static void internal_eink_consume_word(uint16_t word)
{
  if (s_eink.st == (eink_state_t)k_eink_st_cmd) {
    s_eink.cur_cmd    = word;
    s_eink.datawr_idx = 0U;
    if (word == (uint16_t)k_eink_cmd_get_dev_info) {
      s_eink.dev_idx = 0U;
    }
    s_eink.st = (eink_state_t)k_eink_st_preamble;
    return;
  }
  if (s_eink.st == (eink_state_t)k_eink_st_datawr) {
    internal_eink_consume_data(word);
    s_eink.datawr_idx = (uint16_t)(s_eink.datawr_idx + 1U);
    s_eink.st         = (eink_state_t)k_eink_st_preamble;
    return;
  }
  /* k_eink_st_preamble: classify the preamble word. */
  if (word == (uint16_t)k_eink_pre_cmd) {
    s_eink.st = (eink_state_t)k_eink_st_cmd;
  } else if (word == (uint16_t)k_eink_pre_wr) {
    s_eink.st = (eink_state_t)k_eink_st_datawr;
  } else if (word == (uint16_t)k_eink_pre_rd) {
    internal_eink_begin_read(); /* subsequent dummy bytes are answered from rd_buf */
  }
}
 
bool board_eink_attach(void)
{
  s_eink.attached = true;
  board_eink_reset();
  return true;
}
 
bool board_eink_attached(void)
{
  return s_eink.attached;
}
 
uint8_t board_eink_exchange(uint8_t tx)
{
  if (!s_eink.attached) {
    return (uint8_t)k_eink_idle_byte;
  }
  if (s_eink.reading) {
    const uint8_t r =
      (s_eink.rd_pos < s_eink.rd_len) ? s_eink.rd_buf[s_eink.rd_pos] : (uint8_t)k_eink_idle_byte;
    s_eink.rd_pos = (uint8_t)(s_eink.rd_pos + 1U);
    if (s_eink.rd_pos >= s_eink.rd_len) {
      s_eink.reading = false;
    }
    return r;
  }
  if (!s_eink.have_hi) {
    s_eink.hi      = tx;
    s_eink.have_hi = true;
    return (uint8_t)k_eink_idle_byte;
  }
  const uint16_t word =
    (uint16_t)(((uint16_t)s_eink.hi << (uint16_t)k_eink_byte_shift) | (uint16_t)tx);
  s_eink.have_hi = false;
  internal_eink_consume_word(word);
  return (uint8_t)k_eink_idle_byte;
}
 
void board_eink_reset(void)
{
  const bool     was_attached = s_eink.attached;
  const uint64_t pixels       = s_eink.pixels;
  const uint32_t refreshes    = s_eink.refreshes;
  const uint16_t vcom_mv      = s_eink.vcom_mv;
  s_eink                      = (eink_model_t){};
  s_eink.attached             = was_attached;
  s_eink.pixels               = pixels;    /* keep run totals across a mid-run reset        */
  s_eink.refreshes            = refreshes; /* (the SPI block resets framing, not the panel) */
  s_eink.st                   = (eink_state_t)k_eink_st_preamble;
  /* VCOM is controller configuration, not bus framing: a mid-run SPI reset
   * must not clear it, but a cold attach starts from the power-on value. */
  s_eink.vcom_mv     = (vcom_mv != 0U) ? vcom_mv : (uint16_t)k_eink_vcom_power_on_mv;
  s_eink.px_per_word = internal_eink_px_per_word((uint16_t)k_eink_wire_pf_8bpp);
}
 
void board_eink_apply_gpio_defaults(void)
{
  if (!s_eink.attached) {
    return;
  }
  board_periph_gpio_set_input((uint8_t)k_eink_hrdy_port, (uint8_t)k_eink_hrdy_pin, true);
}
 
void board_eink_report(void)
{
  if (!s_eink.attached) {
    return;
  }
  (void)priv_emu_io_errf("  IT8951 e-ink  : %llu pixel(s) loaded, %u refresh(es), last wf=0x%X, "
                         "vcom=%umV\n",
                         (unsigned long long)s_eink.pixels,
                         s_eink.refreshes,
                         (unsigned)s_eink.last_wf,
                         (unsigned)s_eink.vcom_mv);
}