a34e445b62f1bb00d11f9ba5f1db51c1ef7c0750
[reactos.git] / drivers / bus / acpi / acpica / tables / tbxface.c
1 /******************************************************************************
2 *
3 * Module Name: tbxface - ACPI table-oriented external interfaces
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2017, 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.h"
47 #include "accommon.h"
48 #include "actables.h"
49
50 #define _COMPONENT ACPI_TABLES
51 ACPI_MODULE_NAME ("tbxface")
52
53
54 /*******************************************************************************
55 *
56 * FUNCTION: AcpiAllocateRootTable
57 *
58 * PARAMETERS: InitialTableCount - Size of InitialTableArray, in number of
59 * ACPI_TABLE_DESC structures
60 *
61 * RETURN: Status
62 *
63 * DESCRIPTION: Allocate a root table array. Used by iASL compiler and
64 * AcpiInitializeTables.
65 *
66 ******************************************************************************/
67
68 ACPI_STATUS
69 AcpiAllocateRootTable (
70 UINT32 InitialTableCount)
71 {
72
73 AcpiGbl_RootTableList.MaxTableCount = InitialTableCount;
74 AcpiGbl_RootTableList.Flags = ACPI_ROOT_ALLOW_RESIZE;
75
76 return (AcpiTbResizeRootTableList ());
77 }
78
79
80 /*******************************************************************************
81 *
82 * FUNCTION: AcpiInitializeTables
83 *
84 * PARAMETERS: InitialTableArray - Pointer to an array of pre-allocated
85 * ACPI_TABLE_DESC structures. If NULL, the
86 * array is dynamically allocated.
87 * InitialTableCount - Size of InitialTableArray, in number of
88 * ACPI_TABLE_DESC structures
89 * AllowResize - Flag to tell Table Manager if resize of
90 * pre-allocated array is allowed. Ignored
91 * if InitialTableArray is NULL.
92 *
93 * RETURN: Status
94 *
95 * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
96 *
97 * NOTE: Allows static allocation of the initial table array in order
98 * to avoid the use of dynamic memory in confined environments
99 * such as the kernel boot sequence where it may not be available.
100 *
101 * If the host OS memory managers are initialized, use NULL for
102 * InitialTableArray, and the table will be dynamically allocated.
103 *
104 ******************************************************************************/
105
106 ACPI_STATUS ACPI_INIT_FUNCTION
107 AcpiInitializeTables (
108 ACPI_TABLE_DESC *InitialTableArray,
109 UINT32 InitialTableCount,
110 BOOLEAN AllowResize)
111 {
112 ACPI_PHYSICAL_ADDRESS RsdpAddress;
113 ACPI_STATUS Status;
114
115
116 ACPI_FUNCTION_TRACE (AcpiInitializeTables);
117
118
119 /*
120 * Setup the Root Table Array and allocate the table array
121 * if requested
122 */
123 if (!InitialTableArray)
124 {
125 Status = AcpiAllocateRootTable (InitialTableCount);
126 if (ACPI_FAILURE (Status))
127 {
128 return_ACPI_STATUS (Status);
129 }
130 }
131 else
132 {
133 /* Root Table Array has been statically allocated by the host */
134
135 memset (InitialTableArray, 0,
136 (ACPI_SIZE) InitialTableCount * sizeof (ACPI_TABLE_DESC));
137
138 AcpiGbl_RootTableList.Tables = InitialTableArray;
139 AcpiGbl_RootTableList.MaxTableCount = InitialTableCount;
140 AcpiGbl_RootTableList.Flags = ACPI_ROOT_ORIGIN_UNKNOWN;
141 if (AllowResize)
142 {
143 AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ALLOW_RESIZE;
144 }
145 }
146
147 /* Get the address of the RSDP */
148
149 RsdpAddress = AcpiOsGetRootPointer ();
150 if (!RsdpAddress)
151 {
152 return_ACPI_STATUS (AE_NOT_FOUND);
153 }
154
155 /*
156 * Get the root table (RSDT or XSDT) and extract all entries to the local
157 * Root Table Array. This array contains the information of the RSDT/XSDT
158 * in a common, more useable format.
159 */
160 Status = AcpiTbParseRootTable (RsdpAddress);
161 return_ACPI_STATUS (Status);
162 }
163
164 ACPI_EXPORT_SYMBOL_INIT (AcpiInitializeTables)
165
166
167 /*******************************************************************************
168 *
169 * FUNCTION: AcpiReallocateRootTable
170 *
171 * PARAMETERS: None
172 *
173 * RETURN: Status
174 *
175 * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
176 * root list from the previously provided scratch area. Should
177 * be called once dynamic memory allocation is available in the
178 * kernel.
179 *
180 ******************************************************************************/
181
182 ACPI_STATUS ACPI_INIT_FUNCTION
183 AcpiReallocateRootTable (
184 void)
185 {
186 ACPI_STATUS Status;
187 ACPI_TABLE_DESC *TableDesc;
188 UINT32 i, j;
189
190
191 ACPI_FUNCTION_TRACE (AcpiReallocateRootTable);
192
193
194 /*
195 * Only reallocate the root table if the host provided a static buffer
196 * for the table array in the call to AcpiInitializeTables.
197 */
198 if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
199 {
200 return_ACPI_STATUS (AE_SUPPORT);
201 }
202
203 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
204
205 /*
206 * Ensure OS early boot logic, which is required by some hosts. If the
207 * table state is reported to be wrong, developers should fix the
208 * issue by invoking AcpiPutTable() for the reported table during the
209 * early stage.
210 */
211 for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i)
212 {
213 TableDesc = &AcpiGbl_RootTableList.Tables[i];
214 if (TableDesc->Pointer)
215 {
216 ACPI_ERROR ((AE_INFO,
217 "Table [%4.4s] is not invalidated during early boot stage",
218 TableDesc->Signature.Ascii));
219 }
220 }
221
222 if (!AcpiGbl_EnableTableValidation)
223 {
224 /*
225 * Now it's safe to do full table validation. We can do deferred
226 * table initilization here once the flag is set.
227 */
228 AcpiGbl_EnableTableValidation = TRUE;
229 for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i)
230 {
231 TableDesc = &AcpiGbl_RootTableList.Tables[i];
232 if (!(TableDesc->Flags & ACPI_TABLE_IS_VERIFIED))
233 {
234 Status = AcpiTbVerifyTempTable (TableDesc, NULL, &j);
235 if (ACPI_FAILURE (Status))
236 {
237 AcpiTbUninstallTable (TableDesc);
238 }
239 }
240 }
241 }
242
243 AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ALLOW_RESIZE;
244 Status = AcpiTbResizeRootTableList ();
245 AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ORIGIN_ALLOCATED;
246
247 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
248 return_ACPI_STATUS (Status);
249 }
250
251 ACPI_EXPORT_SYMBOL_INIT (AcpiReallocateRootTable)
252
253
254 /*******************************************************************************
255 *
256 * FUNCTION: AcpiGetTableHeader
257 *
258 * PARAMETERS: Signature - ACPI signature of needed table
259 * Instance - Which instance (for SSDTs)
260 * OutTableHeader - The pointer to the table header to fill
261 *
262 * RETURN: Status and pointer to mapped table header
263 *
264 * DESCRIPTION: Finds an ACPI table header.
265 *
266 * NOTE: Caller is responsible in unmapping the header with
267 * AcpiOsUnmapMemory
268 *
269 ******************************************************************************/
270
271 ACPI_STATUS
272 AcpiGetTableHeader (
273 char *Signature,
274 UINT32 Instance,
275 ACPI_TABLE_HEADER *OutTableHeader)
276 {
277 UINT32 i;
278 UINT32 j;
279 ACPI_TABLE_HEADER *Header;
280
281
282 /* Parameter validation */
283
284 if (!Signature || !OutTableHeader)
285 {
286 return (AE_BAD_PARAMETER);
287 }
288
289 /* Walk the root table list */
290
291 for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
292 {
293 if (!ACPI_COMPARE_NAME (
294 &(AcpiGbl_RootTableList.Tables[i].Signature), Signature))
295 {
296 continue;
297 }
298
299 if (++j < Instance)
300 {
301 continue;
302 }
303
304 if (!AcpiGbl_RootTableList.Tables[i].Pointer)
305 {
306 if ((AcpiGbl_RootTableList.Tables[i].Flags &
307 ACPI_TABLE_ORIGIN_MASK) ==
308 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL)
309 {
310 Header = AcpiOsMapMemory (
311 AcpiGbl_RootTableList.Tables[i].Address,
312 sizeof (ACPI_TABLE_HEADER));
313 if (!Header)
314 {
315 return (AE_NO_MEMORY);
316 }
317
318 memcpy (OutTableHeader, Header, sizeof (ACPI_TABLE_HEADER));
319 AcpiOsUnmapMemory (Header, sizeof (ACPI_TABLE_HEADER));
320 }
321 else
322 {
323 return (AE_NOT_FOUND);
324 }
325 }
326 else
327 {
328 memcpy (OutTableHeader,
329 AcpiGbl_RootTableList.Tables[i].Pointer,
330 sizeof (ACPI_TABLE_HEADER));
331 }
332
333 return (AE_OK);
334 }
335
336 return (AE_NOT_FOUND);
337 }
338
339 ACPI_EXPORT_SYMBOL (AcpiGetTableHeader)
340
341
342 /*******************************************************************************
343 *
344 * FUNCTION: AcpiGetTable
345 *
346 * PARAMETERS: Signature - ACPI signature of needed table
347 * Instance - Which instance (for SSDTs)
348 * OutTable - Where the pointer to the table is returned
349 *
350 * RETURN: Status and pointer to the requested table
351 *
352 * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the
353 * RSDT/XSDT.
354 * Note that an early stage AcpiGetTable() call must be paired
355 * with an early stage AcpiPutTable() call. otherwise the table
356 * pointer mapped by the early stage mapping implementation may be
357 * erroneously unmapped by the late stage unmapping implementation
358 * in an AcpiPutTable() invoked during the late stage.
359 *
360 ******************************************************************************/
361
362 ACPI_STATUS
363 AcpiGetTable (
364 char *Signature,
365 UINT32 Instance,
366 ACPI_TABLE_HEADER **OutTable)
367 {
368 UINT32 i;
369 UINT32 j;
370 ACPI_STATUS Status = AE_NOT_FOUND;
371 ACPI_TABLE_DESC *TableDesc;
372
373
374 /* Parameter validation */
375
376 if (!Signature || !OutTable)
377 {
378 return (AE_BAD_PARAMETER);
379 }
380
381 /*
382 * Note that the following line is required by some OSPMs, they only
383 * check if the returned table is NULL instead of the returned status
384 * to determined if this function is succeeded.
385 */
386 *OutTable = NULL;
387
388 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
389
390 /* Walk the root table list */
391
392 for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
393 {
394 TableDesc = &AcpiGbl_RootTableList.Tables[i];
395
396 if (!ACPI_COMPARE_NAME (&TableDesc->Signature, Signature))
397 {
398 continue;
399 }
400
401 if (++j < Instance)
402 {
403 continue;
404 }
405
406 Status = AcpiTbGetTable (TableDesc, OutTable);
407 break;
408 }
409
410 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
411 return (Status);
412 }
413
414 ACPI_EXPORT_SYMBOL (AcpiGetTable)
415
416
417 /*******************************************************************************
418 *
419 * FUNCTION: AcpiPutTable
420 *
421 * PARAMETERS: Table - The pointer to the table
422 *
423 * RETURN: None
424 *
425 * DESCRIPTION: Release a table returned by AcpiGetTable() and its clones.
426 * Note that it is not safe if this function was invoked after an
427 * uninstallation happened to the original table descriptor.
428 * Currently there is no OSPMs' requirement to handle such
429 * situations.
430 *
431 ******************************************************************************/
432
433 void
434 AcpiPutTable (
435 ACPI_TABLE_HEADER *Table)
436 {
437 UINT32 i;
438 ACPI_TABLE_DESC *TableDesc;
439
440
441 ACPI_FUNCTION_TRACE (AcpiPutTable);
442
443
444 if (!Table)
445 {
446 return_VOID;
447 }
448
449 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
450
451 /* Walk the root table list */
452
453 for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
454 {
455 TableDesc = &AcpiGbl_RootTableList.Tables[i];
456
457 if (TableDesc->Pointer != Table)
458 {
459 continue;
460 }
461
462 AcpiTbPutTable (TableDesc);
463 break;
464 }
465
466 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
467 return_VOID;
468 }
469
470 ACPI_EXPORT_SYMBOL (AcpiPutTable)
471
472
473 /*******************************************************************************
474 *
475 * FUNCTION: AcpiGetTableByIndex
476 *
477 * PARAMETERS: TableIndex - Table index
478 * OutTable - Where the pointer to the table is returned
479 *
480 * RETURN: Status and pointer to the requested table
481 *
482 * DESCRIPTION: Obtain a table by an index into the global table list. Used
483 * internally also.
484 *
485 ******************************************************************************/
486
487 ACPI_STATUS
488 AcpiGetTableByIndex (
489 UINT32 TableIndex,
490 ACPI_TABLE_HEADER **OutTable)
491 {
492 ACPI_STATUS Status;
493
494
495 ACPI_FUNCTION_TRACE (AcpiGetTableByIndex);
496
497
498 /* Parameter validation */
499
500 if (!OutTable)
501 {
502 return_ACPI_STATUS (AE_BAD_PARAMETER);
503 }
504
505 /*
506 * Note that the following line is required by some OSPMs, they only
507 * check if the returned table is NULL instead of the returned status
508 * to determined if this function is succeeded.
509 */
510 *OutTable = NULL;
511
512 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
513
514 /* Validate index */
515
516 if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount)
517 {
518 Status = AE_BAD_PARAMETER;
519 goto UnlockAndExit;
520 }
521
522 Status = AcpiTbGetTable (
523 &AcpiGbl_RootTableList.Tables[TableIndex], OutTable);
524
525 UnlockAndExit:
526 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
527 return_ACPI_STATUS (Status);
528 }
529
530 ACPI_EXPORT_SYMBOL (AcpiGetTableByIndex)
531
532
533 /*******************************************************************************
534 *
535 * FUNCTION: AcpiInstallTableHandler
536 *
537 * PARAMETERS: Handler - Table event handler
538 * Context - Value passed to the handler on each event
539 *
540 * RETURN: Status
541 *
542 * DESCRIPTION: Install a global table event handler.
543 *
544 ******************************************************************************/
545
546 ACPI_STATUS
547 AcpiInstallTableHandler (
548 ACPI_TABLE_HANDLER Handler,
549 void *Context)
550 {
551 ACPI_STATUS Status;
552
553
554 ACPI_FUNCTION_TRACE (AcpiInstallTableHandler);
555
556
557 if (!Handler)
558 {
559 return_ACPI_STATUS (AE_BAD_PARAMETER);
560 }
561
562 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
563 if (ACPI_FAILURE (Status))
564 {
565 return_ACPI_STATUS (Status);
566 }
567
568 /* Don't allow more than one handler */
569
570 if (AcpiGbl_TableHandler)
571 {
572 Status = AE_ALREADY_EXISTS;
573 goto Cleanup;
574 }
575
576 /* Install the handler */
577
578 AcpiGbl_TableHandler = Handler;
579 AcpiGbl_TableHandlerContext = Context;
580
581 Cleanup:
582 (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
583 return_ACPI_STATUS (Status);
584 }
585
586 ACPI_EXPORT_SYMBOL (AcpiInstallTableHandler)
587
588
589 /*******************************************************************************
590 *
591 * FUNCTION: AcpiRemoveTableHandler
592 *
593 * PARAMETERS: Handler - Table event handler that was installed
594 * previously.
595 *
596 * RETURN: Status
597 *
598 * DESCRIPTION: Remove a table event handler
599 *
600 ******************************************************************************/
601
602 ACPI_STATUS
603 AcpiRemoveTableHandler (
604 ACPI_TABLE_HANDLER Handler)
605 {
606 ACPI_STATUS Status;
607
608
609 ACPI_FUNCTION_TRACE (AcpiRemoveTableHandler);
610
611
612 Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
613 if (ACPI_FAILURE (Status))
614 {
615 return_ACPI_STATUS (Status);
616 }
617
618 /* Make sure that the installed handler is the same */
619
620 if (!Handler ||
621 Handler != AcpiGbl_TableHandler)
622 {
623 Status = AE_BAD_PARAMETER;
624 goto Cleanup;
625 }
626
627 /* Remove the handler */
628
629 AcpiGbl_TableHandler = NULL;
630
631 Cleanup:
632 (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
633 return_ACPI_STATUS (Status);
634 }
635
636 ACPI_EXPORT_SYMBOL (AcpiRemoveTableHandler)