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