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