atmos/kernel/

uart.rs

use core::fmt;

const UART0_BASE: usize = 0x3F20_1000;

const UART0_DR: *mut u32 = UART0_BASE as *mut u32;
const UART0_FR: *mut u32 = (UART0_BASE + 0x18) as *mut u32;
const UART0_IBRD: *mut u32 = (UART0_BASE + 0x24) as *mut u32;
const UART0_FBRD: *mut u32 = (UART0_BASE + 0x28) as *mut u32;
const UART0_LCRH: *mut u32 = (UART0_BASE + 0x2C) as *mut u32;
const UART0_CR: *mut u32 = (UART0_BASE + 0x30) as *mut u32;
const UART0_IMSC: *mut u32 = (UART0_BASE + 0x38) as *mut u32;
const UART0_ICR: *mut u32 = (UART0_BASE + 0x44) as *mut u32;

// GPIO レジスタ
const GPIO_BASE: usize = 0x3F20_0000;
const GPFSEL1: *mut u32 = (GPIO_BASE + 0x04) as *mut u32;
const GPPUD: *mut u32 = (GPIO_BASE + 0x94) as *mut u32;
const GPPUDCLK0: *mut u32 = (GPIO_BASE + 0x98) as *mut u32;

pub struct Uart;

static mut SERIAL_CHAR_COUNT: usize = 0;

impl Uart {
    /// Mailbox 経由で UART クロック周波数を取得 (ヒープ不要)
    fn query_uart_clock() -> u32 {
        // UART0 の Clock ID = 0x000000002
        // Mailbox Property Tag: Get Clock Rate = 0x00030002
        #[repr(C, align(16))]
        struct ClockReq {
            buf: [u32; 9],
        }
        let mut req = ClockReq {
            buf: [
                9 * 4,       // Buffer size
                0,           // Request code
                0x0003_0002, // Tag: Get Clock Rate
                8,           // Value buffer size
                0,           // Request length
                0x0000_0002, // Clock ID = UART
                0,           // Response: rate
                0,           // End tag
                0,
            ],
        };
        let ptr = req.buf.as_mut_ptr();
        let slice = unsafe { core::slice::from_raw_parts_mut(ptr, 9) };

        // D-Cache フラッシュ
        unsafe {
            let addr = slice.as_ptr() as usize;
            let cache_line = 64usize;
            let start = addr & !(cache_line - 1);
            let end = addr + 9 * 4;
            let mut cur = start;
            while cur < end {
                core::arch::asm!("dc civac, {}", in(reg) cur, options(nostack));
                cur += cache_line;
            }
            core::arch::asm!("dsb sy", options(nostack));
        }

        // Mailbox registers
        const MBOX_BASE: usize = 0x3F00_B880;
        const MBOX_READ: *mut u32 = MBOX_BASE as *mut u32;
        const MBOX_STATUS: *mut u32 = (MBOX_BASE + 0x18) as *mut u32;
        const MBOX_WRITE: *mut u32 = (MBOX_BASE + 0x20) as *mut u32;

        let addr_val = req.buf.as_ptr() as u32;
        let data = (addr_val & !0xF) | 8; // Channel 8 = Property

        unsafe {
            while (core::ptr::read_volatile(MBOX_STATUS) & 0x8000_0000) != 0 {}
            core::ptr::write_volatile(MBOX_WRITE, data);
            loop {
                while (core::ptr::read_volatile(MBOX_STATUS) & 0x4000_0000) != 0 {}
                let res = core::ptr::read_volatile(MBOX_READ);
                if res == data {
                    break;
                }
            }
            // D-Cache invalidate to read back GPU response
            let addr = slice.as_ptr() as usize;
            let cache_line = 64usize;
            let start = addr & !(cache_line - 1);
            let end = addr + 9 * 4;
            let mut cur = start;
            while cur < end {
                core::arch::asm!("dc civac, {}", in(reg) cur, options(nostack));
                cur += cache_line;
            }
            core::arch::asm!("dsb sy", options(nostack));
        }

        if req.buf[1] == 0x8000_0000 && req.buf[6] != 0 {
            req.buf[6]
        } else {
            48_000_000 // フォールバック: 実機のデフォルト 48MHz
        }
    }

