- NDK 0.98, now with versionned headers. Too many changes to list, see the TinyKRNL...

[reactos.git] / reactos / hal / halx86 / generic / spinlock.c

diff --git a/reactos/hal/halx86/generic/spinlock.c b/reactos/hal/halx86/generic/spinlock.c
index 553e51c..432ca1f 100644 (file)
--- a/reactos/hal/halx86/generic/spinlock.c
+++ b/reactos/hal/halx86/generic/spinlock.c
@@ -1,128 +1,166 @@
-/* $Id$
- *
+/*
  * COPYRIGHT:       See COPYING in the top level directory
  * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/hal/x86/spinlock.c
+ * FILE:            ntoskrnl/hal/halx86/up/spinlock.c
  * PURPOSE:         Implements spinlocks
- * PROGRAMMER:      David Welch (welch@cwcom.net)
- *                  Eric Kohl (ekohl@rz-online.de)
- * UPDATE HISTORY:
- *                  09/06/2000 Created
- */
-
-/*
- * NOTE: On a uniprocessor machine spinlocks are implemented by raising
- * the irq level
+ * PROGRAMMER:      Alex Ionescu (alex@relsoft.net)
  */
 
 /* INCLUDES ****************************************************************/
 
-#include <ddk/ntddk.h>
+#include <hal.h>
+#define NDEBUG
+#include <debug.h>
 
-#include <internal/debug.h>
+#undef KeAcquireSpinLock
+#undef KeReleaseSpinLock
 
 /* FUNCTIONS ***************************************************************/
 
-VOID STDCALL
-KeAcquireSpinLock (
-       PKSPIN_LOCK     SpinLock,
-       PKIRQL          OldIrql
-       )
 /*
- * FUNCTION: Acquires a spinlock
- * ARGUMENTS:
- *         SpinLock = Spinlock to acquire
- *         OldIrql (OUT) = Caller supplied storage for the previous irql
+ * @implemented
  */
+VOID
+NTAPI
+KeAcquireSpinLock(PKSPIN_LOCK SpinLock,
+                  PKIRQL OldIrql)
 {
-  *OldIrql = KfAcquireSpinLock(SpinLock);
+    /* Call the fastcall function */
+    *OldIrql = KfAcquireSpinLock(SpinLock);
 }
 
-KIRQL FASTCALL
-KeAcquireSpinLockRaiseToSynch (
-       PKSPIN_LOCK     SpinLock
-       )
+/*
+ * @implemented
+ */
+KIRQL
+FASTCALL
+KeAcquireSpinLockRaiseToSynch(PKSPIN_LOCK SpinLock)
 {
-  KIRQL OldIrql;
-
-  OldIrql = KfRaiseIrql(SYNCH_LEVEL);
-  KiAcquireSpinLock(SpinLock);
+    /* Simply raise to dispatch */
+    return KfRaiseIrql(DISPATCH_LEVEL);
+}
 
-  return OldIrql;
+/*
+ * @implemented
+ */
+VOID
+NTAPI
+KeReleaseSpinLock(PKSPIN_LOCK SpinLock,
+                  KIRQL NewIrql)
+{
+    /* Call the fastcall function */
+    KfReleaseSpinLock(SpinLock, NewIrql);
 }
 
-VOID STDCALL
-KeReleaseSpinLock (
-       PKSPIN_LOCK     SpinLock,
-       KIRQL           NewIrql
-       )
 /*
- * FUNCTION: Releases a spinlock
- * ARGUMENTS:
- *        SpinLock = Spinlock to release
- *        NewIrql = Irql level before acquiring the spinlock
+ * @implemented
  */
+KIRQL
+FASTCALL
+KfAcquireSpinLock(PKSPIN_LOCK SpinLock)
 {
-   KfReleaseSpinLock(SpinLock, NewIrql);
+    /* Simply raise to dispatch */
+    return KfRaiseIrql(DISPATCH_LEVEL);
 }
 
