Raise WARNS to 6:
[dragonfly.git] / sys / contrib / dev / acpica-unix-20040527 / TABLES / tbxface.c
1 /******************************************************************************
2  *
3  * Module Name: tbxface - Public interfaces to the ACPI subsystem
4  *                         ACPI table oriented interfaces
5  *              $Revision: 64 $
6  *
7  *****************************************************************************/
8
9 /******************************************************************************
10  *
11  * 1. Copyright Notice
12  *
13  * Some or all of this work - Copyright (c) 1999 - 2004, Intel Corp.
14  * All rights reserved.
15  *
16  * 2. License
17  *
18  * 2.1. This is your license from Intel Corp. under its intellectual property
19  * rights.  You may have additional license terms from the party that provided
20  * you this software, covering your right to use that party's intellectual
21  * property rights.
22  *
23  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
24  * copy of the source code appearing in this file ("Covered Code") an
25  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
26  * base code distributed originally by Intel ("Original Intel Code") to copy,
27  * make derivatives, distribute, use and display any portion of the Covered
28  * Code in any form, with the right to sublicense such rights; and
29  *
30  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
31  * license (with the right to sublicense), under only those claims of Intel
32  * patents that are infringed by the Original Intel Code, to make, use, sell,
33  * offer to sell, and import the Covered Code and derivative works thereof
34  * solely to the minimum extent necessary to exercise the above copyright
35  * license, and in no event shall the patent license extend to any additions
36  * to or modifications of the Original Intel Code.  No other license or right
37  * is granted directly or by implication, estoppel or otherwise;
38  *
39  * The above copyright and patent license is granted only if the following
40  * conditions are met:
41  *
42  * 3. Conditions
43  *
44  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
45  * Redistribution of source code of any substantial portion of the Covered
46  * Code or modification with rights to further distribute source must include
47  * the above Copyright Notice, the above License, this list of Conditions,
48  * and the following Disclaimer and Export Compliance provision.  In addition,
49  * Licensee must cause all Covered Code to which Licensee contributes to
50  * contain a file documenting the changes Licensee made to create that Covered
51  * Code and the date of any change.  Licensee must include in that file the
52  * documentation of any changes made by any predecessor Licensee.  Licensee
53  * must include a prominent statement that the modification is derived,
54  * directly or indirectly, from Original Intel Code.
55  *
56  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
57  * Redistribution of source code of any substantial portion of the Covered
58  * Code or modification without rights to further distribute source must
59  * include the following Disclaimer and Export Compliance provision in the
60  * documentation and/or other materials provided with distribution.  In
61  * addition, Licensee may not authorize further sublicense of source of any
62  * portion of the Covered Code, and must include terms to the effect that the
63  * license from Licensee to its licensee is limited to the intellectual
64  * property embodied in the software Licensee provides to its licensee, and
65  * not to intellectual property embodied in modifications its licensee may
66  * make.
67  *
68  * 3.3. Redistribution of Executable. Redistribution in executable form of any
69  * substantial portion of the Covered Code or modification must reproduce the
70  * above Copyright Notice, and the following Disclaimer and Export Compliance
71  * provision in the documentation and/or other materials provided with the
72  * distribution.
73  *
74  * 3.4. Intel retains all right, title, and interest in and to the Original
75  * Intel Code.
76  *
77  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
78  * Intel shall be used in advertising or otherwise to promote the sale, use or
79  * other dealings in products derived from or relating to the Covered Code
80  * without prior written authorization from Intel.
81  *
82  * 4. Disclaimer and Export Compliance
83  *
84  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
85  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
86  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
87  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90  * PARTICULAR PURPOSE.
91  *
92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99  * LIMITED REMEDY.
100  *
101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
102  * software or system incorporating such software without first obtaining any
103  * required license or other approval from the U. S. Department of Commerce or
104  * any other agency or department of the United States Government.  In the
105  * event Licensee exports any such software from the United States or
106  * re-exports any such software from a foreign destination, Licensee shall
107  * ensure that the distribution and export/re-export of the software is in
108  * compliance with all laws, regulations, orders, or other restrictions of the
109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
110  * any of its subsidiaries will export/re-export any technical data, process,
111  * software, or service, directly or indirectly, to any country for which the
112  * United States government or any agency thereof requires an export license,
113  * other governmental approval, or letter of assurance, without first obtaining
114  * such license, approval or letter.
115  *
116  *****************************************************************************/
117
118 #define __TBXFACE_C__
119
120 #include "acpi.h"
121 #include "acnamesp.h"
122 #include "actables.h"
123
124
125 #define _COMPONENT          ACPI_TABLES
126         ACPI_MODULE_NAME    ("tbxface")
127
128
129 /*******************************************************************************
130  *
131  * FUNCTION:    AcpiLoadTables
132  *
133  * PARAMETERS:  None
134  *
135  * RETURN:      Status
136  *
137  * DESCRIPTION: This function is called to load the ACPI tables from the
138  *              provided RSDT
139  *
140  ******************************************************************************/
141
142 ACPI_STATUS
143 AcpiLoadTables (void)
144 {
145     ACPI_POINTER            RsdpAddress;
146     ACPI_STATUS             Status;
147
148
149     ACPI_FUNCTION_TRACE ("AcpiLoadTables");
150
151
152     /* Get the RSDP */
153
154     Status = AcpiOsGetRootPointer (ACPI_LOGICAL_ADDRESSING,
155                     &RsdpAddress);
156     if (ACPI_FAILURE (Status))
157     {
158         ACPI_REPORT_ERROR (("AcpiLoadTables: Could not get RSDP, %s\n",
159                         AcpiFormatException (Status)));
160         goto ErrorExit;
161     }
162
163     /* Map and validate the RSDP */
164
165     AcpiGbl_TableFlags = RsdpAddress.PointerType;
166
167     Status = AcpiTbVerifyRsdp (&RsdpAddress);
168     if (ACPI_FAILURE (Status))
169     {
170         ACPI_REPORT_ERROR (("AcpiLoadTables: RSDP Failed validation: %s\n",
171                         AcpiFormatException (Status)));
172         goto ErrorExit;
173     }
174
175     /* Get the RSDT via the RSDP */
176
177     Status = AcpiTbGetTableRsdt ();
178     if (ACPI_FAILURE (Status))
179     {
180         ACPI_REPORT_ERROR (("AcpiLoadTables: Could not load RSDT: %s\n",
181                         AcpiFormatException (Status)));
182         goto ErrorExit;
183     }
184
185     /* Now get the tables needed by this subsystem (FADT, DSDT, etc.) */
186
187     Status = AcpiTbGetRequiredTables ();
188     if (ACPI_FAILURE (Status))
189     {
190         ACPI_REPORT_ERROR (("AcpiLoadTables: Error getting required tables (DSDT/FADT/FACS): %s\n",
191                         AcpiFormatException (Status)));
192         goto ErrorExit;
193     }
194
195     ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "ACPI Tables successfully acquired\n"));
196
197
198     /* Load the namespace from the tables */
199
200     Status = AcpiNsLoadNamespace ();
201     if (ACPI_FAILURE (Status))
202     {
203         ACPI_REPORT_ERROR (("AcpiLoadTables: Could not load namespace: %s\n",
204                         AcpiFormatException (Status)));
205         goto ErrorExit;
206     }
207
208     return_ACPI_STATUS (AE_OK);
209
210
211 ErrorExit:
212     ACPI_REPORT_ERROR (("AcpiLoadTables: Could not load tables: %s\n",
213                     AcpiFormatException (Status)));
214
215     return_ACPI_STATUS (Status);
216 }
217
218
219 /*******************************************************************************
220  *
221  * FUNCTION:    AcpiLoadTable
222  *
223  * PARAMETERS:  TablePtr        - pointer to a buffer containing the entire
224  *                                table to be loaded
225  *
226  * RETURN:      Status
227  *
228  * DESCRIPTION: This function is called to load a table from the caller's
229  *              buffer.  The buffer must contain an entire ACPI Table including
230  *              a valid header.  The header fields will be verified, and if it
231  *              is determined that the table is invalid, the call will fail.
232  *
233  ******************************************************************************/
234
235 ACPI_STATUS
236 AcpiLoadTable (
237     ACPI_TABLE_HEADER       *TablePtr)
238 {
239     ACPI_STATUS             Status;
240     ACPI_TABLE_DESC         TableInfo;
241     ACPI_POINTER            Address;
242
243
244     ACPI_FUNCTION_TRACE ("AcpiLoadTable");
245
246
247     if (!TablePtr)
248     {
249         return_ACPI_STATUS (AE_BAD_PARAMETER);
250     }
251
252     /* Copy the table to a local buffer */
253
254     Address.PointerType     = ACPI_LOGICAL_POINTER | ACPI_LOGICAL_ADDRESSING;
255     Address.Pointer.Logical = TablePtr;
256
257     Status = AcpiTbGetTableBody (&Address, TablePtr, &TableInfo);
258     if (ACPI_FAILURE (Status))
259     {
260         return_ACPI_STATUS (Status);
261     }
262
263     /* Install the new table into the local data structures */
264
265     Status = AcpiTbInstallTable (&TableInfo);
266     if (ACPI_FAILURE (Status))
267     {
268         /* Free table allocated by AcpiTbGetTableBody */
269
270         AcpiTbDeleteSingleTable (&TableInfo);
271         return_ACPI_STATUS (Status);
272     }
273
274     /* Convert the table to common format if necessary */
275
276     switch (TableInfo.Type)
277     {
278     case ACPI_TABLE_FADT:
279
280         Status = AcpiTbConvertTableFadt ();
281         break;
282
283     case ACPI_TABLE_FACS:
284
285         Status = AcpiTbBuildCommonFacs (&TableInfo);
286         break;
287
288     default:
289         /* Load table into namespace if it contains executable AML */
290
291         Status = AcpiNsLoadTable (TableInfo.InstalledDesc, AcpiGbl_RootNode);
292         break;
293     }
294
295     if (ACPI_FAILURE (Status))
296     {
297         /* Uninstall table and free the buffer */
298
299         (void) AcpiTbUninstallTable (TableInfo.InstalledDesc);
300     }
301
302     return_ACPI_STATUS (Status);
303 }
304
305
306 /*******************************************************************************
307  *
308  * FUNCTION:    AcpiUnloadTable
309  *
310  * PARAMETERS:  TableType     - Type of table to be unloaded
311  *
312  * RETURN:      Status
313  *
314  * DESCRIPTION: This routine is used to force the unload of a table
315  *
316  ******************************************************************************/
317
318 ACPI_STATUS
319 AcpiUnloadTable (
320     ACPI_TABLE_TYPE         TableType)
321 {
322     ACPI_TABLE_DESC         *TableDesc;
323
324
325     ACPI_FUNCTION_TRACE ("AcpiUnloadTable");
326
327
328     /* Parameter validation */
329
330     if (TableType > ACPI_TABLE_MAX)
331     {
332         return_ACPI_STATUS (AE_BAD_PARAMETER);
333     }
334
335
336     /* Find all tables of the requested type */
337
338     TableDesc = AcpiGbl_TableLists[TableType].Next;
339     while (TableDesc)
340     {
341         /*
342          * Delete all namespace entries owned by this table.  Note that these
343          * entries can appear anywhere in the namespace by virtue of the AML
344          * "Scope" operator.  Thus, we need to track ownership by an ID, not
345          * simply a position within the hierarchy
346          */
347         AcpiNsDeleteNamespaceByOwner (TableDesc->TableId);
348
349         TableDesc = TableDesc->Next;
350     }
351
352     /* Delete (or unmap) all tables of this type */
353
354     AcpiTbDeleteTablesByType (TableType);
355     return_ACPI_STATUS (AE_OK);
356 }
357
358
359 /*******************************************************************************
360  *
361  * FUNCTION:    AcpiGetTableHeader
362  *
363  * PARAMETERS:  TableType       - one of the defined table types
364  *              Instance        - the non zero instance of the table, allows
365  *                                support for multiple tables of the same type
366  *                                see AcpiGbl_AcpiTableFlag
367  *              OutTableHeader  - pointer to the ACPI_TABLE_HEADER if successful
368  *
369  * DESCRIPTION: This function is called to get an ACPI table header.  The caller
370  *              supplies an pointer to a data area sufficient to contain an ACPI
371  *              ACPI_TABLE_HEADER structure.
372  *
373  *              The header contains a length field that can be used to determine
374  *              the size of the buffer needed to contain the entire table.  This
375  *              function is not valid for the RSD PTR table since it does not
376  *              have a standard header and is fixed length.
377  *
378  ******************************************************************************/
379
380 ACPI_STATUS
381 AcpiGetTableHeader (
382     ACPI_TABLE_TYPE         TableType,
383     UINT32                  Instance,
384     ACPI_TABLE_HEADER       *OutTableHeader)
385 {
386     ACPI_TABLE_HEADER       *TblPtr;
387     ACPI_STATUS             Status;
388
389
390     ACPI_FUNCTION_TRACE ("AcpiGetTableHeader");
391
392
393     if ((Instance == 0)                 ||
394         (TableType == ACPI_TABLE_RSDP)  ||
395         (!OutTableHeader))
396     {
397         return_ACPI_STATUS (AE_BAD_PARAMETER);
398     }
399
400     /* Check the table type and instance */
401
402     if ((TableType > ACPI_TABLE_MAX)    ||
403         (ACPI_IS_SINGLE_TABLE (AcpiGbl_TableData[TableType].Flags) &&
404          Instance > 1))
405     {
406         return_ACPI_STATUS (AE_BAD_PARAMETER);
407     }
408
409
410     /* Get a pointer to the entire table */
411
412     Status = AcpiTbGetTablePtr (TableType, Instance, &TblPtr);
413     if (ACPI_FAILURE (Status))
414     {
415         return_ACPI_STATUS (Status);
416     }
417
418     /*
419      * The function will return a NULL pointer if the table is not loaded
420      */
421     if (TblPtr == NULL)
422     {
423         return_ACPI_STATUS (AE_NOT_EXIST);
424     }
425
426     /*
427      * Copy the header to the caller's buffer
428      */
429     ACPI_MEMCPY ((void *) OutTableHeader, (void *) TblPtr,
430                 sizeof (ACPI_TABLE_HEADER));
431
432     return_ACPI_STATUS (Status);
433 }
434
435
436 /*******************************************************************************
437  *
438  * FUNCTION:    AcpiGetTable
439  *
440  * PARAMETERS:  TableType       - one of the defined table types
441  *              Instance        - the non zero instance of the table, allows
442  *                                support for multiple tables of the same type
443  *                                see AcpiGbl_AcpiTableFlag
444  *              RetBuffer       - pointer to a structure containing a buffer to
445  *                                receive the table
446  *
447  * RETURN:      Status
448  *
449  * DESCRIPTION: This function is called to get an ACPI table.  The caller
450  *              supplies an OutBuffer large enough to contain the entire ACPI
451  *              table.  The caller should call the AcpiGetTableHeader function
452  *              first to determine the buffer size needed.  Upon completion
453  *              the OutBuffer->Length field will indicate the number of bytes
454  *              copied into the OutBuffer->BufPtr buffer.  This table will be
455  *              a complete table including the header.
456  *
457  ******************************************************************************/
458
459 ACPI_STATUS
460 AcpiGetTable (
461     ACPI_TABLE_TYPE         TableType,
462     UINT32                  Instance,
463     ACPI_BUFFER             *RetBuffer)
464 {
465     ACPI_TABLE_HEADER       *TblPtr;
466     ACPI_STATUS             Status;
467     ACPI_SIZE               TableLength;
468
469
470     ACPI_FUNCTION_TRACE ("AcpiGetTable");
471
472
473     /* Parameter validation */
474
475     if (Instance == 0)
476     {
477         return_ACPI_STATUS (AE_BAD_PARAMETER);
478     }
479
480     Status = AcpiUtValidateBuffer (RetBuffer);
481     if (ACPI_FAILURE (Status))
482     {
483         return_ACPI_STATUS (Status);
484     }
485
486     /* Check the table type and instance */
487
488     if ((TableType > ACPI_TABLE_MAX)    ||
489         (ACPI_IS_SINGLE_TABLE (AcpiGbl_TableData[TableType].Flags) &&
490          Instance > 1))
491     {
492         return_ACPI_STATUS (AE_BAD_PARAMETER);
493     }
494
495
496     /* Get a pointer to the entire table */
497
498     Status = AcpiTbGetTablePtr (TableType, Instance, &TblPtr);
499     if (ACPI_FAILURE (Status))
500     {
501         return_ACPI_STATUS (Status);
502     }
503
504     /*
505      * AcpiTbGetTablePtr will return a NULL pointer if the
506      * table is not loaded.
507      */
508     if (TblPtr == NULL)
509     {
510         return_ACPI_STATUS (AE_NOT_EXIST);
511     }
512
513     /* Get the table length */
514
515     if (TableType == ACPI_TABLE_RSDP)
516     {
517         /*
518          *  RSD PTR is the only "table" without a header
519          */
520         TableLength = sizeof (RSDP_DESCRIPTOR);
521     }
522     else
523     {
524         TableLength = (ACPI_SIZE) TblPtr->Length;
525     }
526
527     /* Validate/Allocate/Clear caller buffer */
528
529     Status = AcpiUtInitializeBuffer (RetBuffer, TableLength);
530     if (ACPI_FAILURE (Status))
531     {
532         return_ACPI_STATUS (Status);
533     }
534
535     /* Copy the table to the buffer */
536
537     ACPI_MEMCPY ((void *) RetBuffer->Pointer, (void *) TblPtr, TableLength);
538     return_ACPI_STATUS (AE_OK);
539 }
540
541