    pub fn init() {
        unsafe {
            // 1. UARTを無効化
            core::ptr::write_volatile(UART0_CR, 0);

            // 2. GPIO 14/15 を ALT0 (UART0 TXD/RXD) に設定
            let mut gpfsel1 = core::ptr::read_volatile(GPFSEL1);
            // GPIO 14: FSEL14 = bits [14:12], ALT0 = 0b100
            gpfsel1 &= !(0b111 << 12);
            gpfsel1 |= 0b100 << 12;
            // GPIO 15: FSEL15 = bits [17:15], ALT0 = 0b100
            gpfsel1 &= !(0b111 << 15);
            gpfsel1 |= 0b100 << 15;
            core::ptr::write_volatile(GPFSEL1, gpfsel1);

            // 3. GPIO 14/15 のプルアップ/ダウンをクリア
            core::ptr::write_volatile(GPPUD, 0);
            for _ in 0..150 {
                core::arch::asm!("nop");
            }
            core::ptr::write_volatile(GPPUDCLK0, (1 << 14) | (1 << 15));
            for _ in 0..150 {
                core::arch::asm!("nop");
            }
            core::ptr::write_volatile(GPPUDCLK0, 0);

            // 4. 全割り込みクリア
            core::ptr::write_volatile(UART0_ICR, 0x7FF);

            // 5. すべての割り込みをマスク
            core::ptr::write_volatile(UART0_IMSC, 0);

            // 6. Mailbox でUARTクロック周波数を取得し、動的にボーレートを計算
            // これにより実機 (48MHz) でもQEMU (~3MHz) でも正しく 115200 baud で動作する
            let uart_clk = Self::query_uart_clock();
            let baud = 115200u32;
            let divisor_x64 = ((uart_clk as u64) * 4) / (baud as u64); // = 64 * (clk / (16 * baud))
            let ibrd = (divisor_x64 / 64) as u32;
            let fbrd = (divisor_x64 % 64) as u32;
            core::ptr::write_volatile(UART0_IBRD, ibrd);
            core::ptr::write_volatile(UART0_FBRD, fbrd);

            // 7. 8bit, FIFO有効
            core::ptr::write_volatile(UART0_LCRH, 0x70);

            // 8. UART, TX, RX を有効化
            core::ptr::write_volatile(UART0_CR, 0x301);
        }
    }

    pub fn send(c: u8) {
        unsafe {
            // 送信バッファが空くまで待つ (FR の TXFF (Transmit FIFO Full) ビットが 0 になるまで)
            while (core::ptr::read_volatile(UART0_FR) & 0x20) != 0 {}
            core::ptr::write_volatile(UART0_DR, c as u32);
        }
    }

    /// 受信データがあるか確認します (FRレジスタの RXFE (Receive FIFO Empty) ビットが0ならデータあり)
    pub fn has_char() -> bool {
        unsafe { (core::ptr::read_volatile(UART0_FR) & 0x10) == 0 }
    }

    /// 1バイト受信します (データが来るまで待機します)
    pub fn recv() -> u8 {
        unsafe {
            while !Self::has_char() {}
            (core::ptr::read_volatile(UART0_DR) & 0xFF) as u8
        }
    }

    pub fn send_string(s: &str) {
        unsafe {
            let mut prev = 0u8;
            for b in s.bytes() {
                if b == b'\n' {
                    if prev != b'\r' {
                        Self::send(b'\r');
                    }
                    Self::send(b);
                    SERIAL_CHAR_COUNT = 0;
                    prev = b;
                } else {
                    if !crate::AUTO_TEST_BROWSER && SERIAL_CHAR_COUNT >= 55 {
                        Self::send(b'\r');
                        Self::send(b'\n');
                        SERIAL_CHAR_COUNT = 0;
                    }
                    Self::send(b);
                    if !crate::AUTO_TEST_BROWSER {
                        SERIAL_CHAR_COUNT += 1;
                    }
                    prev = b;
                }
            }
        }
    }
}

impl fmt::Write for Uart {
    fn write_str(&mut self, s: &str) -> fmt::Result {
        Self::send_string(s);
        Ok(())
    }
}

