/* config driver
 * provides userland access to the device manager
 *
 * Copyright 2002-2004, Axel Doerfler. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors : Axel Doerfler, Jerome Duval
 */


#include <Drivers.h>
#include <drivers/device_manager.h>
#include <stdlib.h>
#include <string.h>

#include "config_driver.h"

#ifdef DEBUG
#define TRACE(x...) dprintf(x)
#else
#define TRACE(x...)
#endif

#define DEVICE_NAME "misc/config"

int32 api_version = B_CUR_DRIVER_API_VERSION;

device_manager_info *gDeviceManager;

typedef struct _driver_cookie {
	device_node_handle parent;
	device_node_handle child;
	device_attr_handle attr;
} driver_cookie;

//	Device interface


static status_t
config_open(const char *name, uint32 flags, void **_cookie)
{
	driver_cookie *cookie = malloc(sizeof(driver_cookie));
	if (cookie == NULL)
		return B_ERROR;
	*_cookie = cookie;
	cookie->child = gDeviceManager->get_root();
	cookie->parent = NULL;
	cookie->attr = NULL;
	return B_OK;
}


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


static status_t
config_free_cookie(void *cookie)
{
	driver_cookie *cook = (driver_cookie *)cookie;
	gDeviceManager->put_device_node(cook->child);
	if (cook->parent)
		gDeviceManager->put_device_node(cook->parent);
	return B_OK;
}


static status_t
config_ioctl(void *cookie, uint32 op, void *buffer, size_t len)
{
	driver_cookie *cook = (driver_cookie *)cookie;
	device_node_handle child = NULL;
	const device_attr *attr = NULL;
	
	struct dm_ioctl_data *params = (struct dm_ioctl_data *)buffer;
	status_t err = B_OK;

	// simple check for validity of the argument
	if (params == NULL || params->magic != op)
		return B_BAD_VALUE;

	switch (op) {
		case DM_GET_CHILD:
			TRACE("DM_GET_CHILD parent %p child %p\n", cook->parent, cook->child);
			if (cook->attr) {
				gDeviceManager->release_attr(cook->child, cook->attr);
				cook->attr = NULL;
			}
			err = gDeviceManager->get_next_child_device(cook->child, &child, NULL);
			if (err == B_OK) {
				if (cook->parent)
					gDeviceManager->put_device_node(cook->parent);
				cook->parent = cook->child;
				cook->child = child;
			}
			return err;
		case DM_GET_NEXT_CHILD:
			TRACE("DM_GET_NEXT_CHILD parent %p child %p\n", cook->parent, cook->child);
			if (!cook->parent)
				return B_ENTRY_NOT_FOUND;
			if (cook->attr) {
				gDeviceManager->release_attr(cook->child, cook->attr);
				cook->attr = NULL;
			}
			return gDeviceManager->get_next_child_device(cook->parent, &cook->child, NULL);
		case DM_GET_PARENT:
			TRACE("DM_GET_PARENT parent %p child %p\n", cook->parent, cook->child);
			if (!cook->parent)
				return B_ENTRY_NOT_FOUND;
			if (cook->attr) {
				gDeviceManager->release_attr(cook->child, cook->attr);
				cook->attr = NULL;
			}
			if (cook->child)
				gDeviceManager->put_device_node(cook->child);
			cook->child = cook->parent;
			cook->parent = gDeviceManager->get_parent(cook->child);
			return B_OK;
		case DM_GET_NEXT_ATTRIBUTE:
			TRACE("DM_NEXT_ATTRIBUTE parent %p child %p attr %p\n", cook->parent, cook->child, cook->attr);
			return gDeviceManager->get_next_attr(cook->child, &cook->attr);
		case DM_RETRIEVE_ATTRIBUTE:
			TRACE("DM_RETRIEVE_ATTRIBUTE parent %p child %p attr %p\n", cook->parent, cook->child, cook->attr);
			err = gDeviceManager->retrieve_attr(cook->attr, &attr);
			if (err == B_OK) {
				strlcpy(params->attr->name, attr->name, 254);
				params->attr->type = attr->type;
				switch (attr->type) {
					case B_UINT8_TYPE:
						params->attr->value.ui8 = attr->value.ui8; break;
					case B_UINT16_TYPE:
						params->attr->value.ui16 = attr->value.ui16; break;
					case B_UINT32_TYPE:
						params->attr->value.ui32 = attr->value.ui32; break;
					case B_UINT64_TYPE:
						params->attr->value.ui64 = attr->value.ui64; break;
					case B_STRING_TYPE:
						strlcpy(params->attr->value.string, attr->value.string, 254); break;
					case B_RAW_TYPE:
						if (params->attr->value.raw.length > attr->value.raw.length)
							params->attr->value.raw.length = attr->value.raw.length;
						memcpy(params->attr->value.raw.data, attr->value.raw.data, 
							params->attr->value.raw.length);
						break;
				}
			}
			return err;
	}

	return B_BAD_VALUE;
}


static status_t
config_read(void * cookie, off_t pos, void *buf, size_t *_length)
{
	*_length = 0;
	return B_OK;
}


static status_t
config_write(void * cookie, off_t pos, const void *buf, size_t *_length)
{
	*_length = 0;
	return B_OK;
}


//	#pragma mark -
//	Driver interface


status_t
init_hardware()
{
	return B_OK;
}


const char **
publish_devices(void)
{
	static const char *devices[] = {
		DEVICE_NAME, 
		NULL
	};

	return devices;
}


device_hooks *
find_device(const char *name)
{
	static device_hooks hooks = {
		&config_open,
		&config_close,
		&config_free_cookie,
		&config_ioctl,
		&config_read,
		&config_write,
		/* Leave select/deselect/readv/writev undefined. The kernel will
		 * use its own default implementation. The basic hooks above this
		 * line MUST be defined, however. */
		NULL,
		NULL,
		NULL,
		NULL
	};

	if (!strcmp(name, DEVICE_NAME))
		return &hooks;

	return NULL;
}


status_t
init_driver()
{
	return get_module(B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&gDeviceManager);
}


void
uninit_driver()
{
	if (gDeviceManager != NULL)
		put_module(B_DEVICE_MANAGER_MODULE_NAME);
}