path: root/private/ntos/nthals/halalpha/errframe.h

/*++

Copyright (c) 1995,1996  Digital Equipment Corporation

Module Name:

    errframe.h

Abstract:

    Definitions for both the correctable and uncorrectable error
    frames.

Author:

    Joe Notarangelo  10-Mar-1995
    Chao Chen        24-Apr-1995

Environment:

    Kernel mode only.

Revision History:

0.1   28-Feb-1995 Joe Notarangelo   Initial version.

0.2   10-Mar-1995 Joe Notarangelo   Incorporate initial review comments from
                                    6-Mar-95 review with: C. Chen, S. Jenness,
                                    Bala, E. Rehm. 

0.3   24-Apr-1995 Chao Chen         Made into .h file for inclusion by other
                                    modules.

0.4	  16-Apr-1996 Gene Morgan		Add fields to SystemError struct for PSU,
									Wachdog events.

--*/

#ifndef ERRFRAME_H
#define ERRFRAME_H

#include "errplat.h"

/* 
 *
 * Common defines.
 *
 */

#define ERROR_FRAME_VERSION 0x1

#define UNIDENTIFIED     0x0
#define MEMORY_SPACE     0x1
#define IO_SPACE         0x2
#define PROCESSOR_CACHE  0x2
#define SYSTEM_CACHE     0x3
#define PROCESSOR_MEMORY 0x4
#define SYSTEM_MEMORY    0x5

#define CACHE_ERROR_MASK    0x2
#define MEMORY_ERROR_MASK   0x4

#define BUS_DMA_READ        0x1
#define BUS_DMA_WRITE       0x2
#define BUS_DMA_OP          0x3
#define BUS_IO_READ         0x4
#define BUS_IO_WRITE        0x5
#define BUS_IO_OP           0x6
#define TLB_MISS_READ       0x7
#define TLB_MISS_WRITE      0x8
#define VICTIM_WRITE        0x9

#define MAX_UNCORRERR_STRLEN  128

#define ERROR_FRAME_SIGNATURE   0xE22F2F2A  // ERRORFRA R=2 (18%16)

/* 
 *
 * Definitions for the correctable error frame.
 *
 */

//
// Correctable Error Flags
//    

