reactos/hal/hal/hal.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * FILE:             hal/hal.c
   5  * PURPOSE:          Hardware Abstraction Layer DLL
   6  * PROGRAMMER:       Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  * REVISION HISTORY:
   8  *    01-08-2001 CSH Created
   9  */
  10
  11 /* INCLUDES ******************************************************************/
  12
  13 #include <ntddk.h>
  14 #include <ntdddisk.h>
  15 #include <arc/arc.h>
  16 #include <intrin.h>
  17 #include <ndk/halfuncs.h>
  18 #include <ndk/iofuncs.h>
  19 #include <ndk/kdfuncs.h>
  20
  21 #define NDEBUG
  22 #include <debug.h>
  23
  24 #undef ExAcquireFastMutex
  25 #undef ExReleaseFastMutex
  26 #undef ExTryToAcquireFastMutex
  27
  28 /* DATA **********************************************************************/
  29
  30 PUCHAR KdComPortInUse;
  31
  32 /* FUNCTIONS *****************************************************************/
  33
  34 NTSTATUS
  35 NTAPI
  36 DriverEntry(
  37   PDRIVER_OBJECT DriverObject,
  38   PUNICODE_STRING RegistryPath)
  39 {
  40   UNIMPLEMENTED;
  41
  42   return STATUS_SUCCESS;
  43 }
  44
  45 /*
  46 * @unimplemented
  47 */
  48 VOID
  49 NTAPI
  50 HalStopProfileInterrupt(IN KPROFILE_SOURCE ProfileSource)
  51 {
  52     ASSERT(FALSE);
  53     return;
  54 }
  55
  56 /*
  57 * @unimplemented
  58 */
  59 VOID
  60 NTAPI
  61 HalStartProfileInterrupt(IN KPROFILE_SOURCE ProfileSource)
  62 {
  63     ASSERT(FALSE);
  64     return;
  65 }
  66
  67 /*
  68 * @unimplemented
  69 */
  70 ULONG_PTR
  71 NTAPI
  72 HalSetProfileInterval(IN ULONG_PTR Interval)
  73 {
  74     ASSERT(FALSE);
  75     return Interval;
  76 }
  77
  78 #ifndef _M_AMD64
  79 VOID
  80 FASTCALL
  81 ExAcquireFastMutex(
  82   PFAST_MUTEX FastMutex)
  83 {
  84   UNIMPLEMENTED;
  85 }
  86
  87
  88 VOID
  89 FASTCALL
  90 ExReleaseFastMutex(
  91   PFAST_MUTEX FastMutex)
  92 {
  93   UNIMPLEMENTED;
  94 }
  95
  96
  97 BOOLEAN FASTCALL
  98 ExTryToAcquireFastMutex(
  99   PFAST_MUTEX FastMutex)
 100 {
 101   UNIMPLEMENTED;
 102
 103   return TRUE;
 104 }
 105 #endif
 106
 107 VOID
 108 NTAPI
 109 HalAcquireDisplayOwnership(
 110   PHAL_RESET_DISPLAY_PARAMETERS ResetDisplayParameters)
 111 {
 112   UNIMPLEMENTED;
 113 }
 114
 115
 116 NTSTATUS
 117 NTAPI
 118 HalAdjustResourceList(
 119   PCM_RESOURCE_LIST Resources)
 120 {
 121   UNIMPLEMENTED;
 122
 123   return STATUS_SUCCESS;
 124 }
 125
 126
 127 BOOLEAN
 128 NTAPI
 129 HalAllProcessorsStarted(VOID)
 130 {
 131   UNIMPLEMENTED;
 132
 133   return TRUE;
 134 }
 135
 136
 137 NTSTATUS
 138 NTAPI
 139 HalAllocateAdapterChannel(
 140   PADAPTER_OBJECT AdapterObject,
 141   PWAIT_CONTEXT_BLOCK WaitContextBlock,
 142   ULONG NumberOfMapRegisters,
 143   PDRIVER_CONTROL ExecutionRoutine)
 144 {
 145   UNIMPLEMENTED;
 146
 147   return STATUS_SUCCESS;
 148 }
 149
 150
 151 PVOID
 152 NTAPI
 153 HalAllocateCommonBuffer(
 154   PADAPTER_OBJECT AdapterObject,
 155   ULONG Length,
 156   PPHYSICAL_ADDRESS LogicalAddress,
 157   BOOLEAN CacheEnabled)
 158 {
 159   UNIMPLEMENTED;
 160
 161   return NULL;
 162 }
 163
 164
 165 PVOID
 166 NTAPI
 167 HalAllocateCrashDumpRegisters(
 168   PADAPTER_OBJECT AdapterObject,
 169   PULONG NumberOfMapRegisters)
 170 {
 171   UNIMPLEMENTED;
 172   return NULL;
 173 }
 174
 175 VOID
 176 NTAPI
 177 HalBugCheckSystem (PVOID ErrorRecord)
 178 {
 179   UNIMPLEMENTED;
 180 }
 181
 182
 183 NTSTATUS
 184 NTAPI
 185 HalAssignSlotResources(
 186   PUNICODE_STRING RegistryPath,
 187   PUNICODE_STRING DriverClassName,
 188   PDRIVER_OBJECT DriverObject,
 189   PDEVICE_OBJECT DeviceObject,
 190   INTERFACE_TYPE BusType,
 191   ULONG BusNumber,
 192   ULONG SlotNumber,
 193   PCM_RESOURCE_LIST *AllocatedResources)
 194 {
 195   UNIMPLEMENTED;
 196
 197   return TRUE;
 198 }
 199
 200
 201 BOOLEAN
 202 NTAPI
 203 HalBeginSystemInterrupt (KIRQL Irql,
 204                          ULONG Vector,
 205                          PKIRQL OldIrql)
 206 {
 207   UNIMPLEMENTED;
 208
 209   return TRUE;
 210 }
 211
 212
 213 VOID
 214 NTAPI
 215 HalCalibratePerformanceCounter(
 216   volatile LONG *Count,
 217   ULONGLONG NewCount)
 218 {
 219   UNIMPLEMENTED;
 220 }
 221
 222
 223 VOID
 224 NTAPI
 225 HalDisableSystemInterrupt(ULONG Vector,
 226   KIRQL Irql)
 227 {
 228   UNIMPLEMENTED;
 229 }
 230
 231
 232 VOID
 233 NTAPI
 234 HalDisplayString(
 235   PCH String)
 236 {
 237   UNIMPLEMENTED;
 238 }
 239
 240
 241 BOOLEAN
 242 NTAPI
 243 HalEnableSystemInterrupt(
 244   ULONG Vector,
 245   KIRQL Irql,
 246   KINTERRUPT_MODE InterruptMode)
 247 {
 248   UNIMPLEMENTED;
 249
 250   return TRUE;
 251 }
 252
 253
 254 VOID
 255 NTAPI
 256 HalEndSystemInterrupt(
 257   KIRQL Irql,
 258   ULONG Vector)
 259 {
 260   UNIMPLEMENTED;
 261 }
 262
 263
 264 BOOLEAN
 265 NTAPI
 266 HalFlushCommonBuffer(
 267   ULONG Unknown1,
 268   ULONG Unknown2,
 269   ULONG Unknown3,
 270   ULONG Unknown4,
 271   ULONG Unknown5)
 272 {
 273   UNIMPLEMENTED;
 274
 275    return TRUE;
 276 }
 277
 278
 279 VOID
 280 NTAPI
 281 HalFreeCommonBuffer(
 282   PADAPTER_OBJECT AdapterObject,
 283   ULONG Length,
 284   PHYSICAL_ADDRESS LogicalAddress,
 285   PVOID VirtualAddress,
 286   BOOLEAN CacheEnabled)
 287 {
 288   UNIMPLEMENTED;
 289 }
 290
 291
 292 PADAPTER_OBJECT
 293 NTAPI
 294 HalGetAdapter(
 295   PDEVICE_DESCRIPTION DeviceDescription,
 296   PULONG NumberOfMapRegisters)
 297 {
 298   UNIMPLEMENTED;
 299
 300   return (PADAPTER_OBJECT)NULL;
 301 }
 302
 303
 304 ULONG
 305 NTAPI
 306 HalGetBusData(
 307   BUS_DATA_TYPE BusDataType,
 308   ULONG BusNumber,
 309   ULONG SlotNumber,
 310   PVOID Buffer,
 311   ULONG Length)
 312 {
 313   UNIMPLEMENTED;
 314
 315   return 0;
 316 }
 317
 318
 319 ULONG
 320 NTAPI
 321 HalGetBusDataByOffset(
 322   BUS_DATA_TYPE BusDataType,
 323   ULONG BusNumber,
 324   ULONG SlotNumber,
 325   PVOID Buffer,
 326   ULONG Offset,
 327   ULONG Length)
 328 {
 329   UNIMPLEMENTED;
 330
 331   return 0;
 332 }
 333
 334
 335 ARC_STATUS
 336 NTAPI
 337 HalGetEnvironmentVariable(
 338   PCH Name,
 339   USHORT ValueLength,
 340   PCH Value)
 341 {
 342   UNIMPLEMENTED;
 343
 344   return ENOENT;
 345 }
 346
 347
 348 ULONG
 349 NTAPI
 350 HalGetInterruptVector(
 351   INTERFACE_TYPE InterfaceType,
 352   ULONG BusNumber,
 353   ULONG BusInterruptLevel,
 354   ULONG BusInterruptVector,
 355   PKIRQL Irql,
 356   PKAFFINITY Affinity)
 357 {
 358   UNIMPLEMENTED;
 359
 360   return 0;
 361 }
 362
 363
 364 VOID
 365 NTAPI
 366 HalHandleNMI(
 367   PVOID NmiData)
 368 {
 369   UNIMPLEMENTED;
 370 }
 371
 372
 373 BOOLEAN
 374 NTAPI
 375 HalInitSystem(
 376   ULONG BootPhase,
 377   PLOADER_PARAMETER_BLOCK LoaderBlock)
 378 {
 379   UNIMPLEMENTED;
 380
 381   return TRUE;
 382 }
 383
 384
 385 VOID
 386 NTAPI
 387 HalInitializeProcessor(ULONG ProcessorNumber,
 388                        PLOADER_PARAMETER_BLOCK LoaderBlock)
 389 {
 390   UNIMPLEMENTED;
 391 }
 392
 393
 394 BOOLEAN
 395 NTAPI
 396 HalMakeBeep(
 397   ULONG Frequency)
 398 {
 399   UNIMPLEMENTED;
 400
 401   return TRUE;
 402 }
 403
 404
 405 VOID
 406 NTAPI
 407 HalProcessorIdle(VOID)
 408 {
 409   UNIMPLEMENTED;
 410 }
 411
 412
 413 BOOLEAN
 414 NTAPI
 415 HalQueryDisplayOwnership(VOID)
 416 {
 417   UNIMPLEMENTED;
 418
 419   return FALSE;
 420 }
 421
 422
 423 VOID
 424 NTAPI
 425 HalQueryDisplayParameters(
 426   OUT PULONG DispSizeX,
 427   OUT PULONG DispSizeY,
 428   OUT PULONG CursorPosX,
 429   OUT PULONG CursorPosY)
 430 {
 431   UNIMPLEMENTED;
 432 }
 433
 434
 435 BOOLEAN
 436 NTAPI
 437 HalQueryRealTimeClock(
 438   PTIME_FIELDS Time)
 439 {
 440   UNIMPLEMENTED;
 441   return FALSE;
 442 }
 443
 444
 445 ULONG
 446 NTAPI
 447 HalReadDmaCounter(
 448   PADAPTER_OBJECT AdapterObject)
 449 {
 450   UNIMPLEMENTED;
 451
 452   return 0;
 453 }
 454
 455
 456 VOID
 457 NTAPI
 458 HalReleaseDisplayOwnership(VOID)
 459 {
 460   UNIMPLEMENTED;
 461 }
 462
 463 VOID
 464 NTAPI
 465 HalReportResourceUsage(VOID)
 466 {
 467   UNIMPLEMENTED;
 468 }
 469
 470
 471 VOID
 472 NTAPI
 473 HalRequestIpi(
 474     KAFFINITY TargetSet)
 475 {
 476   UNIMPLEMENTED;
 477 }
 478
 479
 480 VOID
 481 FASTCALL
 482 HalRequestSoftwareInterrupt(
 483   KIRQL Request)
 484 {
 485   UNIMPLEMENTED;
 486 }
 487
 488 VOID FASTCALL
 489 HalClearSoftwareInterrupt(
 490   IN KIRQL Request)
 491 {
 492   UNIMPLEMENTED;
 493 }
 494
 495
 496 VOID
 497 NTAPI
 498 HalReturnToFirmware(
 499   FIRMWARE_REENTRY Action)
 500 {
 501   UNIMPLEMENTED;
 502 }
 503
 504
 505 ULONG
 506 NTAPI
 507 HalSetBusData(
 508   BUS_DATA_TYPE BusDataType,
 509   ULONG BusNumber,
 510   ULONG SlotNumber,
 511   PVOID Buffer,
 512   ULONG Length)
 513 {
 514   UNIMPLEMENTED;
 515
 516   return 0;
 517 }
 518
 519
 520 ULONG
 521 NTAPI
 522 HalSetBusDataByOffset(
 523   BUS_DATA_TYPE BusDataType,
 524   ULONG BusNumber,
 525   ULONG SlotNumber,
 526   PVOID Buffer,
 527   ULONG Offset,
 528   ULONG Length)
 529 {
 530   UNIMPLEMENTED;
 531
 532   return 0;
 533 }
 534
 535
 536 VOID
 537 NTAPI
 538 HalSetDisplayParameters(
 539   ULONG CursorPosX,
 540   ULONG CursorPosY)
 541 {
 542   UNIMPLEMENTED;
 543 }
 544
 545
 546 ARC_STATUS
 547 NTAPI
 548 HalSetEnvironmentVariable(
 549   PCH Name,
 550   PCH Value)
 551 {
 552   UNIMPLEMENTED;
 553
 554   return ESUCCESS;
 555 }
 556
 557
 558 BOOLEAN
 559 NTAPI
 560 HalSetRealTimeClock(
 561   PTIME_FIELDS Time)
 562 {
 563   UNIMPLEMENTED;
 564
 565   return TRUE;
 566 }
 567
 568
 569 ULONG
 570 NTAPI
 571 HalSetTimeIncrement(
 572   ULONG Increment)
 573 {
 574   UNIMPLEMENTED;
 575
 576   return Increment;
 577 }
 578
 579
 580 BOOLEAN
 581 NTAPI
 582 HalStartNextProcessor(IN PLOADER_PARAMETER_BLOCK LoaderBlock,
 583                       IN PKPROCESSOR_STATE ProcessorState)
 584 {
 585   UNIMPLEMENTED;
 586
 587   return TRUE;
 588 }
 589
 590
 591 UCHAR
 592 FASTCALL
 593 HalSystemVectorDispatchEntry(IN ULONG Vector,
 594                              OUT PKINTERRUPT_ROUTINE **FlatDispatch,
 595                              OUT PKINTERRUPT_ROUTINE *NoConnection)
 596 {
 597   UNIMPLEMENTED;
 598   return 0;
 599 }
 600
 601
 602 BOOLEAN
 603 NTAPI
 604 HalTranslateBusAddress(
 605   INTERFACE_TYPE InterfaceType,
 606   ULONG BusNumber,
 607   PHYSICAL_ADDRESS BusAddress,
 608   PULONG AddressSpace,
 609   PPHYSICAL_ADDRESS TranslatedAddress)
 610 {
 611   UNIMPLEMENTED;
 612
 613   return TRUE;
 614 }
 615
 616 #ifndef _M_ARM
 617 VOID
 618 NTAPI
 619 HalpAssignDriveLetters(IN struct _LOADER_PARAMETER_BLOCK *LoaderBlock,
 620                        IN PSTRING NtDeviceName,
 621                        OUT PUCHAR NtSystemPath,
 622                        OUT PSTRING NtSystemPathString)
 623 {
 624     /* Call the kernel */
 625     IoAssignDriveLetters(LoaderBlock,
 626                                 NtDeviceName,
 627                                 NtSystemPath,
 628                                 NtSystemPathString);
 629 }
 630
 631 NTSTATUS
 632 NTAPI
 633 HalpReadPartitionTable(IN PDEVICE_OBJECT DeviceObject,
 634                        IN ULONG SectorSize,
 635                        IN BOOLEAN ReturnRecognizedPartitions,
 636                        IN OUT PDRIVE_LAYOUT_INFORMATION *PartitionBuffer)
 637 {
 638     /* Call the kernel */
 639     return IoReadPartitionTable(DeviceObject,
 640                                 SectorSize,
 641                                 ReturnRecognizedPartitions,
 642                                 PartitionBuffer);
 643 }
 644
 645 NTSTATUS
 646 NTAPI
 647 HalpWritePartitionTable(IN PDEVICE_OBJECT DeviceObject,
 648                         IN ULONG SectorSize,
 649                         IN ULONG SectorsPerTrack,
 650                         IN ULONG NumberOfHeads,
 651                         IN PDRIVE_LAYOUT_INFORMATION PartitionBuffer)
 652 {
 653     /* Call the kernel */
 654     return IoWritePartitionTable(DeviceObject,
 655                                  SectorSize,
 656                                  SectorsPerTrack,
 657                                  NumberOfHeads,
 658                                  PartitionBuffer);
 659 }
 660
 661 NTSTATUS
 662 NTAPI
 663 HalpSetPartitionInformation(IN PDEVICE_OBJECT DeviceObject,
 664                             IN ULONG SectorSize,
 665                             IN ULONG PartitionNumber,
 666                             IN ULONG PartitionType)
 667 {
 668     /* Call the kernel */
 669     return IoSetPartitionInformation(DeviceObject,
 670                                      SectorSize,
 671                                      PartitionNumber,
 672                                      PartitionType);
 673 }
 674 #endif
 675
 676 BOOLEAN
 677 NTAPI
 678 IoFlushAdapterBuffers(
 679   PADAPTER_OBJECT AdapterObject,
 680   PMDL Mdl,
 681   PVOID MapRegisterBase,
 682   PVOID CurrentVa,
 683   ULONG Length,
 684   BOOLEAN WriteToDevice)
 685 {
 686   UNIMPLEMENTED;
 687
 688   return TRUE;
 689 }
 690
 691
 692 VOID
 693 NTAPI
 694 IoFreeAdapterChannel(
 695   PADAPTER_OBJECT AdapterObject)
 696 {
 697   UNIMPLEMENTED;
 698 }
 699
 700
 701 VOID
 702 NTAPI
 703 IoFreeMapRegisters(
 704   PADAPTER_OBJECT AdapterObject,
 705   PVOID MapRegisterBase,
 706   ULONG NumberOfMapRegisters)
 707 {
 708   UNIMPLEMENTED;
 709 }
 710
 711
 712 PHYSICAL_ADDRESS
 713 NTAPI
 714 IoMapTransfer(
 715   PADAPTER_OBJECT AdapterObject,
 716   PMDL Mdl,
 717   PVOID MapRegisterBase,
 718   PVOID CurrentVa,
 719   PULONG Length,
 720   BOOLEAN WriteToDevice)
 721 {
 722   PHYSICAL_ADDRESS Address;
 723
 724   UNIMPLEMENTED;
 725
 726   Address.QuadPart = 0;
 727
 728   return Address;
 729 }
 730
 731
 732 #undef KeAcquireSpinLock
 733 VOID
 734 NTAPI
 735 KeAcquireSpinLock(
 736   PKSPIN_LOCK SpinLock,
 737   PKIRQL OldIrql)
 738 {
 739   UNIMPLEMENTED;
 740 }
 741
 742
 743 KIRQL
 744 FASTCALL
 745 KeAcquireSpinLockRaiseToSynch(
 746   PKSPIN_LOCK SpinLock)
 747 {
 748   UNIMPLEMENTED;
 749
 750   return 0;
 751 }
 752
 753 #ifndef _M_AMD64
 754 VOID
 755 FASTCALL
 756 KeAcquireInStackQueuedSpinLock(
 757     IN PKSPIN_LOCK SpinLock,
 758     IN PKLOCK_QUEUE_HANDLE LockHandle
 759     )
 760 {
 761   UNIMPLEMENTED;
 762 }
 763
 764 VOID
 765 FASTCALL
 766 KeAcquireInStackQueuedSpinLockRaiseToSynch(
 767     IN PKSPIN_LOCK SpinLock,
 768     IN PKLOCK_QUEUE_HANDLE LockHandle
 769     )
 770 {
 771    UNIMPLEMENTED;
 772 }
 773
 774 VOID
 775 FASTCALL
 776 KeReleaseInStackQueuedSpinLock(
 777     IN PKLOCK_QUEUE_HANDLE LockHandle
 778     )
 779 {
 780   UNIMPLEMENTED;
 781 }
 782 #endif
 783
 784 VOID
 785 NTAPI
 786 KeFlushWriteBuffer(VOID)
 787 {
 788   UNIMPLEMENTED;
 789 }
 790
 791 #ifndef _M_AMD64
 792 #undef KeGetCurrentIrql
 793 KIRQL
 794 NTAPI
 795 KeGetCurrentIrql(VOID)
 796 {
 797   UNIMPLEMENTED;
 798
 799   return (KIRQL)0;
 800 }
 801
 802 #undef KeLowerIrql
 803 VOID
 804 NTAPI
 805 KeLowerIrql(
 806   KIRQL NewIrql)
 807 {
 808   UNIMPLEMENTED;
 809 }
 810 #endif
 811
 812
 813 LARGE_INTEGER
 814 NTAPI
 815 KeQueryPerformanceCounter(
 816   PLARGE_INTEGER PerformanceFreq)
 817 {
 818   LARGE_INTEGER Value;
 819
 820   UNIMPLEMENTED;
 821
 822   Value.QuadPart = 0;
 823
 824   return Value;
 825 }
 826
 827 #ifndef _M_AMD64
 828 #undef KeRaiseIrql
 829 VOID
 830 NTAPI
 831 KeRaiseIrql(
 832   KIRQL NewIrql,
 833   PKIRQL OldIrql)
 834 {
 835   UNIMPLEMENTED;
 836 }
 837
 838
 839 KIRQL
 840 NTAPI
 841 KeRaiseIrqlToDpcLevel(VOID)
 842 {
 843   UNIMPLEMENTED;
 844
 845   return (KIRQL)0;
 846 }
 847
 848
 849 KIRQL
 850 NTAPI
 851 KeRaiseIrqlToSynchLevel(VOID)
 852 {
 853   UNIMPLEMENTED;
 854
 855   return (KIRQL)0;
 856 }
 857 #endif
 858
 859 #ifndef _M_AMD64
 860 #undef KeReleaseSpinLock
 861 VOID
 862 NTAPI
 863 KeReleaseSpinLock(
 864   PKSPIN_LOCK SpinLock,
 865   KIRQL NewIrql)
 866 {
 867   UNIMPLEMENTED;
 868 }
 869 #endif
 870
 871 VOID
 872 NTAPI
 873 KeStallExecutionProcessor(
 874   ULONG Microseconds)
 875 {
 876   UNIMPLEMENTED;
 877 }
 878
 879
 880 LOGICAL
 881 FASTCALL
 882 KeTryToAcquireQueuedSpinLock(
 883   KSPIN_LOCK_QUEUE_NUMBER LockNumber,
 884   PKIRQL OldIrql)
 885 {
 886   UNIMPLEMENTED;
 887
 888   return FALSE;
 889 }
 890
 891
 892 BOOLEAN
 893 FASTCALL
 894 KeTryToAcquireQueuedSpinLockRaiseToSynch(
 895   KSPIN_LOCK_QUEUE_NUMBER LockNumber,
 896   PKIRQL OldIrql)
 897 {
 898   UNIMPLEMENTED;
 899
 900   return FALSE;
 901 }
 902
 903 #if !defined(_M_AMD64)
 904 KIRQL
 905 FASTCALL
 906 KfAcquireSpinLock(
 907   PKSPIN_LOCK SpinLock)
 908 {
 909   UNIMPLEMENTED;
 910
 911   return (KIRQL)0;
 912 }
 913
 914
 915 VOID
 916 FASTCALL
 917 KfLowerIrql(
 918   KIRQL NewIrql)
 919 {
 920   UNIMPLEMENTED;
 921 }
 922
 923
 924 KIRQL
 925 FASTCALL
 926 KfRaiseIrql(
 927   KIRQL NewIrql)
 928 {
 929   UNIMPLEMENTED;
 930
 931   return (KIRQL)0;
 932 }
 933
 934
 935 VOID
 936 FASTCALL
 937 KfReleaseSpinLock(
 938   PKSPIN_LOCK SpinLock,
 939   KIRQL NewIrql)
 940 {
 941   UNIMPLEMENTED;
 942 }
 943 #endif
 944
 945 #if !defined(_M_AMD64)
 946 VOID
 947 NTAPI
 948 READ_PORT_BUFFER_UCHAR(
 949   PUCHAR Port,
 950   PUCHAR Buffer,
 951   ULONG Count)
 952 {
 953   UNIMPLEMENTED;
 954 }
 955
 956
 957 VOID
 958 NTAPI
 959 READ_PORT_BUFFER_ULONG(
 960   PULONG Port,
 961   PULONG Buffer,
 962   ULONG Count)
 963 {
 964   UNIMPLEMENTED;
 965 }
 966
 967
 968 VOID
 969 NTAPI
 970 READ_PORT_BUFFER_USHORT(
 971   PUSHORT Port,
 972   PUSHORT Buffer,
 973   ULONG Count)
 974 {
 975   UNIMPLEMENTED;
 976 }
 977
 978
 979 UCHAR
 980 NTAPI
 981 READ_PORT_UCHAR(
 982   PUCHAR Port)
 983 {
 984   UNIMPLEMENTED;
 985
 986   return 0;
 987 }
 988
 989
 990 ULONG
 991 NTAPI
 992 READ_PORT_ULONG(
 993   PULONG Port)
 994 {
 995   UNIMPLEMENTED;
 996
 997   return 0;
 998 }
 999
