xref: /netbsd-src/sys/dev/acpi/acpi_resource.c (revision b0bb4503535f46d986306941621a58cbe2316831)

/*	$NetBSD: acpi_resource.c,v 1.44 2025/01/02 16:32:34 andvar Exp $	*/

/*
 * Copyright 2001 Wasabi Systems, Inc.
 * All rights reserved.
 *
 * Written by Jason R. Thorpe for Wasabi Systems, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed for the NetBSD Project by
 *	Wasabi Systems, Inc.
 * 4. The name of Wasabi Systems, Inc. may not be used to endorse
 *    or promote products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*-
 * Copyright (c) 2000 Michael Smith
 * Copyright (c) 2000 BSDi
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * ACPI resource parsing.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: acpi_resource.c,v 1.44 2025/01/02 16:32:34 andvar Exp $");

#include <sys/param.h>
#include <sys/device.h>
#include <sys/systm.h>

#include <dev/acpi/acpireg.h>
#include <dev/acpi/acpivar.h>

#define	_COMPONENT	ACPI_RESOURCE_COMPONENT
ACPI_MODULE_NAME("RESOURCE")

static ACPI_STATUS acpi_resource_parse_callback(ACPI_RESOURCE *, void *);

struct resource_parse_callback_arg {
	const struct acpi_resource_parse_ops *ops;
	bool include_producer;
	device_t dev;
	void *context;
};

static ACPI_STATUS
acpi_resource_parse_callback(ACPI_RESOURCE *res, void *context)
{
	struct resource_parse_callback_arg *arg = context;
	const struct acpi_resource_parse_ops *ops;
	int i;

	ACPI_FUNCTION_TRACE(__func__);

	ops = arg->ops;

	switch (res->Type) {
	case ACPI_RESOURCE_TYPE_END_TAG:
		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "EndTag\n"));
		break;
	case ACPI_RESOURCE_TYPE_FIXED_IO:
		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				     "FixedIo 0x%x/%u\n",
				     res->Data.FixedIo.Address,
				     res->Data.FixedIo.AddressLength));
		if (ops->ioport)
			(*ops->ioport)(arg->dev, arg->context,
			    res->Data.FixedIo.Address,
			    res->Data.FixedIo.AddressLength);
		break;

	case ACPI_RESOURCE_TYPE_IO:
		if (res->Data.Io.Minimum ==
		    res->Data.Io.Maximum) {
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
					     "Io 0x%x/%u\n",
					     res->Data.Io.Minimum,
					     res->Data.Io.AddressLength));
			if (ops->ioport)
				(*ops->ioport)(arg->dev, arg->context,
				    res->Data.Io.Minimum,
				    res->Data.Io.AddressLength);
		} else {
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
					     "Io 0x%x-0x%x/%u\n",
					     res->Data.Io.Minimum,
					     res->Data.Io.Maximum,
					     res->Data.Io.AddressLength));
			if (ops->iorange)
				(*ops->iorange)(arg->dev, arg->context,
				    res->Data.Io.Minimum,
				    res->Data.Io.Maximum,
				    res->Data.Io.AddressLength,
				    res->Data.Io.Alignment);
		}
		break;

	case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				     "FixedMemory32 0x%x/%u\n",
				     res->Data.FixedMemory32.Address,
				     res->Data.FixedMemory32.AddressLength));
		if (ops->memory)
			(*ops->memory)(arg->dev, arg->context,
			    res->Data.FixedMemory32.Address,
			    res->Data.FixedMemory32.AddressLength,
			    res->Data.FixedMemory32.Address);
		break;

	case ACPI_RESOURCE_TYPE_MEMORY32:
		if (res->Data.Memory32.Minimum ==
		    res->Data.Memory32.Maximum) {
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
					     "Memory32 0x%x/%u\n",
					     res->Data.Memory32.Minimum,
					     res->Data.Memory32.AddressLength));
			if (ops->memory)
				(*ops->memory)(arg->dev, arg->context,
				    res->Data.Memory32.Minimum,
				    res->Data.Memory32.AddressLength,
				    res->Data.Memory32.Minimum);
		} else {
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
					     "Memory32 0x%x-0x%x/%u\n",
					     res->Data.Memory32.Minimum,
					     res->Data.Memory32.Maximum,
					     res->Data.Memory32.AddressLength));
			if (ops->memrange)
				(*ops->memrange)(arg->dev, arg->context,
				    res->Data.Memory32.Minimum,
				    res->Data.Memory32.Maximum,
				    res->Data.Memory32.AddressLength,
				    res->Data.Memory32.Alignment);
		}
		break;

	case ACPI_RESOURCE_TYPE_MEMORY24:
		if (res->Data.Memory24.Minimum ==
		    res->Data.Memory24.Maximum) {
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
					     "Memory24 0x%x/%u\n",
					     res->Data.Memory24.Minimum,
					     res->Data.Memory24.AddressLength));
			if (ops->memory)
				(*ops->memory)(arg->dev, arg->context,
				    res->Data.Memory24.Minimum,
				    res->Data.Memory24.AddressLength,
				    res->Data.Memory24.Minimum);
		} else {
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
					     "Memory24 0x%x-0x%x/%u\n",
					     res->Data.Memory24.Minimum,
					     res->Data.Memory24.Maximum,
					     res->Data.Memory24.AddressLength));
			if (ops->memrange)
				(*ops->memrange)(arg->dev, arg->context,
				    res->Data.Memory24.Minimum,
				    res->Data.Memory24.Maximum,
				    res->Data.Memory24.AddressLength,
				    res->Data.Memory24.Alignment);
		}
		break;

	case ACPI_RESOURCE_TYPE_IRQ:
		for (i = 0; i < res->Data.Irq.InterruptCount; i++) {
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
					     "IRQ %u\n",
					     res->Data.Irq.Interrupts[i]));
			if (ops->irq)
				(*ops->irq)(arg->dev, arg->context,
				    res->Data.Irq.Interrupts[i],
				    res->Data.Irq.Triggering);
		}
		break;

	case ACPI_RESOURCE_TYPE_DMA:
		for (i = 0; i < res->Data.Dma.ChannelCount; i++) {
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
					     "DRQ %u\n",
					     res->Data.Dma.Channels[i]));
			if (ops->drq)
				(*ops->drq)(arg->dev, arg->context,
				    res->Data.Dma.Channels[i]);
		}
		break;

	case ACPI_RESOURCE_TYPE_START_DEPENDENT:
		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				     "Start dependent functions: %u\n",
				     res->Data.StartDpf.CompatibilityPriority));
		if (ops->start_dep)
			(*ops->start_dep)(arg->dev, arg->context,
			    res->Data.StartDpf.CompatibilityPriority);
		break;

	case ACPI_RESOURCE_TYPE_END_DEPENDENT:
		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				     "End dependent functions\n"));
		if (ops->end_dep)
			(*ops->end_dep)(arg->dev, arg->context);
		break;

	case ACPI_RESOURCE_TYPE_ADDRESS32:
		/* XXX Only fixed size supported for now */
		if (res->Data.Address32.Address.AddressLength == 0)
			break;
