Sync to trunk head (r42241)
[reactos.git] / 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 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 KAFFINITY TargetSet)
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 #ifndef _M_ARM
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 #endif
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 #undef KeAcquireSpinLock
731 VOID
732 NTAPI
733 KeAcquireSpinLock(
734 PKSPIN_LOCK SpinLock,
735 PKIRQL OldIrql)
736 {
737 UNIMPLEMENTED;
738 }
739
740
741 KIRQL
742 FASTCALL
743 KeAcquireSpinLockRaiseToSynch(
744 PKSPIN_LOCK SpinLock)
745 {
746 UNIMPLEMENTED;
747
748 return 0;
749 }
750
751 #ifndef _M_AMD64
752 VOID
753 FASTCALL
754 KeAcquireInStackQueuedSpinLock(
755 IN PKSPIN_LOCK SpinLock,
756 IN PKLOCK_QUEUE_HANDLE LockHandle
757 )
758 {
759 UNIMPLEMENTED;
760 }
761
762 VOID
763 FASTCALL
764 KeAcquireInStackQueuedSpinLockRaiseToSynch(
765 IN PKSPIN_LOCK SpinLock,
766 IN PKLOCK_QUEUE_HANDLE LockHandle
767 )
768 {
769 UNIMPLEMENTED;
770 }
771
772 VOID
773 FASTCALL
774 KeReleaseInStackQueuedSpinLock(
775 IN PKLOCK_QUEUE_HANDLE LockHandle
776 )
777 {
778 UNIMPLEMENTED;
779 }
780 #endif
781
782 VOID
783 NTAPI
784 KeFlushWriteBuffer(VOID)
785 {
786 UNIMPLEMENTED;
787 }
788
789 #ifndef _M_AMD64
790 #undef KeGetCurrentIrql
791 KIRQL
792 NTAPI
793 KeGetCurrentIrql(VOID)
794 {
795 UNIMPLEMENTED;
796
797 return (KIRQL)0;
798 }
799
800 #undef KeLowerIrql
801 VOID
802 NTAPI
803 KeLowerIrql(
804 KIRQL NewIrql)
805 {
806 UNIMPLEMENTED;
807 }
808 #endif
809
810
811 LARGE_INTEGER
812 NTAPI
813 KeQueryPerformanceCounter(
814 PLARGE_INTEGER PerformanceFreq)
815 {
816 LARGE_INTEGER Value;
817
818 UNIMPLEMENTED;
819
820 Value.QuadPart = 0;
821
822 return Value;
823 }
824
825 #ifndef _M_AMD64
826 #undef KeRaiseIrql
827 VOID
828 NTAPI
829 KeRaiseIrql(
830 KIRQL NewIrql,
831 PKIRQL OldIrql)
832 {
833 UNIMPLEMENTED;
834 }
835
836
837 KIRQL
838 NTAPI
839 KeRaiseIrqlToDpcLevel(VOID)
840 {
841 UNIMPLEMENTED;
842
843 return (KIRQL)0;
844 }
845
846
847 KIRQL
848 NTAPI
849 KeRaiseIrqlToSynchLevel(VOID)
850 {
851 UNIMPLEMENTED;
852
853 return (KIRQL)0;
854 }
855 #endif
856
857 #ifndef _M_AMD64
858 #undef KeReleaseSpinLock
859 VOID
860 NTAPI
861 KeReleaseSpinLock(
862 PKSPIN_LOCK SpinLock,
863 KIRQL NewIrql)
864 {
865 UNIMPLEMENTED;
866 }
867 #endif
868
869 VOID
870 NTAPI
871 KeStallExecutionProcessor(
872 ULONG Microseconds)
873 {
874 UNIMPLEMENTED;
875 }
876
877
878 LOGICAL
879 FASTCALL
880 KeTryToAcquireQueuedSpinLock(
881 KSPIN_LOCK_QUEUE_NUMBER LockNumber,
882 PKIRQL OldIrql)
883 {
884 UNIMPLEMENTED;
885
886 return FALSE;
887 }
888
889
890 BOOLEAN
891 FASTCALL
892 KeTryToAcquireQueuedSpinLockRaiseToSynch(
893 KSPIN_LOCK_QUEUE_NUMBER LockNumber,
894 PKIRQL OldIrql)
895 {
896 UNIMPLEMENTED;
897
898 return FALSE;
899 }
900
901 #if !defined(_M_AMD64)
902 KIRQL
903 FASTCALL
904 KfAcquireSpinLock(
905 PKSPIN_LOCK SpinLock)
906 {
907 UNIMPLEMENTED;
908
909 return (KIRQL)0;
910 }
911
912
913 VOID
914 FASTCALL
915 KfLowerIrql(
916 KIRQL NewIrql)
917 {
918 UNIMPLEMENTED;
919 }
920
921
922 KIRQL
923 FASTCALL
924 KfRaiseIrql(
925 KIRQL NewIrql)
926 {
927 UNIMPLEMENTED;
928
929 return (KIRQL)0;
930 }
931
932
933 VOID
934 FASTCALL
935 KfReleaseSpinLock(
936 PKSPIN_LOCK SpinLock,
937 KIRQL NewIrql)
938 {
939 UNIMPLEMENTED;
940 }
941 #endif
942
943 #if !defined(_M_AMD64)
944 VOID
945 NTAPI
946 READ_PORT_BUFFER_UCHAR(
947 PUCHAR Port,
948 PUCHAR Buffer,
949 ULONG Count)
950 {
951 UNIMPLEMENTED;
952 }
953
954
955 VOID
956 NTAPI
957 READ_PORT_BUFFER_ULONG(
958 PULONG Port,
959 PULONG Buffer,
960 ULONG Count)
961 {
962 UNIMPLEMENTED;
963 }
964
965
966 VOID
967 NTAPI
968 READ_PORT_BUFFER_USHORT(
969 PUSHORT Port,
970 PUSHORT Buffer,
971 ULONG Count)
972 {
973 UNIMPLEMENTED;
974 }
975
976
977 UCHAR
978 NTAPI
979 READ_PORT_UCHAR(
980 PUCHAR Port)
981 {
982 UNIMPLEMENTED;
983
984 return 0;
985 }
986
987
988 ULONG
989 NTAPI
990 READ_PORT_ULONG(
991 PULONG Port)
992 {
993 UNIMPLEMENTED;
994
995 return 0;
996 }
997
998
999 USHORT
1000 NTAPI
1001 READ_PORT_USHORT(
1002 PUSHORT Port)
1003 {
1004 UNIMPLEMENTED;
1005
1006 return 0;
1007 }
1008
1009
1010 VOID
1011 NTAPI
1012 WRITE_PORT_BUFFER_UCHAR(
1013 PUCHAR Port,
1014 PUCHAR Buffer,
1015 ULONG Count)
1016 {
1017 UNIMPLEMENTED;
1018 }
1019
1020
1021 VOID
1022 NTAPI
1023 WRITE_PORT_BUFFER_USHORT(
1024 PUSHORT Port,
1025 PUSHORT Buffer,
1026 ULONG Count)
1027 {
1028 UNIMPLEMENTED;
1029 }
1030
1031
1032 VOID
1033 NTAPI
1034 WRITE_PORT_BUFFER_ULONG(
1035 PULONG Port,
1036 PULONG Buffer,
1037 ULONG Count)
1038 {
1039 UNIMPLEMENTED;
1040 }
1041
1042
1043 VOID
1044 NTAPI
1045 WRITE_PORT_UCHAR(
1046 PUCHAR Port,
1047 UCHAR Value)
1048 {
1049 UNIMPLEMENTED;
1050 }
1051
1052 VOID
1053 NTAPI
1054 WRITE_PORT_ULONG(
1055 PULONG Port,
1056 ULONG Value)
1057 {
1058 UNIMPLEMENTED;
1059 }
1060
1061 VOID
1062 NTAPI
1063 WRITE_PORT_USHORT(
1064 PUSHORT Port,
1065 USHORT Value)
1066 {
1067 UNIMPLEMENTED;
1068 }
1069 #endif
1070
1071 KIRQL
1072 FASTCALL
1073 KeAcquireQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle)
1074 {
1075 UNIMPLEMENTED;
1076 return (KIRQL)0;
1077 }
1078
1079 KIRQL
1080 FASTCALL
1081 KeAcquireQueuedSpinLockRaiseToSynch(IN PKLOCK_QUEUE_HANDLE LockHandle)
1082 {
1083 UNIMPLEMENTED;
1084 return (KIRQL)0;
1085 }
1086
1087 VOID
1088 FASTCALL
1089 KeReleaseQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle,
1090 IN KIRQL OldIrql)
1091 {
1092 UNIMPLEMENTED;
1093 }
1094
1095 VOID
1096 HalSweepDcache(VOID)
1097 {
1098 UNIMPLEMENTED;
1099 }
1100
1101 VOID
1102 HalSweepIcache(VOID)
1103 {
1104 UNIMPLEMENTED;
1105 }
1106
1107 ULONG
1108 HalGetInterruptSource(VOID)
1109 {
1110 UNIMPLEMENTED;
1111 return 0;
1112 }
1113
1114 /* EOF */