/*
 * 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 <bus/PCI.h>


#include "pch_i2c.h"


struct {
	uint16 id;
	pch_version version;
} pch_pci_devices [] = {

	/* Unknown */
	{0x0aac, PCH_NONE},
	{0x0aae, PCH_NONE},
	{0x0ab0, PCH_NONE},
	{0x0ab2, PCH_NONE},
	{0x0ab4, PCH_NONE},
	{0x0ab6, PCH_NONE},
	{0x0ab8, PCH_NONE},
	{0x0aba, PCH_NONE},

	{0x1aac, PCH_NONE},
	{0x1aae, PCH_NONE},

	{0x1ab0, PCH_NONE},
	{0x1ab2, PCH_NONE},
	{0x1ab4, PCH_NONE},
	{0x1ab6, PCH_NONE},
	{0x1ab8, PCH_NONE},
	{0x1aba, PCH_NONE},

	{0x4b44, PCH_NONE},
	{0x4b45, PCH_NONE},
	{0x4b4b, PCH_NONE},
	{0x4b4c, PCH_NONE},
	{0x4b78, PCH_NONE},
	{0x4b79, PCH_NONE},
	{0x4b7a, PCH_NONE},
	{0x4b7b, PCH_NONE},

	{0x4dc5, PCH_NONE},
	{0x4dc6, PCH_NONE},
	{0x4de8, PCH_NONE},
	{0x4de9, PCH_NONE},
	{0x4dea, PCH_NONE},
	{0x4deb, PCH_NONE},

	{0x7a4c, PCH_NONE},
	{0x7a4d, PCH_NONE},
	{0x7a4e, PCH_NONE},
	{0x7a4f, PCH_NONE},
	{0x7a7c, PCH_NONE},
	{0x7a7d, PCH_NONE},
	
	{0x98c5, PCH_NONE},
	{0x98c6, PCH_NONE},
	{0x98e8, PCH_NONE},
	{0x98e9, PCH_NONE},
	{0x98ea, PCH_NONE},
	{0x98eb, PCH_NONE},

	{0xa2e0, PCH_NONE},
	{0xa2e1, PCH_NONE},
	{0xa2e2, PCH_NONE},
	{0xa2e3, PCH_NONE},

	/* Baytrail */
	{0x0f41, PCH_ATOM},
	{0x0f42, PCH_ATOM},
	{0x0f43, PCH_ATOM},
	{0x0f44, PCH_ATOM},
	{0x0f45, PCH_ATOM},
	{0x0f46, PCH_ATOM},
	{0x0f47, PCH_ATOM},

	/* Haswell */
	{0x9c61, PCH_HASWELL},
	{0x9c62, PCH_HASWELL},

	/* Braswell */
	{0x22c1, PCH_ATOM},
	{0x22c2, PCH_ATOM},
	{0x22c3, PCH_ATOM},
	{0x22c4, PCH_ATOM},
	{0x22c5, PCH_ATOM},
	{0x22c6, PCH_ATOM},
	{0x22c7, PCH_ATOM},

	/* Skylake */
	{0x9d60, PCH_SKYLAKE},
	{0x9d61, PCH_SKYLAKE},
	{0x9d62, PCH_SKYLAKE},
	{0x9d63, PCH_SKYLAKE},
	{0x9d64, PCH_SKYLAKE},
	{0x9d65, PCH_SKYLAKE},

	/* Kaby Lake */
	{0xa160, PCH_SKYLAKE},
	{0xa161, PCH_SKYLAKE},
	{0xa162, PCH_SKYLAKE}, // ?

	/* Apolo Lake */
	{0x5aac, PCH_APL},
	{0x5aae, PCH_APL},
	{0x5ab0, PCH_APL},
	{0x5ab2, PCH_APL},
	{0x5ab4, PCH_APL},
	{0x5ab6, PCH_APL},
	{0x5ab8, PCH_APL},
	{0x5aba, PCH_APL},

	/* Cannon Lake */
	{0x9dc5, PCH_CANNONLAKE},
	{0x9dc6, PCH_CANNONLAKE},
	{0x9de8, PCH_CANNONLAKE},
	{0x9de9, PCH_CANNONLAKE},
	{0x9dea, PCH_CANNONLAKE},
	{0x9deb, PCH_CANNONLAKE},
	{0xa368, PCH_CANNONLAKE},
	{0xa369, PCH_CANNONLAKE},
	{0xa36a, PCH_CANNONLAKE},
	{0xa36b, PCH_CANNONLAKE},

	/* Comet Lake */
	{0x02e8, PCH_CANNONLAKE},
	{0x02e9, PCH_CANNONLAKE},
	{0x02ea, PCH_CANNONLAKE},
	{0x02eb, PCH_CANNONLAKE},
	{0x02c5, PCH_CANNONLAKE},
	{0x02c6, PCH_CANNONLAKE},
	{0x06e8, PCH_CANNONLAKE},
	{0x06e9, PCH_CANNONLAKE},
	{0x06ea, PCH_CANNONLAKE},
	{0x06eb, PCH_CANNONLAKE},
	{0xa3e0, PCH_CANNONLAKE},
	{0xa3e1, PCH_CANNONLAKE},
	{0xa3e2, PCH_CANNONLAKE},
	{0xa3e3, PCH_CANNONLAKE},

	/* Ice Lake */
	{0x34e8, PCH_TIGERLAKE},
	{0x34e9, PCH_TIGERLAKE},
	{0x34ea, PCH_TIGERLAKE},
	{0x34eb, PCH_TIGERLAKE},
	{0x34c5, PCH_TIGERLAKE},
	{0x34c6, PCH_TIGERLAKE},

	/* Tiger Lake */
	{0x43d8, PCH_TIGERLAKE},
	{0x43e8, PCH_TIGERLAKE},
	{0x43e9, PCH_TIGERLAKE},
	{0x43ea, PCH_TIGERLAKE},
	{0x43eb, PCH_TIGERLAKE},
	{0x43ad, PCH_TIGERLAKE},
	{0x43ae, PCH_TIGERLAKE},
	{0xa0c5, PCH_SKYLAKE},
	{0xa0c6, PCH_SKYLAKE},
	{0xa0d8, PCH_SKYLAKE},
	{0xa0d9, PCH_SKYLAKE},
	{0xa0e8, PCH_SKYLAKE},
	{0xa0e9, PCH_SKYLAKE},
	{0xa0ea, PCH_SKYLAKE},
	{0xa0eb, PCH_SKYLAKE},

	/* Gemini Lake */
	{0x31ac, PCH_GEMINILAKE},
	{0x31ae, PCH_GEMINILAKE},
	{0x31b0, PCH_GEMINILAKE},
	{0x31b2, PCH_GEMINILAKE},
	{0x31b4, PCH_GEMINILAKE},
	{0x31b6, PCH_GEMINILAKE},
	{0x31b8, PCH_GEMINILAKE},
	{0x31ba, PCH_GEMINILAKE},

	/* Alder Lake */
	{0x51e8, PCH_TIGERLAKE},
	{0x51e9, PCH_TIGERLAKE},
	{0x51ea, PCH_TIGERLAKE},
	{0x51eb, PCH_TIGERLAKE},
	{0x51c5, PCH_TIGERLAKE},
	{0x51c6, PCH_TIGERLAKE},
	{0x51d8, PCH_TIGERLAKE},
	{0x51d9, PCH_TIGERLAKE},
	{0x7acc, PCH_TIGERLAKE},
	{0x7acd, PCH_TIGERLAKE},
	{0x7ace, PCH_TIGERLAKE},
	{0x7acf, PCH_TIGERLAKE},
	{0x7afc, PCH_TIGERLAKE},
	{0x7afd, PCH_TIGERLAKE},
	{0x54e8, PCH_TIGERLAKE},
	{0x54e9, PCH_TIGERLAKE},
	{0x54ea, PCH_TIGERLAKE},
	{0x54eb, PCH_TIGERLAKE},
	{0x54c5, PCH_TIGERLAKE},
	{0x54c6, PCH_TIGERLAKE},

	/* Meteor Lake */
	{0x7e50, PCH_TIGERLAKE},
	{0x7e51, PCH_TIGERLAKE},
	{0x7e78, PCH_TIGERLAKE},
	{0x7e79, PCH_TIGERLAKE},
	{0x7e7a, PCH_TIGERLAKE},
	{0x7e7b, PCH_TIGERLAKE},

	{0, PCH_NONE}
};