#define ADDRESS32_FIXED2(r)						\
	((r)->Data.Address32.MinAddressFixed == ACPI_ADDRESS_FIXED &&	\
	 (r)->Data.Address32.MaxAddressFixed == ACPI_ADDRESS_FIXED)
		switch (res->Data.Address32.ResourceType) {
		case ACPI_MEMORY_RANGE:
			if (ADDRESS32_FIXED2(res)) {
				if (ops->memory)
					(*ops->memory)(arg->dev, arg->context,
					    res->Data.Address32.Address.Minimum,
					    res->Data.Address32.Address.AddressLength,
					    res->Data.Address32.Address.Minimum +
					        res->Data.Address32.Address.TranslationOffset);
			} else {
				if (ops->memrange)
					(*ops->memrange)(arg->dev, arg->context,
					    res->Data.Address32.Address.Minimum,
					    res->Data.Address32.Address.Maximum,
					    res->Data.Address32.Address.AddressLength,
					    res->Data.Address32.Address.Granularity);
			}
			break;
		case ACPI_IO_RANGE:
			if (ADDRESS32_FIXED2(res)) {
				if (ops->ioport)
					(*ops->ioport)(arg->dev, arg->context,
					    res->Data.Address32.Address.Minimum,
					    res->Data.Address32.Address.AddressLength);
			} else {
				if (ops->iorange)
					(*ops->iorange)(arg->dev, arg->context,
					    res->Data.Address32.Address.Minimum,
					    res->Data.Address32.Address.Maximum,
					    res->Data.Address32.Address.AddressLength,
					    res->Data.Address32.Address.Granularity);
			}
			break;
		case ACPI_BUS_NUMBER_RANGE:
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				      "Address32/BusNumber unimplemented\n"));
			break;
		}
