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