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