#undef ADDRESS32_FIXED2
		break;

	case ACPI_RESOURCE_TYPE_ADDRESS16:
		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				     "Address16 unimplemented\n"));
		break;

	case ACPI_RESOURCE_TYPE_ADDRESS64:
#ifdef _LP64
		/* XXX Only fixed size supported for now */
		if (res->Data.Address64.Address.AddressLength == 0)
			break;
#define ADDRESS64_FIXED2(r)						\
	((r)->Data.Address64.MinAddressFixed == ACPI_ADDRESS_FIXED &&	\
	 (r)->Data.Address64.MaxAddressFixed == ACPI_ADDRESS_FIXED)
		switch (res->Data.Address64.ResourceType) {
		case ACPI_MEMORY_RANGE:
			if (ADDRESS64_FIXED2(res)) {
				if (ops->memory)
					(*ops->memory)(arg->dev, arg->context,
					    res->Data.Address64.Address.Minimum,
					    res->Data.Address64.Address.AddressLength,
					    res->Data.Address64.Address.Minimum +
					        res->Data.Address64.Address.TranslationOffset);
			} else {
				if (ops->memrange)
					(*ops->memrange)(arg->dev, arg->context,
					    res->Data.Address64.Address.Minimum,
					    res->Data.Address64.Address.Maximum,
					    res->Data.Address64.Address.AddressLength,
					    res->Data.Address64.Address.Granularity);
			}
			break;
		case ACPI_IO_RANGE:
			if (ADDRESS64_FIXED2(res)) {
				if (ops->ioport)
					(*ops->ioport)(arg->dev, arg->context,
					    res->Data.Address64.Address.Minimum,
					    res->Data.Address64.Address.AddressLength);
			} else {
				if (ops->iorange)
					(*ops->iorange)(arg->dev, arg->context,
					    res->Data.Address64.Address.Minimum,
					    res->Data.Address64.Address.Maximum,
					    res->Data.Address64.Address.AddressLength,
					    res->Data.Address64.Address.Granularity);
			}
			break;
		case ACPI_BUS_NUMBER_RANGE:
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				      "Address64/BusNumber unimplemented\n"));
			break;
		}
#undef ADDRESS64_FIXED2
#else
		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				     "Address64 unimplemented\n"));
#endif
		break;
	case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				     "Extended address64 unimplemented\n"));
		break;

	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
		if (!arg->include_producer &&
		    res->Data.ExtendedIrq.ProducerConsumer != ACPI_CONSUMER) {
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
			    "ignored ExtIRQ producer\n"));
			break;
		}
		for (i = 0; i < res->Data.ExtendedIrq.InterruptCount; i++) {
			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				     "ExtIRQ %u\n",
				     res->Data.ExtendedIrq.Interrupts[i]));
			if (ops->irq)
				(*ops->irq)(arg->dev, arg->context,
				    res->Data.ExtendedIrq.Interrupts[i],
				    res->Data.ExtendedIrq.Triggering);
		}
		break;

	case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				     "GenericRegister unimplemented\n"));
		break;

	case ACPI_RESOURCE_TYPE_VENDOR:
		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				     "VendorSpecific unimplemented\n"));
		break;

	default:
		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
				     "Unknown resource type: %u\n", res->Type));
		break;
	}

	return_ACPI_STATUS(AE_OK);
}


/*
 * acpi_resource_parse:
 *
 *	Parse a device node's resources and fill them in for the
 *	client.
 *
 *	This API supports _CRS (current resources) and
 *	_PRS (possible resources).
 *
 *	Note that it might be nice to also locate ACPI-specific resource
 *	items, such as GPE bits.
 */
