acpixf.h revision 229989 
1
2/******************************************************************************
3 *
4 * Name: acpixf.h - External interfaces to the ACPI subsystem
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2012, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 *    notice, this list of conditions, and the following disclaimer,
17 *    without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 *    substantially similar to the "NO WARRANTY" disclaimer below
20 *    ("Disclaimer") and any redistribution must be conditioned upon
21 *    including a substantially similar Disclaimer requirement for further
22 *    binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 *    of any contributors may be used to endorse or promote products derived
25 *    from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45
46#ifndef __ACXFACE_H__
47#define __ACXFACE_H__
48
49/* Current ACPICA subsystem version in YYYYMMDD format */
50
51#define ACPI_CA_VERSION                 0x20120111
52
53#include <contrib/dev/acpica/include/actypes.h>
54#include <contrib/dev/acpica/include/actbl.h>
55
56/*
57 * Globals that are publically available
58 */
59extern UINT32               AcpiCurrentGpeCount;
60extern ACPI_TABLE_FADT      AcpiGbl_FADT;
61extern BOOLEAN              AcpiGbl_SystemAwakeAndRunning;
62extern BOOLEAN              AcpiGbl_ReducedHardware;        /* ACPI 5.0 */
63
64/* Runtime configuration of debug print levels */
65
66extern UINT32               AcpiDbgLevel;
67extern UINT32               AcpiDbgLayer;
68
69/* ACPICA runtime options */
70
71extern UINT8                AcpiGbl_EnableInterpreterSlack;
72extern UINT8                AcpiGbl_AllMethodsSerialized;
73extern UINT8                AcpiGbl_CreateOsiMethod;
74extern UINT8                AcpiGbl_UseDefaultRegisterWidths;
75extern ACPI_NAME            AcpiGbl_TraceMethodName;
76extern UINT32               AcpiGbl_TraceFlags;
77extern UINT8                AcpiGbl_EnableAmlDebugObject;
78extern UINT8                AcpiGbl_CopyDsdtLocally;
79extern UINT8                AcpiGbl_TruncateIoAddresses;
80extern UINT8                AcpiGbl_DisableAutoRepair;
81
82
83/*
84 * Initialization
85 */
86ACPI_STATUS
87AcpiInitializeTables (
88    ACPI_TABLE_DESC         *InitialStorage,
89    UINT32                  InitialTableCount,
90    BOOLEAN                 AllowResize);
91
92ACPI_STATUS
93AcpiInitializeSubsystem (
94    void);
95
96ACPI_STATUS
97AcpiEnableSubsystem (
98    UINT32                  Flags);
99
100ACPI_STATUS
101AcpiInitializeObjects (
102    UINT32                  Flags);
103
104ACPI_STATUS
105AcpiTerminate (
106    void);
107
108
109/*
110 * Miscellaneous global interfaces
111 */
112ACPI_STATUS
113AcpiEnable (
114    void);
115
116ACPI_STATUS
117AcpiDisable (
118    void);
119
120ACPI_STATUS
121AcpiSubsystemStatus (
122    void);
123
124ACPI_STATUS
125AcpiGetSystemInfo (
126    ACPI_BUFFER             *RetBuffer);
127
128ACPI_STATUS
129AcpiGetStatistics (
130    ACPI_STATISTICS         *Stats);
131
132const char *
133AcpiFormatException (
134    ACPI_STATUS             Exception);
135
136ACPI_STATUS
137AcpiPurgeCachedObjects (
138    void);
139
140ACPI_STATUS
141AcpiInstallInterface (
142    ACPI_STRING             InterfaceName);
143
144ACPI_STATUS
145AcpiRemoveInterface (
146    ACPI_STRING             InterfaceName);
147
148UINT32
149AcpiCheckAddressRange (
150    ACPI_ADR_SPACE_TYPE     SpaceId,
151    ACPI_PHYSICAL_ADDRESS   Address,
152    ACPI_SIZE               Length,
153    BOOLEAN                 Warn);
154
155
156/*
157 * ACPI Memory management
158 */
159void *
160AcpiAllocate (
161    UINT32                  Size);
162
163void *
164AcpiCallocate (
165    UINT32                  Size);
166
167void
168AcpiFree (
169    void                    *Address);
170
171
172/*
173 * ACPI table manipulation interfaces
174 */
175ACPI_STATUS
176AcpiReallocateRootTable (
177    void);
178
179ACPI_STATUS
180AcpiFindRootPointer (
181    ACPI_SIZE               *RsdpAddress);
182
183ACPI_STATUS
184AcpiLoadTables (
185    void);
186
187ACPI_STATUS
188AcpiGetTableHeader (
189    ACPI_STRING             Signature,
190    UINT32                  Instance,
191    ACPI_TABLE_HEADER       *OutTableHeader);
192
193ACPI_STATUS
194AcpiGetTable (
195    ACPI_STRING             Signature,
196    UINT32                  Instance,
197    ACPI_TABLE_HEADER       **OutTable);
198
199ACPI_STATUS
200AcpiGetTableByIndex (
201    UINT32                  TableIndex,
202    ACPI_TABLE_HEADER       **OutTable);
203
204ACPI_STATUS
205AcpiInstallTableHandler (
206    ACPI_TABLE_HANDLER      Handler,
207    void                    *Context);
208
209ACPI_STATUS
210AcpiRemoveTableHandler (
211    ACPI_TABLE_HANDLER      Handler);
212
213
214/*
215 * Namespace and name interfaces
216 */
217ACPI_STATUS
218AcpiWalkNamespace (
219    ACPI_OBJECT_TYPE        Type,
220    ACPI_HANDLE             StartObject,
221    UINT32                  MaxDepth,
222    ACPI_WALK_CALLBACK      PreOrderVisit,
223    ACPI_WALK_CALLBACK      PostOrderVisit,
224    void                    *Context,
225    void                    **ReturnValue);
226
227ACPI_STATUS
228AcpiGetDevices (
229    char                    *HID,
230    ACPI_WALK_CALLBACK      UserFunction,
231    void                    *Context,
232    void                    **ReturnValue);
233
234ACPI_STATUS
235AcpiGetName (
236    ACPI_HANDLE             Object,
237    UINT32                  NameType,
238    ACPI_BUFFER             *RetPathPtr);
239
240ACPI_STATUS
241AcpiGetHandle (
242    ACPI_HANDLE             Parent,
243    ACPI_STRING             Pathname,
244    ACPI_HANDLE             *RetHandle);
245
246ACPI_STATUS
247AcpiAttachData (
248    ACPI_HANDLE             Object,
249    ACPI_OBJECT_HANDLER     Handler,
250    void                    *Data);
251
252ACPI_STATUS
253AcpiDetachData (
254    ACPI_HANDLE             Object,
255    ACPI_OBJECT_HANDLER     Handler);
256
257ACPI_STATUS
258AcpiGetData (
259    ACPI_HANDLE             Object,
260    ACPI_OBJECT_HANDLER     Handler,
261    void                    **Data);
262
263ACPI_STATUS
264AcpiDebugTrace (
265    char                    *Name,
266    UINT32                  DebugLevel,
267    UINT32                  DebugLayer,
268    UINT32                  Flags);
269
270
271/*
272 * Object manipulation and enumeration
273 */
274ACPI_STATUS
275AcpiEvaluateObject (
276    ACPI_HANDLE             Object,
277    ACPI_STRING             Pathname,
278    ACPI_OBJECT_LIST        *ParameterObjects,
279    ACPI_BUFFER             *ReturnObjectBuffer);
280
281ACPI_STATUS
282AcpiEvaluateObjectTyped (
283    ACPI_HANDLE             Object,
284    ACPI_STRING             Pathname,
285    ACPI_OBJECT_LIST        *ExternalParams,
286    ACPI_BUFFER             *ReturnBuffer,
287    ACPI_OBJECT_TYPE        ReturnType);
288
289ACPI_STATUS
290AcpiGetObjectInfo (
291    ACPI_HANDLE             Object,
292    ACPI_DEVICE_INFO        **ReturnBuffer);
293
294ACPI_STATUS
295AcpiInstallMethod (
296    UINT8                   *Buffer);
297
298ACPI_STATUS
299AcpiGetNextObject (
300    ACPI_OBJECT_TYPE        Type,
301    ACPI_HANDLE             Parent,
302    ACPI_HANDLE             Child,
303    ACPI_HANDLE             *OutHandle);
304
305ACPI_STATUS
306AcpiGetType (
307    ACPI_HANDLE             Object,
308    ACPI_OBJECT_TYPE        *OutType);
309
310ACPI_STATUS
311AcpiGetParent (
312    ACPI_HANDLE             Object,
313    ACPI_HANDLE             *OutHandle);
314
315
316/*
317 * Handler interfaces
318 */
319ACPI_STATUS
320AcpiInstallInitializationHandler (
321    ACPI_INIT_HANDLER       Handler,
322    UINT32                  Function);
323
324ACPI_STATUS
325AcpiInstallGlobalEventHandler (
326    ACPI_GBL_EVENT_HANDLER  Handler,
327    void                    *Context);
328
329ACPI_STATUS
330AcpiInstallFixedEventHandler (
331    UINT32                  AcpiEvent,
332    ACPI_EVENT_HANDLER      Handler,
333    void                    *Context);
334
335ACPI_STATUS
336AcpiRemoveFixedEventHandler (
337    UINT32                  AcpiEvent,
338    ACPI_EVENT_HANDLER      Handler);
339
340ACPI_STATUS
341AcpiInstallGpeHandler (
342    ACPI_HANDLE             GpeDevice,
343    UINT32                  GpeNumber,
344    UINT32                  Type,
345    ACPI_GPE_HANDLER        Address,
346    void                    *Context);
347
348ACPI_STATUS
349AcpiRemoveGpeHandler (
350    ACPI_HANDLE             GpeDevice,
351    UINT32                  GpeNumber,
352    ACPI_GPE_HANDLER        Address);
353
354ACPI_STATUS
355AcpiInstallNotifyHandler (
356    ACPI_HANDLE             Device,
357    UINT32                  HandlerType,
358    ACPI_NOTIFY_HANDLER     Handler,
359    void                    *Context);
360
361ACPI_STATUS
362AcpiRemoveNotifyHandler (
363    ACPI_HANDLE             Device,
364    UINT32                  HandlerType,
365    ACPI_NOTIFY_HANDLER     Handler);
366
367ACPI_STATUS
368AcpiInstallAddressSpaceHandler (
369    ACPI_HANDLE             Device,
370    ACPI_ADR_SPACE_TYPE     SpaceId,
371    ACPI_ADR_SPACE_HANDLER  Handler,
372    ACPI_ADR_SPACE_SETUP    Setup,
373    void                    *Context);
374
375ACPI_STATUS
376AcpiRemoveAddressSpaceHandler (
377    ACPI_HANDLE             Device,
378    ACPI_ADR_SPACE_TYPE     SpaceId,
379    ACPI_ADR_SPACE_HANDLER  Handler);
380
381ACPI_STATUS
382AcpiInstallExceptionHandler (
383    ACPI_EXCEPTION_HANDLER  Handler);
384
385ACPI_STATUS
386AcpiInstallInterfaceHandler (
387    ACPI_INTERFACE_HANDLER  Handler);
388
389
390/*
391 * Global Lock interfaces
392 */
393ACPI_STATUS
394AcpiAcquireGlobalLock (
395    UINT16                  Timeout,
396    UINT32                  *Handle);
397
398ACPI_STATUS
399AcpiReleaseGlobalLock (
400    UINT32                  Handle);
401
402
403/*
404 * Interfaces to AML mutex objects
405 */
406ACPI_STATUS
407AcpiAcquireMutex (
408    ACPI_HANDLE             Handle,
409    ACPI_STRING             Pathname,
410    UINT16                  Timeout);
411
412ACPI_STATUS
413AcpiReleaseMutex (
414    ACPI_HANDLE             Handle,
415    ACPI_STRING             Pathname);
416
417
418/*
419 * Fixed Event interfaces
420 */
421ACPI_STATUS
422AcpiEnableEvent (
423    UINT32                  Event,
424    UINT32                  Flags);
425
426ACPI_STATUS
427AcpiDisableEvent (
428    UINT32                  Event,
429    UINT32                  Flags);
430
431ACPI_STATUS
432AcpiClearEvent (
433    UINT32                  Event);
434
435ACPI_STATUS
436AcpiGetEventStatus (
437    UINT32                  Event,
438    ACPI_EVENT_STATUS       *EventStatus);
439
440
441/*
442 * General Purpose Event (GPE) Interfaces
443 */
444ACPI_STATUS
445AcpiUpdateAllGpes (
446    void);
447
448ACPI_STATUS
449AcpiEnableGpe (
450    ACPI_HANDLE             GpeDevice,
451    UINT32                  GpeNumber);
452
453ACPI_STATUS
454AcpiDisableGpe (
455    ACPI_HANDLE             GpeDevice,
456    UINT32                  GpeNumber);
457
458ACPI_STATUS
459AcpiClearGpe (
460    ACPI_HANDLE             GpeDevice,
461    UINT32                  GpeNumber);
462
463ACPI_STATUS
464AcpiSetGpe (
465    ACPI_HANDLE             GpeDevice,
466    UINT32                  GpeNumber,
467    UINT8                   Action);
468
469ACPI_STATUS
470AcpiFinishGpe (
471    ACPI_HANDLE             GpeDevice,
472    UINT32                  GpeNumber);
473
474ACPI_STATUS
475AcpiSetupGpeForWake (
476    ACPI_HANDLE             ParentDevice,
477    ACPI_HANDLE             GpeDevice,
478    UINT32                  GpeNumber);
479
480ACPI_STATUS
481AcpiSetGpeWakeMask (
482    ACPI_HANDLE             GpeDevice,
483    UINT32                  GpeNumber,
484    UINT8                   Action);
485
486ACPI_STATUS
487AcpiGetGpeStatus (
488    ACPI_HANDLE             GpeDevice,
489    UINT32                  GpeNumber,
490    ACPI_EVENT_STATUS       *EventStatus);
491
492ACPI_STATUS
493AcpiDisableAllGpes (
494    void);
495
496ACPI_STATUS
497AcpiEnableAllRuntimeGpes (
498    void);
499
500ACPI_STATUS
501AcpiGetGpeDevice (
502    UINT32                  GpeIndex,
503    ACPI_HANDLE             *GpeDevice);
504
505ACPI_STATUS
506AcpiInstallGpeBlock (
507    ACPI_HANDLE             GpeDevice,
508    ACPI_GENERIC_ADDRESS    *GpeBlockAddress,
509    UINT32                  RegisterCount,
510    UINT32                  InterruptNumber);
511
512ACPI_STATUS
513AcpiRemoveGpeBlock (
514    ACPI_HANDLE             GpeDevice);
515
516
517/*
518 * Resource interfaces
519 */
520typedef
521ACPI_STATUS (*ACPI_WALK_RESOURCE_CALLBACK) (
522    ACPI_RESOURCE           *Resource,
523    void                    *Context);
524
525ACPI_STATUS
526AcpiGetVendorResource (
527    ACPI_HANDLE             Device,
528    char                    *Name,
529    ACPI_VENDOR_UUID        *Uuid,
530    ACPI_BUFFER             *RetBuffer);
531
532ACPI_STATUS
533AcpiGetCurrentResources (
534    ACPI_HANDLE             Device,
535    ACPI_BUFFER             *RetBuffer);
536
537ACPI_STATUS
538AcpiGetPossibleResources (
539    ACPI_HANDLE             Device,
540    ACPI_BUFFER             *RetBuffer);
541
542ACPI_STATUS
543AcpiGetEventResources (
544    ACPI_HANDLE             DeviceHandle,
545    ACPI_BUFFER             *RetBuffer);
546
547ACPI_STATUS
548AcpiWalkResources (
549    ACPI_HANDLE                 Device,
550    char                        *Name,
551    ACPI_WALK_RESOURCE_CALLBACK UserFunction,
552    void                        *Context);
553
554ACPI_STATUS
555AcpiSetCurrentResources (
556    ACPI_HANDLE             Device,
557    ACPI_BUFFER             *InBuffer);
558
559ACPI_STATUS
560AcpiGetIrqRoutingTable (
561    ACPI_HANDLE             Device,
562    ACPI_BUFFER             *RetBuffer);
563
564ACPI_STATUS
565AcpiResourceToAddress64 (
566    ACPI_RESOURCE           *Resource,
567    ACPI_RESOURCE_ADDRESS64 *Out);
568
569ACPI_STATUS
570AcpiBufferToResource (
571    UINT8                   *AmlBuffer,
572    UINT16                  AmlBufferLength,
573    ACPI_RESOURCE           **ResourcePtr);
574
575
576/*
577 * Hardware (ACPI device) interfaces
578 */
579ACPI_STATUS
580AcpiReset (
581    void);
582
583ACPI_STATUS
584AcpiRead (
585    UINT64                  *Value,
586    ACPI_GENERIC_ADDRESS    *Reg);
587
588ACPI_STATUS
589AcpiWrite (
590    UINT64                  Value,
591    ACPI_GENERIC_ADDRESS    *Reg);
592
593ACPI_STATUS
594AcpiReadBitRegister (
595    UINT32                  RegisterId,
596    UINT32                  *ReturnValue);
597
598ACPI_STATUS
599AcpiWriteBitRegister (
600    UINT32                  RegisterId,
601    UINT32                  Value);
602
603ACPI_STATUS
604AcpiGetSleepTypeData (
605    UINT8                   SleepState,
606    UINT8                   *Slp_TypA,
607    UINT8                   *Slp_TypB);
608
609ACPI_STATUS
610AcpiEnterSleepStatePrep (
611    UINT8                   SleepState);
612
613ACPI_STATUS
614AcpiEnterSleepState (
615    UINT8                   SleepState);
616
617ACPI_STATUS
618AcpiEnterSleepStateS4bios (
619    void);
620
621ACPI_STATUS
622AcpiLeaveSleepState (
623    UINT8                   SleepState)
624    ;
625ACPI_STATUS
626AcpiSetFirmwareWakingVector (
627    UINT32                  PhysicalAddress);
628
629#if ACPI_MACHINE_WIDTH == 64
630ACPI_STATUS
631AcpiSetFirmwareWakingVector64 (
632    UINT64                  PhysicalAddress);
633#endif
634
635
636/*
637 * Error/Warning output
638 */
639void ACPI_INTERNAL_VAR_XFACE
640AcpiError (
641    const char              *ModuleName,
642    UINT32                  LineNumber,
643    const char              *Format,
644    ...) ACPI_PRINTF_LIKE(3);
645
646void  ACPI_INTERNAL_VAR_XFACE
647AcpiException (
648    const char              *ModuleName,
649    UINT32                  LineNumber,
650    ACPI_STATUS             Status,
651    const char              *Format,
652    ...) ACPI_PRINTF_LIKE(4);
653
654void ACPI_INTERNAL_VAR_XFACE
655AcpiWarning (
656    const char              *ModuleName,
657    UINT32                  LineNumber,
658    const char              *Format,
659    ...) ACPI_PRINTF_LIKE(3);
660
661void ACPI_INTERNAL_VAR_XFACE
662AcpiInfo (
663    const char              *ModuleName,
664    UINT32                  LineNumber,
665    const char              *Format,
666    ...) ACPI_PRINTF_LIKE(3);
667
668
669/*
670 * Debug output
671 */
672#ifdef ACPI_DEBUG_OUTPUT
673
674void ACPI_INTERNAL_VAR_XFACE
675AcpiDebugPrint (
676    UINT32                  RequestedDebugLevel,
677    UINT32                  LineNumber,
678    const char              *FunctionName,
679    const char              *ModuleName,
680    UINT32                  ComponentId,
681    const char              *Format,
682    ...) ACPI_PRINTF_LIKE(6);
683
684void ACPI_INTERNAL_VAR_XFACE
685AcpiDebugPrintRaw (
686    UINT32                  RequestedDebugLevel,
687    UINT32                  LineNumber,
688    const char              *FunctionName,
689    const char              *ModuleName,
690    UINT32                  ComponentId,
691    const char              *Format,
692    ...) ACPI_PRINTF_LIKE(6);
693#endif
694
695#endif /* __ACXFACE_H__ */
696