sys/external/intel-public/acpica/dist/os_specific/service_layers/osunixxf.c

   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 - 2009, 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 "acpi.h"
 131 #include "accommon.h"
 132 #include "amlcode.h"
 133 #include "acparser.h"
 134 #include "acdebug.h"
 135
 136 #define _COMPONENT          ACPI_OS_SERVICES
 137         ACPI_MODULE_NAME    ("osunixxf")
 138
 139
 140 extern FILE                    *AcpiGbl_DebugFile;
 141 FILE                           *AcpiGbl_OutputFile;
 142
 143
 144 /* Upcalls to AcpiExec */
 145
 146 ACPI_PHYSICAL_ADDRESS
 147 AeLocalGetRootPointer (
 148     void);
 149
 150 void
 151 AeTableOverride (
 152     ACPI_TABLE_HEADER       *ExistingTable,
 153     ACPI_TABLE_HEADER       **NewTable);
 154
 155 typedef 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
 170 ACPI_STATUS
 171 AcpiOsInitialize (void)
 172 {
 173
 174     AcpiGbl_OutputFile = stdout;
 175     return (AE_OK);
 176 }
 177
 178
 179 ACPI_STATUS
 180 AcpiOsTerminate (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
 199 ACPI_PHYSICAL_ADDRESS
 200 AcpiOsGetRootPointer (
 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
 222 ACPI_STATUS
 223 AcpiOsPredefinedOverride (
 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
 252 ACPI_STATUS
 253 AcpiOsTableOverride (
 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
 288 void
 289 AcpiOsRedirectOutput (
 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
 309 void ACPI_INTERNAL_VAR_XFACE
 310 AcpiOsPrintf (
 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
 336 void
 337 AcpiOsVprintf (
 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
 384 UINT32
 385 AcpiOsGetLine (
 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
 425 void *
 426 AcpiOsMapMemory (
 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
 449 void
 450 AcpiOsUnmapMemory (
 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
 471 void *
 472 AcpiOsAllocate (
 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
 495 void
 496 AcpiOsFree (
 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
 517 ACPI_STATUS
 518 AcpiOsCreateSemaphore (
 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
 561 ACPI_STATUS
 562 AcpiOsDeleteSemaphore (
 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
 596 ACPI_STATUS
 597 AcpiOsWaitSemaphore (
 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
 690 ACPI_STATUS
 691 AcpiOsSignalSemaphore (
 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
 720 ACPI_STATUS
 721 AcpiOsCreateLock (
 722     ACPI_SPINLOCK           *OutHandle)
 723 {
 724
 725     return (AcpiOsCreateSemaphore (1, 1, OutHandle));
 726 }
 727
 728
 729 void
 730 AcpiOsDeleteLock (
 731     ACPI_SPINLOCK           Handle)
 732 {
 733     AcpiOsDeleteSemaphore (Handle);
 734 }
 735
 736
 737 ACPI_CPU_FLAGS
 738 AcpiOsAcquireLock (
 739     ACPI_HANDLE             Handle)
 740 {
 741     AcpiOsWaitSemaphore (Handle, 1, 0xFFFF);
 742     return (0);
 743 }
 744
 745
 746 void
 747 AcpiOsReleaseLock (
 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
 770 UINT32
 771 AcpiOsInstallInterruptHandler (
 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
 793 ACPI_STATUS
 794 AcpiOsRemoveInterruptHandler (
 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
 817 ACPI_STATUS
 818 AcpiOsExecute (
 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
 848 void
 849 AcpiOsStall (
 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
 872 void
 873 AcpiOsSleep (
 874     ACPI_INTEGER            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
 897 UINT64
 898 AcpiOsGetTimer (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
 924 ACPI_STATUS
 925 AcpiOsValidateInterface (
 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
 948 ACPI_STATUS
 949 AcpiOsReadPciConfiguration (
 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
 975 ACPI_STATUS
 976 AcpiOsWritePciConfiguration (
 977     ACPI_PCI_ID             *PciId,
 978     UINT32                  Register,
 979     ACPI_INTEGER            Value,
 980     UINT32                  Width)
 981 {
 982
 983     return (AE_OK);
 984 }
 985
 986 /* TEMPORARY STUB FUNCTION */
 987 void
 988 AcpiOsDerivePciId(
 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
1011 ACPI_STATUS
1012 AcpiOsReadPort (
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
1054 ACPI_STATUS
1055 AcpiOsWritePort (
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
1079 ACPI_STATUS
1080 AcpiOsReadMemory (
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
1115 ACPI_STATUS
1116 AcpiOsWriteMemory (
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
1139 BOOLEAN
1140 AcpiOsReadable (
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
1162 BOOLEAN
1163 AcpiOsWritable (
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
1187 ACPI_THREAD_ID
1188 AcpiOsGetThreadId (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
1208 ACPI_STATUS
1209 AcpiOsSignal (
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