root/Whitix/trunk/memory/dma.c

#include <dma.h>
#include <fs/vfs.h>
#include <vmm.h>
#include <print.h>
#include <module.h>

#define ALIGN(n, a) ALIGN_MASK(n, a-1)
#define ALIGN_MASK(n, mask) (((n)+(mask)) & ~(mask))

void* DmaAllocConsistent(struct PciDevice* device, unsigned int size, DWORD* dmaAddr)
{
        void* ret;
        
        if (size > 4096)
        {
                KePrint("PciAllocConsistent: more than one page. TODO\n");
                return NULL;
        }
        
        ret = VirtMapPhysPage(0xC2000000, 0xD0000000, 3);
        
        *dmaAddr = VirtToPhys(ret);
        
        return ret;
}

SYMBOL_EXPORT(DmaAllocConsistent);

/* TODO: Have DmaPool cache. */

struct DmaPool* DmaPoolCreate(const char* name, unsigned int size, int align,
        int boundary)
{
        struct DmaPool* retVal;
        unsigned long allocation;
        
        if (!align)
                align = 1;
        /* align must be a power of two. */
        else if (align & (align - 1))
                return NULL;
                
        if (!size)
                return NULL;
        else if (size < 4)
                size = 4;
                
        if ((size % align))
                size = ALIGN(size, align);
                
        allocation = MAX(size, PAGE_SIZE);
                
        if (!boundary)
                boundary = allocation;
        else if ((boundary < size) || (boundary & (boundary - 1)))
                return NULL;
                
        retVal = (struct DmaPool*)MemAlloc(sizeof(struct DmaPool));
                
        INIT_LIST_HEAD(&retVal->pageList);
        retVal->name = name;
        retVal->size = size;
        retVal->boundary = boundary;
        retVal->allocation = allocation;
        
        return retVal;
}

SYMBOL_EXPORT(DmaPoolCreate);

static void DmaPoolPageInit(struct DmaPool* pool, struct DmaPage* page)
{
        unsigned int offset = 0;
        unsigned int boundNext = pool->boundary;
        
        do
        {
                unsigned int next = offset + pool->size;
                
                if (pool->size + next >= boundNext)
                {
                        next = boundNext;
                        boundNext += pool->boundary;
                }
                
                *(int*)(page->virtAddr + offset) = next;
                offset = next;
        } while (offset < pool->allocation);
}

static struct DmaPage* DmaPoolAllocPage(struct DmaPool* pool)
{
        struct DmaPage* page;
        
        page = (struct DmaPage*)MemAlloc(sizeof(struct DmaPage));

        ZeroMemory(page, sizeof(struct DmaPage));
        
        page->virtAddr = DmaAllocConsistent(NULL, pool->allocation, &page->dmaAddr);
        
        DmaPoolPageInit(pool, page);
        
        ListAdd(&page->next, &pool->pageList);
        page->inUse = 0;
        page->offset = 0;
        
        return page;
}

void* DmaPoolAlloc(struct DmaPool* pool, unsigned long* dmaAddr)
{
        unsigned long flags;
        struct DmaPage* page;
        void* retVal;
        int offset;
        
        IrqSaveFlags(flags);
                
        ListForEachEntry(page, &pool->pageList, next)
                if (page->offset < pool->allocation)
                        goto found;
        
        page = DmaPoolAllocPage(pool);
        
found:
        page->inUse++;
        offset = page->offset;
        page->offset = *(int*)(page->virtAddr + offset);
        retVal = page->virtAddr + offset;
        *dmaAddr = page->dmaAddr + offset;
                
        IrqRestoreFlags(flags);
        
        return retVal;
}

SYMBOL_EXPORT(DmaPoolAlloc);

void DmaPoolFree(struct DmaPool* pool, void* ptr)
{
}

SYMBOL_EXPORT(DmaPoolFree);

void DmaPoolDestroy(struct DmaPool* pool)
{
}

SYMBOL_EXPORT(DmaPoolDestroy);