1/******************************************************************************
2 *
3 * Module Name: utxface - External interfaces for "global" ACPI functions
4 *
5 *****************************************************************************/
6
7/******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights.  You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code.  No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision.  In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change.  Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee.  Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution.  In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government.  In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************/
115
116
117#define __UTXFACE_C__
118
119#include "acpi.h"
120#include "accommon.h"
121#include "acevents.h"
122#include "acnamesp.h"
123#include "acdebug.h"
124#include "actables.h"
125
126#define _COMPONENT          ACPI_UTILITIES
127        ACPI_MODULE_NAME    ("utxface")
128
129
130#ifndef ACPI_ASL_COMPILER
131
132/*******************************************************************************
133 *
134 * FUNCTION:    AcpiInitializeSubsystem
135 *
136 * PARAMETERS:  None
137 *
138 * RETURN:      Status
139 *
140 * DESCRIPTION: Initializes all global variables.  This is the first function
141 *              called, so any early initialization belongs here.
142 *
143 ******************************************************************************/
144
145ACPI_STATUS
146AcpiInitializeSubsystem (
147    void)
148{
149    ACPI_STATUS             Status;
150
151
152    ACPI_FUNCTION_TRACE (AcpiInitializeSubsystem);
153
154
155    AcpiGbl_StartupFlags = ACPI_SUBSYSTEM_INITIALIZE;
156    ACPI_DEBUG_EXEC (AcpiUtInitStackPtrTrace ());
157
158    /* Initialize the OS-Dependent layer */
159
160    Status = AcpiOsInitialize ();
161    if (ACPI_FAILURE (Status))
162    {
163        ACPI_EXCEPTION ((AE_INFO, Status, "During OSL initialization"));
164        return_ACPI_STATUS (Status);
165    }
166
167    /* Initialize all globals used by the subsystem */
168
169    Status = AcpiUtInitGlobals ();
170    if (ACPI_FAILURE (Status))
171    {
172        ACPI_EXCEPTION ((AE_INFO, Status, "During initialization of globals"));
173        return_ACPI_STATUS (Status);
174    }
175
176    /* Create the default mutex objects */
177
178    Status = AcpiUtMutexInitialize ();
179    if (ACPI_FAILURE (Status))
180    {
181        ACPI_EXCEPTION ((AE_INFO, Status, "During Global Mutex creation"));
182        return_ACPI_STATUS (Status);
183    }
184
185    /*
186     * Initialize the namespace manager and
187     * the root of the namespace tree
188     */
189    Status = AcpiNsRootInitialize ();
190    if (ACPI_FAILURE (Status))
191    {
192        ACPI_EXCEPTION ((AE_INFO, Status, "During Namespace initialization"));
193        return_ACPI_STATUS (Status);
194    }
195
196    /* If configured, initialize the AML debugger */
197
198    ACPI_DEBUGGER_EXEC (Status = AcpiDbInitialize ());
199    return_ACPI_STATUS (Status);
200}
201
202ACPI_EXPORT_SYMBOL (AcpiInitializeSubsystem)
203
204
205/*******************************************************************************
206 *
207 * FUNCTION:    AcpiEnableSubsystem
208 *
209 * PARAMETERS:  Flags           - Init/enable Options
210 *
211 * RETURN:      Status
212 *
213 * DESCRIPTION: Completes the subsystem initialization including hardware.
214 *              Puts system into ACPI mode if it isn't already.
215 *
216 ******************************************************************************/
217
218ACPI_STATUS
219AcpiEnableSubsystem (
220    UINT32                  Flags)
221{
222    ACPI_STATUS             Status = AE_OK;
223
224
225    ACPI_FUNCTION_TRACE (AcpiEnableSubsystem);
226
227
228    /* Enable ACPI mode */
229
230    if (!(Flags & ACPI_NO_ACPI_ENABLE))
231    {
232        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n"));
233
234        AcpiGbl_OriginalMode = AcpiHwGetMode();
235
236        Status = AcpiEnable ();
237        if (ACPI_FAILURE (Status))
238        {
239            ACPI_WARNING ((AE_INFO, "AcpiEnable failed"));
240            return_ACPI_STATUS (Status);
241        }
242    }
243
244    /*
245     * Obtain a permanent mapping for the FACS. This is required for the
246     * Global Lock and the Firmware Waking Vector
247     */
248    Status = AcpiTbInitializeFacs ();
249    if (ACPI_FAILURE (Status))
250    {
251        ACPI_WARNING ((AE_INFO, "Could not map the FACS table"));
252        return_ACPI_STATUS (Status);
253    }
254
255    /*
256     * Install the default OpRegion handlers.  These are installed unless
257     * other handlers have already been installed via the
258     * InstallAddressSpaceHandler interface.
259     */
260    if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
261    {
262        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
263            "[Init] Installing default address space handlers\n"));
264
265        Status = AcpiEvInstallRegionHandlers ();
266        if (ACPI_FAILURE (Status))
267        {
268            return_ACPI_STATUS (Status);
269        }
270    }
271
272    /*
273     * Initialize ACPI Event handling (Fixed and General Purpose)
274     *
275     * Note1: We must have the hardware and events initialized before we can
276     * execute any control methods safely. Any control method can require
277     * ACPI hardware support, so the hardware must be fully initialized before
278     * any method execution!
279     *
280     * Note2: Fixed events are initialized and enabled here. GPEs are
281     * initialized, but cannot be enabled until after the hardware is
282     * completely initialized (SCI and GlobalLock activated) and the various
283     * initialization control methods are run (_REG, _STA, _INI) on the
284     * entire namespace.
285     */
286    if (!(Flags & ACPI_NO_EVENT_INIT))
287    {
288        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
289            "[Init] Initializing ACPI events\n"));
290
291        Status = AcpiEvInitializeEvents ();
292        if (ACPI_FAILURE (Status))
293        {
294            return_ACPI_STATUS (Status);
295        }
296    }
297
298    /*
299     * Install the SCI handler and Global Lock handler. This completes the
300     * hardware initialization.
301     */
302    if (!(Flags & ACPI_NO_HANDLER_INIT))
303    {
304        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
305            "[Init] Installing SCI/GL handlers\n"));
306
307        Status = AcpiEvInstallXruptHandlers ();
308        if (ACPI_FAILURE (Status))
309        {
310            return_ACPI_STATUS (Status);
311        }
312    }
313
314    return_ACPI_STATUS (Status);
315}
316
317ACPI_EXPORT_SYMBOL (AcpiEnableSubsystem)
318
319
320/*******************************************************************************
321 *
322 * FUNCTION:    AcpiInitializeObjects
323 *
324 * PARAMETERS:  Flags           - Init/enable Options
325 *
326 * RETURN:      Status
327 *
328 * DESCRIPTION: Completes namespace initialization by initializing device
329 *              objects and executing AML code for Regions, buffers, etc.
330 *
331 ******************************************************************************/
332
333ACPI_STATUS
334AcpiInitializeObjects (
335    UINT32                  Flags)
336{
337    ACPI_STATUS             Status = AE_OK;
338
339
340    ACPI_FUNCTION_TRACE (AcpiInitializeObjects);
341
342
343    /*
344     * Run all _REG methods
345     *
346     * Note: Any objects accessed by the _REG methods will be automatically
347     * initialized, even if they contain executable AML (see the call to
348     * AcpiNsInitializeObjects below).
349     */
350    if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
351    {
352        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
353            "[Init] Executing _REG OpRegion methods\n"));
354
355        Status = AcpiEvInitializeOpRegions ();
356        if (ACPI_FAILURE (Status))
357        {
358            return_ACPI_STATUS (Status);
359        }
360    }
361
362    /*
363     * Execute any module-level code that was detected during the table load
364     * phase. Although illegal since ACPI 2.0, there are many machines that
365     * contain this type of code. Each block of detected executable AML code
366     * outside of any control method is wrapped with a temporary control
367     * method object and placed on a global list. The methods on this list
368     * are executed below.
369     */
370    AcpiNsExecModuleCodeList ();
371
372    /*
373     * Initialize the objects that remain uninitialized. This runs the
374     * executable AML that may be part of the declaration of these objects:
375     * OperationRegions, BufferFields, Buffers, and Packages.
376     */
377    if (!(Flags & ACPI_NO_OBJECT_INIT))
378    {
379        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
380            "[Init] Completing Initialization of ACPI Objects\n"));
381
382        Status = AcpiNsInitializeObjects ();
383        if (ACPI_FAILURE (Status))
384        {
385            return_ACPI_STATUS (Status);
386        }
387    }
388
389    /*
390     * Initialize all device objects in the namespace. This runs the device
391     * _STA and _INI methods.
392     */
393    if (!(Flags & ACPI_NO_DEVICE_INIT))
394    {
395        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
396            "[Init] Initializing ACPI Devices\n"));
397
398        Status = AcpiNsInitializeDevices ();
399        if (ACPI_FAILURE (Status))
400        {
401            return_ACPI_STATUS (Status);
402        }
403    }
404
405    /*
406     * Initialize the GPE blocks defined in the FADT (GPE block 0 and 1).
407     * The runtime GPEs are enabled here.
408     *
409     * This is where the _PRW methods are executed for the GPEs. These
410     * methods can only be executed after the SCI and Global Lock handlers are
411     * installed and initialized.
412     *
413     * GPEs can only be enabled after the _REG, _STA, and _INI methods have
414     * been run. This ensures that all Operation Regions and all Devices have
415     * been initialized and are ready.
416     */
417    if (!(Flags & ACPI_NO_EVENT_INIT))
418    {
419        Status = AcpiEvInstallFadtGpes ();
420        if (ACPI_FAILURE (Status))
421        {
422            return (Status);
423        }
424    }
425
426    /*
427     * Empty the caches (delete the cached objects) on the assumption that
428     * the table load filled them up more than they will be at runtime --
429     * thus wasting non-paged memory.
430     */
431    Status = AcpiPurgeCachedObjects ();
432
433    AcpiGbl_StartupFlags |= ACPI_INITIALIZED_OK;
434    return_ACPI_STATUS (Status);
435}
436
437ACPI_EXPORT_SYMBOL (AcpiInitializeObjects)
438
439
440#endif
441
442/*******************************************************************************
443 *
444 * FUNCTION:    AcpiTerminate
445 *
446 * PARAMETERS:  None
447 *
448 * RETURN:      Status
449 *
450 * DESCRIPTION: Shutdown the ACPICA subsystem and release all resources.
451 *
452 ******************************************************************************/
453
454ACPI_STATUS
455AcpiTerminate (
456    void)
457{
458    ACPI_STATUS         Status;
459
460
461    ACPI_FUNCTION_TRACE (AcpiTerminate);
462
463
464    /* Just exit if subsystem is already shutdown */
465
466    if (AcpiGbl_Shutdown)
467    {
468        ACPI_ERROR ((AE_INFO, "ACPI Subsystem is already terminated"));
469        return_ACPI_STATUS (AE_OK);
470    }
471
472    /* Subsystem appears active, go ahead and shut it down */
473
474    AcpiGbl_Shutdown = TRUE;
475    AcpiGbl_StartupFlags = 0;
476    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Shutting down ACPI Subsystem\n"));
477
478    /* Terminate the AML Debugger if present */
479
480    ACPI_DEBUGGER_EXEC (AcpiGbl_DbTerminateThreads = TRUE);
481
482    /* Shutdown and free all resources */
483
484    AcpiUtSubsystemShutdown ();
485
486    /* Free the mutex objects */
487
488    AcpiUtMutexTerminate ();
489
490
491#ifdef ACPI_DEBUGGER
492
493    /* Shut down the debugger */
494
495    AcpiDbTerminate ();
496#endif
497
498    /* Now we can shutdown the OS-dependent layer */
499
500    Status = AcpiOsTerminate ();
501    return_ACPI_STATUS (Status);
502}
503
504ACPI_EXPORT_SYMBOL (AcpiTerminate)
505
506
507#ifndef ACPI_ASL_COMPILER
508/*******************************************************************************
509 *
510 * FUNCTION:    AcpiSubsystemStatus
511 *
512 * PARAMETERS:  None
513 *
514 * RETURN:      Status of the ACPI subsystem
515 *
516 * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
517 *              before making any other calls, to ensure the subsystem
518 *              initialized successfully.
519 *
520 ******************************************************************************/
521
522ACPI_STATUS
523AcpiSubsystemStatus (
524    void)
525{
526
527    if (AcpiGbl_StartupFlags & ACPI_INITIALIZED_OK)
528    {
529        return (AE_OK);
530    }
531    else
532    {
533        return (AE_ERROR);
534    }
535}
536
537ACPI_EXPORT_SYMBOL (AcpiSubsystemStatus)
538
539
540/*******************************************************************************
541 *
542 * FUNCTION:    AcpiGetSystemInfo
543 *
544 * PARAMETERS:  OutBuffer       - A buffer to receive the resources for the
545 *                                device
546 *
547 * RETURN:      Status          - the status of the call
548 *
549 * DESCRIPTION: This function is called to get information about the current
550 *              state of the ACPI subsystem.  It will return system information
551 *              in the OutBuffer.
552 *
553 *              If the function fails an appropriate status will be returned
554 *              and the value of OutBuffer is undefined.
555 *
556 ******************************************************************************/
557
558ACPI_STATUS
559AcpiGetSystemInfo (
560    ACPI_BUFFER             *OutBuffer)
561{
562    ACPI_SYSTEM_INFO        *InfoPtr;
563    ACPI_STATUS             Status;
564
565
566    ACPI_FUNCTION_TRACE (AcpiGetSystemInfo);
567
568
569    /* Parameter validation */
570
571    Status = AcpiUtValidateBuffer (OutBuffer);
572    if (ACPI_FAILURE (Status))
573    {
574        return_ACPI_STATUS (Status);
575    }
576
577    /* Validate/Allocate/Clear caller buffer */
578
579    Status = AcpiUtInitializeBuffer (OutBuffer, sizeof (ACPI_SYSTEM_INFO));
580    if (ACPI_FAILURE (Status))
581    {
582        return_ACPI_STATUS (Status);
583    }
584
585    /*
586     * Populate the return buffer
587     */
588    InfoPtr = (ACPI_SYSTEM_INFO *) OutBuffer->Pointer;
589
590    InfoPtr->AcpiCaVersion = ACPI_CA_VERSION;
591
592    /* System flags (ACPI capabilities) */
593
594    InfoPtr->Flags = ACPI_SYS_MODE_ACPI;
595
596    /* Timer resolution - 24 or 32 bits  */
597
598    if (AcpiGbl_FADT.Flags & ACPI_FADT_32BIT_TIMER)
599    {
600        InfoPtr->TimerResolution = 24;
601    }
602    else
603    {
604        InfoPtr->TimerResolution = 32;
605    }
606
607    /* Clear the reserved fields */
608
609    InfoPtr->Reserved1 = 0;
610    InfoPtr->Reserved2 = 0;
611
612    /* Current debug levels */
613
614    InfoPtr->DebugLayer = AcpiDbgLayer;
615    InfoPtr->DebugLevel = AcpiDbgLevel;
616
617    return_ACPI_STATUS (AE_OK);
618}
619
620ACPI_EXPORT_SYMBOL (AcpiGetSystemInfo)
621
622
623/*******************************************************************************
624 *
625 * FUNCTION:    AcpiGetStatistics
626 *
627 * PARAMETERS:  Stats           - Where the statistics are returned
628 *
629 * RETURN:      Status          - the status of the call
630 *
631 * DESCRIPTION: Get the contents of the various system counters
632 *
633 ******************************************************************************/
634
635ACPI_STATUS
636AcpiGetStatistics (
637    ACPI_STATISTICS         *Stats)
638{
639    ACPI_FUNCTION_TRACE (AcpiGetStatistics);
640
641
642    /* Parameter validation */
643
644    if (!Stats)
645    {
646        return_ACPI_STATUS (AE_BAD_PARAMETER);
647    }
648
649    /* Various interrupt-based event counters */
650
651    Stats->SciCount = AcpiSciCount;
652    Stats->GpeCount = AcpiGpeCount;
653
654    ACPI_MEMCPY (Stats->FixedEventCount, AcpiFixedEventCount,
655        sizeof (AcpiFixedEventCount));
656
657
658    /* Other counters */
659
660    Stats->MethodCount = AcpiMethodCount;
661
662    return_ACPI_STATUS (AE_OK);
663}
664
665ACPI_EXPORT_SYMBOL (AcpiGetStatistics)
666
667
668/*****************************************************************************
669 *
670 * FUNCTION:    AcpiInstallInitializationHandler
671 *
672 * PARAMETERS:  Handler             - Callback procedure
673 *              Function            - Not (currently) used, see below
674 *
675 * RETURN:      Status
676 *
677 * DESCRIPTION: Install an initialization handler
678 *
679 * TBD: When a second function is added, must save the Function also.
680 *
681 ****************************************************************************/
682
683ACPI_STATUS
684AcpiInstallInitializationHandler (
685    ACPI_INIT_HANDLER       Handler,
686    UINT32                  Function)
687{
688
689    if (!Handler)
690    {
691        return (AE_BAD_PARAMETER);
692    }
693
694    if (AcpiGbl_InitHandler)
695    {
696        return (AE_ALREADY_EXISTS);
697    }
698
699    AcpiGbl_InitHandler = Handler;
700    return AE_OK;
701}
702
703ACPI_EXPORT_SYMBOL (AcpiInstallInitializationHandler)
704
705
706/*****************************************************************************
707 *
708 * FUNCTION:    AcpiPurgeCachedObjects
709 *
710 * PARAMETERS:  None
711 *
712 * RETURN:      Status
713 *
714 * DESCRIPTION: Empty all caches (delete the cached objects)
715 *
716 ****************************************************************************/
717
718ACPI_STATUS
719AcpiPurgeCachedObjects (
720    void)
721{
722    ACPI_FUNCTION_TRACE (AcpiPurgeCachedObjects);
723
724    (void) AcpiOsPurgeCache (AcpiGbl_StateCache);
725    (void) AcpiOsPurgeCache (AcpiGbl_OperandCache);
726    (void) AcpiOsPurgeCache (AcpiGbl_PsNodeCache);
727    (void) AcpiOsPurgeCache (AcpiGbl_PsNodeExtCache);
728    return_ACPI_STATUS (AE_OK);
729}
730
731ACPI_EXPORT_SYMBOL (AcpiPurgeCachedObjects)
732
733#endif /* ACPI_ASL_COMPILER */
734
735