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