Subversion Repositories or1k

/*******************************************************************************

 *

 * Module Name: rsxface - Public interfaces to the resource manager

 *

 ******************************************************************************/

/*

 * Copyright (C) 2000 - 2004, R. Byron Moore

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

 *    without modification.

 * 2. Redistributions in binary form must reproduce at minimum a disclaimer

 *    substantially similar to the "NO WARRANTY" disclaimer below

 *    ("Disclaimer") and any redistribution must be conditioned upon

 *    including a substantially similar Disclaimer requirement for further

 *    binary redistribution.

 * 3. Neither the names of the above-listed copyright holders nor the names

 *    of any contributors may be used to endorse or promote products derived

 *    from this software without specific prior written permission.

 *

 * Alternatively, this software may be distributed under the terms of the

 * GNU General Public License ("GPL") version 2 as published by the Free

 * Software Foundation.

 *

 * NO WARRANTY

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES.

 */

#include <acpi/acpi.h>

#include <acpi/acresrc.h>

#define _COMPONENT          ACPI_RESOURCES

         ACPI_MODULE_NAME    ("rsxface")

/*******************************************************************************

 *

 * FUNCTION:    acpi_get_irq_routing_table

 *

 * PARAMETERS:  device_handle   - a handle to the Bus device we are querying

 *              ret_buffer      - a pointer to a buffer to receive the

 *                                current resources for the device

 *

 * RETURN:      Status

 *

 * DESCRIPTION: This function is called to get the IRQ routing table for a

 *              specific bus.  The caller must first acquire a handle for the

 *              desired bus.  The routine table is placed in the buffer pointed

 *              to by the ret_buffer variable parameter.

 *

 *              If the function fails an appropriate status will be returned

 *              and the value of ret_buffer is undefined.

 *

 *              This function attempts to execute the _PRT method contained in

 *              the object indicated by the passed device_handle.

 *

 ******************************************************************************/

acpi_status

acpi_get_irq_routing_table (

        acpi_handle                     device_handle,

        struct acpi_buffer              *ret_buffer)

{

        acpi_status                     status;

        ACPI_FUNCTION_TRACE ("acpi_get_irq_routing_table ");

        /*

         * Must have a valid handle and buffer, So we have to have a handle

         * and a return buffer structure, and if there is a non-zero buffer length

         * we also need a valid pointer in the buffer. If it's a zero buffer length,

         * we'll be returning the needed buffer size, so keep going.

         */

        if (!device_handle) {

                return_ACPI_STATUS (AE_BAD_PARAMETER);

        }

        status = acpi_ut_validate_buffer (ret_buffer);

        if (ACPI_FAILURE (status)) {

                return_ACPI_STATUS (status);

        }

        status = acpi_rs_get_prt_method_data (device_handle, ret_buffer);

        return_ACPI_STATUS (status);

}

/*******************************************************************************

 *

 * FUNCTION:    acpi_get_current_resources

 *

 * PARAMETERS:  device_handle   - a handle to the device object for the

 *                                device we are querying

 *              ret_buffer      - a pointer to a buffer to receive the

 *                                current resources for the device

 *

 * RETURN:      Status

 *

 * DESCRIPTION: This function is called to get the current resources for a

 *              specific device.  The caller must first acquire a handle for

 *              the desired device.  The resource data is placed in the buffer

 *              pointed to by the ret_buffer variable parameter.

 *

 *              If the function fails an appropriate status will be returned

 *              and the value of ret_buffer is undefined.

 *

 *              This function attempts to execute the _CRS method contained in

 *              the object indicated by the passed device_handle.

 *

 ******************************************************************************/

acpi_status

acpi_get_current_resources (

        acpi_handle                     device_handle,

        struct acpi_buffer              *ret_buffer)

{

        acpi_status                     status;

        ACPI_FUNCTION_TRACE ("acpi_get_current_resources");

        /*

         * Must have a valid handle and buffer, So we have to have a handle

         * and a return buffer structure, and if there is a non-zero buffer length

         * we also need a valid pointer in the buffer. If it's a zero buffer length,

         * we'll be returning the needed buffer size, so keep going.

         */

