haiku.git

/*
 * Copyright 2009, Clemens Zeidler. All rights reserved.
 * Copyright 2006, Jérôme Duval. All rights reserved.
 *
 * Distributed under the terms of the MIT License.
 */


#include <stdlib.h>
#include <string.h>


#include "ACPIPrivate.h"
extern "C" {
#include "acpi.h"
}
#include <dpc.h>
#include <PCI.h>


//#define TRACE_ACPI_MODULE
#ifdef TRACE_ACPI_MODULE
#	define TRACE(x) dprintf x
#else
#	define TRACE(x) ;
#endif


device_manager_info* gDeviceManager = NULL;
pci_module_info* gPCIManager = NULL;
dpc_module_info* gDPC = NULL;

module_dependency module_dependencies[] = {
	{B_DEVICE_MANAGER_MODULE_NAME, (module_info**)&gDeviceManager},
	{B_PCI_MODULE_NAME, (module_info**)&gPCIManager},
	{B_DPC_MODULE_NAME, (module_info**)&gDPC},
	{}
};


static float
acpi_module_supports_device(device_node* parent)
{
	// 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
acpi_module_register_device(device_node* parent)
{
	device_attr attrs[] = {
		{ B_DEVICE_PRETTY_NAME, B_STRING_TYPE, { .string = "ACPI" }},
		{ B_DEVICE_FLAGS, B_UINT32_TYPE, { .ui32 = B_KEEP_DRIVER_LOADED }},
		{}
	};

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


static status_t
acpi_enumerate_child_devices(device_node* node, const char* root)
{
	char result[255];
	void* counter = NULL;

	TRACE(("acpi_enumerate_child_devices: recursing from %s\n", root));

	while (get_next_entry(ACPI_TYPE_ANY, root, result,
			sizeof(result), &counter) == B_OK) {
		uint32 type = get_object_type(result);
		device_node* deviceNode;

		switch (type) {
			case ACPI_TYPE_POWER:
			case ACPI_TYPE_PROCESSOR:
			case ACPI_TYPE_THERMAL:
			case ACPI_TYPE_DEVICE: {
				device_attr attrs[16] = {
					// info about device
					{ B_DEVICE_BUS, B_STRING_TYPE, { .string = "acpi" }},

					// location on ACPI bus
					{ ACPI_DEVICE_PATH_ITEM, B_STRING_TYPE, { .string = result }},

					// info about the device
					{ ACPI_DEVICE_TYPE_ITEM, B_UINT32_TYPE, { .ui32 = type }},

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

				uint32 attrCount = 4;
				char* hid = NULL;
				char* cidList[11] = { NULL };
				char* uid = NULL;
				char* cls = NULL;
				if (type == ACPI_TYPE_DEVICE) {
					if (get_device_info(result, &hid, (char**)&cidList, 8,
						&uid, &cls) == B_OK) {
						if (hid != NULL) {
							attrs[attrCount].name = ACPI_DEVICE_HID_ITEM;
							attrs[attrCount].type = B_STRING_TYPE;
							attrs[attrCount].value.string = hid;
							attrCount++;
						}
						for (int i = 0; cidList[i] != NULL; i++) {
							attrs[attrCount].name = ACPI_DEVICE_CID_ITEM;
							attrs[attrCount].type = B_STRING_TYPE;
							attrs[attrCount].value.string = cidList[i];
							attrCount++;
						}
						if (uid != NULL) {
							attrs[attrCount].name = ACPI_DEVICE_UID_ITEM;
							attrs[attrCount].type = B_STRING_TYPE;
							attrs[attrCount].value.string = uid;
							attrCount++;
						}
						if (cls != NULL) {
							uint32 clsClass = strtoul(cls, NULL, 16);
							attrs[attrCount].name = B_DEVICE_TYPE;
							attrs[attrCount].type = B_UINT16_TYPE;
							attrs[attrCount].value.ui16 = (clsClass >> 16) & 0xff ;
							attrCount++;
							attrs[attrCount].name = B_DEVICE_SUB_TYPE;
							attrs[attrCount].type = B_UINT16_TYPE;
							attrs[attrCount].value.ui16 = (clsClass >> 8) & 0xff ;
							attrCount++;
							attrs[attrCount].name = B_DEVICE_INTERFACE;
							attrs[attrCount].type = B_UINT16_TYPE;
							attrs[attrCount].value.ui16 = (clsClass >> 0) & 0xff ;
							attrCount++;
						}
					}
					uint32 addr;
					if (get_device_addr(result, &addr) == B_OK) {
						attrs[attrCount].name = ACPI_DEVICE_ADDR_ITEM;
						attrs[attrCount].type = B_UINT32_TYPE;
						attrs[attrCount].value.ui32 = addr;
						attrCount++;
					}
				}

				status_t status = gDeviceManager->register_node(node,
						ACPI_DEVICE_MODULE_NAME, attrs, NULL, &deviceNode);
				free(hid);
				free(uid);
				free(cls);
				for (int i = 0; cidList[i] != NULL; i++)
					free(cidList[i]);
				if (status != B_OK)
					break;
				acpi_enumerate_child_devices(deviceNode, result);
				break;
			}
			default:
				acpi_enumerate_child_devices(node, result);
				break;
		}

	}

	return B_OK;
}


static status_t
acpi_module_register_child_devices(void* cookie)
{
	device_node* node = (device_node*)cookie;

	status_t status = gDeviceManager->publish_device(node, "acpi/namespace",
		ACPI_NS_DUMP_DEVICE_MODULE_NAME);
	if (status != B_OK)
		return status;
	status = gDeviceManager->publish_device(node, "acpi/call",
		ACPI_CALL_DEVICE_MODULE_NAME);
	if (status != B_OK)
		return status;

	if ((AcpiGbl_FADT.Flags & ACPI_FADT_POWER_BUTTON) == 0) {
		dprintf("registering power button\n");
		device_attr attrs[] = {
			// info about device
			{ B_DEVICE_BUS, B_STRING_TYPE, { .string = "acpi" }},

			// info about the device
			{ ACPI_DEVICE_HID_ITEM, B_STRING_TYPE, { .string = "ACPI_FPB" }},
			{ ACPI_DEVICE_TYPE_ITEM, B_UINT32_TYPE, { .ui32 = ACPI_TYPE_DEVICE }},

			// consumer specification
			{ B_DEVICE_FLAGS, B_UINT32_TYPE, { .ui32 = B_FIND_MULTIPLE_CHILDREN }},
			{ NULL }
		};
		device_node* deviceNode;
		gDeviceManager->register_node(node, ACPI_DEVICE_MODULE_NAME, attrs,
				NULL, &deviceNode);
	}
	if ((AcpiGbl_FADT.Flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
		dprintf("registering sleep button\n");
		device_attr attrs[] = {
			// info about device
			{ B_DEVICE_BUS, B_STRING_TYPE, { .string = "acpi" }},

			// info about the device
			{ ACPI_DEVICE_HID_ITEM, B_STRING_TYPE, { .string = "ACPI_FSB" }},
			{ ACPI_DEVICE_TYPE_ITEM, B_UINT32_TYPE, { .ui32 = ACPI_TYPE_DEVICE }},

			// consumer specification
			{ B_DEVICE_FLAGS, B_UINT32_TYPE, { .ui32 = B_FIND_MULTIPLE_CHILDREN }},
			{ NULL }
		};
		device_node* deviceNode;
		gDeviceManager->register_node(node, ACPI_DEVICE_MODULE_NAME, attrs,
				NULL, &deviceNode);

	}

	return acpi_enumerate_child_devices(node, "\\");
}


static status_t
acpi_module_init(device_node* node, void** _cookie)
{
	*_cookie = node;
	return B_OK;
}


static void
acpi_module_uninit(void* cookie)
{
}


static int32
acpi_module_std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
		{
			module_info* module;
			return get_module(B_ACPI_MODULE_NAME, &module);
				// this serializes our module initialization
		}

		case B_MODULE_UNINIT:
			return put_module(B_ACPI_MODULE_NAME);
	}

	return B_BAD_VALUE;
}


static struct acpi_root_info sACPIRootModule = {
	{
		{
			ACPI_ROOT_MODULE_NAME,
			0,
			acpi_module_std_ops
		},

		acpi_module_supports_device,
		acpi_module_register_device,
		acpi_module_init,
		acpi_module_uninit,
		acpi_module_register_child_devices,
		NULL,	// rescan devices
		NULL,	// device removed
	},

	get_handle,
	get_name,
	acquire_global_lock,
	release_global_lock,
	install_notify_handler,
	remove_notify_handler,
	update_all_gpes,
	enable_gpe,
	disable_gpe,
	clear_gpe,
	set_gpe,
	finish_gpe,
	install_gpe_handler,
	remove_gpe_handler,
	install_address_space_handler,
	remove_address_space_handler,
	enable_fixed_event,
	disable_fixed_event,
	fixed_event_status,
	reset_fixed_event,
	install_fixed_event_handler,
	remove_fixed_event_handler,
	get_next_entry,
	get_next_object,
	get_device,
	get_device_info,
	get_object_type,
	get_object,
	get_object_typed,
	ns_handle_to_pathname,
	evaluate_object,
	evaluate_method,
	get_irq_routing_table,
	get_current_resources,
	get_possible_resources,
	set_current_resources,
	walk_resources,
	prepare_sleep_state,
	enter_sleep_state,
	reboot,
	get_table
};


module_info* modules[] = {
	(module_info*)&gACPIModule,
	(module_info*)&sACPIRootModule,
	(module_info*)&acpi_ns_dump_module,
	(module_info*)&gACPIDeviceModule,
	(module_info*)&embedded_controller_driver_module,
	(module_info*)&embedded_controller_device_module,
	(module_info*)&gAcpiCallDeviceModule,
	NULL
};