ACPI_STATUS
acpi_resource_parse(device_t dev, ACPI_HANDLE handle, const char *path,
    void *arg, const struct acpi_resource_parse_ops *ops)
{
	struct resource_parse_callback_arg cbarg;
	ACPI_STATUS rv;

	ACPI_FUNCTION_TRACE(__func__);

	if (ops->init)
		(*ops->init)(dev, arg, &cbarg.context);
	else
		cbarg.context = arg;
	cbarg.ops = ops;
	cbarg.dev = dev;
	cbarg.include_producer = false;

	rv = AcpiWalkResources(handle, path, acpi_resource_parse_callback,
	    &cbarg);
	if (ACPI_FAILURE(rv)) {
		aprint_error_dev(dev, "ACPI: unable to get %s resources: %s\n",
		    path, AcpiFormatException(rv));
		return_ACPI_STATUS(rv);
	}

	if (ops->fini)
		(*ops->fini)(dev, cbarg.context);

	return_ACPI_STATUS(AE_OK);
}

/*
 * acpi_resource_parse_any:
 *
 *	Parse a device node's resources and fill them in for the
 *	client. Like acpi_resource_parse, but doesn't skip ResourceProducer
 *	type resources.
 */
ACPI_STATUS
acpi_resource_parse_any(device_t dev, ACPI_HANDLE handle, const char *path,
    void *arg, const struct acpi_resource_parse_ops *ops)
{
	struct resource_parse_callback_arg cbarg;
	ACPI_STATUS rv;

	ACPI_FUNCTION_TRACE(__func__);

	if (ops->init)
		(*ops->init)(dev, arg, &cbarg.context);
	else
		cbarg.context = arg;
	cbarg.ops = ops;
	cbarg.dev = dev;
	cbarg.include_producer = true;

	rv = AcpiWalkResources(handle, path, acpi_resource_parse_callback,
	    &cbarg);
	if (ACPI_FAILURE(rv)) {
		aprint_error_dev(dev, "ACPI: unable to get %s resources: %s\n",
		    path, AcpiFormatException(rv));
		return_ACPI_STATUS(rv);
	}

	if (ops->fini)
		(*ops->fini)(dev, cbarg.context);

	return_ACPI_STATUS(AE_OK);
}


/*
 * acpi_resource_print:
 *
 *	Print the resources assigned to a device.
 */
void
acpi_resource_print(device_t dev, struct acpi_resources *res)
{
	const char *sep;

	if (SIMPLEQ_EMPTY(&res->ar_io) &&
	    SIMPLEQ_EMPTY(&res->ar_iorange) &&
	    SIMPLEQ_EMPTY(&res->ar_mem) &&
	    SIMPLEQ_EMPTY(&res->ar_memrange) &&
	    SIMPLEQ_EMPTY(&res->ar_irq) &&
	    SIMPLEQ_EMPTY(&res->ar_drq))
		return;

	aprint_normal(":");

	if (SIMPLEQ_EMPTY(&res->ar_io) == 0) {
		struct acpi_io *ar;

		sep = "";
		aprint_normal(" io ");
		SIMPLEQ_FOREACH(ar, &res->ar_io, ar_list) {
			aprint_normal("%s0x%x", sep, ar->ar_base);
			if (ar->ar_length > 1)
				aprint_normal("-0x%x", ar->ar_base +
				    ar->ar_length - 1);
			sep = ",";
		}
	}

	/* XXX iorange */

	if (SIMPLEQ_EMPTY(&res->ar_mem) == 0) {
		struct acpi_mem *ar;

		sep = "";
		aprint_normal(" mem ");
		SIMPLEQ_FOREACH(ar, &res->ar_mem, ar_list) {
			aprint_normal("%s0x%" PRIx64, sep,
			    (uint64_t)ar->ar_base);
			if (ar->ar_length > 1)
				aprint_normal("-0x%" PRIx64,
				    (uint64_t)ar->ar_base +
				    ar->ar_length - 1);
			sep = ",";
		}
	}

	/* XXX memrange */

	if (SIMPLEQ_EMPTY(&res->ar_irq) == 0) {
		struct acpi_irq *ar;

		sep = "";
		aprint_normal(" irq ");
		SIMPLEQ_FOREACH(ar, &res->ar_irq, ar_list) {
			aprint_normal("%s%d", sep, ar->ar_irq);
			sep = ",";
		}
	}

	if (SIMPLEQ_EMPTY(&res->ar_drq) == 0) {
		struct acpi_drq *ar;

		sep = "";
		aprint_normal(" drq ");
		SIMPLEQ_FOREACH(ar, &res->ar_drq, ar_list) {
			aprint_normal("%s%d", sep, ar->ar_drq);
			sep = ",";
		}
	}

	aprint_normal("\n");
	aprint_naive("\n");
}