// 簡単なマクロを実装
#[macro_export]
macro_rules! print {
    ($($arg:tt)*) => {
        // 【2026-08-05】ログ行と直列化する。以前はここが素の書き込みで、
        // ログ行の途中へ割り込んで壊していた。
        $crate::kernel::uart::emit_raw(core::format_args!($($arg)*));
    };
}

#[macro_export]
macro_rules! println {
    () => ($crate::print!("\n"));
    // 【2026-08-05】以前は本文と改行で `print!` を 2 回呼んでいた。
    // 1 回ずつはロックされていても**その隙間**に他スレッドが割り込めるため、
    // 改行の直前で行が割られていた（実測でこの形の混線が 1 件残っていた）。
    // `format_args!` の時点で改行まで含めて 1 回の出力にする。
    ($($arg:tt)*) => ({
        $crate::kernel::uart::emit_raw(core::format_args!("{}\n", core::format_args!($($arg)*)));
    })
}

use core::sync::atomic::{AtomicBool, Ordering};

static IS_SILENT: AtomicBool = AtomicBool::new(false);

pub fn set_silent(silent: bool) {
    IS_SILENT.store(silent, Ordering::Relaxed);
}

pub fn is_silent() -> bool {
    IS_SILENT.load(Ordering::Relaxed)
}

/// ログ 1 行の出力を直列化するロック。
///
/// 【2026-08-05】以前は `write_fmt` を 3 回（レベル・本文・改行）
/// 素で呼んでいた。UART へは 1 文字ずつ書くため、途中でスレッドが
/// 切り替わると**行が混ざる**。リソース取得を 4 並列にしてから頻発し、
/// 実際のログにこうした壊れ方が現れていた:
///
/// ```text
/// [NET][DNSSEND]CgQ hoBnstw7HFyzSD-As=fonts.gstatic.com attempt=1
/// ```
///
/// 診断の土台が壊れると、他のすべての調査が信用できなくなる。
static LOG_LOCK: spin::Mutex<()> = spin::Mutex::new(());

/// ログ 1 行を組み立てて、まとめて出力する。
///
/// # デッドロックを作らないための決め事
///
/// ロックが取れないまま**有限回**спинしたら、諦めてロック無しで出す。
/// 行が混ざるのは困るが、ログが原因で系全体が止まる方がはるかに悪い。
/// 例外ハンドラがロックを握ったまま死んだ場合でも、これで先へ進める。
/// ログ用ロックを有限回だけ待つ。取れなければ `None`。
///
/// 取れなくても**必ず出力はする**（呼び出し側で `None` のまま進む）。
/// 行が混ざるのは困るが、ログが原因で系全体が止まる方がはるかに悪い。
/// 例外ハンドラがロックを握ったまま死んだ場合でも、これで先へ進める。
/// # 上限は「時間」で決める
///
/// 【2026-08-05】最初は回数（10 万回）で切ったが**短すぎた**。
/// 115200 baud では 1 文字 ≈ 87µs、100 文字の行で ≈ 9ms かかる。
/// 一方 10 万回のスピンは 1ms にも満たないので、
/// 先行する行を書き終える前に諦めて混線が残っていた
/// （実測: 399 行中 2 行）。
///
/// tick 基準にすれば CPU 速度に依らず「行 1 本ぶんは待つ」が保証できる。
/// tick が進まない状況（呼び出し元が割り込みを止めている等）でも
/// 止まらないよう、回数の上限も併せて置く。
fn try_lock_log() -> Option<spin::MutexGuard<'static, ()>> {
    let start = crate::kernel::timer::get_ticks();
    let mut spins: u32 = 0;
    loop {
        if let Some(g) = LOG_LOCK.try_lock() {
            return Some(g);
        }
        core::hint::spin_loop();
        spins = spins.wrapping_add(1);
        // 20 tick（≈200ms）待てば、どんな長さの行でも書き終わっている。
        if crate::kernel::timer::get_ticks().wrapping_sub(start) > 20 {
            return None;
        }
        // tick が進まない場合の保険。
        if spins > 50_000_000 {
            return None;
        }
    }
}

