/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2008-2009, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "AbstractModuleDevice.h"

#include "IORequest.h"


AbstractModuleDevice::AbstractModuleDevice()
        :
        fNode(NULL),
        fInitialized(0),
        fDeviceModule(NULL),
        fDeviceData(NULL)
{
}


AbstractModuleDevice::~AbstractModuleDevice()
{
}


bool
AbstractModuleDevice::HasSelect() const
{
        return Module()->select != NULL;
}


bool
AbstractModuleDevice::HasDeselect() const
{
        return Module()->deselect != NULL;
}


bool
AbstractModuleDevice::HasRead() const
{
        return Module()->read != NULL;
}


bool
AbstractModuleDevice::HasWrite() const
{
        return Module()->write != NULL;
}


bool
AbstractModuleDevice::HasIO() const
{
        return Module()->io != NULL;
}


status_t
AbstractModuleDevice::Open(const char* path, int openMode, void** _cookie)
{
        return Module()->open(Data(), path, openMode, _cookie);
}


status_t
AbstractModuleDevice::_DoIO(void* cookie, off_t pos,
        void* buffer, size_t* _length, bool isWrite)
{
        IORequest request;
        status_t status = request.Init(pos, (addr_t)buffer, *_length, isWrite, 0);
        if (status != B_OK)
                return status;

        status = IO(cookie, &request);
        if (status != B_OK)
                return status;

        status = request.Wait(0, 0);
        *_length = request.TransferredBytes();
        return status;
}


status_t
AbstractModuleDevice::Read(void* cookie, off_t pos, void* buffer, size_t* _length)
{
        if (Module()->read == NULL) {
                if (Module()->io == NULL)
                        return BaseDevice::Read(cookie, pos, buffer, _length);

                return _DoIO(cookie, pos, buffer, _length, false);
        }
        return Module()->read(cookie, pos, buffer, _length);
}


status_t
AbstractModuleDevice::Write(void* cookie, off_t pos, const void* buffer, size_t* _length)
{
        if (Module()->write == NULL) {
                if (Module()->io == NULL)
                        return BaseDevice::Write(cookie, pos, buffer, _length);

                return _DoIO(cookie, pos, const_cast<void*>(buffer), _length, true);
        }
        return Module()->write(cookie, pos, buffer, _length);
}


status_t
AbstractModuleDevice::IO(void* cookie, io_request* request)
{
        if (Module()->io == NULL)
                return BaseDevice::IO(cookie, request);
        return Module()->io(cookie, request);
}


status_t
AbstractModuleDevice::Control(void* cookie, int32 op, void* buffer, size_t length)
{
        if (Module()->control == NULL)
                return BaseDevice::Control(cookie, op, buffer, length);
        return Module()->control(cookie, op, buffer, length);
}


status_t
AbstractModuleDevice::Select(void* cookie, uint8 event, selectsync* sync)
{
        if (Module()->select == NULL)
                return BaseDevice::Select(cookie, event, sync);
        return Module()->select(cookie, event, sync);
}


status_t
AbstractModuleDevice::Deselect(void* cookie, uint8 event, selectsync* sync)
{
        if (Module()->deselect == NULL)
                return BaseDevice::Deselect(cookie, event, sync);
        return Module()->deselect(cookie, event, sync);
}


status_t
AbstractModuleDevice::Close(void* cookie)
{
        return Module()->close(cookie);
}


status_t
AbstractModuleDevice::Free(void* cookie)
{
        return Module()->free(cookie);
}