haiku.git

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


#include <ACPI.h>
#include <condition_variable.h>
#include <Drivers.h>
#include <Errors.h>

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

#include <kernel.h>


extern "C" {
#	include "acpi.h"
}


struct als_driver_cookie {
	device_node*				node;
	acpi_device_module_info*	acpi;
	acpi_device					acpi_cookie;
};


struct als_device_cookie {
	als_driver_cookie*		driver_cookie;
	int32					stop_watching;
};


#define ACPI_ALS_DRIVER_NAME "drivers/sensor/acpi_als/driver_v1"
#define ACPI_ALS_DEVICE_NAME "drivers/sensor/acpi_als/device_v1"

/* Base Namespace devices are published to */
#define ACPI_ALS_BASENAME "sensor/acpi_als/%d"

// name of pnp generator of path ids
#define ACPI_ALS_PATHID_GENERATOR "acpi_als/path_id"

#define ACPI_NAME_ALS "ACPI0008"

#define TRACE_ALS
#ifdef TRACE_ALS
#	define TRACE(x...) dprintf("acpi_als: " x)
#else
#	define TRACE(x...)
#endif
#define ERROR(x...) dprintf("acpi_als: " x)


static device_manager_info *sDeviceManager;
static ConditionVariable sALSCondition;


static status_t
acpi_GetInteger(als_driver_cookie *device,
	const char* path, uint64* number)
{
	acpi_data buf;
	acpi_object_type object;
	buf.pointer = &object;
	buf.length = sizeof(acpi_object_type);

	// Assume that what we've been pointed at is an Integer object, or
	// a method that will return an Integer.
	status_t status = device->acpi->evaluate_method(device->acpi_cookie, path,
		NULL, &buf);
	if (status == B_OK) {
		if (object.object_type == ACPI_TYPE_INTEGER)
			*number = object.integer.integer;
		else
			status = B_BAD_VALUE;
	}
	return status;
}


void
als_notify_handler(acpi_handle device, uint32 value, void *context)
{
	TRACE("als_notify_handler event 0x%" B_PRIx32 "\n", value);
	sALSCondition.NotifyAll();
}


//	#pragma mark - device module API


static status_t
acpi_als_init_device(void *driverCookie, void **cookie)
{
	*cookie = driverCookie;
	return B_OK;
}


static void
acpi_als_uninit_device(void *_cookie)
{

}


static status_t
acpi_als_open(void *initCookie, const char *path, int flags, void** cookie)
{
	als_device_cookie *device;
	device = (als_device_cookie*)calloc(1, sizeof(als_device_cookie));
	if (device == NULL)
		return B_NO_MEMORY;

	device->driver_cookie = (als_driver_cookie*)initCookie;
	device->stop_watching = 0;

	*cookie = device;

	return B_OK;
}


static status_t
acpi_als_close(void* cookie)
{
	return B_OK;
}


static status_t
acpi_als_read(void* _cookie, off_t position, void *buffer, size_t* numBytes)
{
	if (*numBytes < 1)
		return B_IO_ERROR;

	als_device_cookie *device = (als_device_cookie*)_cookie;

	if (position == 0) {
		char string[10];
		uint64 luminance = 0;
		status_t status = acpi_GetInteger(device->driver_cookie,
			"_ALI", &luminance);
		if (status != B_OK)
			return B_ERROR;
		snprintf(string, sizeof(string), "%" B_PRIu64 "\n", luminance);
		size_t max_len = user_strlcpy((char*)buffer, string, *numBytes);
		if (max_len < B_OK)
			return B_BAD_ADDRESS;
		*numBytes = max_len;
	} else
		*numBytes = 0;

	return B_OK;
}


static status_t
acpi_als_write(void* cookie, off_t position, const void* buffer,
	size_t* numBytes)
{
	return B_ERROR;
}


static status_t
acpi_als_control(void* _cookie, uint32 op, void* arg, size_t len)
{
	//als_device_cookie* device = (als_device_cookie*)_cookie;

	return B_DEV_INVALID_IOCTL;
}


static status_t
acpi_als_free(void* cookie)
{
	als_device_cookie* device = (als_device_cookie*)cookie;
	free(device);
	return B_OK;
}


