cache.rs

//! (TODO) Bypass cache 
//! 
//! Todo: verify this module!

use core::slice;
use core::str;

/// Convert a buffer or a pointer into ones with uncached address.
/// 
/// Section 3.4.1, Kendryte K210 Datasheet
pub fn uncached<T: Uncache>(buf: T) -> T {
    buf.uncache()
}

/// Uncacheable buffer or pointer.
pub trait Uncache {
    /// Convert this buffer or pointer to uncached addressed ones
    fn uncache(self) -> Self;
}

impl<T> Uncache for &T {
    #[inline]
    fn uncache(self) -> Self {
        let addr = self as *const T as usize;
        assert_addr_cached(addr);
        // note(unsafe): safe for source address is safe
        unsafe { &*((addr - 0x4000_0000) as *const T) }
    }
}

impl<T> Uncache for &mut T {
    #[inline]
    fn uncache(self) -> Self {
        let addr = self as *mut T as usize;
        assert_addr_cached(addr);
        // note(unsafe): safe for source address is safe
        unsafe { &mut *((addr - 0x4000_0000) as *mut T) }
    }
}

impl<T> Uncache for &[T] {
    #[inline]
    fn uncache(self) -> Self {
        let addr = self.as_ptr() as usize;
        assert_addr_cached(addr);
        let new_ptr = (addr - 0x4000_0000) as *const T;
        // note(unsafe): source address is safe; passing ownership
        unsafe { slice::from_raw_parts(new_ptr, self.len()) }
    }
}

impl<T> Uncache for &mut [T] {
    #[inline]
    fn uncache(self) -> Self {
        let addr = self.as_ptr() as usize;
        assert_addr_cached(addr);
        let new_ptr = (addr - 0x4000_0000) as *mut T;
        // note(unsafe): source address is safe; passing ownership
        unsafe { slice::from_raw_parts_mut(new_ptr, self.len()) }
    }
}

impl Uncache for &str {
    #[inline]
    fn uncache(self) -> Self {
        let addr = self.as_ptr() as usize;
        assert_addr_cached(addr);
        let new_ptr = (addr - 0x4000_0000) as *const u8;
        // note(unsafe): source address is safe; passing ownership
        let slice = unsafe { slice::from_raw_parts(new_ptr, self.len()) };