atmos/kernel/

sdhost.rs

// sdhost.rs - BCM2835 SDHOST Controller Driver for Raspberry Pi 3B+
#![allow(dead_code)]
#![allow(static_mut_refs)]

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

// --- BCM2837 GPIO Registers ---
const GPIO_BASE: usize = 0x3F20_0000;
const GPFSEL4: *mut u32 = (GPIO_BASE + 0x10) as *mut u32;
const GPFSEL5: *mut u32 = (GPIO_BASE + 0x14) as *mut u32;
const GPPUD: *mut u32 = (GPIO_BASE + 0x94) as *mut u32;
const GPPUDCLK1: *mut u32 = (GPIO_BASE + 0x9C) as *mut u32;

// --- BCM2835 SDHOST Base Address ---
const SDHOST_BASE: usize = 0x3F20_2000;

const SDCMD:  *mut u32 = SDHOST_BASE as *mut u32;
const SDARG:  *mut u32 = (SDHOST_BASE + 0x04) as *mut u32;
const SDTOUT: *mut u32 = (SDHOST_BASE + 0x08) as *mut u32;
const SDCDIV: *mut u32 = (SDHOST_BASE + 0x0C) as *mut u32;
const SDRSP0: *mut u32 = (SDHOST_BASE + 0x10) as *mut u32;
const SDRSP1: *mut u32 = (SDHOST_BASE + 0x14) as *mut u32;
const SDRSP2: *mut u32 = (SDHOST_BASE + 0x18) as *mut u32;
const SDRSP3: *mut u32 = (SDHOST_BASE + 0x1C) as *mut u32;
const SDHSTS: *mut u32 = (SDHOST_BASE + 0x20) as *mut u32;
const SDVDD:  *mut u32 = (SDHOST_BASE + 0x30) as *mut u32;
const SDEDM:  *mut u32 = (SDHOST_BASE + 0x34) as *mut u32;
const SDHCFG: *mut u32 = (SDHOST_BASE + 0x38) as *mut u32;
/// 1 ブロックあたりのバイト数（512）。
const SDHBCT: *mut u32 = (SDHOST_BASE + 0x3C) as *mut u32;
const SDDATA: *mut u32 = (SDHOST_BASE + 0x40) as *mut u32;
/// 転送ブロック数。
/// 【2026-07-26】従来この定義自体が存在せず、ブロック数を `SDHBCT` の
/// 上位ビットへ詰め込んで書いていた（`512 | (1 << 16)`）。BCM2835 SDHOST では
/// バイト数(SDHBCT 0x3C)とブロック数(SDHBLC 0x50)は**別レジスタ**であり、
/// SDHBLC が 0 のままではコントローラが転送すべきブロック数を知り得ないため
/// データ転送が開始されない。コマンド応答は正常なのに読み書きだけが
/// 成立しなかった原因の一つ。
const SDHBLC: *mut u32 = (SDHOST_BASE + 0x50) as *mut u32;

