drivers/acpi/acpica/rsxface.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: rsxface - Public interfaces to the resource manager
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2008, Intel Corp.
   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 #include <acpi/acpi.h>
  45 #include "accommon.h"
  46 #include "acresrc.h"
  47 #include "acnamesp.h"
  48
  49 #define _COMPONENT          ACPI_RESOURCES
  50 ACPI_MODULE_NAME("rsxface")
  51
  52 /* Local macros for 16,32-bit to 64-bit conversion */
  53 #define ACPI_COPY_FIELD(out, in, field)  ((out)->field = (in)->field)
  54 #define ACPI_COPY_ADDRESS(out, in)                      \
  55         ACPI_COPY_FIELD(out, in, resource_type);             \
  56         ACPI_COPY_FIELD(out, in, producer_consumer);         \
  57         ACPI_COPY_FIELD(out, in, decode);                    \
  58         ACPI_COPY_FIELD(out, in, min_address_fixed);         \
  59         ACPI_COPY_FIELD(out, in, max_address_fixed);         \
  60         ACPI_COPY_FIELD(out, in, info);                      \
  61         ACPI_COPY_FIELD(out, in, granularity);               \
  62         ACPI_COPY_FIELD(out, in, minimum);                   \
  63         ACPI_COPY_FIELD(out, in, maximum);                   \
  64         ACPI_COPY_FIELD(out, in, translation_offset);        \
  65         ACPI_COPY_FIELD(out, in, address_length);            \
  66         ACPI_COPY_FIELD(out, in, resource_source);
  67 /* Local prototypes */
  68 static acpi_status
  69 acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context);
  70
  71 static acpi_status
  72 acpi_rs_validate_parameters(acpi_handle device_handle,
  73                             struct acpi_buffer *buffer,
  74                             struct acpi_namespace_node **return_node);
  75
  76 /*******************************************************************************
  77  *
  78  * FUNCTION:    acpi_rs_validate_parameters
  79  *
  80  * PARAMETERS:  device_handle   - Handle to a device
  81  *              Buffer          - Pointer to a data buffer
  82  *              return_node     - Pointer to where the device node is returned
  83  *
  84  * RETURN:      Status
  85  *
  86  * DESCRIPTION: Common parameter validation for resource interfaces
  87  *
  88  ******************************************************************************/
  89
  90 static acpi_status
  91 acpi_rs_validate_parameters(acpi_handle device_handle,
  92                             struct acpi_buffer *buffer,
  93                             struct acpi_namespace_node **return_node)
  94 {
  95         acpi_status status;
  96         struct acpi_namespace_node *node;
  97
  98         ACPI_FUNCTION_TRACE(rs_validate_parameters);
  99
 100         /*
 101          * Must have a valid handle to an ACPI device
 102          */
 103         if (!device_handle) {
 104                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 105         }
 106
 107         node = acpi_ns_map_handle_to_node(device_handle);
 108         if (!node) {
 109                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 110         }
 111
 112         if (node->type != ACPI_TYPE_DEVICE) {
 113                 return_ACPI_STATUS(AE_TYPE);
 114         }
 115
 116         /*
 117          * Validate the user buffer object
 118          *
 119          * if there is a non-zero buffer length we also need a valid pointer in
 120          * the buffer. If it's a zero buffer length, we'll be returning the
 121          * needed buffer size (later), so keep going.
 122          */
 123         status = acpi_ut_validate_buffer(buffer);
 124         if (ACPI_FAILURE(status)) {
 125                 return_ACPI_STATUS(status);
 126         }
 127
 128         *return_node = node;
 129         return_ACPI_STATUS(AE_OK);
 130 }
 131
 132 /*******************************************************************************
 133  *
 134  * FUNCTION:    acpi_get_irq_routing_table
 135  *
 136  * PARAMETERS:  device_handle   - Handle to the Bus device we are querying
 137  *              ret_buffer      - Pointer to a buffer to receive the
 138  *                                current resources for the device
 139  *
 140  * RETURN:      Status
 141  *
 142  * DESCRIPTION: This function is called to get the IRQ routing table for a
 143  *              specific bus. The caller must first acquire a handle for the
 144  *              desired bus. The routine table is placed in the buffer pointed
 145  *              to by the ret_buffer variable parameter.
 146  *
 147  *              If the function fails an appropriate status will be returned
 148  *              and the value of ret_buffer is undefined.
 149  *
 150  *              This function attempts to execute the _PRT method contained in
 151  *              the object indicated by the passed device_handle.
 152  *
 153  ******************************************************************************/
 154
 155 acpi_status
 156 acpi_get_irq_routing_table(acpi_handle device_handle,
 157                            struct acpi_buffer *ret_buffer)
 158 {
 159         acpi_status status;
 160         struct acpi_namespace_node *node;
 161
 162         ACPI_FUNCTION_TRACE(acpi_get_irq_routing_table);
 163
 164         /* Validate parameters then dispatch to internal routine */
 165
 166         status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
 167         if (ACPI_FAILURE(status)) {
 168                 return_ACPI_STATUS(status);
 169         }
 170
 171         status = acpi_rs_get_prt_method_data(node, ret_buffer);
 172         return_ACPI_STATUS(status);
 173 }
 174
 175 ACPI_EXPORT_SYMBOL(acpi_get_irq_routing_table)
 176
 177 /*******************************************************************************
 178  *
 179  * FUNCTION:    acpi_get_current_resources
 180  *
 181  * PARAMETERS:  device_handle   - Handle to the device object for the
 182  *                                device we are querying
 183  *              ret_buffer      - Pointer to a buffer to receive the
 184  *                                current resources for the device
 185  *
 186  * RETURN:      Status
 187  *
 188  * DESCRIPTION: This function is called to get the current resources for a
 189  *              specific device. The caller must first acquire a handle for
 190  *              the desired device. The resource data is placed in the buffer
 191  *              pointed to by the ret_buffer variable parameter.
 192  *
 193  *              If the function fails an appropriate status will be returned
 194  *              and the value of ret_buffer is undefined.
 195  *
 196  *              This function attempts to execute the _CRS method contained in
 197  *              the object indicated by the passed device_handle.
 198  *
 199  ******************************************************************************/
 200 acpi_status
 201 acpi_get_current_resources(acpi_handle device_handle,
 202                            struct acpi_buffer *ret_buffer)
 203 {
 204         acpi_status status;
 205         struct acpi_namespace_node *node;
 206
 207         ACPI_FUNCTION_TRACE(acpi_get_current_resources);
 208
 209         /* Validate parameters then dispatch to internal routine */
 210
 211         status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
 212         if (ACPI_FAILURE(status)) {
 213                 return_ACPI_STATUS(status);
 214         }
 215
 216         status = acpi_rs_get_crs_method_data(node, ret_buffer);
 217         return_ACPI_STATUS(status);
 218 }
 219
 220 ACPI_EXPORT_SYMBOL(acpi_get_current_resources)
 221 #ifdef ACPI_FUTURE_USAGE
 222 /*******************************************************************************
 223  *
 224  * FUNCTION:    acpi_get_possible_resources
 225  *
 226  * PARAMETERS:  device_handle   - Handle to the device object for the
 227  *                                device we are querying
 228  *              ret_buffer      - Pointer to a buffer to receive the
 229  *                                resources for the device
 230  *
 231  * RETURN:      Status
 232  *
 233  * DESCRIPTION: This function is called to get a list of the possible resources
 234  *              for a specific device. The caller must first acquire a handle
 235  *              for the desired device. The resource data is placed in the
 236  *              buffer pointed to by the ret_buffer variable.
 237  *
 238  *              If the function fails an appropriate status will be returned
 239  *              and the value of ret_buffer is undefined.
 240  *
 241  ******************************************************************************/
 242 acpi_status
 243 acpi_get_possible_resources(acpi_handle device_handle,
 244                             struct acpi_buffer *ret_buffer)
 245 {
 246         acpi_status status;
 247         struct acpi_namespace_node *node;
 248
 249         ACPI_FUNCTION_TRACE(acpi_get_possible_resources);
 250
 251         /* Validate parameters then dispatch to internal routine */
 252
 253         status = acpi_rs_validate_parameters(device_handle, ret_buffer, &node);
 254         if (ACPI_FAILURE(status)) {
 255                 return_ACPI_STATUS(status);
 256         }
 257
 258         status = acpi_rs_get_prs_method_data(node, ret_buffer);
 259         return_ACPI_STATUS(status);
 260 }
 261
 262 ACPI_EXPORT_SYMBOL(acpi_get_possible_resources)
 263 #endif                          /*  ACPI_FUTURE_USAGE  */
 264 /*******************************************************************************
 265  *
 266  * FUNCTION:    acpi_set_current_resources
 267  *
 268  * PARAMETERS:  device_handle   - Handle to the device object for the
 269  *                                device we are setting resources
 270  *              in_buffer       - Pointer to a buffer containing the
 271  *                                resources to be set for the device
 272  *
 273  * RETURN:      Status
 274  *
 275  * DESCRIPTION: This function is called to set the current resources for a
 276  *              specific device. The caller must first acquire a handle for
 277  *              the desired device. The resource data is passed to the routine
 278  *              the buffer pointed to by the in_buffer variable.
 279  *
 280  ******************************************************************************/
 281 acpi_status
 282 acpi_set_current_resources(acpi_handle device_handle,
 283                            struct acpi_buffer *in_buffer)
 284 {
 285         acpi_status status;
 286         struct acpi_namespace_node *node;
 287
 288         ACPI_FUNCTION_TRACE(acpi_set_current_resources);
 289
 290         /* Validate the buffer, don't allow zero length */
 291
 292         if ((!in_buffer) || (!in_buffer->pointer) || (!in_buffer->length)) {
 293                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 294         }
 295
 296         /* Validate parameters then dispatch to internal routine */
 297
 298         status = acpi_rs_validate_parameters(device_handle, in_buffer, &node);
 299         if (ACPI_FAILURE(status)) {
 300                 return_ACPI_STATUS(status);
 301         }
 302
 303         status = acpi_rs_set_srs_method_data(node, in_buffer);
 304         return_ACPI_STATUS(status);
 305 }
 306
 307 ACPI_EXPORT_SYMBOL(acpi_set_current_resources)
 308
 309 /******************************************************************************
 310  *
 311  * FUNCTION:    acpi_resource_to_address64
 312  *
 313  * PARAMETERS:  Resource        - Pointer to a resource
 314  *              Out             - Pointer to the users's return buffer
 315  *                                (a struct acpi_resource_address64)
 316  *
 317  * RETURN:      Status
 318  *
 319  * DESCRIPTION: If the resource is an address16, address32, or address64,
 320  *              copy it to the address64 return buffer. This saves the
 321  *              caller from having to duplicate code for different-sized
 322  *              addresses.
 323  *
 324  ******************************************************************************/
 325 acpi_status
 326 acpi_resource_to_address64(struct acpi_resource *resource,
 327                            struct acpi_resource_address64 *out)
 328 {
 329         struct acpi_resource_address16 *address16;
 330         struct acpi_resource_address32 *address32;
 331
 332         if (!resource || !out) {
 333                 return (AE_BAD_PARAMETER);
 334         }
 335
 336         /* Convert 16 or 32 address descriptor to 64 */
 337
 338         switch (resource->type) {
 339         case ACPI_RESOURCE_TYPE_ADDRESS16:
 340
 341                 address16 =
 342                     ACPI_CAST_PTR(struct acpi_resource_address16,
 343                                   &resource->data);
 344                 ACPI_COPY_ADDRESS(out, address16);
 345                 break;
 346
 347         case ACPI_RESOURCE_TYPE_ADDRESS32:
 348
 349                 address32 =
 350                     ACPI_CAST_PTR(struct acpi_resource_address32,
 351                                   &resource->data);
 352                 ACPI_COPY_ADDRESS(out, address32);
 353                 break;
 354
 355         case ACPI_RESOURCE_TYPE_ADDRESS64:
 356
 357                 /* Simple copy for 64 bit source */
 358
 359                 ACPI_MEMCPY(out, &resource->data,
 360                             sizeof(struct acpi_resource_address64));
 361                 break;
 362
 363         default:
 364                 return (AE_BAD_PARAMETER);
 365         }
 366
 367         return (AE_OK);
 368 }
 369
 370 ACPI_EXPORT_SYMBOL(acpi_resource_to_address64)
 371
 372 /*******************************************************************************
 373  *
 374  * FUNCTION:    acpi_get_vendor_resource
 375  *
 376  * PARAMETERS:  device_handle   - Handle for the parent device object
 377  *              Name            - Method name for the parent resource
 378  *                                (METHOD_NAME__CRS or METHOD_NAME__PRS)
 379  *              Uuid            - Pointer to the UUID to be matched.
 380  *                                includes both subtype and 16-byte UUID
 381  *              ret_buffer      - Where the vendor resource is returned
 382  *
 383  * RETURN:      Status
 384  *
 385  * DESCRIPTION: Walk a resource template for the specified evice to find a
 386  *              vendor-defined resource that matches the supplied UUID and
 387  *              UUID subtype. Returns a struct acpi_resource of type Vendor.
 388  *
 389  ******************************************************************************/
 390 acpi_status
 391 acpi_get_vendor_resource(acpi_handle device_handle,
 392                          char *name,
 393                          struct acpi_vendor_uuid * uuid,
 394                          struct acpi_buffer * ret_buffer)
 395 {
 396         struct acpi_vendor_walk_info info;
 397         acpi_status status;
 398
 399         /* Other parameters are validated by acpi_walk_resources */
 400
 401         if (!uuid || !ret_buffer) {
 402                 return (AE_BAD_PARAMETER);
 403         }
 404
 405         info.uuid = uuid;
 406         info.buffer = ret_buffer;
 407         info.status = AE_NOT_EXIST;
 408
 409         /* Walk the _CRS or _PRS resource list for this device */
 410
 411         status =
 412             acpi_walk_resources(device_handle, name,
 413                                 acpi_rs_match_vendor_resource, &info);
 414         if (ACPI_FAILURE(status)) {
 415                 return (status);
 416         }
 417
 418         return (info.status);
 419 }
 420
 421 ACPI_EXPORT_SYMBOL(acpi_get_vendor_resource)
 422
 423 /*******************************************************************************
 424  *
 425  * FUNCTION:    acpi_rs_match_vendor_resource
 426  *
 427  * PARAMETERS:  acpi_walk_resource_callback
 428  *
 429  * RETURN:      Status
 430  *
 431  * DESCRIPTION: Match a vendor resource via the ACPI 3.0 UUID
 432  *
 433  ******************************************************************************/
 434 static acpi_status
 435 acpi_rs_match_vendor_resource(struct acpi_resource *resource, void *context)
 436 {
 437         struct acpi_vendor_walk_info *info = context;
 438         struct acpi_resource_vendor_typed *vendor;
 439         struct acpi_buffer *buffer;
 440         acpi_status status;
 441
 442         /* Ignore all descriptors except Vendor */
 443
 444         if (resource->type != ACPI_RESOURCE_TYPE_VENDOR) {
 445                 return (AE_OK);
 446         }
 447
 448         vendor = &resource->data.vendor_typed;
 449
 450         /*
 451          * For a valid match, these conditions must hold:
 452          *
 453          * 1) Length of descriptor data must be at least as long as a UUID struct
 454          * 2) The UUID subtypes must match
 455          * 3) The UUID data must match
 456          */
 457         if ((vendor->byte_length < (ACPI_UUID_LENGTH + 1)) ||
 458             (vendor->uuid_subtype != info->uuid->subtype) ||
 459             (ACPI_MEMCMP(vendor->uuid, info->uuid->data, ACPI_UUID_LENGTH))) {
 460                 return (AE_OK);
 461         }
 462
 463         /* Validate/Allocate/Clear caller buffer */
 464
 465         buffer = info->buffer;
 466         status = acpi_ut_initialize_buffer(buffer, resource->length);
 467         if (ACPI_FAILURE(status)) {
 468                 return (status);
 469         }
 470
 471         /* Found the correct resource, copy and return it */
 472
 473         ACPI_MEMCPY(buffer->pointer, resource, resource->length);
 474         buffer->length = resource->length;
 475
 476         /* Found the desired descriptor, terminate resource walk */
 477
 478         info->status = AE_OK;
 479         return (AE_CTRL_TERMINATE);
 480 }
 481
 482 /*******************************************************************************
 483  *
 484  * FUNCTION:    acpi_walk_resources
 485  *
 486  * PARAMETERS:  device_handle   - Handle to the device object for the
 487  *                                device we are querying
 488  *              Name            - Method name of the resources we want
 489  *                                (METHOD_NAME__CRS or METHOD_NAME__PRS)
 490  *              user_function   - Called for each resource
 491  *              Context         - Passed to user_function
 492  *
 493  * RETURN:      Status
 494  *
 495  * DESCRIPTION: Retrieves the current or possible resource list for the
 496  *              specified device. The user_function is called once for
 497  *              each resource in the list.
 498  *
 499  ******************************************************************************/
 500 acpi_status
 501 acpi_walk_resources(acpi_handle device_handle,
 502                     char *name,
 503                     acpi_walk_resource_callback user_function, void *context)
 504 {
 505         acpi_status status;
 506         struct acpi_buffer buffer;
 507         struct acpi_resource *resource;
 508         struct acpi_resource *resource_end;
 509
 510         ACPI_FUNCTION_TRACE(acpi_walk_resources);
 511
 512         /* Parameter validation */
 513
 514         if (!device_handle || !user_function || !name ||
 515             (!ACPI_COMPARE_NAME(name, METHOD_NAME__CRS) &&
 516              !ACPI_COMPARE_NAME(name, METHOD_NAME__PRS))) {
 517                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 518         }
 519
 520         /* Get the _CRS or _PRS resource list */
 521
 522         buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
 523         status = acpi_rs_get_method_data(device_handle, name, &buffer);
 524         if (ACPI_FAILURE(status)) {
 525                 return_ACPI_STATUS(status);
 526         }
 527
 528         /* Buffer now contains the resource list */
 529
 530         resource = ACPI_CAST_PTR(struct acpi_resource, buffer.pointer);
 531         resource_end =
 532             ACPI_ADD_PTR(struct acpi_resource, buffer.pointer, buffer.length);
 533
 534         /* Walk the resource list until the end_tag is found (or buffer end) */
 535
 536         while (resource < resource_end) {
 537
 538                 /* Sanity check the resource */
 539
 540                 if (resource->type > ACPI_RESOURCE_TYPE_MAX) {
 541                         status = AE_AML_INVALID_RESOURCE_TYPE;
 542                         break;
 543                 }
 544
 545                 /* Invoke the user function, abort on any error returned */
 546
 547                 status = user_function(resource, context);
 548                 if (ACPI_FAILURE(status)) {
 549                         if (status == AE_CTRL_TERMINATE) {
 550
 551                                 /* This is an OK termination by the user function */
 552
 553                                 status = AE_OK;
 554                         }
 555                         break;
 556                 }
 557
 558                 /* end_tag indicates end-of-list */
 559
 560                 if (resource->type == ACPI_RESOURCE_TYPE_END_TAG) {
 561                         break;
 562                 }
 563
 564                 /* Get the next resource descriptor */
 565
 566                 resource =
 567                     ACPI_ADD_PTR(struct acpi_resource, resource,
 568                                  resource->length);
 569         }
 570
 571         ACPI_FREE(buffer.pointer);
 572         return_ACPI_STATUS(status);
 573 }
 574
 575 ACPI_EXPORT_SYMBOL(acpi_walk_resources)