1/******************************************************************************
2 *
3 * Module Name: osunixxf - UNIX OSL interfaces
4 *
5 *****************************************************************************/
6
7/******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2008, 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/*
118 * These interfaces are required in order to compile the ASL compiler under
119 * Linux.
120 */
121
122#include <stdio.h>
123#include <stdlib.h>
124#include <stdarg.h>
125#include <unistd.h>
126#include <sys/time.h>
127
128#include "acpi.h"
129#include "amlcode.h"
130#include "acparser.h"
131#include "acdebug.h"
132
133#define _COMPONENT          ACPI_OS_SERVICES
134        ACPI_MODULE_NAME    ("osunixxf")
135
136
137extern FILE                    *AcpiGbl_DebugFile;
138FILE                           *AcpiGbl_OutputFile;
139
140ACPI_PHYSICAL_ADDRESS
141AeLocalGetRootPointer (
142    void);
143
144
145/******************************************************************************
146 *
147 * FUNCTION:    AcpiOsInitialize, AcpiOsTerminate
148 *
149 * PARAMETERS:  None
150 *
151 * RETURN:      Status
152 *
153 * DESCRIPTION: Init and terminate.  Nothing to do.
154 *
155 *****************************************************************************/
156
157ACPI_STATUS
158AcpiOsInitialize (void)
159{
160    AcpiGbl_OutputFile = stdout;
161
162    return AE_OK;
163}
164
165
166ACPI_STATUS
167AcpiOsTerminate (void)
168{
169    return AE_OK;
170}
171
172
173/******************************************************************************
174 *
175 * FUNCTION:    AcpiOsGetRootPointer
176 *
177 * PARAMETERS:  None
178 *
179 * RETURN:      RSDP physical address
180 *
181 * DESCRIPTION: Gets the root pointer (RSDP)
182 *
183 *****************************************************************************/
184
185ACPI_PHYSICAL_ADDRESS
186AcpiOsGetRootPointer (
187    void)
188{
189
190    return (AeLocalGetRootPointer ());
191}
192
193
194/******************************************************************************
195 *
196 * FUNCTION:    AcpiOsPredefinedOverride
197 *
198 * PARAMETERS:  InitVal     - Initial value of the predefined object
199 *              NewVal      - The new value for the object
200 *
201 * RETURN:      Status, pointer to value.  Null pointer returned if not
202 *              overriding.
203 *
204 * DESCRIPTION: Allow the OS to override predefined names
205 *
206 *****************************************************************************/
207
208ACPI_STATUS
209AcpiOsPredefinedOverride (
210    const ACPI_PREDEFINED_NAMES *InitVal,
211    ACPI_STRING                 *NewVal)
212{
213
214    if (!InitVal || !NewVal)
215    {
216        return (AE_BAD_PARAMETER);
217    }
218
219    *NewVal = NULL;
220    return (AE_OK);
221}
222
223
224/******************************************************************************
225 *
226 * FUNCTION:    AcpiOsTableOverride
227 *
228 * PARAMETERS:  ExistingTable   - Header of current table (probably firmware)
229 *              NewTable        - Where an entire new table is returned.
230 *
231 * RETURN:      Status, pointer to new table.  Null pointer returned if no
232 *              table is available to override
233 *
234 * DESCRIPTION: Return a different version of a table if one is available
235 *
236 *****************************************************************************/
237
238ACPI_STATUS
239AcpiOsTableOverride (
240    ACPI_TABLE_HEADER       *ExistingTable,
241    ACPI_TABLE_HEADER       **NewTable)
242{
243
244    if (!ExistingTable || !NewTable)
245    {
246        return (AE_BAD_PARAMETER);
247    }
248
249    *NewTable = NULL;
250
251#ifdef ACPI_EXEC_APP
252
253    /* This code exercises the table override mechanism in the core */
254
255    if (ACPI_COMPARE_NAME (ExistingTable->Signature, ACPI_SIG_DSDT))
256    {
257        /* override DSDT with itself */
258
259        *NewTable = AcpiGbl_DbTablePtr;
260    }
261    return (AE_OK);
262#else
263    return AE_NO_ACPI_TABLES;
264#endif
265}
266
267
268/******************************************************************************
269 *
270 * FUNCTION:    AcpiOsReadable
271 *
272 * PARAMETERS:  Pointer             - Area to be verified
273 *              Length              - Size of area
274 *
275 * RETURN:      TRUE if readable for entire length
276 *
277 * DESCRIPTION: Verify that a pointer is valid for reading
278 *
279 *****************************************************************************/
280
281BOOLEAN
282AcpiOsReadable (
283    void                    *Pointer,
284    ACPI_SIZE               Length)
285{
286
287    return (TRUE);
288}
289
290
291/******************************************************************************
292 *
293 * FUNCTION:    AcpiOsWritable
294 *
295 * PARAMETERS:  Pointer             - Area to be verified
296 *              Length              - Size of area
297 *
298 * RETURN:      TRUE if writable for entire length
299 *
300 * DESCRIPTION: Verify that a pointer is valid for writing
301 *
302 *****************************************************************************/
303
304BOOLEAN
305AcpiOsWritable (
306    void                    *Pointer,
307    ACPI_SIZE               Length)
308{
309
310    return (TRUE);
311}
312
313
314/******************************************************************************
315 *
316 * FUNCTION:    AcpiOsRedirectOutput
317 *
318 * PARAMETERS:  Destination         - An open file handle/pointer
319 *
320 * RETURN:      None
321 *
322 * DESCRIPTION: Causes redirect of AcpiOsPrintf and AcpiOsVprintf
323 *
324 *****************************************************************************/
325
326void
327AcpiOsRedirectOutput (
328    void                    *Destination)
329{
330
331    AcpiGbl_OutputFile = Destination;
332}
333
334
335/******************************************************************************
336 *
337 * FUNCTION:    AcpiOsPrintf
338 *
339 * PARAMETERS:  fmt, ...            Standard printf format
340 *
341 * RETURN:      None
342 *
343 * DESCRIPTION: Formatted output
344 *
345 *****************************************************************************/
346
347void ACPI_INTERNAL_VAR_XFACE
348AcpiOsPrintf (
349    const char              *Fmt,
350    ...)
351{
352    va_list                 Args;
353
354
355    va_start (Args, Fmt);
356
357    AcpiOsVprintf (Fmt, Args);
358
359    va_end (Args);
360    return;
361}
362
363
364/******************************************************************************
365 *
366 * FUNCTION:    AcpiOsVprintf
367 *
368 * PARAMETERS:  fmt                 Standard printf format
369 *              args                Argument list
370 *
371 * RETURN:      None
372 *
373 * DESCRIPTION: Formatted output with argument list pointer
374 *
375 *****************************************************************************/
376
377void
378AcpiOsVprintf (
379    const char              *Fmt,
380    va_list                 Args)
381{
382    INT32                   Count = 0;
383    UINT8                   Flags;
384
385
386    Flags = AcpiGbl_DbOutputFlags;
387    if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT)
388    {
389        /* Output is directable to either a file (if open) or the console */
390
391        if (AcpiGbl_DebugFile)
392        {
393            /* Output file is open, send the output there */
394
395            Count = vfprintf (AcpiGbl_DebugFile, Fmt, Args);
396        }
397        else
398        {
399            /* No redirection, send output to console (once only!) */
400
401            Flags |= ACPI_DB_CONSOLE_OUTPUT;
402        }
403    }
404
405    if (Flags & ACPI_DB_CONSOLE_OUTPUT)
406    {
407        Count = vfprintf (AcpiGbl_OutputFile, Fmt, Args);
408    }
409
410    return;
411}
412
413
414/******************************************************************************
415 *
416 * FUNCTION:    AcpiOsGetLine
417 *
418 * PARAMETERS:  fmt                 Standard printf format
419 *              args                Argument list
420 *
421 * RETURN:      Actual bytes read
422 *
423 * DESCRIPTION: Formatted input with argument list pointer
424 *
425 *****************************************************************************/
426
427UINT32
428AcpiOsGetLine (
429    char                    *Buffer)
430{
431    UINT8                   Temp;
432    UINT32                  i;
433
434
435    for (i = 0; ; i++)
436    {
437        scanf ("%1c", &Temp);
438        if (!Temp || Temp == '\n')
439        {
440            break;
441        }
442
443        Buffer [i] = Temp;
444    }
445
446    /* Null terminate the buffer */
447
448    Buffer [i] = 0;
449
450    /* Return the number of bytes in the string */
451
452    return (i);
453}
454
455/******************************************************************************
456 *
457 * FUNCTION:    AcpiOsMapMemory
458 *
459 * PARAMETERS:  where               Physical address of memory to be mapped
460 *              length              How much memory to map
461 *
462 * RETURN:      Pointer to mapped memory.  Null on error.
463 *
464 * DESCRIPTION: Map physical memory into caller's address space
465 *
466 *****************************************************************************/
467
468void *
469AcpiOsMapMemory (
470    ACPI_PHYSICAL_ADDRESS   where,
471    ACPI_SIZE               length)
472{
473
474    return (ACPI_TO_POINTER ((ACPI_SIZE) where));
475}
476
477
478/******************************************************************************
479 *
480 * FUNCTION:    AcpiOsUnmapMemory
481 *
482 * PARAMETERS:  where               Logical address of memory to be unmapped
483 *              length              How much memory to unmap
484 *
485 * RETURN:      None.
486 *
487 * DESCRIPTION: Delete a previously created mapping.  Where and Length must
488 *              correspond to a previous mapping exactly.
489 *
490 *****************************************************************************/
491
492void
493AcpiOsUnmapMemory (
494    void                    *where,
495    ACPI_SIZE               length)
496{
497
498    return;
499}
500
501
502/******************************************************************************
503 *
504 * FUNCTION:    AcpiOsAllocate
505 *
506 * PARAMETERS:  Size                Amount to allocate, in bytes
507 *
508 * RETURN:      Pointer to the new allocation.  Null on error.
509 *
510 * DESCRIPTION: Allocate memory.  Algorithm is dependent on the OS.
511 *
512 *****************************************************************************/
513
514void *
515AcpiOsAllocate (
516    ACPI_SIZE               size)
517{
518    void                    *Mem;
519
520
521    Mem = (void *) malloc ((size_t) size);
522
523    return Mem;
524}
525
526
527/******************************************************************************
528 *
529 * FUNCTION:    AcpiOsFree
530 *
531 * PARAMETERS:  mem                 Pointer to previously allocated memory
532 *
533 * RETURN:      None.
534 *
535 * DESCRIPTION: Free memory allocated via AcpiOsAllocate
536 *
537 *****************************************************************************/
538
539void
540AcpiOsFree (
541    void                    *mem)
542{
543
544
545    free (mem);
546}
547
548
549/******************************************************************************
550 *
551 * FUNCTION:    AcpiOsCreateSemaphore
552 *
553 * PARAMETERS:  InitialUnits        - Units to be assigned to the new semaphore
554 *              OutHandle           - Where a handle will be returned
555 *
556 * RETURN:      Status
557 *
558 * DESCRIPTION: Create an OS semaphore
559 *
560 *****************************************************************************/
561
562ACPI_STATUS
563AcpiOsCreateSemaphore (
564    UINT32              MaxUnits,
565    UINT32              InitialUnits,
566    ACPI_HANDLE         *OutHandle)
567{
568
569
570    *OutHandle = (ACPI_HANDLE) 1;
571    return AE_OK;
572}
573
574/******************************************************************************
575 *
576 * FUNCTION:    AcpiOsDeleteSemaphore
577 *
578 * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
579 *
580 * RETURN:      Status
581 *
582 * DESCRIPTION: Delete an OS semaphore
583 *
584 *****************************************************************************/
585
586ACPI_STATUS
587AcpiOsDeleteSemaphore (
588    ACPI_HANDLE         Handle)
589{
590
591    if (!Handle)
592    {
593        return AE_BAD_PARAMETER;
594    }
595
596    return AE_OK;
597}
598
599
600/******************************************************************************
601 *
602 * FUNCTION:    AcpiOsWaitSemaphore
603 *
604 * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
605 *              Units               - How many units to wait for
606 *              Timeout             - How long to wait
607 *
608 * RETURN:      Status
609 *
610 * DESCRIPTION: Wait for units
611 *
612 *****************************************************************************/
613
614ACPI_STATUS
615AcpiOsWaitSemaphore (
616    ACPI_HANDLE         Handle,
617    UINT32              Units,
618    UINT16              Timeout)
619{
620
621
622    return AE_OK;
623}
624
625
626/******************************************************************************
627 *
628 * FUNCTION:    AcpiOsSignalSemaphore
629 *
630 * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
631 *              Units               - Number of units to send
632 *
633 * RETURN:      Status
634 *
635 * DESCRIPTION: Send units
636 *
637 *****************************************************************************/
638
639ACPI_STATUS
640AcpiOsSignalSemaphore (
641    ACPI_HANDLE         Handle,
642    UINT32              Units)
643{
644
645
646    return AE_OK;
647}
648
649
650ACPI_STATUS
651AcpiOsCreateLock (
652    ACPI_SPINLOCK           *OutHandle)
653{
654
655    return (AcpiOsCreateSemaphore (1, 1, OutHandle));
656}
657
658void
659AcpiOsDeleteLock (
660    ACPI_SPINLOCK           Handle)
661{
662    AcpiOsDeleteSemaphore (Handle);
663}
664
665
666ACPI_CPU_FLAGS
667AcpiOsAcquireLock (
668    ACPI_HANDLE             Handle)
669{
670    AcpiOsWaitSemaphore (Handle, 1, 0xFFFF);
671    return (0);
672}
673
674
675void
676AcpiOsReleaseLock (
677    ACPI_SPINLOCK           Handle,
678    ACPI_CPU_FLAGS          Flags)
679{
680    AcpiOsSignalSemaphore (Handle, 1);
681}
682
683
684/******************************************************************************
685 *
686 * FUNCTION:    AcpiOsInstallInterruptHandler
687 *
688 * PARAMETERS:  InterruptNumber     Level handler should respond to.
689 *              Isr                 Address of the ACPI interrupt handler
690 *              ExceptPtr           Where status is returned
691 *
692 * RETURN:      Handle to the newly installed handler.
693 *
694 * DESCRIPTION: Install an interrupt handler.  Used to install the ACPI
695 *              OS-independent handler.
696 *
697 *****************************************************************************/
698
699UINT32
700AcpiOsInstallInterruptHandler (
701    UINT32                  InterruptNumber,
702    ACPI_OSD_HANDLER        ServiceRoutine,
703    void                    *Context)
704{
705
706
707    return AE_OK;
708}
709
710
711/******************************************************************************
712 *
713 * FUNCTION:    AcpiOsRemoveInterruptHandler
714 *
715 * PARAMETERS:  Handle              Returned when handler was installed
716 *
717 * RETURN:      Status
718 *
719 * DESCRIPTION: Uninstalls an interrupt handler.
720 *
721 *****************************************************************************/
722
723ACPI_STATUS
724AcpiOsRemoveInterruptHandler (
725    UINT32                  InterruptNumber,
726    ACPI_OSD_HANDLER        ServiceRoutine)
727{
728
729    return AE_OK;
730}
731
732
733/******************************************************************************
734 *
735 * FUNCTION:    AcpiOsExecute
736 *
737 * PARAMETERS:  Type            - Type of execution
738 *              Function        - Address of the function to execute
739 *              Context         - Passed as a parameter to the function
740 *
741 * RETURN:      Status.
742 *
743 * DESCRIPTION: Execute a new thread
744 *
745 *****************************************************************************/
746
747ACPI_STATUS
748AcpiOsExecute (
749    ACPI_EXECUTE_TYPE       Type,
750    ACPI_OSD_EXEC_CALLBACK  Function,
751    void                    *Context)
752{
753
754//    _beginthread (Function, (unsigned) 0, Context);
755    return 0;
756}
757
758
759/******************************************************************************
760 *
761 * FUNCTION:    AcpiOsBreakpoint
762 *
763 * PARAMETERS:  Msg                 Message to print
764 *
765 * RETURN:      Status
766 *
767 * DESCRIPTION: Print a message and break to the debugger.
768 *
769 *****************************************************************************/
770
771ACPI_STATUS
772AcpiOsBreakpoint (
773    char                    *Msg)
774{
775
776    if (Msg)
777    {
778        AcpiOsPrintf ("AcpiOsBreakpoint: %s ****\n", Msg);
779    }
780    else
781    {
782        AcpiOsPrintf ("At AcpiOsBreakpoint ****\n");
783    }
784
785    return AE_OK;
786}
787
788
789/******************************************************************************
790 *
791 * FUNCTION:    AcpiOsStall
792 *
793 * PARAMETERS:  microseconds        To sleep
794 *
795 * RETURN:      Blocks until sleep is completed.
796 *
797 * DESCRIPTION: Sleep at microsecond granularity
798 *
799 *****************************************************************************/
800
801void
802AcpiOsStall (
803    UINT32                  microseconds)
804{
805
806    if (microseconds)
807    {
808        usleep (microseconds);
809    }
810    return;
811}
812
813
814/******************************************************************************
815 *
816 * FUNCTION:    AcpiOsSleep
817 *
818 * PARAMETERS:  milliseconds        To sleep
819 *
820 * RETURN:      Blocks until sleep is completed.
821 *
822 * DESCRIPTION: Sleep at millisecond granularity
823 *
824 *****************************************************************************/
825
826void
827AcpiOsSleep (
828    ACPI_INTEGER            milliseconds)
829{
830
831    sleep (milliseconds / 1000);    /* Sleep for whole seconds */
832
833    /*
834     * Arg to usleep() must be less than 1,000,000 (1 second)
835     */
836    usleep ((milliseconds % 1000) * 1000);      /* Sleep for remaining usecs */
837
838    return;
839}
840
841/******************************************************************************
842 *
843 * FUNCTION:    AcpiOsGetTimer
844 *
845 * PARAMETERS:  None
846 *
847 * RETURN:      Current time in 100 nanosecond units
848 *
849 * DESCRIPTION: Get the current system time
850 *
851 *****************************************************************************/
852
853UINT64
854AcpiOsGetTimer (void)
855{
856    struct timeval  time;
857
858    gettimeofday(&time, NULL);
859
860    /* Seconds * 10^7 = 100ns(10^-7), Microseconds(10^-6) * 10^1 = 100ns */
861
862    return (((UINT64) time.tv_sec * 10000000) + ((UINT64) time.tv_usec * 10));
863}
864
865
866/******************************************************************************
867 *
868 * FUNCTION:    AcpiOsValidateInterface
869 *
870 * PARAMETERS:  Interface           - Requested interface to be validated
871 *
872 * RETURN:      AE_OK if interface is supported, AE_SUPPORT otherwise
873 *
874 * DESCRIPTION: Match an interface string to the interfaces supported by the
875 *              host. Strings originate from an AML call to the _OSI method.
876 *
877 *****************************************************************************/
878
879ACPI_STATUS
880AcpiOsValidateInterface (
881    char                    *Interface)
882{
883
884    return (AE_SUPPORT);
885}
886
887
888/******************************************************************************
889 *
890 * FUNCTION:    AcpiOsValidateAddress
891 *
892 * PARAMETERS:  SpaceId             - ACPI space ID
893 *              Address             - Physical address
894 *              Length              - Address length
895 *
896 * RETURN:      AE_OK if Address/Length is valid for the SpaceId. Otherwise,
897 *              should return AE_AML_ILLEGAL_ADDRESS.
898 *
899 * DESCRIPTION: Validate a system address via the host OS. Used to validate
900 *              the addresses accessed by AML operation regions.
901 *
902 *****************************************************************************/
903
904ACPI_STATUS
905AcpiOsValidateAddress (
906    UINT8                   SpaceId,
907    ACPI_PHYSICAL_ADDRESS   Address,
908    ACPI_SIZE               Length)
909{
910
911    return (AE_OK);
912}
913
914
915/******************************************************************************
916 *
917 * FUNCTION:    AcpiOsReadPciConfiguration
918 *
919 * PARAMETERS:  PciId               Seg/Bus/Dev
920 *              Register            Device Register
921 *              Value               Buffer where value is placed
922 *              Width               Number of bits
923 *
924 * RETURN:      Status
925 *
926 * DESCRIPTION: Read data from PCI configuration space
927 *
928 *****************************************************************************/
929
930ACPI_STATUS
931AcpiOsReadPciConfiguration (
932    ACPI_PCI_ID             *PciId,
933    UINT32                  Register,
934    void                    *Value,
935    UINT32                  Width)
936{
937
938    return (AE_OK);
939}
940
941
942/******************************************************************************
943 *
944 * FUNCTION:    AcpiOsWritePciConfiguration
945 *
946 * PARAMETERS:  PciId               Seg/Bus/Dev
947 *              Register            Device Register
948 *              Value               Value to be written
949 *              Width               Number of bits
950 *
951 * RETURN:      Status.
952 *
953 * DESCRIPTION: Write data to PCI configuration space
954 *
955 *****************************************************************************/
956
957ACPI_STATUS
958AcpiOsWritePciConfiguration (
959    ACPI_PCI_ID             *PciId,
960    UINT32                  Register,
961    ACPI_INTEGER            Value,
962    UINT32                  Width)
963{
964
965    return (AE_OK);
966}
967
968/* TEMPORARY STUB FUNCTION */
969void
970AcpiOsDerivePciId(
971    ACPI_HANDLE             rhandle,
972    ACPI_HANDLE             chandle,
973    ACPI_PCI_ID             **PciId)
974{
975
976}
977
978
979/******************************************************************************
980 *
981 * FUNCTION:    AcpiOsReadPort
982 *
983 * PARAMETERS:  Address             Address of I/O port/register to read
984 *              Value               Where value is placed
985 *              Width               Number of bits
986 *
987 * RETURN:      Value read from port
988 *
989 * DESCRIPTION: Read data from an I/O port or register
990 *
991 *****************************************************************************/
992
993ACPI_STATUS
994AcpiOsReadPort (
995    ACPI_IO_ADDRESS         Address,
996    UINT32                  *Value,
997    UINT32                  Width)
998{
999
1000    switch (Width)
1001    {
1002    case 8:
1003        *Value = 0xFF;
1004        break;
1005
1006    case 16:
1007        *Value = 0xFFFF;
1008        break;
1009
1010    case 32:
1011        *Value = 0xFFFFFFFF;
1012        break;
1013    }
1014
1015    return (AE_OK);
1016}
1017
1018
1019/******************************************************************************
1020 *
1021 * FUNCTION:    AcpiOsWritePort
1022 *
1023 * PARAMETERS:  Address             Address of I/O port/register to write
1024 *              Value               Value to write
1025 *              Width               Number of bits
1026 *
1027 * RETURN:      None
1028 *
1029 * DESCRIPTION: Write data to an I/O port or register
1030 *
1031 *****************************************************************************/
1032
1033ACPI_STATUS
1034AcpiOsWritePort (
1035    ACPI_IO_ADDRESS         Address,
1036    UINT32                  Value,
1037    UINT32                  Width)
1038{
1039
1040    return (AE_OK);
1041}
1042
1043
1044/******************************************************************************
1045 *
1046 * FUNCTION:    AcpiOsReadMemory
1047 *
1048 * PARAMETERS:  Address             Physical Memory Address to read
1049 *              Value               Where value is placed
1050 *              Width               Number of bits
1051 *
1052 * RETURN:      Value read from physical memory address
1053 *
1054 * DESCRIPTION: Read data from a physical memory address
1055 *
1056 *****************************************************************************/
1057
1058ACPI_STATUS
1059AcpiOsReadMemory (
1060    ACPI_PHYSICAL_ADDRESS   Address,
1061    UINT32                  *Value,
1062    UINT32                  Width)
1063{
1064
1065    switch (Width)
1066    {
1067    case 8:
1068    case 16:
1069    case 32:
1070        *Value = 0;
1071        break;
1072
1073    default:
1074        return (AE_BAD_PARAMETER);
1075        break;
1076    }
1077    return (AE_OK);
1078}
1079
1080
1081/******************************************************************************
1082 *
1083 * FUNCTION:    AcpiOsWriteMemory
1084 *
1085 * PARAMETERS:  Address             Physical Memory Address to write
1086 *              Value               Value to write
1087 *              Width               Number of bits
1088 *
1089 * RETURN:      None
1090 *
1091 * DESCRIPTION: Write data to a physical memory address
1092 *
1093 *****************************************************************************/
1094
1095ACPI_STATUS
1096AcpiOsWriteMemory (
1097    ACPI_PHYSICAL_ADDRESS   Address,
1098    UINT32                  Value,
1099    UINT32                  Width)
1100{
1101
1102    return (AE_OK);
1103}
1104
1105
1106ACPI_THREAD_ID
1107AcpiOsGetThreadId(void)
1108{
1109    return getpid();
1110}
1111
1112
1113/******************************************************************************
1114 *
1115 * FUNCTION:    AcpiOsSignal
1116 *
1117 * PARAMETERS:  Function            ACPI CA signal function code
1118 *              Info                Pointer to function-dependent structure
1119 *
1120 * RETURN:      Status
1121 *
1122 * DESCRIPTION: Miscellaneous functions
1123 *
1124 *****************************************************************************/
1125
1126ACPI_STATUS
1127AcpiOsSignal (
1128    UINT32                  Function,
1129    void                    *Info)
1130{
1131
1132    switch (Function)
1133    {
1134    case ACPI_SIGNAL_FATAL:
1135        break;
1136
1137    case ACPI_SIGNAL_BREAKPOINT:
1138
1139        if (Info)
1140        {
1141            AcpiOsPrintf ("AcpiOsBreakpoint: %s ****\n", Info);
1142        }
1143        else
1144        {
1145            AcpiOsPrintf ("At AcpiOsBreakpoint ****\n");
1146        }
1147
1148        break;
1149    }
1150
1151
1152    return (AE_OK);
1153}
1154
1155
1156