sys/contrib/dev/acpica/osunixxf.c

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