typedef struct _CORRECTABLE_FLAGS{

  //
  // Address space
  //  Unidentified: 00
  //  Memory Space: 01
  //  I/O Space:    10
  //  Reserved:     11
  //

  ULONGLONG AddressSpace: 2;

  //
  // Error Interpretation Validity.
  //

  ULONGLONG ServerManagementInformationValid: 1;
  ULONGLONG PhysicalAddressValid: 1;
  ULONGLONG ErrorBitMasksValid: 1;
  ULONGLONG ExtendedErrorValid: 1;
  ULONGLONG ProcessorInformationValid: 1;
  ULONGLONG SystemInformationValid: 1;

  //
  // Memory Space Error Source:
  //
  //  Unidentified:    000
  //  ProcessorCache:  010
  //  SystemCache:     011
  //  ProcessorMemory: 100
  //  SystemMemory:    101
  //

  ULONGLONG MemoryErrorSource: 4;

  //
  // Driver Actions.
  //

  ULONGLONG ScrubError: 1;

  //
  // Lost errors.
  //

  ULONGLONG LostCorrectable: 1;
  ULONGLONG LostAddressSpace: 2;
  ULONGLONG LostMemoryErrorSource: 4;

} CORRECTABLE_FLAGS, *PCORRECTABLE_FLAGS;

  //
  // Description of CORRECTABLE_FLAG structure:
  //
  // AddressSpace
  //
  //      Identifies the system address space that was the source of the
  //      correctable error.
  //
  // PhysicalAddressValid
  //
  //      Indicates if the physical address in the CORRECTABLE_ERROR 
  //      structure is valid.  A value of 1 indicates the physical address
  //      is valid, a value of 0 indicates the physical address is not
  //      valid.
  //
  // ErrorBitMasksValid
  //
  //      Indicates if the error bit mask fields in the CORRECTABLE_ERROR 
  //      structure are valid.  A value of 1 indicates the DataBitErrorMask
  //      and the CheckBitErrorMask are valid,  a value of 0 indicates they
  //      are not valid.
  //
  // ExtendedErrorValid
  //
  //      Indicates if the extended error information structure in the 
  //      CORRECTABLE_ERROR structure is valid.  A value of 1 indicates the 
  //      extended error information structure is valid, a value of 0 
  //      indicates that it is not.
  //
  // ProcessorInformationValid
  //
  //      Indicates if the raw processor information pointer in the 
  //      CORRECTABLE_ERROR structure is valid.  A value of 1 indicates the 
  //      processor information is valid, a value of 0 indicates it is not.
  //
  // SystemInformationValid
  //
  //      Indicates if the raw system information pointer in the 
  //      CORRECTABLE_ERROR structure is valid.  A value of 1 indicates the 
  //      system information is valid, a value of 0 indicates it is not.
  //
  // ServerManagementInformationValid
  //
  //      Indicates that the server management information in the extended
  //      error information structure is valid.  The server management
  //      information relays information about failed fans or high
  //      temperature in the system.
  //
  //
  // MemoryErrorSource
  //
  //      Identifies the source of a memory error as either main error
  //      or cache for either a system or processor.
  //
  // ScrubError
  //
  //      Instructs the driver to scrub the correctable error.  If the
  //      value is 1 the driver should scrub the error, if the value is
  //      0 the driver must not scrub the error.
  //
  // LostCorrectable
  //
  //      Identifies if a lost correctable error has been reported.  A
  //      lost error is an error that reported by the hardware while
  //      correctable error handling for a previous error was in progress.
  //      A value of 1 indicates that a correctable error report was lost.
  //
  // LostAddressSpace
  //
  //      Identifies the system address space that was the source of the
  //      correctable error.  Valid only if LostCorrectable == 1.
  //
  // LostMemoryErrorSource
  //
  //      Identifies the source of a memory error as either main error
  //      or cache for either a system or processor.  Valid only if
  //      LostCorrectable == 1.
  //

//
// Processor information.
//

typedef struct _PROCESSOR_INFO{
  
  ULONG ProcessorType;
  ULONG ProcessorRevision;
  ULONG PhysicalProcessorNumber;
  ULONG LogicalProcessorNumber;

} PROCESSOR_INFO, *PPROCESSOR_INFO;

  //
  // Description of PROCESSOR_INFO structure:
  //
  // ProcessorType
  //
  //      Identifies the type of processor running on the system 
  //      (eg. 21064, 21066, 21164).  Note that the type of processor
  //      is expected to be consistent across the system for MP machines.
  //
  // ProcessorRevision
  //
  //      Identifies the revision number of the processor running on
  //      the system.  Note that the revision is expected to be consistent
  //      across the system for MP machines.
  //
  // PhysicalProcessorNumber
  //
  //      The physical processor number as numbered in the hardware 
  //      specifications.
  //
  // LogicalProcessorNumber
  //
  //      The logical processor number assigned to the processor by NT.
  //

//
// System Information.
//

typedef struct _SYSTEM_INFORMATION{
  
  UCHAR SystemType[8];
  ULONG ClockSpeed;
  ULONG OsRevisionId;
  ULONG PalMajorVersion;
  ULONG PalMinorVersion;
  UCHAR FirmwareRevisionId[16];
  ULONG SystemVariant;
  ULONG SystemRevision;
  UCHAR SystemSerialNumber[16];
  ULONG ModuleVariant;
  ULONG ModuleRevision;
  ULONG ModuleSerialNumber;
} SYSTEM_INFORMATION, *PSYSTEM_INFORMATION;

  //
  // Description of SYSTEM_INFORMATION structure:
  //
  // SystemType
  //
  //      Identifies the type of system that reported the error 
  //      (eg. "Sable", "Gamma").  The actual format and value of the
  //      SystemType string is system-specific.
  //
  // OsRevisionId
  //
  //      A numeric value that identifies the OS revision executing
  //      on the system that reported the fault.
  //
  // PalRevisionId
  //
  //      A numeric value that identifies the pal revision executing
  //      on the system that reported the fault.
  //
  // FirmwareRevisionId
  //
  //      A numeric value that identifies the firmware revision executing
  //      on the system that reported the fault.
  //
  // SystemVariant
  //
  //      A numeric value used to distinguish variants of the same system
  //      type.  The values and their interpretation are system_specific.
  //
  // SystemRevision
  //
  //      A numeric value used to distinguish revisions of the same system
  //      type.  The values and their interpretation are system_specific.
  //
  //      

