1 /****************************************************************************** 2 * 3 * Module Name: tbxface - ACPI table-oriented external interfaces 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, 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 "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_resize - 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 ACPI_INIT_FUNCTION 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 * Setup the Root Table Array and allocate the table array 112 * 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 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 ACPI_EXPORT_SYMBOL_INIT(acpi_initialize_tables) 152 153 /******************************************************************************* 154 * 155 * FUNCTION: acpi_reallocate_root_table 156 * 157 * PARAMETERS: None 158 * 159 * RETURN: Status 160 * 161 * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the 162 * root list from the previously provided scratch area. Should 163 * be called once dynamic memory allocation is available in the 164 * kernel. 165 * 166 ******************************************************************************/ 167 acpi_status ACPI_INIT_FUNCTION acpi_reallocate_root_table(void) 168 { 169 acpi_status status; 170 u32 i; 171 172 ACPI_FUNCTION_TRACE(acpi_reallocate_root_table); 173 174 /* 175 * Only reallocate the root table if the host provided a static buffer 176 * for the table array in the call to acpi_initialize_tables. 177 */ 178 if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) { 179 return_ACPI_STATUS(AE_SUPPORT); 180 } 181 182 /* 183 * Ensure OS early boot logic, which is required by some hosts. If the 184 * table state is reported to be wrong, developers should fix the 185 * issue by invoking acpi_put_table() for the reported table during the 186 * early stage. 187 */ 188 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; ++i) { 189 if (acpi_gbl_root_table_list.tables[i].pointer) { 190 ACPI_ERROR((AE_INFO, 191 "Table [%4.4s] is not invalidated during early boot stage", 192 acpi_gbl_root_table_list.tables[i]. 193 signature.ascii)); 194 } 195 } 196 197 acpi_gbl_root_table_list.flags |= ACPI_ROOT_ALLOW_RESIZE; 198 199 status = acpi_tb_resize_root_table_list(); 200 return_ACPI_STATUS(status); 201 } 202 203 ACPI_EXPORT_SYMBOL_INIT(acpi_reallocate_root_table) 204 205 /******************************************************************************* 206 * 207 * FUNCTION: acpi_get_table_header 208 * 209 * PARAMETERS: signature - ACPI signature of needed table 210 * instance - Which instance (for SSDTs) 211 * out_table_header - The pointer to the table header to fill 212 * 213 * RETURN: Status and pointer to mapped table header 214 * 215 * DESCRIPTION: Finds an ACPI table header. 216 * 217 * NOTE: Caller is responsible in unmapping the header with 218 * acpi_os_unmap_memory 219 * 220 ******************************************************************************/ 221 acpi_status 222 acpi_get_table_header(char *signature, 223 u32 instance, struct acpi_table_header *out_table_header) 224 { 225 u32 i; 226 u32 j; 227 struct acpi_table_header *header; 228 229 /* Parameter validation */ 230 231 if (!signature || !out_table_header) { 232 return (AE_BAD_PARAMETER); 233 } 234 235 /* Walk the root table list */ 236 237 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count; 238 i++) { 239 if (!ACPI_COMPARE_NAME 240 (&(acpi_gbl_root_table_list.tables[i].signature), 241 signature)) { 242 continue; 243 } 244 245 if (++j < instance) { 246 continue; 247 } 248 249 if (!acpi_gbl_root_table_list.tables[i].pointer) { 250 if ((acpi_gbl_root_table_list.tables[i].flags & 251 ACPI_TABLE_ORIGIN_MASK) == 252 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL) { 253 header = 254 acpi_os_map_memory(acpi_gbl_root_table_list. 255 tables[i].address, 256 sizeof(struct 257 acpi_table_header)); 258 if (!header) { 259 return (AE_NO_MEMORY); 260 } 261 262 memcpy(out_table_header, header, 263 sizeof(struct acpi_table_header)); 264 acpi_os_unmap_memory(header, 265 sizeof(struct 266 acpi_table_header)); 267 } else { 268 return (AE_NOT_FOUND); 269 } 270 } else { 271 memcpy(out_table_header, 272 acpi_gbl_root_table_list.tables[i].pointer, 273 sizeof(struct acpi_table_header)); 274 } 275 return (AE_OK); 276 } 277 278 return (AE_NOT_FOUND); 279 } 280 281 ACPI_EXPORT_SYMBOL(acpi_get_table_header) 282 283 /******************************************************************************* 284 * 285 * FUNCTION: acpi_get_table 286 * 287 * PARAMETERS: signature - ACPI signature of needed table 288 * instance - Which instance (for SSDTs) 289 * out_table - Where the pointer to the table is returned 290 * 291 * RETURN: Status and pointer to the requested table 292 * 293 * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the 294 * RSDT/XSDT. 295 * Note that an early stage acpi_get_table() call must be paired 296 * with an early stage acpi_put_table() call. otherwise the table 297 * pointer mapped by the early stage mapping implementation may be 298 * erroneously unmapped by the late stage unmapping implementation 299 * in an acpi_put_table() invoked during the late stage. 300 * 301 ******************************************************************************/ 302 acpi_status 303 acpi_get_table(char *signature, 304 u32 instance, struct acpi_table_header ** out_table) 305 { 306 u32 i; 307 u32 j; 308 acpi_status status = AE_NOT_FOUND; 309 struct acpi_table_desc *table_desc; 310 311 /* Parameter validation */ 312 313 if (!signature || !out_table) { 314 return (AE_BAD_PARAMETER); 315 } 316 317 /* 318 * Note that the following line is required by some OSPMs, they only 319 * check if the returned table is NULL instead of the returned status 320 * to determined if this function is succeeded. 321 */ 322 *out_table = NULL; 323 324 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 325 326 /* Walk the root table list */ 327 328 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count; 329 i++) { 330 table_desc = &acpi_gbl_root_table_list.tables[i]; 331 332 if (!ACPI_COMPARE_NAME(&table_desc->signature, signature)) { 333 continue; 334 } 335 336 if (++j < instance) { 337 continue; 338 } 339 340 status = acpi_tb_get_table(table_desc, out_table); 341 break; 342 } 343 344 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 345 return (status); 346 } 347 348 ACPI_EXPORT_SYMBOL(acpi_get_table) 349 350 /******************************************************************************* 351 * 352 * FUNCTION: acpi_put_table 353 * 354 * PARAMETERS: table - The pointer to the table 355 * 356 * RETURN: None 357 * 358 * DESCRIPTION: Release a table returned by acpi_get_table() and its clones. 359 * Note that it is not safe if this function was invoked after an 360 * uninstallation happened to the original table descriptor. 361 * Currently there is no OSPMs' requirement to handle such 362 * situations. 363 * 364 ******************************************************************************/ 365 void acpi_put_table(struct acpi_table_header *table) 366 { 367 u32 i; 368 struct acpi_table_desc *table_desc; 369 370 ACPI_FUNCTION_TRACE(acpi_put_table); 371 372 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 373 374 /* Walk the root table list */ 375 376 for (i = 0; i < acpi_gbl_root_table_list.current_table_count; i++) { 377 table_desc = &acpi_gbl_root_table_list.tables[i]; 378 379 if (table_desc->pointer != table) { 380 continue; 381 } 382 383 acpi_tb_put_table(table_desc); 384 break; 385 } 386 387 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 388 return_VOID; 389 } 390 391 ACPI_EXPORT_SYMBOL(acpi_put_table) 392 393 /******************************************************************************* 394 * 395 * FUNCTION: acpi_get_table_by_index 396 * 397 * PARAMETERS: table_index - Table index 398 * out_table - Where the pointer to the table is returned 399 * 400 * RETURN: Status and pointer to the requested table 401 * 402 * DESCRIPTION: Obtain a table by an index into the global table list. Used 403 * internally also. 404 * 405 ******************************************************************************/ 406 acpi_status 407 acpi_get_table_by_index(u32 table_index, struct acpi_table_header **out_table) 408 { 409 acpi_status status; 410 411 ACPI_FUNCTION_TRACE(acpi_get_table_by_index); 412 413 /* Parameter validation */ 414 415 if (!out_table) { 416 return_ACPI_STATUS(AE_BAD_PARAMETER); 417 } 418 419 /* 420 * Note that the following line is required by some OSPMs, they only 421 * check if the returned table is NULL instead of the returned status 422 * to determined if this function is succeeded. 423 */ 424 *out_table = NULL; 425 426 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 427 428 /* Validate index */ 429 430 if (table_index >= acpi_gbl_root_table_list.current_table_count) { 431 status = AE_BAD_PARAMETER; 432 goto unlock_and_exit; 433 } 434 435 status = 436 acpi_tb_get_table(&acpi_gbl_root_table_list.tables[table_index], 437 out_table); 438 439 unlock_and_exit: 440 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 441 return_ACPI_STATUS(status); 442 } 443 444 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index) 445 446 /******************************************************************************* 447 * 448 * FUNCTION: acpi_install_table_handler 449 * 450 * PARAMETERS: handler - Table event handler 451 * context - Value passed to the handler on each event 452 * 453 * RETURN: Status 454 * 455 * DESCRIPTION: Install a global table event handler. 456 * 457 ******************************************************************************/ 458 acpi_status 459 acpi_install_table_handler(acpi_table_handler handler, void *context) 460 { 461 acpi_status status; 462 463 ACPI_FUNCTION_TRACE(acpi_install_table_handler); 464 465 if (!handler) { 466 return_ACPI_STATUS(AE_BAD_PARAMETER); 467 } 468 469 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 470 if (ACPI_FAILURE(status)) { 471 return_ACPI_STATUS(status); 472 } 473 474 /* Don't allow more than one handler */ 475 476 if (acpi_gbl_table_handler) { 477 status = AE_ALREADY_EXISTS; 478 goto cleanup; 479 } 480 481 /* Install the handler */ 482 483 acpi_gbl_table_handler = handler; 484 acpi_gbl_table_handler_context = context; 485 486 cleanup: 487 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 488 return_ACPI_STATUS(status); 489 } 490 491 ACPI_EXPORT_SYMBOL(acpi_install_table_handler) 492 493 /******************************************************************************* 494 * 495 * FUNCTION: acpi_remove_table_handler 496 * 497 * PARAMETERS: handler - Table event handler that was installed 498 * previously. 499 * 500 * RETURN: Status 501 * 502 * DESCRIPTION: Remove a table event handler 503 * 504 ******************************************************************************/ 505 acpi_status acpi_remove_table_handler(acpi_table_handler handler) 506 { 507 acpi_status status; 508 509 ACPI_FUNCTION_TRACE(acpi_remove_table_handler); 510 511 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 512 if (ACPI_FAILURE(status)) { 513 return_ACPI_STATUS(status); 514 } 515 516 /* Make sure that the installed handler is the same */ 517 518 if (!handler || handler != acpi_gbl_table_handler) { 519 status = AE_BAD_PARAMETER; 520 goto cleanup; 521 } 522 523 /* Remove the handler */ 524 525 acpi_gbl_table_handler = NULL; 526 527 cleanup: 528 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 529 return_ACPI_STATUS(status); 530 } 531 532 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler) 533