mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-20 09:03:28 +00:00
commit
3e3879ba4d
10 changed files with 704 additions and 11 deletions
|
|
@ -89,6 +89,28 @@ impl<'a> ShellCmdApi<'a> for Test {
|
||||||
// run forever, code blocks here
|
// run forever, code blocks here
|
||||||
wheel.run(None);
|
wheel.run(None);
|
||||||
}
|
}
|
||||||
|
"temp" => {
|
||||||
|
let adc = bao1x_hal_service::Adc::new();
|
||||||
|
let raw_temp = adc.read_raw(bao1x_hal::udma::AdcSource::Temperature, Some(8));
|
||||||
|
log::info!(
|
||||||
|
"raw: {}, temp: {}",
|
||||||
|
raw_temp,
|
||||||
|
bao1x_hal::udma::Adc::raw_to_temp_celsius(raw_temp)
|
||||||
|
);
|
||||||
|
}
|
||||||
|
"adc" => {
|
||||||
|
let adc = bao1x_hal_service::Adc::new();
|
||||||
|
// safety - we have manually checked there are no conflicts with this mapping
|
||||||
|
unsafe { adc.enable_channel(bao1x_hal::udma::AdcExtChannel::Adc0) };
|
||||||
|
loop {
|
||||||
|
let raw = adc.read_raw(
|
||||||
|
bao1x_hal::udma::AdcSource::Ext(bao1x_hal::udma::AdcExtChannel::Adc0),
|
||||||
|
Some(8),
|
||||||
|
);
|
||||||
|
log::info!("raw: {} volts: {:.3}V", raw, bao1x_hal::udma::Adc::raw_to_voltage(raw));
|
||||||
|
std::thread::sleep(std::time::Duration::from_millis(500));
|
||||||
|
}
|
||||||
|
}
|
||||||
"env" => {
|
"env" => {
|
||||||
log::info!("{:?}", std::env::vars());
|
log::info!("{:?}", std::env::vars());
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -40,6 +40,8 @@ pub enum HalOpcode {
|
||||||
ConfigureUdmaEvent = 8,
|
ConfigureUdmaEvent = 8,
|
||||||
// blocking scalar
|
// blocking scalar
|
||||||
UdmaIrqStatusBits = 16,
|
UdmaIrqStatusBits = 16,
|
||||||
|
// blocking scalar
|
||||||
|
UpdatePerclk = 18,
|
||||||
|
|
||||||
/// I2C operations
|
/// I2C operations
|
||||||
I2c = 9,
|
I2c = 9,
|
||||||
|
|
@ -53,14 +55,16 @@ pub enum HalOpcode {
|
||||||
|
|
||||||
/// Manipulate the OS timer
|
/// Manipulate the OS timer
|
||||||
SetPreemptionState = 64,
|
SetPreemptionState = 64,
|
||||||
|
}
|
||||||
/// Behavior opcode base
|
|
||||||
#[cfg(feature = "bio")]
|
#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive)]
|
||||||
BehaviorBase0 = 0x1000,
|
#[repr(usize)]
|
||||||
#[cfg(feature = "bio")]
|
pub enum PeripheralOpcode {
|
||||||
BehaviorBase1 = 0x2000,
|
InvalidCall = 0,
|
||||||
#[cfg(feature = "bio")]
|
UpdatePerclk = 1,
|
||||||
BehaviorBase2 = 0x3000,
|
|
||||||
#[cfg(feature = "bio")]
|
/// Adc operations
|
||||||
BehaviorBase3 = 0x4000,
|
// blocking scalar
|
||||||
|
ReadAdcChannel = 0x100,
|
||||||
|
EnableChannel = 0x101,
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -49,6 +49,10 @@ pub const SERVER_NAME_KBD: &str = "_Matrix keyboard driver_";
|
||||||
/// Do not change this constant, it is hard-coded into libraries in order to break
|
/// Do not change this constant, it is hard-coded into libraries in order to break
|
||||||
/// circular dependencies on the IFRAM block.
|
/// circular dependencies on the IFRAM block.
|
||||||
pub const SERVER_NAME_BAO1X_HAL: &str = "_bao1x-SoC HAL_";
|
pub const SERVER_NAME_BAO1X_HAL: &str = "_bao1x-SoC HAL_";
|
||||||
|
/// Server for peripherals that *also* depend on the core Bao1x HAL. These have to
|
||||||
|
/// be in a separate server to avoid lock-up issues of the server depending on itself
|
||||||
|
/// for services.
|
||||||
|
pub const SERVER_NAME_BAO1X_OTHERS: &str = "_HAL-everthing-else_";
|
||||||
|
|
||||||
/// Number of boots to trigger the 'audit' command. It's set to be bigger than 1, because
|
/// Number of boots to trigger the 'audit' command. It's set to be bigger than 1, because
|
||||||
/// the chip tester may power cycle the chip during the provisioning process before the
|
/// the chip tester may power cycle the chip during the provisioning process before the
|
||||||
|
|
|
||||||
493
libs/bao1x-hal/src/udma/adc.rs
Normal file
493
libs/bao1x-hal/src/udma/adc.rs
Normal file
|
|
@ -0,0 +1,493 @@
|
||||||
|
//! UDMA ADC block driver
|
||||||
|
//!
|
||||||
|
//! Supports internal temperature sensor and external voltage measurement on
|
||||||
|
//! PA04–PA07 via the uDMA RX channel.
|
||||||
|
//!
|
||||||
|
//! # `std` (Xous userspace)
|
||||||
|
//! ```no_run
|
||||||
|
//! let mut adc = unsafe { Adc::new(perclk_freq) };
|
||||||
|
//! let raw = adc.read_raw(AdcSource::Temperature);
|
||||||
|
//! let temp_c = Adc::raw_to_temp_celsius(raw as f64);
|
||||||
|
//!
|
||||||
|
//! let raw = adc.read_raw(AdcSource::Ext(AdcExtChannel::Pa04));
|
||||||
|
//! let volts = Adc::raw_to_voltage(raw);
|
||||||
|
//! ```
|
||||||
|
//!
|
||||||
|
//! # `no_std` (loader / bare-metal)
|
||||||
|
//! ```no_run
|
||||||
|
//! let mut adc = unsafe { Adc::new_baremetal(perclk_freq, dma_buf_phys) }; // no_std
|
||||||
|
//! ```
|
||||||
|
|
||||||
|
use utralib::utra::udma_adc;
|
||||||
|
use utralib::*;
|
||||||
|
|
||||||
|
use crate::ifram::IframRange;
|
||||||
|
use crate::udma::*;
|
||||||
|
|
||||||
|
// ============================================================================
|
||||||
|
// Fine-grained field definitions for REG_CR_ADC
|
||||||
|
//
|
||||||
|
// The auto-generated UTRA only exposes one monolithic 28-bit field
|
||||||
|
// (REG_CR_ADC_CR_ADC). We break it out here to match the datasheet's
|
||||||
|
// per-bit definitions for ADC_CR_CFG (byte offset 0x10, word offset 4).
|
||||||
|
// ============================================================================
|
||||||
|
pub mod cr_adc {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
/// Bit[0]: Bandgap chopper enable (0 = disable, 1 = enable)
|
||||||
|
pub const CHOPPER_EN: Field = Field::new(1, 0, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bit[1]: Temperature-related voltage buffer (0 = disable, 1 = enable)
|
||||||
|
pub const TEMP_BUF_EN: Field = Field::new(1, 1, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bit[2]: Bandgap voltage buffer / reference select
|
||||||
|
/// 0 = disable buffer, use AVDD as reference
|
||||||
|
/// 1 = enable buffer, use bandgap voltage as reference
|
||||||
|
pub const BANDGAP_BUF_EN: Field = Field::new(1, 2, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bit[3]: External voltage buffer (0 = disable, 1 = enable)
|
||||||
|
pub const EXT_BUF_EN: Field = Field::new(1, 3, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bit[4]: Temperature-related voltage control (0 = voltage 1, 1 = voltage 2)
|
||||||
|
pub const TEMP_V_CTRL: Field = Field::new(1, 4, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bit[5]: Temperature voltage filter bypass (0 = filter, 1 = bypass)
|
||||||
|
pub const TEMP_FILTER_BYPASS: Field = Field::new(1, 5, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bit[6]: Bandgap voltage filter bypass (0 = filter, 1 = bypass)
|
||||||
|
pub const BANDGAP_FILTER_BYPASS: Field = Field::new(1, 6, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bits[12:8]: ADC clock cycles per conversion (must be ≥ 14)
|
||||||
|
pub const DATA_COUNT: Field = Field::new(5, 8, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bit[13]: Bandgap / temperature sensor enable
|
||||||
|
pub const SENSOR_EN: Field = Field::new(1, 13, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bit[14]: ADC enable
|
||||||
|
pub const ADC_EN: Field = Field::new(1, 14, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bit[15]: ADC reset (write 1 to reset)
|
||||||
|
pub const ADC_RST: Field = Field::new(1, 15, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bits[23:16]: Clock frequency divider.
|
||||||
|
/// adc_clk = perclk / (2 × FD). The resulting adc_clk must be 0.2–1.6 MHz.
|
||||||
|
pub const CLK_FD: Field = Field::new(8, 16, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bits[25:24]: ADC input mux
|
||||||
|
/// 00 = temperature-related voltage (internal)
|
||||||
|
/// 01 = external voltage
|
||||||
|
pub const ADC_SEL: Field = Field::new(2, 24, udma_adc::REG_CR_ADC);
|
||||||
|
/// Bits[27:26]: External analog input select
|
||||||
|
/// 00 = PA04 (ADC0), 01 = PA05 (ADC1),
|
||||||
|
/// 10 = PA06 (ADC2), 11 = PA07 (ADC3)
|
||||||
|
pub const VIN_SEL: Field = Field::new(2, 26, udma_adc::REG_CR_ADC);
|
||||||
|
}
|
||||||
|
|
||||||
|
// ============================================================================
|
||||||
|
// Public types
|
||||||
|
// ============================================================================
|
||||||
|
|
||||||
|
/// External analog input channel (PA04–PA07).
|
||||||
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||||
|
#[repr(usize)]
|
||||||
|
pub enum AdcExtChannel {
|
||||||
|
/// PA04 / ADC0
|
||||||
|
Adc0 = 0,
|
||||||
|
/// PA05 / ADC1
|
||||||
|
Adc1 = 1,
|
||||||
|
/// PA06 / ADC2
|
||||||
|
Adc2 = 2,
|
||||||
|
/// PA07 / ADC3
|
||||||
|
Adc3 = 3,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<AdcExtChannel> for usize {
|
||||||
|
fn from(ch: AdcExtChannel) -> usize { ch as usize }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<usize> for AdcExtChannel {
|
||||||
|
fn from(val: usize) -> AdcExtChannel {
|
||||||
|
match val {
|
||||||
|
0 => AdcExtChannel::Adc0,
|
||||||
|
1 => AdcExtChannel::Adc1,
|
||||||
|
2 => AdcExtChannel::Adc2,
|
||||||
|
3 => AdcExtChannel::Adc3,
|
||||||
|
_ => unimplemented!("AdcExtChannel value out of range: {}", val),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// ADC measurement source.
|
||||||
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||||
|
pub enum AdcSource {
|
||||||
|
/// Internal temperature sensor
|
||||||
|
Temperature,
|
||||||
|
/// External voltage on the specified channel
|
||||||
|
Ext(AdcExtChannel),
|
||||||
|
}
|
||||||
|
|
||||||
|
impl AdcSource {
|
||||||
|
pub fn to_usize(self) -> usize {
|
||||||
|
match self {
|
||||||
|
AdcSource::Temperature => 0,
|
||||||
|
AdcSource::Ext(ch) => 1 + ch as usize, // 1..=4
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn from_usize(val: usize) -> AdcSource {
|
||||||
|
match val {
|
||||||
|
0 => AdcSource::Temperature,
|
||||||
|
1 => AdcSource::Ext(AdcExtChannel::Adc0),
|
||||||
|
2 => AdcSource::Ext(AdcExtChannel::Adc1),
|
||||||
|
3 => AdcSource::Ext(AdcExtChannel::Adc2),
|
||||||
|
4 => AdcSource::Ext(AdcExtChannel::Adc3),
|
||||||
|
_ => unimplemented!("AdcSource::from_usize: invalid value {}", val),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Target ADC conversion clock in kHz. The divider is computed from `perclk`
|
||||||
|
/// so that adc_clk lands as close to this as possible within the valid
|
||||||
|
/// 200–1600 kHz range.
|
||||||
|
const ADC_TARGET_CLK_KHZ: u32 = 1_000;
|
||||||
|
|
||||||
|
/// Minimum clock cycles per conversion (from the datasheet).
|
||||||
|
const ADC_MIN_DATA_COUNT: u32 = 14;
|
||||||
|
|
||||||
|
/// The ADC is RX-only; the entire IFRAM page is the receive buffer.
|
||||||
|
pub const ADC_RX_BUF_SIZE: usize = 4096;
|
||||||
|
|
||||||
|
// ============================================================================
|
||||||
|
// Driver
|
||||||
|
// ============================================================================
|
||||||
|
|
||||||
|
/// UDMA ADC block driver.
|
||||||
|
pub struct Adc {
|
||||||
|
csr: CSR<u32>,
|
||||||
|
/// IFRAM allocation backing the uDMA RX buffer.
|
||||||
|
#[allow(dead_code)]
|
||||||
|
ifram: IframRange,
|
||||||
|
/// Current peripheral clock frequency in Hz, used to compute the ADC
|
||||||
|
/// clock divider. Updated via [`update_perclk`].
|
||||||
|
perclk_freq: u32,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Blanket [`Udma`] trait implementation so the generic uDMA helpers
|
||||||
|
/// (`udma_busy`, `udma_enqueue`, etc.) work on `Adc`.
|
||||||
|
impl Udma for Adc {
|
||||||
|
fn csr_mut(&mut self) -> &mut CSR<u32> { &mut self.csr }
|
||||||
|
|
||||||
|
fn csr(&self) -> &CSR<u32> { &self.csr }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Adc {
|
||||||
|
// --- Construction --------------------------------------------------------
|
||||||
|
|
||||||
|
/// Create a new ADC driver, mapping the hardware registers and allocating
|
||||||
|
/// an IFRAM DMA buffer.
|
||||||
|
///
|
||||||
|
/// `perclk_freq` is the UDMA peripheral clock frequency in Hz (derived
|
||||||
|
/// from the system clock and the `fdper` fractional divider).
|
||||||
|
///
|
||||||
|
/// # Safety
|
||||||
|
///
|
||||||
|
/// Caller must ensure the global UDMA state has been initialized (clocks
|
||||||
|
/// un-gated, events configured) before calling this, and must manually
|
||||||
|
/// gate the ADC clock again when the driver is no longer needed.
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
pub unsafe fn new(perclk_freq: u32) -> Self {
|
||||||
|
let adc_mem = xous::syscall::map_memory(
|
||||||
|
xous::MemoryAddress::new(udma_adc::HW_UDMA_ADC_BASE),
|
||||||
|
None,
|
||||||
|
4096,
|
||||||
|
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||||
|
)
|
||||||
|
.expect("couldn't map ADC registers");
|
||||||
|
|
||||||
|
let csr = CSR::new(adc_mem.as_mut_ptr() as *mut u32);
|
||||||
|
let ifram = IframRange::request(ADC_RX_BUF_SIZE, None).expect("couldn't allocate IFRAM for ADC");
|
||||||
|
|
||||||
|
let mut adc = Adc { csr, ifram, perclk_freq };
|
||||||
|
adc.init();
|
||||||
|
adc
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Create a bare-metal ADC driver (no MMU, physical addresses used
|
||||||
|
/// directly).
|
||||||
|
///
|
||||||
|
/// # Safety
|
||||||
|
///
|
||||||
|
/// Same preconditions as [`new`], plus the caller is responsible for
|
||||||
|
/// ensuring `udma_buf_phys` points to a valid, word-aligned DMA buffer
|
||||||
|
/// region of at least [`ADC_RX_BUF_SIZE`] bytes that is accessible to the
|
||||||
|
/// uDMA engine.
|
||||||
|
#[cfg(not(feature = "std"))]
|
||||||
|
pub unsafe fn new_baremetal(perclk_freq: u32, udma_buf_phys: usize) -> Self {
|
||||||
|
let csr = CSR::new(udma_adc::HW_UDMA_ADC_BASE as *mut u32);
|
||||||
|
let ifram = IframRange::from_raw_parts(
|
||||||
|
udma_buf_phys,
|
||||||
|
udma_buf_phys, // virt == phys in bare-metal
|
||||||
|
ADC_RX_BUF_SIZE,
|
||||||
|
);
|
||||||
|
|
||||||
|
let mut adc = Adc { csr, ifram, perclk_freq };
|
||||||
|
adc.init();
|
||||||
|
adc
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Re-acquire a handle to a previously initialized ADC.
|
||||||
|
///
|
||||||
|
/// This is the equivalent of the UART's `get_handle` — use it when the
|
||||||
|
/// hardware was already configured (e.g. by the loader) and you just need
|
||||||
|
/// a driver object to operate on it.
|
||||||
|
///
|
||||||
|
/// # Safety
|
||||||
|
///
|
||||||
|
/// Only safe when the ADC hardware is already initialized and the
|
||||||
|
/// provided addresses are valid.
|
||||||
|
pub unsafe fn get_handle(
|
||||||
|
csr_virt_addr: usize,
|
||||||
|
udma_phys_addr: usize,
|
||||||
|
udma_virt_addr: usize,
|
||||||
|
perclk_freq: u32,
|
||||||
|
) -> Self {
|
||||||
|
let csr = CSR::new(csr_virt_addr as *mut u32);
|
||||||
|
let ifram = IframRange::from_raw_parts(udma_phys_addr, udma_virt_addr, ADC_RX_BUF_SIZE);
|
||||||
|
Adc { csr, ifram, perclk_freq }
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Clock management ---------------------------------------------------
|
||||||
|
|
||||||
|
/// Compute the clock frequency divider for a given peripheral clock.
|
||||||
|
///
|
||||||
|
/// `perclk_khz`: peripheral clock in kHz.
|
||||||
|
/// `target_khz`: desired ADC clock in kHz (clamped to 200–1600).
|
||||||
|
///
|
||||||
|
/// The hardware divides: adc_clk = perclk / (2 × FD).
|
||||||
|
fn calc_clk_fd(perclk_khz: u32, target_khz: u32) -> u32 {
|
||||||
|
let target_khz = target_khz.clamp(200, 1600);
|
||||||
|
let fd = perclk_khz / (2 * target_khz);
|
||||||
|
fd.clamp(1, 0xFF)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Notify the driver that the peripheral clock frequency has changed
|
||||||
|
/// (e.g. after a power-mode transition). Re-computes and writes the
|
||||||
|
/// ADC clock divider.
|
||||||
|
///
|
||||||
|
/// `perclk_freq`: new peripheral clock in **Hz**.
|
||||||
|
pub fn update_perclk(&mut self, perclk_freq: u32) {
|
||||||
|
self.perclk_freq = perclk_freq;
|
||||||
|
|
||||||
|
let fd = Self::calc_clk_fd(perclk_freq / 1_000, ADC_TARGET_CLK_KHZ);
|
||||||
|
|
||||||
|
// Read-modify-write: touch only CLK_FD[23:16]
|
||||||
|
let mut cr = self.csr.r(udma_adc::REG_CR_ADC);
|
||||||
|
cr &= !((cr_adc::CLK_FD.mask() as u32) << cr_adc::CLK_FD.offset());
|
||||||
|
cr |= fd << cr_adc::CLK_FD.offset();
|
||||||
|
self.csr.wo(udma_adc::REG_CR_ADC, cr);
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Delays -------------------------------------------------------------
|
||||||
|
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
fn delay_us(us: u64) {
|
||||||
|
if us < 1000 {
|
||||||
|
// less than 1ms is not reliable in std
|
||||||
|
std::thread::sleep(std::time::Duration::from_millis(1));
|
||||||
|
} else {
|
||||||
|
std::thread::sleep(std::time::Duration::from_micros(us));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Bare-metal delay stub.
|
||||||
|
#[cfg(not(feature = "std"))]
|
||||||
|
fn delay_us(us: u64) {
|
||||||
|
// abuse the d11ctime timer to create some time-out like thing
|
||||||
|
let mut d11c = CSR::new(utra::d11ctime::HW_D11CTIME_BASE as *mut u32);
|
||||||
|
d11c.wfo(utra::d11ctime::CONTROL_COUNT, 333); // 1.0us per interval
|
||||||
|
let mut polarity = d11c.rf(utra::d11ctime::HEARTBEAT_BEAT);
|
||||||
|
for _ in 0..us {
|
||||||
|
while polarity == d11c.rf(utra::d11ctime::HEARTBEAT_BEAT) {}
|
||||||
|
polarity = d11c.rf(utra::d11ctime::HEARTBEAT_BEAT);
|
||||||
|
}
|
||||||
|
// we have to split this because we don't know where we caught the previous interval
|
||||||
|
if us == 1 {
|
||||||
|
while polarity == d11c.rf(utra::d11ctime::HEARTBEAT_BEAT) {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Initialization -----------------------------------------------------
|
||||||
|
|
||||||
|
/// Full ADC power-on sequence per the datasheet start timing spec:
|
||||||
|
///
|
||||||
|
/// 1. Stop any in-flight DMA
|
||||||
|
/// 2. Assert reset, set clock divider + data count + sensor enable
|
||||||
|
/// 3. Wait ≥ 10 µs (t1)
|
||||||
|
/// 4. Enable bandgap reference + voltage buffers
|
||||||
|
/// 5. Wait (t2 — spec says 0 µs min, we add margin)
|
||||||
|
/// 6. Enable ADC
|
||||||
|
/// 7. Wait ≥ 90 µs (t3)
|
||||||
|
///
|
||||||
|
/// Defaults to temperature sensor source after init.
|
||||||
|
fn init(&mut self) {
|
||||||
|
// Step 0 — stop any prior DMA
|
||||||
|
let rx_cfg = self.csr.r(udma_adc::REG_RX_CFG);
|
||||||
|
if (rx_cfg & ((1 << 4) | (1 << 5))) != 0 {
|
||||||
|
self.csr.rmwf(udma_adc::REG_RX_CFG_R_RX_CLR, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Step 1 — reset + base config
|
||||||
|
self.csr.wo(udma_adc::REG_CR_ADC, 0);
|
||||||
|
|
||||||
|
let fd = Self::calc_clk_fd(self.perclk_freq / 1_000, ADC_TARGET_CLK_KHZ);
|
||||||
|
|
||||||
|
let mut cr: u32 = 0;
|
||||||
|
cr |= 1 << cr_adc::ADC_RST.offset();
|
||||||
|
cr |= fd << cr_adc::CLK_FD.offset();
|
||||||
|
cr |= ADC_MIN_DATA_COUNT << cr_adc::DATA_COUNT.offset();
|
||||||
|
cr |= 1 << cr_adc::SENSOR_EN.offset();
|
||||||
|
self.csr.wo(udma_adc::REG_CR_ADC, cr);
|
||||||
|
|
||||||
|
// Step 2 — t1
|
||||||
|
Self::delay_us(20);
|
||||||
|
|
||||||
|
// Step 3 — bandgap + temperature buffers
|
||||||
|
cr |= 1 << cr_adc::BANDGAP_BUF_EN.offset();
|
||||||
|
cr |= 1 << cr_adc::TEMP_BUF_EN.offset();
|
||||||
|
cr |= 1 << cr_adc::TEMP_FILTER_BYPASS.offset();
|
||||||
|
cr |= 1 << cr_adc::BANDGAP_FILTER_BYPASS.offset();
|
||||||
|
self.csr.wo(udma_adc::REG_CR_ADC, cr);
|
||||||
|
|
||||||
|
// Step 4 — t2
|
||||||
|
Self::delay_us(20);
|
||||||
|
|
||||||
|
// Step 5 — enable ADC
|
||||||
|
cr |= 1 << cr_adc::ADC_EN.offset();
|
||||||
|
self.csr.wo(udma_adc::REG_CR_ADC, cr);
|
||||||
|
|
||||||
|
// Step 6 — t3
|
||||||
|
Self::delay_us(120);
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Source selection ----------------------------------------------------
|
||||||
|
|
||||||
|
/// Reconfigure the analog mux for the given source.
|
||||||
|
///
|
||||||
|
/// Read-modify-writes only the buffer-enable and mux-select bits.
|
||||||
|
pub fn configure_source(&mut self, source: AdcSource) {
|
||||||
|
let mut cr = self.csr.r(udma_adc::REG_CR_ADC);
|
||||||
|
|
||||||
|
// Clear mux-related bits in one shot
|
||||||
|
cr &= !((1u32 << cr_adc::TEMP_BUF_EN.offset())
|
||||||
|
| (1u32 << cr_adc::EXT_BUF_EN.offset())
|
||||||
|
| ((cr_adc::ADC_SEL.mask() as u32) << cr_adc::ADC_SEL.offset())
|
||||||
|
| ((cr_adc::VIN_SEL.mask() as u32) << cr_adc::VIN_SEL.offset()));
|
||||||
|
|
||||||
|
match source {
|
||||||
|
AdcSource::Temperature => {
|
||||||
|
cr |= 1 << cr_adc::TEMP_BUF_EN.offset();
|
||||||
|
// ADC_SEL = 00 (temperature), VIN_SEL = don't-care
|
||||||
|
}
|
||||||
|
AdcSource::Ext(ch) => {
|
||||||
|
cr |= 1 << cr_adc::EXT_BUF_EN.offset();
|
||||||
|
cr |= 1 << cr_adc::ADC_SEL.offset(); // 01 = external
|
||||||
|
cr |= (ch as u32) << cr_adc::VIN_SEL.offset();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
self.csr.wo(udma_adc::REG_CR_ADC, cr);
|
||||||
|
Self::delay_us(20);
|
||||||
|
}
|
||||||
|
|
||||||
|
// --- Measurement --------------------------------------------------------
|
||||||
|
|
||||||
|
/// Blocking single-shot read. Returns the raw 10-bit result (0–1023).
|
||||||
|
pub fn read_raw(&mut self, source: AdcSource) -> u16 {
|
||||||
|
self.configure_source(source);
|
||||||
|
|
||||||
|
self.csr.rmwf(udma_adc::REG_RX_CFG_R_RX_CLR, 1);
|
||||||
|
|
||||||
|
// Enqueue a 1-word (4-byte) DMA transfer
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
unsafe {
|
||||||
|
self.udma_enqueue(Bank::Rx, &self.ifram.as_phys_slice::<u8>()[..4], CFG_EN | CFG_SIZE_32);
|
||||||
|
}
|
||||||
|
#[cfg(not(feature = "std"))]
|
||||||
|
unsafe {
|
||||||
|
self.udma_enqueue(Bank::Rx, &self.ifram.as_phys_slice::<u8>()[..4], CFG_EN | CFG_SIZE_32);
|
||||||
|
}
|
||||||
|
|
||||||
|
while self.udma_busy(Bank::Rx) {
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
xous::yield_slice();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(any(feature = "std", feature = "kernel"))]
|
||||||
|
let val = self.ifram.as_slice::<u32>()[0];
|
||||||
|
#[cfg(not(any(feature = "std", feature = "kernel")))]
|
||||||
|
let val = unsafe { self.ifram.as_phys_slice::<u32>()[0] };
|
||||||
|
|
||||||
|
(val & 0x3FF) as u16
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read `n` samples and return the average (raw 10-bit value).
|
||||||
|
pub fn read_raw_averaged(&mut self, source: AdcSource, n: usize) -> u16 {
|
||||||
|
let max_words = ADC_RX_BUF_SIZE / core::mem::size_of::<u32>();
|
||||||
|
assert!(n > 0 && n <= max_words, "n must be 1..={}", max_words);
|
||||||
|
|
||||||
|
self.configure_source(source);
|
||||||
|
|
||||||
|
self.csr.rmwf(udma_adc::REG_RX_CFG_R_RX_CLR, 1);
|
||||||
|
|
||||||
|
let byte_len = n * core::mem::size_of::<u32>();
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
unsafe {
|
||||||
|
self.udma_enqueue(Bank::Rx, &self.ifram.as_phys_slice::<u8>()[..byte_len], CFG_EN | CFG_SIZE_32);
|
||||||
|
}
|
||||||
|
#[cfg(not(feature = "std"))]
|
||||||
|
unsafe {
|
||||||
|
self.udma_enqueue(Bank::Rx, &self.ifram.as_phys_slice::<u8>()[..byte_len], CFG_EN | CFG_SIZE_32);
|
||||||
|
}
|
||||||
|
|
||||||
|
while self.udma_busy(Bank::Rx) {
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
xous::yield_slice();
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut sum: u32 = 0;
|
||||||
|
for i in 0..n {
|
||||||
|
#[cfg(any(feature = "std", feature = "kernel"))]
|
||||||
|
let val = self.ifram.as_slice::<u32>()[i];
|
||||||
|
#[cfg(not(any(feature = "std", feature = "kernel")))]
|
||||||
|
let val = unsafe { self.ifram.as_phys_slice::<u32>()[i] };
|
||||||
|
|
||||||
|
sum += val & 0x3FF;
|
||||||
|
}
|
||||||
|
(sum / n as u32) as u16
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Arm continuous DMA conversion. The uDMA will repeatedly fill the
|
||||||
|
/// buffer and wrap. Use the ADC RX interrupt (IRQn 121 - irqarray8::EV_PENDING_ADC_RX) or poll
|
||||||
|
/// `udma_busy(Bank::Rx)` to track progress.
|
||||||
|
pub fn start_continuous(&mut self, source: AdcSource) {
|
||||||
|
self.configure_source(source);
|
||||||
|
|
||||||
|
self.csr.rmwf(udma_adc::REG_RX_CFG_R_RX_CLR, 1);
|
||||||
|
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
unsafe {
|
||||||
|
self.udma_enqueue(Bank::Rx, self.ifram.as_phys_slice::<u8>(), CFG_EN | CFG_SIZE_32 | CFG_CONT);
|
||||||
|
}
|
||||||
|
#[cfg(not(feature = "std"))]
|
||||||
|
unsafe {
|
||||||
|
self.udma_enqueue(Bank::Rx, self.ifram.as_phys_slice::<u8>(), CFG_EN | CFG_SIZE_32 | CFG_CONT);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Stop continuous conversion.
|
||||||
|
pub fn stop_continuous(&mut self) { self.csr.rmwf(udma_adc::REG_RX_CFG_R_RX_CLR, 1); }
|
||||||
|
|
||||||
|
// --- Conversion helpers -------------------------------------------------
|
||||||
|
|
||||||
|
/// Raw → temperature in °C (float).
|
||||||
|
///
|
||||||
|
/// Linear regression on the datasheet table
|
||||||
|
/// T = −0.5877 × raw + 328.68, R² ≈ 0.99997
|
||||||
|
pub fn raw_to_temp_celsius(raw: u16) -> f32 { -0.587_744_8 * raw as f32 + 328.679_84 }
|
||||||
|
|
||||||
|
/// Raw → temperature in tenths of °C (integer).
|
||||||
|
/// e.g. 253 means 25.3 °C.
|
||||||
|
pub fn raw_to_temp_tenths_c(raw: u16) -> i16 { 3287i16 - (raw as i32 * 587_745 / 100_000) as i16 }
|
||||||
|
|
||||||
|
/// Raw → voltage in volts (bandgap ref, Vbg = 1.208 V).
|
||||||
|
/// V_in = raw / 1023 × 1.208
|
||||||
|
pub fn raw_to_voltage(raw: u16) -> f32 { (raw as f32 / 1023.0) * 1.208 }
|
||||||
|
}
|
||||||
|
|
@ -75,7 +75,10 @@ pub struct I2cDriver<'a> {
|
||||||
#[allow(dead_code)] // used in bao1x
|
#[allow(dead_code)] // used in bao1x
|
||||||
channel: I2cChannel,
|
channel: I2cChannel,
|
||||||
divider: u16,
|
divider: u16,
|
||||||
|
// cached value of perclk
|
||||||
perclk_freq: u32,
|
perclk_freq: u32,
|
||||||
|
// cached value of our clock setting
|
||||||
|
i2c_freq: u32,
|
||||||
pub ifram: IframRange,
|
pub ifram: IframRange,
|
||||||
tx_buf: &'static mut [u8],
|
tx_buf: &'static mut [u8],
|
||||||
tx_buf_phys: &'static mut [u8],
|
tx_buf_phys: &'static mut [u8],
|
||||||
|
|
@ -197,6 +200,7 @@ impl<'a> I2cDriver<'a> {
|
||||||
seq_len: 0,
|
seq_len: 0,
|
||||||
pending: I2cPending::Idle,
|
pending: I2cPending::Idle,
|
||||||
perclk_freq,
|
perclk_freq,
|
||||||
|
i2c_freq,
|
||||||
};
|
};
|
||||||
i2c.send_cmd_list(&[I2cCmd::Config(divider)]);
|
i2c.send_cmd_list(&[I2cCmd::Config(divider)]);
|
||||||
i2c
|
i2c
|
||||||
|
|
@ -205,6 +209,12 @@ impl<'a> I2cDriver<'a> {
|
||||||
pub fn set_freq(&mut self, freq_hz: u32) {
|
pub fn set_freq(&mut self, freq_hz: u32) {
|
||||||
// divide-by-4 is an empirical observation
|
// divide-by-4 is an empirical observation
|
||||||
self.divider = ((self.perclk_freq / (freq_hz * 4)).min(u16::MAX as u32)) as u16;
|
self.divider = ((self.perclk_freq / (freq_hz * 4)).min(u16::MAX as u32)) as u16;
|
||||||
|
self.i2c_freq = freq_hz;
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn update_perclk(&mut self, perclk_freq: u32) {
|
||||||
|
self.perclk_freq = perclk_freq;
|
||||||
|
self.set_freq(self.i2c_freq);
|
||||||
}
|
}
|
||||||
|
|
||||||
// always blocks
|
// always blocks
|
||||||
|
|
|
||||||
|
|
@ -1,9 +1,11 @@
|
||||||
|
pub mod adc;
|
||||||
pub mod i2c;
|
pub mod i2c;
|
||||||
pub mod spim;
|
pub mod spim;
|
||||||
pub mod uart;
|
pub mod uart;
|
||||||
|
|
||||||
use core::mem::size_of;
|
use core::mem::size_of;
|
||||||
|
|
||||||
|
pub use adc::*;
|
||||||
use bao1x_api::*;
|
use bao1x_api::*;
|
||||||
pub use i2c::*;
|
pub use i2c::*;
|
||||||
pub use spim::*;
|
pub use spim::*;
|
||||||
|
|
|
||||||
|
|
@ -2,6 +2,7 @@ pub mod api;
|
||||||
pub mod trng;
|
pub mod trng;
|
||||||
|
|
||||||
use bao1x_api::*;
|
use bao1x_api::*;
|
||||||
|
use bao1x_hal::udma::{AdcExtChannel, AdcSource};
|
||||||
use num_traits::*;
|
use num_traits::*;
|
||||||
use xous::{Message, send_message};
|
use xous::{Message, send_message};
|
||||||
use xous_api_susres::api::Opcode as SusresOp;
|
use xous_api_susres::api::Opcode as SusresOp;
|
||||||
|
|
@ -128,6 +129,58 @@ impl UdmaGlobalConfig for UdmaGlobal {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub struct Adc {
|
||||||
|
conn: xous::CID,
|
||||||
|
}
|
||||||
|
impl Adc {
|
||||||
|
pub fn new() -> Self {
|
||||||
|
let xns = xous_names::XousNames::new().unwrap();
|
||||||
|
let conn =
|
||||||
|
xns.request_connection(SERVER_NAME_BAO1X_OTHERS).expect("Couldn't connect to bao1x HAL server");
|
||||||
|
Adc { conn }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Averaging can range from 1..1024. Out of range values are silently converted to in-range values
|
||||||
|
/// based on saturating logic. None for averaging translates to 1.
|
||||||
|
///
|
||||||
|
/// For analog channels, the measurement goes from 0..1.208v. There is some nonlinearity observed below
|
||||||
|
/// 0.2V, so the "sweet spot" is 0.2V-1.2V.
|
||||||
|
pub fn read_raw(&self, channel: AdcSource, averaging: Option<u16>) -> u16 {
|
||||||
|
let averaging =
|
||||||
|
averaging.unwrap_or(1).min(1).max((bao1x_hal::udma::ADC_RX_BUF_SIZE / size_of::<u32>()) as u16);
|
||||||
|
match xous::send_message(
|
||||||
|
self.conn,
|
||||||
|
xous::Message::new_blocking_scalar(
|
||||||
|
PeripheralOpcode::ReadAdcChannel.to_usize().unwrap(),
|
||||||
|
channel.to_usize(),
|
||||||
|
averaging as usize,
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
),
|
||||||
|
) {
|
||||||
|
Ok(xous::Result::Scalar5(_, value, _, _, _)) => value as u16,
|
||||||
|
_ => panic!("Unhandled response on Adc::read_raw"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Safety: this method does no checks for concurrent use of the analog channels.
|
||||||
|
/// It is up to the caller to ensure that ADC0-3 (mapped to PA4-7) have no conflicts
|
||||||
|
/// with other I/O functions.
|
||||||
|
pub unsafe fn enable_channel(&self, channel: AdcExtChannel) {
|
||||||
|
xous::send_message(
|
||||||
|
self.conn,
|
||||||
|
xous::Message::new_blocking_scalar(
|
||||||
|
PeripheralOpcode::EnableChannel.to_usize().unwrap(),
|
||||||
|
channel.into(),
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
.ok();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
pub struct ClockManager {
|
pub struct ClockManager {
|
||||||
conn: xous::CID,
|
conn: xous::CID,
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -96,10 +96,10 @@ fn try_alloc(ifram_allocs: &mut Vec<Option<Sender>>, size: usize, sender: Sender
|
||||||
} else {
|
} else {
|
||||||
if free_start.is_some() {
|
if free_start.is_some() {
|
||||||
log::trace!("Adding unallocated page at {} to length", index);
|
log::trace!("Adding unallocated page at {} to length", index);
|
||||||
found_len += 1;
|
|
||||||
if found_len >= size_pages {
|
if found_len >= size_pages {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
found_len += 1;
|
||||||
} else {
|
} else {
|
||||||
log::trace!("Starting allocation search at {}", index);
|
log::trace!("Starting allocation search at {}", index);
|
||||||
free_start = Some(index);
|
free_start = Some(index);
|
||||||
|
|
@ -615,6 +615,12 @@ fn main() {
|
||||||
os_timer.wfo(utra::timer0::EV_ENABLE_ZERO, if timer_run { 1 } else { 0 });
|
os_timer.wfo(utra::timer0::EV_ENABLE_ZERO, if timer_run { 1 } else { 0 });
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
HalOpcode::UpdatePerclk => {
|
||||||
|
if let Some(scalar) = msg_opt.as_mut().unwrap().body.scalar_message_mut() {
|
||||||
|
let new_perclk = scalar.arg1 as u32;
|
||||||
|
i2c.update_perclk(new_perclk);
|
||||||
|
}
|
||||||
|
}
|
||||||
HalOpcode::InvalidCall => {
|
HalOpcode::InvalidCall => {
|
||||||
log::error!("Invalid opcode received: {:?}", msg_opt);
|
log::error!("Invalid opcode received: {:?}", msg_opt);
|
||||||
}
|
}
|
||||||
|
|
@ -633,6 +639,9 @@ fn main() {
|
||||||
servers::trng::start_trng_service();
|
servers::trng::start_trng_service();
|
||||||
servers::rtc::start_rtc_service();
|
servers::rtc::start_rtc_service();
|
||||||
|
|
||||||
|
// start the remaining services
|
||||||
|
servers::others::start_peri_service(clk_mgr.get_per());
|
||||||
|
|
||||||
let tt = ticktimer::Ticktimer::new().unwrap();
|
let tt = ticktimer::Ticktimer::new().unwrap();
|
||||||
// placeholder - we can put an actual service here but for now just sleep the main thread.
|
// placeholder - we can put an actual service here but for now just sleep the main thread.
|
||||||
loop {
|
loop {
|
||||||
|
|
|
||||||
|
|
@ -4,6 +4,7 @@ pub mod keyboard;
|
||||||
#[cfg(all(feature = "board-baosec", not(feature = "oem-baosec-lite")))]
|
#[cfg(all(feature = "board-baosec", not(feature = "oem-baosec-lite")))]
|
||||||
mod baosec_hw;
|
mod baosec_hw;
|
||||||
pub mod bio;
|
pub mod bio;
|
||||||
|
pub mod others;
|
||||||
pub mod rtc;
|
pub mod rtc;
|
||||||
pub mod susres;
|
pub mod susres;
|
||||||
pub mod trng;
|
pub mod trng;
|
||||||
|
|
|
||||||
95
services/bao1x-hal-service/src/servers/others.rs
Normal file
95
services/bao1x-hal-service/src/servers/others.rs
Normal file
|
|
@ -0,0 +1,95 @@
|
||||||
|
//! Server for all the other hardware pieces that aren't covered by
|
||||||
|
//! existing well-known/shared service providers, and which also can't
|
||||||
|
//! be condensed into the main loop due to dependencies on core HAL
|
||||||
|
//! services (such as IFRAM resolution, I/O setup, etc.)
|
||||||
|
|
||||||
|
use bao1x_api::{IoxDir, IoxEnable, IoxFunction, PeripheralOpcode, SERVER_NAME_BAO1X_OTHERS, iox::IoSetup};
|
||||||
|
use bao1x_hal::udma::{Adc, AdcExtChannel, AdcSource};
|
||||||
|
use bao1x_hal_service::UdmaGlobal;
|
||||||
|
|
||||||
|
pub fn start_peri_service(clk_freq: u32) {
|
||||||
|
let _ = std::thread::spawn({
|
||||||
|
move || {
|
||||||
|
peri_service(clk_freq);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
fn peri_service(clk_freq: u32) -> ! {
|
||||||
|
let xns = xous_names::XousNames::new().unwrap();
|
||||||
|
// claim the server name
|
||||||
|
let sid = xns.register_name(SERVER_NAME_BAO1X_OTHERS, None).unwrap();
|
||||||
|
|
||||||
|
let iox = crate::iox::IoxHal::new();
|
||||||
|
let udma_global = UdmaGlobal::new();
|
||||||
|
udma_global.udma_clock_config(bao1x_api::PeriphId::Adc, true);
|
||||||
|
// safety: clocks are turned on, and perclk already configured as so
|
||||||
|
let mut adc = unsafe { Adc::new(clk_freq) };
|
||||||
|
|
||||||
|
let mut msg_opt = None;
|
||||||
|
|
||||||
|
loop {
|
||||||
|
xous::reply_and_receive_next(sid, &mut msg_opt).unwrap();
|
||||||
|
let opcode = {
|
||||||
|
let msg = msg_opt.as_mut().unwrap();
|
||||||
|
num_traits::FromPrimitive::from_usize(msg.body.id()).unwrap_or(PeripheralOpcode::InvalidCall)
|
||||||
|
};
|
||||||
|
log::debug!("{:?}", opcode);
|
||||||
|
match opcode {
|
||||||
|
PeripheralOpcode::ReadAdcChannel => {
|
||||||
|
if let Some(scalar) = msg_opt.as_mut().unwrap().body.scalar_message_mut() {
|
||||||
|
let channel = AdcSource::from_usize(scalar.arg1);
|
||||||
|
// sets to at least 1, even if the arg is 0
|
||||||
|
// max averaging is limited by the size of the ADC buffer
|
||||||
|
let averaging =
|
||||||
|
scalar.arg2.max(1).min(bao1x_hal::udma::ADC_RX_BUF_SIZE / size_of::<u32>());
|
||||||
|
scalar.arg1 = adc.read_raw_averaged(channel, averaging) as usize;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
PeripheralOpcode::EnableChannel => {
|
||||||
|
if let Some(scalar) = msg_opt.as_mut().unwrap().body.scalar_message_mut() {
|
||||||
|
let channel: AdcExtChannel = scalar.arg1.into();
|
||||||
|
let pin = match channel {
|
||||||
|
AdcExtChannel::Adc0 => 4,
|
||||||
|
AdcExtChannel::Adc1 => 5,
|
||||||
|
AdcExtChannel::Adc2 => 6,
|
||||||
|
AdcExtChannel::Adc3 => 7,
|
||||||
|
};
|
||||||
|
iox.setup_pin(
|
||||||
|
bao1x_api::IoxPort::PA,
|
||||||
|
pin,
|
||||||
|
Some(IoxDir::Input),
|
||||||
|
Some(IoxFunction::Gpio),
|
||||||
|
Some(IoxEnable::Disable),
|
||||||
|
Some(IoxEnable::Disable),
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
);
|
||||||
|
// dabao boards have a dependency to configure this pin as an input as well.
|
||||||
|
#[cfg(feature = "board-dabao")]
|
||||||
|
if channel == AdcExtChannel::Adc0 {
|
||||||
|
iox.setup_pin(
|
||||||
|
bao1x_api::IoxPort::PC,
|
||||||
|
9,
|
||||||
|
Some(IoxDir::Input),
|
||||||
|
Some(IoxFunction::Gpio),
|
||||||
|
Some(IoxEnable::Disable),
|
||||||
|
Some(IoxEnable::Disable),
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
PeripheralOpcode::UpdatePerclk => {
|
||||||
|
if let Some(scalar) = msg_opt.as_mut().unwrap().body.scalar_message_mut() {
|
||||||
|
let new_perclk = scalar.arg1 as u32;
|
||||||
|
adc.update_perclk(new_perclk);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
PeripheralOpcode::InvalidCall => {
|
||||||
|
log::error!("Invalid opcode received: {:?}", msg_opt);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in a new issue