        if (!device_handle) {

                return_ACPI_STATUS (AE_BAD_PARAMETER);

        }

        status = acpi_ut_validate_buffer (ret_buffer);

        if (ACPI_FAILURE (status)) {

                return_ACPI_STATUS (status);

        }

        status = acpi_rs_get_crs_method_data (device_handle, ret_buffer);

        return_ACPI_STATUS (status);

}

/*******************************************************************************

 *

 * FUNCTION:    acpi_get_possible_resources

 *

 * PARAMETERS:  device_handle   - a handle to the device object for the

 *                                device we are querying

 *              ret_buffer      - a pointer to a buffer to receive the

 *                                resources for the device

 *

 * RETURN:      Status

 *

 * DESCRIPTION: This function is called to get a list of the possible resources

 *              for a specific device.  The caller must first acquire a handle

 *              for the desired device.  The resource data is placed in the

 *              buffer pointed to by the ret_buffer variable.

 *

 *              If the function fails an appropriate status will be returned

 *              and the value of ret_buffer is undefined.

 *

 ******************************************************************************/

acpi_status

acpi_get_possible_resources (

        acpi_handle                     device_handle,

        struct acpi_buffer              *ret_buffer)

{

        acpi_status                     status;

        ACPI_FUNCTION_TRACE ("acpi_get_possible_resources");

        /*

         * Must have a valid handle and buffer, So we have to have a handle

         * and a return buffer structure, and if there is a non-zero buffer length

         * we also need a valid pointer in the buffer. If it's a zero buffer length,

         * we'll be returning the needed buffer size, so keep going.

         */

        if (!device_handle) {

                return_ACPI_STATUS (AE_BAD_PARAMETER);

        }

        status = acpi_ut_validate_buffer (ret_buffer);

        if (ACPI_FAILURE (status)) {

                return_ACPI_STATUS (status);

        }

        status = acpi_rs_get_prs_method_data (device_handle, ret_buffer);

        return_ACPI_STATUS (status);

}

/*******************************************************************************

 *

 * FUNCTION:    acpi_walk_resources

 *

 * PARAMETERS:  device_handle   - a handle to the device object for the

 *                                device we are querying

 *              Path            - method name of the resources we want

 *                                (METHOD_NAME__CRS or METHOD_NAME__PRS)

 *              user_function   - called for each resource

 *              Context         - passed to user_function

 *

 * RETURN:      Status

 *

 * DESCRIPTION: Retrieves the current or possible resource list for the

 *              specified device.  The user_function is called once for

 *              each resource in the list.

 *

 ******************************************************************************/

acpi_status

acpi_walk_resources (

        acpi_handle                             device_handle,

        char                                    *path,

        ACPI_WALK_RESOURCE_CALLBACK     user_function,

        void                                    *context)

{

        acpi_status                         status;

        struct acpi_buffer                  buffer = {ACPI_ALLOCATE_BUFFER, NULL};

        struct acpi_resource                *resource;

        struct acpi_resource                *buffer_end;

        ACPI_FUNCTION_TRACE ("acpi_walk_resources");

        if (!device_handle ||

                (ACPI_STRNCMP (path, METHOD_NAME__CRS, sizeof (METHOD_NAME__CRS)) &&

                 ACPI_STRNCMP (path, METHOD_NAME__PRS, sizeof (METHOD_NAME__PRS)))) {

                return_ACPI_STATUS (AE_BAD_PARAMETER);

        }

        status = acpi_rs_get_method_data (device_handle, path, &buffer);

        if (ACPI_FAILURE (status)) {

                return_ACPI_STATUS (status);

        }

        /* Setup pointers */

        resource  = (struct acpi_resource *) buffer.pointer;

        buffer_end = (struct acpi_resource *) ((u8 *) buffer.pointer + buffer.length);

        /* Walk the resource list */

        for (;;) {

                if (!resource || resource->id == ACPI_RSTYPE_END_TAG) {

                        break;

                }

                status = user_function (resource, context);

                switch (status) {

                case AE_OK:

                case AE_CTRL_DEPTH:

                        /* Just keep going */

                        status = AE_OK;

                        break;

                case AE_CTRL_TERMINATE:

                        /* Exit now, with OK stats */

                        status = AE_OK;

                        goto cleanup;

                default:

                        /* All others are valid exceptions */

                        goto cleanup;

                }

                /* Get the next resource descriptor */

                resource = ACPI_NEXT_RESOURCE (resource);

                /* Check for end-of-buffer */

                if (resource >= buffer_end) {

                        goto cleanup;

                }

        }

cleanup:

        acpi_os_free (buffer.pointer);

        return_ACPI_STATUS (status);

}