//	#pragma mark - driver module API


static float
acpi_als_support(device_node *parent)
{
	// make sure parent is really the ACPI bus manager
	const char *bus;
	if (sDeviceManager->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 (sDeviceManager->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 a als device
	const char *name;
	if (sDeviceManager->get_attr_string(parent, ACPI_DEVICE_HID_ITEM, &name,
		false) != B_OK || strcmp(name, ACPI_NAME_ALS)) {
		return 0.0;
	}

	return 0.6;
}


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

	return sDeviceManager->register_node(node, ACPI_ALS_DRIVER_NAME, attrs,
		NULL, NULL);
}


static status_t
acpi_als_init_driver(device_node *node, void **driverCookie)
{
	als_driver_cookie *device;
	device = (als_driver_cookie *)calloc(1, sizeof(als_driver_cookie));
	if (device == NULL)
		return B_NO_MEMORY;

	*driverCookie = device;

	device->node = node;

	device_node *parent;
	parent = sDeviceManager->get_parent_node(node);
	sDeviceManager->get_driver(parent, (driver_module_info **)&device->acpi,
		(void **)&device->acpi_cookie);

#ifdef TRACE_ALS
	const char* device_path;
	if (sDeviceManager->get_attr_string(parent, ACPI_DEVICE_PATH_ITEM,
		&device_path, false) == B_OK) {
		TRACE("acpi_als_init_driver %s\n", device_path);
	}
#endif

	sDeviceManager->put_node(parent);

	uint64 sta;
	status_t status = acpi_GetInteger(device, "_STA", &sta);
	uint64 mask = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED
		| ACPI_STA_DEVICE_FUNCTIONING;
	if (status == B_OK && (sta & mask) != mask) {
		ERROR("acpi_als_init_driver device disabled\n");
		return B_ERROR;
	}

	uint64 luminance;
	status = acpi_GetInteger(device, "_ALI", &luminance);
	if (status != B_OK) {
		ERROR("acpi_als_init_driver error when calling _ALI\n");
		return B_ERROR;
	}

	// install notify handler
	device->acpi->install_notify_handler(device->acpi_cookie,
		ACPI_ALL_NOTIFY, als_notify_handler, device);

	return B_OK;
}


static void
acpi_als_uninit_driver(void *driverCookie)
{
	TRACE("acpi_als_uninit_driver\n");
	als_driver_cookie *device = (als_driver_cookie*)driverCookie;

	device->acpi->remove_notify_handler(device->acpi_cookie,
		ACPI_ALL_NOTIFY, als_notify_handler);

	free(device);
}


static status_t
acpi_als_register_child_devices(void *cookie)
{
	als_driver_cookie *device = (als_driver_cookie*)cookie;

	int pathID = sDeviceManager->create_id(ACPI_ALS_PATHID_GENERATOR);
	if (pathID < 0) {
		ERROR("register_child_devices: couldn't create a path_id\n");
		return B_ERROR;
	}

	char name[B_DEV_NAME_LENGTH];
	snprintf(name, sizeof(name), ACPI_ALS_BASENAME, pathID);

	return sDeviceManager->publish_device(device->node, name,
		ACPI_ALS_DEVICE_NAME);
}






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


driver_module_info acpi_als_driver_module = {
	{
		ACPI_ALS_DRIVER_NAME,
		0,
		NULL
	},

	acpi_als_support,
	acpi_als_register_device,
	acpi_als_init_driver,
	acpi_als_uninit_driver,
	acpi_als_register_child_devices,
	NULL,	// rescan
	NULL,	// removed
};


struct device_module_info acpi_als_device_module = {
	{
		ACPI_ALS_DEVICE_NAME,
		0,
		NULL
	},

	acpi_als_init_device,
	acpi_als_uninit_device,
	NULL,

	acpi_als_open,
	acpi_als_close,
	acpi_als_free,
	acpi_als_read,
	acpi_als_write,
	NULL,
	acpi_als_control,

	NULL,
	NULL
};

module_info *modules[] = {
	(module_info *)&acpi_als_driver_module,
	(module_info *)&acpi_als_device_module,
	NULL
};