---

dma.c

Go to the documentation of this file.

/*!     \file drivers/dma/dma.c
 *      \brief DMA (Direct Memory Access) driver.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update: 2003-11-08
 *
 *      This driver is based on the Fabian Nunez DMA driver.
 *      The author can be reached by email at: <fabian@cs.uct.ac.za>.
 */

#include <const.h>

#include <arch/i386.h>
#include <arch/mem.h>
#include <arch/paging.h>

#include <kernel/kernel_map.h>
#include <kernel/kmalloc.h>
#include <kernel/task.h>

#include <kernel/dma.h>

// --- DMA transfers -------------------------------------------------- //

/** \ingroup Drivers
 *  \defgroup DMADriver DMA (Direct Memory Access) driver
 *  The DMA (Direct Memory Access) low level driver
 *  (based on i386-architecture).
 *  @{
 */

//! Definition of DMA channels.
static dma_channel_t dmainfo[] =
{
        { 0x87, 0x00, 0x01 },
        { 0x83, 0x02, 0x03 },
        { 0x81, 0x04, 0x05 },
        { 0x82, 0x06, 0x07 }
};

//! \brief Set up a DMA transfer between a device and memory.
//! \param channel The 8-bit channel number (0..3).
//! \param physaddr The physical address of the buffer.
//! \param length The size of the buffer.
//! \param read
//!     If it is #TRUE the transfer will be from memory to device,
//!     otherwise will be from device to memory.
void dma_xfer(unsigned channel, addr_t physaddr, size_t length, bool read)
{
        int page, offset;

        if (channel > 3) return;

        // calculate dma page and offset //
        page = physaddr >> 16;
        offset = physaddr & 0xFFFF;
        length -= 1;  // with dma, if you want k bytes, you ask for k-1 //

        disable();

        // set the mask bit for the channel //
        outportb(0x0A, channel | 0x04);

        // clear flipflop //
        outportb(0x0C, 0x00);

        // set DMA mode (write+single+r/w) //
        outportb(0x0B, (read ? 0x48 : 0x44) + channel);

        // set DMA page //
        outportb(dmainfo[channel].page, page);

        // set DMA offset //
        outportb(dmainfo[channel].offset, offset & 0xFF);  // low byte //
        outportb(dmainfo[channel].offset, offset >> 8);    // high byte //

        // set DMA length //
        outportb(dmainfo[channel].length, length & 0xFF);  // low byte //
        outportb(dmainfo[channel].length, length >> 8);    // high byte //

        // clear DMA mask bit //
        outportb(0x0A, channel);

        enable();
}

/** @} */ // end of DMADriver

// --- DMA memory allocator ------------------------------------------- //

/** \ingroup Memory
 *  \defgroup KDMAAllocator The DMA (Direct Memory Access) Allocator
 *  The allocator for the DMA memory area.
 *  @{
 */

//! The size of the DMA memory area.
#define DMA_MEMORY_DIM (DMA_MEMORY_END-DMA_MEMORY_START)

//! DMA free frames vector. It maps every frame into the DMA memory
//! area. On i386 we have to reserve the first 16MB of physical memory
//! to the DMA, because on the bus we have a 24-bit register dedicated
//! to the addressing (2^24=16MB).
/** \todo
 *      Yes I know! A vector is ugly... a bitmap should be much better.
 *      It requests some bit twiddling, but we can gain a lot of memory!
 *      Unfortunately for now I've not much time to spent here! :-(
 */
byte *dma_free_frames;

//! The DMA-memory frame is marked as free.
#define DMA_FREE_FRAME  0
//! The DMA-memory frame is marked as busy.
#define DMA_BUSY_FRAME  1

//! \brief Initialize the DMA memory allocator.
void dma_alloc_init()
{
        uint32_t i;
        extern dword *K_VIR_END;

        // Initialize the DMA free frames vector                        //
        dma_free_frames = kmalloc(DMA_MEMORY_DIM/PAGE_SIZE);
        memset(dma_free_frames, DMA_FREE_FRAME, DMA_MEMORY_DIM/PAGE_SIZE);

        // Set the kernel physical space busy                           //
        for (i=0; i<=(uint32_t)K_VIR_END-K_VIR_START; i+=PAGE_SIZE)
                dma_free_frames[K_PHYS_ADDR+i] = DMA_BUSY_FRAME;
}

//! \brief
//!     Return a pointer of \p len contiguous bytes into the
//!     DMA address space.
//! \param len The size of the buffer we want to allocate.
//! \return
//!     A pointer to the allocated buffer.
//! \note
//!     The pointer is the <b>physical address</b> of the buffer
//!     and not the <b>virtual address</b>!!!
//! \exception
//!     NULL Out of DMA memory area!
void *dma_phys_alloc(size_t len)
{
        dword i, j, ret;
        char flag=0;

        // len must be not null!                                        //
        if (!len) return(NULL);

        // Round up len to frames boundary                              //
        len = PAGE_ALIGN_UP(len);

        sched_enter_critical_region();

        // Search for a free dma page                                   //
        for(i=0; i<(DMA_MEMORY_DIM/PAGE_SIZE); i++)
        {
                if (dma_free_frames[i] == DMA_FREE_FRAME)
                {
                        // Found a free frame!                          //
                        // OK, now I require (len/PAGE_SIZE-1)          //
                        // others free frames                           //
                        for(j=1, flag=0; j<len/PAGE_SIZE; j++)
                        {
                                if (dma_free_frames[i+j] == DMA_BUSY_FRAME)
                                {
                                        // Nooo! Found a busy frame!    //
                                        flag = 1;
                                        break;
                                }
                        }
                        if (flag == 1)
                        {
                                // Not a valid contiguous free space.   //
                                // Continue after j position...         //
                                i += j;
                        }
                        else
                        {
                                // Found a valid contiguous free        //
                                // space, so mark it                    //
                                for(j=0; j<len/PAGE_SIZE; j++)
                                        dma_free_frames[i+j] = DMA_BUSY_FRAME;
                                break;
                        }
                }
        }
        // Check if we have found the free DMA location                 //
        if (flag == 0)
                // We found it!!!                                       //
                ret = (i * PAGE_SIZE + DMA_MEMORY_START);
        else
                // Not found!!!                                         //
                ret = NULL;

        sched_leave_critical_region();
        return((void *)ret);
}

//! \brief
//!     Free the DMA memory area from \p dma_start to \p dma_start+len
//!     address.
//! \param dma_start The beginning of the area to free.
//! \param len The size of the buffer to free.
//! \return
//!     \li #TRUE on success;
//!     \li #FALSE if an error occurs.
//! \note
//!     The \p dma_start address is the <b>physical address</b>
//!     of the buffer to free and not the <b>virtual address</b>!!!
bool dma_phys_free(size_t dma_start, size_t len)
{
        int i;

        if (!len) return(FALSE);

        // Round up len to frames boundary                              //
        len = PAGE_ALIGN_UP(len);

        if (
                (dma_start >= DMA_MEMORY_START) && (dma_start < DMA_MEMORY_END) &&
                ((dma_start + len) < DMA_MEMORY_END)
        )
        {
                sched_enter_critical_region();

                // Mark the DMA region as free                          //
                for(i=(dma_start-DMA_MEMORY_START)/PAGE_SIZE; i<DMA_MEMORY_DIM/PAGE_SIZE; i++)
                        dma_free_frames[i] = DMA_FREE_FRAME;

                sched_leave_critical_region();

                return(TRUE);
        }
        else
                // Invalid DMA memory range                             //
                return(FALSE);
}

/** @} */ // end of KDMAAllocator

---