입출력 방식

// I/O 포트 주소 (메모리 맵드 I/O 가정)
#define DISK_STATUS_REG  0xFF00  // 상태 레지스터 (read-only)
#define DISK_DATA_REG    0xFF04  // 데이터 레지스터
#define DISK_CMD_REG     0xFF08  // 커맨드 레지스터 (write-only)
#define CMD_READ         0x20    // 섹터 읽기 명령
#define CMD_READ_NEXT    0x21    // 다음 워드 전송 요청
#define STATUS_READY     0x02    // 데이터 준비 완료 비트

volatile uint32_t *status_reg = (volatile uint32_t *)DISK_STATUS_REG;
volatile uint32_t *data_reg   = (volatile uint32_t *)DISK_DATA_REG;
volatile uint32_t *cmd_reg    = (volatile uint32_t *)DISK_CMD_REG;

// Programmed I/O: CPU가 직접 폴링하며 대기
uint32_t pio_read_sector(uint32_t sector) {
    // 1. 커맨드 레지스터에 읽기 명령 전송 (상태 레지스터는 read-only)
    *cmd_reg = sector | CMD_READ;

    // 2. Busy-Wait: 완료 비트(READY)가 설정될 때까지 CPU가 반복 폴링
    //    '!BUSY'가 아니라 'READY 설정'을 검사 — 장치가 상태를 갱신하기 전에
    //    루프를 빠져나가는 경합(race)을 방지하기 위함
    while (!(*status_reg & STATUS_READY)) {
        /* spin — CPU 100% 점유, 다른 일 불가 */
    }

    // 3. 완료 후 데이터 직접 읽기
    return *data_reg;
}

// Interrupt-Driven I/O: 명령만 내리고 CPU는 다른 작업 수행
void irq_read_sector(uint32_t sector) {
    // 1. 커맨드 레지스터에 읽기 명령 전송
    *cmd_reg = sector | CMD_READ;

    // 2. CPU는 즉시 다른 작업으로 복귀 — 폴링(Busy-Wait)이 없음
    //    완료 통보는 인터럽트(ISR)가 담당
    do_other_work();
}

// ISR: 장치가 데이터 1워드를 준비할 때마다 인터럽트로 호출됨
void __attribute__((interrupt)) disk_isr() {
    uint32_t data = *data_reg;        // 데이터 복사를 CPU(ISR)가 직접 수행
    store_to_buffer(data);            // 수신 버퍼에 누적

    if (transfer_remaining()) {        // 받을 데이터가 더 남았으면
        *cmd_reg = CMD_READ_NEXT;        // 다음 워드 요청 → 또 인터럽트 발생
    } else {
        wake_up_waiting_process();      // 전송 완료 — 대기 프로세스 깨움
    }
    eoi();                            // End of Interrupt 신호

    // 주의: 섹터(예: 128워드)당 인터럽트가 워드 수만큼 발생한다.
    //       폴링 낭비는 없앴지만 전송 단위마다 CPU가 개입하므로
    //       대용량 전송에서는 인터럽트+복사 오버헤드가 누적된다 → DMA의 동기
}

#define DMA_SRC_REG   0xFE00  // 소스 주소 레지스터
#define DMA_DST_REG   0xFE04  // 목적지 주소 레지스터
#define DMA_LEN_REG   0xFE08  // 전송 길이 레지스터
#define DMA_CTRL_REG  0xFE0C  // 제어 레지스터 (START=0x1)

volatile uint32_t *dma_src  = (volatile uint32_t *)DMA_SRC_REG;
volatile uint32_t *dma_dst  = (volatile uint32_t *)DMA_DST_REG;
volatile uint32_t *dma_len  = (volatile uint32_t *)DMA_LEN_REG;
volatile uint32_t *dma_ctrl = (volatile uint32_t *)DMA_CTRL_REG;

/**
 * DMA 전송 시작 — CPU는 주소/길이만 설정하고 즉시 반환
 * 실제 데이터 이동은 DMA 컨트롤러가 버스를 직접 제어해서 수행
 * 완료 시 DMA가 인터럽트를 발생시켜 CPU에 통보
 */
void dma_transfer(uint32_t src_phys, uint32_t dst_phys, size_t len) {
    *dma_src  = src_phys;  // 소스 물리 주소 설정
    *dma_dst  = dst_phys;  // 목적지 물리 주소 설정
    *dma_len  = len;       // 전송 바이트 수
    *dma_ctrl = 0x01;     // START 비트 — DMA 전송 시작

    // CPU는 여기서 즉시 반환 — DMA가 버스를 점유하며 전송 수행
    // CPU는 다른 프로세스 실행 가능
    schedule();           // 다른 프로세스에 CPU 양보
}

// DMA 완료 ISR
void __attribute__((interrupt)) dma_isr() {
    wake_up_waiting_process(); // 대기 중인 프로세스를 준비 큐로 이동
    eoi();
}

// 세 방식 CPU 개입 비교
// Programmed I/O : 전송 내내 CPU 100% 점유 (Busy-Wait)
// Interrupt-Driven: 폴링 낭비는 없으나 전송 단위(워드)마다 인터럽트+CPU 복사
//                   → 대용량일수록 인터럽트 오버헤드 누적
// DMA            : 설정 + 완료 인터럽트 1회만 CPU 개입 (전송 전체에 ~0%)
//                   단, 전송 중 버스 경합(Cycle Stealing) 주의