drivers/bus/acpi/osl.c

   1 /*******************************************************************************
   2 *                                                                              *
   3 * ACPI Component Architecture Operating System Layer (OSL) for ReactOS         *
   4 *                                                                              *
   5 *******************************************************************************/
   6
   7 #include "precomp.h"
   8
   9 #include <pseh/pseh2.h>
  10
  11 #define NDEBUG
  12 #include <debug.h>
  13
  14 static PKINTERRUPT AcpiInterrupt;
  15 static BOOLEAN AcpiInterruptHandlerRegistered = FALSE;
  16 static ACPI_OSD_HANDLER AcpiIrqHandler = NULL;
  17 static PVOID AcpiIrqContext = NULL;
  18 static ULONG AcpiIrqNumber = 0;
  19
  20 ACPI_STATUS
  21 AcpiOsInitialize (void)
  22 {
  23     DPRINT("AcpiOsInitialize called\n");
  24
  25 #ifndef NDEBUG
  26     /* Verboseness level of the acpica core */
  27     AcpiDbgLevel = 0x00FFFFFF;
  28     AcpiDbgLayer = 0xFFFFFFFF;
  29 #endif
  30
  31     return AE_OK;
  32 }
  33
  34 ACPI_STATUS
  35 AcpiOsTerminate(void)
  36 {
  37     DPRINT("AcpiOsTerminate() called\n");
  38
  39     return AE_OK;
  40 }
  41
  42 ACPI_PHYSICAL_ADDRESS
  43 AcpiOsGetRootPointer (
  44     void)
  45 {
  46     ACPI_PHYSICAL_ADDRESS pa = 0;
  47
  48     DPRINT("AcpiOsGetRootPointer\n");
  49
  50     AcpiFindRootPointer(&pa);
  51     return pa;
  52 }
  53
  54 ACPI_STATUS
  55 AcpiOsPredefinedOverride(
  56     const ACPI_PREDEFINED_NAMES *PredefinedObject,
  57     ACPI_STRING                 *NewValue)
  58 {
  59     if (!PredefinedObject || !NewValue)
  60     {
  61         DPRINT1("Invalid parameter\n");
  62         return AE_BAD_PARAMETER;
  63     }
  64
  65     /* No override */
  66     *NewValue = NULL;
  67
  68     return AE_OK;
  69 }
  70
  71 ACPI_STATUS
  72 AcpiOsTableOverride(
  73     ACPI_TABLE_HEADER *ExistingTable,
  74     ACPI_TABLE_HEADER **NewTable)
  75 {
  76     if (!ExistingTable || !NewTable)
  77     {
  78         DPRINT1("Invalid parameter\n");
  79         return AE_BAD_PARAMETER;
  80     }
  81
  82     /* No override */
  83     *NewTable = NULL;
  84
  85     return AE_OK;
  86 }
  87
  88 ACPI_STATUS
  89 AcpiOsPhysicalTableOverride(
  90     ACPI_TABLE_HEADER       *ExistingTable,
  91     ACPI_PHYSICAL_ADDRESS   *NewAddress,
  92     UINT32                  *NewTableLength)
  93 {
  94     if (!ExistingTable || !NewAddress || !NewTableLength)
  95     {
  96         DPRINT1("Invalid parameter\n");
  97         return AE_BAD_PARAMETER;
  98     }
  99
 100     /* No override */
 101     *NewAddress     = 0;
 102     *NewTableLength = 0;
 103
 104     return AE_OK;
 105 }
 106
 107 void *
 108 AcpiOsMapMemory (
 109     ACPI_PHYSICAL_ADDRESS   phys,
 110     ACPI_SIZE               length)
 111 {
 112     PHYSICAL_ADDRESS Address;
 113     PVOID Ptr;
 114
 115     DPRINT("AcpiOsMapMemory(phys 0x%p  size 0x%X)\n", phys, length);
 116
 117     ASSERT(phys);
 118
 119     Address.QuadPart = (ULONG)phys;
 120     Ptr = MmMapIoSpace(Address, length, MmNonCached);
 121     if (!Ptr)
 122     {
 123         DPRINT1("Mapping failed\n");
 124     }
 125
 126     return Ptr;
 127 }
 128
 129 void
 130 AcpiOsUnmapMemory (
 131     void                    *virt,
 132     ACPI_SIZE               length)
 133 {
 134     DPRINT("AcpiOsMapMemory(phys 0x%p  size 0x%X)\n", virt, length);
 135
 136     ASSERT(virt);
 137
 138     MmUnmapIoSpace(virt, length);
 139 }
 140
 141 ACPI_STATUS
 142 AcpiOsGetPhysicalAddress(
 143     void *LogicalAddress,
 144     ACPI_PHYSICAL_ADDRESS *PhysicalAddress)
 145 {
 146     PHYSICAL_ADDRESS PhysAddr;
 147
 148     if (!LogicalAddress || !PhysicalAddress)
 149     {
 150         DPRINT1("Bad parameter\n");
 151         return AE_BAD_PARAMETER;
 152     }
 153
 154     PhysAddr = MmGetPhysicalAddress(LogicalAddress);
 155
 156     *PhysicalAddress = (ACPI_PHYSICAL_ADDRESS)PhysAddr.QuadPart;
 157
 158     return AE_OK;
 159 }
 160
 161 void *
 162 AcpiOsAllocate (ACPI_SIZE size)
 163 {
 164     DPRINT("AcpiOsAllocate size %d\n",size);
 165     return ExAllocatePoolWithTag(NonPagedPool, size, 'IPCA');
 166 }
 167
 168 void
 169 AcpiOsFree(void *ptr)
 170 {
 171     if (!ptr)
 172         DPRINT1("Attempt to free null pointer!!!\n");
 173     ExFreePoolWithTag(ptr, 'IPCA');
 174 }
 175
 176 BOOLEAN
 177 AcpiOsReadable(
 178     void *Memory,
 179     ACPI_SIZE Length)
 180 {
 181     BOOLEAN Ret = FALSE;
 182
 183     _SEH2_TRY
 184     {
 185         ProbeForRead(Memory, Length, sizeof(UCHAR));
 186         Ret = TRUE;
 187     }
 188     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 189     {
 190         Ret = FALSE;
 191     }
 192     _SEH2_END;
 193
 194     return Ret;
 195 }
 196
 197 BOOLEAN
 198 AcpiOsWritable(
 199     void *Memory,
 200     ACPI_SIZE Length)
 201 {
 202     BOOLEAN Ret = FALSE;
 203
 204     _SEH2_TRY
 205     {
 206         ProbeForWrite(Memory, Length, sizeof(UCHAR));
 207         Ret = TRUE;
 208     }
 209     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 210     {
 211         Ret = FALSE;
 212     }
 213     _SEH2_END;
 214
 215     return Ret;
 216 }
 217
 218 ACPI_THREAD_ID
 219 AcpiOsGetThreadId (void)
 220 {
 221     /* Thread ID must be non-zero */
 222     return (ULONG)PsGetCurrentThreadId() + 1;
 223 }
 224
 225 ACPI_STATUS
 226 AcpiOsExecute (
 227     ACPI_EXECUTE_TYPE       Type,
 228     ACPI_OSD_EXEC_CALLBACK  Function,
 229     void                    *Context)
 230 {
 231     HANDLE ThreadHandle;
 232     OBJECT_ATTRIBUTES ObjectAttributes;
 233     NTSTATUS Status;
 234
 235     DPRINT("AcpiOsExecute\n");
 236
 237     InitializeObjectAttributes(&ObjectAttributes,
 238                                NULL,
 239                                OBJ_KERNEL_HANDLE,
 240                                NULL,
 241                                NULL);
 242
 243     Status = PsCreateSystemThread(&ThreadHandle,
 244                                   THREAD_ALL_ACCESS,
 245                                   &ObjectAttributes,
 246                                   NULL,
 247                                   NULL,
 248                                   (PKSTART_ROUTINE)Function,
 249                                   Context);
 250     if (!NT_SUCCESS(Status))
 251         return AE_ERROR;
 252
 253     ZwClose(ThreadHandle);
 254
 255     return AE_OK;
 256 }
 257
 258 void
 259 AcpiOsSleep (UINT64 milliseconds)
 260 {
 261     DPRINT("AcpiOsSleep %d\n", milliseconds);
 262     KeStallExecutionProcessor(milliseconds*1000);
 263 }
 264
 265 void
 266 AcpiOsStall (UINT32 microseconds)
 267 {
 268     DPRINT("AcpiOsStall %d\n",microseconds);
 269     KeStallExecutionProcessor(microseconds);
 270 }
 271
 272 ACPI_STATUS
 273 AcpiOsCreateMutex(
 274     ACPI_MUTEX *OutHandle)
 275 {
 276     PFAST_MUTEX Mutex;
 277
 278     if (!OutHandle)
 279     {
 280         DPRINT1("Bad parameter\n");
 281         return AE_BAD_PARAMETER;
 282     }
 283
 284     Mutex = ExAllocatePool(NonPagedPool, sizeof(FAST_MUTEX));
 285     if (!Mutex) return AE_NO_MEMORY;
 286
 287     ExInitializeFastMutex(Mutex);
 288
 289     *OutHandle = (ACPI_MUTEX)Mutex;
 290
 291     return AE_OK;
 292 }
 293
 294 void
 295 AcpiOsDeleteMutex(
 296     ACPI_MUTEX Handle)
 297 {
 298     if (!Handle)
 299     {
 300         DPRINT1("Bad parameter\n");
 301         return;
 302     }
 303
 304     ExFreePool(Handle);
 305 }
 306
 307 ACPI_STATUS
 308 AcpiOsAcquireMutex(
 309     ACPI_MUTEX Handle,
 310     UINT16 Timeout)
 311 {
 312     if (!Handle)
 313     {
 314         DPRINT1("Bad parameter\n");
 315         return AE_BAD_PARAMETER;
 316     }
 317
 318     /* Check what the caller wants us to do */
 319     if (Timeout == ACPI_DO_NOT_WAIT)
 320     {
 321         /* Try to acquire without waiting */
 322         if (!ExTryToAcquireFastMutex((PFAST_MUTEX)Handle))
 323             return AE_TIME;
 324     }
 325     else
 326     {
 327         /* Block until we get it */
 328         ExAcquireFastMutex((PFAST_MUTEX)Handle);
 329     }
 330
 331     return AE_OK;
 332 }
 333
 334 void
 335 AcpiOsReleaseMutex(
 336     ACPI_MUTEX Handle)
 337 {
 338     if (!Handle)
 339     {
 340         DPRINT1("Bad parameter\n");
 341         return;
 342     }
 343
 344     ExReleaseFastMutex((PFAST_MUTEX)Handle);
 345 }
 346
 347 typedef struct _ACPI_SEM {
 348     UINT32 CurrentUnits;
 349     KEVENT Event;
 350     KSPIN_LOCK Lock;
 351 } ACPI_SEM, *PACPI_SEM;
 352
 353 ACPI_STATUS
 354 AcpiOsCreateSemaphore(
 355     UINT32 MaxUnits,
 356     UINT32 InitialUnits,
 357     ACPI_SEMAPHORE *OutHandle)
 358 {
 359     PACPI_SEM Sem;
 360
 361     if (!OutHandle)
 362     {
 363         DPRINT1("Bad parameter\n");
 364         return AE_BAD_PARAMETER;
 365     }
 366
 367     Sem = ExAllocatePool(NonPagedPool, sizeof(ACPI_SEM));
 368     if (!Sem) return AE_NO_MEMORY;
 369
 370     Sem->CurrentUnits = InitialUnits;
 371     KeInitializeEvent(&Sem->Event, SynchronizationEvent, Sem->CurrentUnits != 0);
 372     KeInitializeSpinLock(&Sem->Lock);
 373
 374     *OutHandle = (ACPI_SEMAPHORE)Sem;
 375
 376     return AE_OK;
 377 }
 378
 379 ACPI_STATUS
 380 AcpiOsDeleteSemaphore(
 381     ACPI_SEMAPHORE Handle)
 382 {
 383     if (!Handle)
 384     {
 385         DPRINT1("Bad parameter\n");
 386         return AE_BAD_PARAMETER;
 387     }
 388
 389     ExFreePool(Handle);
 390
 391     return AE_OK;
 392 }
 393
 394 ACPI_STATUS
 395 AcpiOsWaitSemaphore(
 396     ACPI_SEMAPHORE Handle,
 397     UINT32 Units,
 398     UINT16 Timeout)
 399 {
 400     PACPI_SEM Sem = Handle;
 401     KIRQL OldIrql;
 402
 403     if (!Handle)
 404     {
 405         DPRINT1("Bad parameter\n");
 406         return AE_BAD_PARAMETER;
 407     }
 408
 409     KeAcquireSpinLock(&Sem->Lock, &OldIrql);
 410
 411     /* Make sure we can wait if we have fewer units than we need */
 412     if ((Timeout == ACPI_DO_NOT_WAIT) && (Sem->CurrentUnits < Units))
 413     {
 414         /* We can't so we must bail now */
 415         KeReleaseSpinLock(&Sem->Lock, OldIrql);
 416         return AE_TIME;
 417     }
 418
 419     /* Time to block until we get enough units */
 420     while (Sem->CurrentUnits < Units)
 421     {
 422         KeReleaseSpinLock(&Sem->Lock, OldIrql);
 423         KeWaitForSingleObject(&Sem->Event,
 424                               Executive,
 425                               KernelMode,
 426                               FALSE,
 427                               NULL);
 428         KeAcquireSpinLock(&Sem->Lock, &OldIrql);
 429     }
 430
 431     Sem->CurrentUnits -= Units;
 432
 433     if (Sem->CurrentUnits != 0) KeSetEvent(&Sem->Event, IO_NO_INCREMENT, FALSE);
 434
 435     KeReleaseSpinLock(&Sem->Lock, OldIrql);
 436
 437     return AE_OK;
 438 }
 439
 440 ACPI_STATUS
 441 AcpiOsSignalSemaphore(
 442     ACPI_SEMAPHORE Handle,
 443     UINT32 Units)
 444 {
 445     PACPI_SEM Sem = Handle;
 446     KIRQL OldIrql;
 447
 448     if (!Handle)
 449     {
 450         DPRINT1("Bad parameter\n");
 451         return AE_BAD_PARAMETER;
 452     }
 453
 454     KeAcquireSpinLock(&Sem->Lock, &OldIrql);
 455
 456     Sem->CurrentUnits += Units;
 457     KeSetEvent(&Sem->Event, IO_NO_INCREMENT, FALSE);
 458
 459     KeReleaseSpinLock(&Sem->Lock, OldIrql);
 460
 461     return AE_OK;
 462 }
 463
 464 ACPI_STATUS
 465 AcpiOsCreateLock(
 466     ACPI_SPINLOCK *OutHandle)
 467 {
 468     PKSPIN_LOCK SpinLock;
 469
 470     if (!OutHandle)
 471     {
 472         DPRINT1("Bad parameter\n");
 473         return AE_BAD_PARAMETER;
 474     }
 475
 476     SpinLock = ExAllocatePool(NonPagedPool, sizeof(KSPIN_LOCK));
 477     if (!SpinLock) return AE_NO_MEMORY;
 478
 479     KeInitializeSpinLock(SpinLock);
 480
 481     *OutHandle = (ACPI_SPINLOCK)SpinLock;
 482
 483     return AE_OK;
 484 }
 485
 486 void
 487 AcpiOsDeleteLock(
 488     ACPI_SPINLOCK Handle)
 489 {
 490     if (!Handle)
 491     {
 492         DPRINT1("Bad parameter\n");
 493         return;
 494     }
 495
 496     ExFreePool(Handle);
 497 }
 498
 499 ACPI_CPU_FLAGS
 500 AcpiOsAcquireLock(
 501     ACPI_SPINLOCK Handle)
 502 {
 503     KIRQL OldIrql;
 504
 505     if ((OldIrql = KeGetCurrentIrql()) >= DISPATCH_LEVEL)
 506     {
 507         KeAcquireSpinLockAtDpcLevel((PKSPIN_LOCK)Handle);
 508     }
 509     else
 510     {
 511         KeAcquireSpinLock((PKSPIN_LOCK)Handle, &OldIrql);
 512     }
 513
 514     return (ACPI_CPU_FLAGS)OldIrql;
 515 }
 516
 517 void
 518 AcpiOsReleaseLock(
 519     ACPI_SPINLOCK Handle,
 520     ACPI_CPU_FLAGS Flags)
 521 {
 522     KIRQL OldIrql = (KIRQL)Flags;
 523
 524     if (OldIrql >= DISPATCH_LEVEL)
 525     {
 526         KeReleaseSpinLockFromDpcLevel((PKSPIN_LOCK)Handle);
 527     }
 528     else
 529     {
 530         KeReleaseSpinLock((PKSPIN_LOCK)Handle, OldIrql);
 531     }
 532 }
 533
 534 BOOLEAN NTAPI
 535 OslIsrStub(
 536   PKINTERRUPT Interrupt,
 537   PVOID ServiceContext)
 538 {
 539   INT32 Status;
 540
 541   Status = (*AcpiIrqHandler)(AcpiIrqContext);
 542
 543   if (Status == ACPI_INTERRUPT_HANDLED)
 544     return TRUE;
 545   else
 546     return FALSE;
 547 }
 548
 549 UINT32
 550 AcpiOsInstallInterruptHandler (
 551     UINT32                  InterruptNumber,
 552     ACPI_OSD_HANDLER        ServiceRoutine,
 553     void                    *Context)
 554 {
 555     ULONG Vector;
 556     KIRQL DIrql;
 557     KAFFINITY Affinity;
 558     NTSTATUS Status;
 559
 560     if (AcpiInterruptHandlerRegistered)
 561     {
 562         DPRINT1("Reregister interrupt attempt failed\n");
 563         return AE_ALREADY_EXISTS;
 564     }
 565
 566     if (!ServiceRoutine)
 567     {
 568         DPRINT1("Bad parameter\n");
 569         return AE_BAD_PARAMETER;
 570     }
 571
 572     DPRINT("AcpiOsInstallInterruptHandler()\n");
 573     Vector = HalGetInterruptVector(
 574         Internal,
 575         0,
 576         InterruptNumber,
 577         InterruptNumber,
 578         &DIrql,
 579         &Affinity);
 580
 581     AcpiIrqNumber = InterruptNumber;
 582     AcpiIrqHandler = ServiceRoutine;
 583     AcpiIrqContext = Context;
 584     AcpiInterruptHandlerRegistered = TRUE;
 585
 586     Status = IoConnectInterrupt(
 587         &AcpiInterrupt,
 588         OslIsrStub,
 589         NULL,
 590         NULL,
 591         Vector,
 592         DIrql,
 593         DIrql,
 594         LevelSensitive,
 595         TRUE,
 596         Affinity,
 597         FALSE);
 598
 599     if (!NT_SUCCESS(Status))
 600     {
 601         DPRINT("Could not connect to interrupt %d\n", Vector);
 602         return AE_ERROR;
 603     }
 604     return AE_OK;
 605 }
 606
 607 ACPI_STATUS
 608 AcpiOsRemoveInterruptHandler (
 609     UINT32                  InterruptNumber,
 610     ACPI_OSD_HANDLER        ServiceRoutine)
 611 {
 612     DPRINT("AcpiOsRemoveInterruptHandler()\n");
 613
 614     if (!ServiceRoutine)
 615     {
 616         DPRINT1("Bad parameter\n");
 617         return AE_BAD_PARAMETER;
 618     }
 619
 620     if (AcpiInterruptHandlerRegistered)
 621     {
 622         IoDisconnectInterrupt(AcpiInterrupt);
 623         AcpiInterrupt = NULL;
 624         AcpiInterruptHandlerRegistered = FALSE;
 625     }
 626     else
 627     {
 628         DPRINT1("Trying to remove non-existing interrupt handler\n");
 629         return AE_NOT_EXIST;
 630     }
 631
 632     return AE_OK;
 633 }
 634
 635 ACPI_STATUS
 636 AcpiOsReadMemory (
 637     ACPI_PHYSICAL_ADDRESS   Address,
 638     UINT64                  *Value,
 639     UINT32                  Width)
 640 {
 641     DPRINT("AcpiOsReadMemory %p\n", Address);
 642     switch (Width)
 643     {
 644     case 8:
 645         *Value = (*(PUCHAR)(ULONG_PTR)Address);
 646         break;
 647
 648     case 16:
 649         *Value = (*(PUSHORT)(ULONG_PTR)Address);
 650         break;
 651
 652     case 32:
 653         *Value = (*(PULONG)(ULONG_PTR)Address);
 654         break;
 655
 656     case 64:
 657         *Value = (*(PULONGLONG)(ULONG_PTR)Address);
 658         break;
 659
 660     default:
 661         DPRINT1("AcpiOsReadMemory got bad width: %d\n",Width);
 662         return (AE_BAD_PARAMETER);
 663         break;
 664     }
 665     return (AE_OK);
 666 }
 667
 668 ACPI_STATUS
 669 AcpiOsWriteMemory (
 670     ACPI_PHYSICAL_ADDRESS   Address,
 671     UINT64                  Value,
 672     UINT32                  Width)
 673 {
 674     DPRINT("AcpiOsWriteMemory %p\n", Address);
 675     switch (Width)
 676     {
 677     case 8:
 678         *(PUCHAR)(ULONG_PTR)Address = Value;
 679         break;
 680
 681     case 16:
 682         *(PUSHORT)(ULONG_PTR)Address = Value;
 683         break;
 684
 685     case 32:
 686         *(PULONG)(ULONG_PTR)Address = Value;
 687         break;
 688
 689     case 64:
 690         *(PULONGLONG)(ULONG_PTR)Address = Value;
 691         break;
 692
 693     default:
 694         DPRINT1("AcpiOsWriteMemory got bad width: %d\n",Width);
 695         return (AE_BAD_PARAMETER);
 696         break;
 697     }
 698
 699     return (AE_OK);
 700 }
 701
 702 ACPI_STATUS
 703 AcpiOsReadPort (
 704     ACPI_IO_ADDRESS         Address,
 705     UINT32                  *Value,
 706     UINT32                  Width)
 707 {
 708     DPRINT("AcpiOsReadPort %p, width %d\n",Address,Width);
 709
 710     switch (Width)
 711     {
 712     case 8:
 713         *Value = READ_PORT_UCHAR((PUCHAR)Address);
 714         break;
 715
 716     case 16:
 717         *Value = READ_PORT_USHORT((PUSHORT)Address);
 718         break;
 719
 720     case 32:
 721         *Value = READ_PORT_ULONG((PULONG)Address);
 722         break;
 723
 724     default:
 725         DPRINT1("AcpiOsReadPort got bad width: %d\n",Width);
 726         return (AE_BAD_PARAMETER);
 727         break;
 728     }
 729     return (AE_OK);
 730 }
 731
 732 ACPI_STATUS
 733 AcpiOsWritePort (
 734     ACPI_IO_ADDRESS         Address,
 735     UINT32                  Value,
 736     UINT32                  Width)
 737 {
 738     DPRINT("AcpiOsWritePort %p, width %d\n",Address,Width);
 739     switch (Width)
 740     {
 741     case 8:
 742         WRITE_PORT_UCHAR((PUCHAR)Address, Value);
 743         break;
 744
 745     case 16:
 746         WRITE_PORT_USHORT((PUSHORT)Address, Value);
 747         break;
 748
 749     case 32:
 750         WRITE_PORT_ULONG((PULONG)Address, Value);
 751         break;
 752
 753     default:
 754         DPRINT1("AcpiOsWritePort got bad width: %d\n",Width);
 755         return (AE_BAD_PARAMETER);
 756         break;
 757     }
 758     return (AE_OK);
 759 }
 760
 761 BOOLEAN
 762 OslIsPciDevicePresent(ULONG BusNumber, ULONG SlotNumber)
 763 {
 764     UINT32 ReadLength;
 765     PCI_COMMON_CONFIG PciConfig;
 766
 767     /* Detect device presence by reading the PCI configuration space */
 768
 769     ReadLength = HalGetBusDataByOffset(PCIConfiguration,
 770                                        BusNumber,
 771                                        SlotNumber,
 772                                        &PciConfig,
 773                                        0,
 774                                        sizeof(PciConfig));
 775     if (ReadLength == 0)
 776     {
 777         DPRINT("PCI device is not present\n");
 778         return FALSE;
 779     }
 780
 781     ASSERT(ReadLength >= 2);
 782
 783     if (PciConfig.VendorID == PCI_INVALID_VENDORID)
 784     {
 785         DPRINT("Invalid vendor ID in PCI configuration space\n");
 786         return FALSE;
 787     }
 788
 789     DPRINT("PCI device is present\n");
 790
 791     return TRUE;
 792 }
 793
 794 ACPI_STATUS
 795 AcpiOsReadPciConfiguration (
 796     ACPI_PCI_ID             *PciId,
 797     UINT32                  Reg,
 798     UINT64                  *Value,
 799     UINT32                  Width)
 800 {
 801     PCI_SLOT_NUMBER slot;
 802
 803     slot.u.AsULONG = 0;
 804     slot.u.bits.DeviceNumber = PciId->Device;
 805     slot.u.bits.FunctionNumber = PciId->Function;
 806
 807     DPRINT("AcpiOsReadPciConfiguration, slot=0x%X, func=0x%X\n", slot.u.AsULONG, Reg);
 808
 809     if (!OslIsPciDevicePresent(PciId->Bus, slot.u.AsULONG))
 810         return AE_NOT_FOUND;
 811
 812     /* Width is in BITS */
 813     HalGetBusDataByOffset(PCIConfiguration,
 814         PciId->Bus,
 815         slot.u.AsULONG,
 816         Value,
 817         Reg,
 818         (Width >> 3));
 819
 820     return AE_OK;
 821 }
 822
 823 ACPI_STATUS
 824 AcpiOsWritePciConfiguration (
 825     ACPI_PCI_ID              *PciId,
 826     UINT32                   Reg,
 827     UINT64                   Value,
 828     UINT32                   Width)
 829 {
 830     ULONG buf = Value;
 831     PCI_SLOT_NUMBER slot;
 832
 833     slot.u.AsULONG = 0;
 834     slot.u.bits.DeviceNumber = PciId->Device;
 835     slot.u.bits.FunctionNumber = PciId->Function;
 836
 837     DPRINT("AcpiOsWritePciConfiguration, slot=0x%x\n", slot.u.AsULONG);
 838     if (!OslIsPciDevicePresent(PciId->Bus, slot.u.AsULONG))
 839         return AE_NOT_FOUND;
 840
 841     /* Width is in BITS */
 842     HalSetBusDataByOffset(PCIConfiguration,
 843         PciId->Bus,
 844         slot.u.AsULONG,
 845         &buf,
 846         Reg,
 847         (Width >> 3));
 848
 849     return AE_OK;
 850 }
 851
 852 void ACPI_INTERNAL_VAR_XFACE
 853 AcpiOsPrintf (
 854     const char              *Fmt,
 855     ...)
 856 {
 857     va_list                 Args;
 858     va_start (Args, Fmt);
 859
 860     AcpiOsVprintf (Fmt, Args);
 861
 862     va_end (Args);
 863     return;
 864 }
 865
 866 void
 867 AcpiOsVprintf (
 868     const char              *Fmt,
 869     va_list                 Args)
 870 {
 871 #ifndef NDEBUG
 872     vDbgPrintEx (-1, DPFLTR_ERROR_LEVEL, Fmt, Args);
 873 #endif
 874     return;
 875 }
 876
 877 void
 878 AcpiOsRedirectOutput(
 879     void *Destination)
 880 {
 881     /* No-op */
 882     DPRINT1("Output redirection not supported\n");
 883 }
 884
 885 UINT64
 886 AcpiOsGetTimer(
 887     void)
 888 {
 889     LARGE_INTEGER CurrentTime;
 890
 891     KeQuerySystemTime(&CurrentTime);
 892     return CurrentTime.QuadPart;
 893 }
 894
 895 void
 896 AcpiOsWaitEventsComplete(void)
 897 {
 898     /*
 899      * Wait for all asynchronous events to complete.
 900      * This implementation does nothing.
 901      */
 902     return;
 903 }
 904
 905 ACPI_STATUS
 906 AcpiOsSignal (
 907     UINT32                  Function,
 908     void                    *Info)
 909 {
 910     ACPI_SIGNAL_FATAL_INFO *FatalInfo = Info;
 911
 912     switch (Function)
 913     {
 914     case ACPI_SIGNAL_FATAL:
 915         if (Info)
 916             DPRINT1 ("AcpiOsBreakpoint: %d %d %d ****\n", FatalInfo->Type, FatalInfo->Code, FatalInfo->Argument);
 917         else
 918             DPRINT1 ("AcpiOsBreakpoint ****\n");
 919         break;
 920     case ACPI_SIGNAL_BREAKPOINT:
 921         if (Info)
 922             DPRINT1 ("AcpiOsBreakpoint: %s ****\n", Info);
 923         else
 924             DPRINT1 ("AcpiOsBreakpoint ****\n");
 925         break;
 926     }
 927
 928     ASSERT(FALSE);
 929
 930     return (AE_OK);
 931 }
 932
 933 ACPI_STATUS
 934 AcpiOsGetLine(
 935     char *Buffer,
 936     UINT32 BufferLength,
 937     UINT32 *BytesRead)
 938 {
 939     DPRINT1("File reading not supported\n");
 940     return AE_ERROR;
 941 }