/// `print!` の出力をログ行と直列化する。
///
/// 【2026-08-05】`log!` 側を直列化しただけでは足りなかった。
/// `print!` は同じ UART へ**ロックを通さずに**書くため、
/// ログ行の途中に割り込んで壊していた（実測で `[PERF] style_t` の
/// ように途中で切れた行が残っていた）。
///
/// `print!` は端末表示にも使い、長さも改行の有無も自由なので、
/// `emit_line` のような固定長バッファは通さずロックだけ掛ける。
pub fn emit_raw(args: core::fmt::Arguments) {
    use core::fmt::Write;
    let guard = try_lock_log();
    let mut uart = Uart;
    let _ = uart.write_fmt(args);
    #[allow(unused_unsafe)]
    unsafe {
        if crate::kernel::draw::SPLASH_ACTIVE {
            let mut writer = crate::kernel::draw::SplashWriter;
            let _ = writer.write_fmt(args);
        }
    }
    drop(guard);
}

pub fn emit_line(level_str: &str, args: core::fmt::Arguments) {
    use core::fmt::Write;
    let mut line = crate::kernel::uart_line_buf::LineBuf::new();
    let _ = line.write_str(level_str);
    let _ = line.write_str(" ");
    let _ = line.write_fmt(args);
    if line.was_truncated() {
        // 切り詰めは UTF-8 の途中で起きうる。文字境界まで戻してから
        // 印を付ける（不正なバイト列を UART へ流さないため）。
        line.trim_to_char_boundary();
        let _ = line.write_str("...");
    }
    let _ = line.write_str("\n");

    let guard = try_lock_log();

    // 1 回で書き切る。ここを分けると混線の余地が戻る。
    let text = core::str::from_utf8(line.as_bytes()).unwrap_or("[log: invalid utf-8]\n");
    let mut uart = Uart;
    let _ = uart.write_str(text);
    #[allow(unused_unsafe)]
    unsafe {
        if crate::kernel::draw::SPLASH_ACTIVE {
            let mut writer = crate::kernel::draw::SplashWriter;
            let _ = writer.write_str(text);
        }
    }
    drop(guard);
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum LogLevel {
    Error = 0,
    Warn = 1,
    Info = 2,
    Debug = 3,
}

/// システム全体のログ出力レベル（マスター音量ノブ）。
pub const CURRENT_LOG_LEVEL: LogLevel = LogLevel::Warn;

#[macro_export]
macro_rules! log {
    ($level:expr, $($arg:tt)*) => {
        if !$crate::kernel::uart::is_silent() {
            if $level <= $crate::kernel::uart::CURRENT_LOG_LEVEL {
                let level_str = match $level {
                    $crate::kernel::uart::LogLevel::Error => "[ERROR]",
                    $crate::kernel::uart::LogLevel::Warn  => "[WARN ]",
                    $crate::kernel::uart::LogLevel::Info  => "[INFO ]",
                    $crate::kernel::uart::LogLevel::Debug => "[DEBUG]",
                };
                // 【2026-08-05】以前はここで `write_fmt` を 3 回
                // （レベル・本文・改行）素で呼んでいた。UART へは 1 文字ずつ
                // 書くので、途中でスレッドが切り替わると**行が混ざる**。
                // 4 並列でリソースを取るようにしてから頻発していた。
                // 組み立てと出力は `emit_line` に集約する。
                $crate::kernel::uart::emit_line(level_str, core::format_args!($($arg)*));
            }
        }
    };
}

#[macro_export]
macro_rules! error {
    ($($arg:tt)*) => ($crate::log!($crate::kernel::uart::LogLevel::Error, $($arg)*));
}

#[macro_export]
macro_rules! warn {
    ($($arg:tt)*) => ($crate::log!($crate::kernel::uart::LogLevel::Warn, $($arg)*));
}

#[macro_export]
macro_rules! info {
    ($($arg:tt)*) => ($crate::log!($crate::kernel::uart::LogLevel::Info, $($arg)*));
}

#[macro_export]
macro_rules! debug {
    ($($arg:tt)*) => ($crate::log!($crate::kernel::uart::LogLevel::Debug, $($arg)*));
}