dma.c

Go to the documentation of this file.

 
#include <core/system.h>
#include <core/string.h>
#include <cpu/io.h>
#include <mm/mm.h>
#include <sys/sched.h>
#include <aquila/errno.h>
 
#include <ata.h>
 
/* the bus master's registers, from its base */
#define BM_CMD          0
#define BM_STATUS       2
#define BM_PRDT         4
 
#define BM_CMD_START    0x01
#define BM_CMD_READ     0x08    /* from the drive to memory */
 
#define BM_ST_ACTIVE    0x01
#define BM_ST_ERROR     0x02
#define BM_ST_IRQ       0x04
 
#define DMA_BUF_SIZE    (64 * 1024)
#define DMA_MAX_SECTORS (DMA_BUF_SIZE / 512)

struct prd {
    uint32_t addr;
    uint16_t size;      /* 0 is 64 KiB */
    uint16_t flags;
} __packed;
 
#define PRD_EOT         0x8000
 
/* each channel's descriptor and buffer, in the kernel image, so that their
 * physical address is LMA() */
static struct prd prdt[2] __aligned(16);
static char dma_buf[2][DMA_BUF_SIZE] __aligned(DMA_BUF_SIZE);

static int channel_index(struct ata_drive *drive)
{
    return drive->id / 2;
}

static void dma_complete(struct ata_channel *ch, uint8_t bm_status)
{
    ch->status = io_in8(&ch->base, ATA_REG_STATUS);
    ch->bm_status = bm_status;
    io_out8(&ch->bm, BM_STATUS, BM_ST_IRQ | BM_ST_ERROR);
    ch->done = 1;
}

void dma_irq(struct ata_channel *ch)
{
    uint8_t bm_status = ch->bm.addr ? io_in8(&ch->bm, BM_STATUS) : 0;
 
    /* not from a DMA transfer: reading the status acknowledges it */
    if (!(bm_status & BM_ST_IRQ)) {
        io_in8(&ch->base, ATA_REG_STATUS);
        return;
    }
 
    dma_complete(ch, bm_status);
    waitq_wakeup_nopoll(&ch->irq_wait);
}

static int dma_transfer(struct ata_drive *drive, uint64_t lba, size_t count, int write)
{
    struct ata_channel *ch = drive->channel;
    int c = channel_index(drive);
 
    prdt[c].addr  = (uint32_t) (uintptr_t) LMA(&dma_buf[c][0]);
    prdt[c].size  = (count * 512) & 0xFFFF;
    prdt[c].flags = PRD_EOT;
 
    /* stop the bus master, set the direction and the descriptor table,
     * and clear its interrupt and error bits */
    io_out8(&ch->bm, BM_CMD, write ? 0 : BM_CMD_READ);
    io_out32(&ch->bm, BM_PRDT, (uint32_t) (uintptr_t) LMA(&prdt[c]));
    io_out8(&ch->bm, BM_STATUS, BM_ST_IRQ | BM_ST_ERROR);
 
    ata_setup(drive, lba, count);
    ch->done = 0;
 
    if (drive->mode == ATA_MODE_LBA48)
        io_out8(&drive->base, ATA_REG_CMD, write ? ATA_CMD_WRITE_DMA_EXT : ATA_CMD_READ_DMA_EXT);
    else
        io_out8(&drive->base, ATA_REG_CMD, write ? ATA_CMD_WRITE_DMA : ATA_CMD_READ_DMA);
 
    io_out8(&ch->bm, BM_CMD, (write ? 0 : BM_CMD_READ) | BM_CMD_START);
 
    /* a process sleeps until the interrupt; before there are processes
     * (mounting the root, loading init at boot), the status is polled */
    while (!ch->done) {
        if (sched_running && curthread) {
            waitq_sleep_unint(&ch->irq_wait);
        } else {
            uint8_t bm_status = io_in8(&ch->bm, BM_STATUS);
 
            if (bm_status & BM_ST_IRQ)
                dma_complete(ch, bm_status);
        }
    }
 
    io_out8(&ch->bm, BM_CMD, 0);
 
    if ((ch->bm_status & BM_ST_ERROR) || (ch->status & (ATA_STATUS_ERR | ATA_STATUS_DF))) {
        printk("ata%d: DMA %s error, status 0x%x, bus master 0x%x\n", drive->id,
                write ? "write" : "read", ch->status, ch->bm_status);
        return -EIO;
    }
 
    return 0;
}

static ssize_t dma_read(struct ata_drive *drive, uint64_t lba, size_t count, void *buf)
{
    char *cbuf = buf;
 
    while (count) {
        size_t n = MIN(count, DMA_MAX_SECTORS);
        int err;
 
        if ((err = dma_transfer(drive, lba, n, 0)))
            return err;
 
        memcpy(cbuf, dma_buf[channel_index(drive)], n * 512);
 
        lba   += n;
        count -= n;
        cbuf  += n * 512;
    }
 
    return 0;
}

static ssize_t dma_write(struct ata_drive *drive, uint64_t lba, size_t count, void *buf)
{
    char *cbuf = buf;
 
    while (count) {
        size_t n = MIN(count, DMA_MAX_SECTORS);
        int err;
 
        memcpy(dma_buf[channel_index(drive)], cbuf, n * 512);
 
        if ((err = dma_transfer(drive, lba, n, 1)))
            return err;
 
        lba   += n;
        count -= n;
        cbuf  += n * 512;
    }
 
    return 0;
}

int dma_init(struct ata_drive *drive)
{
    if (!drive->channel->bm.addr || !(drive->capabilities & ATA_CAP_DMA))
        return -ENODEV;
 
    drive->read  = dma_read;
    drive->write = dma_write;
    return 0;
}