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


#include <new>
#include <stdio.h>
#include <string.h>

#include <ACPI.h>
#include <ByteOrder.h>
#include <condition_variable.h>

#include "pch_i2c.h"


struct {
        const char* name;
        pch_version version;
} pch_acpi_devices [] = {
        {"INT33C2", PCH_ATOM},
        {"INT33C3", PCH_ATOM},
        {"INT3332", PCH_ATOM},
        {"INT3433", PCH_ATOM},
        {"INT3442", PCH_ATOM},
        {"INT3443", PCH_ATOM},
        {"INT3444", PCH_ATOM},
        {"INT3445", PCH_ATOM},
        {"INT3446", PCH_ATOM},
        {"INT3447", PCH_ATOM},
        {"80860AAC", PCH_ATOM},
        {"80865AAC", PCH_ATOM},
        {"80860F41", PCH_ATOM},
        {"808662C1", PCH_ATOM},
        {"AMD0010", PCH_ATOM},
        {"AMDI0010", PCH_ATOM},
        {"AMDI0510", PCH_ATOM},
        {"APMC0D0F", PCH_EMAG},
        {NULL, PCH_NONE}
};

typedef struct {
        pch_i2c_sim_info info;
        acpi_device_module_info* acpi;
        acpi_device device;

} pch_i2c_acpi_sim_info;


static status_t
pch_i2c_acpi_set_powerstate(pch_i2c_acpi_sim_info* info, uint8 power)
{
        status_t status = info->acpi->evaluate_method(info->device,
                power == 1 ? "_PS0" : "_PS3", NULL, NULL);
        return status;
}



static acpi_status
pch_i2c_scan_parse_callback(ACPI_RESOURCE *res, void *context)
{
        struct pch_i2c_crs* crs = (struct pch_i2c_crs*)context;

        if (res->Type == ACPI_RESOURCE_TYPE_IRQ) {
                crs->irq = res->Data.Irq.Interrupts[0];
                crs->irq_triggering = res->Data.Irq.Triggering;
                crs->irq_polarity = res->Data.Irq.Polarity;
                crs->irq_shareable = res->Data.Irq.Shareable;
        } else if (res->Type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
                crs->irq = res->Data.ExtendedIrq.Interrupts[0];
                crs->irq_triggering = res->Data.ExtendedIrq.Triggering;
                crs->irq_polarity = res->Data.ExtendedIrq.Polarity;
                crs->irq_shareable = res->Data.ExtendedIrq.Shareable;
        } else if (res->Type == ACPI_RESOURCE_TYPE_FIXED_MEMORY32) {
                crs->addr_bas = res->Data.FixedMemory32.Address;
                crs->addr_len = res->Data.FixedMemory32.AddressLength;
        }

        return B_OK;
}


//      #pragma mark -


static status_t
acpi_scan_bus(i2c_bus_cookie cookie)
{
        CALLED();
        pch_i2c_acpi_sim_info* bus = (pch_i2c_acpi_sim_info*)cookie;

        bus->acpi->walk_namespace(bus->device, ACPI_TYPE_DEVICE, 1,
                pch_i2c_scan_bus_callback, NULL, bus, NULL);

        return B_OK;
}


static status_t
register_child_devices(void* cookie)
{
        CALLED();

        pch_i2c_acpi_sim_info* bus = (pch_i2c_acpi_sim_info*)cookie;
        device_node* node = bus->info.driver_node;

        char prettyName[25];
        sprintf(prettyName, "PCH I2C Controller");

        device_attr attrs[] = {
                // properties of this controller for i2c bus manager
                { B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
                        { .string = prettyName }},
                { B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
                        { .string = I2C_FOR_CONTROLLER_MODULE_NAME }},

                // private data to identify the device
                { NULL }
        };

        return gDeviceManager->register_node(node, PCH_I2C_SIM_MODULE_NAME,
                attrs, NULL, NULL);
}


