sys/contrib/dev/acpica-unix-20031203/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 - 2003, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights.  You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code.  No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision.  In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change.  Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee.  Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution.  In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government.  In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116
 117 /*
 118  * These interfaces are required in order to compile the ASL compiler under
 119  * Linux.
 120  */
 121
 122 #include <stdio.h>
 123 #include <stdlib.h>
 124 #include <stdarg.h>
 125 #include <unistd.h>
 126 #include <sys/time.h>
 127
 128 #include "acpi.h"
 129 #include "amlcode.h"
 130 #include "acparser.h"
 131 #include "acdebug.h"
 132
 133 #define _COMPONENT          ACPI_OS_SERVICES
 134         ACPI_MODULE_NAME    ("osunixxf")
 135
 136
 137 extern FILE                    *AcpiGbl_DebugFile;
 138 FILE                           *AcpiGbl_OutputFile;
 139
 140
 141 /******************************************************************************
 142  *
 143  * FUNCTION:    AcpiOsInitialize, AcpiOsTerminate
 144  *
 145  * PARAMETERS:  None
 146  *
 147  * RETURN:      Status
 148  *
 149  * DESCRIPTION: Init and terminate.  Nothing to do.
 150  *
 151  *****************************************************************************/
 152
 153 ACPI_STATUS
 154 AcpiOsInitialize (void)
 155 {
 156     AcpiGbl_OutputFile = stdout;
 157
 158     return AE_OK;
 159 }
 160
 161
 162 ACPI_STATUS
 163 AcpiOsTerminate (void)
 164 {
 165     return AE_OK;
 166 }
 167
 168
 169 /******************************************************************************
 170  *
 171  * FUNCTION:    AcpiOsGetRootPointer
 172  *
 173  * PARAMETERS:  Flags   - Logical or physical addressing mode
 174  *              Address - Where the address is returned
 175  *
 176  * RETURN:      Status
 177  *
 178  * DESCRIPTION: Gets the root pointer (RSDP)
 179  *
 180  *****************************************************************************/
 181
 182 ACPI_STATUS
 183 AcpiOsGetRootPointer (
 184     UINT32                  Flags,
 185     ACPI_POINTER           *Address)
 186 {
 187
 188     return (AE_OK);
 189 }
 190
 191
 192 /******************************************************************************
 193  *
 194  * FUNCTION:    AcpiOsPredefinedOverride
 195  *
 196  * PARAMETERS:  InitVal     - Initial value of the predefined object
 197  *              NewVal      - The new value for the object
 198  *
 199  * RETURN:      Status, pointer to value.  Null pointer returned if not
 200  *              overriding.
 201  *
 202  * DESCRIPTION: Allow the OS to override predefined names
 203  *
 204  *****************************************************************************/
 205
 206 ACPI_STATUS
 207 AcpiOsPredefinedOverride (
 208     const ACPI_PREDEFINED_NAMES *InitVal,
 209     ACPI_STRING                 *NewVal)
 210 {
 211
 212     if (!InitVal || !NewVal)
 213     {
 214         return (AE_BAD_PARAMETER);
 215     }
 216
 217     *NewVal = NULL;
 218     return (AE_OK);
 219 }
 220
 221
 222 /******************************************************************************
 223  *
 224  * FUNCTION:    AcpiOsTableOverride
 225  *
 226  * PARAMETERS:  ExistingTable   - Header of current table (probably firmware)
 227  *              NewTable        - Where an entire new table is returned.
 228  *
 229  * RETURN:      Status, pointer to new table.  Null pointer returned if no
 230  *              table is available to override
 231  *
 232  * DESCRIPTION: Return a different version of a table if one is available
 233  *
 234  *****************************************************************************/
 235
 236 ACPI_STATUS
 237 AcpiOsTableOverride (
 238     ACPI_TABLE_HEADER       *ExistingTable,
 239     ACPI_TABLE_HEADER       **NewTable)
 240 {
 241     if (!ExistingTable || !NewTable)
 242     {
 243         return (AE_BAD_PARAMETER);
 244     }
 245
 246     /* TODO: Add table-getting code here */
 247     *NewTable = NULL;
 248     return (AE_NO_ACPI_TABLES);
 249 }
 250
 251
 252 /******************************************************************************
 253  *
 254  * FUNCTION:    AcpiOsReadable
 255  *
 256  * PARAMETERS:  Pointer             - Area to be verified
 257  *              Length              - Size of area
 258  *
 259  * RETURN:      TRUE if readable for entire length
 260  *
 261  * DESCRIPTION: Verify that a pointer is valid for reading
 262  *
 263  *****************************************************************************/
 264
 265 BOOLEAN
 266 AcpiOsReadable (
 267     void                    *Pointer,
 268     ACPI_SIZE               Length)
 269 {
 270
 271     return (TRUE);
 272 }
 273
 274
 275 /******************************************************************************
 276  *
 277  * FUNCTION:    AcpiOsWritable
 278  *
 279  * PARAMETERS:  Pointer             - Area to be verified
 280  *              Length              - Size of area
 281  *
 282  * RETURN:      TRUE if writable for entire length
 283  *
 284  * DESCRIPTION: Verify that a pointer is valid for writing
 285  *
 286  *****************************************************************************/
 287
 288 BOOLEAN
 289 AcpiOsWritable (
 290     void                    *Pointer,
 291     ACPI_SIZE               Length)
 292 {
 293
 294     return (TRUE);
 295 }
 296
 297
 298 /******************************************************************************
 299  *
 300  * FUNCTION:    AcpiOsRedirectOutput
 301  *
 302  * PARAMETERS:  Destination         - An open file handle/pointer
 303  *
 304  * RETURN:      None
 305  *
 306  * DESCRIPTION: Causes redirect of AcpiOsPrintf and AcpiOsVprintf
 307  *
 308  *****************************************************************************/
 309
 310 void
 311 AcpiOsRedirectOutput (
 312     void                    *Destination)
 313 {
 314
 315     AcpiGbl_OutputFile = Destination;
 316 }
 317
 318
 319 /******************************************************************************
 320  *
 321  * FUNCTION:    AcpiOsPrintf
 322  *
 323  * PARAMETERS:  fmt, ...            Standard printf format
 324  *
 325  * RETURN:      None
 326  *
 327  * DESCRIPTION: Formatted output
 328  *
 329  *****************************************************************************/
 330
 331 void ACPI_INTERNAL_VAR_XFACE
 332 AcpiOsPrintf (
 333     const char              *Fmt,
 334     ...)
 335 {
 336     va_list                 Args;
 337
 338
 339     va_start (Args, Fmt);
 340
 341     AcpiOsVprintf (Fmt, Args);
 342
 343     va_end (Args);
 344     return;
 345 }
 346
 347
 348 /******************************************************************************
 349  *
 350  * FUNCTION:    AcpiOsVprintf
 351  *
 352  * PARAMETERS:  fmt                 Standard printf format
 353  *              args                Argument list
 354  *
 355  * RETURN:      None
 356  *
 357  * DESCRIPTION: Formatted output with argument list pointer
 358  *
 359  *****************************************************************************/
 360
 361 void
 362 AcpiOsVprintf (
 363     const char              *Fmt,
 364     va_list                 Args)
 365 {
 366     INT32                   Count = 0;
 367     UINT8                   Flags;
 368
 369
 370     Flags = AcpiGbl_DbOutputFlags;
 371     if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT)
 372     {
 373         /* Output is directable to either a file (if open) or the console */
 374
 375         if (AcpiGbl_DebugFile)
 376         {
 377             /* Output file is open, send the output there */
 378
 379             Count = vfprintf (AcpiGbl_DebugFile, Fmt, Args);
 380         }
 381         else
 382         {
 383             /* No redirection, send output to console (once only!) */
 384
 385             Flags |= ACPI_DB_CONSOLE_OUTPUT;
 386         }
 387     }
 388
 389     if (Flags & ACPI_DB_CONSOLE_OUTPUT)
 390     {
 391         Count = vfprintf (AcpiGbl_OutputFile, Fmt, Args);
 392     }
 393
 394     return;
 395 }
 396
 397
 398 /******************************************************************************
 399  *
 400  * FUNCTION:    AcpiOsGetLine
 401  *
 402  * PARAMETERS:  fmt                 Standard printf format
 403  *              args                Argument list
 404  *
 405  * RETURN:      Actual bytes read
 406  *
 407  * DESCRIPTION: Formatted input with argument list pointer
 408  *
 409  *****************************************************************************/
 410
 411 UINT32
 412 AcpiOsGetLine (
 413     char                    *Buffer)
 414 {
 415     UINT8                   Temp;
 416     UINT32                  i;
 417
 418
 419     for (i = 0; ; i++)
 420     {
 421         scanf ("%1c", &Temp);
 422         if (!Temp || Temp == '\n')
 423         {
 424             break;
 425         }
 426
 427         Buffer [i] = Temp;
 428     }
 429
 430     /* Null terminate the buffer */
 431
 432     Buffer [i] = 0;
 433
 434     /* Return the number of bytes in the string */
 435
 436     return (i);
 437 }
 438
 439 /******************************************************************************
 440  *
 441  * FUNCTION:    AcpiOsMapMemory
 442  *
 443  * PARAMETERS:  where               Physical address of memory to be mapped
 444  *              length              How much memory to map
 445  *              there               Logical address of mapped memory
 446  *
 447  * RETURN:      Pointer to mapped memory.  Null on error.
 448  *
 449  * DESCRIPTION: Map physical memory into caller's address space
 450  *
 451  *****************************************************************************/
 452
 453 ACPI_STATUS
 454 AcpiOsMapMemory (
 455     ACPI_PHYSICAL_ADDRESS   where,
 456     ACPI_SIZE               length,
 457     void                    **there)
 458 {
 459     *there = ACPI_TO_POINTER (where);
 460
 461     return AE_OK;
 462 }
 463
 464
 465 /******************************************************************************
 466  *
 467  * FUNCTION:    AcpiOsUnmapMemory
 468  *
 469  * PARAMETERS:  where               Logical address of memory to be unmapped
 470  *              length              How much memory to unmap
 471  *
 472  * RETURN:      None.
 473  *
 474  * DESCRIPTION: Delete a previously created mapping.  Where and Length must
 475  *              correspond to a previous mapping exactly.
 476  *
 477  *****************************************************************************/
 478
 479 void
 480 AcpiOsUnmapMemory (
 481     void                    *where,
 482     ACPI_SIZE               length)
 483 {
 484
 485     return;
 486 }
 487
 488
 489 /******************************************************************************
 490  *
 491  * FUNCTION:    AcpiOsAllocate
 492  *
 493  * PARAMETERS:  Size                Amount to allocate, in bytes
 494  *
 495  * RETURN:      Pointer to the new allocation.  Null on error.
 496  *
 497  * DESCRIPTION: Allocate memory.  Algorithm is dependent on the OS.
 498  *
 499  *****************************************************************************/
 500
 501 void *
 502 AcpiOsAllocate (
 503     ACPI_SIZE               size)
 504 {
 505     void                    *Mem;
 506
 507
 508     Mem = (void *) malloc ((size_t) size);
 509
 510     return Mem;
 511 }
 512
 513
 514 /******************************************************************************
 515  *
 516  * FUNCTION:    AcpiOsFree
 517  *
 518  * PARAMETERS:  mem                 Pointer to previously allocated memory
 519  *
 520  * RETURN:      None.
 521  *
 522  * DESCRIPTION: Free memory allocated via AcpiOsAllocate
 523  *
 524  *****************************************************************************/
 525
 526 void
 527 AcpiOsFree (
 528     void                    *mem)
 529 {
 530
 531
 532     free (mem);
 533 }
 534
 535
 536 /******************************************************************************
 537  *
 538  * FUNCTION:    AcpiOsCreateSemaphore
 539  *
 540  * PARAMETERS:  InitialUnits        - Units to be assigned to the new semaphore
 541  *              OutHandle           - Where a handle will be returned
 542  *
 543  * RETURN:      Status
 544  *
 545  * DESCRIPTION: Create an OS semaphore
 546  *
 547  *****************************************************************************/
 548
 549 ACPI_STATUS
 550 AcpiOsCreateSemaphore (
 551     UINT32              MaxUnits,
 552     UINT32              InitialUnits,
 553     ACPI_HANDLE         *OutHandle)
 554 {
 555
 556
 557     *OutHandle = (ACPI_HANDLE) 1;
 558     return AE_OK;
 559 }
 560
 561 /******************************************************************************
 562  *
 563  * FUNCTION:    AcpiOsDeleteSemaphore
 564  *
 565  * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
 566  *
 567  * RETURN:      Status
 568  *
 569  * DESCRIPTION: Delete an OS semaphore
 570  *
 571  *****************************************************************************/
 572
 573 ACPI_STATUS
 574 AcpiOsDeleteSemaphore (
 575     ACPI_HANDLE         Handle)
 576 {
 577
 578     if (!Handle)
 579     {
 580         return AE_BAD_PARAMETER;
 581     }
 582
 583     return AE_OK;
 584 }
 585
 586
 587 /******************************************************************************
 588  *
 589  * FUNCTION:    AcpiOsWaitSemaphore
 590  *
 591  * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
 592  *              Units               - How many units to wait for
 593  *              Timeout             - How long to wait
 594  *
 595  * RETURN:      Status
 596  *
 597  * DESCRIPTION: Wait for units
 598  *
 599  *****************************************************************************/
 600
 601 ACPI_STATUS
 602 AcpiOsWaitSemaphore (
 603     ACPI_HANDLE         Handle,
 604     UINT32              Units,
 605     UINT16              Timeout)
 606 {
 607
 608
 609     return AE_OK;
 610 }
 611
 612
 613 /******************************************************************************
 614  *
 615  * FUNCTION:    AcpiOsSignalSemaphore
 616  *
 617  * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
 618  *              Units               - Number of units to send
 619  *
 620  * RETURN:      Status
 621  *
 622  * DESCRIPTION: Send units
 623  *
 624  *****************************************************************************/
 625
 626 ACPI_STATUS
 627 AcpiOsSignalSemaphore (
 628     ACPI_HANDLE         Handle,
 629     UINT32              Units)
 630 {
 631
 632
 633     return AE_OK;
 634 }
 635
 636
 637 ACPI_STATUS
 638 AcpiOsCreateLock (
 639     ACPI_HANDLE             *OutHandle)
 640 {
 641
 642     return (AcpiOsCreateSemaphore (1, 1, OutHandle));
 643 }
 644
 645 void
 646 AcpiOsDeleteLock (
 647     ACPI_HANDLE             Handle)
 648 {
 649     AcpiOsDeleteSemaphore (Handle);
 650 }
 651
 652
 653 void
 654 AcpiOsAcquireLock (
 655     ACPI_HANDLE             Handle,
 656     UINT32                  Flags)
 657 {
 658     AcpiOsWaitSemaphore (Handle, 1, 0xFFFF);
 659 }
 660
 661
 662 void
 663 AcpiOsReleaseLock (
 664     ACPI_HANDLE             Handle,
 665     UINT32                  Flags)
 666 {
 667     AcpiOsSignalSemaphore (Handle, 1);
 668 }
 669
 670
 671 /******************************************************************************
 672  *
 673  * FUNCTION:    AcpiOsInstallInterruptHandler
 674  *
 675  * PARAMETERS:  InterruptNumber     Level handler should respond to.
 676  *              Isr                 Address of the ACPI interrupt handler
 677  *              ExceptPtr           Where status is returned
 678  *
 679  * RETURN:      Handle to the newly installed handler.
 680  *
 681  * DESCRIPTION: Install an interrupt handler.  Used to install the ACPI
 682  *              OS-independent handler.
 683  *
 684  *****************************************************************************/
 685
 686 UINT32
 687 AcpiOsInstallInterruptHandler (
 688     UINT32                  InterruptNumber,
 689     OSD_HANDLER             ServiceRoutine,
 690     void                    *Context)
 691 {
 692
 693
 694     return AE_OK;
 695 }
 696
 697
 698 /******************************************************************************
 699  *
 700  * FUNCTION:    AcpiOsRemoveInterruptHandler
 701  *
 702  * PARAMETERS:  Handle              Returned when handler was installed
 703  *
 704  * RETURN:      Status
 705  *
 706  * DESCRIPTION: Uninstalls an interrupt handler.
 707  *
 708  *****************************************************************************/
 709
 710 ACPI_STATUS
 711 AcpiOsRemoveInterruptHandler (
 712     UINT32                  InterruptNumber,
 713     OSD_HANDLER             ServiceRoutine)
 714 {
 715
 716     return AE_OK;
 717 }
 718
 719
 720 /******************************************************************************
 721  *
 722  * FUNCTION:    AcpiOsQueueForExecution
 723  *
 724  * PARAMETERS:  Priority        - Requested execution priority
 725  *              Function        - Address of the function to execute
 726  *              Context         - Passed as a parameter to the function
 727  *
 728  * RETURN:      Status.
 729  *
 730  * DESCRIPTION: Sleep at microsecond granularity
 731  *
 732  *****************************************************************************/
 733
 734 ACPI_STATUS
 735 AcpiOsQueueForExecution (
 736     UINT32                  Priority,
 737     OSD_EXECUTION_CALLBACK  Function,
 738     void                    *Context)
 739 {
 740
 741 //    _beginthread (Function, (unsigned) 0, Context);
 742     return 0;
 743 }
 744
 745
 746 /******************************************************************************
 747  *
 748  * FUNCTION:    AcpiOsBreakpoint
 749  *
 750  * PARAMETERS:  Msg                 Message to print
 751  *
 752  * RETURN:      Status
 753  *
 754  * DESCRIPTION: Print a message and break to the debugger.
 755  *
 756  *****************************************************************************/
 757
 758 ACPI_STATUS
 759 AcpiOsBreakpoint (
 760     char                    *Msg)
 761 {
 762
 763     /* Print the message and do an INT 3 */
 764
 765     if (Msg)
 766     {
 767         AcpiOsPrintf ("AcpiOsBreakpoint: %s ****\n", Msg);
 768     }
 769     else
 770     {
 771         AcpiOsPrintf ("At AcpiOsBreakpoint ****\n");
 772     }
 773
 774
 775     return AE_OK;
 776 }
 777
 778
 779 /******************************************************************************
 780  *
 781  * FUNCTION:    AcpiOsSleepUsec
 782  *
 783  * PARAMETERS:  microseconds        To sleep
 784  *
 785  * RETURN:      Blocks until sleep is completed.
 786  *
 787  * DESCRIPTION: Sleep at microsecond granularity
 788  *
 789  *****************************************************************************/
 790
 791 void
 792 AcpiOsStall (
 793     UINT32                  microseconds)
 794 {
 795
 796     if (microseconds)
 797     {
 798         usleep (microseconds);
 799     }
 800     return;
 801 }
 802
 803
 804 /******************************************************************************
 805  *
 806  * FUNCTION:    AcpiOsSleep
 807  *
 808  * PARAMETERS:  seconds             To sleep
 809  *              milliseconds        To sleep
 810  *
 811  * RETURN:      Blocks until sleep is completed.
 812  *
 813  * DESCRIPTION: Sleep at second/millisecond granularity
 814  *
 815  *****************************************************************************/
 816
 817 void
 818 AcpiOsSleep (
 819     UINT32                  seconds,
 820     UINT32                  milliseconds)
 821 {
 822
 823     sleep (seconds + (milliseconds / 1000));    /* Sleep for whole seconds */
 824
 825     /*
 826      * Arg to usleep() must be less than 1,000,000 (1 second)
 827      */
 828     usleep ((milliseconds % 1000) * 1000);      /* Sleep for remaining usecs */
 829
 830     return;
 831 }
 832
 833 /******************************************************************************
 834  *
 835  * FUNCTION:    AcpiOsGetTimer
 836  *
 837  * PARAMETERS:  None
 838  *
 839  * RETURN:      Current time in milliseconds
 840  *
 841  * DESCRIPTION: Get the current system time (in milliseconds).
 842  *
 843  *****************************************************************************/
 844
 845 UINT32
 846 AcpiOsGetTimer (void)
 847 {
 848     struct timeval  time;
 849
 850     gettimeofday(&time, NULL);
 851
 852     return ((time.tv_sec/1000) + (time.tv_usec*1000));
 853 }
 854
 855
 856 /******************************************************************************
 857  *
 858  * FUNCTION:    AcpiOsReadPciConfiguration
 859  *
 860  * PARAMETERS:  PciId               Seg/Bus/Dev
 861  *              Register            Device Register
 862  *              Value               Buffer where value is placed
 863  *              Width               Number of bits
 864  *
 865  * RETURN:      Status
 866  *
 867  * DESCRIPTION: Read data from PCI configuration space
 868  *
 869  *****************************************************************************/
 870
 871 ACPI_STATUS
 872 AcpiOsReadPciConfiguration (
 873     ACPI_PCI_ID             *PciId,
 874     UINT32                  Register,
 875     void                    *Value,
 876     UINT32                  Width)
 877 {
 878
 879     return (AE_OK);
 880 }
 881
 882
 883 /******************************************************************************
 884  *
 885  * FUNCTION:    AcpiOsWritePciConfiguration
 886  *
 887  * PARAMETERS:  PciId               Seg/Bus/Dev
 888  *              Register            Device Register
 889  *              Value               Value to be written
 890  *              Width               Number of bits
 891  *
 892  * RETURN:      Status.
 893  *
 894  * DESCRIPTION: Write data to PCI configuration space
 895  *
 896  *****************************************************************************/
 897
 898 ACPI_STATUS
 899 AcpiOsWritePciConfiguration (
 900     ACPI_PCI_ID             *PciId,
 901     UINT32                  Register,
 902     ACPI_INTEGER            Value,
 903     UINT32                  Width)
 904 {
 905
 906     return (AE_OK);
 907 }
 908
 909 /* TEMPORARY STUB FUNCTION */
 910 void
 911 AcpiOsDerivePciId(
 912     ACPI_HANDLE             rhandle,
 913     ACPI_HANDLE             chandle,
 914     ACPI_PCI_ID             **PciId)
 915 {
 916
 917 }
 918
 919
 920 /******************************************************************************
 921  *
 922  * FUNCTION:    AcpiOsReadPort
 923  *
 924  * PARAMETERS:  Address             Address of I/O port/register to read
 925  *              Value               Where value is placed
 926  *              Width               Number of bits
 927  *
 928  * RETURN:      Value read from port
 929  *
 930  * DESCRIPTION: Read data from an I/O port or register
 931  *
 932  *****************************************************************************/
 933
 934 ACPI_STATUS
 935 AcpiOsReadPort (
 936     ACPI_IO_ADDRESS         Address,
 937     UINT32                  *Value,
 938     UINT32                  Width)
 939 {
 940
 941     switch (Width)
 942     {
 943     case 8:
 944         *Value = 0xFF;
 945         break;
 946
 947     case 16:
 948         *Value = 0xFFFF;
 949         break;
 950
 951     case 32:
 952         *Value = 0xFFFFFFFF;
 953         break;
 954     }
 955
 956     return (AE_OK);
 957 }
 958
 959
 960 /******************************************************************************
 961  *
 962  * FUNCTION:    AcpiOsWritePort
 963  *
 964  * PARAMETERS:  Address             Address of I/O port/register to write
 965  *              Value               Value to write
 966  *              Width               Number of bits
 967  *
 968  * RETURN:      None
 969  *
 970  * DESCRIPTION: Write data to an I/O port or register
 971  *
 972  *****************************************************************************/
 973
 974 ACPI_STATUS
 975 AcpiOsWritePort (
 976     ACPI_IO_ADDRESS         Address,
 977     UINT32                  Value,
 978     UINT32                  Width)
 979 {
 980
 981     return (AE_OK);
 982 }
 983
 984
 985 /******************************************************************************
 986  *
 987  * FUNCTION:    AcpiOsReadMemory
 988  *
 989  * PARAMETERS:  Address             Physical Memory Address to read
 990  *              Value               Where value is placed
 991  *              Width               Number of bits
 992  *
 993  * RETURN:      Value read from physical memory address
 994  *
 995  * DESCRIPTION: Read data from a physical memory address
 996  *
 997  *****************************************************************************/
 998
 999 ACPI_STATUS
