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