1000
1001 USHORT
1002 NTAPI
1003 READ_PORT_USHORT(
1004   PUSHORT Port)
1005 {
1006   UNIMPLEMENTED;
1007
1008   return 0;
1009 }
1010
1011
1012 VOID
1013 NTAPI
1014 WRITE_PORT_BUFFER_UCHAR(
1015   PUCHAR Port,
1016   PUCHAR Buffer,
1017   ULONG Count)
1018 {
1019   UNIMPLEMENTED;
1020 }
1021
1022
1023 VOID
1024 NTAPI
1025 WRITE_PORT_BUFFER_USHORT(
1026   PUSHORT Port,
1027   PUSHORT Buffer,
1028   ULONG Count)
1029 {
1030   UNIMPLEMENTED;
1031 }
1032
1033
1034 VOID
1035 NTAPI
1036 WRITE_PORT_BUFFER_ULONG(
1037   PULONG Port,
1038   PULONG Buffer,
1039   ULONG Count)
1040 {
1041   UNIMPLEMENTED;
1042 }
1043
1044
1045 VOID
1046 NTAPI
1047 WRITE_PORT_UCHAR(
1048   PUCHAR Port,
1049   UCHAR Value)
1050 {
1051   UNIMPLEMENTED;
1052 }
1053
1054 VOID
1055 NTAPI
1056 WRITE_PORT_ULONG(
1057   PULONG Port,
1058   ULONG Value)
1059 {
1060   UNIMPLEMENTED;
1061 }
1062
1063 VOID
1064 NTAPI
1065 WRITE_PORT_USHORT(
1066   PUSHORT Port,
1067   USHORT Value)
1068 {
1069   UNIMPLEMENTED;
1070 }
1071 #endif
1072
1073 KIRQL
1074 FASTCALL
1075 KeAcquireQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle)
1076 {
1077   UNIMPLEMENTED;
1078   return (KIRQL)0;
1079 }
1080
1081 KIRQL
1082 FASTCALL
1083 KeAcquireQueuedSpinLockRaiseToSynch(IN PKLOCK_QUEUE_HANDLE LockHandle)
1084 {
1085     UNIMPLEMENTED;
1086     return (KIRQL)0;
1087 }
1088
1089 VOID
1090 FASTCALL
1091 KeReleaseQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle,
1092                         IN KIRQL OldIrql)
1093 {
1094   UNIMPLEMENTED;
1095 }
1096
1097 VOID
1098 HalSweepDcache(VOID)
1099 {
1100   UNIMPLEMENTED;
1101 }
1102
1103 VOID
1104 HalSweepIcache(VOID)
1105 {
1106     UNIMPLEMENTED;
1107 }
1108
1109 ULONG
1110 HalGetInterruptSource(VOID)
1111 {
1112     UNIMPLEMENTED;
1113     return 0;
1114 }
1115
1116 #ifdef _X86BIOS_
1117 NTSTATUS
1118 NTAPI
1119 x86BiosAllocateBuffer (
1120     ULONG *Size,
1121     USHORT *Segment,
1122     USHORT *Offset)
1123 {
1124     UNIMPLEMENTED;
1125     return STATUS_UNSUCCESSFUL;;
1126
1127 }
1128
1129 BOOLEAN
1130 NTAPI
1131 x86BiosCall (
1132     ULONG InterruptNumber,
1133     X86_BIOS_REGISTERS *Registers)
1134 {
1135     UNIMPLEMENTED;
1136     return FALSE;
1137 }
1138
1139 NTSTATUS
1140 NTAPI
1141 x86BiosFreeBuffer (
1142     USHORT Segment,
1143     USHORT Offset)
1144 {
1145     UNIMPLEMENTED;
1146     return STATUS_UNSUCCESSFUL;;
1147 }
1148
1149 NTSTATUS
1150 x86BiosReadMemory (
1151     USHORT Segment,
1152     USHORT Offset,
1153     PVOID Buffer,
1154     ULONG Size)
1155 {
1156     UNIMPLEMENTED;
1157     return STATUS_UNSUCCESSFUL;;
1158 }
1159
1160 NTSTATUS
1161 NTAPI
1162 x86BiosWriteMemory (
1163     USHORT Segment,
1164     USHORT Offset,
1165     PVOID Buffer,
1166     ULONG Size)
1167 {
1168     UNIMPLEMENTED;
1169     return STATUS_UNSUCCESSFUL;;
1170 }
1171 #endif
1172
1173 /* EOF */