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


#define DRIVER_NAME "wmi_acpi"
#include "WMIPrivate.h"


#define ACPI_NAME_ACPI_WMI "PNP0C14"

#define ACPI_WMI_REGFLAG_EXPENSIVE	(1 << 0)
#define ACPI_WMI_REGFLAG_METHOD		(1 << 1)
#define ACPI_WMI_REGFLAG_STRING		(1 << 2)
#define ACPI_WMI_REGFLAG_EVENT		(1 << 3)


device_manager_info *gDeviceManager;
smbios_module_info *gSMBios;


acpi_status wmi_acpi_adr_space_handler(uint32 function,
	acpi_physical_address address, uint32 bitWidth, int *value,
	void *handlerContext, void *regionContext)
{
	return B_OK;
}


WMIACPI::WMIACPI(device_node *node)
	:
	fNode(node)
{
	CALLED();

	device_node *parent;
	parent = gDeviceManager->get_parent_node(node);
	gDeviceManager->get_driver(parent, (driver_module_info **)&acpi,
		(void **)&acpi_cookie);
	gDeviceManager->get_attr_string(parent, ACPI_DEVICE_UID_ITEM, &fUid,
		false);
	gDeviceManager->put_node(parent);

	// install notify handler
	fStatus = acpi->install_notify_handler(acpi_cookie,
		ACPI_ALL_NOTIFY, _NotifyHandler, this);
	if (fStatus != B_OK) {
		ERROR("install_notify_handler failed\n");
		return;
	}

	fStatus = acpi->install_address_space_handler(acpi_cookie,
		ACPI_ADR_SPACE_EC, wmi_acpi_adr_space_handler, NULL, this);
	if (fStatus != B_OK) {
		ERROR("wmi_acpi_adr_space_handler failed\n");
		return;
	}

	acpi_data buffer = {ACPI_ALLOCATE_BUFFER, NULL};
	fStatus = acpi->evaluate_method(acpi_cookie, "_WDG", NULL, &buffer);
	if (fStatus != B_OK) {
		ERROR("Method call _WDG failed\n");
		return;
	}

	acpi_object_type* object = (acpi_object_type*)buffer.pointer;
	fWMIInfoCount = object->buffer.length / sizeof(guid_info);
	guid_info *info = (guid_info*)object->buffer.buffer;
	fWMIInfos = (wmi_info *)calloc(fWMIInfoCount, sizeof(wmi_info));
	TRACE("found %" B_PRIu32 " objects\n", fWMIInfoCount);
	for (uint32 i = 0; i < fWMIInfoCount; i++, info++) {
		wmi_info *wmi = &fWMIInfos[i];
		wmi->guid = *info;
		fList.Add(wmi);
	}
	free(object);
}


WMIACPI::~WMIACPI()
{
	free(fWMIInfos);

	acpi->remove_notify_handler(acpi_cookie,
		ACPI_ALL_NOTIFY, _NotifyHandler);
}


status_t
WMIACPI::InitCheck()
{
	return fStatus;
}


status_t
WMIACPI::Scan()
{
	CALLED();
	status_t status;
	wmi_info* wmiInfo = NULL;
	uint32 index = 0;
	for (WMIInfoList::Iterator it = fList.GetIterator();
			(wmiInfo = it.Next()) != NULL; index++) {
		uint8* guid = wmiInfo->guid.guid;
		char guidString[37] = {};
		_GuidToGuidString(guid, guidString);
		device_attr attrs[] = {
			// connection
			{ WMI_GUID_STRING_ITEM, B_STRING_TYPE, { .string = guidString }},

			{ WMI_BUS_COOKIE, B_UINT32_TYPE, { .ui32 = index }},

			// description of peripheral drivers
			{ B_DEVICE_BUS, B_STRING_TYPE, { .string = "wmi" }},

			{ B_DEVICE_FLAGS, B_UINT32_TYPE,
				{ .ui32 = B_FIND_MULTIPLE_CHILDREN }},

			{ NULL }
		};

		status = gDeviceManager->register_node(fNode, WMI_DEVICE_MODULE_NAME,
			attrs, NULL, NULL);
		if (status != B_OK)
			return status;
	}

	return B_OK;

}


