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
 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 VOID
 217 NTAPI
 218 HalDisableSystemInterrupt(ULONG Vector,
 219                           KIRQL Irql)
 220 {
 221     UNIMPLEMENTED;
 222 }
 223
 224
 225 VOID
 226 NTAPI
 227 HalDisplayString(
 228   PCH String)
 229 {
 230   UNIMPLEMENTED;
 231 }
 232
 233
 234 BOOLEAN
 235 NTAPI
 236 HalEnableSystemInterrupt(
 237   ULONG Vector,
 238   KIRQL Irql,
 239   KINTERRUPT_MODE InterruptMode)
 240 {
 241   UNIMPLEMENTED;
 242
 243   return TRUE;
 244 }
 245
 246
 247 VOID
 248 NTAPI
 249 HalEndSystemInterrupt(
 250   KIRQL Irql,
 251   ULONG Unknown2)
 252 {
 253   UNIMPLEMENTED;
 254 }
 255
 256
 257 BOOLEAN
 258 NTAPI
 259 HalFlushCommonBuffer(
 260   ULONG Unknown1,
 261   ULONG Unknown2,
 262   ULONG Unknown3,
 263   ULONG Unknown4,
 264   ULONG Unknown5)
 265 {
 266   UNIMPLEMENTED;
 267
 268    return TRUE;
 269 }
 270
 271
 272 VOID
 273 NTAPI
 274 HalFreeCommonBuffer(
 275   PADAPTER_OBJECT AdapterObject,
 276   ULONG Length,
 277   PHYSICAL_ADDRESS LogicalAddress,
 278   PVOID VirtualAddress,
 279   BOOLEAN CacheEnabled)
 280 {
 281   UNIMPLEMENTED;
 282 }
 283
 284
 285 PADAPTER_OBJECT
 286 NTAPI
 287 HalGetAdapter(
 288   PDEVICE_DESCRIPTION DeviceDescription,
 289   PULONG NumberOfMapRegisters)
 290 {
 291   UNIMPLEMENTED;
 292
 293   return (PADAPTER_OBJECT)NULL;
 294 }
 295
 296
 297 ULONG
 298 NTAPI
 299 HalGetBusData(
 300   BUS_DATA_TYPE BusDataType,
 301   ULONG BusNumber,
 302   ULONG SlotNumber,
 303   PVOID Buffer,
 304   ULONG Length)
 305 {
 306   UNIMPLEMENTED;
 307
 308   return 0;
 309 }
 310
 311
 312 ULONG
 313 NTAPI
 314 HalGetBusDataByOffset(
 315   BUS_DATA_TYPE BusDataType,
 316   ULONG BusNumber,
 317   ULONG SlotNumber,
 318   PVOID Buffer,
 319   ULONG Offset,
 320   ULONG Length)
 321 {
 322   UNIMPLEMENTED;
 323
 324   return 0;
 325 }
 326
 327
 328 ARC_STATUS
 329 NTAPI
 330 HalGetEnvironmentVariable(
 331   PCH Name,
 332   USHORT ValueLength,
 333   PCH Value)
 334 {
 335   UNIMPLEMENTED;
 336
 337   return ENOENT;
 338 }
 339
 340
 341 ULONG
 342 NTAPI
 343 HalGetInterruptVector(
 344   INTERFACE_TYPE InterfaceType,
 345   ULONG BusNumber,
 346   ULONG BusInterruptLevel,
 347   ULONG BusInterruptVector,
 348   PKIRQL Irql,
 349   PKAFFINITY Affinity)
 350 {
 351   UNIMPLEMENTED;
 352
 353   return 0;
 354 }
 355
 356
 357 VOID
 358 NTAPI
 359 HalHandleNMI(
 360   PVOID NmiData)
 361 {
 362   UNIMPLEMENTED;
 363 }
 364
 365
 366 BOOLEAN
 367 NTAPI
 368 HalInitSystem(
 369   ULONG BootPhase,
 370   PLOADER_PARAMETER_BLOCK LoaderBlock)
 371 {
 372   UNIMPLEMENTED;
 373
 374   return TRUE;
 375 }
 376
 377
 378 VOID
 379 NTAPI
 380 HalInitializeProcessor(ULONG ProcessorNumber,
 381                        PLOADER_PARAMETER_BLOCK LoaderBlock)
 382 {
 383   UNIMPLEMENTED;
 384 }
 385
 386
 387 BOOLEAN
 388 NTAPI
 389 HalMakeBeep(
 390   ULONG Frequency)
 391 {
 392   UNIMPLEMENTED;
 393
 394   return TRUE;
 395 }
 396
 397
 398 VOID
 399 NTAPI
 400 HalProcessorIdle(VOID)
 401 {
 402   UNIMPLEMENTED;
 403 }
 404
 405
 406 BOOLEAN
 407 NTAPI
 408 HalQueryDisplayOwnership(VOID)
 409 {
 410   UNIMPLEMENTED;
 411
 412   return FALSE;
 413 }
 414
 415
 416 VOID
 417 NTAPI
 418 HalQueryDisplayParameters(
 419   OUT PULONG DispSizeX,
 420   OUT PULONG DispSizeY,
 421   OUT PULONG CursorPosX,
 422   OUT PULONG CursorPosY)
 423 {
 424   UNIMPLEMENTED;
 425 }
 426
 427
 428 BOOLEAN
 429 NTAPI
 430 HalQueryRealTimeClock(
 431   PTIME_FIELDS Time)
 432 {
 433   UNIMPLEMENTED;
 434   return FALSE;
 435 }
 436
 437
 438 ULONG
 439 NTAPI
 440 HalReadDmaCounter(
 441   PADAPTER_OBJECT AdapterObject)
 442 {
 443   UNIMPLEMENTED;
 444
 445   return 0;
 446 }
 447
 448
 449 VOID
 450 NTAPI
 451 HalReleaseDisplayOwnership(VOID)
 452 {
 453   UNIMPLEMENTED;
 454 }
 455
 456 VOID
 457 NTAPI
 458 HalReportResourceUsage(VOID)
 459 {
 460   UNIMPLEMENTED;
 461 }
 462
 463
 464 VOID
 465 NTAPI
 466 HalRequestIpi(
 467     KAFFINITY TargetSet)
 468 {
 469   UNIMPLEMENTED;
 470 }
 471
 472
 473 VOID
 474 FASTCALL
 475 HalRequestSoftwareInterrupt(
 476   KIRQL Request)
 477 {
 478   UNIMPLEMENTED;
 479 }
 480
 481 VOID FASTCALL
 482 HalClearSoftwareInterrupt(
 483   IN KIRQL Request)
 484 {
 485   UNIMPLEMENTED;
 486 }
 487
 488
 489 VOID
 490 NTAPI
 491 HalReturnToFirmware(
 492   FIRMWARE_REENTRY Action)
 493 {
 494   UNIMPLEMENTED;
 495 }
 496
 497
 498 ULONG
 499 NTAPI
 500 HalSetBusData(
 501   BUS_DATA_TYPE BusDataType,
 502   ULONG BusNumber,
 503   ULONG SlotNumber,
 504   PVOID Buffer,
 505   ULONG Length)
 506 {
 507   UNIMPLEMENTED;
 508
 509   return 0;
 510 }
 511
 512
 513 ULONG
 514 NTAPI
 515 HalSetBusDataByOffset(
 516   BUS_DATA_TYPE BusDataType,
 517   ULONG BusNumber,
 518   ULONG SlotNumber,
 519   PVOID Buffer,
 520   ULONG Offset,
 521   ULONG Length)
 522 {
 523   UNIMPLEMENTED;
 524
 525   return 0;
 526 }
 527
 528
 529 VOID
 530 NTAPI
 531 HalSetDisplayParameters(
 532   ULONG CursorPosX,
 533   ULONG CursorPosY)
 534 {
 535   UNIMPLEMENTED;
 536 }
 537
 538
 539 ARC_STATUS
 540 NTAPI
 541 HalSetEnvironmentVariable(
 542   PCH Name,
 543   PCH Value)
 544 {
 545   UNIMPLEMENTED;
 546
 547   return ESUCCESS;
 548 }
 549
 550
 551 BOOLEAN
 552 NTAPI
 553 HalSetRealTimeClock(
 554   PTIME_FIELDS Time)
 555 {
 556   UNIMPLEMENTED;
 557
 558   return TRUE;
 559 }
 560
 561
 562 ULONG
 563 NTAPI
 564 HalSetTimeIncrement(
 565   ULONG Increment)
 566 {
 567   UNIMPLEMENTED;
 568
 569   return Increment;
 570 }
 571
 572
 573 BOOLEAN
 574 NTAPI
 575 HalStartNextProcessor(IN PLOADER_PARAMETER_BLOCK LoaderBlock,
 576                       IN PKPROCESSOR_STATE ProcessorState)
 577 {
 578   UNIMPLEMENTED;
 579
 580   return TRUE;
 581 }
 582
 583
 584 UCHAR
 585 FASTCALL
 586 HalSystemVectorDispatchEntry(IN ULONG Vector,
 587                              OUT PKINTERRUPT_ROUTINE **FlatDispatch,
 588                              OUT PKINTERRUPT_ROUTINE *NoConnection)
 589 {
 590   UNIMPLEMENTED;
 591   return 0;
 592 }
 593
 594
 595 BOOLEAN
 596 NTAPI
 597 HalTranslateBusAddress(
 598   INTERFACE_TYPE InterfaceType,
 599   ULONG BusNumber,
 600   PHYSICAL_ADDRESS BusAddress,
 601   PULONG AddressSpace,
 602   PPHYSICAL_ADDRESS TranslatedAddress)
 603 {
 604   UNIMPLEMENTED;
 605
 606   return TRUE;
 607 }
 608
 609 #ifndef _M_ARM
 610 VOID
 611 NTAPI
 612 HalpAssignDriveLetters(IN struct _LOADER_PARAMETER_BLOCK *LoaderBlock,
 613                        IN PSTRING NtDeviceName,
 614                        OUT PUCHAR NtSystemPath,
 615                        OUT PSTRING NtSystemPathString)
 616 {
 617     /* Call the kernel */
 618     IoAssignDriveLetters(LoaderBlock,
 619                                 NtDeviceName,
 620                                 NtSystemPath,
 621                                 NtSystemPathString);
 622 }
 623
 624 NTSTATUS
 625 NTAPI
 626 HalpReadPartitionTable(IN PDEVICE_OBJECT DeviceObject,
 627                        IN ULONG SectorSize,
 628                        IN BOOLEAN ReturnRecognizedPartitions,
 629                        IN OUT PDRIVE_LAYOUT_INFORMATION *PartitionBuffer)
 630 {
 631     /* Call the kernel */
 632     return IoReadPartitionTable(DeviceObject,
 633                                 SectorSize,
 634                                 ReturnRecognizedPartitions,
 635                                 PartitionBuffer);
 636 }
 637
 638 NTSTATUS
 639 NTAPI
 640 HalpWritePartitionTable(IN PDEVICE_OBJECT DeviceObject,
 641                         IN ULONG SectorSize,
 642                         IN ULONG SectorsPerTrack,
 643                         IN ULONG NumberOfHeads,
 644                         IN PDRIVE_LAYOUT_INFORMATION PartitionBuffer)
 645 {
 646     /* Call the kernel */
 647     return IoWritePartitionTable(DeviceObject,
 648                                  SectorSize,
 649                                  SectorsPerTrack,
 650                                  NumberOfHeads,
 651                                  PartitionBuffer);
 652 }
 653
 654 NTSTATUS
 655 NTAPI
 656 HalpSetPartitionInformation(IN PDEVICE_OBJECT DeviceObject,
 657                             IN ULONG SectorSize,
 658                             IN ULONG PartitionNumber,
 659                             IN ULONG PartitionType)
 660 {
 661     /* Call the kernel */
 662     return IoSetPartitionInformation(DeviceObject,
 663                                      SectorSize,
 664                                      PartitionNumber,
 665                                      PartitionType);
 666 }
 667 #endif
 668
 669 BOOLEAN
 670 NTAPI
 671 IoFlushAdapterBuffers(
 672   PADAPTER_OBJECT AdapterObject,
 673   PMDL Mdl,
 674   PVOID MapRegisterBase,
 675   PVOID CurrentVa,
 676   ULONG Length,
 677   BOOLEAN WriteToDevice)
 678 {
 679   UNIMPLEMENTED;
 680
 681   return TRUE;
 682 }
 683
 684
 685 VOID
 686 NTAPI
 687 IoFreeAdapterChannel(
 688   PADAPTER_OBJECT AdapterObject)
 689 {
 690   UNIMPLEMENTED;
 691 }
 692
 693
 694 VOID
 695 NTAPI
 696 IoFreeMapRegisters(
 697   PADAPTER_OBJECT AdapterObject,
 698   PVOID MapRegisterBase,
 699   ULONG NumberOfMapRegisters)
 700 {
 701   UNIMPLEMENTED;
 702 }
 703
 704
 705 PHYSICAL_ADDRESS
 706 NTAPI
 707 IoMapTransfer(
 708   PADAPTER_OBJECT AdapterObject,
 709   PMDL Mdl,
 710   PVOID MapRegisterBase,
 711   PVOID CurrentVa,
 712   PULONG Length,
 713   BOOLEAN WriteToDevice)
 714 {
 715   PHYSICAL_ADDRESS Address;
 716
 717   UNIMPLEMENTED;
 718
 719   Address.QuadPart = 0;
 720
 721   return Address;
 722 }
 723
 724
 725 #undef KeAcquireSpinLock
 726 VOID
 727 NTAPI
 728 KeAcquireSpinLock(
 729   PKSPIN_LOCK SpinLock,
 730   PKIRQL OldIrql)
 731 {
 732   UNIMPLEMENTED;
 733 }
 734
 735
 736 KIRQL
 737 FASTCALL
 738 KeAcquireSpinLockRaiseToSynch(
 739   PKSPIN_LOCK SpinLock)
 740 {
 741   UNIMPLEMENTED;
 742
 743   return 0;
 744 }
 745
 746 #ifndef _M_AMD64
 747 VOID
 748 FASTCALL
 749 KeAcquireInStackQueuedSpinLock(
 750     IN PKSPIN_LOCK SpinLock,
 751     IN PKLOCK_QUEUE_HANDLE LockHandle
 752     )
 753 {
 754   UNIMPLEMENTED;
 755 }
 756
 757 VOID
 758 FASTCALL
 759 KeAcquireInStackQueuedSpinLockRaiseToSynch(
 760     IN PKSPIN_LOCK SpinLock,
 761     IN PKLOCK_QUEUE_HANDLE LockHandle
 762     )
 763 {
 764    UNIMPLEMENTED;
 765 }
 766
 767 VOID
 768 FASTCALL
 769 KeReleaseInStackQueuedSpinLock(
 770     IN PKLOCK_QUEUE_HANDLE LockHandle
 771     )
 772 {
 773   UNIMPLEMENTED;
 774 }
 775 #endif
 776
 777 VOID
 778 NTAPI
 779 KeFlushWriteBuffer(VOID)
 780 {
 781   UNIMPLEMENTED;
 782 }
 783
 784 #ifndef _M_AMD64
 785 #undef KeGetCurrentIrql
 786 KIRQL
 787 NTAPI
 788 KeGetCurrentIrql(VOID)
 789 {
 790   UNIMPLEMENTED;
 791
 792   return (KIRQL)0;
 793 }
 794
 795 #undef KeLowerIrql
 796 VOID
 797 NTAPI
 798 KeLowerIrql(
 799   KIRQL NewIrql)
 800 {
 801   UNIMPLEMENTED;
 802 }
 803 #endif
 804
 805
 806 LARGE_INTEGER
 807 NTAPI
 808 KeQueryPerformanceCounter(
 809   PLARGE_INTEGER PerformanceFreq)
 810 {
 811   LARGE_INTEGER Value;
 812
 813   UNIMPLEMENTED;
 814
 815   Value.QuadPart = 0;
 816
 817   return Value;
 818 }
 819
 820 #ifndef _M_AMD64
 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 #endif
 851
 852 #ifndef _M_AMD64
 853 #undef KeReleaseSpinLock
 854 VOID
 855 NTAPI
 856 KeReleaseSpinLock(
 857   PKSPIN_LOCK SpinLock,
 858   KIRQL NewIrql)
 859 {
 860   UNIMPLEMENTED;
 861 }
 862 #endif
 863
 864 VOID
 865 NTAPI
 866 KeStallExecutionProcessor(
 867   ULONG Microseconds)
 868 {
 869   UNIMPLEMENTED;
 870 }
 871
 872
 873 LOGICAL
 874 FASTCALL
 875 KeTryToAcquireQueuedSpinLock(
 876   KSPIN_LOCK_QUEUE_NUMBER LockNumber,
 877   PKIRQL OldIrql)
 878 {
 879   UNIMPLEMENTED;
 880
 881   return FALSE;
 882 }
 883
 884
 885 BOOLEAN
 886 FASTCALL
 887 KeTryToAcquireQueuedSpinLockRaiseToSynch(
 888   KSPIN_LOCK_QUEUE_NUMBER LockNumber,
 889   PKIRQL OldIrql)
 890 {
 891   UNIMPLEMENTED;
 892
 893   return FALSE;
 894 }
 895
 896 #if !defined(_M_AMD64)
 897 KIRQL
 898 FASTCALL
 899 KfAcquireSpinLock(
 900   PKSPIN_LOCK SpinLock)
 901 {
 902   UNIMPLEMENTED;
 903
 904   return (KIRQL)0;
 905 }
 906
 907
 908 VOID
 909 FASTCALL
 910 KfLowerIrql(
 911   KIRQL NewIrql)
 912 {
 913   UNIMPLEMENTED;
 914 }
 915
 916
 917 KIRQL
 918 FASTCALL
 919 KfRaiseIrql(
 920   KIRQL NewIrql)
 921 {
 922   UNIMPLEMENTED;
 923
 924   return (KIRQL)0;
 925 }
 926
 927
 928 VOID
 929 FASTCALL
 930 KfReleaseSpinLock(
 931   PKSPIN_LOCK SpinLock,
 932   KIRQL NewIrql)
 933 {
 934   UNIMPLEMENTED;
 935 }
 936 #endif
 937
 938 #if !defined(_M_AMD64)
 939 VOID
 940 NTAPI
 941 READ_PORT_BUFFER_UCHAR(
 942   PUCHAR Port,
 943   PUCHAR Buffer,
 944   ULONG Count)
 945 {
 946   UNIMPLEMENTED;
 947 }
 948
 949
 950 VOID
 951 NTAPI
 952 READ_PORT_BUFFER_ULONG(
 953   PULONG Port,
 954   PULONG Buffer,
 955   ULONG Count)
 956 {
 957   UNIMPLEMENTED;
 958 }
 959
 960
 961 VOID
 962 NTAPI
 963 READ_PORT_BUFFER_USHORT(
 964   PUSHORT Port,
 965   PUSHORT Buffer,
 966   ULONG Count)
 967 {
 968   UNIMPLEMENTED;
 969 }
 970
 971
 972 UCHAR
 973 NTAPI
 974 READ_PORT_UCHAR(
 975   PUCHAR Port)
 976 {
 977   UNIMPLEMENTED;
 978
 979   return 0;
 980 }
 981
 982
 983 ULONG
 984 NTAPI
 985 READ_PORT_ULONG(
 986   PULONG Port)
 987 {
 988   UNIMPLEMENTED;
 989
 990   return 0;
 991 }
 992
 993
 994 USHORT
 995 NTAPI
 996 READ_PORT_USHORT(
 997   PUSHORT Port)
 998 {
 999   UNIMPLEMENTED;
1000
1001   return 0;
1002 }
1003
1004
1005 VOID
1006 NTAPI
1007 WRITE_PORT_BUFFER_UCHAR(
1008   PUCHAR Port,
1009   PUCHAR Buffer,
1010   ULONG Count)
1011 {
1012   UNIMPLEMENTED;
1013 }
1014
1015
1016 VOID
1017 NTAPI
1018 WRITE_PORT_BUFFER_USHORT(
1019   PUSHORT Port,
1020   PUSHORT Buffer,
1021   ULONG Count)
1022 {
1023   UNIMPLEMENTED;
1024 }
1025
1026
1027 VOID
1028 NTAPI
1029 WRITE_PORT_BUFFER_ULONG(
1030   PULONG Port,
1031   PULONG Buffer,
1032   ULONG Count)
1033 {
1034   UNIMPLEMENTED;
1035 }
1036
1037
1038 VOID
1039 NTAPI
1040 WRITE_PORT_UCHAR(
1041   PUCHAR Port,
1042   UCHAR Value)
1043 {
1044   UNIMPLEMENTED;
1045 }
1046
1047 VOID
1048 NTAPI
1049 WRITE_PORT_ULONG(
1050   PULONG Port,
1051   ULONG Value)
1052 {
1053   UNIMPLEMENTED;
1054 }
1055
1056 VOID
1057 NTAPI
1058 WRITE_PORT_USHORT(
1059   PUSHORT Port,
1060   USHORT Value)
1061 {
1062   UNIMPLEMENTED;
1063 }
1064 #endif
1065
1066 KIRQL
1067 FASTCALL
1068 KeAcquireQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle)
1069 {
1070   UNIMPLEMENTED;
1071   return (KIRQL)0;
1072 }
1073
1074 KIRQL
1075 FASTCALL
1076 KeAcquireQueuedSpinLockRaiseToSynch(IN PKLOCK_QUEUE_HANDLE LockHandle)
1077 {
1078     UNIMPLEMENTED;
1079     return (KIRQL)0;
1080 }
1081
1082 VOID
1083 FASTCALL
1084 KeReleaseQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle,
1085                         IN KIRQL OldIrql)
1086 {
1087   UNIMPLEMENTED;
1088 }
1089
1090 VOID
1091 HalSweepDcache(VOID)
1092 {
1093   UNIMPLEMENTED;
1094 }
1095
1096 VOID
1097 HalSweepIcache(VOID)
1098 {
1099     UNIMPLEMENTED;
1100 }
1101
1102 ULONG
1103 HalGetInterruptSource(VOID)
1104 {
1105     UNIMPLEMENTED;
1106     return 0;
1107 }
1108
1109 /* EOF */