ra8_lpm_graphics.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_log.h"
#include "ra8_lpm.h"
#include "ra8_lpm_regs.h"
#include "ra8_register_protection.h"

static const char* s_tag = "LPM";
 
/* =============================================================================
 * Graphics power domain
 * =============================================================================
 */

RA8_INTERNAL static ra8_err_t internal_pdctrgd_wait(uint8_t mask, bool want_set, uint32_t limit)
{
  for (uint32_t i = 0U; i < limit; ++i) {
    /* HUM Ch 11.2.14 "PDCTRGD : Graphics Power Domain Control Register", p 452 */
    const bool is_set = ((*ra8_lpm_sysc_reg8(k_ra8_lpm_pdctrgd_off) & mask) != 0U);
    if (is_set == want_set) {
      return k_ra8_ok;
    }
  }
  return k_ra8_err_hw_timeout;
}

RA8_INTERNAL static void internal_graphics_enable_moco(void)
{
  RA8_PROTECTED_WRITE(k_ra8_prcr_unlock_cgc)
  {
    /* HUM Ch 9.2.18 "MOCOCR : MOCO Control Register", p 341 */
    volatile uint8_t* mococr = ra8_lpm_sysc_reg8(k_ra8_lpm_mococr_off);
    *mococr                  = (uint8_t)(*mococr & (uint8_t)~k_ra8_lpm_clock_stop_mask);
  }
}

RA8_INTERNAL static ra8_err_t internal_graphics_confirm_ready(uint32_t limit)
{
  ra8_err_t err = internal_pdctrgd_wait((uint8_t)k_ra8_lpm_pdctr_pdcsf_mask, false, limit);
  RA8_RETURN_ON_ERROR(err, s_tag, "graphics_power_on: PDCSF busy");
  err = internal_pdctrgd_wait((uint8_t)k_ra8_lpm_pdctr_pdpgsf_mask, true, limit);
  return err;
}

RA8_INTERNAL static ra8_err_t internal_graphics_confirm_powered(uint32_t limit)
{
  ra8_err_t err = internal_pdctrgd_wait((uint8_t)k_ra8_lpm_pdctr_pdcsf_mask, false, limit);
  /* GCOVR_EXCL_BR_START -- internal_pdctrgd_wait() error edge; PDCSF always clears off-target */
  RA8_RETURN_ON_ERROR(err, s_tag, "graphics_power_on: PDCSF stuck");
  /* GCOVR_EXCL_BR_STOP */
  err = internal_pdctrgd_wait((uint8_t)k_ra8_lpm_pdctr_pdpgsf_mask, false, limit);
  return err;
}

RA8_INTERNAL static void internal_graphics_clear_pdde(void)
{
  RA8_PROTECTED_WRITE(k_ra8_prcr_unlock_lpm)
  {
    /* HUM Ch 11.2.14 "PDCTRGD : Graphics Power Domain Control Register", p 452 */
    *ra8_lpm_sysc_reg8(k_ra8_lpm_pdctrgd_off) = 0U;
  }
}
 
[[nodiscard]] ra8_err_t ra8_lpm_graphics_power_on(uint32_t timeout_iters)
{
  if (timeout_iters == 0U) {
    ra8_log_error(s_tag, "graphics_power_on: timeout_iters == 0");
    return k_ra8_err_invalid_arg;
  }
 
  /* HUM Ch 11.2.14 "PDCTRGD : Graphics Power Domain Control Register", p 452 */
  /* Already powered (PDPGSF = 0)? Idempotent no-op for multi-driver init. */
  if ((*ra8_lpm_sysc_reg8(k_ra8_lpm_pdctrgd_off) & (uint8_t)k_ra8_lpm_pdctr_pdpgsf_mask) == 0U) {
    return k_ra8_ok;
  }
 
  internal_graphics_enable_moco();
 
  ra8_err_t err = internal_graphics_confirm_ready(timeout_iters);
  RA8_RETURN_ON_ERROR(err, s_tag, "graphics_power_on: not ready");
 
  internal_graphics_clear_pdde();
 
  err = internal_graphics_confirm_powered(timeout_iters);
  /* GCOVR_EXCL_BR_START -- internal_graphics_confirm_powered() error edge after clearing PDDE */
  RA8_RETURN_ON_ERROR(err, s_tag, "graphics_power_on: still gated");
  /* GCOVR_EXCL_BR_STOP */
 
  ra8_log_info(s_tag, "graphics power domain on");
  return k_ra8_ok;
}