status_t
WMIACPI::GetBlock(uint32 busCookie, uint8 instance, uint32 methodId,
	acpi_data* out)
{
	CALLED();
	if (busCookie >= fWMIInfoCount)
		return B_BAD_VALUE;
	wmi_info* info = &fWMIInfos[busCookie];
	if ((info->guid.flags & ACPI_WMI_REGFLAG_METHOD) != 0
		|| (info->guid.flags & ACPI_WMI_REGFLAG_EVENT) != 0) {
		return B_BAD_VALUE;
	} else if (instance > info->guid.max_instance)
		return B_BAD_VALUE;

	char method[5] = "WQ";
	strncat(method, info->guid.oid, 2);
	char wcMethod[5] = "WC";
	strncat(wcMethod, info->guid.oid, 2);
	status_t wcStatus = B_OK;
	status_t status = B_OK;

	if ((info->guid.flags & ACPI_WMI_REGFLAG_EXPENSIVE) != 0)
		 wcStatus = _EvaluateMethodSimple(wcMethod, 1);

	acpi_object_type object;
	object.object_type = ACPI_TYPE_INTEGER;
	object.integer.integer = instance;
	acpi_objects objects = { 1, &object};
	TRACE("GetBlock calling %s\n", method);
	status = acpi->evaluate_method(acpi_cookie, method, &objects, out);

	if ((info->guid.flags & ACPI_WMI_REGFLAG_EXPENSIVE) != 0
		&& wcStatus == B_OK) {
		 _EvaluateMethodSimple(wcMethod, 0);
	}

	return status;
}


status_t
WMIACPI::SetBlock(uint32 busCookie, uint8 instance, uint32 methodId,
	const acpi_data* in)
{
	CALLED();
	if (busCookie >= fWMIInfoCount)
		return B_BAD_VALUE;
	wmi_info* info = &fWMIInfos[busCookie];
	if ((info->guid.flags & ACPI_WMI_REGFLAG_METHOD) != 0
		|| (info->guid.flags & ACPI_WMI_REGFLAG_EVENT) != 0) {
		return B_BAD_VALUE;
	} else if (instance > info->guid.max_instance)
		return B_BAD_VALUE;

	char method[5] = "WS";
	strncat(method, info->guid.oid, 2);

	acpi_object_type object[2];
	object[0].object_type = ACPI_TYPE_INTEGER;
	object[0].integer.integer = instance;
	object[1].object_type = ACPI_TYPE_BUFFER;
	if ((info->guid.flags & ACPI_WMI_REGFLAG_STRING) != 0)
		object[1].object_type = ACPI_TYPE_STRING;
	object[1].buffer.buffer = in->pointer;
	object[1].buffer.length = in->length;
	acpi_objects objects = { 2, object};
	TRACE("SetBlock calling %s\n", method);
	return acpi->evaluate_method(acpi_cookie, method, &objects, NULL);
}


status_t
WMIACPI::EvaluateMethod(uint32 busCookie, uint8 instance, uint32 methodId,
	const acpi_data* in, acpi_data* out)
{
	CALLED();
	if (busCookie >= fWMIInfoCount)
		return B_BAD_VALUE;
	wmi_info* info = &fWMIInfos[busCookie];
	if ((info->guid.flags & ACPI_WMI_REGFLAG_METHOD) == 0)
		return B_BAD_VALUE;

	char method[5] = "WM";
	strncat(method, info->guid.oid, 2);

	acpi_object_type object[3];
	object[0].object_type = ACPI_TYPE_INTEGER;
	object[0].integer.integer = instance;
	object[1].object_type = ACPI_TYPE_INTEGER;
	object[1].integer.integer = methodId;
	uint32 count = 2;
	if (in != NULL) {
		object[2].object_type = ACPI_TYPE_BUFFER;
		if ((info->guid.flags & ACPI_WMI_REGFLAG_STRING) != 0)
			object[2].object_type = ACPI_TYPE_STRING;
		object[2].buffer.buffer = in->pointer;
		object[2].buffer.length = in->length;
		count++;
	}
	acpi_objects objects = { count, object};
	TRACE("EvaluateMethod calling %s\n", method);
	return acpi->evaluate_method(acpi_cookie, method, &objects, out);
}


status_t
WMIACPI::InstallEventHandler(const char* guidString,
	acpi_notify_handler handler, void* context)
{
	CALLED();
	char string[37] = {};
	for (uint32 i = 0; i < fWMIInfoCount; i++) {
		wmi_info* info = &fWMIInfos[i];
		_GuidToGuidString(info->guid.guid, string);
		if (strcmp(guidString, string) == 0) {
			status_t status = B_OK;
			if (info->handler == NULL)
				status = _SetEventGeneration(info, true);
			if (status == B_OK) {
				info->handler = handler;
				info->handler_context = context;
			}
			return status;
		}
	}
	return B_ENTRY_NOT_FOUND;
}


status_t
WMIACPI::RemoveEventHandler(const char* guidString)
{
	CALLED();
	char string[37] = {};
	for (uint32 i = 0; i < fWMIInfoCount; i++) {
		wmi_info* info = &fWMIInfos[i];
		_GuidToGuidString(info->guid.guid, string);
		if (strcmp(guidString, string) == 0) {
			status_t status = _SetEventGeneration(info, false);
			info->handler = NULL;
			info->handler_context = NULL;
			return status;
		}
	}
	return B_ENTRY_NOT_FOUND;
}