/*
 * acpi_resource_cleanup:
 *
 *	Free all allocated buffers
 */
void
acpi_resource_cleanup(struct acpi_resources *res)
{
	while (!SIMPLEQ_EMPTY(&res->ar_io)) {
		struct acpi_io *ar;
		ar = SIMPLEQ_FIRST(&res->ar_io);
		SIMPLEQ_REMOVE_HEAD(&res->ar_io, ar_list);
		ACPI_FREE(ar);
	}

	while (!SIMPLEQ_EMPTY(&res->ar_iorange)) {
		struct acpi_iorange *ar;
		ar = SIMPLEQ_FIRST(&res->ar_iorange);
		SIMPLEQ_REMOVE_HEAD(&res->ar_iorange, ar_list);
		ACPI_FREE(ar);
	}

	while (!SIMPLEQ_EMPTY(&res->ar_mem)) {
		struct acpi_mem *ar;
		ar = SIMPLEQ_FIRST(&res->ar_mem);
		SIMPLEQ_REMOVE_HEAD(&res->ar_mem, ar_list);
		ACPI_FREE(ar);
	}

	while (!SIMPLEQ_EMPTY(&res->ar_memrange)) {
		struct acpi_memrange *ar;
		ar = SIMPLEQ_FIRST(&res->ar_memrange);
		SIMPLEQ_REMOVE_HEAD(&res->ar_memrange, ar_list);
		ACPI_FREE(ar);
	}

	while (!SIMPLEQ_EMPTY(&res->ar_irq)) {
		struct acpi_irq *ar;
		ar = SIMPLEQ_FIRST(&res->ar_irq);
		SIMPLEQ_REMOVE_HEAD(&res->ar_irq, ar_list);
		ACPI_FREE(ar);
	}

	while (!SIMPLEQ_EMPTY(&res->ar_drq)) {
		struct acpi_drq *ar;
		ar = SIMPLEQ_FIRST(&res->ar_drq);
		SIMPLEQ_REMOVE_HEAD(&res->ar_drq, ar_list);
		ACPI_FREE(ar);
	}

	res->ar_nio = res->ar_niorange = res->ar_nmem =
	    res->ar_nmemrange = res->ar_nirq = res->ar_ndrq = 0;
}

struct acpi_io *
acpi_res_io(struct acpi_resources *res, int idx)
{
	struct acpi_io *ar;

	SIMPLEQ_FOREACH(ar, &res->ar_io, ar_list) {
		if (ar->ar_index == idx)
			return ar;
	}
	return NULL;
}

struct acpi_iorange *
acpi_res_iorange(struct acpi_resources *res, int idx)
{
	struct acpi_iorange *ar;

	SIMPLEQ_FOREACH(ar, &res->ar_iorange, ar_list) {
		if (ar->ar_index == idx)
			return ar;
	}
	return NULL;
}

struct acpi_mem *
acpi_res_mem(struct acpi_resources *res, int idx)
{
	struct acpi_mem *ar;

	SIMPLEQ_FOREACH(ar, &res->ar_mem, ar_list) {
		if (ar->ar_index == idx)
			return ar;
	}
	return NULL;
}

struct acpi_memrange *
acpi_res_memrange(struct acpi_resources *res, int idx)
{
	struct acpi_memrange *ar;

	SIMPLEQ_FOREACH(ar, &res->ar_memrange, ar_list) {
		if (ar->ar_index == idx)
			return ar;
	}
	return NULL;
}

struct acpi_irq *
acpi_res_irq(struct acpi_resources *res, int idx)
{
	struct acpi_irq *ar;

	SIMPLEQ_FOREACH(ar, &res->ar_irq, ar_list) {
		if (ar->ar_index == idx)
			return ar;
	}
	return NULL;
}

struct acpi_drq *
acpi_res_drq(struct acpi_resources *res, int idx)
{
	struct acpi_drq *ar;

	SIMPLEQ_FOREACH(ar, &res->ar_drq, ar_list) {
		if (ar->ar_index == idx)
			return ar;
	}
	return NULL;
}

