arch/all-pc/acpica/source/os_specific/service_layers/oswinxf.c

   1 /******************************************************************************
   2  *
   3  * Module Name: oswinxf - Windows OSL
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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 #include "acpi.h"
  45 #include "accommon.h"
  46
  47 #ifdef WIN32
  48 #pragma warning(disable:4115)   /* warning C4115: named type definition in parentheses (caused by rpcasync.h> */
  49
  50 #include <windows.h>
  51 #include <winbase.h>
  52
  53 #elif WIN64
  54 #include <windowsx.h>
  55 #endif
  56
  57 #include <stdio.h>
  58 #include <stdlib.h>
  59 #include <stdarg.h>
  60 #include <process.h>
  61 #include <time.h>
  62
  63 #define _COMPONENT          ACPI_OS_SERVICES
  64         ACPI_MODULE_NAME    ("oswinxf")
  65
  66
  67 extern FILE                 *AcpiGbl_DebugFile;
  68
  69 FILE                        *AcpiGbl_OutputFile;
  70 UINT64                      TimerFrequency;
  71 char                        TableName[ACPI_NAME_SIZE + 1];
  72
  73 #define ACPI_OS_DEBUG_TIMEOUT   30000 /* 30 seconds */
  74
  75
  76 /* Upcalls to AcpiExec application */
  77
  78 ACPI_PHYSICAL_ADDRESS
  79 AeLocalGetRootPointer (
  80     void);
  81
  82 void
  83 AeTableOverride (
  84     ACPI_TABLE_HEADER       *ExistingTable,
  85     ACPI_TABLE_HEADER       **NewTable);
  86
  87 /*
  88  * Real semaphores are only used for a multi-threaded application
  89  */
  90 #ifndef ACPI_SINGLE_THREADED
  91
  92 /* Semaphore information structure */
  93
  94 typedef struct acpi_os_semaphore_info
  95 {
  96     UINT16                  MaxUnits;
  97     UINT16                  CurrentUnits;
  98     void                    *OsHandle;
  99
 100 } ACPI_OS_SEMAPHORE_INFO;
 101
 102 /* Need enough semaphores to run the large aslts suite */
 103
 104 #define ACPI_OS_MAX_SEMAPHORES  256
 105
 106 ACPI_OS_SEMAPHORE_INFO          AcpiGbl_Semaphores[ACPI_OS_MAX_SEMAPHORES];
 107
 108 #endif /* ACPI_SINGLE_THREADED */
 109
 110 BOOLEAN                         AcpiGbl_DebugTimeout = FALSE;
 111
 112 /******************************************************************************
 113  *
 114  * FUNCTION:    AcpiOsTerminate
 115  *
 116  * PARAMETERS:  None
 117  *
 118  * RETURN:      Status
 119  *
 120  * DESCRIPTION: Nothing to do for windows
 121  *
 122  *****************************************************************************/
 123
 124 ACPI_STATUS
 125 AcpiOsTerminate (
 126     void)
 127 {
 128     return (AE_OK);
 129 }
 130
 131
 132 /******************************************************************************
 133  *
 134  * FUNCTION:    AcpiOsInitialize
 135  *
 136  * PARAMETERS:  None
 137  *
 138  * RETURN:      Status
 139  *
 140  * DESCRIPTION: Init this OSL
 141  *
 142  *****************************************************************************/
 143
 144 ACPI_STATUS
 145 AcpiOsInitialize (
 146     void)
 147 {
 148     LARGE_INTEGER           LocalTimerFrequency;
 149
 150
 151 #ifndef ACPI_SINGLE_THREADED
 152     /* Clear the semaphore info array */
 153
 154     memset (AcpiGbl_Semaphores, 0x00, sizeof (AcpiGbl_Semaphores));
 155 #endif
 156
 157     AcpiGbl_OutputFile = stdout;
 158
 159     /* Get the timer frequency for use in AcpiOsGetTimer */
 160
 161     TimerFrequency = 0;
 162     if (QueryPerformanceFrequency (&LocalTimerFrequency))
 163     {
 164         /* Frequency is in ticks per second */
 165
 166         TimerFrequency = LocalTimerFrequency.QuadPart;
 167     }
 168
 169     return (AE_OK);
 170 }
 171
 172
 173 /******************************************************************************
 174  *
 175  * FUNCTION:    AcpiOsGetRootPointer
 176  *
 177  * PARAMETERS:  None
 178  *
 179  * RETURN:      RSDP physical address
 180  *
 181  * DESCRIPTION: Gets the root pointer (RSDP)
 182  *
 183  *****************************************************************************/
 184
 185 ACPI_PHYSICAL_ADDRESS
 186 AcpiOsGetRootPointer (
 187     void)
 188 {
 189
 190     return (AeLocalGetRootPointer ());
 191 }
 192
 193
 194 /******************************************************************************
 195  *
 196  * FUNCTION:    AcpiOsPredefinedOverride
 197  *
 198  * PARAMETERS:  InitVal             - Initial value of the predefined object
 199  *              NewVal              - The new value for the object
 200  *
 201  * RETURN:      Status, pointer to value. Null pointer returned if not
 202  *              overriding.
 203  *
 204  * DESCRIPTION: Allow the OS to override predefined names
 205  *
 206  *****************************************************************************/
 207
 208 ACPI_STATUS
 209 AcpiOsPredefinedOverride (
 210     const ACPI_PREDEFINED_NAMES *InitVal,
 211     ACPI_STRING                 *NewVal)
 212 {
 213
 214     if (!InitVal || !NewVal)
 215     {
 216         return (AE_BAD_PARAMETER);
 217     }
 218
 219     *NewVal = NULL;
 220     return (AE_OK);
 221 }
 222
 223
 224 /******************************************************************************
 225  *
 226  * FUNCTION:    AcpiOsTableOverride
 227  *
 228  * PARAMETERS:  ExistingTable       - Header of current table (probably firmware)
 229  *              NewTable            - Where an entire new table is returned.
 230  *
 231  * RETURN:      Status, pointer to new table. Null pointer returned if no
 232  *              table is available to override
 233  *
 234  * DESCRIPTION: Return a different version of a table if one is available
 235  *
 236  *****************************************************************************/
 237
 238 ACPI_STATUS
 239 AcpiOsTableOverride (
 240     ACPI_TABLE_HEADER       *ExistingTable,
 241     ACPI_TABLE_HEADER       **NewTable)
 242 {
 243 #ifdef ACPI_ASL_COMPILER
 244     ACPI_STATUS             Status;
 245     ACPI_PHYSICAL_ADDRESS   Address;
 246 #endif
 247
 248     if (!ExistingTable || !NewTable)
 249     {
 250         return (AE_BAD_PARAMETER);
 251     }
 252
 253     *NewTable = NULL;
 254
 255
 256 #ifdef ACPI_EXEC_APP
 257
 258     /* Call back up to AcpiExec */
 259
 260     AeTableOverride (ExistingTable, NewTable);
 261 #endif
 262
 263
 264 #ifdef ACPI_ASL_COMPILER
 265
 266     /* Attempt to get the table from the registry */
 267
 268     /* Construct a null-terminated string from table signature */
 269
 270     ACPI_MOVE_NAME (TableName, ExistingTable->Signature);
 271     TableName[ACPI_NAME_SIZE] = 0;
 272
 273     Status = AcpiOsGetTableByName (TableName, 0, NewTable, &Address);
 274     if (ACPI_SUCCESS (Status))
 275     {
 276         AcpiOsPrintf ("Table [%s] obtained from registry, %u bytes\n",
 277             TableName, (*NewTable)->Length);
 278     }
 279     else
 280     {
 281         AcpiOsPrintf ("Could not read table %s from registry (%s)\n",
 282             TableName, AcpiFormatException (Status));
 283     }
 284 #endif
 285
 286     return (AE_OK);
 287 }
 288
 289
 290 /******************************************************************************
 291  *
 292  * FUNCTION:    AcpiOsPhysicalTableOverride
 293  *
 294  * PARAMETERS:  ExistingTable       - Header of current table (probably firmware)
 295  *              NewAddress          - Where new table address is returned
 296  *                                    (Physical address)
 297  *              NewTableLength      - Where new table length is returned
 298  *
 299  * RETURN:      Status, address/length of new table. Null pointer returned
 300  *              if no table is available to override.
 301  *
 302  * DESCRIPTION: Returns AE_SUPPORT, function not used in user space.
 303  *
 304  *****************************************************************************/
 305
 306 ACPI_STATUS
 307 AcpiOsPhysicalTableOverride (
 308     ACPI_TABLE_HEADER       *ExistingTable,
 309     ACPI_PHYSICAL_ADDRESS   *NewAddress,
 310     UINT32                  *NewTableLength)
 311 {
 312
 313     return (AE_SUPPORT);
 314 }
 315
 316
 317 /******************************************************************************
 318  *
 319  * FUNCTION:    AcpiOsGetTimer
 320  *
 321  * PARAMETERS:  None
 322  *
 323  * RETURN:      Current ticks in 100-nanosecond units
 324  *
 325  * DESCRIPTION: Get the value of a system timer
 326  *
 327  ******************************************************************************/
 328
 329 UINT64
 330 AcpiOsGetTimer (
 331     void)
 332 {
 333     LARGE_INTEGER           Timer;
 334
 335
 336     /* Attempt to use hi-granularity timer first */
 337
 338     if (TimerFrequency &&
 339         QueryPerformanceCounter (&Timer))
 340     {
 341         /* Convert to 100 nanosecond ticks */
 342
 343         return ((UINT64) ((Timer.QuadPart * (UINT64) ACPI_100NSEC_PER_SEC) /
 344             TimerFrequency));
 345     }
 346
 347     /* Fall back to the lo-granularity timer */
 348
 349     else
 350     {
 351         /* Convert milliseconds to 100 nanosecond ticks */
 352
 353         return ((UINT64) GetTickCount() * ACPI_100NSEC_PER_MSEC);
 354     }
 355 }
 356
 357
 358 /******************************************************************************
 359  *
 360  * FUNCTION:    AcpiOsReadable
 361  *
 362  * PARAMETERS:  Pointer             - Area to be verified
 363  *              Length              - Size of area
 364  *
 365  * RETURN:      TRUE if readable for entire length
 366  *
 367  * DESCRIPTION: Verify that a pointer is valid for reading
 368  *
 369  *****************************************************************************/
 370
 371 BOOLEAN
 372 AcpiOsReadable (
 373     void                    *Pointer,
 374     ACPI_SIZE               Length)
 375 {
 376
 377     return ((BOOLEAN) !IsBadReadPtr (Pointer, Length));
 378 }
 379
 380
 381 /******************************************************************************
 382  *
 383  * FUNCTION:    AcpiOsWritable
 384  *
 385  * PARAMETERS:  Pointer             - Area to be verified
 386  *              Length              - Size of area
 387  *
 388  * RETURN:      TRUE if writable for entire length
 389  *
 390  * DESCRIPTION: Verify that a pointer is valid for writing
 391  *
 392  *****************************************************************************/
 393
 394 BOOLEAN
 395 AcpiOsWritable (
 396     void                    *Pointer,
 397     ACPI_SIZE               Length)
 398 {
 399
 400     return ((BOOLEAN) !IsBadWritePtr (Pointer, Length));
 401 }
 402
 403
 404 /******************************************************************************
 405  *
 406  * FUNCTION:    AcpiOsRedirectOutput
 407  *
 408  * PARAMETERS:  Destination         - An open file handle/pointer
 409  *
 410  * RETURN:      None
 411  *
 412  * DESCRIPTION: Causes redirect of AcpiOsPrintf and AcpiOsVprintf
 413  *
 414  *****************************************************************************/
 415
 416 void
 417 AcpiOsRedirectOutput (
 418     void                    *Destination)
 419 {
 420
 421     AcpiGbl_OutputFile = Destination;
 422 }
 423
 424
 425 /******************************************************************************
 426  *
 427  * FUNCTION:    AcpiOsPrintf
 428  *
 429  * PARAMETERS:  Fmt, ...            - Standard printf format
 430  *
 431  * RETURN:      None
 432  *
 433  * DESCRIPTION: Formatted output
 434  *
 435  *****************************************************************************/
 436
 437 void ACPI_INTERNAL_VAR_XFACE
 438 AcpiOsPrintf (
 439     const char              *Fmt,
 440     ...)
 441 {
 442     va_list                 Args;
 443     UINT8                   Flags;
 444
 445
 446     Flags = AcpiGbl_DbOutputFlags;
 447     if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT)
 448     {
 449         /* Output is directable to either a file (if open) or the console */
 450
 451         if (AcpiGbl_DebugFile)
 452         {
 453             /* Output file is open, send the output there */
 454
 455             va_start (Args, Fmt);
 456             vfprintf (AcpiGbl_DebugFile, Fmt, Args);
 457             va_end (Args);
 458         }
 459         else
 460         {
 461             /* No redirection, send output to console (once only!) */
 462
 463             Flags |= ACPI_DB_CONSOLE_OUTPUT;
 464         }
 465     }
 466
 467     if (Flags & ACPI_DB_CONSOLE_OUTPUT)
 468     {
 469         va_start (Args, Fmt);
 470         vfprintf (AcpiGbl_OutputFile, Fmt, Args);
 471         va_end (Args);
 472     }
 473
 474     return;
 475 }
 476
 477
 478 /******************************************************************************
 479  *
 480  * FUNCTION:    AcpiOsVprintf
 481  *
 482  * PARAMETERS:  Fmt                 - Standard printf format
 483  *              Args                - Argument list
 484  *
 485  * RETURN:      None
 486  *
 487  * DESCRIPTION: Formatted output with argument list pointer
 488  *
 489  *****************************************************************************/
 490
 491 void
 492 AcpiOsVprintf (
 493     const char              *Fmt,
 494     va_list                 Args)
 495 {
 496     INT32                   Count = 0;
 497     UINT8                   Flags;
 498
 499
 500     Flags = AcpiGbl_DbOutputFlags;
 501     if (Flags & ACPI_DB_REDIRECTABLE_OUTPUT)
 502     {
 503         /* Output is directable to either a file (if open) or the console */
 504
 505         if (AcpiGbl_DebugFile)
 506         {
 507             /* Output file is open, send the output there */
 508
 509             Count = vfprintf (AcpiGbl_DebugFile, Fmt, Args);
 510         }
 511         else
 512         {
 513             /* No redirection, send output to console (once only!) */
 514
 515             Flags |= ACPI_DB_CONSOLE_OUTPUT;
 516         }
 517     }
 518
 519     if (Flags & ACPI_DB_CONSOLE_OUTPUT)
 520     {
 521         Count = vfprintf (AcpiGbl_OutputFile, Fmt, Args);
 522     }
 523
 524     return;
 525 }
 526
 527
 528 /******************************************************************************
 529  *
 530  * FUNCTION:    AcpiOsGetLine
 531  *
 532  * PARAMETERS:  Buffer              - Where to return the command line
 533  *              BufferLength        - Maximum length of Buffer
 534  *              BytesRead           - Where the actual byte count is returned
 535  *
 536  * RETURN:      Status and actual bytes read
 537  *
 538  * DESCRIPTION: Formatted input with argument list pointer
 539  *
 540  *****************************************************************************/
 541
 542 ACPI_STATUS
 543 AcpiOsGetLine (
 544     char                    *Buffer,
 545     UINT32                  BufferLength,
 546     UINT32                  *BytesRead)
 547 {
 548     int                     Temp;
 549     UINT32                  i;
 550
 551
 552     for (i = 0; ; i++)
 553     {
 554         if (i >= BufferLength)
 555         {
 556             return (AE_BUFFER_OVERFLOW);
 557         }
 558
 559         if ((Temp = getchar ()) == EOF)
 560         {
 561             return (AE_ERROR);
 562         }
 563
 564         if (!Temp || Temp == '\n')
 565         {
 566             break;
 567         }
 568
 569         Buffer [i] = (char) Temp;
 570     }
 571
 572     /* Null terminate the buffer */
 573
 574     Buffer [i] = 0;
 575
 576     /* Return the number of bytes in the string */
 577
 578     if (BytesRead)
 579     {
 580         *BytesRead = i;
 581     }
 582     return (AE_OK);
 583 }
 584
 585
 586 /******************************************************************************
 587  *
 588  * FUNCTION:    AcpiOsMapMemory
 589  *
 590  * PARAMETERS:  Where               - Physical address of memory to be mapped
 591  *              Length              - How much memory to map
 592  *
 593  * RETURN:      Pointer to mapped memory. Null on error.
 594  *
 595  * DESCRIPTION: Map physical memory into caller's address space
 596  *
 597  *****************************************************************************/
 598
 599 void *
 600 AcpiOsMapMemory (
 601     ACPI_PHYSICAL_ADDRESS   Where,
 602     ACPI_SIZE               Length)
 603 {
 604
 605     return (ACPI_TO_POINTER ((ACPI_SIZE) Where));
 606 }
 607
 608
 609 /******************************************************************************
 610  *
 611  * FUNCTION:    AcpiOsUnmapMemory
 612  *
 613  * PARAMETERS:  Where               - Logical address of memory to be unmapped
 614  *              Length              - How much memory to unmap
 615  *
 616  * RETURN:      None.
 617  *
 618  * DESCRIPTION: Delete a previously created mapping. Where and Length must
 619  *              correspond to a previous mapping exactly.
 620  *
 621  *****************************************************************************/
 622
 623 void
 624 AcpiOsUnmapMemory (
 625     void                    *Where,
 626     ACPI_SIZE               Length)
 627 {
 628
 629     return;
 630 }
 631
 632
 633 /******************************************************************************
 634  *
 635  * FUNCTION:    AcpiOsAllocate
 636  *
 637  * PARAMETERS:  Size                - Amount to allocate, in bytes
 638  *
 639  * RETURN:      Pointer to the new allocation. Null on error.
 640  *
 641  * DESCRIPTION: Allocate memory. Algorithm is dependent on the OS.
 642  *
 643  *****************************************************************************/
 644
 645 void *
 646 AcpiOsAllocate (
 647     ACPI_SIZE               Size)
 648 {
 649     void                    *Mem;
 650
 651
 652     Mem = (void *) malloc ((size_t) Size);
 653
 654     return (Mem);
 655 }
 656
 657
 658 /******************************************************************************
 659  *
 660  * FUNCTION:    AcpiOsFree
 661  *
 662  * PARAMETERS:  Mem                 - Pointer to previously allocated memory
 663  *
 664  * RETURN:      None.
 665  *
 666  * DESCRIPTION: Free memory allocated via AcpiOsAllocate
 667  *
 668  *****************************************************************************/
 669
 670 void
 671 AcpiOsFree (
 672     void                    *Mem)
 673 {
 674
 675     free (Mem);
 676 }
 677
 678
 679 #ifdef ACPI_SINGLE_THREADED
 680 /******************************************************************************
 681  *
 682  * FUNCTION:    Semaphore stub functions
 683  *
 684  * DESCRIPTION: Stub functions used for single-thread applications that do
 685  *              not require semaphore synchronization. Full implementations
 686  *              of these functions appear after the stubs.
 687  *
 688  *****************************************************************************/
 689
 690 ACPI_STATUS
 691 AcpiOsCreateSemaphore (
 692     UINT32              MaxUnits,
 693     UINT32              InitialUnits,
 694     ACPI_HANDLE         *OutHandle)
 695 {
 696     *OutHandle = (ACPI_HANDLE) 1;
 697     return (AE_OK);
 698 }
 699
 700 ACPI_STATUS
 701 AcpiOsDeleteSemaphore (
 702     ACPI_HANDLE         Handle)
 703 {
 704     return (AE_OK);
 705 }
 706
 707 ACPI_STATUS
 708 AcpiOsWaitSemaphore (
 709     ACPI_HANDLE         Handle,
 710     UINT32              Units,
 711     UINT16              Timeout)
 712 {
 713     return (AE_OK);
 714 }
 715
 716 ACPI_STATUS
 717 AcpiOsSignalSemaphore (
 718     ACPI_HANDLE         Handle,
 719     UINT32              Units)
 720 {
 721     return (AE_OK);
 722 }
 723
 724 #else
 725 /******************************************************************************
 726  *
 727  * FUNCTION:    AcpiOsCreateSemaphore
 728  *
 729  * PARAMETERS:  MaxUnits            - Maximum units that can be sent
 730  *              InitialUnits        - Units to be assigned to the new semaphore
 731  *              OutHandle           - Where a handle will be returned
 732  *
 733  * RETURN:      Status
 734  *
 735  * DESCRIPTION: Create an OS semaphore
 736  *
 737  *****************************************************************************/
 738
 739 ACPI_STATUS
 740 AcpiOsCreateSemaphore (
 741     UINT32              MaxUnits,
 742     UINT32              InitialUnits,
 743     ACPI_SEMAPHORE      *OutHandle)
 744 {
 745     void                *Mutex;
 746     UINT32              i;
 747
 748     ACPI_FUNCTION_NAME (OsCreateSemaphore);
 749
 750
 751     if (MaxUnits == ACPI_UINT32_MAX)
 752     {
 753         MaxUnits = 255;
 754     }
 755
 756     if (InitialUnits == ACPI_UINT32_MAX)
 757     {
 758         InitialUnits = MaxUnits;
 759     }
 760
 761     if (InitialUnits > MaxUnits)
 762     {
 763         return (AE_BAD_PARAMETER);
 764     }
 765
 766     /* Find an empty slot */
 767
 768     for (i = 0; i < ACPI_OS_MAX_SEMAPHORES; i++)
 769     {
 770         if (!AcpiGbl_Semaphores[i].OsHandle)
 771         {
 772             break;
 773         }
 774     }
 775     if (i >= ACPI_OS_MAX_SEMAPHORES)
 776     {
 777         ACPI_EXCEPTION ((AE_INFO, AE_LIMIT,
 778             "Reached max semaphores (%u), could not create", ACPI_OS_MAX_SEMAPHORES));
 779         return (AE_LIMIT);
 780     }
 781
 782     /* Create an OS semaphore */
 783
 784     Mutex = CreateSemaphore (NULL, InitialUnits, MaxUnits, NULL);
 785     if (!Mutex)
 786     {
 787         ACPI_ERROR ((AE_INFO, "Could not create semaphore"));
 788         return (AE_NO_MEMORY);
 789     }
 790
 791     AcpiGbl_Semaphores[i].MaxUnits = (UINT16) MaxUnits;
 792     AcpiGbl_Semaphores[i].CurrentUnits = (UINT16) InitialUnits;
 793     AcpiGbl_Semaphores[i].OsHandle = Mutex;
 794
 795     ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Handle=%u, Max=%u, Current=%u, OsHandle=%p\n",
 796             i, MaxUnits, InitialUnits, Mutex));
 797
 798     *OutHandle = (void *) i;
 799     return (AE_OK);
 800 }
 801
 802
 803 /******************************************************************************
 804  *
 805  * FUNCTION:    AcpiOsDeleteSemaphore
 806  *
 807  * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
 808  *
 809  * RETURN:      Status
 810  *
 811  * DESCRIPTION: Delete an OS semaphore
 812  *
 813  *****************************************************************************/
 814
 815 ACPI_STATUS
 816 AcpiOsDeleteSemaphore (
 817     ACPI_SEMAPHORE      Handle)
 818 {
 819     UINT32              Index = (UINT32) Handle;
 820
 821
 822     if ((Index >= ACPI_OS_MAX_SEMAPHORES) ||
 823         !AcpiGbl_Semaphores[Index].OsHandle)
 824     {
 825         return (AE_BAD_PARAMETER);
 826     }
 827
 828     CloseHandle (AcpiGbl_Semaphores[Index].OsHandle);
 829     AcpiGbl_Semaphores[Index].OsHandle = NULL;
 830     return (AE_OK);
 831 }
 832
 833
 834 /******************************************************************************
 835  *
 836  * FUNCTION:    AcpiOsWaitSemaphore
 837  *
 838  * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
 839  *              Units               - How many units to wait for
 840  *              Timeout             - How long to wait
 841  *
 842  * RETURN:      Status
 843  *
 844  * DESCRIPTION: Wait for units
 845  *
 846  *****************************************************************************/
 847
 848 ACPI_STATUS
 849 AcpiOsWaitSemaphore (
 850     ACPI_SEMAPHORE      Handle,
 851     UINT32              Units,
 852     UINT16              Timeout)
 853 {
 854     UINT32              Index = (UINT32) Handle;
 855     UINT32              WaitStatus;
 856     UINT32              OsTimeout = Timeout;
 857
 858
 859     ACPI_FUNCTION_ENTRY ();
 860
 861
 862     if ((Index >= ACPI_OS_MAX_SEMAPHORES) ||
 863         !AcpiGbl_Semaphores[Index].OsHandle)
 864     {
 865         return (AE_BAD_PARAMETER);
 866     }
 867
 868     if (Units > 1)
 869     {
 870         printf ("WaitSemaphore: Attempt to receive %u units\n", Units);
 871         return (AE_NOT_IMPLEMENTED);
 872     }
 873
 874     if (Timeout == ACPI_WAIT_FOREVER)
 875     {
 876         OsTimeout = INFINITE;
 877         if (AcpiGbl_DebugTimeout)
 878         {
 879             /* The debug timeout will prevent hang conditions */
 880
 881             OsTimeout = ACPI_OS_DEBUG_TIMEOUT;
 882         }
 883     }
 884     else
 885     {
 886         /* Add 10ms to account for clock tick granularity */
 887
 888         OsTimeout += 10;
 889     }
 890
 891     WaitStatus = WaitForSingleObject (AcpiGbl_Semaphores[Index].OsHandle, OsTimeout);
 892     if (WaitStatus == WAIT_TIMEOUT)
 893     {
 894         if (AcpiGbl_DebugTimeout)
 895         {
 896             ACPI_EXCEPTION ((AE_INFO, AE_TIME,
 897                 "Debug timeout on semaphore 0x%04X (%ums)\n",
 898                 Index, ACPI_OS_DEBUG_TIMEOUT));
 899         }
 900         return (AE_TIME);
 901     }
 902
 903     if (AcpiGbl_Semaphores[Index].CurrentUnits == 0)
 904     {
 905         ACPI_ERROR ((AE_INFO, "%s - No unit received. Timeout 0x%X, OS_Status 0x%X",
 906             AcpiUtGetMutexName (Index), Timeout, WaitStatus));
 907
 908         return (AE_OK);
 909     }
 910
 911     AcpiGbl_Semaphores[Index].CurrentUnits--;
 912     return (AE_OK);
 913 }
 914
 915
 916 /******************************************************************************
 917  *
 918  * FUNCTION:    AcpiOsSignalSemaphore
 919  *
 920  * PARAMETERS:  Handle              - Handle returned by AcpiOsCreateSemaphore
 921  *              Units               - Number of units to send
 922  *
 923  * RETURN:      Status
 924  *
 925  * DESCRIPTION: Send units
 926  *
 927  *****************************************************************************/
 928
 929 ACPI_STATUS
 930 AcpiOsSignalSemaphore (
 931     ACPI_SEMAPHORE      Handle,
 932     UINT32              Units)
 933 {
 934     UINT32              Index = (UINT32) Handle;
 935
 936
 937     ACPI_FUNCTION_ENTRY ();
 938
 939
 940     if (Index >= ACPI_OS_MAX_SEMAPHORES)
 941     {
 942         printf ("SignalSemaphore: Index/Handle out of range: %2.2X\n", Index);
 943         return (AE_BAD_PARAMETER);
 944     }
 945
 946     if (!AcpiGbl_Semaphores[Index].OsHandle)
 947     {
 948         printf ("SignalSemaphore: Null OS handle, Index %2.2X\n", Index);
 949         return (AE_BAD_PARAMETER);
 950     }
 951
 952     if (Units > 1)
 953     {
 954         printf ("SignalSemaphore: Attempt to signal %u units, Index %2.2X\n", Units, Index);
 955         return (AE_NOT_IMPLEMENTED);
 956     }
 957
 958     if ((AcpiGbl_Semaphores[Index].CurrentUnits + 1) >
 959         AcpiGbl_Semaphores[Index].MaxUnits)
 960     {
 961         ACPI_ERROR ((AE_INFO,
 962             "Oversignalled semaphore[%u]! Current %u Max %u",
 963             Index, AcpiGbl_Semaphores[Index].CurrentUnits,
 964             AcpiGbl_Semaphores[Index].MaxUnits));
 965
 966         return (AE_LIMIT);
 967     }
 968
 969     AcpiGbl_Semaphores[Index].CurrentUnits++;
 970     ReleaseSemaphore (AcpiGbl_Semaphores[Index].OsHandle, Units, NULL);
 971
 972     return (AE_OK);
 973 }
 974
 975 #endif /* ACPI_SINGLE_THREADED */
 976
 977
 978 /******************************************************************************
 979  *
 980  * FUNCTION:    Spinlock interfaces
 981  *
 982  * DESCRIPTION: Map these interfaces to semaphore interfaces
 983  *
 984  *****************************************************************************/
 985
 986 ACPI_STATUS
 987 AcpiOsCreateLock (
 988     ACPI_SPINLOCK           *OutHandle)
 989 {
 990     return (AcpiOsCreateSemaphore (1, 1, OutHandle));
 991 }
 992
 993 void
 994 AcpiOsDeleteLock (
 995     ACPI_SPINLOCK           Handle)
 996 {
 997     AcpiOsDeleteSemaphore (Handle);
 998 }
 999
