/*
 * Copyright 2014, Ithamar R. Adema <ithamar@upgrade-android.com>
 * All rights reserved. Distributed under the terms of the MIT License.
 *
 * Copyright 2015-2022, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include <drivers/bus/FDT.h>
#include <KernelExport.h>
#include <util/kernel_cpp.h>
#include <util/Vector.h>
#include <device_manager.h>

#include <AutoDeleter.h>
#include <AutoDeleterDrivers.h>
#include <HashMap.h>
#include <debug.h>

extern "C" {
#include <libfdt_env.h>
#include <fdt.h>
#include <libfdt.h>
};


//#define TRACE_FDT
#ifdef TRACE_FDT
#define TRACE(x...) dprintf(x)
#else
#define TRACE(x...)
#endif


#define GIC_INTERRUPT_CELL_TYPE     0
#define GIC_INTERRUPT_CELL_ID       1
#define GIC_INTERRUPT_CELL_FLAGS    2
#define GIC_INTERRUPT_TYPE_SPI      0
#define GIC_INTERRUPT_TYPE_PPI      1
#define GIC_INTERRUPT_BASE_SPI      32
#define GIC_INTERRUPT_BASE_PPI      16


extern void* gFDT;

device_manager_info* gDeviceManager;

extern fdt_bus_module_info gBusModule;
extern fdt_device_module_info gDeviceModule;


//#pragma mark -


struct fdt_bus {
        device_node* node;
        HashMap<HashKey32<int32>, device_node*> phandles;
};


struct fdt_device {
        device_node* node;
        device_node* bus;
};


struct fdt_interrupt_map_entry {
        uint32_t childAddr;
        uint32_t childIrq;
        uint32_t parentIrqCtrl;
        uint32_t parentIrq;
};


struct fdt_interrupt_map {
        uint32_t childAddrMask;
        uint32_t childIrqMask;

        Vector<fdt_interrupt_map_entry> fInterruptMap;
};


static status_t
fdt_register_node(fdt_bus* bus, int node, device_node* parentDev,
        device_node*& curDev)
{
        TRACE("%s('%s', %p)\n", __func__, fdt_get_name(gFDT, node, NULL),
                parentDev);

        const void* prop; int propLen;
        Vector<device_attr> attrs;
        int nameLen = 0;
        const char *name = fdt_get_name(gFDT, node, &nameLen);

        if (name == NULL) {
                dprintf("%s ERROR: fdt_get_name: %s\n", __func__,
                        fdt_strerror(nameLen));
                return B_ERROR;
        }

        attrs.Add({ B_DEVICE_BUS, B_STRING_TYPE, {.string = "fdt"}});
        attrs.Add({ B_DEVICE_PRETTY_NAME, B_STRING_TYPE,
                { .string = (strcmp(name, "") != 0) ? name : "Root" }});
        attrs.Add({ "fdt/node", B_UINT32_TYPE, {.ui32 = (uint32)node}});
        attrs.Add({ "fdt/name", B_STRING_TYPE, {.string = name}});

        prop = fdt_getprop(gFDT, node, "device_type", &propLen);
        if (prop != NULL)
                attrs.Add({ "fdt/device_type", B_STRING_TYPE, { .string = (const char*)prop }});

        prop = fdt_getprop(gFDT, node, "compatible", &propLen);

        if (prop != NULL) {
                const char* propStr = (const char*)prop;
                const char* propEnd = propStr + propLen;
                while (propEnd - propStr > 0) {
                        int curLen = strlen(propStr);
                        attrs.Add({ "fdt/compatible", B_STRING_TYPE, { .string = propStr }});
                        propStr += curLen + 1;
                }
        }

        attrs.Add({});

        status_t res = gDeviceManager->register_node(parentDev,
                "bus_managers/fdt/driver_v1", &attrs[0], NULL, &curDev);

        if (res < B_OK)
                return res;

        prop = fdt_getprop(gFDT, node, "phandle", &propLen);

        if (prop != NULL)
                bus->phandles.Put(fdt32_to_cpu(*(uint32_t*)prop), curDev);

        return B_OK;
}


static void
fdt_traverse(fdt_bus* bus, int &node, int &depth, device_node* parentDev)
{
        int curDepth = depth;
#if 0
        for (int i = 0; i < depth; i++) dprintf("  ");
        dprintf("node('%s')\n", fdt_get_name(gFDT, node, NULL));
#endif
        device_node* curDev;
        fdt_register_node(bus, node, parentDev, curDev);

        node = fdt_next_node(gFDT, node, &depth);
        while (node >= 0 && depth == curDepth + 1) {
                fdt_traverse(bus, node, depth, curDev);
        }
}


//#pragma mark bus

static int32
fdt_bus_std_ops(int32 op, ...)
{
        switch (op) {
                case B_MODULE_INIT:
                        TRACE("fdt root init\n");
                        return B_OK;

                case B_MODULE_UNINIT:
                        TRACE("fdt root uninit\n");
                        return B_OK;
        }

        return B_BAD_VALUE;
}


static float
fdt_bus_supports_device(device_node* parent)
{
        TRACE("fdt_bus_supports_device\n");

        // make sure parent is really device root
        const char* bus;
        if (gDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
                return B_ERROR;

        if (strcmp(bus, "root"))
                return 0.0;

        return 1.0;
}


static status_t
fdt_bus_register_device(device_node* parent)
{
        TRACE("+fdt_bus_register_device\n");
        struct ScopeExit {
                ScopeExit() {TRACE("-fdt_bus_register_device\n");}
        } scopeExit;

        device_attr attrs[] = {
                {B_DEVICE_PRETTY_NAME, B_STRING_TYPE, {.string = "FDT"}},
                {B_DEVICE_FLAGS, B_UINT32_TYPE, {.ui32 = B_KEEP_DRIVER_LOADED}},
                {}
        };

        return gDeviceManager->register_node(
                parent, "bus_managers/fdt/root/driver_v1", attrs, NULL, NULL);
}


static status_t
fdt_bus_init(device_node* node, void** cookie)
{
        TRACE("fdt_bus_init\n");

        if (gFDT == NULL) {
                TRACE("FDT is NULL!\n");
                return B_DEVICE_NOT_FOUND;
        }

        ObjectDeleter<fdt_bus> bus(new(std::nothrow) fdt_bus());
        if (!bus.IsSet())
                return B_NO_MEMORY;

        // gFDT is stored in kernel_args and will be freed, so copy it to kernel heap.
        size_t size = fdt_totalsize(gFDT);
        void* newFDT = malloc(size);
        if (newFDT == NULL)
                return B_NO_MEMORY;

        memcpy(newFDT, gFDT, size);
        gFDT = newFDT;

        bus->node = node;
        *cookie = bus.Detach();
        return B_OK;
}


static void
fdt_bus_uninit(void* cookie)
{
        TRACE("fdt_bus_uninit\n");

        ObjectDeleter<fdt_bus> bus((fdt_bus*)cookie);
}


static status_t
fdt_bus_register_child_devices(void* cookie)
{
        TRACE("fdt_bus_register_child_devices\n");

        fdt_bus* bus = (fdt_bus*)cookie;

        status_t res = gDeviceManager->publish_device(bus->node, "bus/fdt/blob",
                "bus_managers/fdt/device/v1");
        if (res < B_OK)
                return res;

        int node = -1, depth = -1;
        node = fdt_next_node(gFDT, node, &depth);
        fdt_traverse(bus, node, depth, bus->node);

        return B_OK;
}


device_node*
fdt_bus_node_by_phandle(fdt_bus* bus, int phandle)
{
        ASSERT(bus != NULL);

        device_node** devNode;
        if (!bus->phandles.Get(phandle, devNode))
                return NULL;

        return *devNode;
}


//#pragma mark device


static status_t
fdt_device_std_ops(int32 op, ...)
{
        switch (op) {
                case B_MODULE_INIT:
                case B_MODULE_UNINIT:
                        return B_OK;
        }

        return B_BAD_VALUE;
}


static status_t
fdt_device_init_driver(device_node* node, void** cookie)
{
        TRACE("fdt_device_init_driver()\n");

        ObjectDeleter<fdt_device> dev(new(std::nothrow) fdt_device());
        if (!dev.IsSet())
                return B_NO_MEMORY;

        dev->node = node;

        // get bus from parent node
        DeviceNodePutter<&gDeviceManager> parent(
                gDeviceManager->get_parent_node(node));
        driver_module_info* parentModule;
        void* parentDev;
        ASSERT(gDeviceManager->get_driver(
                parent.Get(), &parentModule, &parentDev) >= B_OK);
        if (parentModule == (driver_module_info*)&gDeviceModule)
                dev->bus = ((fdt_device*)parentDev)->bus;
        else if (parentModule == (driver_module_info*)&gBusModule)
                dev->bus = parent.Get();
        else
                panic("bad parent node");

        *cookie = dev.Detach();
        return B_OK;
}


static void
fdt_device_uninit_driver(void* cookie)
{
        TRACE("fdt_device_uninit_driver()\n");
        ObjectDeleter<fdt_device> dev((fdt_device*)cookie);
}


static status_t
fdt_device_register_child_devices(void* cookie)
{
        TRACE("fdt_device_register_child_devices()\n");
        return B_OK;
}


static device_node*
fdt_device_get_bus(fdt_device* dev)
{
        ASSERT(dev != NULL);
        return dev->bus;
}


static const char*
fdt_device_get_name(fdt_device* dev)
{
        ASSERT(dev != NULL);

        uint32 fdtNode;
        ASSERT(gDeviceManager->get_attr_uint32(
                dev->node, "fdt/node", &fdtNode, false) >= B_OK);

        return fdt_get_name(gFDT, (int)fdtNode, NULL);
}


static const void*
fdt_device_get_prop(fdt_device* dev, const char* name, int* len)
{
        ASSERT(dev != NULL);

        uint32 fdtNode;
        ASSERT(gDeviceManager->get_attr_uint32(
                dev->node, "fdt/node", &fdtNode, false) >= B_OK);

        return fdt_getprop(gFDT, (int)fdtNode, name, len);
}


static uint32
fdt_get_address_cells(const void* fdt, int node)
{
        uint32 res = 2;

        int parent = fdt_parent_offset(fdt, node);
        if (parent < 0)
                return res;

        uint32 *prop = (uint32*)fdt_getprop(fdt, parent, "#address-cells", NULL);
        if (prop == NULL)
                return res;

        res = fdt32_to_cpu(*prop);
        return res;
}


static uint32
fdt_get_size_cells(const void* fdt, int node)
{
        uint32 res = 1;

        int parent = fdt_parent_offset(fdt, node);
        if (parent < 0)
                return res;

        uint32 *prop = (uint32*)fdt_getprop(fdt, parent, "#size-cells", NULL);
        if (prop == NULL)
                return res;

        res = fdt32_to_cpu(*prop);
        return res;
}


static bool
fdt_device_get_reg(fdt_device* dev, uint32 ord, uint64* regs, uint64* len)
{
        ASSERT(dev != NULL);

        uint32 fdtNode;
        ASSERT(gDeviceManager->get_attr_uint32(
                dev->node, "fdt/node", &fdtNode, false) >= B_OK);

        int propLen;
        const void* prop = fdt_getprop(gFDT, (int)fdtNode, "reg", &propLen);
        if (prop == NULL)
                return false;

        uint32 addressCells = fdt_get_address_cells(gFDT, fdtNode);
        uint32 sizeCells = fdt_get_size_cells(gFDT, fdtNode);
        size_t entrySize = 4 * (addressCells + sizeCells);

        if ((ord + 1) * entrySize > (uint32)propLen)
                return false;

        const void* addressPtr = (const uint8*)prop + ord * entrySize;
        const void* sizePtr = (const uint32*)addressPtr + addressCells;

        switch (addressCells) {
                case 1:
                        *regs = fdt32_to_cpu(*(const uint32*)addressPtr);
                        break;
                case 2:
                        *regs = fdt64_to_cpu(*(const uint64*)addressPtr);
                        break;
                default:
                        return false;
        }
        switch (sizeCells) {
                case 1:
                        *len = fdt32_to_cpu(*(const uint32*)sizePtr);
                        break;
                case 2:
                        *len = fdt64_to_cpu(*(const uint64*)sizePtr);
                        break;
                default:
                        return false;
        }

        return true;
}


static uint32
fdt_get_interrupt_parent(fdt_device* dev, int node)
{
        while (node >= 0) {
                uint32* prop;
                int propLen;
                prop = (uint32*)fdt_getprop(gFDT, node, "interrupt-parent", &propLen);
                if (prop != NULL && propLen == 4) {
                        return fdt32_to_cpu(*prop);
                }

                node = fdt_parent_offset(gFDT, node);
        }

        return 0;
}


static uint32
fdt_get_interrupt_cells(uint32 interrupt_parent_phandle)
{
        if (interrupt_parent_phandle > 0) {
                int node = fdt_node_offset_by_phandle(gFDT, interrupt_parent_phandle);
                if (node >= 0) {
                        uint32* prop;
                        int propLen;
                        prop  = (uint32*)fdt_getprop(gFDT, node, "#interrupt-cells", &propLen);
                        if (prop != NULL && propLen == 4) {
                                return fdt32_to_cpu(*prop);
                        }
                }
        }
        return 1;
}


static bool
fdt_device_get_interrupt(fdt_device* dev, uint32 index,
        device_node** interruptController, uint64* interrupt)
{
        ASSERT(dev != NULL);

        uint32 fdtNode;
        ASSERT(gDeviceManager->get_attr_uint32(
                dev->node, "fdt/node", &fdtNode, false) >= B_OK);

        int propLen;
        const uint32 *prop = (uint32*)fdt_getprop(gFDT, (int)fdtNode, "interrupts-extended",
                &propLen);
        if (prop == NULL) {
                uint32 interruptParent = fdt_get_interrupt_parent(dev, fdtNode);
                uint32 interruptCells = fdt_get_interrupt_cells(interruptParent);

                prop = (uint32*)fdt_getprop(gFDT, (int)fdtNode, "interrupts",
                        &propLen);
                if (prop == NULL)
                        return false;

                if ((index + 1) * interruptCells * sizeof(uint32) > (uint32)propLen)
                        return false;

                uint32 offset = interruptCells * index;
                uint32 interruptNumber = 0;

                if ((interruptCells == 1) || (interruptCells == 2)) {
                         interruptNumber = fdt32_to_cpu(*(prop + offset));
                } else if (interruptCells == 3) {
                        uint32 interruptType = fdt32_to_cpu(prop[offset + GIC_INTERRUPT_CELL_TYPE]);
                        interruptNumber = fdt32_to_cpu(prop[offset + GIC_INTERRUPT_CELL_ID]);

                        if (interruptType == GIC_INTERRUPT_TYPE_SPI)
                                interruptNumber += GIC_INTERRUPT_BASE_SPI;
                        else if (interruptType == GIC_INTERRUPT_TYPE_PPI)
                                interruptNumber += GIC_INTERRUPT_BASE_PPI;
                } else {
                        panic("unsupported interruptCells");
                }

                if (interrupt != NULL)
                        *interrupt = interruptNumber;

                if (interruptController != NULL && interruptParent != 0) {
                        fdt_bus* bus;
                        ASSERT(gDeviceManager->get_driver(dev->bus, NULL, (void**)&bus) >= B_OK);
                        *interruptController = fdt_bus_node_by_phandle(bus, interruptParent);
                }

                return true;
        }

        if ((index + 1) * 8 > (uint32)propLen)
                return false;

        if (interruptController != NULL) {
                uint32 phandle = fdt32_to_cpu(*(prop + 2 * index));

                fdt_bus* bus;
                ASSERT(gDeviceManager->get_driver(
                        dev->bus, NULL, (void**)&bus) >= B_OK);

                *interruptController = fdt_bus_node_by_phandle(bus, phandle);
        }

        if (interrupt != NULL)
                *interrupt = fdt32_to_cpu(*(prop + 2 * index + 1));

        return true;
}


static struct fdt_interrupt_map *
fdt_device_get_interrupt_map(struct fdt_device* dev)
{
        int fdtNode;
        ASSERT(gDeviceManager->get_attr_uint32(
                dev->node, "fdt/node", (uint32*)&fdtNode, false) >= B_OK);

        ObjectDeleter<struct fdt_interrupt_map> interrupt_map(new struct fdt_interrupt_map());

        int intMapMaskLen;
        const void* intMapMask = fdt_getprop(gFDT, fdtNode, "interrupt-map-mask",
                &intMapMaskLen);

        if (intMapMask == NULL || intMapMaskLen != 4 * 4) {
                dprintf("  interrupt-map-mask property not found or invalid\n");
                return NULL;
        }

        interrupt_map->childAddrMask = B_BENDIAN_TO_HOST_INT32(*((uint32*)intMapMask + 0));
        interrupt_map->childIrqMask = B_BENDIAN_TO_HOST_INT32(*((uint32*)intMapMask + 3));

        int intMapLen;
        const void* intMapAddr = fdt_getprop(gFDT, fdtNode, "interrupt-map", &intMapLen);
        if (intMapAddr == NULL) {
                dprintf("  interrupt-map property not found\n");
                return NULL;
        }

        int addressCells = 3;
        int interruptCells = 1;
        int phandleCells = 1;

        const void *property;

        property = fdt_getprop(gFDT, fdtNode, "#address-cells", NULL);
        if (property != NULL)
                addressCells = B_BENDIAN_TO_HOST_INT32(*(uint32*)property);

        property = fdt_getprop(gFDT, fdtNode, "#interrupt-cells", NULL);
        if (property != NULL)
                interruptCells = B_BENDIAN_TO_HOST_INT32(*(uint32*)property);

        uint32_t *it = (uint32_t*)intMapAddr;
        while ((uint8_t*)it - (uint8_t*)intMapAddr < intMapLen) {
                struct fdt_interrupt_map_entry irqEntry;

                irqEntry.childAddr = B_BENDIAN_TO_HOST_INT32(*it);
                it += addressCells;

                irqEntry.childIrq = B_BENDIAN_TO_HOST_INT32(*it);
                it += interruptCells;

                irqEntry.parentIrqCtrl = B_BENDIAN_TO_HOST_INT32(*it);
                it += phandleCells;

                int parentAddressCells = 0;
                int parentInterruptCells = 1;

                int interruptParent = fdt_node_offset_by_phandle(gFDT, irqEntry.parentIrqCtrl);
                if (interruptParent >= 0) {
                        property = fdt_getprop(gFDT, interruptParent, "#address-cells", NULL);
                        if (property != NULL)
                                parentAddressCells = B_BENDIAN_TO_HOST_INT32(*(uint32*)property);

                        property = fdt_getprop(gFDT, interruptParent, "#interrupt-cells", NULL);
                        if (property != NULL)
                                parentInterruptCells = B_BENDIAN_TO_HOST_INT32(*(uint32*)property);
                }

                it += parentAddressCells;

                if ((parentInterruptCells == 1) || (parentInterruptCells == 2)) {
                        irqEntry.parentIrq = B_BENDIAN_TO_HOST_INT32(*it);
                } else if (parentInterruptCells == 3) {
                        uint32 interruptType = fdt32_to_cpu(it[GIC_INTERRUPT_CELL_TYPE]);
                        uint32 interruptNumber = fdt32_to_cpu(it[GIC_INTERRUPT_CELL_ID]);

                        if (interruptType == GIC_INTERRUPT_TYPE_SPI)
                                irqEntry.parentIrq = interruptNumber + GIC_INTERRUPT_BASE_SPI;
                        else if (interruptType == GIC_INTERRUPT_TYPE_PPI)
                                irqEntry.parentIrq = interruptNumber + GIC_INTERRUPT_BASE_PPI;
                        else
                                irqEntry.parentIrq = interruptNumber;
                }
                it += parentInterruptCells;

                interrupt_map->fInterruptMap.PushBack(irqEntry);
        }

        return interrupt_map.Detach();
}


static void
fdt_device_print_interrupt_map(struct fdt_interrupt_map* interruptMap)
{
        if (interruptMap == NULL)
                return;

        dprintf("interrupt_map_mask: 0x%08" PRIx32 ", 0x%08" PRIx32 "\n",
                interruptMap->childAddrMask, interruptMap->childIrqMask);
        dprintf("interrupt_map:\n");

        for (Vector<struct fdt_interrupt_map_entry>::Iterator it = interruptMap->fInterruptMap.Begin();
                it != interruptMap->fInterruptMap.End();
                it++) {

                dprintf("childAddr=0x%08" PRIx32 ", childIrq=%" PRIu32 ", parentIrqCtrl=%" PRIu32 ", parentIrq=%" PRIu32 "\n",
                        it->childAddr, it->childIrq, it->parentIrqCtrl, it->parentIrq);
        }
}


static uint32
fdt_device_lookup_interrupt_map(struct fdt_interrupt_map* interruptMap, uint32 childAddr, uint32 childIrq)
{
        if (interruptMap == NULL)
                return 0xffffffff;

        childAddr &= interruptMap->childAddrMask;
        childIrq &= interruptMap->childIrqMask;

        for (Vector<struct fdt_interrupt_map_entry>::Iterator it = interruptMap->fInterruptMap.Begin();
                        it != interruptMap->fInterruptMap.End(); it++) {
                if ((it->childAddr == childAddr) && (it->childIrq == childIrq))
                        return it->parentIrq;
        }

        return 0xffffffff;
}


//#pragma mark devfs node


static status_t
fdt_devfs_node_read(void *cookie, off_t pos, void *buffer, size_t *_length)
{
        if (pos < 0)
                return B_BAD_VALUE;

        size_t size = fdt_totalsize(gFDT);
        if ((uint64)pos >= size) {
                *_length = 0;
                return B_OK;
        }
        size_t readSize = *_length;
        if (pos + readSize > size)
                readSize = size - pos;

        status_t res = user_memcpy(buffer, (uint8*)gFDT + pos, readSize);
        if (res < B_OK)
                return res;

        *_length = readSize;
        return B_OK;
}


//#pragma mark -

fdt_bus_module_info gBusModule = {
        {
                {
                        "bus_managers/fdt/root/driver_v1",
                        0,
                        fdt_bus_std_ops
                },
                fdt_bus_supports_device,
                fdt_bus_register_device,
                fdt_bus_init,
                fdt_bus_uninit,
                fdt_bus_register_child_devices,
                NULL,   // rescan devices
                NULL,   // device removed
        },
        fdt_bus_node_by_phandle,
};


fdt_device_module_info gDeviceModule = {
        {
                {
                        "bus_managers/fdt/driver_v1",
                        0,
                        fdt_device_std_ops
                },

                NULL,           // supports device
                NULL,           // register device (our parent registered us)
                fdt_device_init_driver,
                fdt_device_uninit_driver,
                fdt_device_register_child_devices,
                NULL,           // rescan devices
                NULL,           // device removed
        },
        fdt_device_get_bus,
        fdt_device_get_name,
        fdt_device_get_prop,
        fdt_device_get_reg,
        fdt_device_get_interrupt,
        fdt_device_get_interrupt_map,
        fdt_device_print_interrupt_map,
        fdt_device_lookup_interrupt_map,
};


device_module_info gDevfsNodeModule = {
        .info = {
                        .name = "bus_managers/fdt/device/v1"
        },
        .init_device = [](void *driverCookie, void **_deviceCookie) {
                *_deviceCookie = NULL;
                return B_OK;
        },
        .uninit_device = [](void *deviceCookie) {},
        .open = [](void *deviceCookie, const char *path, int openMode, void **_cookie) {
                return B_OK;
        },
        .close = [](void *cookie) {
                return B_OK;
        },
        .free = [](void *cookie) {
                return B_OK;
        },
        .read = fdt_devfs_node_read,
        .control = [](void *cookie, uint32 op, void *buffer, size_t length) {
                return B_DEV_INVALID_IOCTL;
        },
};


module_info* modules[] = {
        (module_info*)&gBusModule,
        (module_info*)&gDeviceModule,
        (module_info*)&gDevfsNodeModule,
        NULL
};

module_dependency module_dependencies[] = {
        { B_DEVICE_MANAGER_MODULE_NAME, (module_info**)&gDeviceManager },
        { NULL }
};