//
// Extended Error Information.
//

typedef union _EXTENDED_ERROR{

  struct{
    struct{
      ULONG CacheLevelValid: 1;
      ULONG CacheBoardValid: 1;
      ULONG CacheSimmValid: 1;
    } Flags;
    PROCESSOR_INFO ProcessorInfo;
    ULONG CacheLevel;
    ULONG CacheBoardNumber;
    ULONG CacheSimm;
    ULONG TransferType;
    ULONG Reserved;
  } CacheError;

  struct{
    struct{
      ULONG MemoryBoardValid: 1;
      ULONG MemorySimmValid: 1;
    } Flags;
    PROCESSOR_INFO ProcessorInfo;
    ULONG MemoryBoard;
    ULONG MemorySimm;
    ULONG TransferType;
    ULONG Reserved[2];
  } MemoryError;

  struct{
    INTERFACE_TYPE Interface;
    ULONG BusNumber;
    PHYSICAL_ADDRESS BusAddress;
    ULONG TransferType;
    ULONG Reserved[5];
  } IoError;

  struct{
    struct{
      ULONG FanNumberValid: 1;
      ULONG TempSensorNumberValid: 1;
      ULONG PowerSupplyNumberValid: 1;
      ULONG WatchDogExpiredValid: 1;
    } Flags;
    ULONG FanNumber;
    ULONG TempSensorNumber;
    ULONG PowerSupplyNumber;
    ULONG WatchdogExpiration;
    ULONG Reserved[5];
  } SystemError;
  
} EXTENDED_ERROR, *PEXTENDED_ERROR;

  //
  // Description of EXTENDED_ERROR union:
  //
  // The EXTENDED_ERROR union has different interpretation depending
  // upon the AddressSpace and MemoryErrorSource fields of the
  // CORRECTABLE_FLAGS structure according to the following table:
  //
  // 1. AddressSpace=MemorySpace 
  //    MemoryErrorSource = 01x       use CacheError structure
  //
  // 2. AddressSpace=MemorySpace
  //    MemoryErrorSource = 10x       use MemoryError structure
  //
  // 3. AddressSpace=IoSpace          use IoError
  //
  // 4. AddressSpace=Unidentified     use SystemError
  //    MemoryErrorSource = 0x0       (note: ServerManagementInformationValid
  //                                         should be set)
  //
  //
  // CacheError.Flags
  //
  //      Identifies which fields of the CacheError structure are valid.
  //      CacheLevelValid = 1 indicates CacheLevel is valid.
  //      CacheBoardValid = 1 indicates CacheBoardNumber is valid.
  //      CacheSimmValid = 1 indicates CacheSimm is valid.
  //
  // CacheError.ProcessorInfo
  //
  //      Identifies the processor associated with the error.  Most 
  //      frequently will identify the processor that experienced and 
  //      reported the error.  However, it is possible that the processor 
  //      that is reporting has experienced the error from another 
  //      processor's cache.  This field is valid only if the 
  //      MemoryErrorSource = 010 .
  //
  // CacheError.CacheLevel
  //
  //      Identifies the level of the cache that caused the error.  Primary
  //      caches are Level 1, Secondary are Level 2, etc..  This field
  //      only valid if CacheError.Flags.CacheLevelValid == 1.
  //
  // CacheError.CacheBoardNumber
  //
  //      Identifies the board number of the cache that caused the error.  
  //      This field only valid if 
  //      CacheError.Flags.CacheBoardNumberValid == 1.
  //
  // CacheError.CacheSimm
  //
  //      Identifies the Cache Simm that caused the error.
  //      This field only valid if CacheError.Flags.CacheSimmValid == 1.
  //
  //
  // MemoryError.Flags
  //
  //      Identifies which fields of the CacheError structure are valid.
  //      CacheLevelValid = 1 indicates CacheLevel is valid.
  //      CacheBoardValid = 1 indicates CacheBoardNumber is valid.
  //      CacheSimmValid = 1 indicates CacheSimm is valid.
  //
  // MemoryError.ProcessorInfo
  //
  //      Identifies the processor associated with the error.  Most 
  //      frequently will identify the processor that experienced and 
  //      reported the error.  However, it is possible that the processor 
  //      that is reporting has experienced the error from another 
  //      processor's cache.  This field is valid only if the 
  //      MemoryErrorSource = 010 .
  //
  // MemoryError.MemoryBoardNumber
  //
  //      Identifies the board number of the cache that caused the error.  
  //      This field only valid if MemoryError.Flags.MemoryBoardValid == 1.
  //
  // MemoryError.MemorySimm
  //
  //      Identifies the memory SIMM that caused the error.  
  //      This field only valid if MemoryError.Flags.MemorySimmValid == 1.
  //
  //
  // IoError.Interface
  //
  //      Identifies the bus interface type (eg. PCI) of the bus that caused
  //      the correctable error.
  //
  // IoError.BusNumber
  //
  //      Identifies the bus number of the bus that caused the correctable 
  //      error.
  //
  // IoError.BusAddress
  //
  //      Identifies the bus address of the bus that caused the correctable 
  //      error.
  //