1000 ACPI_CPU_FLAGS
1001 AcpiOsAcquireLock (
1002     ACPI_SPINLOCK           Handle)
1003 {
1004     AcpiOsWaitSemaphore (Handle, 1, 0xFFFF);
1005     return (0);
1006 }
1007
1008 void
1009 AcpiOsReleaseLock (
1010     ACPI_SPINLOCK           Handle,
1011     ACPI_CPU_FLAGS          Flags)
1012 {
1013     AcpiOsSignalSemaphore (Handle, 1);
1014 }
1015
1016
1017 #if ACPI_FUTURE_IMPLEMENTATION
1018
1019 /* Mutex interfaces, just implement with a semaphore */
1020
1021 ACPI_STATUS
1022 AcpiOsCreateMutex (
1023     ACPI_MUTEX              *OutHandle)
1024 {
1025     return (AcpiOsCreateSemaphore (1, 1, OutHandle));
1026 }
1027
1028 void
1029 AcpiOsDeleteMutex (
1030     ACPI_MUTEX              Handle)
1031 {
1032     AcpiOsDeleteSemaphore (Handle);
1033 }
1034
1035 ACPI_STATUS
1036 AcpiOsAcquireMutex (
1037     ACPI_MUTEX              Handle,
1038     UINT16                  Timeout)
1039 {
1040     AcpiOsWaitSemaphore (Handle, 1, Timeout);
1041     return (0);
1042 }
1043
1044 void
1045 AcpiOsReleaseMutex (
1046     ACPI_MUTEX              Handle)
1047 {
1048     AcpiOsSignalSemaphore (Handle, 1);
1049 }
1050 #endif
1051
1052
1053 /******************************************************************************
1054  *
1055  * FUNCTION:    AcpiOsInstallInterruptHandler
1056  *
1057  * PARAMETERS:  InterruptNumber     - Level handler should respond to.
1058  *              ServiceRoutine      - Address of the ACPI interrupt handler
1059  *              Context             - User context
1060  *
1061  * RETURN:      Handle to the newly installed handler.
1062  *
1063  * DESCRIPTION: Install an interrupt handler. Used to install the ACPI
1064  *              OS-independent handler.
1065  *
1066  *****************************************************************************/
1067
1068 UINT32
1069 AcpiOsInstallInterruptHandler (
1070     UINT32                  InterruptNumber,
1071     ACPI_OSD_HANDLER        ServiceRoutine,
1072     void                    *Context)
1073 {
1074
1075     return (AE_OK);
1076 }
1077
1078
1079 /******************************************************************************
1080  *
1081  * FUNCTION:    AcpiOsRemoveInterruptHandler
1082  *
1083  * PARAMETERS:  Handle              - Returned when handler was installed
1084  *
1085  * RETURN:      Status
1086  *
1087  * DESCRIPTION: Uninstalls an interrupt handler.
1088  *
1089  *****************************************************************************/
1090
1091 ACPI_STATUS
1092 AcpiOsRemoveInterruptHandler (
1093     UINT32                  InterruptNumber,
1094     ACPI_OSD_HANDLER        ServiceRoutine)
1095 {
1096
1097     return (AE_OK);
1098 }
1099
1100
1101 /******************************************************************************
1102  *
1103  * FUNCTION:    AcpiOsStall
1104  *
1105  * PARAMETERS:  Microseconds        - Time to stall
1106  *
1107  * RETURN:      None. Blocks until stall is completed.
1108  *
1109  * DESCRIPTION: Sleep at microsecond granularity
1110  *
1111  *****************************************************************************/
1112
1113 void
1114 AcpiOsStall (
1115     UINT32                  Microseconds)
1116 {
1117
1118     Sleep ((Microseconds / ACPI_USEC_PER_MSEC) + 1);
1119     return;
1120 }
1121
1122
1123 /******************************************************************************
1124  *
1125  * FUNCTION:    AcpiOsSleep
1126  *
1127  * PARAMETERS:  Milliseconds        - Time to sleep
1128  *
1129  * RETURN:      None. Blocks until sleep is completed.
1130  *
1131  * DESCRIPTION: Sleep at millisecond granularity
1132  *
1133  *****************************************************************************/
1134
1135 void
1136 AcpiOsSleep (
1137     UINT64                  Milliseconds)
1138 {
1139
1140     /* Add 10ms to account for clock tick granularity */
1141
1142     Sleep (((unsigned long) Milliseconds) + 10);
1143     return;
1144 }
1145
1146
1147 /******************************************************************************
1148  *
1149  * FUNCTION:    AcpiOsReadPciConfiguration
1150  *
1151  * PARAMETERS:  PciId               - Seg/Bus/Dev
1152  *              Register            - Device Register
1153  *              Value               - Buffer where value is placed
1154  *              Width               - Number of bits
1155  *
1156  * RETURN:      Status
1157  *
1158  * DESCRIPTION: Read data from PCI configuration space
1159  *
1160  *****************************************************************************/
1161
1162 ACPI_STATUS
1163 AcpiOsReadPciConfiguration (
1164     ACPI_PCI_ID             *PciId,
1165     UINT32                  Register,
1166     UINT64                  *Value,
1167     UINT32                  Width)
1168 {
1169
1170     *Value = 0;
1171     return (AE_OK);
1172 }
1173
1174
1175 /******************************************************************************
1176  *
1177  * FUNCTION:    AcpiOsWritePciConfiguration
1178  *
1179  * PARAMETERS:  PciId               - Seg/Bus/Dev
1180  *              Register            - Device Register
1181  *              Value               - Value to be written
1182  *              Width               - Number of bits
1183  *
1184  * RETURN:      Status
1185  *
1186  * DESCRIPTION: Write data to PCI configuration space
1187  *
1188  *****************************************************************************/
1189
1190 ACPI_STATUS
1191 AcpiOsWritePciConfiguration (
1192     ACPI_PCI_ID             *PciId,
1193     UINT32                  Register,
1194     UINT64                  Value,
1195     UINT32                  Width)
1196 {
1197
1198     return (AE_OK);
1199 }
1200
1201
1202 /******************************************************************************
1203  *
1204  * FUNCTION:    AcpiOsReadPort
1205  *
1206  * PARAMETERS:  Address             - Address of I/O port/register to read
1207  *              Value               - Where value is placed
1208  *              Width               - Number of bits
1209  *
1210  * RETURN:      Value read from port
1211  *
1212  * DESCRIPTION: Read data from an I/O port or register
1213  *
1214  *****************************************************************************/
1215
1216 ACPI_STATUS
1217 AcpiOsReadPort (
1218     ACPI_IO_ADDRESS         Address,
1219     UINT32                  *Value,
1220     UINT32                  Width)
1221 {
1222     ACPI_FUNCTION_NAME (OsReadPort);
1223
1224
1225     switch (Width)
1226     {
1227     case 8:
1228
1229         *Value = 0xFF;
1230         break;
1231
1232     case 16:
1233
1234         *Value = 0xFFFF;
1235         break;
1236
1237     case 32:
1238
1239         *Value = 0xFFFFFFFF;
1240         break;
1241
1242     default:
1243
1244         ACPI_ERROR ((AE_INFO, "Bad width parameter: %X", Width));
1245         return (AE_BAD_PARAMETER);
1246     }
1247
1248     return (AE_OK);
1249 }
1250
1251
1252 /******************************************************************************
1253  *
1254  * FUNCTION:    AcpiOsWritePort
1255  *
1256  * PARAMETERS:  Address             - Address of I/O port/register to write
1257  *              Value               - Value to write
1258  *              Width               - Number of bits
1259  *
1260  * RETURN:      None
1261  *
1262  * DESCRIPTION: Write data to an I/O port or register
1263  *
1264  *****************************************************************************/
1265
1266 ACPI_STATUS
1267 AcpiOsWritePort (
1268     ACPI_IO_ADDRESS         Address,
1269     UINT32                  Value,
1270     UINT32                  Width)
1271 {
1272     ACPI_FUNCTION_NAME (OsWritePort);
1273
1274
1275     if ((Width == 8) || (Width == 16) || (Width == 32))
1276     {
1277         return (AE_OK);
1278     }
1279
1280     ACPI_ERROR ((AE_INFO, "Bad width parameter: %X", Width));
1281     return (AE_BAD_PARAMETER);
1282 }
1283
1284
1285 /******************************************************************************
1286  *
1287  * FUNCTION:    AcpiOsReadMemory
1288  *
1289  * PARAMETERS:  Address             - Physical Memory Address to read
1290  *              Value               - Where value is placed
1291  *              Width               - Number of bits (8,16,32, or 64)
1292  *
1293  * RETURN:      Value read from physical memory address. Always returned
1294  *              as a 64-bit integer, regardless of the read width.
1295  *
1296  * DESCRIPTION: Read data from a physical memory address
1297  *
1298  *****************************************************************************/
1299
1300 ACPI_STATUS
1301 AcpiOsReadMemory (
1302     ACPI_PHYSICAL_ADDRESS   Address,
1303     UINT64                  *Value,
1304     UINT32                  Width)
1305 {
1306
1307     switch (Width)
1308     {
1309     case 8:
1310     case 16:
1311     case 32:
1312     case 64:
1313
1314         *Value = 0;
1315         break;
1316
1317     default:
1318
1319         return (AE_BAD_PARAMETER);
1320         break;
1321     }
1322
1323     return (AE_OK);
1324 }
1325
1326
1327 /******************************************************************************
1328  *
1329  * FUNCTION:    AcpiOsWriteMemory
1330  *
1331  * PARAMETERS:  Address             - Physical Memory Address to write
1332  *              Value               - Value to write
1333  *              Width               - Number of bits (8,16,32, or 64)
1334  *
1335  * RETURN:      None
1336  *
1337  * DESCRIPTION: Write data to a physical memory address
1338  *
1339  *****************************************************************************/
1340
1341 ACPI_STATUS
1342 AcpiOsWriteMemory (
1343     ACPI_PHYSICAL_ADDRESS   Address,
1344     UINT64                  Value,
1345     UINT32                  Width)
1346 {
1347
1348     return (AE_OK);
1349 }
1350
1351
1352 /******************************************************************************
1353  *
1354  * FUNCTION:    AcpiOsSignal
1355  *
1356  * PARAMETERS:  Function            - ACPI CA signal function code
1357  *              Info                - Pointer to function-dependent structure
1358  *
1359  * RETURN:      Status
1360  *
1361  * DESCRIPTION: Miscellaneous functions. Example implementation only.
1362  *
1363  *****************************************************************************/
1364
1365 ACPI_STATUS
1366 AcpiOsSignal (
1367     UINT32                  Function,
1368     void                    *Info)
1369 {
1370
1371     switch (Function)
1372     {
1373     case ACPI_SIGNAL_FATAL:
1374
1375         break;
1376
1377     case ACPI_SIGNAL_BREAKPOINT:
1378
1379         break;
1380
1381     default:
1382
1383         break;
1384     }
1385
1386     return (AE_OK);
1387 }
1388
1389
1390 /******************************************************************************
1391  *
1392  * FUNCTION:    Local cache interfaces
1393  *
1394  * DESCRIPTION: Implements cache interfaces via malloc/free for testing
1395  *              purposes only.
1396  *
1397  *****************************************************************************/
1398
1399 #ifndef ACPI_USE_LOCAL_CACHE
1400
1401 ACPI_STATUS
1402 AcpiOsCreateCache (
1403     char                    *CacheName,
1404     UINT16                  ObjectSize,
1405     UINT16                  MaxDepth,
1406     ACPI_CACHE_T            **ReturnCache)
1407 {
1408     ACPI_MEMORY_LIST        *NewCache;
1409
1410
1411     NewCache = malloc (sizeof (ACPI_MEMORY_LIST));
1412     if (!NewCache)
1413     {
1414         return (AE_NO_MEMORY);
1415     }
1416
1417     memset (NewCache, 0, sizeof (ACPI_MEMORY_LIST));
1418     NewCache->ListName = CacheName;
1419     NewCache->ObjectSize = ObjectSize;
1420     NewCache->MaxDepth = MaxDepth;
1421
1422     *ReturnCache = (ACPI_CACHE_T) NewCache;
1423     return (AE_OK);
1424 }
1425
1426 ACPI_STATUS
1427 AcpiOsDeleteCache (
1428     ACPI_CACHE_T            *Cache)
1429 {
1430     free (Cache);
1431     return (AE_OK);
1432 }
1433
1434 ACPI_STATUS
1435 AcpiOsPurgeCache (
1436     ACPI_CACHE_T            *Cache)
1437 {
1438     return (AE_OK);
1439 }
1440
1441 void *
1442 AcpiOsAcquireObject (
1443     ACPI_CACHE_T            *Cache)
1444 {
1445     void                    *NewObject;
1446
1447     NewObject = malloc (((ACPI_MEMORY_LIST *) Cache)->ObjectSize);
1448     memset (NewObject, 0, ((ACPI_MEMORY_LIST *) Cache)->ObjectSize);
1449
1450     return (NewObject);
1451 }
1452
1453 ACPI_STATUS
1454 AcpiOsReleaseObject (
1455     ACPI_CACHE_T            *Cache,
1456     void                    *Object)
1457 {
1458     free (Object);
1459     return (AE_OK);
1460 }
1461
1462 #endif /* ACPI_USE_LOCAL_CACHE */
1463
1464
1465 /* Optional multi-thread support */
1466
1467 #ifndef ACPI_SINGLE_THREADED
1468 /******************************************************************************
1469  *
1470  * FUNCTION:    AcpiOsGetThreadId
1471  *
1472  * PARAMETERS:  None
1473  *
1474  * RETURN:      Id of the running thread
1475  *
1476  * DESCRIPTION: Get the Id of the current (running) thread
1477  *
1478  *****************************************************************************/
1479
1480 ACPI_THREAD_ID
1481 AcpiOsGetThreadId (
1482     void)
1483 {
1484     DWORD                   ThreadId;
1485
1486     /* Ensure ID is never 0 */
1487
1488     ThreadId = GetCurrentThreadId ();
1489     return ((ACPI_THREAD_ID) (ThreadId + 1));
1490 }
1491
1492
1493 /******************************************************************************
1494  *
1495  * FUNCTION:    AcpiOsExecute
1496  *
1497  * PARAMETERS:  Type                - Type of execution
1498  *              Function            - Address of the function to execute
1499  *              Context             - Passed as a parameter to the function
1500  *
1501  * RETURN:      Status
1502  *
1503  * DESCRIPTION: Execute a new thread
1504  *
1505  *****************************************************************************/
1506
1507 ACPI_STATUS
1508 AcpiOsExecute (
1509     ACPI_EXECUTE_TYPE       Type,
1510     ACPI_OSD_EXEC_CALLBACK  Function,
1511     void                    *Context)
1512 {
1513
1514     _beginthread (Function, (unsigned) 0, Context);
1515     return (0);
1516 }
1517
1518 #endif /* ACPI_SINGLE_THREADED */
1519
1520
1521 /******************************************************************************
1522  *
1523  * FUNCTION:    AcpiOsWaitEventsComplete
1524  *
1525  * PARAMETERS:  None
1526  *
1527  * RETURN:      None
1528  *
1529  * DESCRIPTION: Wait for all asynchronous events to complete. This
1530  *              implementation does nothing.
1531  *
1532  *****************************************************************************/
1533
1534 void
1535 AcpiOsWaitEventsComplete (
1536     void)
1537 {
1538     return;
1539 }