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