Windows NT 4.0 source code leak
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
|
|
/*++
Copyright (c) 1993 Digital Equipment Corporation
Module Name:
ebsysint.c
Abstract:
This module implements the HAL enable/disable system interrupt, and request interprocessor interrupt routines for a Low Cost Alpha (LCA) based system.
Originally taken from JENSEN hal code.
Author:
Wim Colgate 26-Oct-1993
Environment:
Kernel mode
Revision History:
Dick Bissen [DEC] 12-May-1994
Removed all support of the EB66 pass1 module from the code.
--*/
#include "halp.h"
#include "eb66def.h"
#include "axp21064.h"
//
// Define reference to the builtin device interrupt enables.
//
extern USHORT HalpBuiltinInterruptEnable;extern BOOLEAN bMustang;
VOIDHalDisableSystemInterrupt ( IN ULONG Vector, IN KIRQL Irql )
/*++
Routine Description:
This routine disables the specified system interrupt.
Arguments:
Vector - Supplies the vector of the system interrupt that is disabled.
Irql - Supplies the IRQL of the interrupting source.
Return Value:
None.
--*/
{
ULONG Irq; KIRQL OldIrql;
//
// Raise IRQL to the highest level.
//
KeRaiseIrql(HIGH_LEVEL, &OldIrql);
//
// If the vector number is within the range of the ISA interrupts, then
// disable the ISA interrrupt.
//
if (Vector >= ISA_VECTORS && Vector < MAXIMUM_ISA_VECTOR && Irql == ISA_DEVICE_LEVEL) { HalpDisableSioInterrupt(Vector); } //
// If the vector number is within the range of the PCI interrupts, then
// disable the PCI interrrupt.
if (Vector >= PCI_VECTORS && Vector < MAXIMUM_PCI_VECTOR && Irql == PCI_DEVICE_LEVEL) { HalpDisablePCIInterrupt(Vector); }
//
// If the vector is a performance counter vector or one of the internal
// device vectors (serial and keyboard/mouse for LCA) then disable the
// interrupt.
//
switch (Vector) {
//
// Performance counter 0 interrupt (internal to 21064)
//
case PC0_VECTOR: case PC0_SECONDARY_VECTOR:
HalpDisable21064PerformanceInterrupt( Vector ); break;
//
// Performance counter 1 interrupt (internal to 21064)
//
case PC1_VECTOR: case PC1_SECONDARY_VECTOR:
HalpDisable21064PerformanceInterrupt( Vector ); break;
} //end switch Vector
//
// Lower IRQL to the previous level.
//
KeLowerIrql(OldIrql); return;} BOOLEANHalEnableSystemInterrupt ( IN ULONG Vector, IN KIRQL Irql, IN KINTERRUPT_MODE InterruptMode )
/*++
Routine Description:
This routine enables the specified system interrupt.
Arguments:
Vector - Supplies the vector of the system interrupt that is enabled.
Irql - Supplies the IRQL of the interrupting source.
InterruptMode - Supplies the mode of the interrupt; LevelSensitive or Latched.
Return Value:
TRUE if the system interrupt was enabled
--*/
{ BOOLEAN Enabled = FALSE; ULONG Irq; KIRQL OldIrql;
//
// Raise IRQL to the highest level.
//
KeRaiseIrql(HIGH_LEVEL, &OldIrql);
//
// If the vector number is within the range of the ISA interrupts, then
// enable the ISA interrrupt. It must be latched.
//
if (Vector >= ISA_VECTORS && Vector < MAXIMUM_ISA_VECTOR && Irql == ISA_DEVICE_LEVEL) { HalpEnableSioInterrupt( Vector, InterruptMode ); Enabled = TRUE; }
//
// If the vector number is within the range of the PCI interrupts, then
// enable the PCI interrrupt. PCI interrupts must be LevelSensitve.
// (PCI Spec. 2.2.6)
//
if (Vector >= PCI_VECTORS && Vector < MAXIMUM_PCI_VECTOR && Irql == PCI_DEVICE_LEVEL && InterruptMode == LevelSensitive) { HalpEnablePCIInterrupt( Vector ); Enabled = TRUE; }
//
// If the vector is a performance counter vector or one of the
// internal device vectors (serial or keyboard/mouse) then perform
// 21064-specific enable.
//
switch (Vector) {
//
// Performance counter 0 (internal to 21064)
//
case PC0_VECTOR: case PC0_SECONDARY_VECTOR:
HalpEnable21064PerformanceInterrupt( Vector, Irql ); Enabled = TRUE; break;
//
// Performance counter 1 (internal to 21064)
//
case PC1_VECTOR: case PC1_SECONDARY_VECTOR:
HalpEnable21064PerformanceInterrupt( Vector, Irql ); Enabled = TRUE; break;
} //end switch Vector
//
// Lower IRQL to the previous level.
//
KeLowerIrql(OldIrql); return Enabled;} ULONGHalpGetSystemInterruptVector( IN PBUS_HANDLER BusHandler, IN PBUS_HANDLER RootHandler, IN ULONG BusInterruptLevel, IN ULONG BusInterruptVector, OUT PKIRQL Irql, OUT PKAFFINITY Affinity )
/*++
Routine Description:
This function returns the system interrupt vector and IRQL level corresponding to the specified bus interrupt level and/or vector. The system interrupt vector and IRQL are suitable for use in a subsequent call to KeInitializeInterrupt.
We only use InterfaceType, and BusInterruptLevel. BusInterruptVector for ISA and EISA are the same as the InterruptLevel, so ignore.
Arguments:
BusHandler - Registered BUSHANDLER for the target configuration space
RootHandler - Registered BUSHANDLER for the orginating HalGetBusData request.
BusInterruptLevel - Supplies the bus specific interrupt level.
BusInterruptVector - Supplies the bus specific interrupt vector.
Irql - Returns the system request priority.
Affinity - Returns the affinity for the requested vector
Return Value:
Returns the system interrupt vector corresponding to the specified device.
--*/
{ INTERFACE_TYPE InterfaceType = BusHandler->InterfaceType; ULONG BusNumber = BusHandler->BusNumber;
ULONG Vector;
*Affinity = 1;
switch (InterfaceType) {
case ProcessorInternal:
//
// Handle the internal defined for the processor itself
// and used to control the performance counters in the 21064.
//
if( (Vector = HalpGet21064PerformanceVector( BusInterruptLevel, Irql)) != 0 ){
//
// Performance counter was successfully recognized.
//
return Vector;
} else {
//
// Unrecognized processor interrupt.
//
*Irql = 0; *Affinity = 0; return 0;
} //end if Vector
break;
case Isa:
//
// Assumes all ISA devices coming in on same pin
//
*Irql = ISA_DEVICE_LEVEL;
//
// The vector is equal to the specified bus level plus the ISA_VECTOR.
// This is assuming that the ISA levels not assigned Interrupt Levels
// in the Beta programming guide are unused in the LCA system.
// Otherwise, need a different encoding scheme.
//
// Not all interrupt levels are actually supported on Beta;
// Should we make some of them illegal here?
return(BusInterruptLevel + ISA_VECTORS); break;
case Eisa:
//
// Assumes all EISA devices coming in on same pin
//
*Irql = EISA_DEVICE_LEVEL;
//
// The vector is equal to the specified bus level plus the EISA_VECTOR.
//
return(BusInterruptLevel + EISA_VECTORS); break;
case PCIBus:
//
// Assumes all PCI devices coming in on same pin
//
*Irql = PCI_DEVICE_LEVEL;
//
// The vector is equal to the specified bus level plus the PCI_VECTOR.
//
return((BusInterruptLevel) + PCI_VECTORS);
break;
default:
//
// Not an interface supported on EB66/Mustang systems
//
*Irql = 0; *Affinity = 0; return(0); break;
} //end switch(InterfaceType)
} VOIDHalRequestIpi ( IN ULONG Mask )
/*++
Routine Description:
This routine requests an interprocessor interrupt on a set of processors.
This routine performs no function on an EB66/Mustang because it is a uni-processor system.
Arguments:
Mask - Supplies the set of processors that are sent an interprocessor interrupt.
Return Value:
None.
--*/
{
return;}
|