// --- SDCMD bits (BCM2835 SDHOST) ---
//
// 【2026-07-26 重大バグ修正】レスポンス種別のビット定義が実機の仕様と
// 食い違っており、**全コマンドが誤った種別で発行されていた**。
// BCM2835 SDHOST の SDCMD レジスタでは
//   0x400 = NO_RESPONSE（応答なし）
//   0x200 = LONG_RESPONSE（136bit 応答）
//   48bit 応答は「フラグを立てない(0)」
// が正しい。従来の定義は
//   RESP_NONE=0x000 / RESP_48=0x200 / RESP_136=0x400
// と 3 つとも取り違えていたため、
//   * CMD8/CMD55/ACMD41 等の 48bit 応答コマンド → LONG_RESPONSE として発行され、
//     来るはずのない 136bit 応答を待って失敗する
//   * CMD0（応答なし）→ 48bit 応答を期待して待ってしまう
//   * CMD2/CMD9（本当の 136bit）→ NO_RESPONSE として発行され応答を取り込めない
// という状態だった。起動時に必ず出ていた
// `SDHOST: Card initialization failed (ACMD41 timeout)` の直接原因。
// （定義は Linux の `drivers/mmc/host/bcm2835-sdhost.c` と同じ）
const SDCMD_NEW_CMD: u32 = 0x8000;
const SDCMD_FAIL_ERROR: u32 = 0x4000;
const SDCMD_BUSYWAIT: u32 = 0x0800;
const SDCMD_NO_RESPONSE: u32 = 0x0400;
const SDCMD_LONG_RESPONSE: u32 = 0x0200;
/// データ書き込みを伴うコマンド。従来 `0x8000` と定義されており
/// `SDCMD_NEW_CMD` と衝突していたため、**書き込みビットが一度も立って
/// いなかった**（CMD24 が書き込みとして扱われない）。正しくは 0x80。
const SDCMD_WRITE: u32 = 0x0080;
/// データ読み出しを伴うコマンド（CMD17 等）。従来まったく指定されていなかった。
const SDCMD_READ: u32 = 0x0040;

// `send_command` の `resp_type` 引数として渡すレスポンス種別。
const SDCMD_RESP_NONE: u32 = SDCMD_NO_RESPONSE;
const SDCMD_RESP_48: u32 = 0x0000;
const SDCMD_RESP_136: u32 = SDCMD_LONG_RESPONSE;

// --- SDHCFG bits (BCM2835 SDHOST HOST CONFIG) ---
const SDHCFG_REL_CMD_LINE: u32 = 0x0001;
/// 内部バス（FIFO 側）を広幅で扱う。常に立てる。
const SDHCFG_WIDE_INT_BUS: u32 = 0x0002;
/// 外部バス（カードとの DAT 線）を 4bit で扱う。ACMD6 で 4bit へ切り替えたら
/// **必ずこちらも立てる**こと。片方だけだとデータ転送が成立しない。
const SDHCFG_WIDE_EXT_BUS: u32 = 0x0004;
const SDHCFG_SLOW_CARD: u32 = 0x0008;
const SDHCFG_DATA_IRPT_EN: u32 = 0x0010;

// --- SDEDM bits (BCM2835 SDHOST Extended Data Mode) ---
const SDEDM_WRITE_THRESHOLD_SHIFT: u32 = 9;
const SDEDM_READ_THRESHOLD_SHIFT: u32 = 14;
const SDEDM_THRESHOLD_MASK: u32 = 0x1F;
const FIFO_READ_THRESHOLD: u32 = 4;
const FIFO_WRITE_THRESHOLD: u32 = 4;

// --- SDHSTS bits ---
// 【2026-07-26 重大バグ修正】BCM2835 SDHOST の SDHSTS ビット割り当ては
//   bit0 FIFO_ERROR / bit1 CRC7_ERROR / bit2 CRC16_ERROR /
//   bit3 CMD_TIME_OUT / bit4 REW_TIME_OUT / bit5 SDIO_IRPT /
//   bit8 DATA_FLAG(FIFOにデータあり) / bit9 BLOCK_IRPT / bit10 BUSY_IRPT
// である。従来の定義は
//   FIFO_DATA=0x200 / FIFO_ERROR=0x008 / ERROR=0x078
// と誤っており、特に **「FIFO にデータがある」の判定に 0x200
// （実際はブロック転送完了割り込み）を使っていた**ため、読み出しループが
// データ到着を永久に検知できずタイムアウトしていた。コマンド応答は
// 正常に返るのに読み書きだけが成立しなかった直接の原因。
// また FIFO_ERROR として見ていた 0x008 は実際には CMD_TIME_OUT である。
const SDHSTS_FIFO_ERROR: u32 = 0x0001;
const SDHSTS_CRC7_ERROR: u32 = 0x0002;
const SDHSTS_CRC16_ERROR: u32 = 0x0004;
const SDHSTS_CMD_TIME_OUT: u32 = 0x0008;
const SDHSTS_REW_TIME_OUT: u32 = 0x0010;
/// FIFO にデータが存在する（読み出し可能／書き込み可能）。
const SDHSTS_DATA_FLAG: u32 = 0x0100;
const SDHSTS_BLOCK_IRPT: u32 = 0x0200;
const SDHSTS_BUSY: u32 = 0x0400;
/// エラー系ビットのマスク（タイムアウト・CRC・FIFO）。
const SDHSTS_ERROR: u32 = SDHSTS_FIFO_ERROR
    | SDHSTS_CRC7_ERROR
    | SDHSTS_CRC16_ERROR
    | SDHSTS_CMD_TIME_OUT
    | SDHSTS_REW_TIME_OUT;

