1/****************************************************************************** 2 * 3 * Module Name: evmisc - Miscellaneous event manager support functions 4 * 5 *****************************************************************************/ 6 7/* 8 * Copyright (C) 2000 - 2010, 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#include "acinterp.h" 49 50#define _COMPONENT ACPI_EVENTS 51ACPI_MODULE_NAME("evmisc") 52 53/* Local prototypes */ 54static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context); 55 56static u32 acpi_ev_global_lock_handler(void *context); 57 58static acpi_status acpi_ev_remove_global_lock_handler(void); 59 60/******************************************************************************* 61 * 62 * FUNCTION: acpi_ev_is_notify_object 63 * 64 * PARAMETERS: Node - Node to check 65 * 66 * RETURN: TRUE if notifies allowed on this object 67 * 68 * DESCRIPTION: Check type of node for a object that supports notifies. 69 * 70 * TBD: This could be replaced by a flag bit in the node. 71 * 72 ******************************************************************************/ 73 74u8 acpi_ev_is_notify_object(struct acpi_namespace_node *node) 75{ 76 switch (node->type) { 77 case ACPI_TYPE_DEVICE: 78 case ACPI_TYPE_PROCESSOR: 79 case ACPI_TYPE_THERMAL: 80 /* 81 * These are the ONLY objects that can receive ACPI notifications 82 */ 83 return (TRUE); 84 85 default: 86 return (FALSE); 87 } 88} 89 90/******************************************************************************* 91 * 92 * FUNCTION: acpi_ev_queue_notify_request 93 * 94 * PARAMETERS: Node - NS node for the notified object 95 * notify_value - Value from the Notify() request 96 * 97 * RETURN: Status 98 * 99 * DESCRIPTION: Dispatch a device notification event to a previously 100 * installed handler. 101 * 102 ******************************************************************************/ 103 104acpi_status 105acpi_ev_queue_notify_request(struct acpi_namespace_node * node, 106 u32 notify_value) 107{ 108 union acpi_operand_object *obj_desc; 109 union acpi_operand_object *handler_obj = NULL; 110 union acpi_generic_state *notify_info; 111 acpi_status status = AE_OK; 112 113 ACPI_FUNCTION_NAME(ev_queue_notify_request); 114 115 /* 116 * For value 3 (Ejection Request), some device method may need to be run. 117 * For value 2 (Device Wake) if _PRW exists, the _PS0 method may need 118 * to be run. 119 * For value 0x80 (Status Change) on the power button or sleep button, 120 * initiate soft-off or sleep operation? 121 */ 122 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 123 "Dispatching Notify on [%4.4s] Node %p Value 0x%2.2X (%s)\n", 124 acpi_ut_get_node_name(node), node, notify_value, 125 acpi_ut_get_notify_name(notify_value))); 126 127 /* Get the notify object attached to the NS Node */ 128 129 obj_desc = acpi_ns_get_attached_object(node); 130 if (obj_desc) { 131 132 /* We have the notify object, Get the right handler */ 133 134 switch (node->type) { 135 136 /* Notify allowed only on these types */ 137 138 case ACPI_TYPE_DEVICE: 139 case ACPI_TYPE_THERMAL: 140 case ACPI_TYPE_PROCESSOR: 141 142 if (notify_value <= ACPI_MAX_SYS_NOTIFY) { 143 handler_obj = 144 obj_desc->common_notify.system_notify; 145 } else { 146 handler_obj = 147 obj_desc->common_notify.device_notify; 148 } 149 break; 150 151 default: 152 153 /* All other types are not supported */ 154 155 return (AE_TYPE); 156 } 157 } 158 159 /* 160 * If there is any handler to run, schedule the dispatcher. 161 * Check for: 162 * 1) Global system notify handler 163 * 2) Global device notify handler 164 * 3) Per-device notify handler 165 */ 166 if ((acpi_gbl_system_notify.handler && 167 (notify_value <= ACPI_MAX_SYS_NOTIFY)) || 168 (acpi_gbl_device_notify.handler && 169 (notify_value > ACPI_MAX_SYS_NOTIFY)) || handler_obj) { 170 notify_info = acpi_ut_create_generic_state(); 171 if (!notify_info) { 172 return (AE_NO_MEMORY); 173 } 174 175 if (!handler_obj) { 176 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 177 "Executing system notify handler for Notify (%4.4s, %X) " 178 "node %p\n", 179 acpi_ut_get_node_name(node), 180 notify_value, node)); 181 } 182 183 notify_info->common.descriptor_type = 184 ACPI_DESC_TYPE_STATE_NOTIFY; 185 notify_info->notify.node = node; 186 notify_info->notify.value = (u16) notify_value; 187 notify_info->notify.handler_obj = handler_obj; 188 189 status = 190 acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_ev_notify_dispatch, 191 notify_info); 192 if (ACPI_FAILURE(status)) { 193 acpi_ut_delete_generic_state(notify_info); 194 } 195 } else { 196 /* There is no notify handler (per-device or system) for this device */ 197 198 ACPI_DEBUG_PRINT((ACPI_DB_INFO, 199 "No notify handler for Notify (%4.4s, %X) node %p\n", 200 acpi_ut_get_node_name(node), notify_value, 201 node)); 202 } 203 204 return (status); 205} 206 207/******************************************************************************* 208 * 209 * FUNCTION: acpi_ev_notify_dispatch 210 * 211 * PARAMETERS: Context - To be passed to the notify handler 212 * 213 * RETURN: None. 214 * 215 * DESCRIPTION: Dispatch a device notification event to a previously 216 * installed handler. 217 * 218 ******************************************************************************/ 219 220static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context) 221{ 222 union acpi_generic_state *notify_info = 223 (union acpi_generic_state *)context; 224 acpi_notify_handler global_handler = NULL; 225 void *global_context = NULL; 226 union acpi_operand_object *handler_obj; 227 228 ACPI_FUNCTION_ENTRY(); 229 230 /* 231 * We will invoke a global notify handler if installed. This is done 232 * _before_ we invoke the per-device handler attached to the device. 233 */ 234 if (notify_info->notify.value <= ACPI_MAX_SYS_NOTIFY) { 235 236 /* Global system notification handler */ 237 238 if (acpi_gbl_system_notify.handler) { 239 global_handler = acpi_gbl_system_notify.handler; 240 global_context = acpi_gbl_system_notify.context; 241 } 242 } else { 243 /* Global driver notification handler */ 244 245 if (acpi_gbl_device_notify.handler) { 246 global_handler = acpi_gbl_device_notify.handler; 247 global_context = acpi_gbl_device_notify.context; 248 } 249 } 250 251 /* Invoke the system handler first, if present */ 252 253 if (global_handler) { 254 global_handler(notify_info->notify.node, 255 notify_info->notify.value, global_context); 256 } 257 258 /* Now invoke the per-device handler, if present */ 259 260 handler_obj = notify_info->notify.handler_obj; 261 if (handler_obj) { 262 struct acpi_object_notify_handler *notifier; 263 264 notifier = &handler_obj->notify; 265 while (notifier) { 266 notifier->handler(notify_info->notify.node, 267 notify_info->notify.value, 268 notifier->context); 269 notifier = notifier->next; 270 } 271 } 272 273 /* All done with the info object */ 274 275 acpi_ut_delete_generic_state(notify_info); 276} 277 278/******************************************************************************* 279 * 280 * FUNCTION: acpi_ev_global_lock_handler 281 * 282 * PARAMETERS: Context - From thread interface, not used 283 * 284 * RETURN: ACPI_INTERRUPT_HANDLED 285 * 286 * DESCRIPTION: Invoked directly from the SCI handler when a global lock 287 * release interrupt occurs. Attempt to acquire the global lock, 288 * if successful, signal the thread waiting for the lock. 289 * 290 * NOTE: Assumes that the semaphore can be signaled from interrupt level. If 291 * this is not possible for some reason, a separate thread will have to be 292 * scheduled to do this. 293 * 294 ******************************************************************************/ 295 296static u32 acpi_ev_global_lock_handler(void *context) 297{ 298 u8 acquired = FALSE; 299 300 /* 301 * Attempt to get the lock. 302 * 303 * If we don't get it now, it will be marked pending and we will 304 * take another interrupt when it becomes free. 305 */ 306 ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired); 307 if (acquired) { 308 309 /* Got the lock, now wake all threads waiting for it */ 310 311 acpi_gbl_global_lock_acquired = TRUE; 312 /* Send a unit to the semaphore */ 313 314 if (ACPI_FAILURE 315 (acpi_os_signal_semaphore 316 (acpi_gbl_global_lock_semaphore, 1))) { 317 ACPI_ERROR((AE_INFO, 318 "Could not signal Global Lock semaphore")); 319 } 320 } 321 322 return (ACPI_INTERRUPT_HANDLED); 323} 324 325/******************************************************************************* 326 * 327 * FUNCTION: acpi_ev_init_global_lock_handler 328 * 329 * PARAMETERS: None 330 * 331 * RETURN: Status 332 * 333 * DESCRIPTION: Install a handler for the global lock release event 334 * 335 ******************************************************************************/ 336 337acpi_status acpi_ev_init_global_lock_handler(void) 338{ 339 acpi_status status; 340 341 ACPI_FUNCTION_TRACE(ev_init_global_lock_handler); 342 343 /* Attempt installation of the global lock handler */ 344 345 status = acpi_install_fixed_event_handler(ACPI_EVENT_GLOBAL, 346 acpi_ev_global_lock_handler, 347 NULL); 348 349 /* 350 * If the global lock does not exist on this platform, the attempt to 351 * enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick). 352 * Map to AE_OK, but mark global lock as not present. Any attempt to 353 * actually use the global lock will be flagged with an error. 354 */ 355 if (status == AE_NO_HARDWARE_RESPONSE) { 356 ACPI_ERROR((AE_INFO, 357 "No response from Global Lock hardware, disabling lock")); 358 359 acpi_gbl_global_lock_present = FALSE; 360 return_ACPI_STATUS(AE_OK); 361 } 362 363 acpi_gbl_global_lock_present = TRUE; 364 return_ACPI_STATUS(status); 365} 366 367/******************************************************************************* 368 * 369 * FUNCTION: acpi_ev_remove_global_lock_handler 370 * 371 * PARAMETERS: None 372 * 373 * RETURN: Status 374 * 375 * DESCRIPTION: Remove the handler for the Global Lock 376 * 377 ******************************************************************************/ 378 379static acpi_status acpi_ev_remove_global_lock_handler(void) 380{ 381 acpi_status status; 382 383 ACPI_FUNCTION_TRACE(ev_remove_global_lock_handler); 384 385 acpi_gbl_global_lock_present = FALSE; 386 status = acpi_remove_fixed_event_handler(ACPI_EVENT_GLOBAL, 387 acpi_ev_global_lock_handler); 388 389 return_ACPI_STATUS(status); 390} 391 392/****************************************************************************** 393 * 394 * FUNCTION: acpi_ev_acquire_global_lock 395 * 396 * PARAMETERS: Timeout - Max time to wait for the lock, in millisec. 397 * 398 * RETURN: Status 399 * 400 * DESCRIPTION: Attempt to gain ownership of the Global Lock. 401 * 402 * MUTEX: Interpreter must be locked 403 * 404 * Note: The original implementation allowed multiple threads to "acquire" the 405 * Global Lock, and the OS would hold the lock until the last thread had 406 * released it. However, this could potentially starve the BIOS out of the 407 * lock, especially in the case where there is a tight handshake between the 408 * Embedded Controller driver and the BIOS. Therefore, this implementation 409 * allows only one thread to acquire the HW Global Lock at a time, and makes 410 * the global lock appear as a standard mutex on the OS side. 411 * 412 *****************************************************************************/ 413static acpi_thread_id acpi_ev_global_lock_thread_id; 414static int acpi_ev_global_lock_acquired; 415 416acpi_status acpi_ev_acquire_global_lock(u16 timeout) 417{ 418 acpi_status status = AE_OK; 419 u8 acquired = FALSE; 420 421 ACPI_FUNCTION_TRACE(ev_acquire_global_lock); 422 423 /* 424 * Only one thread can acquire the GL at a time, the global_lock_mutex 425 * enforces this. This interface releases the interpreter if we must wait. 426 */ 427 status = acpi_ex_system_wait_mutex( 428 acpi_gbl_global_lock_mutex->mutex.os_mutex, 0); 429 if (status == AE_TIME) { 430 if (acpi_ev_global_lock_thread_id == acpi_os_get_thread_id()) { 431 acpi_ev_global_lock_acquired++; 432 return AE_OK; 433 } 434 } 435 436 if (ACPI_FAILURE(status)) { 437 status = acpi_ex_system_wait_mutex( 438 acpi_gbl_global_lock_mutex->mutex.os_mutex, 439 timeout); 440 } 441 if (ACPI_FAILURE(status)) { 442 return_ACPI_STATUS(status); 443 } 444 445 acpi_ev_global_lock_thread_id = acpi_os_get_thread_id(); 446 acpi_ev_global_lock_acquired++; 447 448 /* 449 * Update the global lock handle and check for wraparound. The handle is 450 * only used for the external global lock interfaces, but it is updated 451 * here to properly handle the case where a single thread may acquire the 452 * lock via both the AML and the acpi_acquire_global_lock interfaces. The 453 * handle is therefore updated on the first acquire from a given thread 454 * regardless of where the acquisition request originated. 455 */ 456 acpi_gbl_global_lock_handle++; 457 if (acpi_gbl_global_lock_handle == 0) { 458 acpi_gbl_global_lock_handle = 1; 459 } 460 461 /* 462 * Make sure that a global lock actually exists. If not, just treat the 463 * lock as a standard mutex. 464 */ 465 if (!acpi_gbl_global_lock_present) { 466 acpi_gbl_global_lock_acquired = TRUE; 467 return_ACPI_STATUS(AE_OK); 468 } 469 470 /* Attempt to acquire the actual hardware lock */ 471 472 ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired); 473 if (acquired) { 474 475 /* We got the lock */ 476 477 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 478 "Acquired hardware Global Lock\n")); 479 480 acpi_gbl_global_lock_acquired = TRUE; 481 return_ACPI_STATUS(AE_OK); 482 } 483 484 /* 485 * Did not get the lock. The pending bit was set above, and we must now 486 * wait until we get the global lock released interrupt. 487 */ 488 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Waiting for hardware Global Lock\n")); 489 490 /* 491 * Wait for handshake with the global lock interrupt handler. 492 * This interface releases the interpreter if we must wait. 493 */ 494 status = acpi_ex_system_wait_semaphore(acpi_gbl_global_lock_semaphore, 495 ACPI_WAIT_FOREVER); 496 497 return_ACPI_STATUS(status); 498} 499 500/******************************************************************************* 501 * 502 * FUNCTION: acpi_ev_release_global_lock 503 * 504 * PARAMETERS: None 505 * 506 * RETURN: Status 507 * 508 * DESCRIPTION: Releases ownership of the Global Lock. 509 * 510 ******************************************************************************/ 511 512acpi_status acpi_ev_release_global_lock(void) 513{ 514 u8 pending = FALSE; 515 acpi_status status = AE_OK; 516 517 ACPI_FUNCTION_TRACE(ev_release_global_lock); 518 519 /* Lock must be already acquired */ 520 521 if (!acpi_gbl_global_lock_acquired) { 522 ACPI_WARNING((AE_INFO, 523 "Cannot release the ACPI Global Lock, it has not been acquired")); 524 return_ACPI_STATUS(AE_NOT_ACQUIRED); 525 } 526 527 acpi_ev_global_lock_acquired--; 528 if (acpi_ev_global_lock_acquired > 0) { 529 return AE_OK; 530 } 531 532 if (acpi_gbl_global_lock_present) { 533 534 /* Allow any thread to release the lock */ 535 536 ACPI_RELEASE_GLOBAL_LOCK(acpi_gbl_FACS, pending); 537 538 /* 539 * If the pending bit was set, we must write GBL_RLS to the control 540 * register 541 */ 542 if (pending) { 543 status = 544 acpi_write_bit_register 545 (ACPI_BITREG_GLOBAL_LOCK_RELEASE, 546 ACPI_ENABLE_EVENT); 547 } 548 549 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 550 "Released hardware Global Lock\n")); 551 } 552 553 acpi_gbl_global_lock_acquired = FALSE; 554 555 /* Release the local GL mutex */ 556 acpi_ev_global_lock_thread_id = NULL; 557 acpi_ev_global_lock_acquired = 0; 558 acpi_os_release_mutex(acpi_gbl_global_lock_mutex->mutex.os_mutex); 559 return_ACPI_STATUS(status); 560} 561 562/****************************************************************************** 563 * 564 * FUNCTION: acpi_ev_terminate 565 * 566 * PARAMETERS: none 567 * 568 * RETURN: none 569 * 570 * DESCRIPTION: Disable events and free memory allocated for table storage. 571 * 572 ******************************************************************************/ 573 574void acpi_ev_terminate(void) 575{ 576 u32 i; 577 acpi_status status; 578 579 ACPI_FUNCTION_TRACE(ev_terminate); 580 581 if (acpi_gbl_events_initialized) { 582 /* 583 * Disable all event-related functionality. In all cases, on error, 584 * print a message but obviously we don't abort. 585 */ 586 587 /* Disable all fixed events */ 588 589 for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) { 590 status = acpi_disable_event(i, 0); 591 if (ACPI_FAILURE(status)) { 592 ACPI_ERROR((AE_INFO, 593 "Could not disable fixed event %u", 594 (u32) i)); 595 } 596 } 597 598 /* Disable all GPEs in all GPE blocks */ 599 600 status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL); 601 602 /* Remove SCI handler */ 603 604 status = acpi_ev_remove_sci_handler(); 605 if (ACPI_FAILURE(status)) { 606 ACPI_ERROR((AE_INFO, "Could not remove SCI handler")); 607 } 608 609 status = acpi_ev_remove_global_lock_handler(); 610 if (ACPI_FAILURE(status)) { 611 ACPI_ERROR((AE_INFO, 612 "Could not remove Global Lock handler")); 613 } 614 } 615 616 /* Deallocate all handler objects installed within GPE info structs */ 617 618 status = acpi_ev_walk_gpe_list(acpi_ev_delete_gpe_handlers, NULL); 619 620 /* Return to original mode if necessary */ 621 622 if (acpi_gbl_original_mode == ACPI_SYS_MODE_LEGACY) { 623 status = acpi_disable(); 624 if (ACPI_FAILURE(status)) { 625 ACPI_WARNING((AE_INFO, "AcpiDisable failed")); 626 } 627 } 628 return_VOID; 629} 630