/*******************************************************************************

 *

 * FUNCTION:    acpi_set_current_resources

 *

 * PARAMETERS:  device_handle   - a handle to the device object for the

 *                                device we are changing the resources of

 *              in_buffer       - a pointer to a buffer containing the

 *                                resources to be set for the device

 *

 * RETURN:      Status

 *

 * DESCRIPTION: This function is called to set the current resources for a

 *              specific device.  The caller must first acquire a handle for

 *              the desired device.  The resource data is passed to the routine

 *              the buffer pointed to by the in_buffer variable.

 *

 ******************************************************************************/

acpi_status

acpi_set_current_resources (

        acpi_handle                     device_handle,

        struct acpi_buffer              *in_buffer)

{

        acpi_status                     status;

        ACPI_FUNCTION_TRACE ("acpi_set_current_resources");

        /*

         * Must have a valid handle and buffer

         */

        if ((!device_handle)      ||

                (!in_buffer)          ||

                (!in_buffer->pointer) ||

                (!in_buffer->length)) {

                return_ACPI_STATUS (AE_BAD_PARAMETER);

        }

        status = acpi_rs_set_srs_method_data (device_handle, in_buffer);

        return_ACPI_STATUS (status);

}

#define ACPI_COPY_FIELD(out, in, field)  ((out)->field = (in)->field)

#define ACPI_COPY_ADDRESS(out, in)                      \

        ACPI_COPY_FIELD(out, in, resource_type);             \

        ACPI_COPY_FIELD(out, in, producer_consumer);         \

        ACPI_COPY_FIELD(out, in, decode);                    \

        ACPI_COPY_FIELD(out, in, min_address_fixed);         \

        ACPI_COPY_FIELD(out, in, max_address_fixed);         \

        ACPI_COPY_FIELD(out, in, attribute);                 \

        ACPI_COPY_FIELD(out, in, granularity);               \

        ACPI_COPY_FIELD(out, in, min_address_range);         \

        ACPI_COPY_FIELD(out, in, max_address_range);         \

        ACPI_COPY_FIELD(out, in, address_translation_offset); \

        ACPI_COPY_FIELD(out, in, address_length);            \

        ACPI_COPY_FIELD(out, in, resource_source);

/******************************************************************************

 *

 * FUNCTION:    acpi_resource_to_address64

 *

 * PARAMETERS:  resource                - Pointer to a resource

 *              out                     - Pointer to the users's return

 *                                        buffer (a struct

 *                                        struct acpi_resource_address64)

 *

 * RETURN:      Status

 *

 * DESCRIPTION: If the resource is an address16, address32, or address64,

 *              copy it to the address64 return buffer.  This saves the

 *              caller from having to duplicate code for different-sized

 *              addresses.

 *

 ******************************************************************************/

acpi_status

acpi_resource_to_address64 (

        struct acpi_resource                *resource,

        struct acpi_resource_address64      *out)

{

        struct acpi_resource_address16      *address16;

        struct acpi_resource_address32      *address32;

        switch (resource->id) {

        case ACPI_RSTYPE_ADDRESS16:

                address16 = (struct acpi_resource_address16 *) &resource->data;

                ACPI_COPY_ADDRESS(out, address16);

                break;

        case ACPI_RSTYPE_ADDRESS32:

                address32 = (struct acpi_resource_address32 *) &resource->data;

                ACPI_COPY_ADDRESS(out, address32);

                break;

        case ACPI_RSTYPE_ADDRESS64:

                /* Simple copy for 64 bit source */

                ACPI_MEMCPY (out, &resource->data, sizeof (struct acpi_resource_address64));

                break;

        default:

                return (AE_BAD_PARAMETER);

        }

        return (AE_OK);

}