// --- Globals ---
static SD_INITIALIZED: AtomicBool = AtomicBool::new(false);
static mut RCA: u32 = 0;
static mut CARD_SECTORS: usize = 0;

/// マイクロ秒単位の簡単なディレイ
fn delay_us(us: u32) {
    let start = crate::kernel::timer::get_system_time_us();
    while crate::kernel::timer::get_system_time_us() - start < us as u64 {
        core::hint::spin_loop();
    }
}

/// GPIO 48-53 を SDHOST (ALT0) に設定
fn setup_gpio() {
    unsafe {
        // GPFSEL4 (GPIO 40-49)
        // GPIO 48 (DAT0), GPIO 49 (DAT1) -> ALT0 (0b100)
        let mut fsel4 = core::ptr::read_volatile(GPFSEL4);
        fsel4 &= !(0b111 << 24); // clear 48
        fsel4 |= 0b100 << 24;  // set 48 to ALT0
        fsel4 &= !(0b111 << 27); // clear 49
        fsel4 |= 0b100 << 27;  // set 49 to ALT0
        core::ptr::write_volatile(GPFSEL4, fsel4);

        // GPFSEL5 (GPIO 50-53)
        // GPIO 50 (DAT2), 51 (DAT3), 52 (CLK), 53 (CMD) -> ALT0 (0b100)
        let mut fsel5 = core::ptr::read_volatile(GPFSEL5);
        for pin in 50..=53 {
            let shift = (pin - 50) * 3;
            fsel5 &= !(0b111 << shift);
            fsel5 |= 0b100 << shift;
        }
        core::ptr::write_volatile(GPFSEL5, fsel5);

        // プルアップ設定 (CMD, DAT0-3) とプルダウン設定 (CLK)
        core::ptr::write_volatile(GPPUD, 2); // Pull Up
        delay_us(10);
        core::ptr::write_volatile(GPPUDCLK1, (1 << (48 - 32)) | (1 << (49 - 32)) | (1 << (50 - 32)) | (1 << (51 - 32)) | (1 << (53 - 32)));
        delay_us(10);
        core::ptr::write_volatile(GPPUD, 0);
        core::ptr::write_volatile(GPPUDCLK1, 0);

        core::ptr::write_volatile(GPPUD, 1); // Pull Down
        delay_us(10);
        core::ptr::write_volatile(GPPUDCLK1, 1 << (52 - 32)); // CLK
        delay_us(10);
        core::ptr::write_volatile(GPPUD, 0);
        core::ptr::write_volatile(GPPUDCLK1, 0);
    }
}

