/*
 * Copyright 2008, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
 * Distributed under the terms of the MIT License.
 */


#include "bus.h"

#include <KernelExport.h>
#include <PCI.h>


void
bus_trigger_device_removed(device_node* node)
{
	// the network device
	device_attr attrs[] = {
		{B_DEVICE_VENDOR_ID, B_UINT16_TYPE, {ui16: 0x1001}},
		{B_DEVICE_ID, B_UINT16_TYPE, {ui16: 0x0001}},
		{NULL}
	};

	device_node* child = NULL;
	while (gDeviceManager->get_next_child_node(node, attrs, &child) == B_OK) {
		gDeviceManager->unregister_node(child);
	}
}


void
bus_trigger_device_added(device_node* node)
{
}


//	#pragma mark - bus


static float
supports_device(device_node* parent)
{
	const char* bus;
	if (gDeviceManager->get_attr_string(parent, B_DEVICE_BUS, &bus, false)
			!= B_OK)
		return -1;

	if (bus != NULL && !strcmp(bus, "root"))
		return 1.0;

	return -1;
}


static status_t
register_device(device_node* parent)
{
	device_attr attrs[] = {
		{B_DEVICE_PRETTY_NAME,	B_STRING_TYPE,	{string: "My Bus"}},
		{B_DEVICE_BUS,			B_STRING_TYPE,	{string: BUS_NAME}},
		{NULL}
	};

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


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


static void
uninit_driver(void* cookie)
{
}


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

	const struct device_info {
		uint16		vendor;
		uint16		device;
		uint16		type;
		uint16		sub_type;
		uint16		interface;
	} kDevices[] = {
		{0x1000, 0x0001, PCI_mass_storage, PCI_sata, PCI_sata_ahci},
		{0x1001, 0x0001, PCI_network, PCI_ethernet, 0},
		{0x1001, 0x0002, PCI_display, 0, 0},
		{0x1002, 0x0001, PCI_multimedia, PCI_audio, 0},
		{0x1002, 0x0002, PCI_serial_bus, PCI_usb, PCI_usb_ehci},
	};
	const size_t kNumDevices = sizeof(kDevices) / sizeof(kDevices[0]);

	for (uint32 i = 0; i < kNumDevices; i++) {
		device_attr attrs[] = {
			// info about the device
			{B_DEVICE_VENDOR_ID, B_UINT16_TYPE, {ui16: kDevices[i].vendor}},
			{B_DEVICE_ID, B_UINT16_TYPE, {ui16: kDevices[i].device}},

			{B_DEVICE_BUS, B_STRING_TYPE, {string: BUS_NAME}},
			{B_DEVICE_TYPE, B_UINT16_TYPE, {ui16: kDevices[i].type}},
			{B_DEVICE_SUB_TYPE, B_UINT16_TYPE,
				{ui16: kDevices[i].sub_type}},
			{B_DEVICE_INTERFACE, B_UINT16_TYPE,
				{ui16: kDevices[i].interface}},

			{B_DEVICE_FLAGS, B_UINT32_TYPE, {ui32: B_FIND_CHILD_ON_DEMAND}},
			{NULL}
		};

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

	device_attr attrs[] = {
		{B_DEVICE_FIXED_CHILD, B_STRING_TYPE,
			{string: "non_existing/driver_v1"}},
		{NULL}
	};

#if 1
	// this is supposed to fail
	dprintf("non-existing child: %ld\n", gDeviceManager->register_node(node,
		BUS_FOR_DRIVER_NAME, attrs, NULL, NULL));
#endif
	return B_OK;
}


static status_t
rescan_child_devices(void* cookie)
{
	return B_ERROR;
}


static void
device_removed(void* cookie)
{
}


//	#pragma mark - for driver


static status_t
get_bus_info(void* cookie, bus_info* info)
{
	gDeviceManager->get_attr_uint16((device_node*)cookie, B_DEVICE_VENDOR_ID,
		&info->vendor_id, false);
	gDeviceManager->get_attr_uint16((device_node*)cookie, B_DEVICE_ID,
		&info->device_id, false);
	return B_OK;
}


//	#pragma mark -


struct driver_module_info gBusModuleInfo = {
	{
		BUS_MODULE_NAME,
		0,
		NULL,
	},

	supports_device,
	register_device,

	init_driver,
	uninit_driver,
	register_child_devices,
	rescan_child_devices,
	device_removed,
};

struct bus_for_driver_module_info gBusDriverModuleInfo = {
	{
		{
			BUS_FOR_DRIVER_NAME,
			0,
			NULL,
		},

		NULL,
		NULL,

		init_driver,
	},
	get_bus_info
};