/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: ntoskrnl/hal/x86/mpsirql.c
+ * FILE: hal/halx86/mp/mpsirql.c
* PURPOSE: Implements IRQLs for multiprocessor systems
* PROGRAMMERS: David Welch (welch@cwcom.net)
* Casper S. Hornstrup (chorns@users.sourceforge.net)
/* INCLUDES *****************************************************************/
-#include <ddk/ntddk.h>
-#include <internal/ke.h>
-#include <internal/ps.h>
-#include <ntos/minmax.h>
-#include <halirq.h>
#include <hal.h>
-#include <mps.h>
-#include <apic.h>
-#include <ioapic.h>
-
#define NDEBUG
-#include <internal/debug.h>
+#include <debug.h>
-/* GLOBALS ******************************************************************/;
+/* GLOBALS ******************************************************************/
/* FUNCTIONS ****************************************************************/
-KIRQL STDCALL KeGetCurrentIrql (VOID)
+#undef KeGetCurrentIrql
+KIRQL NTAPI KeGetCurrentIrql (VOID)
/*
* PURPOSE: Returns the current irq level
* RETURNS: The current irq level
KIRQL irql;
ULONG Flags;
- Ki386SaveFlags(Flags);
- Ki386DisableInterrupts();
+ Flags = __readeflags();
+ _disable();
- irql = Ki386ReadFsByte(offsetof(KPCR, Irql));
+ irql = __readfsbyte(FIELD_OFFSET(KPCR, Irql));
if (irql > HIGH_LEVEL)
{
DPRINT1 ("CurrentIrql %x\n", irql);
- KEBUGCHECK (0);
+ ASSERT(FALSE);
}
- if (Flags & X86_EFLAGS_IF)
+ if (Flags & EFLAGS_INTERRUPT_MASK)
{
- Ki386EnableInterrupts();
+ _enable();
}
return irql;
}
+#undef KeSetCurrentIrql
VOID KeSetCurrentIrql (KIRQL NewIrql)
/*
* PURPOSE: Sets the current irq level without taking any action
if (NewIrql > HIGH_LEVEL)
{
DPRINT1 ("NewIrql %x\n", NewIrql);
- KEBUGCHECK (0);
+ ASSERT(FALSE);
}
- Ki386SaveFlags(Flags);
- Ki386DisableInterrupts();
- Ki386WriteFsByte(offsetof(KPCR, Irql), NewIrql);
- if (Flags & X86_EFLAGS_IF)
+ Flags = __readeflags();
+ _disable();
+ __writefsbyte(FIELD_OFFSET(KPCR, Irql), NewIrql);
+ if (Flags & EFLAGS_INTERRUPT_MASK)
{
- Ki386EnableInterrupts();
+ _enable();
}
}
VOID
-HalpLowerIrql(KIRQL NewIrql, BOOL FromHalEndSystemInterrupt)
+HalpLowerIrql(KIRQL NewIrql, BOOLEAN FromHalEndSystemInterrupt)
{
ULONG Flags;
+ UCHAR DpcRequested;
if (NewIrql >= DISPATCH_LEVEL)
{
KeSetCurrentIrql (NewIrql);
APICWrite(APIC_TPR, IRQL2TPR (NewIrql) & APIC_TPR_PRI);
return;
}
- Ki386SaveFlags(Flags);
+ Flags = __readeflags();
if (KeGetCurrentIrql() > APC_LEVEL)
{
KeSetCurrentIrql (DISPATCH_LEVEL);
APICWrite(APIC_TPR, IRQL2TPR (DISPATCH_LEVEL) & APIC_TPR_PRI);
- if (FromHalEndSystemInterrupt || Ki386ReadFsByte(offsetof(KPCR, HalReserved[HAL_DPC_REQUEST])))
+ DpcRequested = __readfsbyte(FIELD_OFFSET(KIPCR, HalReserved[HAL_DPC_REQUEST]));
+ if (FromHalEndSystemInterrupt || DpcRequested)
{
- Ki386WriteFsByte(offsetof(KPCR, HalReserved[HAL_DPC_REQUEST]), 0);
- Ki386EnableInterrupts();
+ __writefsbyte(FIELD_OFFSET(KIPCR, HalReserved[HAL_DPC_REQUEST]), 0);
+ _enable();
KiDispatchInterrupt();
- if (!(Flags & X86_EFLAGS_IF))
+ if (!(Flags & EFLAGS_INTERRUPT_MASK))
{
- Ki386DisableInterrupts();
+ _disable();
}
}
KeSetCurrentIrql (APC_LEVEL);
if (KeGetCurrentThread () != NULL &&
KeGetCurrentThread ()->ApcState.KernelApcPending)
{
- Ki386EnableInterrupts();
+ _enable();
KiDeliverApc(KernelMode, NULL, NULL);
- if (!(Flags & X86_EFLAGS_IF))
+ if (!(Flags & EFLAGS_INTERRUPT_MASK))
{
- Ki386DisableInterrupts();
+ _disable();
}
}
KeSetCurrentIrql (PASSIVE_LEVEL);
if (NewIrql > oldIrql)
{
DPRINT1 ("NewIrql %x CurrentIrql %x\n", NewIrql, oldIrql);
- KEBUGCHECK (0);
+ ASSERT(FALSE);
}
HalpLowerIrql (NewIrql, FALSE);
}
*
* NOTES
*/
-
-VOID STDCALL
+#undef KeLowerIrql
+VOID NTAPI
KeLowerIrql (KIRQL NewIrql)
{
KfLowerIrql (NewIrql);
KIRQL OldIrql;
ULONG Flags;
- Ki386SaveFlags(Flags);
- Ki386DisableInterrupts();
+ Flags = __readeflags();
+ _disable();
OldIrql = KeGetCurrentIrql ();
if (NewIrql < OldIrql)
{
DPRINT1 ("CurrentIrql %x NewIrql %x\n", KeGetCurrentIrql (), NewIrql);
- KEBUGCHECK (0);
+ ASSERT(FALSE);
}
APICWrite (APIC_TPR, IRQL2TPR(NewIrql) & APIC_TPR_PRI);
}
KeSetCurrentIrql (NewIrql);
- if (Flags & X86_EFLAGS_IF)
+ if (Flags & EFLAGS_INTERRUPT_MASK)
{
- Ki386EnableInterrupts();
+ _enable();
}
return OldIrql;
* NOTES
* Calls KfRaiseIrql
*/
-VOID STDCALL
+#undef KeRaiseIrql
+VOID NTAPI
KeRaiseIrql (KIRQL NewIrql,
PKIRQL OldIrql)
{
* Calls KfRaiseIrql
*/
-KIRQL STDCALL
+KIRQL NTAPI
KeRaiseIrqlToDpcLevel (VOID)
{
return KfRaiseIrql (DISPATCH_LEVEL);
* Calls KfRaiseIrql
*/
-KIRQL STDCALL
+KIRQL NTAPI
KeRaiseIrqlToSynchLevel (VOID)
{
return KfRaiseIrql (CLOCK2_LEVEL);
}
-BOOLEAN STDCALL
-HalBeginSystemInterrupt (ULONG Vector,
- KIRQL Irql,
+BOOLEAN NTAPI
+HalBeginSystemInterrupt (KIRQL Irql,
+ UCHAR Vector,
PKIRQL OldIrql)
{
ULONG Flags;
if (KeGetCurrentIrql () >= Irql)
{
DPRINT1("current irql %d, new irql %d\n", KeGetCurrentIrql(), Irql);
- KEBUGCHECK(0);
+ ASSERT(FALSE);
}
- Ki386SaveFlags(Flags);
- if (Flags & X86_EFLAGS_IF)
+ Flags = __readeflags();
+ if (Flags & EFLAGS_INTERRUPT_MASK)
{
DPRINT1("HalBeginSystemInterrupt was called with interrupt's enabled\n");
- KEBUGCHECK(0);
+ ASSERT(FALSE);
}
APICWrite (APIC_TPR, IRQL2TPR (Irql) & APIC_TPR_PRI);
*OldIrql = KeGetCurrentIrql ();
}
-VOID STDCALL
+VOID NTAPI
HalEndSystemInterrupt (KIRQL Irql,
- ULONG Unknown2)
+ IN PKTRAP_FRAME TrapFrame)
/*
* FUNCTION: Finish a system interrupt and restore the specified irq level.
*/
{
ULONG Flags;
- Ki386SaveFlags(Flags);
+ Flags = __readeflags();
- if (Flags & X86_EFLAGS_IF)
+ if (Flags & EFLAGS_INTERRUPT_MASK)
{
DPRINT1("HalEndSystemInterrupt was called with interrupt's enabled\n");
- KEBUGCHECK(0);
+ ASSERT(FALSE);
}
APICSendEOI();
HalpLowerIrql (Irql, TRUE);
}
-BOOLEAN STDCALL
-HalDisableSystemInterrupt (ULONG Vector,
- KIRQL Irql)
+VOID
+NTAPI
+HalDisableSystemInterrupt(UCHAR Vector,
+ KIRQL Irql)
{
ULONG irq;
Vector >= FIRST_DEVICE_VECTOR + NUMBER_DEVICE_VECTORS)
{
DPRINT1("Not a device interrupt, vector=%x\n", Vector);
- return FALSE;
+ ASSERT(FALSE);
+ return;
}
irq = VECTOR2IRQ (Vector);
IOAPICMaskIrq (irq);
- return TRUE;
+ return;
}
-BOOLEAN STDCALL
-HalEnableSystemInterrupt (ULONG Vector,
+BOOLEAN NTAPI
+HalEnableSystemInterrupt (UCHAR Vector,
KIRQL Irql,
KINTERRUPT_MODE InterruptMode)
{
switch (Request)
{
case APC_LEVEL:
- Ki386WriteFsByte(offsetof(KPCR, HalReserved[HAL_APC_REQUEST]), 1);
+ __writefsbyte(FIELD_OFFSET(KIPCR, HalReserved[HAL_APC_REQUEST]), 1);
break;
case DISPATCH_LEVEL:
- Ki386WriteFsByte(offsetof(KPCR, HalReserved[HAL_DPC_REQUEST]), 1);
+ __writefsbyte(FIELD_OFFSET(KIPCR, HalReserved[HAL_DPC_REQUEST]), 1);
break;
default:
- KEBUGCHECK(0);
+ ASSERT(FALSE);
}
}
+
+VOID FASTCALL
+HalClearSoftwareInterrupt(
+ IN KIRQL Request)
+{
+ UNIMPLEMENTED;
+}
projects / reactos.git / blobdiff