/// SDHOST コントローラにコマンドを送信し、結果を待つ
fn send_command(cmd_idx: u32, arg: u32, resp_type: u32) -> Result<[u32; 4], &'static str> {
    unsafe {
        // 前のコマンド完了待ち
        let mut timeout = 100000;
        while (core::ptr::read_volatile(SDCMD) & SDCMD_NEW_CMD) != 0 {
            timeout -= 1;
            if timeout == 0 {
                return Err("SDHOST: send_command previous timeout");
            }
            core::hint::spin_loop();
        }

        // 引数とレスポンスクリア
        core::ptr::write_volatile(SDARG, arg);

        // コマンドレジスタへ書き込んで発行
        let cmd = (cmd_idx & 0x3F) | resp_type | SDCMD_NEW_CMD;
        core::ptr::write_volatile(SDCMD, cmd);

        // 発行完了とレスポンス準備完了待ち
        timeout = 100000;
        while (core::ptr::read_volatile(SDCMD) & SDCMD_NEW_CMD) != 0 {
            timeout -= 1;
            if timeout == 0 {
                return Err("SDHOST: command execution timeout");
            }
            core::hint::spin_loop();
        }

        let cmd_status = core::ptr::read_volatile(SDCMD);
        if (cmd_status & SDCMD_FAIL_ERROR) != 0 {
            return Err("SDHOST: command execution failed");
        }

        // レスポンス取得
        let mut resp = [0u32; 4];
        resp[0] = core::ptr::read_volatile(SDRSP0);
        if resp_type == SDCMD_RESP_136 {
            resp[1] = core::ptr::read_volatile(SDRSP1);
            resp[2] = core::ptr::read_volatile(SDRSP2);
            resp[3] = core::ptr::read_volatile(SDRSP3);
        }

        Ok(resp)
    }
}

/// SDHOST クロック分周器設定 (周波数変更用)
fn set_clock(hz: u32) {
    unsafe {
        // SDHOST コントローラの内部クロックは約 250MHz (QEMUではダミーだが実機対応)
        let host_clk = 250_000_000;
        let mut div = host_clk / hz;
        if div < 2 {
            div = 2;
        }
        // SDCDIV の設定値は (div / 2) - 1 もしくは簡易に
        let cdiv = if div >= 2 { (div / 2) - 1 } else { 0 };
        core::ptr::write_volatile(SDCDIV, cdiv & 0x7FF);
        delay_us(100);
    }
}

