1 /****************************************************************************** 2 * 3 * Module Name: evrgnini- ACPI address_space (op_region) init 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 "acevents.h" 47 #include "acnamesp.h" 48 49 #define _COMPONENT ACPI_EVENTS 50 ACPI_MODULE_NAME("evrgnini") 51 52 /* Local prototypes */ 53 static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node); 54 55 /******************************************************************************* 56 * 57 * FUNCTION: acpi_ev_system_memory_region_setup 58 * 59 * PARAMETERS: Handle - Region we are interested in 60 * Function - Start or stop 61 * handler_context - Address space handler context 62 * region_context - Region specific context 63 * 64 * RETURN: Status 65 * 66 * DESCRIPTION: Setup a system_memory operation region 67 * 68 ******************************************************************************/ 69 70 acpi_status 71 acpi_ev_system_memory_region_setup(acpi_handle handle, 72 u32 function, 73 void *handler_context, void **region_context) 74 { 75 union acpi_operand_object *region_desc = 76 (union acpi_operand_object *)handle; 77 struct acpi_mem_space_context *local_region_context; 78 79 ACPI_FUNCTION_TRACE(ev_system_memory_region_setup); 80 81 if (function == ACPI_REGION_DEACTIVATE) { 82 if (*region_context) { 83 local_region_context = 84 (struct acpi_mem_space_context *)*region_context; 85 86 /* Delete a cached mapping if present */ 87 88 if (local_region_context->mapped_length) { 89 acpi_os_unmap_memory(local_region_context-> 90 mapped_logical_address, 91 local_region_context-> 92 mapped_length); 93 } 94 ACPI_FREE(local_region_context); 95 *region_context = NULL; 96 } 97 return_ACPI_STATUS(AE_OK); 98 } 99 100 /* Create a new context */ 101 102 local_region_context = 103 ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_mem_space_context)); 104 if (!(local_region_context)) { 105 return_ACPI_STATUS(AE_NO_MEMORY); 106 } 107 108 /* Save the region length and address for use in the handler */ 109 110 local_region_context->length = region_desc->region.length; 111 local_region_context->address = region_desc->region.address; 112 113 *region_context = local_region_context; 114 return_ACPI_STATUS(AE_OK); 115 } 116 117 /******************************************************************************* 118 * 119 * FUNCTION: acpi_ev_io_space_region_setup 120 * 121 * PARAMETERS: Handle - Region we are interested in 122 * Function - Start or stop 123 * handler_context - Address space handler context 124 * region_context - Region specific context 125 * 126 * RETURN: Status 127 * 128 * DESCRIPTION: Setup a IO operation region 129 * 130 ******************************************************************************/ 131 132 acpi_status 133 acpi_ev_io_space_region_setup(acpi_handle handle, 134 u32 function, 135 void *handler_context, void **region_context) 136 { 137 ACPI_FUNCTION_TRACE(ev_io_space_region_setup); 138 139 if (function == ACPI_REGION_DEACTIVATE) { 140 *region_context = NULL; 141 } else { 142 *region_context = handler_context; 143 } 144 145 return_ACPI_STATUS(AE_OK); 146 } 147 148 /******************************************************************************* 149 * 150 * FUNCTION: acpi_ev_pci_config_region_setup 151 * 152 * PARAMETERS: Handle - Region we are interested in 153 * Function - Start or stop 154 * handler_context - Address space handler context 155 * region_context - Region specific context 156 * 157 * RETURN: Status 158 * 159 * DESCRIPTION: Setup a PCI_Config operation region 160 * 161 * MUTEX: Assumes namespace is not locked 162 * 163 ******************************************************************************/ 164 165 acpi_status 166 acpi_ev_pci_config_region_setup(acpi_handle handle, 167 u32 function, 168 void *handler_context, void **region_context) 169 { 170 acpi_status status = AE_OK; 171 acpi_integer pci_value; 172 struct acpi_pci_id *pci_id = *region_context; 173 union acpi_operand_object *handler_obj; 174 struct acpi_namespace_node *parent_node; 175 struct acpi_namespace_node *pci_root_node; 176 struct acpi_namespace_node *pci_device_node; 177 union acpi_operand_object *region_obj = 178 (union acpi_operand_object *)handle; 179 180 ACPI_FUNCTION_TRACE(ev_pci_config_region_setup); 181 182 handler_obj = region_obj->region.handler; 183 if (!handler_obj) { 184 /* 185 * No installed handler. This shouldn't happen because the dispatch 186 * routine checks before we get here, but we check again just in case. 187 */ 188 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 189 "Attempting to init a region %p, with no handler\n", 190 region_obj)); 191 return_ACPI_STATUS(AE_NOT_EXIST); 192 } 193 194 *region_context = NULL; 195 if (function == ACPI_REGION_DEACTIVATE) { 196 if (pci_id) { 197 ACPI_FREE(pci_id); 198 } 199 return_ACPI_STATUS(status); 200 } 201 202 parent_node = acpi_ns_get_parent_node(region_obj->region.node); 203 204 /* 205 * Get the _SEG and _BBN values from the device upon which the handler 206 * is installed. 207 * 208 * We need to get the _SEG and _BBN objects relative to the PCI BUS device. 209 * This is the device the handler has been registered to handle. 210 */ 211 212 /* 213 * If the address_space.Node is still pointing to the root, we need 214 * to scan upward for a PCI Root bridge and re-associate the op_region 215 * handlers with that device. 216 */ 217 if (handler_obj->address_space.node == acpi_gbl_root_node) { 218 219 /* Start search from the parent object */ 220 221 pci_root_node = parent_node; 222 while (pci_root_node != acpi_gbl_root_node) { 223 224 /* Get the _HID/_CID in order to detect a root_bridge */ 225 226 if (acpi_ev_is_pci_root_bridge(pci_root_node)) { 227 228 /* Install a handler for this PCI root bridge */ 229 230 status = 231 acpi_install_address_space_handler((acpi_handle) pci_root_node, ACPI_ADR_SPACE_PCI_CONFIG, ACPI_DEFAULT_HANDLER, NULL, NULL); 232 if (ACPI_FAILURE(status)) { 233 if (status == AE_SAME_HANDLER) { 234 /* 235 * It is OK if the handler is already installed on the 236 * root bridge. Still need to return a context object 237 * for the new PCI_Config operation region, however. 238 */ 239 status = AE_OK; 240 } else { 241 ACPI_EXCEPTION((AE_INFO, status, 242 "Could not install PciConfig handler " 243 "for Root Bridge %4.4s", 244 acpi_ut_get_node_name 245 (pci_root_node))); 246 } 247 } 248 break; 249 } 250 251 pci_root_node = acpi_ns_get_parent_node(pci_root_node); 252 } 253 254 /* PCI root bridge not found, use namespace root node */ 255 } else { 256 pci_root_node = handler_obj->address_space.node; 257 } 258 259 /* 260 * If this region is now initialized, we are done. 261 * (install_address_space_handler could have initialized it) 262 */ 263 if (region_obj->region.flags & AOPOBJ_SETUP_COMPLETE) { 264 return_ACPI_STATUS(AE_OK); 265 } 266 267 /* Region is still not initialized. Create a new context */ 268 269 pci_id = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pci_id)); 270 if (!pci_id) { 271 return_ACPI_STATUS(AE_NO_MEMORY); 272 } 273 274 /* 275 * For PCI_Config space access, we need the segment, bus, device and 276 * function numbers. Acquire them here. 277 * 278 * Find the parent device object. (This allows the operation region to be 279 * within a subscope under the device, such as a control method.) 280 */ 281 pci_device_node = region_obj->region.node; 282 while (pci_device_node && (pci_device_node->type != ACPI_TYPE_DEVICE)) { 283 pci_device_node = acpi_ns_get_parent_node(pci_device_node); 284 } 285 286 if (!pci_device_node) { 287 ACPI_FREE(pci_id); 288 return_ACPI_STATUS(AE_AML_OPERAND_TYPE); 289 } 290 291 /* 292 * Get the PCI device and function numbers from the _ADR object contained 293 * in the parent's scope. 294 */ 295 status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, 296 pci_device_node, &pci_value); 297 298 /* 299 * The default is zero, and since the allocation above zeroed the data, 300 * just do nothing on failure. 301 */ 302 if (ACPI_SUCCESS(status)) { 303 pci_id->device = ACPI_HIWORD(ACPI_LODWORD(pci_value)); 304 pci_id->function = ACPI_LOWORD(ACPI_LODWORD(pci_value)); 305 } 306 307 /* The PCI segment number comes from the _SEG method */ 308 309 status = acpi_ut_evaluate_numeric_object(METHOD_NAME__SEG, 310 pci_root_node, &pci_value); 311 if (ACPI_SUCCESS(status)) { 312 pci_id->segment = ACPI_LOWORD(pci_value); 313 } 314 315 /* The PCI bus number comes from the _BBN method */ 316 317 status = acpi_ut_evaluate_numeric_object(METHOD_NAME__BBN, 318 pci_root_node, &pci_value); 319 if (ACPI_SUCCESS(status)) { 320 pci_id->bus = ACPI_LOWORD(pci_value); 321 } 322 323 /* Complete this device's pci_id */ 324 325 acpi_os_derive_pci_id(pci_root_node, region_obj->region.node, &pci_id); 326 327 *region_context = pci_id; 328 return_ACPI_STATUS(AE_OK); 329 } 330 331 /******************************************************************************* 332 * 333 * FUNCTION: acpi_ev_is_pci_root_bridge 334 * 335 * PARAMETERS: Node - Device node being examined 336 * 337 * RETURN: TRUE if device is a PCI/PCI-Express Root Bridge 338 * 339 * DESCRIPTION: Determine if the input device represents a PCI Root Bridge by 340 * examining the _HID and _CID for the device. 341 * 342 ******************************************************************************/ 343 344 static u8 acpi_ev_is_pci_root_bridge(struct acpi_namespace_node *node) 345 { 346 acpi_status status; 347 struct acpica_device_id *hid; 348 struct acpica_device_id_list *cid; 349 u32 i; 350 u8 match; 351 352 /* Get the _HID and check for a PCI Root Bridge */ 353 354 status = acpi_ut_execute_HID(node, &hid); 355 if (ACPI_FAILURE(status)) { 356 return (FALSE); 357 } 358 359 match = acpi_ut_is_pci_root_bridge(hid->string); 360 ACPI_FREE(hid); 361 362 if (match) { 363 return (TRUE); 364 } 365 366 /* The _HID did not match. Get the _CID and check for a PCI Root Bridge */ 367 368 status = acpi_ut_execute_CID(node, &cid); 369 if (ACPI_FAILURE(status)) { 370 return (FALSE); 371 } 372 373 /* Check all _CIDs in the returned list */ 374 375 for (i = 0; i < cid->count; i++) { 376 if (acpi_ut_is_pci_root_bridge(cid->ids[i].string)) { 377 ACPI_FREE(cid); 378 return (TRUE); 379 } 380 } 381 382 ACPI_FREE(cid); 383 return (FALSE); 384 } 385 386 /******************************************************************************* 387 * 388 * FUNCTION: acpi_ev_pci_bar_region_setup 389 * 390 * PARAMETERS: Handle - Region we are interested in 391 * Function - Start or stop 392 * handler_context - Address space handler context 393 * region_context - Region specific context 394 * 395 * RETURN: Status 396 * 397 * DESCRIPTION: Setup a pci_bAR operation region 398 * 399 * MUTEX: Assumes namespace is not locked 400 * 401 ******************************************************************************/ 402 403 acpi_status 404 acpi_ev_pci_bar_region_setup(acpi_handle handle, 405 u32 function, 406 void *handler_context, void **region_context) 407 { 408 ACPI_FUNCTION_TRACE(ev_pci_bar_region_setup); 409 410 return_ACPI_STATUS(AE_OK); 411 } 412 413 /******************************************************************************* 414 * 415 * FUNCTION: acpi_ev_cmos_region_setup 416 * 417 * PARAMETERS: Handle - Region we are interested in 418 * Function - Start or stop 419 * handler_context - Address space handler context 420 * region_context - Region specific context 421 * 422 * RETURN: Status 423 * 424 * DESCRIPTION: Setup a CMOS operation region 425 * 426 * MUTEX: Assumes namespace is not locked 427 * 428 ******************************************************************************/ 429 430 acpi_status 431 acpi_ev_cmos_region_setup(acpi_handle handle, 432 u32 function, 433 void *handler_context, void **region_context) 434 { 435 ACPI_FUNCTION_TRACE(ev_cmos_region_setup); 436 437 return_ACPI_STATUS(AE_OK); 438 } 439 440 /******************************************************************************* 441 * 442 * FUNCTION: acpi_ev_default_region_setup 443 * 444 * PARAMETERS: Handle - Region we are interested in 445 * Function - Start or stop 446 * handler_context - Address space handler context 447 * region_context - Region specific context 448 * 449 * RETURN: Status 450 * 451 * DESCRIPTION: Default region initialization 452 * 453 ******************************************************************************/ 454 455 acpi_status 456 acpi_ev_default_region_setup(acpi_handle handle, 457 u32 function, 458 void *handler_context, void **region_context) 459 { 460 ACPI_FUNCTION_TRACE(ev_default_region_setup); 461 462 if (function == ACPI_REGION_DEACTIVATE) { 463 *region_context = NULL; 464 } else { 465 *region_context = handler_context; 466 } 467 468 return_ACPI_STATUS(AE_OK); 469 } 470 471 /******************************************************************************* 472 * 473 * FUNCTION: acpi_ev_initialize_region 474 * 475 * PARAMETERS: region_obj - Region we are initializing 476 * acpi_ns_locked - Is namespace locked? 477 * 478 * RETURN: Status 479 * 480 * DESCRIPTION: Initializes the region, finds any _REG methods and saves them 481 * for execution at a later time 482 * 483 * Get the appropriate address space handler for a newly 484 * created region. 485 * 486 * This also performs address space specific initialization. For 487 * example, PCI regions must have an _ADR object that contains 488 * a PCI address in the scope of the definition. This address is 489 * required to perform an access to PCI config space. 490 * 491 * MUTEX: Interpreter should be unlocked, because we may run the _REG 492 * method for this region. 493 * 494 ******************************************************************************/ 495 496 acpi_status 497 acpi_ev_initialize_region(union acpi_operand_object *region_obj, 498 u8 acpi_ns_locked) 499 { 500 union acpi_operand_object *handler_obj; 501 union acpi_operand_object *obj_desc; 502 acpi_adr_space_type space_id; 503 struct acpi_namespace_node *node; 504 acpi_status status; 505 struct acpi_namespace_node *method_node; 506 acpi_name *reg_name_ptr = (acpi_name *) METHOD_NAME__REG; 507 union acpi_operand_object *region_obj2; 508 509 ACPI_FUNCTION_TRACE_U32(ev_initialize_region, acpi_ns_locked); 510 511 if (!region_obj) { 512 return_ACPI_STATUS(AE_BAD_PARAMETER); 513 } 514 515 if (region_obj->common.flags & AOPOBJ_OBJECT_INITIALIZED) { 516 return_ACPI_STATUS(AE_OK); 517 } 518 519 region_obj2 = acpi_ns_get_secondary_object(region_obj); 520 if (!region_obj2) { 521 return_ACPI_STATUS(AE_NOT_EXIST); 522 } 523 524 node = acpi_ns_get_parent_node(region_obj->region.node); 525 space_id = region_obj->region.space_id; 526 527 /* Setup defaults */ 528 529 region_obj->region.handler = NULL; 530 region_obj2->extra.method_REG = NULL; 531 region_obj->common.flags &= ~(AOPOBJ_SETUP_COMPLETE); 532 region_obj->common.flags |= AOPOBJ_OBJECT_INITIALIZED; 533 534 /* Find any "_REG" method associated with this region definition */ 535 536 status = 537 acpi_ns_search_one_scope(*reg_name_ptr, node, ACPI_TYPE_METHOD, 538 &method_node); 539 if (ACPI_SUCCESS(status)) { 540 /* 541 * The _REG method is optional and there can be only one per region 542 * definition. This will be executed when the handler is attached 543 * or removed 544 */ 545 region_obj2->extra.method_REG = method_node; 546 } 547 548 /* 549 * The following loop depends upon the root Node having no parent 550 * ie: acpi_gbl_root_node->parent_entry being set to NULL 551 */ 552 while (node) { 553 554 /* Check to see if a handler exists */ 555 556 handler_obj = NULL; 557 obj_desc = acpi_ns_get_attached_object(node); 558 if (obj_desc) { 559 560 /* Can only be a handler if the object exists */ 561 562 switch (node->type) { 563 case ACPI_TYPE_DEVICE: 564 565 handler_obj = obj_desc->device.handler; 566 break; 567 568 case ACPI_TYPE_PROCESSOR: 569 570 handler_obj = obj_desc->processor.handler; 571 break; 572 573 case ACPI_TYPE_THERMAL: 574 575 handler_obj = obj_desc->thermal_zone.handler; 576 break; 577 578 default: 579 /* Ignore other objects */ 580 break; 581 } 582 583 while (handler_obj) { 584 585 /* Is this handler of the correct type? */ 586 587 if (handler_obj->address_space.space_id == 588 space_id) { 589 590 /* Found correct handler */ 591 592 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 593 "Found handler %p for region %p in obj %p\n", 594 handler_obj, 595 region_obj, 596 obj_desc)); 597 598 status = 599 acpi_ev_attach_region(handler_obj, 600 region_obj, 601 acpi_ns_locked); 602 603 /* 604 * Tell all users that this region is usable by 605 * running the _REG method 606 */ 607 if (acpi_ns_locked) { 608 status = 609 acpi_ut_release_mutex 610 (ACPI_MTX_NAMESPACE); 611 if (ACPI_FAILURE(status)) { 612 return_ACPI_STATUS 613 (status); 614 } 615 } 616 617 status = 618 acpi_ev_execute_reg_method 619 (region_obj, 1); 620 621 if (acpi_ns_locked) { 622 status = 623 acpi_ut_acquire_mutex 624 (ACPI_MTX_NAMESPACE); 625 if (ACPI_FAILURE(status)) { 626 return_ACPI_STATUS 627 (status); 628 } 629 } 630 631 return_ACPI_STATUS(AE_OK); 632 } 633 634 /* Try next handler in the list */ 635 636 handler_obj = handler_obj->address_space.next; 637 } 638 } 639 640 /* This node does not have the handler we need; Pop up one level */ 641 642 node = acpi_ns_get_parent_node(node); 643 } 644 645 /* If we get here, there is no handler for this region */ 646 647 ACPI_DEBUG_PRINT((ACPI_DB_OPREGION, 648 "No handler for RegionType %s(%X) (RegionObj %p)\n", 649 acpi_ut_get_region_name(space_id), space_id, 650 region_obj)); 651 652 return_ACPI_STATUS(AE_NOT_EXIST); 653 } 654