/*****************************************************************************
 * Default ACPI resource parse operations.
 *****************************************************************************/

static void	acpi_res_parse_init(device_t, void *, void **);
static void	acpi_res_parse_fini(device_t, void *);

static void	acpi_res_parse_ioport(device_t, void *, uint32_t,
		    uint32_t);
static void	acpi_res_parse_iorange(device_t, void *, uint32_t,
		    uint32_t, uint32_t, uint32_t);

static void	acpi_res_parse_memory(device_t, void *, uint64_t,
		    uint64_t, uint64_t);
static void	acpi_res_parse_memrange(device_t, void *, uint64_t,
		    uint64_t, uint64_t, uint64_t);

static void	acpi_res_parse_irq(device_t, void *, uint32_t, uint32_t);
static void	acpi_res_parse_drq(device_t, void *, uint32_t);

static void	acpi_res_parse_start_dep(device_t, void *, int);
static void	acpi_res_parse_end_dep(device_t, void *);

const struct acpi_resource_parse_ops acpi_resource_parse_ops_default = {
	.init = acpi_res_parse_init,
	.fini = acpi_res_parse_fini,

	.ioport = acpi_res_parse_ioport,
	.iorange = acpi_res_parse_iorange,

	.memory = acpi_res_parse_memory,
	.memrange = acpi_res_parse_memrange,

	.irq = acpi_res_parse_irq,
	.drq = acpi_res_parse_drq,

	.start_dep = acpi_res_parse_start_dep,
	.end_dep = acpi_res_parse_end_dep,
};

const struct acpi_resource_parse_ops acpi_resource_parse_ops_quiet = {
	.init = acpi_res_parse_init,
	.fini = NULL,

	.ioport = acpi_res_parse_ioport,
	.iorange = acpi_res_parse_iorange,

	.memory = acpi_res_parse_memory,
	.memrange = acpi_res_parse_memrange,

	.irq = acpi_res_parse_irq,
	.drq = acpi_res_parse_drq,

	.start_dep = acpi_res_parse_start_dep,
	.end_dep = acpi_res_parse_end_dep,
};

static void
acpi_res_parse_init(device_t dev, void *arg, void **contextp)
{
	struct acpi_resources *res = arg;

	SIMPLEQ_INIT(&res->ar_io);
	res->ar_nio = 0;

	SIMPLEQ_INIT(&res->ar_iorange);
	res->ar_niorange = 0;

	SIMPLEQ_INIT(&res->ar_mem);
	res->ar_nmem = 0;

	SIMPLEQ_INIT(&res->ar_memrange);
	res->ar_nmemrange = 0;

	SIMPLEQ_INIT(&res->ar_irq);
	res->ar_nirq = 0;

	SIMPLEQ_INIT(&res->ar_drq);
	res->ar_ndrq = 0;

	*contextp = res;
}

static void
acpi_res_parse_fini(device_t dev, void *context)
{
	struct acpi_resources *res = context;

	/* Print the resources we're using. */
	acpi_resource_print(dev, res);
}

static void
acpi_res_parse_ioport(device_t dev, void *context, uint32_t base,
    uint32_t length)
{
	struct acpi_resources *res = context;
	struct acpi_io *ar;

	/*
	 * Check if there is another I/O port directly below/under
	 * this one.
	 */
	SIMPLEQ_FOREACH(ar, &res->ar_io, ar_list) {
		if (ar->ar_base == base + length ) {
			/*
			 * Entry just below existing entry - adjust
			 * the entry and return.
			 */
			ar->ar_base = base;
			ar->ar_length += length;
			return;
		} else if (ar->ar_base + ar->ar_length == base) {
			/*
			 * Entry just above existing entry - adjust
			 * the entry and return.
			 */
			ar->ar_length += length;
			return;
		}
	}

	/* IO and FixedIO I/O resource addresses are limited to 10/16-bit. */
	if (base + length - 1 > UINT16_MAX) {
		aprint_error_dev(dev, "ACPI: invalid I/O register resource %d,"
		    " base 0x%x, length %d\n",
		    res->ar_nio, base, length);
		res->ar_nio++;
		return;
	}

	ar = ACPI_ALLOCATE(sizeof(*ar));
	if (ar == NULL) {
		aprint_error_dev(dev, "ACPI: unable to allocate I/O resource %d\n",
		    res->ar_nio);
		res->ar_nio++;
		return;
	}

	ar->ar_index = res->ar_nio++;
	ar->ar_base = base;
	ar->ar_length = length;

	SIMPLEQ_INSERT_TAIL(&res->ar_io, ar, ar_list);
}