/// SDHOST および SDカードの初期化シーケンス
pub fn init() -> Result<(), &'static str> {
    if SD_INITIALIZED.load(Ordering::SeqCst) {
        return Ok(());
    }

    crate::info!("[SD] Initializing BCM2835 SDHOST controller...");

    setup_gpio();

    unsafe {
        // SDHOST のパワーON
        core::ptr::write_volatile(SDVDD, 1); // Power on VDD
        core::ptr::write_volatile(SDTOUT, 0xF00000); // タイムアウト値設定
        core::ptr::write_volatile(SDHSTS, 0x7F); // ステータスクリア
        core::ptr::write_volatile(SDHCFG, 0); // 初期設定クリア
    }

    // 初期化用低速クロック (400kHz)
    set_clock(400_000);

    // QEMU/実機での安定稼働のためのウェイト
    delay_us(10000);

    // CMD0: GO_IDLE_STATE
    let _ = send_command(0, 0, SDCMD_RESP_NONE);
    delay_us(5000);

    // CMD8: SEND_IF_COND (3.3V, check pattern 0xAA)
    let has_hc = match send_command(8, 0x1AA, SDCMD_RESP_48) {
        Ok(resp) => (resp[0] & 0xFF) == 0xAA,
        Err(_) => false,
    };

    // ACMD41: SD_SEND_OP_COND でカードがReadyになるまでポーリング
    let mut ocr = 0x0010_0000; // 3.2-3.3V support
    if has_hc {
        ocr |= 0x4000_0000; // HCS (High Capacity Support)
    }

    let mut ready = false;
    for _ in 0..100 {
        // ACMD は CMD55 -> CMD41 の順
        if send_command(55, 0, SDCMD_RESP_48).is_err() {
            continue;
        }
        if let Ok(resp) = send_command(41, ocr, SDCMD_RESP_48) {
            if (resp[0] & 0x8000_0000) != 0 {
                ready = true;
                ocr = resp[0];
                break;
            }
        }
        delay_us(10000);
    }

    if !ready {
        return Err("SDHOST: Card initialization failed (ACMD41 timeout)");
    }

    let is_sdhc = (ocr & 0x4000_0000) != 0;
    crate::info!("[SD] Card detected: SDHC={}", is_sdhc);

    // CMD2: ALL_SEND_CID
    let _cid = send_command(2, 0, SDCMD_RESP_136)?;

    // CMD3: SEND_RELATIVE_ADDR
    let resp3 = send_command(3, 0, SDCMD_RESP_48)?;
    let rca = resp3[0] & 0xFFFF_0000;
    unsafe {
        RCA = rca;
    }

    // CMD9: SEND_CSD (容量算出のためレジスタをパース)
    let csd = send_command(9, rca, SDCMD_RESP_136)?;
    parse_csd(csd)?;

    // CMD7: SELECT_CARD (カードを選択状態にしデータ通信を許可)
    let _ = send_command(7, rca, SDCMD_RESP_48)?;

    // CMD16: SET_BLOCKLEN (ブロック長を 512 バイトに設定)
    let _ = send_command(16, 512, SDCMD_RESP_48)?;

    // ACMD6: SET_BUS_WIDTH (4-bit バス幅に切り替え)
    let _ = send_command(55, rca, SDCMD_RESP_48)?;
    let _ = send_command(6, 2, SDCMD_RESP_48)?; // 2: 4-bit bus

    // データ転送用の高速クロック (25MHz) へ切り替え
    set_clock(25_000_000);

    // SDHOST ホスト設定レジスタ (SDHCFG) の設定。
    //
    // 【2026-07-26 重大バグ修正】従来は `0x12` を書いていた。BCM2835 SDHOST の
    // SDHCFG のビット割り当ては
    //   bit0 REL_CMD_LINE / bit1 WIDE_INT_BUS / bit2 WIDE_EXT_BUS /
    //   bit3 SLOW_CARD / bit4 DATA_IRPT_EN / bit5 SDIO_IRPT_EN /
    //   bit8 BLOCK_IRPT_EN / bit10 BUSY_IRPT_EN
    // であり、`0x12` は WIDE_INT_BUS + DATA_IRPT_EN を意味する
    // （コード内コメントの「bit4 = Slow Card / No DMA」は誤りで、
    //   SLOW_CARD は bit3、bit4 はデータ割り込み許可）。
    //
    // 問題は **WIDE_EXT_BUS (bit2) が立っていなかった**こと。直前の ACMD6 で
    // カード側は 4bit バス幅へ切り替えているのに、ホスト側は 1bit のままだった。
    // カードが 4 本の DAT 線で送出するデータをホストが 1 本しか読まないため、
    // コマンド応答は正常に返るのに**データ転送だけが成立しない**という状態に
    // なっていた（SDカードは初期化できるのに読み書きが全滅する症状の原因）。
    // 本ドライバはポーリング方式で割り込みハンドラを持たないため、
    // 割り込み許可ビットは立てない。
    unsafe {
        core::ptr::write_volatile(SDHCFG, SDHCFG_WIDE_INT_BUS | SDHCFG_WIDE_EXT_BUS);

        // SDEDM: FIFO のしきい値設定。
        // 【2026-07-26】本ドライバはこのレジスタを一度も設定していなかった。
        // SDHOST は FIFO のしきい値に達して初めて `SDHSTS_DATA_FLAG` を
        // 立てるため、しきい値が未設定（既定値が不定/0）だとデータ転送の
        // 準備完了が通知されない可能性がある。Linux の `bcm2835-sdhost.c`
        // と同じく read/write とも 4 に設定する。
        let mut edm = core::ptr::read_volatile(SDEDM);
        edm &= !((SDEDM_THRESHOLD_MASK << SDEDM_READ_THRESHOLD_SHIFT)
            | (SDEDM_THRESHOLD_MASK << SDEDM_WRITE_THRESHOLD_SHIFT));
        edm |= (FIFO_READ_THRESHOLD << SDEDM_READ_THRESHOLD_SHIFT)
            | (FIFO_WRITE_THRESHOLD << SDEDM_WRITE_THRESHOLD_SHIFT);
        core::ptr::write_volatile(SDEDM, edm);
    }

    SD_INITIALIZED.store(true, Ordering::SeqCst);
    unsafe {
        crate::info!("[SD] SDCard initialization success. Capacity: {} sectors ({} MiB)", CARD_SECTORS, (CARD_SECTORS * 512) / (1024 * 1024));
    }

    Ok(())
}

