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