misc.cc

/*
 * Copyright (c) 2007 Kevin Wolf
 *
 * This program is free software. It comes without any warranty, to
 * the extent permitted by applicable law. You can redistribute it 
 * and/or modify it under the terms of the Do What The Fuck You Want 
 * To Public License, Version 2, as published by Sam Hocevar. See
 * http://sam.zoy.org/projects/COPYING.WTFPL for more details.
 */  

#include <stdbool.h>
#include <stddef.h>
#include "cdi-osdep.h"
#include "cdi/io.h"
#include "cdi/mem.h"
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/IrqHandler.h"
#include "pedigree/kernel/machine/IrqManager.h"
#include "pedigree/kernel/machine/Machine.h"
#include "pedigree/kernel/machine/types.h"
#include "pedigree/kernel/process/Semaphore.h"
#include "pedigree/kernel/process/Thread.h"
#include "pedigree/kernel/processor/MemoryRegion.h"
#include "pedigree/kernel/processor/PhysicalMemoryManager.h"
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/processor/ProcessorInformation.h"
#include "pedigree/kernel/processor/VirtualAddressSpace.h"
#include "pedigree/kernel/processor/state_forward.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/time/Time.h"
#include "pedigree/kernel/utilities/utility.h"

struct cdi_device;

class CdiIrqHandler : public IrqHandler {
        virtual bool irq(irq_id_t number, InterruptState &state);
};

static CdiIrqHandler cdi_irq_handler;

#define IRQ_COUNT           0x10

static void (*driver_irq_handler[IRQ_COUNT])(struct cdi_device*) = { NULL };
static struct cdi_device* driver_irq_device[IRQ_COUNT] = { NULL };
static Spinlock irqCountLock;
static Semaphore *driver_irq_count[IRQ_COUNT] = {0};
// static volatile uint8_t driver_irq_count[IRQ_COUNT] = { 0 };

bool CdiIrqHandler::irq(irq_id_t irq, InterruptState &state)
{
    if(driver_irq_count[irq])
    {
        irqCountLock.acquire();
        driver_irq_count[irq]->release();
        irqCountLock.release();
    }

    if (driver_irq_handler[irq]) {
        driver_irq_handler[irq](driver_irq_device[irq]);
    }

    return true;
}

extern "C" {

extern "C" EXPORTED_PUBLIC void cdi_register_irq(uint8_t irq, void (*handler)(struct cdi_device*),
    struct cdi_device* device)
{
    if (irq >= IRQ_COUNT) {
        // FIXME: Eigentlich sollte diese Funktion etwas weniger optimistisch
        // sein, und einen Rueckgabewert haben.
        return;
    }

    // Der Interrupt wurde schon mal registriert
    if (driver_irq_handler[irq]) {
        NOTICE("cdi: Versuch IRQ " << irq << " mehrfach zu registrieren");
        return;
    }

    if(driver_irq_count[irq])
        delete driver_irq_count[irq];
    driver_irq_count[irq] = new Semaphore(0);

    driver_irq_handler[irq] = handler;
    driver_irq_device[irq] = device;

    Machine::instance().getIrqManager()->registerIsaIrqHandler(irq, static_cast<IrqHandler*>(&cdi_irq_handler));
}

extern "C" EXPORTED_PUBLIC int cdi_reset_wait_irq(uint8_t irq)
{
    if (irq > IRQ_COUNT) {
        return -1;
    }

    if(driver_irq_count[irq])
    {
        irqCountLock.acquire();
        while(driver_irq_count[irq]->tryAcquire())
            driver_irq_count[irq]->release();
        irqCountLock.release();
        return 0;
    }

    return -1;
}

// Dummy-Callback fuer den timer_register-Aufruf in cdi_wait_irq
//static void wait_irq_dummy_callback(void) { }

extern "C" EXPORTED_PUBLIC int cdi_wait_irq(uint8_t irq, uint32_t timeout)
{
    if (irq > IRQ_COUNT) {
        return -1;
    }

    if (!driver_irq_handler[irq]) {
        return -2;
    }

    Semaphore *pSem;

    {
        LockGuard<Spinlock> lock(irqCountLock);

        pSem = driver_irq_count[irq];
        if(!pSem)
        {
            pSem = new Semaphore(0);
            driver_irq_count[irq] = pSem;
        }
    }

    if(pSem)
    {
        pSem->acquire(1, 0, timeout * 1000);
        if(Processor::information().getCurrentThread()->wasInterrupted())
            return -3;
        else
            return 0;
    }
    else
        return -2;
}
}