-KIRQL FASTCALL
-KfAcquireSpinLock (
-       PKSPIN_LOCK     SpinLock
-       )
+/*
+ * @implemented
+ */
+VOID
+FASTCALL
+KfReleaseSpinLock(PKSPIN_LOCK SpinLock,
+                  KIRQL OldIrql)
 {
-   KIRQL OldIrql;
+    /* Simply lower IRQL back */
+    KfLowerIrql(OldIrql);
+}
 
-   ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
-   
-   OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
-   KiAcquireSpinLock(SpinLock);
+/*
+ * @implemented
+ */
+KIRQL
+FASTCALL
+KeAcquireQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle)
+{
+    /* Simply raise to dispatch */
+    return KfRaiseIrql(DISPATCH_LEVEL);
+}
 
-   return OldIrql;
+/*
+ * @implemented
+ */
+KIRQL
+FASTCALL
+KeAcquireQueuedSpinLockRaiseToSynch(IN KSPIN_LOCK_QUEUE_NUMBER LockNumber)
+{
+    /* Simply raise to dispatch */
+    return KfRaiseIrql(DISPATCH_LEVEL);
 }
 
-VOID FASTCALL
-KfReleaseSpinLock (
-       PKSPIN_LOCK     SpinLock,
-       KIRQL           NewIrql
-       )
 /*
- * FUNCTION: Releases a spinlock
- * ARGUMENTS:
- *        SpinLock = Spinlock to release
- *        NewIrql = Irql level before acquiring the spinlock
+ * @implemented
  */
+VOID
+FASTCALL
+KeAcquireInStackQueuedSpinLock(IN PKSPIN_LOCK SpinLock,
+                               IN PKLOCK_QUEUE_HANDLE LockHandle)
 {
-   ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL || KeGetCurrentIrql() == SYNCH_LEVEL);
-   KiReleaseSpinLock(SpinLock);
-   KfLowerIrql(NewIrql);
+    /* Simply raise to dispatch */
+    LockHandle->OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
 }
 
+/*
+ * @implemented
+ */
+VOID
+FASTCALL
+KeReleaseQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle,
+                        IN KIRQL OldIrql)
+{
+    /* Simply lower IRQL back */
+    KfLowerIrql(OldIrql);
+}
 
 /*
- * @unimplemented
+ * @implemented
  */
 VOID
 FASTCALL
-KeAcquireInStackQueuedSpinLock(
-    IN PKSPIN_LOCK SpinLock,
-    IN PKLOCK_QUEUE_HANDLE LockHandle
-    )
+KeReleaseInStackQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle)
 {
-   UNIMPLEMENTED;
+    /* Simply lower IRQL back */
+    KfLowerIrql(LockHandle->OldIrql);
 }
 
+/*
+ * @implemented
+ */
+BOOLEAN
+FASTCALL
+KeTryToAcquireQueuedSpinLockRaiseToSynch(IN PKLOCK_QUEUE_HANDLE LockHandle,
+                                         IN PKIRQL OldIrql)
+{
+    /* Simply raise to dispatch */
+    *OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
+
+    /* Always return true on UP Machines */
+    return TRUE;
+}
 
 /*
- * @unimplemented
+ * @implemented
  */
-VOID
+BOOLEAN
 FASTCALL
-KeReleaseInStackQueuedSpinLock(
-    IN PKLOCK_QUEUE_HANDLE LockHandle
-    )
+KeTryToAcquireQueuedSpinLock(IN PKLOCK_QUEUE_HANDLE LockHandle,
+                             IN PKIRQL OldIrql)
 {
-   UNIMPLEMENTED;
+    /* Simply raise to dispatch */
+    *OldIrql = KfRaiseIrql(DISPATCH_LEVEL);
+
+    /* Always return true on UP Machines */
+    return TRUE;
 }
 
+
 /* EOF */