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