dlls/hal/hal.c

   1 /*
   2  * hal.dll implementation
   3  *
   4  * Copyright (C) 2007 Chris Wulff
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #include "ntstatus.h"
  24 #define WIN32_NO_STATUS
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winternl.h"
  28 #include "excpt.h"
  29 #include "ddk/ntddk.h"
  30 #include "wine/asm.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl);
  34
  35 #ifdef __i386__
  36
  37 #ifdef __ASM_USE_FASTCALL_WRAPPER
  38
  39 extern void * WINAPI wrap_fastcall_func1( void *func, const void *a );
  40 __ASM_STDCALL_FUNC( wrap_fastcall_func1, 8,
  41                    "popl %ecx\n\t"
  42                    "popl %eax\n\t"
  43                    "xchgl (%esp),%ecx\n\t"
  44                    "jmp *%eax" );
  45 extern void * WINAPI wrap_fastcall_func2( void *func, const void *a, const void *b );
  46 __ASM_STDCALL_FUNC( wrap_fastcall_func2, 12,
  47                    "popl %edx\n\t"
  48                    "popl %eax\n\t"
  49                    "popl %ecx\n\t"
  50                    "xchgl (%esp),%edx\n\t"
  51                    "jmp *%eax" );
  52
  53 #define call_fastcall_func1(func,a) wrap_fastcall_func1(func,a)
  54 #define call_fastcall_func2(func,a,b) wrap_fastcall_func2(func,a,b)
  55
  56 #else  /* __ASM_USE_FASTCALL_WRAPPER */
  57
  58 #define call_fastcall_func1(func,a) func(a)
  59 #define call_fastcall_func2(func,a,b) func(a,b)
  60
  61 #endif  /* __ASM_USE_FASTCALL_WRAPPER */
  62
  63 DEFINE_FASTCALL1_WRAPPER( ExAcquireFastMutex )
  64 void FASTCALL ExAcquireFastMutex( FAST_MUTEX *mutex )
  65 {
  66     call_fastcall_func1( ExAcquireFastMutexUnsafe, mutex );
  67 }
  68
  69 DEFINE_FASTCALL1_WRAPPER( ExReleaseFastMutex )
  70 void FASTCALL ExReleaseFastMutex( FAST_MUTEX *mutex )
  71 {
  72     call_fastcall_func1( ExReleaseFastMutexUnsafe, mutex );
  73 }
  74
  75 DEFINE_FASTCALL1_WRAPPER( ExTryToAcquireFastMutex )
  76 BOOLEAN FASTCALL ExTryToAcquireFastMutex( FAST_MUTEX *mutex )
  77 {
  78     TRACE("mutex %p.\n", mutex);
  79
  80     return (InterlockedCompareExchange( &mutex->Count, 0, 1 ) == 1);
  81 }
  82
  83 DEFINE_FASTCALL1_WRAPPER( KfAcquireSpinLock )
  84 KIRQL FASTCALL KfAcquireSpinLock( KSPIN_LOCK *lock )
  85 {
  86     KIRQL irql;
  87     KeAcquireSpinLock( lock, &irql );
  88     return irql;
  89 }
  90
  91 void WINAPI KeAcquireSpinLock( KSPIN_LOCK *lock, KIRQL *irql )
  92 {
  93     TRACE("lock %p, irql %p.\n", lock, irql);
  94     KeAcquireSpinLockAtDpcLevel( lock );
  95     *irql = 0;
  96 }
  97
  98 DEFINE_FASTCALL_WRAPPER( KfReleaseSpinLock, 8 )
  99 void FASTCALL KfReleaseSpinLock( KSPIN_LOCK *lock, KIRQL irql )
 100 {
 101     KeReleaseSpinLock( lock, irql );
 102 }
 103
 104 void WINAPI KeReleaseSpinLock( KSPIN_LOCK *lock, KIRQL irql )
 105 {
 106     TRACE("lock %p, irql %u.\n", lock, irql);
 107     KeReleaseSpinLockFromDpcLevel( lock );
 108 }
 109
 110 DEFINE_FASTCALL_WRAPPER( KeAcquireInStackQueuedSpinLock, 8 )
 111 void FASTCALL KeAcquireInStackQueuedSpinLock( KSPIN_LOCK *lock, KLOCK_QUEUE_HANDLE *queue )
 112 {
 113     call_fastcall_func2( KeAcquireInStackQueuedSpinLockAtDpcLevel, lock, queue );
 114 }
 115
 116 DEFINE_FASTCALL1_WRAPPER( KeReleaseInStackQueuedSpinLock )
 117 void FASTCALL KeReleaseInStackQueuedSpinLock( KLOCK_QUEUE_HANDLE *queue )
 118 {
 119     call_fastcall_func1( KeReleaseInStackQueuedSpinLockFromDpcLevel, queue );
 120 }
 121 #endif /* __i386__ */
 122
 123 #if defined(__i386__) || defined(__arm__) || defined(__aarch64__)
 124
 125 DEFINE_FASTCALL1_WRAPPER( KfLowerIrql )
 126 VOID FASTCALL KfLowerIrql(KIRQL NewIrql)
 127 {
 128     FIXME( "(%u) stub!\n", NewIrql );
 129 }
 130
 131 DEFINE_FASTCALL1_WRAPPER( KfRaiseIrql )
 132 KIRQL FASTCALL KfRaiseIrql(KIRQL NewIrql)
 133 {
 134     FIXME( "(%u) stub!\n", NewIrql );
 135
 136     return 0;
 137 }
 138
 139 KIRQL WINAPI KeGetCurrentIrql(VOID)
 140 {
 141     FIXME( " stub!\n");
 142     return 0;
 143 }
 144
 145 UCHAR WINAPI READ_PORT_UCHAR(UCHAR *port)
 146 {
 147     FIXME("(%p) stub!\n", port);
 148     return 0;
 149 }
 150
 151 ULONG WINAPI READ_PORT_ULONG(ULONG *port)
 152 {
 153     FIXME("(%p) stub!\n", port);
 154     return 0;
 155 }
 156
 157 void WINAPI WRITE_PORT_UCHAR(UCHAR *port, UCHAR value)
 158 {
 159     FIXME("(%p %d) stub!\n", port, value);
 160 }
 161
 162 void WINAPI WRITE_PORT_ULONG(ULONG *port, ULONG value)
 163 {
 164     FIXME("(%p %ld) stub!\n", port, value);
 165 }
 166 #endif /* __i386__ || __arm__ || __arm64__ */
 167
 168 ULONG WINAPI HalGetBusData(BUS_DATA_TYPE BusDataType, ULONG BusNumber, ULONG SlotNumber, PVOID Buffer, ULONG Length)
 169 {
 170     FIXME("(%u %lu %lu %p %lu) stub!\n", BusDataType, BusNumber, SlotNumber, Buffer, Length);
 171     /* Claim that there is no such bus */
 172     return 0;
 173 }
 174
 175 ULONG WINAPI HalGetBusDataByOffset(BUS_DATA_TYPE BusDataType, ULONG BusNumber, ULONG SlotNumber, PVOID Buffer, ULONG Offset, ULONG Length)
 176 {
 177     FIXME("(%u %lu %lu %p %lu %lu) stub!\n", BusDataType, BusNumber, SlotNumber, Buffer, Offset, Length);
 178     /* Claim that there is no such bus */
 179     return 0;
 180 }
 181
 182 BOOLEAN WINAPI HalTranslateBusAddress(INTERFACE_TYPE InterfaceType, ULONG BusNumber, PHYSICAL_ADDRESS BusAddress,
 183                                               PULONG AddressSpace, PPHYSICAL_ADDRESS TranslatedAddress)
 184 {
 185     FIXME("(%d %ld %s %p %p) stub!\n", InterfaceType, BusNumber,
 186                 wine_dbgstr_longlong(BusAddress.QuadPart), AddressSpace, TranslatedAddress);
 187     return FALSE;
 188 }
 189
 190 ULONGLONG WINAPI KeQueryPerformanceCounter(LARGE_INTEGER *frequency)
 191 {
 192     LARGE_INTEGER counter;
 193
 194     TRACE("(%p)\n", frequency);
 195
 196     NtQueryPerformanceCounter(&counter, frequency);
 197     return counter.QuadPart;
 198 }