dif_sensor_ctrl.c

// Copyright lowRISC contributors (OpenTitan project).
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
 
#include "sw/device/lib/dif/dif_sensor_ctrl.h"
 
#include <assert.h>
 
#include "sw/device/lib/base/bitfield.h"
#include "sw/device/lib/base/mmio.h"
#include "sw/device/lib/base/multibits.h"
#include "sw/device/lib/dif/dif_base.h"
 
#include "sensor_ctrl_regs.h"  // Generated
 
/**
 * Helper function to determine if a higher than supported event was supplied
 * as an argument.  This check is used in multiple places so use a helper
 * function.
 */
static inline bool is_ast_event_invalid(dif_sensor_ctrl_event_idx_t event_idx) {
  return event_idx > SENSOR_CTRL_PARAM_NUM_ALERT_EVENTS;
}
 
/**
 * Helper function to get CFG_REGWEN
 */
static bool is_locked(const dif_sensor_ctrl_t *sensor_ctrl) {
  return (mmio_region_read32(sensor_ctrl->base_addr,
                             SENSOR_CTRL_CFG_REGWEN_REG_OFFSET) == 0);
}
 
OT_WARN_UNUSED_RESULT
dif_result_t dif_sensor_ctrl_lock_cfg(const dif_sensor_ctrl_t *sensor_ctrl) {
  if (sensor_ctrl == NULL) {
    return kDifBadArg;
  }
 
  mmio_region_write32(sensor_ctrl->base_addr, SENSOR_CTRL_CFG_REGWEN_REG_OFFSET,
                      0);
 
  return kDifOk;
}
 
OT_WARN_UNUSED_RESULT
dif_result_t dif_sensor_ctrl_get_ast_event_trigger(
    const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_event_idx_t event_idx,
    dif_toggle_t *enable) {
  if (sensor_ctrl == NULL || is_ast_event_invalid(event_idx) ||
      enable == NULL) {
    return kDifBadArg;
  };
 
  uint32_t reg = mmio_region_read32(sensor_ctrl->base_addr,
                                    SENSOR_CTRL_ALERT_TRIG_REG_OFFSET);
  *enable = dif_bool_to_toggle(bitfield_bit32_read(reg, event_idx));
 
  return kDifOk;
}
 
OT_WARN_UNUSED_RESULT
dif_result_t dif_sensor_ctrl_set_ast_event_trigger(
    const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_event_idx_t event_idx,
    dif_toggle_t enable) {
  if (sensor_ctrl == NULL || is_ast_event_invalid(event_idx)) {
    return kDifBadArg;
  };
 
  uint32_t reg = mmio_region_read32(sensor_ctrl->base_addr,
                                    SENSOR_CTRL_ALERT_TRIG_REG_OFFSET);
  reg = bitfield_bit32_write(reg, event_idx, dif_toggle_to_bool(enable));
  mmio_region_write32(sensor_ctrl->base_addr, SENSOR_CTRL_ALERT_TRIG_REG_OFFSET,
                      reg);
 
  return kDifOk;
}
 
OT_WARN_UNUSED_RESULT
dif_result_t dif_sensor_ctrl_set_alert_en(const dif_sensor_ctrl_t *sensor_ctrl,
                                          dif_sensor_ctrl_event_idx_t event_idx,
                                          dif_toggle_t en) {
  if (sensor_ctrl == NULL || is_ast_event_invalid(event_idx)) {
    return kDifBadArg;
  };
 
  if (is_locked(sensor_ctrl)) {
    return kDifLocked;
  }
 
  mmio_region_write32(
      sensor_ctrl->base_addr,
      SENSOR_CTRL_ALERT_EN_0_REG_OFFSET + ((ptrdiff_t)event_idx << 2),
      dif_toggle_to_multi_bit_bool4(en));
 
  return kDifOk;
}
 
OT_WARN_UNUSED_RESULT
dif_result_t dif_sensor_ctrl_set_alert_fatal(
    const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_event_idx_t event_idx,
    dif_toggle_t en_fatal) {
  if (sensor_ctrl == NULL || is_ast_event_invalid(event_idx)) {
    return kDifBadArg;
  };
 
  if (is_locked(sensor_ctrl)) {
    return kDifLocked;
  }
 
  uint32_t reg = mmio_region_read32(sensor_ctrl->base_addr,
                                    SENSOR_CTRL_FATAL_ALERT_EN_REG_OFFSET);
  reg = bitfield_bit32_write(reg, event_idx, dif_toggle_to_bool(en_fatal));
  mmio_region_write32(sensor_ctrl->base_addr,
                      SENSOR_CTRL_FATAL_ALERT_EN_REG_OFFSET, reg);
 
  return kDifOk;
}
 
OT_WARN_UNUSED_RESULT
dif_result_t dif_sensor_ctrl_get_recov_events(
    const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_events_t *events) {
  if (sensor_ctrl == NULL || events == NULL) {
    return kDifBadArg;
  };
 
  *events = mmio_region_read32(sensor_ctrl->base_addr,
                               SENSOR_CTRL_RECOV_ALERT_REG_OFFSET);
 
  return kDifOk;
};
 
OT_WARN_UNUSED_RESULT
dif_result_t dif_sensor_ctrl_clear_recov_event(
    const dif_sensor_ctrl_t *sensor_ctrl,
    dif_sensor_ctrl_event_idx_t event_idx) {
  if (sensor_ctrl == NULL || is_ast_event_invalid(event_idx)) {
    return kDifBadArg;
  };
 
  uint32_t reg = bitfield_bit32_write(0, event_idx, 1);
  mmio_region_write32(sensor_ctrl->base_addr,
                      SENSOR_CTRL_RECOV_ALERT_REG_OFFSET, reg);
 
  return kDifOk;
}
 
OT_WARN_UNUSED_RESULT
dif_result_t dif_sensor_ctrl_get_fatal_events(
    const dif_sensor_ctrl_t *sensor_ctrl, dif_sensor_ctrl_events_t *events) {
  if (sensor_ctrl == NULL || events == NULL) {
    return kDifBadArg;
  };
 
  *events = mmio_region_read32(sensor_ctrl->base_addr,
                               SENSOR_CTRL_FATAL_ALERT_REG_OFFSET);
 
  return kDifOk;
};
 
OT_WARN_UNUSED_RESULT
dif_result_t dif_sensor_ctrl_get_ast_init_done_status(
    const dif_sensor_ctrl_t *sensor_ctrl, dif_toggle_t *done) {
  if (sensor_ctrl == NULL || done == NULL) {
    return kDifBadArg;
  };
 
  uint32_t reg =
      mmio_region_read32(sensor_ctrl->base_addr, SENSOR_CTRL_STATUS_REG_OFFSET);
  *done = dif_bool_to_toggle(
      bitfield_bit32_read(reg, SENSOR_CTRL_STATUS_AST_INIT_DONE_BIT));
 
  return kDifOk;
}
 
OT_WARN_UNUSED_RESULT
dif_result_t dif_sensor_ctrl_get_io_power_status(
    const dif_sensor_ctrl_t *sensor_ctrl,
    dif_sensor_ctrl_io_power_status_t *io_power_status) {
  if (sensor_ctrl == NULL || io_power_status == NULL) {
    return kDifBadArg;
  };
 
  uint32_t reg =
      mmio_region_read32(sensor_ctrl->base_addr, SENSOR_CTRL_STATUS_REG_OFFSET);
  *io_power_status =
      bitfield_field32_read(reg, SENSOR_CTRL_STATUS_IO_POK_FIELD);
 
  return kDifOk;
}