/*
 * Copyright 2020, Jérôme Duval, jerome.duval@gmail.com.
 * Distributed under the terms of the MIT License.
 */


#include "I2CPrivate.h"


I2CDevice::I2CDevice(device_node *node, I2CBus* bus, i2c_addr slaveAddress)
        :
        fNode(node),
        fBus(bus),
        fSlaveAddress(slaveAddress)
{
        CALLED();
}


I2CDevice::~I2CDevice()
{
}


status_t
I2CDevice::InitCheck()
{
        return B_OK;
}


status_t
I2CDevice::ExecCommand(i2c_op op, const void *cmdBuffer,
        size_t cmdLength, void* dataBuffer, size_t dataLength)
{
        CALLED();
        return fBus->ExecCommand(op, fSlaveAddress, cmdBuffer, cmdLength,
                dataBuffer, dataLength);
}


status_t
I2CDevice::AcquireBus()
{
        CALLED();
        return fBus->AcquireBus();
}


void
I2CDevice::ReleaseBus()
{
        CALLED();
        fBus->ReleaseBus();
}


static status_t
i2c_init_device(device_node *node, void **_device)
{
        CALLED();
        I2CBus* bus;

        {
                device_node *parent = gDeviceManager->get_parent_node(node);
                gDeviceManager->get_driver(parent, NULL, (void **)&bus);
                gDeviceManager->put_node(parent);
        }

        uint16 slaveAddress;
        if (gDeviceManager->get_attr_uint16(node, I2C_DEVICE_SLAVE_ADDR_ITEM,
                &slaveAddress, false) != B_OK) {
                return B_ERROR;
        }


        I2CDevice *device = new(std::nothrow) I2CDevice(node, bus, slaveAddress);
        if (device == NULL)
                return B_NO_MEMORY;

        status_t result = device->InitCheck();
        if (result != B_OK) {
                ERROR("failed to set up i2c device object\n");
                return result;
        }

        *_device = device;

        return B_OK;
}


static void
i2c_uninit_device(void *_device)
{
        CALLED();
        I2CDevice *device = (I2CDevice *)_device;
        delete device;
}


static void
i2c_device_removed(void *_device)
{
        CALLED();
        //I2CDevice *device = (I2CDevice *)_device;
}


static status_t
i2c_exec_command(i2c_device _device, i2c_op op, const void *cmdBuffer,
        size_t cmdLength, void* dataBuffer, size_t dataLength)
{
        I2CDevice *device = (I2CDevice *)_device;
        return device->ExecCommand(op, cmdBuffer, cmdLength, dataBuffer, dataLength);
}


static status_t
i2c_acquire_bus(i2c_device _device)
{
        I2CDevice *device = (I2CDevice *)_device;
        return device->AcquireBus();
}


static void
i2c_release_bus(i2c_device _device)
{
        I2CDevice *device = (I2CDevice *)_device;
        return device->ReleaseBus();
}


static status_t
std_ops(int32 op, ...)
{
        switch (op) {
                case B_MODULE_INIT:
                {
                        // Link to I2C bus.
                        // I2C device driver must have I2C bus loaded, but it calls its
                        // functions directly instead via official interface, so this
                        // pointer is never read.
                        module_info *dummy;
                        return get_module(I2C_BUS_MODULE_NAME, &dummy);
                }
                case B_MODULE_UNINIT:
                        return put_module(I2C_BUS_MODULE_NAME);

                default:
                        return B_ERROR;
        }
}


i2c_device_interface gI2CDeviceModule = {
        {
                {
                        I2C_DEVICE_MODULE_NAME,
                        0,
                        std_ops
                },

                NULL,   // supported devices
                NULL,   // register node
                i2c_init_device,
                (void (*)(void *)) i2c_uninit_device,
                NULL,   // register child devices
                NULL,   // rescan
                (void (*)(void *)) i2c_device_removed
        },
        i2c_exec_command,
        i2c_acquire_bus,
        i2c_release_bus,
};