reactos/drivers/bus/acpi/osl.c

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