mirror of https://github.com/lianthony/NT4.0
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.
473 lines
9.8 KiB
473 lines
9.8 KiB
/*++
|
|
|
|
Copyright (c) 1991 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
axsysint.c
|
|
|
|
Abstract:
|
|
|
|
This module implements the HAL enable/disable system interrupt, and
|
|
request interprocessor interrupt routines for the alpha system JENSEN.
|
|
|
|
Author:
|
|
|
|
David N. Cutler (davec) 6-May-1991
|
|
Miche Baker-Harvey (miche) 13-May-1992
|
|
|
|
Environment:
|
|
|
|
Kernel mode
|
|
|
|
Revision History:
|
|
|
|
08-Jul-1992 Joe Notarangelo
|
|
Add support for performance counter interrupts.
|
|
Add support to enable/disable serial and keyboard interrupts via the
|
|
standard HalEnable/Disable interfaces.
|
|
NOTE: This module is now, decidely JENSEN-specific.
|
|
|
|
28-Jul-1992 Jeff McLeman (DEC)
|
|
Remove reference to ISA
|
|
|
|
13-May-92 Converted to Alpha Beta and Jensen (EV4-based)
|
|
systems. Stole from jxsysint.c
|
|
Beta is ISA/82380; Jensen is EISA/82357, as is Jazz
|
|
|
|
--*/
|
|
|
|
#include "halp.h"
|
|
#include "jnsnint.h"
|
|
#include "jnsndef.h"
|
|
#include "axp21064.h"
|
|
|
|
//
|
|
// Define reference to the builtin device interrupt enables.
|
|
//
|
|
|
|
extern USHORT HalpBuiltinInterruptEnable;
|
|
|
|
VOID
|
|
HalDisableSystemInterrupt (
|
|
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.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
KIRQL IrqlIndex;
|
|
PIETEntry_21064 IetEntry;
|
|
KIRQL OldIrql;
|
|
|
|
//
|
|
// Raise IRQL to the highest level.
|
|
//
|
|
|
|
KeRaiseIrql(HIGH_LEVEL, &OldIrql);
|
|
|
|
//
|
|
// If the vector number is within the range of the EISA interrupts, then
|
|
// disable the EISA interrrupt.
|
|
//
|
|
|
|
if (Vector >= EISA_VECTORS &&
|
|
Vector < EISA_VECTORS + MAXIMUM_EISA_VECTOR &&
|
|
Irql == EISA_DEVICE_LEVEL) {
|
|
HalpDisableEisaInterrupt(Vector);
|
|
}
|
|
|
|
//
|
|
// If the vector is a performance counter vector or one of the internal
|
|
// device vectors (serial and keyboard/mouse for JENSEN) then disable the
|
|
// interrupt in the IET and alert the PAL to re-cache the interrupt
|
|
// enable masks.
|
|
//
|
|
|
|
if( (Vector == SERIAL_VECTOR) ||
|
|
(Vector == KEYBOARD_MOUSE_VECTOR) ||
|
|
(Vector == PC0_VECTOR) ||
|
|
(Vector == PC1_VECTOR) ){
|
|
|
|
IetEntry = (PIETEntry_21064)&PCR->IrqlTable;
|
|
IrqlIndex = PASSIVE_LEVEL;
|
|
|
|
//
|
|
// Update the enable table for all the Irqls such that the interrupt
|
|
// is disabled.
|
|
//
|
|
|
|
while( IrqlIndex <= HIGH_LEVEL ){
|
|
|
|
switch( Vector ){
|
|
|
|
case PC0_VECTOR:
|
|
|
|
IetEntry[IrqlIndex].PerformanceCounter0Enable = 0;
|
|
break;
|
|
|
|
case PC1_VECTOR:
|
|
|
|
IetEntry[IrqlIndex].PerformanceCounter1Enable = 0;
|
|
break;
|
|
|
|
case SERIAL_VECTOR:
|
|
|
|
IetEntry[IrqlIndex].Irq5Enable = 0;
|
|
break;
|
|
|
|
case KEYBOARD_MOUSE_VECTOR:
|
|
|
|
IetEntry[IrqlIndex].Irq3Enable = 0;
|
|
break;
|
|
|
|
} //end switch( Vector )
|
|
|
|
IrqlIndex++;
|
|
|
|
} //end while IrqlIndex <= HIGH_LEVEL
|
|
|
|
//
|
|
// Alert the PAL that the enable table has changed so that it can
|
|
// reload the new values.
|
|
//
|
|
|
|
HalpCachePcrValues();
|
|
|
|
} //end if Vector == SERIAL_VECTOR, etc.
|
|
|
|
//
|
|
// Lower IRQL to the previous level.
|
|
//
|
|
|
|
KeLowerIrql(OldIrql);
|
|
return;
|
|
}
|
|
|
|
BOOLEAN
|
|
HalEnableSystemInterrupt (
|
|
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
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
KIRQL IrqlIndex;
|
|
PIETEntry_21064 IetEntry;
|
|
KIRQL OldIrql;
|
|
|
|
//
|
|
// Raise IRQL to the highest level.
|
|
//
|
|
|
|
KeRaiseIrql(HIGH_LEVEL, &OldIrql);
|
|
|
|
//
|
|
// If the vector number is within the range of the EISA interrupts, then
|
|
// enable the EISA interrrupt and set the Level/Edge register.
|
|
//
|
|
|
|
if (Vector >= EISA_VECTORS &&
|
|
Vector < EISA_VECTORS + MAXIMUM_EISA_VECTOR &&
|
|
Irql == EISA_DEVICE_LEVEL) {
|
|
HalpEnableEisaInterrupt( Vector, InterruptMode);
|
|
}
|
|
|
|
//
|
|
// If the vector is a performance counter vector or one of the
|
|
// internal device vectors (serial or keyboard/mouse) then enable the
|
|
// interrupt in the IET and alert the PAL to re-cache the interrupt
|
|
// enable masks.
|
|
//
|
|
|
|
if( (Vector == SERIAL_VECTOR) ||
|
|
(Vector == KEYBOARD_MOUSE_VECTOR) ||
|
|
(Vector == PC0_VECTOR) ||
|
|
(Vector == PC1_VECTOR) ){
|
|
|
|
IetEntry = (PIETEntry_21064)&PCR->IrqlTable;
|
|
IrqlIndex = PASSIVE_LEVEL;
|
|
|
|
//
|
|
// Update the enable table for each Irql that the interrupt should
|
|
// be enabled.
|
|
//
|
|
|
|
while( IrqlIndex < Irql ){
|
|
|
|
switch( Vector ){
|
|
|
|
case PC0_VECTOR:
|
|
|
|
IetEntry[IrqlIndex].PerformanceCounter0Enable = 1;
|
|
break;
|
|
|
|
case PC1_VECTOR:
|
|
|
|
IetEntry[IrqlIndex].PerformanceCounter1Enable = 1;
|
|
break;
|
|
|
|
case SERIAL_VECTOR:
|
|
|
|
IetEntry[IrqlIndex].Irq5Enable = 1;
|
|
break;
|
|
|
|
case KEYBOARD_MOUSE_VECTOR:
|
|
|
|
IetEntry[IrqlIndex].Irq3Enable = 1;
|
|
break;
|
|
|
|
} // end switch( Vector )
|
|
|
|
IrqlIndex++;
|
|
|
|
} //end while IrqlIndex < Irql
|
|
|
|
//
|
|
// Alert the PAL that the enable table has changed so that it can
|
|
// reload the new values.
|
|
//
|
|
|
|
HalpCachePcrValues();
|
|
|
|
} //end if Vector == SERIAL_VECTOR, etc.
|
|
|
|
//
|
|
// Lower IRQL to the previous level.
|
|
//
|
|
|
|
KeLowerIrql(OldIrql);
|
|
return TRUE;
|
|
}
|
|
|
|
ULONG
|
|
HalpGetSystemInterruptVector(
|
|
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;
|
|
|
|
*Affinity = 1;
|
|
|
|
//
|
|
// Handle the special internal bus defined for the processor itself
|
|
// and used to control the performance counters in the 21064.
|
|
//
|
|
|
|
if(InterfaceType == ProcessorInternal) {
|
|
|
|
*Irql = IPI_LEVEL;
|
|
|
|
switch( BusInterruptLevel ){
|
|
|
|
//
|
|
// Performance Counter 0
|
|
//
|
|
|
|
case 0:
|
|
|
|
return PC0_VECTOR;
|
|
|
|
//
|
|
// Performance Counter 1
|
|
//
|
|
|
|
case 1:
|
|
|
|
return PC1_VECTOR;
|
|
|
|
//
|
|
// Unrecognized.
|
|
//
|
|
|
|
default:
|
|
|
|
*Irql = 0;
|
|
*Affinity = 0;
|
|
return 0;
|
|
|
|
} //end switch( BusInterruptLevel )
|
|
|
|
} // end if InterfaceType == ProcessorInternal
|
|
|
|
//
|
|
// If this is for the internal bus then everything but the serial
|
|
// lines comes in on DEVICE_LOW, and the vector depends on the
|
|
// particular device. We have coded things like "SERIAL_VECTOR"
|
|
// into the drivers for the built-in devices.
|
|
//
|
|
|
|
if (InterfaceType == Internal) {
|
|
|
|
if (BusInterruptVector == SERIAL_VECTOR) {
|
|
|
|
//
|
|
// This is the only device which interrupts at DEVICE_HIGH_LEVEL
|
|
//
|
|
|
|
*Irql = DEVICE_HIGH_LEVEL;
|
|
|
|
} else {
|
|
|
|
*Irql = DEVICE_LOW_LEVEL;
|
|
|
|
}
|
|
|
|
return(BusInterruptVector);
|
|
}
|
|
|
|
if (InterfaceType == 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 Jensen 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);
|
|
|
|
}
|
|
|
|
if (InterfaceType == 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);
|
|
|
|
}
|
|
|
|
//
|
|
// Not an interface supported on Alpha systems
|
|
//
|
|
|
|
*Irql = 0;
|
|
*Affinity = 0;
|
|
return(0);
|
|
|
|
}
|
|
|
|
VOID
|
|
HalRequestIpi (
|
|
IN ULONG Mask
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine requests an interprocessor interrupt on a set of processors.
|
|
|
|
For all currently known machines - there's only one processor
|
|
|
|
Arguments:
|
|
|
|
Mask - Supplies the set of processors that are sent an interprocessor
|
|
interrupt.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
return;
|
|
}
|