---

dma.c File Reference

DMA (Direct Memory Access) driver. More...

#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>

Go to the source code of this file.

Defines
#define	DMA_MEMORY_DIM   (DMA_MEMORY_END-DMA_MEMORY_START)
	The size of the DMA memory area.
#define	DMA_FREE_FRAME   0
	The DMA-memory frame is marked as free.
#define	DMA_BUSY_FRAME   1
	The DMA-memory frame is marked as busy.
Functions
void	dma_xfer (unsigned channel, addr_t physaddr, size_t length, bool read)
	Set up a DMA transfer between a device and memory. Parameters: channel  The 8-bit channel number (0..3). physaddr  The physical address of the buffer. length  The size of the buffer. read  If it is TRUE the transfer will be from memory to device, otherwise will be from device to memory.
void	dma_alloc_init ()
	Initialize the DMA memory allocator.
void *	dma_phys_alloc (size_t len)
	Return a pointer of len contiguous bytes into the DMA address space. Parameters: len  The size of the buffer we want to allocate. Returns: A pointer to the allocated buffer. Note: The pointer is the physical address of the buffer and not the virtual address!!! Exceptions: NULL  Out of DMA memory area!
bool	dma_phys_free (size_t dma_start, size_t len)
	Free the DMA memory area from dma_start to dma_start+len address. Parameters: dma_start  The beginning of the area to free. len  The size of the buffer to free. Returns: TRUE on success; FALSE if an error occurs. Note: The dma_start address is the physical address of the buffer to free and not the virtual address!!!
Variables
dma_channel_t	dmainfo []
	Definition of DMA channels.
byte *	dma_free_frames
	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).

---

Detailed Description

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>.

Definition in file dma.c.

---

Function Documentation

void dma_alloc_init (    )

Initialize the DMA memory allocator. Definition at line 116 of file dma.c. { 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; }

void* dma_phys_alloc (  size_t    len )

Return a pointer of len contiguous bytes into the DMA address space. Parameters: len  The size of the buffer we want to allocate. Returns: A pointer to the allocated buffer. Note: The pointer is the physical address of the buffer and not the virtual address!!! Exceptions: NULL  Out of DMA memory area! Definition at line 141 of file dma.c. { 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); }

bool dma_phys_free (  size_t    dma_start, size_t    len )

Free the DMA memory area from dma_start to dma_start+len address. Parameters: dma_start  The beginning of the area to free. len  The size of the buffer to free. Returns: TRUE on success; FALSE if an error occurs. Note: The dma_start address is the physical address of the buffer to free and not the virtual address!!! Definition at line 210 of file dma.c. { 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); }

void dma_xfer (  unsigned    channel, addr_t    physaddr, size_t    length, bool    read )

Set up a DMA transfer between a device and memory. Parameters: channel  The 8-bit channel number (0..3). physaddr  The physical address of the buffer. length  The size of the buffer. read  If it is TRUE the transfer will be from memory to device, otherwise will be from device to memory. Definition at line 47 of file dma.c. { 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(); }

---