dma.c

Go to the documentation of this file.

#include <sys/types.h>
#include <sys/io.h>
#include <stdio.h>
#include <stddef.h>

#include <dma.h>
#include <interrupt.h>

#include <list.h>

#define DMA_DISABLE(ch) do { \
        outb(dma_ctrl[(ch)>>2].single_mask, DMA_MASK_DISABLE_CH|(ch)); \
} while (0)

#define DMA_ENABLE(ch) do { \
        outb(dma_ctrl[(ch)>>2].single_mask, (ch)); \
} while (0)

#define DMA_RESET_PTR(ch) do { \
        outb(dma_ctrl[(ch) >> 2].byte_ptr, 0x00); \
} while (0)

#define DMA_SET_PAGE(ch, addr) do { \
        outb(dma_port[ch].page, (((addr) & 0x00FF0000) >> 16)); \
} while (0)

#define DMA_SET_ADDRESS(ch, addr) do { \
        outb(dma_port[ch].address, ((addr) & 0x000000FF)); \
        outb(dma_port[ch].address, ((addr) & 0x0000FF00) >> 8); \
} while (0)

#define DMA_SET_MODE(ch, mode) do { \
        outb(dma_ctrl[(ch)>>2].write_mode, (mode) | (ch)); \
} while (0)

#define DMA_SET_TX_SIZE(ch, cnt) do { \
        outb(dma_port[ch].count, ((unsigned short)(cnt) & 0x00FF)); \
        outb(dma_port[ch].count, ((unsigned short)(cnt) & 0xFF00) >> 8); \
} while (0)

#define DMA_CTRL_FROM_CH(ch) (((ch) >> 2) ? DMA_16BIT : DMA_8BIT)

static struct dma_ctrl_port_entry_t dma_ctrl[DMA_MAX_TYPE] = {
        {       
                .write_mode     = 0x0B,
                .single_mask    = 0x0A,
                .byte_ptr       = 0x0C,

                .status         = 0x08, 
                .command        = 0x08, 
                .request        = 0x09, 
                .intermediate   = 0x0D, 
                .dma_mask       = 0x0F, 
        },
        {       
                .write_mode     = 0xD6,
                .single_mask    = 0xD4,
                .byte_ptr       = 0xD8,

                .status         = 0xD0, 
                .command        = 0xD0, 
                .request        = 0xD2, 
                .intermediate   = 0xDA, 
                .dma_mask       = 0xDE, 
        },
};

static struct dma_port_entry_t dma_port[DMA_MAX_CHANNEL] = {
        {       
                .page           = 0x87,
                .address        = 0x00,
                .count          = 0x01,
        },
        {       
                .page           = 0x83,
                .address        = 0x02,
                .count          = 0x03,
        },
        {       
                .page           = 0x81,
                .address        = 0x04,
                .count          = 0x05,
        },
        {       
                .page           = 0x82,
                .address        = 0x06,
                .count          = 0x07,
        },

        {       
                .page           = 0x8F,
                .address        = 0xC0,
                .count          = 0xC2,
        },
        {       
                .page           = 0x8B,
                .address        = 0xC4,
                .count          = 0xC6,
        },
        {       
                .page           = 0x89,
                .address        = 0xC8,
                .count          = 0xCA,
        },
        {       
                .page           = 0x8A,
                .address        = 0xCC,
                .count          = 0xCE,
        },
};

struct dma_ctrl_port_entry_t *dma_get_ctrl_port(int type)
{
        if (type < 0 || type >= DMA_MAX_TYPE) {
                return NULL;
        }

        return dma_ctrl + type;
}

struct dma_port_entry_t *dma_get_port(int channel)
{
        if (channel < 0 || channel >= DMA_MAX_CHANNEL) {
                return NULL;
        }
        
        return dma_port + channel;
}

void dma_init(int ch, int mode, unsigned long address, int count)
{
        unsigned long flags;

        irq_local_save(&flags);
        DMA_DISABLE(ch);
        DMA_RESET_PTR(ch);

        DMA_SET_ADDRESS(ch, address);
        DMA_RESET_PTR(ch);

        DMA_SET_TX_SIZE(ch, count - 1);

        DMA_SET_MODE(ch, mode);
        DMA_SET_PAGE(ch, address);

        DMA_ENABLE(ch);
        irq_local_restore(flags);
}

int dma_is_done(int ch)
{
        unsigned char ret;

        ret = inb(dma_ctrl[DMA_CTRL_FROM_CH(ch)].status);
        return (ret & (0x01 << ch)) ? 0 : -1;
}

/* End of a file */