/*      $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. */
}