static status_t
init_device(device_node* node, void** device_cookie)
{
        CALLED();
        status_t status = B_OK;

        pch_i2c_acpi_sim_info* bus = (pch_i2c_acpi_sim_info*)calloc(1,
                sizeof(pch_i2c_acpi_sim_info));
        if (bus == NULL)
                return B_NO_MEMORY;

        acpi_device_module_info* acpi;
        acpi_device device;
        {
                device_node* acpiParent = gDeviceManager->get_parent_node(node);
                gDeviceManager->get_driver(acpiParent, (driver_module_info**)&acpi,
                        (void**)&device);

                const char* name;
                if (gDeviceManager->get_attr_string(acpiParent, ACPI_DEVICE_HID_ITEM, &name, false)
                        == B_OK) {

                        size_t device = 0;

                        while (pch_acpi_devices[device].name) {
                                if (strcmp(name, pch_acpi_devices[device].name) == 0) {
                                        bus->info.version = pch_acpi_devices[device].version;
                                        break;
                                }
                                device++;
                        }
                }

                gDeviceManager->put_node(acpiParent);
        }

        bus->acpi = acpi;
        bus->device = device;
        bus->info.driver_node = node;
        bus->info.scan_bus = acpi_scan_bus;

        // Attach devices for I2C resources
        struct pch_i2c_crs crs;
        status = acpi->walk_resources(device, (ACPI_STRING)"_CRS",
                pch_i2c_scan_parse_callback, &crs);
        if (status != B_OK) {
                ERROR("Error while getting I2C devices\n");
                free(bus);
                return status;
        }
        if (crs.addr_bas == 0 || crs.addr_len == 0) {
                TRACE("skipping non configured I2C devices\n");
                free(bus);
                return B_BAD_VALUE;
        }

        bus->info.base_addr = crs.addr_bas;
        bus->info.map_size = crs.addr_len;
        bus->info.irq = crs.irq;

        pch_i2c_acpi_set_powerstate(bus, 1);

        *device_cookie = bus;
        return B_OK;
}


static void
uninit_device(void* device_cookie)
{
        pch_i2c_acpi_sim_info* bus = (pch_i2c_acpi_sim_info*)device_cookie;
        free(bus);
}


static status_t
register_device(device_node* parent)
{
        device_attr attrs[] = {
                {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "PCH I2C ACPI"}},
                {}
        };

        return gDeviceManager->register_node(parent,
                PCH_I2C_ACPI_DEVICE_MODULE_NAME, attrs, NULL, NULL);
}


static float
supports_device(device_node* parent)
{
        CALLED();
        const char* bus;

        // make sure parent is a PCH I2C ACPI device node
        if (gDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false)
                < B_OK) {
                return -1;
        }

        if (strcmp(bus, "acpi") != 0)
                return 0.0f;

        TRACE("found an acpi node\n");

        // check whether it's really a device
        uint32 device_type;
        if (gDeviceManager->get_attr_uint32(parent, ACPI_DEVICE_TYPE_ITEM,
                        &device_type, false) != B_OK
                || device_type != ACPI_TYPE_DEVICE) {
                return 0.0;
        }
        TRACE("found an acpi device\n");

        // check whether it's a PCH I2C device
        const char *name;
        if (gDeviceManager->get_attr_string(parent, ACPI_DEVICE_HID_ITEM, &name,
                false) != B_OK) {
                return 0.0;
        }
        TRACE("found an acpi device hid %s\n", name);

        size_t device = 0;

        while (pch_acpi_devices[device].name) {
                if (strcmp(name, pch_acpi_devices[device].name) == 0) {
                        TRACE("PCH I2C device found! name %s\n", name);
                        return 0.6f;
                }
                device++;
        }

        return 0.0f;
}


//      #pragma mark -


driver_module_info gPchI2cAcpiDevice = {
        {
                PCH_I2C_ACPI_DEVICE_MODULE_NAME,
                0,
                NULL
        },

        supports_device,
        register_device,
        init_device,
        uninit_device,
        register_child_devices,
        NULL,   // rescan
        NULL,   // device removed
};