1 /******************************************************************************
2 *
3 * Module Name: tbxfload - Table load/unload external interfaces
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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 __TBXFLOAD_C__
45 #define EXPORT_ACPI_INTERFACES
46
47 #include "acpi.h"
48 #include "accommon.h"
49 #include "acnamesp.h"
50 #include "actables.h"
51
52 #define _COMPONENT ACPI_TABLES
53 ACPI_MODULE_NAME ("tbxfload")
54
55 /* Local prototypes */
56
57 static ACPI_STATUS
58 AcpiTbLoadNamespace (
59 void);
60
61
62 /*******************************************************************************
63 *
64 * FUNCTION: AcpiLoadTables
65 *
66 * PARAMETERS: None
67 *
68 * RETURN: Status
69 *
70 * DESCRIPTION: Load the ACPI tables from the RSDT/XSDT
71 *
72 ******************************************************************************/
73
74 ACPI_STATUS
75 AcpiLoadTables (
76 void)
77 {
78 ACPI_STATUS Status;
79
80
81 ACPI_FUNCTION_TRACE (AcpiLoadTables);
82
83
84 /* Load the namespace from the tables */
85
86 Status = AcpiTbLoadNamespace ();
87 if (ACPI_FAILURE (Status))
88 {
89 ACPI_EXCEPTION ((AE_INFO, Status,
90 "While loading namespace from ACPI tables"));
91 }
92
93 return_ACPI_STATUS (Status);
94 }
95
96 ACPI_EXPORT_SYMBOL_INIT (AcpiLoadTables)
97
98
99 /*******************************************************************************
100 *
101 * FUNCTION: AcpiTbLoadNamespace
102 *
103 * PARAMETERS: None
104 *
105 * RETURN: Status
106 *
107 * DESCRIPTION: Load the namespace from the DSDT and all SSDTs/PSDTs found in
108 * the RSDT/XSDT.
109 *
110 ******************************************************************************/
111
112 static ACPI_STATUS
113 AcpiTbLoadNamespace (
114 void)
115 {
116 ACPI_STATUS Status;
117 UINT32 i;
118 ACPI_TABLE_HEADER *NewDsdt;
119
120
121 ACPI_FUNCTION_TRACE (TbLoadNamespace);
122
123
124 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
125
126 /*
127 * Load the namespace. The DSDT is required, but any SSDT and
128 * PSDT tables are optional. Verify the DSDT.
129 */
130 if (!AcpiGbl_RootTableList.CurrentTableCount ||
131 !ACPI_COMPARE_NAME (
132 &(AcpiGbl_RootTableList.Tables[ACPI_TABLE_INDEX_DSDT].Signature),
133 ACPI_SIG_DSDT) ||
134 ACPI_FAILURE (AcpiTbVerifyTable (
135 &AcpiGbl_RootTableList.Tables[ACPI_TABLE_INDEX_DSDT])))
136 {
137 Status = AE_NO_ACPI_TABLES;
138 goto UnlockAndExit;
139 }
140
141 /*
142 * Save the DSDT pointer for simple access. This is the mapped memory
143 * address. We must take care here because the address of the .Tables
144 * array can change dynamically as tables are loaded at run-time. Note:
145 * .Pointer field is not validated until after call to AcpiTbVerifyTable.
146 */
147 AcpiGbl_DSDT = AcpiGbl_RootTableList.Tables[ACPI_TABLE_INDEX_DSDT].Pointer;
148
149 /*
150 * Optionally copy the entire DSDT to local memory (instead of simply
151 * mapping it.) There are some BIOSs that corrupt or replace the original
152 * DSDT, creating the need for this option. Default is FALSE, do not copy
153 * the DSDT.
154 */
155 if (AcpiGbl_CopyDsdtLocally)
156 {
157 NewDsdt = AcpiTbCopyDsdt (ACPI_TABLE_INDEX_DSDT);
158 if (NewDsdt)
159 {
160 AcpiGbl_DSDT = NewDsdt;
161 }
162 }
163
164 /*
165 * Save the original DSDT header for detection of table corruption
166 * and/or replacement of the DSDT from outside the OS.
167 */
168 ACPI_MEMCPY (&AcpiGbl_OriginalDsdtHeader, AcpiGbl_DSDT,
169 sizeof (ACPI_TABLE_HEADER));
170
171 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
172
173 /* Load and parse tables */
174
175 Status = AcpiNsLoadTable (ACPI_TABLE_INDEX_DSDT, AcpiGbl_RootNode);
176 if (ACPI_FAILURE (Status))
177 {
178 return_ACPI_STATUS (Status);
179 }
180
181 /* Load any SSDT or PSDT tables. Note: Loop leaves tables locked */
182
183 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
184 for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; ++i)
185 {
186 if ((!ACPI_COMPARE_NAME (&(AcpiGbl_RootTableList.Tables[i].Signature),
187 ACPI_SIG_SSDT) &&
188 !ACPI_COMPARE_NAME (&(AcpiGbl_RootTableList.Tables[i].Signature),
189 ACPI_SIG_PSDT)) ||
190 ACPI_FAILURE (AcpiTbVerifyTable (
191 &AcpiGbl_RootTableList.Tables[i])))
192 {
193 continue;
194 }
195
196 /*
197 * Optionally do not load any SSDTs from the RSDT/XSDT. This can
198 * be useful for debugging ACPI problems on some machines.
199 */
200 if (AcpiGbl_DisableSsdtTableLoad)
201 {
202 ACPI_INFO ((AE_INFO, "Ignoring %4.4s at %p",
203 AcpiGbl_RootTableList.Tables[i].Signature.Ascii,
204 ACPI_CAST_PTR (void, AcpiGbl_RootTableList.Tables[i].Address)));
205 continue;
206 }
207
208 /* Ignore errors while loading tables, get as many as possible */
209
210 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
211 (void) AcpiNsLoadTable (i, AcpiGbl_RootNode);
212 (void) AcpiUtAcquireMutex (ACPI_MTX_TABLES);
213 }
214
215 ACPI_INFO ((AE_INFO, "All ACPI Tables successfully acquired"));
216
217 UnlockAndExit:
218 (void) AcpiUtReleaseMutex (ACPI_MTX_TABLES);
219 return_ACPI_STATUS (Status);
220 }
221
222
223 /*******************************************************************************
224 *
225 * FUNCTION: AcpiLoadTable
226 *
227 * PARAMETERS: Table - Pointer to a buffer containing the ACPI
228 * table to be loaded.
229 *
230 * RETURN: Status
231 *
232 * DESCRIPTION: Dynamically load an ACPI table from the caller's buffer. Must
233 * be a valid ACPI table with a valid ACPI table header.
234 * Note1: Mainly intended to support hotplug addition of SSDTs.
235 * Note2: Does not copy the incoming table. User is responsible
236 * to ensure that the table is not deleted or unmapped.
237 *
238 ******************************************************************************/
239
240 ACPI_STATUS
241 AcpiLoadTable (
242 ACPI_TABLE_HEADER *Table)
243 {
244 ACPI_STATUS Status;
245 ACPI_TABLE_DESC TableDesc;
246 UINT32 TableIndex;
247
248
249 ACPI_FUNCTION_TRACE (AcpiLoadTable);
250
251
252 /* Parameter validation */
253
254 if (!Table)
255 {
256 return_ACPI_STATUS (AE_BAD_PARAMETER);
257 }
258
259 /* Init local table descriptor */
260
261 ACPI_MEMSET (&TableDesc, 0, sizeof (ACPI_TABLE_DESC));
262 TableDesc.Address = ACPI_PTR_TO_PHYSADDR (Table);
263 TableDesc.Pointer = Table;
264 TableDesc.Length = Table->Length;
265 TableDesc.Flags = ACPI_TABLE_ORIGIN_UNKNOWN;
266
267 /* Must acquire the interpreter lock during this operation */
268
269 Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER);
270 if (ACPI_FAILURE (Status))
271 {
272 return_ACPI_STATUS (Status);
273 }
274
275 /* Install the table and load it into the namespace */
276
277 ACPI_INFO ((AE_INFO, "Host-directed Dynamic ACPI Table Load:"));
278 Status = AcpiTbAddTable (&TableDesc, &TableIndex);
279 if (ACPI_FAILURE (Status))
280 {
281 goto UnlockAndExit;
282 }
283
284 Status = AcpiNsLoadTable (TableIndex, AcpiGbl_RootNode);
285
286 /* Invoke table handler if present */
287
288 if (AcpiGbl_TableHandler)
289 {
290 (void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, Table,
291 AcpiGbl_TableHandlerContext);
292 }
293
294 UnlockAndExit:
295 (void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
296 return_ACPI_STATUS (Status);
297 }
298
299 ACPI_EXPORT_SYMBOL (AcpiLoadTable)
300
301
302 /*******************************************************************************
303 *
304 * FUNCTION: AcpiUnloadParentTable
305 *
306 * PARAMETERS: Object - Handle to any namespace object owned by
307 * the table to be unloaded
308 *
309 * RETURN: Status
310 *
311 * DESCRIPTION: Via any namespace object within an SSDT or OEMx table, unloads
312 * the table and deletes all namespace objects associated with
313 * that table. Unloading of the DSDT is not allowed.
314 * Note: Mainly intended to support hotplug removal of SSDTs.
315 *
316 ******************************************************************************/
317
318 ACPI_STATUS
319 AcpiUnloadParentTable (
320 ACPI_HANDLE Object)
321 {
322 ACPI_NAMESPACE_NODE *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Object);
323 ACPI_STATUS Status = AE_NOT_EXIST;
324 ACPI_OWNER_ID OwnerId;
325 UINT32 i;
326
327
328 ACPI_FUNCTION_TRACE (AcpiUnloadParentTable);
329
330
331 /* Parameter validation */
332
333 if (!Object)
334 {
335 return_ACPI_STATUS (AE_BAD_PARAMETER);
336 }
337
338 /*
339 * The node OwnerId is currently the same as the parent table ID.
340 * However, this could change in the future.
341 */
342 OwnerId = Node->OwnerId;
343 if (!OwnerId)
344 {
345 /* OwnerId==0 means DSDT is the owner. DSDT cannot be unloaded */
346
347 return_ACPI_STATUS (AE_TYPE);
348 }
349
350 /* Must acquire the interpreter lock during this operation */
351
352 Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER);
353 if (ACPI_FAILURE (Status))
354 {
355 return_ACPI_STATUS (Status);
356 }
357
358 /* Find the table in the global table list */
359
360 for (i = 0; i < AcpiGbl_RootTableList.CurrentTableCount; i++)
361 {
362 if (OwnerId != AcpiGbl_RootTableList.Tables[i].OwnerId)
363 {
364 continue;
365 }
366
367 /*
368 * Allow unload of SSDT and OEMx tables only. Do not allow unload
369 * of the DSDT. No other types of tables should get here, since
370 * only these types can contain AML and thus are the only types
371 * that can create namespace objects.
372 */
373 if (ACPI_COMPARE_NAME (
374 AcpiGbl_RootTableList.Tables[i].Signature.Ascii,
375 ACPI_SIG_DSDT))
376 {
377 Status = AE_TYPE;
378 break;
379 }
380
381 /* Ensure the table is actually loaded */
382
383 if (!AcpiTbIsTableLoaded (i))
384 {
385 Status = AE_NOT_EXIST;
386 break;
387 }
388
389 /* Invoke table handler if present */
390
391 if (AcpiGbl_TableHandler)
392 {
393 (void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_UNLOAD,
394 AcpiGbl_RootTableList.Tables[i].Pointer,
395 AcpiGbl_TableHandlerContext);
396 }
397
398 /*
399 * Delete all namespace objects owned by this table. Note that
400 * these objects can appear anywhere in the namespace by virtue
401 * of the AML "Scope" operator. Thus, we need to track ownership
402 * by an ID, not simply a position within the hierarchy.
403 */
404 Status = AcpiTbDeleteNamespaceByOwner (i);
405 if (ACPI_FAILURE (Status))
406 {
407 break;
408 }
409
410 Status = AcpiTbReleaseOwnerId (i);
411 AcpiTbSetTableLoadedFlag (i, FALSE);
412 break;
413 }
414
415 (void) AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
416 return_ACPI_STATUS (Status);
417 }
418
419 ACPI_EXPORT_SYMBOL (AcpiUnloadParentTable)