1 /****************************************************************************** 2 * 3 * Module Name: utxface - External interfaces, miscellaneous utility functions 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 "acdebug.h" 49 50 #define _COMPONENT ACPI_UTILITIES 51 ACPI_MODULE_NAME("utxface") 52 53 /******************************************************************************* 54 * 55 * FUNCTION: acpi_terminate 56 * 57 * PARAMETERS: None 58 * 59 * RETURN: Status 60 * 61 * DESCRIPTION: Shutdown the ACPICA subsystem and release all resources. 62 * 63 ******************************************************************************/ 64 acpi_status __init acpi_terminate(void) 65 { 66 acpi_status status; 67 68 ACPI_FUNCTION_TRACE(acpi_terminate); 69 70 /* Just exit if subsystem is already shutdown */ 71 72 if (acpi_gbl_shutdown) { 73 ACPI_ERROR((AE_INFO, "ACPI Subsystem is already terminated")); 74 return_ACPI_STATUS(AE_OK); 75 } 76 77 /* Subsystem appears active, go ahead and shut it down */ 78 79 acpi_gbl_shutdown = TRUE; 80 acpi_gbl_startup_flags = 0; 81 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n")); 82 83 /* Terminate the AML Debugger if present */ 84 85 ACPI_DEBUGGER_EXEC(acpi_gbl_db_terminate_threads = TRUE); 86 87 /* Shutdown and free all resources */ 88 89 acpi_ut_subsystem_shutdown(); 90 91 /* Free the mutex objects */ 92 93 acpi_ut_mutex_terminate(); 94 95 #ifdef ACPI_DEBUGGER 96 97 /* Shut down the debugger */ 98 99 acpi_db_terminate(); 100 #endif 101 102 /* Now we can shutdown the OS-dependent layer */ 103 104 status = acpi_os_terminate(); 105 return_ACPI_STATUS(status); 106 } 107 108 ACPI_EXPORT_SYMBOL_INIT(acpi_terminate) 109 110 #ifndef ACPI_ASL_COMPILER 111 #ifdef ACPI_FUTURE_USAGE 112 /******************************************************************************* 113 * 114 * FUNCTION: acpi_subsystem_status 115 * 116 * PARAMETERS: None 117 * 118 * RETURN: Status of the ACPI subsystem 119 * 120 * DESCRIPTION: Other drivers that use the ACPI subsystem should call this 121 * before making any other calls, to ensure the subsystem 122 * initialized successfully. 123 * 124 ******************************************************************************/ 125 acpi_status acpi_subsystem_status(void) 126 { 127 128 if (acpi_gbl_startup_flags & ACPI_INITIALIZED_OK) { 129 return (AE_OK); 130 } else { 131 return (AE_ERROR); 132 } 133 } 134 135 ACPI_EXPORT_SYMBOL(acpi_subsystem_status) 136 137 /******************************************************************************* 138 * 139 * FUNCTION: acpi_get_system_info 140 * 141 * PARAMETERS: out_buffer - A buffer to receive the resources for the 142 * device 143 * 144 * RETURN: status - the status of the call 145 * 146 * DESCRIPTION: This function is called to get information about the current 147 * state of the ACPI subsystem. It will return system information 148 * in the out_buffer. 149 * 150 * If the function fails an appropriate status will be returned 151 * and the value of out_buffer is undefined. 152 * 153 ******************************************************************************/ 154 acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer) 155 { 156 struct acpi_system_info *info_ptr; 157 acpi_status status; 158 159 ACPI_FUNCTION_TRACE(acpi_get_system_info); 160 161 /* Parameter validation */ 162 163 status = acpi_ut_validate_buffer(out_buffer); 164 if (ACPI_FAILURE(status)) { 165 return_ACPI_STATUS(status); 166 } 167 168 /* Validate/Allocate/Clear caller buffer */ 169 170 status = 171 acpi_ut_initialize_buffer(out_buffer, 172 sizeof(struct acpi_system_info)); 173 if (ACPI_FAILURE(status)) { 174 return_ACPI_STATUS(status); 175 } 176 177 /* 178 * Populate the return buffer 179 */ 180 info_ptr = (struct acpi_system_info *)out_buffer->pointer; 181 182 info_ptr->acpi_ca_version = ACPI_CA_VERSION; 183 184 /* System flags (ACPI capabilities) */ 185 186 info_ptr->flags = ACPI_SYS_MODE_ACPI; 187 188 /* Timer resolution - 24 or 32 bits */ 189 190 if (acpi_gbl_FADT.flags & ACPI_FADT_32BIT_TIMER) { 191 info_ptr->timer_resolution = 24; 192 } else { 193 info_ptr->timer_resolution = 32; 194 } 195 196 /* Clear the reserved fields */ 197 198 info_ptr->reserved1 = 0; 199 info_ptr->reserved2 = 0; 200 201 /* Current debug levels */ 202 203 info_ptr->debug_layer = acpi_dbg_layer; 204 info_ptr->debug_level = acpi_dbg_level; 205 206 return_ACPI_STATUS(AE_OK); 207 } 208 209 ACPI_EXPORT_SYMBOL(acpi_get_system_info) 210 211 /******************************************************************************* 212 * 213 * FUNCTION: acpi_get_statistics 214 * 215 * PARAMETERS: stats - Where the statistics are returned 216 * 217 * RETURN: status - the status of the call 218 * 219 * DESCRIPTION: Get the contents of the various system counters 220 * 221 ******************************************************************************/ 222 acpi_status acpi_get_statistics(struct acpi_statistics *stats) 223 { 224 ACPI_FUNCTION_TRACE(acpi_get_statistics); 225 226 /* Parameter validation */ 227 228 if (!stats) { 229 return_ACPI_STATUS(AE_BAD_PARAMETER); 230 } 231 232 /* Various interrupt-based event counters */ 233 234 stats->sci_count = acpi_sci_count; 235 stats->gpe_count = acpi_gpe_count; 236 237 memcpy(stats->fixed_event_count, acpi_fixed_event_count, 238 sizeof(acpi_fixed_event_count)); 239 240 /* Other counters */ 241 242 stats->method_count = acpi_method_count; 243 244 return_ACPI_STATUS(AE_OK); 245 } 246 247 ACPI_EXPORT_SYMBOL(acpi_get_statistics) 248 249 /***************************************************************************** 250 * 251 * FUNCTION: acpi_install_initialization_handler 252 * 253 * PARAMETERS: handler - Callback procedure 254 * function - Not (currently) used, see below 255 * 256 * RETURN: Status 257 * 258 * DESCRIPTION: Install an initialization handler 259 * 260 * TBD: When a second function is added, must save the Function also. 261 * 262 ****************************************************************************/ 263 acpi_status 264 acpi_install_initialization_handler(acpi_init_handler handler, u32 function) 265 { 266 267 if (!handler) { 268 return (AE_BAD_PARAMETER); 269 } 270 271 if (acpi_gbl_init_handler) { 272 return (AE_ALREADY_EXISTS); 273 } 274 275 acpi_gbl_init_handler = handler; 276 return (AE_OK); 277 } 278 279 ACPI_EXPORT_SYMBOL(acpi_install_initialization_handler) 280 #endif /* ACPI_FUTURE_USAGE */ 281 282 /***************************************************************************** 283 * 284 * FUNCTION: acpi_purge_cached_objects 285 * 286 * PARAMETERS: None 287 * 288 * RETURN: Status 289 * 290 * DESCRIPTION: Empty all caches (delete the cached objects) 291 * 292 ****************************************************************************/ 293 acpi_status acpi_purge_cached_objects(void) 294 { 295 ACPI_FUNCTION_TRACE(acpi_purge_cached_objects); 296 297 (void)acpi_os_purge_cache(acpi_gbl_state_cache); 298 (void)acpi_os_purge_cache(acpi_gbl_operand_cache); 299 (void)acpi_os_purge_cache(acpi_gbl_ps_node_cache); 300 (void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache); 301 302 return_ACPI_STATUS(AE_OK); 303 } 304 305 ACPI_EXPORT_SYMBOL(acpi_purge_cached_objects) 306 307 /***************************************************************************** 308 * 309 * FUNCTION: acpi_install_interface 310 * 311 * PARAMETERS: interface_name - The interface to install 312 * 313 * RETURN: Status 314 * 315 * DESCRIPTION: Install an _OSI interface to the global list 316 * 317 ****************************************************************************/ 318 acpi_status acpi_install_interface(acpi_string interface_name) 319 { 320 acpi_status status; 321 struct acpi_interface_info *interface_info; 322 323 /* Parameter validation */ 324 325 if (!interface_name || (strlen(interface_name) == 0)) { 326 return (AE_BAD_PARAMETER); 327 } 328 329 status = acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER); 330 if (ACPI_FAILURE(status)) { 331 return (status); 332 } 333 334 /* Check if the interface name is already in the global list */ 335 336 interface_info = acpi_ut_get_interface(interface_name); 337 if (interface_info) { 338 /* 339 * The interface already exists in the list. This is OK if the 340 * interface has been marked invalid -- just clear the bit. 341 */ 342 if (interface_info->flags & ACPI_OSI_INVALID) { 343 interface_info->flags &= ~ACPI_OSI_INVALID; 344 status = AE_OK; 345 } else { 346 status = AE_ALREADY_EXISTS; 347 } 348 } else { 349 /* New interface name, install into the global list */ 350 351 status = acpi_ut_install_interface(interface_name); 352 } 353 354 acpi_os_release_mutex(acpi_gbl_osi_mutex); 355 return (status); 356 } 357 358 ACPI_EXPORT_SYMBOL(acpi_install_interface) 359 360 /***************************************************************************** 361 * 362 * FUNCTION: acpi_remove_interface 363 * 364 * PARAMETERS: interface_name - The interface to remove 365 * 366 * RETURN: Status 367 * 368 * DESCRIPTION: Remove an _OSI interface from the global list 369 * 370 ****************************************************************************/ 371 acpi_status acpi_remove_interface(acpi_string interface_name) 372 { 373 acpi_status status; 374 375 /* Parameter validation */ 376 377 if (!interface_name || (strlen(interface_name) == 0)) { 378 return (AE_BAD_PARAMETER); 379 } 380 381 status = acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER); 382 if (ACPI_FAILURE(status)) { 383 return (status); 384 } 385 386 status = acpi_ut_remove_interface(interface_name); 387 388 acpi_os_release_mutex(acpi_gbl_osi_mutex); 389 return (status); 390 } 391 392 ACPI_EXPORT_SYMBOL(acpi_remove_interface) 393 394 /***************************************************************************** 395 * 396 * FUNCTION: acpi_install_interface_handler 397 * 398 * PARAMETERS: handler - The _OSI interface handler to install 399 * NULL means "remove existing handler" 400 * 401 * RETURN: Status 402 * 403 * DESCRIPTION: Install a handler for the predefined _OSI ACPI method. 404 * invoked during execution of the internal implementation of 405 * _OSI. A NULL handler simply removes any existing handler. 406 * 407 ****************************************************************************/ 408 acpi_status acpi_install_interface_handler(acpi_interface_handler handler) 409 { 410 acpi_status status; 411 412 status = acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER); 413 if (ACPI_FAILURE(status)) { 414 return (status); 415 } 416 417 if (handler && acpi_gbl_interface_handler) { 418 status = AE_ALREADY_EXISTS; 419 } else { 420 acpi_gbl_interface_handler = handler; 421 } 422 423 acpi_os_release_mutex(acpi_gbl_osi_mutex); 424 return (status); 425 } 426 427 ACPI_EXPORT_SYMBOL(acpi_install_interface_handler) 428 429 /***************************************************************************** 430 * 431 * FUNCTION: acpi_update_interfaces 432 * 433 * PARAMETERS: action - Actions to be performed during the 434 * update 435 * 436 * RETURN: Status 437 * 438 * DESCRIPTION: Update _OSI interface strings, disabling or enabling OS vendor 439 * string or/and feature group strings. 440 * 441 ****************************************************************************/ 442 acpi_status acpi_update_interfaces(u8 action) 443 { 444 acpi_status status; 445 446 status = acpi_os_acquire_mutex(acpi_gbl_osi_mutex, ACPI_WAIT_FOREVER); 447 if (ACPI_FAILURE(status)) { 448 return (status); 449 } 450 451 status = acpi_ut_update_interfaces(action); 452 453 acpi_os_release_mutex(acpi_gbl_osi_mutex); 454 return (status); 455 } 456 457 /***************************************************************************** 458 * 459 * FUNCTION: acpi_check_address_range 460 * 461 * PARAMETERS: space_id - Address space ID 462 * address - Start address 463 * length - Length 464 * warn - TRUE if warning on overlap desired 465 * 466 * RETURN: Count of the number of conflicts detected. 467 * 468 * DESCRIPTION: Check if the input address range overlaps any of the 469 * ASL operation region address ranges. 470 * 471 ****************************************************************************/ 472 473 u32 474 acpi_check_address_range(acpi_adr_space_type space_id, 475 acpi_physical_address address, 476 acpi_size length, u8 warn) 477 { 478 u32 overlaps; 479 acpi_status status; 480 481 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 482 if (ACPI_FAILURE(status)) { 483 return (0); 484 } 485 486 overlaps = acpi_ut_check_address_range(space_id, address, 487 (u32)length, warn); 488 489 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 490 return (overlaps); 491 } 492 493 ACPI_EXPORT_SYMBOL(acpi_check_address_range) 494 #endif /* !ACPI_ASL_COMPILER */ 495 /******************************************************************************* 496 * 497 * FUNCTION: acpi_decode_pld_buffer 498 * 499 * PARAMETERS: in_buffer - Buffer returned by _PLD method 500 * length - Length of the in_buffer 501 * return_buffer - Where the decode buffer is returned 502 * 503 * RETURN: Status and the decoded _PLD buffer. User must deallocate 504 * the buffer via ACPI_FREE. 505 * 506 * DESCRIPTION: Decode the bit-packed buffer returned by the _PLD method into 507 * a local struct that is much more useful to an ACPI driver. 508 * 509 ******************************************************************************/ 510 acpi_status 511 acpi_decode_pld_buffer(u8 *in_buffer, 512 acpi_size length, struct acpi_pld_info ** return_buffer) 513 { 514 struct acpi_pld_info *pld_info; 515 u32 *buffer = ACPI_CAST_PTR(u32, in_buffer); 516 u32 dword; 517 518 /* Parameter validation */ 519 520 if (!in_buffer || !return_buffer || (length < 16)) { 521 return (AE_BAD_PARAMETER); 522 } 523 524 pld_info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_pld_info)); 525 if (!pld_info) { 526 return (AE_NO_MEMORY); 527 } 528 529 /* First 32-bit DWord */ 530 531 ACPI_MOVE_32_TO_32(&dword, &buffer[0]); 532 pld_info->revision = ACPI_PLD_GET_REVISION(&dword); 533 pld_info->ignore_color = ACPI_PLD_GET_IGNORE_COLOR(&dword); 534 pld_info->red = ACPI_PLD_GET_RED(&dword); 535 pld_info->green = ACPI_PLD_GET_GREEN(&dword); 536 pld_info->blue = ACPI_PLD_GET_BLUE(&dword); 537 538 /* Second 32-bit DWord */ 539 540 ACPI_MOVE_32_TO_32(&dword, &buffer[1]); 541 pld_info->width = ACPI_PLD_GET_WIDTH(&dword); 542 pld_info->height = ACPI_PLD_GET_HEIGHT(&dword); 543 544 /* Third 32-bit DWord */ 545 546 ACPI_MOVE_32_TO_32(&dword, &buffer[2]); 547 pld_info->user_visible = ACPI_PLD_GET_USER_VISIBLE(&dword); 548 pld_info->dock = ACPI_PLD_GET_DOCK(&dword); 549 pld_info->lid = ACPI_PLD_GET_LID(&dword); 550 pld_info->panel = ACPI_PLD_GET_PANEL(&dword); 551 pld_info->vertical_position = ACPI_PLD_GET_VERTICAL(&dword); 552 pld_info->horizontal_position = ACPI_PLD_GET_HORIZONTAL(&dword); 553 pld_info->shape = ACPI_PLD_GET_SHAPE(&dword); 554 pld_info->group_orientation = ACPI_PLD_GET_ORIENTATION(&dword); 555 pld_info->group_token = ACPI_PLD_GET_TOKEN(&dword); 556 pld_info->group_position = ACPI_PLD_GET_POSITION(&dword); 557 pld_info->bay = ACPI_PLD_GET_BAY(&dword); 558 559 /* Fourth 32-bit DWord */ 560 561 ACPI_MOVE_32_TO_32(&dword, &buffer[3]); 562 pld_info->ejectable = ACPI_PLD_GET_EJECTABLE(&dword); 563 pld_info->ospm_eject_required = ACPI_PLD_GET_OSPM_EJECT(&dword); 564 pld_info->cabinet_number = ACPI_PLD_GET_CABINET(&dword); 565 pld_info->card_cage_number = ACPI_PLD_GET_CARD_CAGE(&dword); 566 pld_info->reference = ACPI_PLD_GET_REFERENCE(&dword); 567 pld_info->rotation = ACPI_PLD_GET_ROTATION(&dword); 568 pld_info->order = ACPI_PLD_GET_ORDER(&dword); 569 570 if (length >= ACPI_PLD_BUFFER_SIZE) { 571 572 /* Fifth 32-bit DWord (Revision 2 of _PLD) */ 573 574 ACPI_MOVE_32_TO_32(&dword, &buffer[4]); 575 pld_info->vertical_offset = ACPI_PLD_GET_VERT_OFFSET(&dword); 576 pld_info->horizontal_offset = ACPI_PLD_GET_HORIZ_OFFSET(&dword); 577 } 578 579 *return_buffer = pld_info; 580 return (AE_OK); 581 } 582 583 ACPI_EXPORT_SYMBOL(acpi_decode_pld_buffer) 584