drivers/acpi/resources/rsxface.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: rsxface - Public interfaces to the resource manager
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2004, R. Byron Moore
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44
  45 #include <acpi/acpi.h>
  46 #include <acpi/acresrc.h>
  47
  48 #define _COMPONENT          ACPI_RESOURCES
  49          ACPI_MODULE_NAME    ("rsxface")
  50
  51
  52 /*******************************************************************************
  53  *
  54  * FUNCTION:    acpi_get_irq_routing_table
  55  *
  56  * PARAMETERS:  device_handle   - a handle to the Bus device we are querying
  57  *              ret_buffer      - a pointer to a buffer to receive the
  58  *                                current resources for the device
  59  *
  60  * RETURN:      Status
  61  *
  62  * DESCRIPTION: This function is called to get the IRQ routing table for a
  63  *              specific bus.  The caller must first acquire a handle for the
  64  *              desired bus.  The routine table is placed in the buffer pointed
  65  *              to by the ret_buffer variable parameter.
  66  *
  67  *              If the function fails an appropriate status will be returned
  68  *              and the value of ret_buffer is undefined.
  69  *
  70  *              This function attempts to execute the _PRT method contained in
  71  *              the object indicated by the passed device_handle.
  72  *
  73  ******************************************************************************/
  74
  75 acpi_status
  76 acpi_get_irq_routing_table (
  77         acpi_handle                     device_handle,
  78         struct acpi_buffer              *ret_buffer)
  79 {
  80         acpi_status                     status;
  81
  82
  83         ACPI_FUNCTION_TRACE ("acpi_get_irq_routing_table ");
  84
  85
  86         /*
  87          * Must have a valid handle and buffer, So we have to have a handle
  88          * and a return buffer structure, and if there is a non-zero buffer length
  89          * we also need a valid pointer in the buffer. If it's a zero buffer length,
  90          * we'll be returning the needed buffer size, so keep going.
  91          */
  92         if (!device_handle) {
  93                 return_ACPI_STATUS (AE_BAD_PARAMETER);
  94         }
  95
  96         status = acpi_ut_validate_buffer (ret_buffer);
  97         if (ACPI_FAILURE (status)) {
  98                 return_ACPI_STATUS (status);
  99         }
 100
 101         status = acpi_rs_get_prt_method_data (device_handle, ret_buffer);
 102         return_ACPI_STATUS (status);
 103 }
 104
 105
 106 /*******************************************************************************
 107  *
 108  * FUNCTION:    acpi_get_current_resources
 109  *
 110  * PARAMETERS:  device_handle   - a handle to the device object for the
 111  *                                device we are querying
 112  *              ret_buffer      - a pointer to a buffer to receive the
 113  *                                current resources for the device
 114  *
 115  * RETURN:      Status
 116  *
 117  * DESCRIPTION: This function is called to get the current resources for a
 118  *              specific device.  The caller must first acquire a handle for
 119  *              the desired device.  The resource data is placed in the buffer
 120  *              pointed to by the ret_buffer variable parameter.
 121  *
 122  *              If the function fails an appropriate status will be returned
 123  *              and the value of ret_buffer is undefined.
 124  *
 125  *              This function attempts to execute the _CRS method contained in
 126  *              the object indicated by the passed device_handle.
 127  *
 128  ******************************************************************************/
 129
 130 acpi_status
 131 acpi_get_current_resources (
 132         acpi_handle                     device_handle,
 133         struct acpi_buffer              *ret_buffer)
 134 {
 135         acpi_status                     status;
 136
 137
 138         ACPI_FUNCTION_TRACE ("acpi_get_current_resources");
 139
 140
 141         /*
 142          * Must have a valid handle and buffer, So we have to have a handle
 143          * and a return buffer structure, and if there is a non-zero buffer length
 144          * we also need a valid pointer in the buffer. If it's a zero buffer length,
 145          * we'll be returning the needed buffer size, so keep going.
 146          */
 147         if (!device_handle) {
 148                 return_ACPI_STATUS (AE_BAD_PARAMETER);
 149         }
 150
 151         status = acpi_ut_validate_buffer (ret_buffer);
 152         if (ACPI_FAILURE (status)) {
 153                 return_ACPI_STATUS (status);
 154         }
 155
 156         status = acpi_rs_get_crs_method_data (device_handle, ret_buffer);
 157         return_ACPI_STATUS (status);
 158 }
 159
 160
 161 /*******************************************************************************
 162  *
 163  * FUNCTION:    acpi_get_possible_resources
 164  *
 165  * PARAMETERS:  device_handle   - a handle to the device object for the
 166  *                                device we are querying
 167  *              ret_buffer      - a pointer to a buffer to receive the
 168  *                                resources for the device
 169  *
 170  * RETURN:      Status
 171  *
 172  * DESCRIPTION: This function is called to get a list of the possible resources
 173  *              for a specific device.  The caller must first acquire a handle
 174  *              for the desired device.  The resource data is placed in the
 175  *              buffer pointed to by the ret_buffer variable.
 176  *
 177  *              If the function fails an appropriate status will be returned
 178  *              and the value of ret_buffer is undefined.
 179  *
 180  ******************************************************************************/
 181
 182 acpi_status
 183 acpi_get_possible_resources (
 184         acpi_handle                     device_handle,
 185         struct acpi_buffer              *ret_buffer)
 186 {
 187         acpi_status                     status;
 188
 189
 190         ACPI_FUNCTION_TRACE ("acpi_get_possible_resources");
 191
 192
 193         /*
 194          * Must have a valid handle and buffer, So we have to have a handle
 195          * and a return buffer structure, and if there is a non-zero buffer length
 196          * we also need a valid pointer in the buffer. If it's a zero buffer length,
 197          * we'll be returning the needed buffer size, so keep going.
 198          */
 199         if (!device_handle) {
 200                 return_ACPI_STATUS (AE_BAD_PARAMETER);
 201         }
 202
 203         status = acpi_ut_validate_buffer (ret_buffer);
 204         if (ACPI_FAILURE (status)) {
 205                 return_ACPI_STATUS (status);
 206         }
 207
 208         status = acpi_rs_get_prs_method_data (device_handle, ret_buffer);
 209         return_ACPI_STATUS (status);
 210 }
 211
 212
 213 /*******************************************************************************
 214  *
 215  * FUNCTION:    acpi_walk_resources
 216  *
 217  * PARAMETERS:  device_handle   - a handle to the device object for the
 218  *                                device we are querying
 219  *              Path            - method name of the resources we want
 220  *                                (METHOD_NAME__CRS or METHOD_NAME__PRS)
 221  *              user_function   - called for each resource
 222  *              Context         - passed to user_function
 223  *
 224  * RETURN:      Status
 225  *
 226  * DESCRIPTION: Retrieves the current or possible resource list for the
 227  *              specified device.  The user_function is called once for
 228  *              each resource in the list.
 229  *
 230  ******************************************************************************/
 231
 232 acpi_status
 233 acpi_walk_resources (
 234         acpi_handle                             device_handle,
 235         char                                    *path,
 236         ACPI_WALK_RESOURCE_CALLBACK     user_function,
 237         void                                    *context)
 238 {
 239         acpi_status                         status;
 240         struct acpi_buffer                  buffer = {ACPI_ALLOCATE_BUFFER, NULL};
 241         struct acpi_resource                *resource;
 242         struct acpi_resource                *buffer_end;
 243
 244
 245         ACPI_FUNCTION_TRACE ("acpi_walk_resources");
 246
 247
 248         if (!device_handle ||
 249                 (ACPI_STRNCMP (path, METHOD_NAME__CRS, sizeof (METHOD_NAME__CRS)) &&
 250                  ACPI_STRNCMP (path, METHOD_NAME__PRS, sizeof (METHOD_NAME__PRS)))) {
 251                 return_ACPI_STATUS (AE_BAD_PARAMETER);
 252         }
 253
 254         status = acpi_rs_get_method_data (device_handle, path, &buffer);
 255         if (ACPI_FAILURE (status)) {
 256                 return_ACPI_STATUS (status);
 257         }
 258
 259         /* Setup pointers */
 260
 261         resource  = (struct acpi_resource *) buffer.pointer;
 262         buffer_end = (struct acpi_resource *) ((u8 *) buffer.pointer + buffer.length);
 263
 264         /* Walk the resource list */
 265
 266         for (;;) {
 267                 if (!resource || resource->id == ACPI_RSTYPE_END_TAG) {
 268                         break;
 269                 }
 270
 271                 status = user_function (resource, context);
 272
 273                 switch (status) {
 274                 case AE_OK:
 275                 case AE_CTRL_DEPTH:
 276
 277                         /* Just keep going */
 278
 279                         status = AE_OK;
 280                         break;
 281
 282                 case AE_CTRL_TERMINATE:
 283
 284                         /* Exit now, with OK stats */
 285
 286                         status = AE_OK;
 287                         goto cleanup;
 288
 289                 default:
 290
 291                         /* All others are valid exceptions */
 292
 293                         goto cleanup;
 294                 }
 295
 296                 /* Get the next resource descriptor */
 297
 298                 resource = ACPI_NEXT_RESOURCE (resource);
 299
 300                 /* Check for end-of-buffer */
 301
 302                 if (resource >= buffer_end) {
 303                         goto cleanup;
 304                 }
 305         }
 306
 307 cleanup:
 308
 309         acpi_os_free (buffer.pointer);
 310         return_ACPI_STATUS (status);
 311 }
 312
 313
 314 /*******************************************************************************
 315  *
 316  * FUNCTION:    acpi_set_current_resources
 317  *
 318  * PARAMETERS:  device_handle   - a handle to the device object for the
 319  *                                device we are changing the resources of
 320  *              in_buffer       - a pointer to a buffer containing the
 321  *                                resources to be set for the device
 322  *
 323  * RETURN:      Status
 324  *
 325  * DESCRIPTION: This function is called to set the current resources for a
 326  *              specific device.  The caller must first acquire a handle for
 327  *              the desired device.  The resource data is passed to the routine
 328  *              the buffer pointed to by the in_buffer variable.
 329  *
 330  ******************************************************************************/
 331
 332 acpi_status
 333 acpi_set_current_resources (
 334         acpi_handle                     device_handle,
 335         struct acpi_buffer              *in_buffer)
 336 {
 337         acpi_status                     status;
 338
 339
 340         ACPI_FUNCTION_TRACE ("acpi_set_current_resources");
 341
 342
 343         /*
 344          * Must have a valid handle and buffer
 345          */
 346         if ((!device_handle)      ||
 347                 (!in_buffer)          ||
 348                 (!in_buffer->pointer) ||
 349                 (!in_buffer->length)) {
 350                 return_ACPI_STATUS (AE_BAD_PARAMETER);
 351         }
 352
 353         status = acpi_rs_set_srs_method_data (device_handle, in_buffer);
 354         return_ACPI_STATUS (status);
 355 }
 356
 357
 358 #define ACPI_COPY_FIELD(out, in, field)  ((out)->field = (in)->field)
 359 #define ACPI_COPY_ADDRESS(out, in)                      \
 360         ACPI_COPY_FIELD(out, in, resource_type);             \
 361         ACPI_COPY_FIELD(out, in, producer_consumer);         \
 362         ACPI_COPY_FIELD(out, in, decode);                    \
 363         ACPI_COPY_FIELD(out, in, min_address_fixed);         \
 364         ACPI_COPY_FIELD(out, in, max_address_fixed);         \
 365         ACPI_COPY_FIELD(out, in, attribute);                 \
 366         ACPI_COPY_FIELD(out, in, granularity);               \
 367         ACPI_COPY_FIELD(out, in, min_address_range);         \
 368         ACPI_COPY_FIELD(out, in, max_address_range);         \
 369         ACPI_COPY_FIELD(out, in, address_translation_offset); \
 370         ACPI_COPY_FIELD(out, in, address_length);            \
 371         ACPI_COPY_FIELD(out, in, resource_source);
 372
 373 /******************************************************************************
 374  *
 375  * FUNCTION:    acpi_resource_to_address64
 376  *
 377  * PARAMETERS:  resource                - Pointer to a resource
 378  *              out                     - Pointer to the users's return
 379  *                                        buffer (a struct
 380  *                                        struct acpi_resource_address64)
 381  *
 382  * RETURN:      Status
 383  *
 384  * DESCRIPTION: If the resource is an address16, address32, or address64,
 385  *              copy it to the address64 return buffer.  This saves the
 386  *              caller from having to duplicate code for different-sized
 387  *              addresses.
 388  *
 389  ******************************************************************************/
 390
 391 acpi_status
 392 acpi_resource_to_address64 (
 393         struct acpi_resource                *resource,
 394         struct acpi_resource_address64      *out)
 395 {
 396         struct acpi_resource_address16      *address16;
 397         struct acpi_resource_address32      *address32;
 398
 399
 400         switch (resource->id) {
 401         case ACPI_RSTYPE_ADDRESS16:
 402
 403                 address16 = (struct acpi_resource_address16 *) &resource->data;
 404                 ACPI_COPY_ADDRESS(out, address16);
 405                 break;
 406
 407
 408         case ACPI_RSTYPE_ADDRESS32:
 409
 410                 address32 = (struct acpi_resource_address32 *) &resource->data;
 411                 ACPI_COPY_ADDRESS(out, address32);
 412                 break;
 413
 414
 415         case ACPI_RSTYPE_ADDRESS64:
 416
 417                 /* Simple copy for 64 bit source */
 418
 419                 ACPI_MEMCPY (out, &resource->data, sizeof (struct acpi_resource_address64));
 420                 break;
 421
 422
 423         default:
 424                 return (AE_BAD_PARAMETER);
 425         }
 426
 427         return (AE_OK);
 428 }