/*
 * 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>


#define DRIVER_MODULE_NAME "drivers/net/sample_driver/driver_v1"
#define DRIVER_DEVICE_MODULE_NAME "drivers/net/sample_driver/device_v1"


//	#pragma mark - driver


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

	if (bus == NULL || strcmp(bus, BUS_NAME))
		return -1;
#endif

	bus_for_driver_module_info* module;
	void* data;
	gDeviceManager->get_driver(parent, (driver_module_info**)&module, &data);

	if (strcmp(module->info.info.name, BUS_FOR_DRIVER_NAME))
		return -1;

	bus_info info;
	if (module->get_bus_info(data, &info) == B_OK
		&& info.vendor_id == 0x1001
		&& info.device_id == 0x0001)
		return 1.0;

	return 0.0;
}


static status_t
register_device(device_node* parent)
{
	return gDeviceManager->register_node(parent, DRIVER_MODULE_NAME, NULL,
		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;

	gDeviceManager->publish_device(node, "net/sample/0",
		DRIVER_DEVICE_MODULE_NAME);
	return B_OK;
}


static void
driver_device_removed(void* cookie)
{
}


//	#pragma mark - device


static status_t
init_device(void* driverCookie, void** _deviceCookie)
{
	// called once before one or several open() calls
	return B_OK;
}


static void
uninit_device(void* deviceCookie)
{
	// supposed to free deviceCookie, called when the last reference to
	// the device is closed
}


static void
device_removed(void* deviceCookie)
{
	dprintf("network device removed!\n");
}


static status_t
device_open(void* deviceCookie, int openMode, void** _cookie)
{
	// deviceCookie is an object attached to the published device
	return B_ERROR;
}


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


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


static status_t
device_read(void* cookie, off_t pos, void* buffer, size_t* _length)
{
	return B_ERROR;
}


static status_t
device_write(void* cookie, off_t pos, const void* buffer, size_t* _length)
{
	return B_ERROR;
}


static status_t
device_ioctl(void* cookie, int32 op, void* buffer, size_t length)
{
	return B_ERROR;
}


static status_t
device_io(void* cookie, io_request* request)
{
	// new function to deal with I/O requests directly.
	return B_ERROR;
}


//	#pragma mark -


struct driver_module_info gDriverModuleInfo = {
	{
		DRIVER_MODULE_NAME,
		0,
		NULL,
	},

	supports_device,
	register_device,
	init_driver,
	uninit_driver,
	register_child_devices,
	NULL,
	driver_device_removed,
};

struct device_module_info gDeviceModuleInfo = {
	{
		DRIVER_DEVICE_MODULE_NAME,
		0,
		NULL,
	},

	init_device,
	uninit_device,
	device_removed,

	device_open,
	device_close,
	device_free,
	device_read,
	device_write,
	device_ioctl,
	device_io,
};