static void
acpi_res_parse_iorange(device_t dev, void *context, uint32_t low,
    uint32_t high, uint32_t length, uint32_t align)
{
	struct acpi_resources *res = context;
	struct acpi_iorange *ar;

	ar = ACPI_ALLOCATE(sizeof(*ar));
	if (ar == NULL) {
		aprint_error_dev(dev, "ACPI: unable to allocate I/O range resource %d\n",
		    res->ar_niorange);
		res->ar_niorange++;
		return;
	}

	ar->ar_index = res->ar_niorange++;
	ar->ar_low = low;
	ar->ar_high = high;
	ar->ar_length = length;
	ar->ar_align = align;

	SIMPLEQ_INSERT_TAIL(&res->ar_iorange, ar, ar_list);
}

static void
acpi_res_parse_memory(device_t dev, void *context, uint64_t base,
    uint64_t length, uint64_t xbase)
{
	struct acpi_resources *res = context;
	struct acpi_mem *ar;

	ar = ACPI_ALLOCATE(sizeof(*ar));
	if (ar == NULL) {
		aprint_error_dev(dev, "ACPI: unable to allocate Memory resource %d\n",
		    res->ar_nmem);
		res->ar_nmem++;
		return;
	}

	ar->ar_index = res->ar_nmem++;
	ar->ar_base = base;
	ar->ar_length = length;
	ar->ar_xbase = xbase;

	SIMPLEQ_INSERT_TAIL(&res->ar_mem, ar, ar_list);
}

static void
acpi_res_parse_memrange(device_t dev, void *context, uint64_t low,
    uint64_t high, uint64_t length, uint64_t align)
{
	struct acpi_resources *res = context;
	struct acpi_memrange *ar;

	ar = ACPI_ALLOCATE(sizeof(*ar));
	if (ar == NULL) {
		aprint_error_dev(dev, "ACPI: unable to allocate Memory range resource %d\n",
		    res->ar_nmemrange);
		res->ar_nmemrange++;
		return;
	}

	ar->ar_index = res->ar_nmemrange++;
	ar->ar_low = low;
	ar->ar_high = high;
	ar->ar_length = length;
	ar->ar_align = align;

	SIMPLEQ_INSERT_TAIL(&res->ar_memrange, ar, ar_list);
}

static void
acpi_res_parse_irq(device_t dev, void *context, uint32_t irq, uint32_t type)
{
	struct acpi_resources *res = context;
	struct acpi_irq *ar;

	ar = ACPI_ALLOCATE(sizeof(*ar));
	if (ar == NULL) {
		aprint_error_dev(dev, "ACPI: unable to allocate IRQ resource %d\n",
		    res->ar_nirq);
		res->ar_nirq++;
		return;
	}

	ar->ar_index = res->ar_nirq++;
	ar->ar_irq = irq;
	ar->ar_type = type;

	SIMPLEQ_INSERT_TAIL(&res->ar_irq, ar, ar_list);
}

static void
acpi_res_parse_drq(device_t dev, void *context, uint32_t drq)
{
	struct acpi_resources *res = context;
	struct acpi_drq *ar;

	ar = ACPI_ALLOCATE(sizeof(*ar));
	if (ar == NULL) {
		aprint_error_dev(dev, "ACPI: unable to allocate DRQ resource %d\n",
		    res->ar_ndrq);
		res->ar_ndrq++;
		return;
	}

	ar->ar_index = res->ar_ndrq++;
	ar->ar_drq = drq;

	SIMPLEQ_INSERT_TAIL(&res->ar_drq, ar, ar_list);
}

static void
acpi_res_parse_start_dep(device_t dev, void *context,
    int preference)
{

	aprint_error_dev(dev, "ACPI: dependent functions not supported\n");
}

static void
acpi_res_parse_end_dep(device_t dev, void *context)
{

	/* Nothing to do. */
}