//
// Correctable Error Frame.
//

typedef struct _CORRECTABLE_ERROR{

  CORRECTABLE_FLAGS Flags;
  ULONGLONG PhysicalAddress;
  ULONGLONG DataBitErrorMask;
  ULONGLONG CheckBitErrorMask;
  EXTENDED_ERROR ErrorInformation;
  PROCESSOR_INFO ReportingProcessor;
  SYSTEM_INFORMATION System;
  ULONG RawProcessorInformationLength;
  PVOID RawProcessorInformation;
  ULONG RawSystemInformationLength;
  PVOID RawSystemInformation;
  ULONG Reserved;
  
} CORRECTABLE_ERROR, *PCORRECTABLE_ERROR;

  //
  // Description of CORRECTABLE_ERROR structure:
  //
  // Flags
  //
  //      The flags describe the various aspects of the error report.  The
  //      CORRECTABLE_FLAGS structure is described below.
  //
  // PhysicalAddress
  //
  //      The physical CPU address of the quadword that caused the correctable
  //      error report.  This value is optional, its validiity is indicated
  //      in the Flags.
  //
  // DataBitErrorMask
  //
  //      A mask that describes which data bits in the corrected word were
  //      in error.  A value of one in the mask indicates that the 
  //      corresponding bit in the data word were in error.
  //
  // CheckBitErrorMask
  //
  //      A mask that describes which check bits in the corrected word were
  //      in error.  A value of one in the mask indicates that the 
  //      corresponding bit in the check bits were in error.
  //
  // ErrorInformation
  //
  //      A structure that desribes interpretation of the error.  The values
  //      in the structure are optional, the EXTENDED_ERROR structure is
  //      described below.
  //
  // ReportingProcessor
  //
  //      A structure that describes the processor type on the system and
  //      the processor that reported the error.  PROCESSOR_INFO structure
  //      is described below.
  //      
  // RawProcessorInformationLength
  //
  //      The length of the raw processor error information structure in
  //      bytes.
  //
  // RawProcessorInformation
  //
  //      A pointer to the raw processor error information structure.  The
  //      definition of the structure is processor-specific.  The definitions
  //      for the known processors is defined in Appendix A below.
  //
  // System
  //
  //      A structure that describes the type of system for which the
  //      error was reported.  SYSTEM_INFORMATION structure is described below.
  //
  // RawSystemInformationLength
  //
  //      The length of the raw processor error information structure in
  //      bytes.
  //
  // RawSystemInformation
  //
  //      A pointer to the raw system error information structure.  The
  //      definition of the structure is system/ASIC-specific.  The 
  //      definitions for the known systems/ASICs is defined in Appendix B.
  //
  //


