xref: /titanic_50/usr/src/uts/intel/io/acpica/tables/tbxface.c (revision 2a52a1627973d84afe3af6de87c1fe00ac3d087e)
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.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
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
183 AcpiReallocateRootTable (
184     void)
185 {
186     ACPI_STATUS             Status;
187 
188 
189     ACPI_FUNCTION_TRACE (AcpiReallocateRootTable);
190 
191 
192     /*
193      * Only reallocate the root table if the host provided a static buffer
194      * for the table array in the call to AcpiInitializeTables.
195      */
196     if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
197     {
198         return_ACPI_STATUS (AE_SUPPORT);
199     }
200 
201     AcpiGbl_RootTableList.Flags |= ACPI_ROOT_ALLOW_RESIZE;
202 
203     Status = AcpiTbResizeRootTableList ();
204     return_ACPI_STATUS (Status);
205 }
206 
207 ACPI_EXPORT_SYMBOL_INIT (AcpiReallocateRootTable)
208 
209 
210 /*******************************************************************************
211  *
212  * FUNCTION:    AcpiGetTableHeader
213  *
214  * PARAMETERS:  Signature           - ACPI signature of needed table
215  *              Instance            - Which instance (for SSDTs)
216  *              OutTableHeader      - The pointer to the table header to fill
217  *
218  * RETURN:      Status and pointer to mapped table header
219  *
220  * DESCRIPTION: Finds an ACPI table header.
221  *
222  * NOTE:        Caller is responsible in unmapping the header with
223  *              AcpiOsUnmapMemory
224  *
225  ******************************************************************************/
226 
227 ACPI_STATUS
228 AcpiGetTableHeader (
229     char                    *Signature,
230     UINT32                  Instance,
231     ACPI_TABLE_HEADER       *OutTableHeader)
232 {
233     UINT32                  i;
234     UINT32                  j;
235     ACPI_TABLE_HEADER       *Header;
236 
237 
238     /* Parameter validation */
239 
240     if (!Signature || !OutTableHeader)
241     {
242         return (AE_BAD_PARAMETER);
243     }
244 
245     /* Walk the root table list */
246 
247     for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
248     {
249         if (!ACPI_COMPARE_NAME (
250                 &(AcpiGbl_RootTableList.Tables[i].Signature), Signature))
251         {
252             continue;
253         }
254 
255         if (++j < Instance)
256         {
257             continue;
258         }
259 
260         if (!AcpiGbl_RootTableList.Tables[i].Pointer)
261         {
262             if ((AcpiGbl_RootTableList.Tables[i].Flags &
263                     ACPI_TABLE_ORIGIN_MASK) ==
264                 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL)
265             {
266                 Header = AcpiOsMapMemory (
267                     AcpiGbl_RootTableList.Tables[i].Address,
268                     sizeof (ACPI_TABLE_HEADER));
269                 if (!Header)
270                 {
271                     return (AE_NO_MEMORY);
272                 }
273 
274                 memcpy (OutTableHeader, Header, sizeof (ACPI_TABLE_HEADER));
275                 AcpiOsUnmapMemory (Header, sizeof (ACPI_TABLE_HEADER));
276             }
277             else
278             {
279                 return (AE_NOT_FOUND);
280             }
281         }
282         else
283         {
284             memcpy (OutTableHeader,
285                 AcpiGbl_RootTableList.Tables[i].Pointer,
286                 sizeof (ACPI_TABLE_HEADER));
287         }
288 
289         return (AE_OK);
290     }
291 
292     return (AE_NOT_FOUND);
293 }
294 
295 ACPI_EXPORT_SYMBOL (AcpiGetTableHeader)
296 
297 
298 /*******************************************************************************
299  *
300  * FUNCTION:    AcpiGetTable
301  *
302  * PARAMETERS:  Signature           - ACPI signature of needed table
303  *              Instance            - Which instance (for SSDTs)
304  *              OutTable            - Where the pointer to the table is returned
305  *
306  * RETURN:      Status and pointer to the requested table
307  *
308  * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the
309  *              RSDT/XSDT.
310  *
311  ******************************************************************************/
312 
313 ACPI_STATUS
314 AcpiGetTable (
315     char                    *Signature,
316     UINT32                  Instance,
317     ACPI_TABLE_HEADER       **OutTable)
318 {
319     UINT32                  i;
320     UINT32                  j;
321     ACPI_STATUS             Status;
322 
323 
324     /* Parameter validation */
325 
326     if (!Signature || !OutTable)
327     {
328         return (AE_BAD_PARAMETER);
329     }
330 
331     /* Walk the root table list */
332 
333     for (i = 0, j = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
334     {
335         if (!ACPI_COMPARE_NAME (
336                 &(AcpiGbl_RootTableList.Tables[i].Signature), Signature))
337         {
338             continue;
339         }
340 
341         if (++j < Instance)
342         {
343             continue;
344         }
345 
346         Status = AcpiTbValidateTable (&AcpiGbl_RootTableList.Tables[i]);
347         if (ACPI_SUCCESS (Status))
348         {
349             *OutTable = AcpiGbl_RootTableList.Tables[i].Pointer;
350         }
351 
352         return (Status);
353     }
354 
355     return (AE_NOT_FOUND);
356 }
357 
358 ACPI_EXPORT_SYMBOL (AcpiGetTable)
359 
360 
361 /*******************************************************************************
362  *
363  * FUNCTION:    AcpiGetTableByIndex
364  *
365  * PARAMETERS:  TableIndex          - Table index
366  *              Table               - Where the pointer to the table is returned
367  *
368  * RETURN:      Status and pointer to the requested table
369  *
370  * DESCRIPTION: Obtain a table by an index into the global table list. Used
371  *              internally also.
372  *
373  ******************************************************************************/
374 
375 ACPI_STATUS
376 AcpiGetTableByIndex (
377     UINT32                  TableIndex,
378     ACPI_TABLE_HEADER       **Table)
379 {
380     ACPI_STATUS             Status;
381 
382 
383     ACPI_FUNCTION_TRACE (AcpiGetTableByIndex);
384 
385 
386     /* Parameter validation */
387 
388     if (!Table)
389     {
390         return_ACPI_STATUS (AE_BAD_PARAMETER);
391     }
392 
393     (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
394 
395     /* Validate index */
396 
397     if (TableIndex >= AcpiGbl_RootTableList.CurrentTableCount)
398     {
399         (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
400         return_ACPI_STATUS (AE_BAD_PARAMETER);
401     }
402 
403     if (!AcpiGbl_RootTableList.Tables[TableIndex].Pointer)
404     {
405         /* Table is not mapped, map it */
406 
407         Status = AcpiTbValidateTable (
408             &AcpiGbl_RootTableList.Tables[TableIndex]);
409         if (ACPI_FAILURE (Status))
410         {
411             (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
412             return_ACPI_STATUS (Status);
413         }
414     }
415 
416     *Table = AcpiGbl_RootTableList.Tables[TableIndex].Pointer;
417     (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
418     return_ACPI_STATUS (AE_OK);
419 }
420 
421 ACPI_EXPORT_SYMBOL (AcpiGetTableByIndex)
422 
423 
424 /*******************************************************************************
425  *
426  * FUNCTION:    AcpiInstallTableHandler
427  *
428  * PARAMETERS:  Handler         - Table event handler
429  *              Context         - Value passed to the handler on each event
430  *
431  * RETURN:      Status
432  *
433  * DESCRIPTION: Install a global table event handler.
434  *
435  ******************************************************************************/
436 
437 ACPI_STATUS
438 AcpiInstallTableHandler (
439     ACPI_TABLE_HANDLER      Handler,
440     void                    *Context)
441 {
442     ACPI_STATUS             Status;
443 
444 
445     ACPI_FUNCTION_TRACE (AcpiInstallTableHandler);
446 
447 
448     if (!Handler)
449     {
450         return_ACPI_STATUS (AE_BAD_PARAMETER);
451     }
452 
453     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
454     if (ACPI_FAILURE (Status))
455     {
456         return_ACPI_STATUS (Status);
457     }
458 
459     /* Don't allow more than one handler */
460 
461     if (AcpiGbl_TableHandler)
462     {
463         Status = AE_ALREADY_EXISTS;
464         goto Cleanup;
465     }
466 
467     /* Install the handler */
468 
469     AcpiGbl_TableHandler = Handler;
470     AcpiGbl_TableHandlerContext = Context;
471 
472 Cleanup:
473     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
474     return_ACPI_STATUS (Status);
475 }
476 
477 ACPI_EXPORT_SYMBOL (AcpiInstallTableHandler)
478 
479 
480 /*******************************************************************************
481  *
482  * FUNCTION:    AcpiRemoveTableHandler
483  *
484  * PARAMETERS:  Handler         - Table event handler that was installed
485  *                                previously.
486  *
487  * RETURN:      Status
488  *
489  * DESCRIPTION: Remove a table event handler
490  *
491  ******************************************************************************/
492 
493 ACPI_STATUS
494 AcpiRemoveTableHandler (
495     ACPI_TABLE_HANDLER      Handler)
496 {
497     ACPI_STATUS             Status;
498 
499 
500     ACPI_FUNCTION_TRACE (AcpiRemoveTableHandler);
501 
502 
503     Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);
504     if (ACPI_FAILURE (Status))
505     {
506         return_ACPI_STATUS (Status);
507     }
508 
509     /* Make sure that the installed handler is the same */
510 
511     if (!Handler ||
512         Handler != AcpiGbl_TableHandler)
513     {
514         Status = AE_BAD_PARAMETER;
515         goto Cleanup;
516     }
517 
518     /* Remove the handler */
519 
520     AcpiGbl_TableHandler = NULL;
521 
522 Cleanup:
523     (void) AcpiUtReleaseMutex (ACPI_MTX_EVENTS);
524     return_ACPI_STATUS (Status);
525 }
526 
527 ACPI_EXPORT_SYMBOL (AcpiRemoveTableHandler)
528