1 /****************************************************************************** 2 * 3 * Module Name: tbxface - ACPI table-oriented external interfaces 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 "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 __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 * 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 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 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 __init acpi_reallocate_root_table(void) 168 { 169 acpi_status status; 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 acpi_gbl_root_table_list.flags |= ACPI_ROOT_ALLOW_RESIZE; 182 183 status = acpi_tb_resize_root_table_list(); 184 return_ACPI_STATUS(status); 185 } 186 187 ACPI_EXPORT_SYMBOL_INIT(acpi_reallocate_root_table) 188 189 /******************************************************************************* 190 * 191 * FUNCTION: acpi_get_table_header 192 * 193 * PARAMETERS: signature - ACPI signature of needed table 194 * instance - Which instance (for SSDTs) 195 * out_table_header - The pointer to the table header to fill 196 * 197 * RETURN: Status and pointer to mapped table header 198 * 199 * DESCRIPTION: Finds an ACPI table header. 200 * 201 * NOTE: Caller is responsible in unmapping the header with 202 * acpi_os_unmap_memory 203 * 204 ******************************************************************************/ 205 acpi_status 206 acpi_get_table_header(char *signature, 207 u32 instance, struct acpi_table_header *out_table_header) 208 { 209 u32 i; 210 u32 j; 211 struct acpi_table_header *header; 212 213 /* Parameter validation */ 214 215 if (!signature || !out_table_header) { 216 return (AE_BAD_PARAMETER); 217 } 218 219 /* Walk the root table list */ 220 221 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count; 222 i++) { 223 if (!ACPI_COMPARE_NAME 224 (&(acpi_gbl_root_table_list.tables[i].signature), 225 signature)) { 226 continue; 227 } 228 229 if (++j < instance) { 230 continue; 231 } 232 233 if (!acpi_gbl_root_table_list.tables[i].pointer) { 234 if ((acpi_gbl_root_table_list.tables[i].flags & 235 ACPI_TABLE_ORIGIN_MASK) == 236 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL) { 237 header = 238 acpi_os_map_memory(acpi_gbl_root_table_list. 239 tables[i].address, 240 sizeof(struct 241 acpi_table_header)); 242 if (!header) { 243 return (AE_NO_MEMORY); 244 } 245 ACPI_MEMCPY(out_table_header, header, 246 sizeof(struct acpi_table_header)); 247 acpi_os_unmap_memory(header, 248 sizeof(struct 249 acpi_table_header)); 250 } else { 251 return (AE_NOT_FOUND); 252 } 253 } else { 254 ACPI_MEMCPY(out_table_header, 255 acpi_gbl_root_table_list.tables[i].pointer, 256 sizeof(struct acpi_table_header)); 257 } 258 return (AE_OK); 259 } 260 261 return (AE_NOT_FOUND); 262 } 263 264 ACPI_EXPORT_SYMBOL(acpi_get_table_header) 265 266 /******************************************************************************* 267 * 268 * FUNCTION: acpi_get_table_with_size 269 * 270 * PARAMETERS: signature - ACPI signature of needed table 271 * instance - Which instance (for SSDTs) 272 * out_table - Where the pointer to the table is returned 273 * 274 * RETURN: Status and pointer to the requested table 275 * 276 * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the 277 * RSDT/XSDT. 278 * 279 ******************************************************************************/ 280 acpi_status 281 acpi_get_table_with_size(char *signature, 282 u32 instance, struct acpi_table_header **out_table, 283 acpi_size *tbl_size) 284 { 285 u32 i; 286 u32 j; 287 acpi_status status; 288 289 /* Parameter validation */ 290 291 if (!signature || !out_table) { 292 return (AE_BAD_PARAMETER); 293 } 294 295 /* Walk the root table list */ 296 297 for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count; 298 i++) { 299 if (!ACPI_COMPARE_NAME 300 (&(acpi_gbl_root_table_list.tables[i].signature), 301 signature)) { 302 continue; 303 } 304 305 if (++j < instance) { 306 continue; 307 } 308 309 status = 310 acpi_tb_validate_table(&acpi_gbl_root_table_list.tables[i]); 311 if (ACPI_SUCCESS(status)) { 312 *out_table = acpi_gbl_root_table_list.tables[i].pointer; 313 *tbl_size = acpi_gbl_root_table_list.tables[i].length; 314 } 315 316 if (!acpi_gbl_permanent_mmap) { 317 acpi_gbl_root_table_list.tables[i].pointer = NULL; 318 } 319 320 return (status); 321 } 322 323 return (AE_NOT_FOUND); 324 } 325 326 ACPI_EXPORT_SYMBOL(acpi_get_table_with_size) 327 328 acpi_status 329 acpi_get_table(char *signature, 330 u32 instance, struct acpi_table_header **out_table) 331 { 332 acpi_size tbl_size; 333 334 return acpi_get_table_with_size(signature, 335 instance, out_table, &tbl_size); 336 } 337 338 ACPI_EXPORT_SYMBOL(acpi_get_table) 339 340 /******************************************************************************* 341 * 342 * FUNCTION: acpi_get_table_by_index 343 * 344 * PARAMETERS: table_index - Table index 345 * table - Where the pointer to the table is returned 346 * 347 * RETURN: Status and pointer to the requested table 348 * 349 * DESCRIPTION: Obtain a table by an index into the global table list. Used 350 * internally also. 351 * 352 ******************************************************************************/ 353 acpi_status 354 acpi_get_table_by_index(u32 table_index, struct acpi_table_header ** table) 355 { 356 acpi_status status; 357 358 ACPI_FUNCTION_TRACE(acpi_get_table_by_index); 359 360 /* Parameter validation */ 361 362 if (!table) { 363 return_ACPI_STATUS(AE_BAD_PARAMETER); 364 } 365 366 (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES); 367 368 /* Validate index */ 369 370 if (table_index >= acpi_gbl_root_table_list.current_table_count) { 371 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 372 return_ACPI_STATUS(AE_BAD_PARAMETER); 373 } 374 375 if (!acpi_gbl_root_table_list.tables[table_index].pointer) { 376 377 /* Table is not mapped, map it */ 378 379 status = 380 acpi_tb_validate_table(&acpi_gbl_root_table_list. 381 tables[table_index]); 382 if (ACPI_FAILURE(status)) { 383 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 384 return_ACPI_STATUS(status); 385 } 386 } 387 388 *table = acpi_gbl_root_table_list.tables[table_index].pointer; 389 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES); 390 return_ACPI_STATUS(AE_OK); 391 } 392 393 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index) 394 395 /******************************************************************************* 396 * 397 * FUNCTION: acpi_install_table_handler 398 * 399 * PARAMETERS: handler - Table event handler 400 * context - Value passed to the handler on each event 401 * 402 * RETURN: Status 403 * 404 * DESCRIPTION: Install a global table event handler. 405 * 406 ******************************************************************************/ 407 acpi_status 408 acpi_install_table_handler(acpi_table_handler handler, void *context) 409 { 410 acpi_status status; 411 412 ACPI_FUNCTION_TRACE(acpi_install_table_handler); 413 414 if (!handler) { 415 return_ACPI_STATUS(AE_BAD_PARAMETER); 416 } 417 418 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 419 if (ACPI_FAILURE(status)) { 420 return_ACPI_STATUS(status); 421 } 422 423 /* Don't allow more than one handler */ 424 425 if (acpi_gbl_table_handler) { 426 status = AE_ALREADY_EXISTS; 427 goto cleanup; 428 } 429 430 /* Install the handler */ 431 432 acpi_gbl_table_handler = handler; 433 acpi_gbl_table_handler_context = context; 434 435 cleanup: 436 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 437 return_ACPI_STATUS(status); 438 } 439 440 ACPI_EXPORT_SYMBOL(acpi_install_table_handler) 441 442 /******************************************************************************* 443 * 444 * FUNCTION: acpi_remove_table_handler 445 * 446 * PARAMETERS: handler - Table event handler that was installed 447 * previously. 448 * 449 * RETURN: Status 450 * 451 * DESCRIPTION: Remove a table event handler 452 * 453 ******************************************************************************/ 454 acpi_status acpi_remove_table_handler(acpi_table_handler handler) 455 { 456 acpi_status status; 457 458 ACPI_FUNCTION_TRACE(acpi_remove_table_handler); 459 460 status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS); 461 if (ACPI_FAILURE(status)) { 462 return_ACPI_STATUS(status); 463 } 464 465 /* Make sure that the installed handler is the same */ 466 467 if (!handler || handler != acpi_gbl_table_handler) { 468 status = AE_BAD_PARAMETER; 469 goto cleanup; 470 } 471 472 /* Remove the handler */ 473 474 acpi_gbl_table_handler = NULL; 475 476 cleanup: 477 (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS); 478 return_ACPI_STATUS(status); 479 } 480 481 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler) 482