extern "C" EXPORTED_PUBLIC struct cdi_mem_area* cdi_mem_alloc(size_t size, cdi_mem_flags_t flags)
{

    MemoryRegion* region = new MemoryRegion("cdi");
    size_t pageSize = PhysicalMemoryManager::getPageSize();

    if(!PhysicalMemoryManager::instance().allocateRegion(
        *region, (size + (pageSize - 1)) / pageSize,
        PhysicalMemoryManager::continuous, VirtualAddressSpace::Write, -1))
    {
        WARNING("cdi: cdi_mem_alloc: couldn't allocate memory");
        delete region;
        return 0;
    }

    struct cdi_mem_area *ret = new struct cdi_mem_area;
    ret->size = size;
    ret->vaddr = region->virtualAddress();
    ret->paddr.num = 1;
    ret->paddr.items = new struct cdi_mem_sg_item;
    ret->paddr.items->start = region->physicalAddress();
    ret->paddr.items->size = size;
    ret->osdep.pMemRegion = reinterpret_cast<void*>(region);
    return ret;
}

extern "C" EXPORTED_PUBLIC struct cdi_mem_area* cdi_mem_map(uintptr_t paddr, size_t size)
{
    MemoryRegion* region = new MemoryRegion("cdi");
    size_t pageSize = PhysicalMemoryManager::getPageSize();

    if(!PhysicalMemoryManager::instance().allocateRegion(
        *region, (size + (pageSize - 1)) / pageSize,
        PhysicalMemoryManager::continuous, VirtualAddressSpace::Write,
        paddr))
    {
        WARNING("cdi: cdi_mem_map: couldn't allocate memory");
        delete region;
        return 0;
    }

    struct cdi_mem_area *ret = new struct cdi_mem_area;
    ret->size = size;
    ret->vaddr = region->virtualAddress();
    ret->paddr.num = 1;
    ret->paddr.items = new struct cdi_mem_sg_item;
    ret->paddr.items->start = region->physicalAddress();
    ret->paddr.items->size = size;
    ret->osdep.pMemRegion = reinterpret_cast<void*>(region);
    return ret;
}

extern "C" EXPORTED_PUBLIC void cdi_mem_free(struct cdi_mem_area* p)
{
    if(p)
    {
        MemoryRegion *mem = reinterpret_cast<MemoryRegion *>(p->osdep.pMemRegion);
        delete mem;
        delete p;
    }
}

extern "C" EXPORTED_PUBLIC struct cdi_mem_area* cdi_mem_require_flags(struct cdi_mem_area* p,
    cdi_mem_flags_t flags)
{
    // Pretend the memory area matches the given flags
    return p;
}

extern "C" EXPORTED_PUBLIC int cdi_mem_copy(struct cdi_mem_area* dest, struct cdi_mem_area* src)
{
    if(dest && src && dest->size == src->size)
    {
        if(dest->vaddr != src->vaddr)
            MemoryCopy(dest->vaddr, src->vaddr, src->size);
        return 0;
    }
    else
        return -1;
}

extern "C" EXPORTED_PUBLIC int cdi_ioports_alloc(uint16_t start, uint16_t count)
{
    // Not required in Pedigree drivers (ring0)
    return 0;
}

extern "C" EXPORTED_PUBLIC int cdi_ioports_free(uint16_t start, uint16_t count)
{
    // Not required in Pedigree drivers (ring0)
    return 0;
}

extern "C" EXPORTED_PUBLIC void cdi_sleep_ms(uint32_t ms)
{
    Semaphore sem(0);
    sem.acquire(1, 0, ms * 1000);
}

extern "C" EXPORTED_PUBLIC uint64_t cdi_elapsed_ms()
{
    return Time::getTimeNanoseconds();
}

extern "C" EXPORTED_PUBLIC uint8_t cdi_cmos_read(uint8_t index)
{
    cdi_outb(0x70, index);
    return cdi_inb(0x71);
}

extern "C" EXPORTED_PUBLIC void cdi_cmos_write(uint8_t index, uint8_t value)
{
    cdi_outb(0x70, index);
    cdi_outb(0x71, value);
}