/// CSD (Card Specific Data) レジスタからカードセクタ数を取得
fn parse_csd(csd: [u32; 4]) -> Result<(), &'static str> {
    // 136ビットの CSD は 4つの 32ビットレジスタにまたがって格納される。
    // csd[0] = SDRSP0 (bits 127-96)
    // csd[1] = SDRSP1 (bits 95-64)
    // csd[2] = SDRSP2 (bits 63-32)
    // csd[3] = SDRSP3 (bits 31-0)
    //
    // CSD のバージョン確認 (SDRSP0 の bits 127-126, すなわち csd[0] の bits 31-30)
    let csd_structure = (csd[0] >> 30) & 0x3;

    if csd_structure == 1 {
        // CSD Version 2.0 (SDHC / SDXC)
        // C_SIZE は bits 69-48 に格納される。
        // これは SDRSP1 (bits 95-64) と SDRSP2 (bits 63-32) にまたがる。
        // SDRSP1 の bits 5-0 (csd[1] & 0x3F) -> C_SIZE の上位 6ビット
        // SDRSP2 の bits 31-16 (csd[2] >> 16) -> C_SIZE の下位 16ビット
        let c_size_upper = csd[1] & 0x3F;
        let c_size_lower = csd[2] >> 16;
        let c_size = (c_size_upper << 16) | c_size_lower;

        // 容量計算: (C_SIZE + 1) * 512 KB
        let capacity_kb = (c_size + 1) * 512;
        let sectors = (capacity_kb * 1024) / 512;
        unsafe {
            CARD_SECTORS = sectors as usize;
        }
    } else {
        // CSD Version 1.0 (標準容量 SD)
        // C_SIZE は bits 73-62、C_SIZE_MULT は bits 49-47
        let c_size = ((csd[1] & 0x3FF) << 2) | ((csd[2] >> 30) & 0x3);
        let c_size_mult = (csd[2] >> 15) & 0x7;
        let read_bl_len = csd[1] & 0xF;

        let mult = 1 << (c_size_mult + 2);
        let block_len = 1 << read_bl_len;
        let capacity_bytes = (c_size + 1) * mult * block_len;
        unsafe {
            CARD_SECTORS = (capacity_bytes / 512) as usize;
        }
    }

    Ok(())
}

/// 公開用ゲッター
pub fn get_total_sectors() -> usize {
    unsafe { CARD_SECTORS }
}

