haiku.git

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

/*
	ISA bus manager

	Implementation.
*/


#include <ISA.h>
#include <bus/ISA.h>
#include <KernelExport.h>
#include <device_manager.h>
#include <arch/cpu.h>

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

#include "isa_arch.h"

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

// ToDo: this is architecture dependent and should be made differently!
//	(for example, the Pegasos (PPC based) also has an ISA bus)


#define ISA_MODULE_NAME "bus_managers/isa/root/driver_v1"

device_manager_info *pnp;


static long
make_isa_dma_table(const void *buffer, long buffer_size, ulong num_bits,
	isa_dma_entry *table, long num_entries)
{
	// ToDo: implement this?!
	return ENOSYS;
}


static long
start_scattered_isa_dma(long channel, const isa_dma_entry *table,
	uchar mode, uchar emode)
{
	// ToDo: implement this?!
	return ENOSYS;
}


static status_t
lock_isa_dma_channel(long channel)
{
	// ToDo: implement this?!
	return B_NOT_ALLOWED;
}


static status_t
unlock_isa_dma_channel(long channel)
{
	// ToDo: implement this?!
	return B_ERROR;
}


//	#pragma mark - driver module API


static status_t
isa_init_driver(device_node *node, void **cookie)
{
	*cookie = node;
	return B_OK;
}


static void
isa_uninit_driver(void *cookie)
{
}


static float
isa_supports_device(device_node *parent)
{
	const char *bus;

	// make sure parent is really pnp root
	if (pnp->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
isa_register_device(device_node *parent)
{
	static const device_attr attrs[] = {
		// tell where to look for child devices
		{B_DEVICE_BUS, B_STRING_TYPE, {.string = "isa" }},
		{B_DEVICE_FLAGS, B_UINT32_TYPE,
			{.ui32 = B_FIND_CHILD_ON_DEMAND | B_FIND_MULTIPLE_CHILDREN}},
		{}
	};

	return pnp->register_node(parent, ISA_MODULE_NAME, attrs, NULL, NULL);
}


static status_t
std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
			return arch_isa_init();
		case B_MODULE_UNINIT:
			return B_OK;

		default:
			return B_ERROR;
	}
}


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

static isa_module_info isa_module = {
	{
		{
			B_ISA_MODULE_NAME,
			B_KEEP_LOADED,
			std_ops
		},
		NULL	// rescan
	},
	&arch_isa_read_io_8,
	&arch_isa_write_io_8,
	&arch_isa_read_io_16,
	&arch_isa_write_io_16,
	&arch_isa_read_io_32,
	&arch_isa_write_io_32,
	&arch_isa_ram_address,
	&make_isa_dma_table,
	&arch_start_isa_dma,
	&start_scattered_isa_dma,
	&lock_isa_dma_channel,
	&unlock_isa_dma_channel
};

static isa2_module_info isa2_module = {
	{
		{
			ISA_MODULE_NAME,
			0,
			std_ops
		},

		isa_supports_device,
		isa_register_device,
		isa_init_driver,
		isa_uninit_driver,
		NULL,	// removed device
		NULL,	// register child devices
		NULL,	// rescan bus
	},

	arch_isa_read_io_8, arch_isa_write_io_8,
	arch_isa_read_io_16, arch_isa_write_io_16,
	arch_isa_read_io_32, arch_isa_write_io_32,

	arch_isa_ram_address,

	arch_start_isa_dma,
};

module_info *modules[] = {
	(module_info *)&isa_module,
	(module_info *)&isa2_module,
	NULL
};