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


#include "io_resources.h"

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


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


typedef DoublyLinkedList<io_resource_private,
	DoublyLinkedListMemberGetLink<io_resource_private,
		&io_resource_private::fTypeLink> > ResourceTypeList;


static ResourceTypeList sMemoryList;
static ResourceTypeList sPortList;
static ResourceTypeList sDMAChannelList;


io_resource_private::io_resource_private()
{
	_Init();
}


io_resource_private::~io_resource_private()
{
	Release();
}


void
io_resource_private::_Init()
{
	type = 0;
	base = 0;
	length = 0;
}


status_t
io_resource_private::Acquire(const io_resource& resource)
{
	if (!_IsValid(resource))
		return B_BAD_VALUE;

	type = resource.type;
	base = resource.base;

	if (type != B_ISA_DMA_CHANNEL)
		length = resource.length;
	else
		length = 1;

	ResourceTypeList* list = NULL;

	switch (type) {
		case B_IO_MEMORY:
			list = &sMemoryList;
			break;
		case B_IO_PORT:
			list = &sPortList;
			break;
		case B_ISA_DMA_CHANNEL:
			list = &sDMAChannelList;
			break;
	}

	ResourceTypeList::Iterator iterator = list->GetIterator();
	while (iterator.HasNext()) {
		io_resource* resource = iterator.Next();

		// we need the "base + length - 1" trick to avoid wrap around at 4 GB
		if (resource->base >= base
			&& resource->base + length - 1 <= base + length - 1) {
			// This range is already covered by someone else
			// TODO: we might want to ignore resources that belong to
			// a node that isn't used.
			_Init();
			return B_RESOURCE_UNAVAILABLE;
		}
	}

	list->Add(this);
	return B_OK;
}


void
io_resource_private::Release()
{
	if (type == 0)
		return;

	switch (type) {
		case B_IO_MEMORY:
			sMemoryList.Remove(this);
			break;
		case B_IO_PORT:
			sPortList.Remove(this);
			break;
		case B_ISA_DMA_CHANNEL:
			sDMAChannelList.Remove(this);
			break;
	}

	_Init();
}


/*static*/ bool
io_resource_private::_IsValid(const io_resource& resource)
{
	switch (resource.type) {
		case B_IO_MEMORY:
			return resource.base + resource.length > resource.base;
		case B_IO_PORT:
			return (uint16)resource.base == resource.base
				&& (uint16)resource.length == resource.length
				&& resource.base + resource.length > resource.base;
		case B_ISA_DMA_CHANNEL:
			return resource.base <= 8;

		default:
			return false;
	}
}


//	#pragma mark -


void
dm_init_io_resources(void)
{
	new(&sMemoryList) ResourceTypeList;
	new(&sPortList) ResourceTypeList;
	new(&sDMAChannelList) ResourceTypeList;
}