1000 AcpiOsReadMemory (
1001     ACPI_PHYSICAL_ADDRESS   Address,
1002     UINT32                  *Value,
1003     UINT32                  Width)
1004 {
1005
1006     switch (Width)
1007     {
1008     case 8:
1009     case 16:
1010     case 32:
1011         *Value = 0;
1012         break;
1013
1014     default:
1015         return (AE_BAD_PARAMETER);
1016         break;
1017     }
1018     return (AE_OK);
1019 }
1020
1021
1022 /******************************************************************************
1023  *
1024  * FUNCTION:    AcpiOsWriteMemory
1025  *
1026  * PARAMETERS:  Address             Physical Memory Address to write
1027  *              Value               Value to write
1028  *              Width               Number of bits
1029  *
1030  * RETURN:      None
1031  *
1032  * DESCRIPTION: Write data to a physical memory address
1033  *
1034  *****************************************************************************/
1035
1036 ACPI_STATUS
1037 AcpiOsWriteMemory (
1038     ACPI_PHYSICAL_ADDRESS   Address,
1039     UINT32                  Value,
1040     UINT32                  Width)
1041 {
1042
1043     return (AE_OK);
1044 }
1045
1046
1047 UINT32
1048 AcpiOsGetThreadId(void)
1049 {
1050     return getpid();
1051 }
1052
1053
1054 /******************************************************************************
1055  *
1056  * FUNCTION:    AcpiOsSignal
1057  *
1058  * PARAMETERS:  Function            ACPI CA signal function code
1059  *              Info                Pointer to function-dependent structure
1060  *
1061  * RETURN:      Status
1062  *
1063  * DESCRIPTION: Miscellaneous functions
1064  *
1065  *****************************************************************************/
1066
1067 ACPI_STATUS
1068 AcpiOsSignal (
1069     UINT32                  Function,
1070     void                    *Info)
1071 {
1072
1073     switch (Function)
1074     {
1075     case ACPI_SIGNAL_FATAL:
1076         break;
1077
1078     case ACPI_SIGNAL_BREAKPOINT:
1079
1080         if (Info)
1081         {
1082             AcpiOsPrintf ("AcpiOsBreakpoint: %s ****\n", Info);
1083         }
1084         else
1085         {
1086             AcpiOsPrintf ("At AcpiOsBreakpoint ****\n");
1087         }
1088
1089         break;
1090     }
1091
1092
1093     return (AE_OK);
1094 }
1095
1096