/// 1セクタ (512バイト) のポーリング読み込み
pub fn read_sector(lba: usize, buf: &mut [u8]) -> Result<(), &'static str> {
    if !SD_INITIALIZED.load(Ordering::SeqCst) {
        return Err("SDHOST: not initialized");
    }
    if buf.len() < 512 {
        return Err("SDHOST: read buffer too small");
    }

    unsafe {
        // 1. ブロックサイズおよびブロック数をホストコントローラに設定
        // バイト数とブロック数はそれぞれ専用レジスタへ設定する。
        core::ptr::write_volatile(SDHBCT, 512);
        core::ptr::write_volatile(SDHBLC, 1);

        // 2. 読込コマンド (CMD17) を送信
        // アドレス引数は、SDHCの場合はセクタ番号(LBA)、標準SDの場合はバイトアドレス
        let arg = lba as u32;
        // データ読み出しを伴うコマンドなので READ ビットを立てる
        // （従来は指定漏れで、コントローラがデータ転送と認識できなかった）。
        send_command(17, arg, SDCMD_RESP_48 | SDCMD_READ)?;

        // 3. FIFOからデータを 512バイト（32ビットワードで128回）読み出し
        let mut words_read = 0;
        let mut timeout = 500000;
        let buf_u32 = buf.as_mut_ptr() as *mut u32;

        while words_read < 128 {
            let hsts = core::ptr::read_volatile(SDHSTS);
            if (hsts & SDHSTS_DATA_FLAG) != 0 {
                let data = core::ptr::read_volatile(SDDATA);
                core::ptr::write_volatile(buf_u32.add(words_read), data);
                words_read += 1;
            } else if (hsts & SDHSTS_FIFO_ERROR) != 0 {
                return Err("SDHOST: FIFO error during read");
            } else {
                timeout -= 1;
                if timeout == 0 {
                    return Err("SDHOST: read timeout waiting for FIFO data");
                }
                core::hint::spin_loop();
            }
        }

        // コマンド転送完了までビジーチェック
        timeout = 100000;
        while (core::ptr::read_volatile(SDHSTS) & SDHSTS_BUSY) != 0 {
            timeout -= 1;
            if timeout == 0 {
                return Err("SDHOST: read busy timeout");
            }
            core::hint::spin_loop();
        }

        // エラーチェック
        let hsts = core::ptr::read_volatile(SDHSTS);
        if (hsts & SDHSTS_ERROR) != 0 {
            core::ptr::write_volatile(SDHSTS, SDHSTS_ERROR); // クリア
            return Err("SDHOST: read error flag set in host status");
        }
    }

    Ok(())
}

/// 1セクタ (512バイト) のポーリング書き込み
pub fn write_sector(lba: usize, buf: &[u8]) -> Result<(), &'static str> {
    if !SD_INITIALIZED.load(Ordering::SeqCst) {
        return Err("SDHOST: not initialized");
    }
    if buf.len() < 512 {
        return Err("SDHOST: write buffer too small");
    }

    unsafe {
        // 1. ブロックサイズおよびブロック数を設定
        core::ptr::write_volatile(SDHBCT, 512);
        core::ptr::write_volatile(SDHBLC, 1);

        // 2. 書込コマンド (CMD24) を送信
        let arg = lba as u32;
        send_command(24, arg, SDCMD_RESP_48 | SDCMD_WRITE)?;

        // 3. FIFOへデータを 512バイト（32ビットワードで128回）書き出し
        let mut words_written = 0;
        let mut timeout = 500000;
        let buf_u32 = buf.as_ptr() as *const u32;

        while words_written < 128 {
            let hsts = core::ptr::read_volatile(SDHSTS);
            if (hsts & SDHSTS_DATA_FLAG) != 0 {
                let data = core::ptr::read_volatile(buf_u32.add(words_written));
                core::ptr::write_volatile(SDDATA, data);
                words_written += 1;
            } else if (hsts & SDHSTS_FIFO_ERROR) != 0 {
                return Err("SDHOST: FIFO error during write");
            } else {
                timeout -= 1;
                if timeout == 0 {
                    return Err("SDHOST: write timeout waiting for FIFO space");
                }
                core::hint::spin_loop();
            }
        }

        // コマンドおよびフラッシュ完了待ち
        timeout = 100000;
        while (core::ptr::read_volatile(SDHSTS) & SDHSTS_BUSY) != 0 {
            timeout -= 1;
            if timeout == 0 {
                return Err("SDHOST: write busy timeout");
            }
            core::hint::spin_loop();
        }

        // エラーチェック
        let hsts = core::ptr::read_volatile(SDHSTS);
        if (hsts & SDHSTS_ERROR) != 0 {
            core::ptr::write_volatile(SDHSTS, SDHSTS_ERROR); // クリア
            return Err("SDHOST: write error flag set in host status");
        }
    }

    Ok(())
}