/* 
 *
 * Definitions for the uncorrectable error frame.
 *
 */

//
// Uncorrectable Error Flags.
//

typedef struct _UNCORRECTABLE_FLAGS{
  
  //
  // Address space
  //  Unidentified: 00
  //  Memory Space: 01
  //  I/O Space:    10
  //  Reserved:     11
  //

  ULONGLONG AddressSpace: 2;

  //
  // Error Interpretation Validity.
  //

  ULONGLONG ErrorStringValid: 1;
  ULONGLONG PhysicalAddressValid: 1;
  ULONGLONG ErrorBitMasksValid: 1;
  ULONGLONG ExtendedErrorValid: 1;
  ULONGLONG ProcessorInformationValid: 1;
  ULONGLONG SystemInformationValid: 1;

  //
  // Memory Space Error Source:
  //
  //  Unidentified:    000
  //  ProcessorCache:  010
  //  SystemCache:     011
  //  ProcessorMemory: 100
  //  SystemMemory:    101
  //

  ULONGLONG MemoryErrorSource: 4;

} UNCORRECTABLE_FLAGS, *PUNCORRECTABLE_FLAGS;

  //
  // The extended error information, processor information and system
  // information structures are identical for correctable and uncorrectable
  // errors.  The rules for printing the failing FRU are also identical
  // to the rules for the correctable errors.
  //

//
// Uncorrectable Error Frame.
//

typedef struct _UNCORRECTABLE_ERROR{

  UNCORRECTABLE_FLAGS Flags;
  CHAR ErrorString[MAX_UNCORRERR_STRLEN];
  ULONGLONG PhysicalAddress;
  ULONGLONG DataBitErrorMask;
  ULONGLONG CheckBitErrorMask;
  EXTENDED_ERROR ErrorInformation;
  PROCESSOR_INFO ReportingProcessor;
  SYSTEM_INFORMATION System;
  ULONG RawProcessorInformationLength;
  PVOID RawProcessorInformation;
  ULONG RawSystemInformationLength;
  PVOID RawSystemInformation;
  ULONG Reserved;

} UNCORRECTABLE_ERROR, *PUNCORRECTABLE_ERROR;


/* 
 *
 * Generic definitions for the error frame.
 *
 */

//
// Generic error frame.
//

typedef enum _FRAME_TYPE{
  CorrectableFrame,
  UncorrectableFrame
} FRAME_TYPE, *PFRAME_TYPE;

typedef struct _ERROR_FRAME{

  ULONG Signature;          // Needed to make sure that the buffer is infact
                            // an error frame.
  ULONG      LengthOfEntireErrorFrame;
  FRAME_TYPE FrameType;
  ULONG      VersionNumber;
  ULONG      SequenceNumber;
  ULONGLONG  PerformanceCounterValue;

  union {
    CORRECTABLE_ERROR CorrectableFrame;
    UNCORRECTABLE_ERROR UncorrectableFrame;
  };
  
} ERROR_FRAME, *PERROR_FRAME;

  //
  // Description of the generic error frame structure:
  //
  // FrameType
  //
  //      Specify which frame type we have.  Either correctable or
  //      uncorrectable.
  //
  // VersionNumber
  //
  //      Defines the version of the error structure.  Current version
  //      number = 1.
  //
  // SequenceNumber
  //
  //      A number that identifies a particular error frame.
  //
  // PerformanceCounterValue
  //
  //      The value of the system performance counter when the error was
  //      reported.  The value is determined during error processing by the
  //      HAL and so may be captured significantly after the hardware
  //      detected the error.  The value cannot be used for fine grained
  //      timing of when errors occurred but can be used for coarse grained
  //      timing and approximate timing.
  //
  // CorrectableFrame
  //
  //      Shared common area for a correctable frame.
  //
  // UncorrectableFrame
  // 
  //      Shared common area for an uncorrectable frame.
  //

#endif //ERRFRAME_H