typedef struct {
	pch_i2c_sim_info info;
	pci_device_module_info* pci;
	pci_device* device;
	pch_i2c_irq_type irq_type;

	pci_info pciinfo;
} pch_i2c_pci_sim_info;


//	#pragma mark -


static status_t
pci_scan_bus(i2c_bus_cookie cookie)
{
	CALLED();
	pch_i2c_pci_sim_info* bus = (pch_i2c_pci_sim_info*)cookie;
	device_node *acpiNode = NULL;

	pci_info *pciInfo = &bus->pciinfo;

	// search ACPI I2C nodes for this device
	{
		device_node* deviceRoot = gDeviceManager->get_root_node();
		uint32 addr = (pciInfo->device << 16) | pciInfo->function;
		device_attr acpiAttrs[] = {
			{ B_DEVICE_BUS, B_STRING_TYPE, { .string = "acpi" }},
			{ ACPI_DEVICE_ADDR_ITEM, B_UINT32_TYPE, {.ui32 = addr}},
			{ NULL }
		};
		if (addr != 0 && gDeviceManager->find_child_node(deviceRoot, acpiAttrs,
				&acpiNode) != B_OK) {
			ERROR("init_bus() acpi device not found\n");
			return B_DEV_CONFIGURATION_ERROR;
		}
	}

	TRACE("init_bus() find_child_node() found %x %x %p\n",
		pciInfo->device, pciInfo->function, acpiNode);
	// TODO eventually check timings on acpi
	acpi_device_module_info *acpi;
	acpi_device	acpiDevice;
	if (gDeviceManager->get_driver(acpiNode, (driver_module_info **)&acpi,
		(void **)&acpiDevice) == B_OK) {
		// find out I2C device nodes
		acpi->walk_namespace(acpiDevice, 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_pci_sim_info* bus = (pch_i2c_pci_sim_info*)cookie;
	device_node* node = bus->info.driver_node;

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

	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_pci_sim_info* bus = (pch_i2c_pci_sim_info*)calloc(1,
		sizeof(pch_i2c_pci_sim_info));
	if (bus == NULL)
		return B_NO_MEMORY;

	pci_device_module_info* pci;
	pci_device* device;
	{
		device_node* pciParent = gDeviceManager->get_parent_node(node);
		gDeviceManager->get_driver(pciParent, (driver_module_info**)&pci,
			(void**)&device);
		gDeviceManager->put_node(pciParent);
	}

	bus->pci = pci;
	bus->device = device;
	bus->info.driver_node = node;
	bus->info.scan_bus = pci_scan_bus;

	pci_info *pciInfo = &bus->pciinfo;
	pci->get_pci_info(device, pciInfo);

	size_t dev = 0;
	while (pch_pci_devices[dev].id != 0) {
		if (pch_pci_devices[dev].id == pciInfo->device_id) {
			bus->info.version = pch_pci_devices[dev].version;
			break;
		}
		dev++;
	}

	bus->info.base_addr = pciInfo->u.h0.base_registers[0];
	bus->info.map_size = pciInfo->u.h0.base_register_sizes[0];
	if ((pciInfo->u.h0.base_register_flags[0] & PCI_address_type)
			== PCI_address_type_64) {
		bus->info.base_addr |= (uint64)pciInfo->u.h0.base_registers[1] << 32;
		bus->info.map_size |= (uint64)pciInfo->u.h0.base_register_sizes[1] << 32;
	}

	if (bus->info.base_addr == 0) {
		ERROR("PCI BAR not assigned\n");
		free(bus);
		return B_ERROR;
	}

	// enable power
	pci->set_powerstate(device, PCI_pm_state_d0);

	// enable bus master and memory
	uint16 pcicmd = pci->read_pci_config(device, PCI_command, 2);
	pcicmd |= PCI_command_master | PCI_command_memory;
	pci->write_pci_config(device, PCI_command, 2, pcicmd);

	// try MSI-X
	if (pci->get_msix_count(device) >= 1) {
		uint32 vector;
		if (pci->configure_msix(device, 1, &vector) == B_OK
			&& pci->enable_msix(device) == B_OK) {
			TRACE_ALWAYS("using MSI-X vector %" B_PRIu32 "\n", vector);
			bus->info.irq = vector;
			bus->irq_type = PCH_I2C_IRQ_MSI_X_SHARED;
		} else {
			ERROR("couldn't use MSI-X SHARED\n");
		}
	} else if (pci->get_msi_count(device) >= 1) {
		// try MSI
		uint32 vector;
		if (pci->configure_msi(device, 1, &vector) == B_OK
			&& pci->enable_msi(device) == B_OK) {
			TRACE_ALWAYS("using MSI vector %" B_PRIu32 "\n", vector);
			bus->info.irq = vector;
			bus->irq_type = PCH_I2C_IRQ_MSI;
		} else {
			ERROR("couldn't use MSI\n");
		}
	}
	if (bus->irq_type == PCH_I2C_IRQ_LEGACY) {
		bus->info.irq = pciInfo->u.h0.interrupt_line;
		if (bus->info.irq == 0xff)
			bus->info.irq = 0;

		TRACE_ALWAYS("using legacy interrupt %" B_PRIu32 "\n", bus->info.irq);
	}
	if (bus->info.irq == 0) {
		ERROR("PCI IRQ not assigned\n");
		status = B_ERROR;
		goto err;
	}

	*device_cookie = bus;
	return B_OK;

err:
	free(bus);
	return status;
}


static void
uninit_device(void* device_cookie)
{
	pch_i2c_pci_sim_info* bus = (pch_i2c_pci_sim_info*)device_cookie;
	if (bus->irq_type != PCH_I2C_IRQ_LEGACY) {
		bus->pci->disable_msi(bus->device);
		bus->pci->unconfigure_msi(bus->device);
	}
	free(bus);
}


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

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


static float
supports_device(device_node* parent)
{
	CALLED();
	const char* bus;
	uint16 vendorID, deviceID;

	// make sure parent is a PCH I2C PCI device node
	if (gDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false)
		< B_OK || gDeviceManager->get_attr_uint16(parent, B_DEVICE_VENDOR_ID,
				&vendorID, false) < B_OK
		|| gDeviceManager->get_attr_uint16(parent, B_DEVICE_ID, &deviceID,
				false) < B_OK) {
		return -1;
	}

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

	if (vendorID == 0x8086) {
		size_t dev = 0;
		bool found = false;

		while (pch_pci_devices[dev].id != 0) {
			if (pch_pci_devices[dev].id == deviceID) {
				found = true;
				break;
			}
			dev++;
		}

		if (!found)
			return 0.0f;

		pci_device_module_info* pci;
		pci_device* device;
		gDeviceManager->get_driver(parent, (driver_module_info**)&pci,
			(void**)&device);
#ifdef TRACE_PCH_I2C
		uint8 pciSubDeviceId = pci->read_pci_config(device, PCI_revision,
			1);

		TRACE("PCH I2C device found! vendor 0x%04x, device 0x%04x, subdevice 0x%02x\n", vendorID,
			deviceID, pciSubDeviceId);
#endif
		return 0.8f;
	}

	return 0.0f;
}


//	#pragma mark -


driver_module_info gPchI2cPciDevice = {
	{
		PCH_I2C_PCI_DEVICE_MODULE_NAME,
		0,
		NULL
	},

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