1 /****************************************************************************** 2 * 3 * Module Name: tbxface - ACPI table oriented external interfaces 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 "acnamesp.h" 48 #include "actables.h" 49 50 #define _COMPONENT ACPI_TABLES 51 ACPI_MODULE_NAME("tbxface") 52 53 /******************************************************************************* 54 * 55 * FUNCTION: acpi_allocate_root_table 56 * 57 * PARAMETERS: initial_table_count - Size of initial_table_array, in number of 58 * struct acpi_table_desc structures 59 * 60 * RETURN: Status 61 * 62 * DESCRIPTION: Allocate a root table array. Used by iASL compiler and 63 * acpi_initialize_tables. 64 * 65 ******************************************************************************/ 66 acpi_status acpi_allocate_root_table(u32 initial_table_count) 67 { 68 69 acpi_gbl_root_table_list.max_table_count = initial_table_count; 70 acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE; 71 72 return (acpi_tb_resize_root_table_list()); 73 } 74 75 /******************************************************************************* 76 * 77 * FUNCTION: acpi_initialize_tables 78 * 79 * PARAMETERS: initial_table_array - Pointer to an array of pre-allocated 80 * struct acpi_table_desc structures. If NULL, the 81 * array is dynamically allocated. 82 * initial_table_count - Size of initial_table_array, in number of 83 * struct acpi_table_desc structures 84 * allow_realloc - Flag to tell Table Manager if resize of 85 * pre-allocated array is allowed. Ignored 86 * if initial_table_array is NULL. 87 * 88 * RETURN: Status 89 * 90 * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT. 91 * 92 * NOTE: Allows static allocation of the initial table array in order 93 * to avoid the use of dynamic memory in confined environments 94 * such as the kernel boot sequence where it may not be available. 95 * 96 * If the host OS memory managers are initialized, use NULL for 97 * initial_table_array, and the table will be dynamically allocated. 98 * 99 ******************************************************************************/ 100 101 acpi_status __init 102 acpi_initialize_tables(struct acpi_table_desc * initial_table_array, 103 u32 initial_table_count, u8 allow_resize) 104 { 105 acpi_physical_address rsdp_address; 106 acpi_status status; 107 108 ACPI_FUNCTION_TRACE(acpi_initialize_tables); 109 110 /* 111 * Set up the Root Table Array 112 * Allocate the table array if requested 113 */ 114 if (!initial_table_array) { 115 status = acpi_allocate_root_table(initial_table_count); 116 if (ACPI_FAILURE(status)) { 117 return_ACPI_STATUS(status); 118 } 119 } else { 120 /* Root Table Array has been statically allocated by the host */ 121 122 ACPI_MEMSET(initial_table_array, 0, 123 (acpi_size) initial_table_count * 124 sizeof(struct acpi_table_desc)); 125 126 acpi_gbl_root_table_list.tables = initial_table_array; 127 acpi_gbl_root_table_list.max_table_count = initial_table_count; 128 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN; 129 if (allow_resize) { 130 acpi_gbl_root_table_list.flags |= 131 ACPI_ROOT_ALLOW_RESIZE; 132 } 133 } 134 135 /* Get the address of the RSDP */ 136 137 rsdp_address = acpi_os_get_root_pointer(); 138 if (!rsdp_address) { 139 return_ACPI_STATUS(AE_NOT_FOUND); 140 } 141 142 /* 143 * Get the root table (RSDT or XSDT) and extract all entries to the local 144 * Root Table Array. This array contains the information of the RSDT/XSDT 145 * in a common, more useable format. 146 */ 147 status = acpi_tb_parse_root_table(rsdp_address); 148 return_ACPI_STATUS(status); 149 } 150 151 /******************************************************************************* 152 * 153 * FUNCTION: acpi_reallocate_root_table 154 * 155 * PARAMETERS: None 156 * 157 * RETURN: Status 158 * 159 * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the 160 * root list from the previously provided scratch area. Should 161 * be called once dynamic memory allocation is available in the 162 * kernel 163 * 164 ******************************************************************************/ 165 acpi_status acpi_reallocate_root_table(void) 166 { 167 struct acpi_table_desc *tables; 168 acpi_size new_size; 169 acpi_size current_size; 170 171 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table); 172 173 /* 174 * Only reallocate the root table if the host provided a static buffer 175 * for the table array in the call to acpi_initialize_tables. 176 */ 177 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { 178 return_ACPI_STATUS(AE_SUPPORT); 179 } 180 181 /* 182 * Get the current size of the root table and add the default 183 * increment to create the new table size. 184 */ 185 current_size = (acpi_size) 186 acpi_gbl_root_table_list.current_table_count * 187 sizeof(struct acpi_table_desc); 188 189 new_size = current_size + 190 (ACPI_ROOT_TABLE_SIZE_INCREMENT * sizeof(struct acpi_table_desc)); 191 192 /* Create new array and copy the old array */ 193 194 tables = ACPI_ALLOCATE_ZEROED(new_size); 195 if (!tables) { 196 return_ACPI_STATUS(AE_NO_MEMORY); 197 } 198 199 ACPI_MEMCPY(tables, acpi_gbl_root_table_list.tables, current_size); 200 201 /* 202 * Update the root table descriptor. The new size will be the current 203 * number of tables plus the increment, independent of the reserved 204 * size of the original table list. 205 */ 206 acpi_gbl_root_table_list.tables = tables; 207 acpi_gbl_root_table_list.max_table_count = 208 acpi_gbl_root_table_list.current_table_count + 209 ACPI_ROOT_TABLE_SIZE_INCREMENT; 210 acpi_gbl_root_table_list.flags = 211 ACPI_ROOT_ORIGIN_ALLOCATED | ACPI_ROOT_ALLOW_RESIZE; 212 213 return_ACPI_STATUS(AE_OK); 214 } 215 216 /******************************************************************************* 217 * 218 * FUNCTION: acpi_get_table_header 219 * 220 * PARAMETERS: signature - ACPI signature of needed table 221 * instance - Which instance (for SSDTs) 222 * out_table_header - The pointer to the table header to fill 223 * 224 * RETURN: Status and pointer to mapped table header 225 * 226 * DESCRIPTION: Finds an ACPI table header. 227 * 228 * NOTE: Caller is responsible in unmapping the header with 229 * acpi_os_unmap_memory 230 * 231 ******************************************************************************/ 232 acpi_status 233 acpi_get_table_header(char *signature, 234 u32 instance, struct acpi_table_header *out_table_header) 235 { 236 u32 i; 237 u32 j; 238 struct acpi_table_header *header; 239 240 /* Parameter validation */ 241 242 if (!signature || !out_table_header) { 243 return (AE_BAD_PARAMETER); 244 } 245 246 /* Walk the root table list */ 247 248 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count; 249 i++) { 250 if (!ACPI_COMPARE_NAME 251 (&(acpi_gbl_root_table_list.tables[i].signature), 252 signature)) { 253 continue; 254 } 255 256 if (++j < instance) { 257 continue; 258 } 259 260 if (!acpi_gbl_root_table_list.tables[i].pointer) { 261 if ((acpi_gbl_root_table_list.tables[i].flags & 262 ACPI_TABLE_ORIGIN_MASK) == 263 ACPI_TABLE_ORIGIN_MAPPED) { 264 header = 265 acpi_os_map_memory(acpi_gbl_root_table_list. 266 tables[i].address, 267 sizeof(struct 268 acpi_table_header)); 269 if (!header) { 270 return AE_NO_MEMORY; 271 } 272 ACPI_MEMCPY(out_table_header, header, 273 sizeof(struct acpi_table_header)); 274 acpi_os_unmap_memory(header, 275 sizeof(struct 276 acpi_table_header)); 277 } else { 278 return AE_NOT_FOUND; 279 } 280 } else { 281 ACPI_MEMCPY(out_table_header, 282 acpi_gbl_root_table_list.tables[i].pointer, 283 sizeof(struct acpi_table_header)); 284 } 285 return (AE_OK); 286 } 287 288 return (AE_NOT_FOUND); 289 } 290 291 ACPI_EXPORT_SYMBOL(acpi_get_table_header) 292 293 /******************************************************************************* 294 * 295 * FUNCTION: acpi_unload_table_id 296 * 297 * PARAMETERS: id - Owner ID of the table to be removed. 298 * 299 * RETURN: Status 300 * 301 * DESCRIPTION: This routine is used to force the unload of a table (by id) 302 * 303 ******************************************************************************/ 304 acpi_status acpi_unload_table_id(acpi_owner_id id) 305 { 306 int i; 307 acpi_status status = AE_NOT_EXIST; 308 309 ACPI_FUNCTION_TRACE(acpi_unload_table_id); 310 311 /* Find table in the global table list */ 312 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) { 313 if (id != acpi_gbl_root_table_list.tables[i].owner_id) { 314 continue; 315 } 316 /* 317 * Delete all namespace objects owned by this table. Note that these 318 * objects can appear anywhere in the namespace by virtue of the AML 319 * "Scope" operator. Thus, we need to track ownership by an ID, not 320 * simply a position within the hierarchy 321 */ 322 acpi_tb_delete_namespace_by_owner(i); 323 status = acpi_tb_release_owner_id(i); 324 acpi_tb_set_table_loaded_flag(i, FALSE); 325 break; 326 } 327 return_ACPI_STATUS(status); 328 } 329 330 ACPI_EXPORT_SYMBOL(acpi_unload_table_id) 331 332 /******************************************************************************* 333 * 334 * FUNCTION: acpi_get_table_with_size 335 * 336 * PARAMETERS: signature - ACPI signature of needed table 337 * instance - Which instance (for SSDTs) 338 * out_table - Where the pointer to the table is returned 339 * 340 * RETURN: Status and pointer to table 341 * 342 * DESCRIPTION: Finds and verifies an ACPI table. 343 * 344 ******************************************************************************/ 345 acpi_status 346 acpi_get_table_with_size(char *signature, 347 u32 instance, struct acpi_table_header **out_table, 348 acpi_size *tbl_size) 349 { 350 u32 i; 351 u32 j; 352 acpi_status status; 353 354 /* Parameter validation */ 355 356 if (!signature || !out_table) { 357 return (AE_BAD_PARAMETER); 358 } 359 360 /* Walk the root table list */ 361 362 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count; 363 i++) { 364 if (!ACPI_COMPARE_NAME 365 (&(acpi_gbl_root_table_list.tables[i].signature), 366 signature)) { 367 continue; 368 } 369 370 if (++j < instance) { 371 continue; 372 } 373 374 status = 375 acpi_tb_verify_table(&acpi_gbl_root_table_list.tables[i]); 376 if (ACPI_SUCCESS(status)) { 377 *out_table = acpi_gbl_root_table_list.tables[i].pointer; 378 *tbl_size = acpi_gbl_root_table_list.tables[i].length; 379 } 380 381 if (!acpi_gbl_permanent_mmap) { 382 acpi_gbl_root_table_list.tables[i].pointer = NULL; 383 } 384 385 return (status); 386 } 387 388 return (AE_NOT_FOUND); 389 } 390 ACPI_EXPORT_SYMBOL(acpi_get_table_with_size) 391 392 acpi_status 393 acpi_get_table(char *signature, 394 u32 instance, struct acpi_table_header **out_table) 395 { 396 acpi_size tbl_size; 397 398 return acpi_get_table_with_size(signature, 399 instance, out_table, &tbl_size); 400 } 401 ACPI_EXPORT_SYMBOL(acpi_get_table) 402 403 /******************************************************************************* 404 * 405 * FUNCTION: acpi_get_table_by_index 406 * 407 * PARAMETERS: table_index - Table index 408 * table - Where the pointer to the table is returned 409 * 410 * RETURN: Status and pointer to the table 411 * 412 * DESCRIPTION: Obtain a table by an index into the global table list. 413 * 414 ******************************************************************************/ 415 acpi_status 416 acpi_get_table_by_index(u32 table_index, struct acpi_table_header **table) 417 { 418 acpi_status status; 419 420 ACPI_FUNCTION_TRACE(acpi_get_table_by_index); 421 422 /* Parameter validation */ 423 424 if (!table) { 425 return_ACPI_STATUS(AE_BAD_PARAMETER); 426 } 427 428 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 429 430 /* Validate index */ 431 432 if (table_index >= acpi_gbl_root_table_list.current_table_count) { 433 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 434 return_ACPI_STATUS(AE_BAD_PARAMETER); 435 } 436 437 if (!acpi_gbl_root_table_list.tables[table_index].pointer) { 438 439 /* Table is not mapped, map it */ 440 441 status = 442 acpi_tb_verify_table(&acpi_gbl_root_table_list. 443 tables[table_index]); 444 if (ACPI_FAILURE(status)) { 445 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 446 return_ACPI_STATUS(status); 447 } 448 } 449 450 *table = acpi_gbl_root_table_list.tables[table_index].pointer; 451 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 452 return_ACPI_STATUS(AE_OK); 453 } 454 455 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index) 456 457 458 /******************************************************************************* 459 * 460 * FUNCTION: acpi_install_table_handler 461 * 462 * PARAMETERS: handler - Table event handler 463 * context - Value passed to the handler on each event 464 * 465 * RETURN: Status 466 * 467 * DESCRIPTION: Install table event handler 468 * 469 ******************************************************************************/ 470 acpi_status 471 acpi_install_table_handler(acpi_tbl_handler handler, void *context) 472 { 473 acpi_status status; 474 475 ACPI_FUNCTION_TRACE(acpi_install_table_handler); 476 477 if (!handler) { 478 return_ACPI_STATUS(AE_BAD_PARAMETER); 479 } 480 481 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 482 if (ACPI_FAILURE(status)) { 483 return_ACPI_STATUS(status); 484 } 485 486 /* Don't allow more than one handler */ 487 488 if (acpi_gbl_table_handler) { 489 status = AE_ALREADY_EXISTS; 490 goto cleanup; 491 } 492 493 /* Install the handler */ 494 495 acpi_gbl_table_handler = handler; 496 acpi_gbl_table_handler_context = context; 497 498 cleanup: 499 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 500 return_ACPI_STATUS(status); 501 } 502 503 ACPI_EXPORT_SYMBOL(acpi_install_table_handler) 504 505 /******************************************************************************* 506 * 507 * FUNCTION: acpi_remove_table_handler 508 * 509 * PARAMETERS: handler - Table event handler that was installed 510 * previously. 511 * 512 * RETURN: Status 513 * 514 * DESCRIPTION: Remove table event handler 515 * 516 ******************************************************************************/ 517 acpi_status acpi_remove_table_handler(acpi_tbl_handler handler) 518 { 519 acpi_status status; 520 521 ACPI_FUNCTION_TRACE(acpi_remove_table_handler); 522 523 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 524 if (ACPI_FAILURE(status)) { 525 return_ACPI_STATUS(status); 526 } 527 528 /* Make sure that the installed handler is the same */ 529 530 if (!handler || handler != acpi_gbl_table_handler) { 531 status = AE_BAD_PARAMETER; 532 goto cleanup; 533 } 534 535 /* Remove the handler */ 536 537 acpi_gbl_table_handler = NULL; 538 539 cleanup: 540 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 541 return_ACPI_STATUS(status); 542 } 543 544 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler) 545