status_t
WMIACPI::GetEventData(uint32 notify, acpi_data* out)
{
	CALLED();

	acpi_object_type object;
	object.object_type = ACPI_TYPE_INTEGER;
	object.integer.integer = notify;
	acpi_objects objects = { 1, &object };

	for (uint32 i = 0; i < fWMIInfoCount; i++) {
		wmi_info* info = &fWMIInfos[i];
		if (info->guid.notify_id == notify
			&& (info->guid.flags & ACPI_WMI_REGFLAG_EVENT) != 0) {
			return acpi->evaluate_method(acpi_cookie, "_WED", &objects, out);
		}
	}
	return B_ENTRY_NOT_FOUND;
}


const char*
WMIACPI::GetUid(uint32 busCookie)
{
	return fUid;
}


status_t
WMIACPI::_SetEventGeneration(wmi_info* info, bool enabled)
{
	char method[5];
	sprintf(method, "WE%02X", info->guid.notify_id);
	TRACE("_SetEventGeneration calling %s\n", method);
	status_t status = _EvaluateMethodSimple(method, enabled ? 1 : 0);
	// the method is allowed not to exist
	if (status == B_ERROR)
		status = B_OK;
	return status;
}


status_t
WMIACPI::_EvaluateMethodSimple(const char* method, uint64 integer)
{
	acpi_object_type object;
	object.object_type = ACPI_TYPE_INTEGER;
	object.integer.integer = integer;
	acpi_objects objects = { 1, &object};
	return acpi->evaluate_method(acpi_cookie, method, &objects, NULL);
}


void
WMIACPI::_NotifyHandler(acpi_handle device, uint32 value, void *context)
{
	WMIACPI* bus = (WMIACPI*)context;
	bus->_Notify(device, value);
}


void
WMIACPI::_Notify(acpi_handle device, uint32 value)
{
	for (uint32 i = 0; i < fWMIInfoCount; i++) {
		wmi_info* wmi = &fWMIInfos[i];
		if (wmi->guid.notify_id == value) {
			TRACE("_Notify found event 0x%" B_PRIx32 "\n", value);
			if (wmi->handler != NULL) {
				TRACE("_Notify found handler for event 0x%" B_PRIx32 "\n",
					value);
				wmi->handler(device, value, wmi->handler_context);
			}
			break;
		}
	}
}


void
WMIACPI::_GuidToGuidString(uint8 guid[16], char* guidString)
{
	sprintf(guidString,
		"%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
		guid[3], guid[2], guid[1], guid[0], guid[5], guid[4], guid[7], guid[6],
		guid[8], guid[9], guid[10], guid[11], guid[12], guid[13], guid[14],
		guid[15]);
}


//	#pragma mark - driver module API


static float
wmi_acpi_support(device_node *parent)
{
	CALLED();

	// make sure parent is really the ACPI bus manager
	const char *bus;
	if (gDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false))
		return -1;

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

	// 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;
	}

	// check whether it's an acpi wmi device
	const char *name;
	if (gDeviceManager->get_attr_string(parent, ACPI_DEVICE_HID_ITEM, &name,
		false) != B_OK || strcmp(name, ACPI_NAME_ACPI_WMI) != 0) {
		return 0.0;
	}

	TRACE("found an acpi wmi device\n");

	return 0.6;
}


static status_t
wmi_acpi_register_device(device_node *node)
{
	CALLED();
	device_attr attrs[] = {
		{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "WMI ACPI" }},
		{ NULL }
	};

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


static status_t
wmi_acpi_init_driver(device_node *node, void **driverCookie)
{
	CALLED();
	WMIACPI* device = new(std::nothrow) WMIACPI(node);
	if (device == NULL)
		return B_NO_MEMORY;

	*driverCookie = device;

	return B_OK;
}


static void
wmi_acpi_uninit_driver(void *driverCookie)
{
	CALLED();
	WMIACPI *device = (WMIACPI*)driverCookie;

	delete device;
}


static status_t
wmi_acpi_register_child_devices(void *cookie)
{
	CALLED();
	WMIACPI *device = (WMIACPI*)cookie;
	return device->Scan();
}


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


static driver_module_info sWMIACPIDriverModule = {
	{
		WMI_ACPI_DRIVER_NAME,
		0,
		NULL
	},

	wmi_acpi_support,
	wmi_acpi_register_device,
	wmi_acpi_init_driver,
	wmi_acpi_uninit_driver,
	wmi_acpi_register_child_devices,
	NULL,	// rescan
	NULL,	// removed
};


module_info *modules[] = {
	(module_info *)&sWMIACPIDriverModule,
	(module_info *)&gWMIAsusDriverModule,
	(module_info *)&gWMIDeviceModule,
	NULL
};