/****************************************************************************
  Copyright (c) 2006, Dell Inc
  All rights reserved.
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
  - Redistributions of source code must retain the above copyright notice,
    this list of conditions and the following disclaimer.
    
  - Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution. 
  - Neither the name of Dell Inc nor the names of its contributors
    may be used to endorse or promote products derived from this software 
    without specific prior written permission. 
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  POSSIBILITY OF SUCH DAMAGE. 
 
 
*****************************************************************************/

#include <ipmitool/cssipmi.h>
#include <ipmitool/cssapi.h>
#include <ipmitool/cssstat.h>
#include <ipmitool/csssupt.h>

char g_PciSlot[]               = "PCI Slot ";
char g_Drive[]                 = "Drive ";
char g_Slot[]                  = "Slot ";
char g_OemEventRecord[]        = "OEM event data record";
char g_SoftwareEvent[]         = "System Software event";
char g_sensor[]                = " sensor";
char g_sensorfor[]             = " sensor for ";
char g_systemboot[]            = "<System Boot>";
char g_wasAsserted[]           = " was asserted";
char g_wasDeasserted[]         = " was deasserted";
char g_oemEvent[]              = "OEM Diagnostic data event";
char g_whileOn[]               = " while system was ON";
char g_whileOff[]              = " while system was OFF";


char g_DefaultUnknownStatus[]  = "unknown event";
char g_Normal[]                = "normal event";
char g_Warning[]               = "warning event";
char g_Failure[]               = "failure event";
char g_DetectedNR[]            = "non-recoverable event";

/****************************************************************************
  Generic reading/event tables
****************************************************************************/

#ifndef SYSTEM_BBB
/* Discrete type 2  */ 
#define GENERICTYPE2_SIZE (3)
AppendStateText g_GenericType2[GENERICTYPE2_SIZE] =
{ 
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,  "transition to idle"}, 
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,  "transition to active"},           
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL,  "transition to busy"}
};
#endif 

/* Discrete type 3  */
#define GENERICTYPE3_SIZE (2)
AppendStateText g_GenericType3[GENERICTYPE3_SIZE] =
{
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,  "state deasserted"},     
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,  "state asserted"}
};

/* Discrete type 4  */ 
#define GENERICTYPE4_SIZE (2)
AppendStateText g_GenericType4[GENERICTYPE4_SIZE] =
{ 
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,   "predictive failure deasserted"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL,   "predictive failure asserted"}
};

#ifndef SYSTEM_BBB
/* Discrete type 5  */  
#define GENERICTYPE5_SIZE (2)
AppendStateText g_GenericType5[GENERICTYPE5_SIZE] =
{
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,   "limit not exceeded"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL,   "limit exceeded"}
};
#endif 

#ifndef SYSTEM_BBB
/* Discrete type 6 */
#define GENERICTYPE6_SIZE (2)
AppendStateText g_GenericType6[GENERICTYPE6_SIZE] =      
{ 
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,  "performance met"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL,  "performance lags"}
};
#endif 
  
/* Discrete type 7 */  
#define GENERICTYPE7_SIZE (9)
AppendStateText g_GenericType7[GENERICTYPE7_SIZE] =
{
    {CSS_SEVERITY_NORMAL,           CSS_SEVERITY_NORMAL,  "transition to OK"},
    {CSS_SEVERITY_WARNING,          CSS_SEVERITY_NORMAL,  "transition to non-critical from OK"},
    {CSS_SEVERITY_CRITICAL,         CSS_SEVERITY_NORMAL,  "transition to critical from less severe"},
    {CSS_SEVERITY_NONRECOVERABLE,   CSS_SEVERITY_NORMAL,  "transition to non-recoverable from less severe"},
    {CSS_SEVERITY_WARNING,          CSS_SEVERITY_NORMAL,  "transition to non-critical from more severe"},
    {CSS_SEVERITY_CRITICAL,         CSS_SEVERITY_NORMAL,  "transition to critical from Non-recoverable"},
    {CSS_SEVERITY_NONRECOVERABLE,   CSS_SEVERITY_NORMAL,  "transition to non-recoverable"},
    {CSS_SEVERITY_INFORMATIONAL,    CSS_SEVERITY_INFORMATIONAL,  "monitor"},
    {CSS_SEVERITY_INFORMATIONAL,    CSS_SEVERITY_INFORMATIONAL,  "informational"}
};

#ifndef SYSTEM_BBB
/* Discrete type 8  */ 
#define GENERICTYPE8_SIZE (2)
AppendStateText g_GenericType8[GENERICTYPE8_SIZE] =     
{    
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "device removed"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "device inserted"}
};
#endif 

#ifndef SYSTEM_BBB
/* Discrete type 9  */ 
#define GENERICTYPE9_SIZE (2) 
AppendStateText g_GenericType9[GENERICTYPE9_SIZE] =
{ 
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "device disabled"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "device enabled"}
};
#endif 

/* Discrete type A  */ 
#define GENERICTYPEA_SIZE (9)  
AppendStateText g_GenericTypeA[GENERICTYPEA_SIZE] =
{ 
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "transitioned to running"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "transitioned to in-test"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "transitioned to power off"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "transitioned to on-line"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "transitioned to off-line"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "transitioned to off-duty"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL, "transitioned to a degraded state"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "transitioned to power save state"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "install error"}
};

/* Discrete type B Redundancy  */ 
#define GENERICTYPEB_SIZE (8)   
AppendStateText g_GenericTypeB[GENERICTYPEB_SIZE] =
{ 
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "redundancy regained"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "redundancy lost"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL, "redundancy degraded"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "non-redundant"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "non-redundant"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "non-redundant"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL, "redundancy degraded"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL, "redundancy degraded"},
};
    
#ifndef SYSTEM_BBB
/* Discrete type C  */ 
#define GENERICTYPEC_SIZE (4)  
AppendStateText g_GenericTypeC[GENERICTYPEC_SIZE] =
{
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "D0 power state"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "D1 power state"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "D2 power state"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "D3 power state"}
};
#endif 


/* Generic  access Table */
AppendStateElement g_GenericTable[GENERIC_TABLE_SIZE] =
{
#ifndef SYSTEM_BBB
    {IPMI_READING_TYPE_DISCRETE,        GENERICTYPE2_SIZE,  g_GenericType2},
#endif 
    {IPMI_READING_TYPE_DIG_DISCRETE3,   GENERICTYPE3_SIZE,  g_GenericType3},
#ifndef SYSTEM_BBB
    {IPMI_READING_TYPE_DIG_DISCRETE4,   GENERICTYPE4_SIZE,  g_GenericType4},
    {IPMI_READING_TYPE_DIG_DISCRETE5,   GENERICTYPE5_SIZE,  g_GenericType5},
    {IPMI_READING_TYPE_DIG_DISCRETE6,   GENERICTYPE6_SIZE,  g_GenericType6},
#endif 
    {IPMI_READING_TYPE_DIG_DISCRETE7,   GENERICTYPE7_SIZE,  g_GenericType7},
#ifndef SYSTEM_BBB
    {IPMI_READING_TYPE_DIG_DISCRETE8,   GENERICTYPE8_SIZE,  g_GenericType8},
    {IPMI_READING_TYPE_DIG_DISCRETE9,   GENERICTYPE9_SIZE,  g_GenericType9},
    {IPMI_READING_TYPE_DISCRETE0A,      GENERICTYPEA_SIZE,  g_GenericTypeA},
#endif 
    {IPMI_READING_TYPE_REDUNDANCY,      GENERICTYPEB_SIZE,  g_GenericTypeB},
#ifndef SYSTEM_BBB
    {IPMI_READING_TYPE_DISCRETE0C,      GENERICTYPEC_SIZE,  g_GenericTypeC},
#endif 
};

/****************************************************************************
  Specific reading/event tables
****************************************************************************/
 
/* 5 intrusion */ 
#define SPECIFICTYPE5_SIZE  (7)
AppendStateText g_SpecificType5[SPECIFICTYPE5_SIZE] =
{
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "chassis intrusion"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "drive bay intrusion"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "I/O card area intrusion"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "processor area intrusion"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "LAN disconnect"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "unauthorized dock"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "FAN area intrusion"}
};

#ifndef SYSTEM_BBB
/* 6 Security Violation */ 
#define SPECIFICTYPE6_SIZE  (6)   
AppendStateText g_SpecificType6[SPECIFICTYPE6_SIZE] =
{
    {CSS_SEVERITY_WARNING, CSS_SEVERITY_NORMAL, "secure mode violation"},
    {CSS_SEVERITY_WARNING, CSS_SEVERITY_NORMAL, "pre-boot user password violation"},
    {CSS_SEVERITY_WARNING, CSS_SEVERITY_NORMAL, "pre-boot setup password violation"},
    {CSS_SEVERITY_WARNING, CSS_SEVERITY_NORMAL, "network boot password violation"},
    {CSS_SEVERITY_WARNING, CSS_SEVERITY_NORMAL, "password violation"},
    {CSS_SEVERITY_WARNING, CSS_SEVERITY_NORMAL, "out-of-band password violation"}
};
#endif 

/* 7 Processor */ 
#define SPECIFICTYPE7_SIZE  (11)    
AppendStateText g_SpecificType7[SPECIFICTYPE7_SIZE] =
{
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "IERR"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "thermal tripped"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "FRB1/BIST failure"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "FRB2/Hang in POST failure"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "FRB3 initialization failure"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "configuration error"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "uncorrectable CPU complex"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_CRITICAL,  "presence"},
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL,    "disabled"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL,    "terminator presence"},
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL,    "throttled"}
}; 
    
/* 8 Power Supply */ 
#define SPECIFICTYPE8_SIZE  (7)    
AppendStateText g_SpecificType8[SPECIFICTYPE8_SIZE] =
{
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_CRITICAL,  "presence"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "failure"},
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL,    "predictive failure"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "input lost"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "input lost or out of range"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "input present but out of range"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "configuration error"}
}; 
    
#ifndef SYSTEM_BBB
/* 9 Power Unit */ 
#define SPECIFICTYPE9_SIZE  (8)       
AppendStateText g_SpecificType9[SPECIFICTYPE9_SIZE] =
{
    {CSS_SEVERITY_INFORMATIONAL,CSS_SEVERITY_INFORMATIONAL, "power off"},
    {CSS_SEVERITY_INFORMATIONAL,CSS_SEVERITY_INFORMATIONAL, "power cycle"},
    {CSS_SEVERITY_CRITICAL,     CSS_SEVERITY_NORMAL,        "240VA power down error"},
    {CSS_SEVERITY_CRITICAL,     CSS_SEVERITY_NORMAL,        "interlock power down error"},
    {CSS_SEVERITY_CRITICAL,     CSS_SEVERITY_NORMAL,        "power lost error"},
    {CSS_SEVERITY_CRITICAL,     CSS_SEVERITY_NORMAL,        "soft power control failure"},
    {CSS_SEVERITY_CRITICAL,     CSS_SEVERITY_NORMAL,        "power unit failure"},
    {CSS_SEVERITY_WARNING,      CSS_SEVERITY_NORMAL,        "predictive failure"}
}; 
#endif 
    
/* C Memory */ 
#define SPECIFICTYPEC_SIZE  (11)     
AppendStateText g_SpecificTypeC[SPECIFICTYPEC_SIZE] =
{
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL, "correctable ECC"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "uncorrectable ECC"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "parity error"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "scrub failed (stuck bit)"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "device disabled"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "ECC logging limit reached"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_WARNING,"presence"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "configuration error"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "spare"},
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL, "throttled"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "critical overtemperature"}
}; 
    
/* D Drive Bay/Slot */ 
#define SPECIFICTYPED_SIZE  (9)    
AppendStateText g_SpecificTypeD[SPECIFICTYPED_SIZE] =
{
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_CRITICAL,  "drive presence"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "drive fault"},
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL,    "predictive failure"},
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL,    "hot spare"},
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL,    "consistency check in progress"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "in critical array"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,    "in failed array"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL,    "rebuild in progress"},
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL,    "rebuild aborted"}
};

#ifndef SYSTEM_BBB
/* E POST Memory Resize */ 
#define SPECIFICTYPEE_SIZE  (1)   
AppendStateText g_SpecificTypeE[SPECIFICTYPEE_SIZE] =
{
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL,    "memory resized"}
};
#endif 
    
/* F POST error */
#define SPECIFICTYPEF_SIZE  (3)
AppendStateText g_SpecificTypeF[SPECIFICTYPEF_SIZE] =
{ 
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "POST error"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "system firmware hang"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "system firmware progress"}
};
    
/* 10 event logging */
#define SPECIFICTYPE10_SIZE  (7)
AppendStateText g_SpecificType10[SPECIFICTYPE10_SIZE] =
{
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "correctable memory error logging disabled"},   
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "event logging disabled"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "log cleared"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "all event logging disabled"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "log full"},
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL, "log almost full"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "install error"}
};
    
#ifndef SYSTEM_BBB
/* 11 Watchdog1 */
#define SPECIFICTYPE11_SIZE  (8)  
AppendStateText g_SpecificType11[SPECIFICTYPE11_SIZE] =
{
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"BIOS watchdog reset"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"OS watchdog reset"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"OS watchdog shutdown"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"OS watchdog power down"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"OS watchdog power cycle"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"OS watchdog power off"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"OS watchdog expired"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"OS watchdog pre-timeout interrupt"}
};  
#endif 
    
/* 12 System Event */
#define SPECIFICTYPE12_SIZE  (6) 
AppendStateText g_SpecificType12[SPECIFICTYPE12_SIZE] =
{
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "system reconfigured"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "OEM system boot event"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "unknown system hardware failure"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "auxilary log entry event"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "PEF action executed"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "timestamp clock synch"}
};
    
/* 13 Critical Interrupt */
#define SPECIFICTYPE13_SIZE  (11) 
AppendStateText g_SpecificType13[SPECIFICTYPE13_SIZE] =
{
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "front panel NMI / diagnostic interrupt"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "bus timeout"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "I/O channel check NMI"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "software NMI"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "PCI PERR"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "PCI SERR"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "EISA fail safe timeout"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "bus correctable error"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "bus uncorrectable error"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "fatal NMI"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "bus fatal error"}
};
    
#ifndef SYSTEM_BBB
/* 14 Button / Switch */
#define SPECIFICTYPE14_SIZE  (5) 
AppendStateText g_SpecificType14[SPECIFICTYPE14_SIZE] =
{
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "power button"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "sleep button"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "reset button"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "FRU latch"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "FRU service request"}
};
    
/* 19 Chip Set */
#define SPECIFICTYPE19_SIZE  (1) 
AppendStateText g_SpecificType19[SPECIFICTYPE19_SIZE] =
{
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "soft power control failure"}
};
#endif 

/* 1B Cable / Interconnect */
#define SPECIFICTYPE1B_SIZE  (2) 
AppendStateText g_SpecificType1B[SPECIFICTYPE1B_SIZE] =
{
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,"connection"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"configuration error"}
};
    
    
#ifndef SYSTEM_BBB
/* 1D System Boot */
#define SPECIFICTYPE1D_SIZE  (8) 
AppendStateText g_SpecificType1D[SPECIFICTYPE1D_SIZE] =
{
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "power up"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "hard reset"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "warm reset"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "user requested PXE boot"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "automatic boot to diagnostic"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "OS/run-time software initiated hard reset"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "OS/run-time software initiated warm reset"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "system restart"}
};
#endif 

#ifndef SYSTEM_BBB
/* 1E Boot Error */
#define SPECIFICTYPE1E_SIZE  (5) 
AppendStateText g_SpecificType1E[SPECIFICTYPE1E_SIZE] =
{
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "no bootable media"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "non-bootable diskette"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "PXE server not found"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "invalid boot sector"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "timeout waiting for user to select boot source"}
};
    
/* 1F OS Boot */
#define SPECIFICTYPE1F_SIZE  (7) 
AppendStateText g_SpecificType1F[SPECIFICTYPE1F_SIZE] =
{
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_CRITICAL, "A: boot completed"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_CRITICAL, "C: boot completed"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_CRITICAL, "PXE boot completed"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_CRITICAL, "diagnostic boot completed"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_CRITICAL, "CD-ROM boot completed"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_CRITICAL, "ROM boot completed"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_CRITICAL, "boot completed"},
};
#endif 
    
/* 20 OS Stop / Shutdown */
#define SPECIFICTYPE20_SIZE  (6) 
AppendStateText g_SpecificType20[SPECIFICTYPE20_SIZE] =
{
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "critical stop during OS load"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "run-time critical stop"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "OS graceful stop"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL, "OS graceful shutdown"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "soft shutdown initiated by PEF"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "agent not responding"},
};
    
#ifndef SYSTEM_BBB
/* 21 Slot */
#define SPECIFICTYPE21_SIZE  (10) 
AppendStateText g_SpecificType21[SPECIFICTYPE21_SIZE] =
{
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "fault status"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "identify status"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "installed"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "ready for installation"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "ready for removal"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "power is off"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "removal requested"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "interlock active"},
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL, "slot disabled"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "slot holds spare device"}
};
#endif 
    
#ifndef SYSTEM_BBB
/* 22 System ACPI Power State */
#define SPECIFICTYPE22_SIZE  (13) 
AppendStateText g_SpecificType22[SPECIFICTYPE22_SIZE] =
{
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "S0/G0"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "S1 state"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "S2 state"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "S3 state"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "S4 state"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "S5/G2 soft-off"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "S4/S5 soft-off"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "G3/mechanical Off"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "sleeping in an S1, S2, or S3 states"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "G1 sleeping"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "S5 entered by override"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "legacy ON"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "legacy OFF"}
};
#endif 
    
/* 23 Watchdog 2 */
#define SPECIFICTYPE23_SIZE  (9)
AppendStateText g_SpecificType23[SPECIFICTYPE23_SIZE] =
{
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "timer expired"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "reboot"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "power off"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "power cycle"},
    {CSS_SEVERITY_UNKNOWN,  CSS_SEVERITY_UNKNOWN, g_DefaultUnknownStatus},        
    {CSS_SEVERITY_UNKNOWN,  CSS_SEVERITY_UNKNOWN, g_DefaultUnknownStatus},        
    {CSS_SEVERITY_UNKNOWN,  CSS_SEVERITY_UNKNOWN, g_DefaultUnknownStatus},        
    {CSS_SEVERITY_UNKNOWN,  CSS_SEVERITY_UNKNOWN, g_DefaultUnknownStatus},        
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL,  "timer interrupt"}
};
    
#ifndef SYSTEM_BBB
/* 24 Platform Alert */
#define SPECIFICTYPE24_SIZE  (4)
AppendStateText g_SpecificType24[SPECIFICTYPE24_SIZE] =
{
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "generated page"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "generated LAN alert"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "generated event trap"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "generated SNMP trap"}
};
#endif 
    
/* 25 Entity Presence */
#define SPECIFICTYPE25_SIZE  (3)
AppendStateText g_SpecificType25[SPECIFICTYPE25_SIZE] =
{
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,"presence"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"absent"},
    {CSS_SEVERITY_NORMAL ,   CSS_SEVERITY_NORMAL,"disable"}
};

#ifndef SYSTEM_BBB
/* 27 LAN */
#define SPECIFICTYPE27_SIZE  (2)
AppendStateText g_SpecificType27[SPECIFICTYPE27_SIZE] =
{
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"LAN heartbeat lost"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,"LAN heartbeat"}
};

/* 28 Management Subsystem Health */
#define SPECIFICTYPE28_SIZE  (7)
AppendStateText g_SpecificType28[SPECIFICTYPE28_SIZE] =
{
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_WARNING,"on-line"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL, "sensor access degraded/unavailable"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL, "controller access degraded/unavailable"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL, "management controller off-line"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL, "management controller unavailable"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "sensor failure"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL, "FRU failure"}
};
#endif 

/* 29 Battery */
#define SPECIFICTYPE29_SIZE  (3)
AppendStateText g_SpecificType29[SPECIFICTYPE29_SIZE] =
{
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL, "is low"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "failed"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "presence"}
};    
    
#ifndef SYSTEM_BBB
/* 2A Session Audit */
#define SPECIFICTYPE2A_SIZE  (2)
AppendStateText g_SpecificType2A[SPECIFICTYPE2A_SIZE] =
{
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,"session activation"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,"session deactivation"}
};
#endif 
    
/* 2B Version Change */
#define SPECIFICTYPE2B_SIZE  (8)
AppendStateText g_SpecificType2B[SPECIFICTYPE2B_SIZE] =
{
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL, "hardware changed"},
    {CSS_SEVERITY_WARNING,  CSS_SEVERITY_NORMAL, "firmware or software changed"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "hardware incompatibility"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "firmware or software incompatibility"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "invalid/unsupported hardware version"},
    {CSS_SEVERITY_CRITICAL, CSS_SEVERITY_NORMAL, "invalid/unsupported firmware/software version"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "successful hardware change"},
    {CSS_SEVERITY_NORMAL,   CSS_SEVERITY_NORMAL, "successful software or F/W change"}
};
    
#ifndef SYSTEM_BBB
/* 2C FRU State */
#define SPECIFICTYPE2C_SIZE  (8)
AppendStateText g_SpecificType2C[SPECIFICTYPE2C_SIZE] =
{
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL,"not installed"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,"inactive (in standby or 'hot spare' state)"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,"activation request"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,"activation in progress"},
    {CSS_SEVERITY_NORMAL,    CSS_SEVERITY_NORMAL,"active"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL,"deactivation request"},
    {CSS_SEVERITY_WARNING,   CSS_SEVERITY_NORMAL,"deactivation in progress"},
    {CSS_SEVERITY_CRITICAL,  CSS_SEVERITY_NORMAL,"communication lost"}
};
#endif 

/* Specific Assert access Table */
AppendStateElement g_SpecificTable[SPECIFIC_TABLE_SIZE] =
{
    {IPMI_SENSOR_INTRUSION,        SPECIFICTYPE5_SIZE,     g_SpecificType5},
    {IPMI_SENSOR_PROCESSOR,        SPECIFICTYPE7_SIZE,     g_SpecificType7},
    {IPMI_SENSOR_PS,               SPECIFICTYPE8_SIZE,     g_SpecificType8},
    {IPMI_SENSOR_MEMORY,           SPECIFICTYPEC_SIZE,     g_SpecificTypeC},
    {IPMI_SENSOR_DRIVE_SLOT,       SPECIFICTYPED_SIZE,     g_SpecificTypeD},
    {IPMI_SENSOR_POST_ERROR,       SPECIFICTYPEF_SIZE,     g_SpecificTypeF},
    {IPMI_SENSOR_CRIT_EVENT,       SPECIFICTYPE13_SIZE,    g_SpecificType13},
    {IPMI_SENSOR_EVENT_LOGGING,    SPECIFICTYPE10_SIZE,    g_SpecificType10},
    {IPMI_SENSOR_SYSTEM_EVENT,     SPECIFICTYPE12_SIZE,    g_SpecificType12},
    {IPMI_SENSOR_CI,               SPECIFICTYPE1B_SIZE,    g_SpecificType1B},
    {IPMI_SENSOR_OS_CRITICAL_STOP, SPECIFICTYPE20_SIZE,    g_SpecificType20},
    {IPMI_SENSOR_WDOG2,            SPECIFICTYPE23_SIZE,    g_SpecificType23},
    {IPMI_SENSOR_ENTITY_PRESENCE,  SPECIFICTYPE25_SIZE,    g_SpecificType25},
    {IPMI_SENSOR_BATTERY,          SPECIFICTYPE29_SIZE,    g_SpecificType29},
    {IPMI_SENSOR_VERSION_CHANGE,   SPECIFICTYPE2B_SIZE,    g_SpecificType2B},

#ifndef SYSTEM_BBB
    {IPMI_SENSOR_SECURE_MODE,      SPECIFICTYPE6_SIZE,     g_SpecificType6},
    {IPMI_SENSOR_POWER_UNIT,       SPECIFICTYPE9_SIZE,     g_SpecificType9},
    {IPMI_SENSOR_MEM_RESIZE,       SPECIFICTYPEE_SIZE,     g_SpecificTypeE},
    {IPMI_SENSOR_WDOG,             SPECIFICTYPE11_SIZE,    g_SpecificType11},
    {IPMI_SENSOR_POWER_BUTTON,     SPECIFICTYPE14_SIZE,    g_SpecificType14},
    {IPMI_SENSOR_CHIP_SET,         SPECIFICTYPE19_SIZE,    g_SpecificType19},
    {IPMI_SENSOR_SYSTEM_BOOT,      SPECIFICTYPE1D_SIZE,    g_SpecificType1D},
    {IPMI_SENSOR_BOOT_ERROR,       SPECIFICTYPE1E_SIZE,    g_SpecificType1E},
    {IPMI_SENSOR_OS_BOOT,          SPECIFICTYPE1F_SIZE,    g_SpecificType1F},
    {IPMI_SENSOR_SLOT,             SPECIFICTYPE21_SIZE,    g_SpecificType21},
    {IPMI_SENSOR_ACPI,             SPECIFICTYPE22_SIZE,    g_SpecificType22},
    {IPMI_SENSOR_PLATFORM_ALERT,   SPECIFICTYPE24_SIZE,    g_SpecificType24},
    {IPMI_SENSOR_LAN,              SPECIFICTYPE27_SIZE,    g_SpecificType27},
    {IPMI_SENSOR_MGMT_SYS_HEALTH,  SPECIFICTYPE28_SIZE,    g_SpecificType28},    
    {IPMI_SENSOR_SESSION_AUDIT,    SPECIFICTYPE2A_SIZE,    g_SpecificType2A},
    {IPMI_SENSOR_FRU_STATE,        SPECIFICTYPE2C_SIZE,    g_SpecificType2C}
#endif 
};

PostCodeType g_PostMessages[POST_TABLE_SIZE] =
{
  {0x80, "No memory installed"},
  {0x81, "Memory configuration error"},
  {0x82, "Unusable memory error"},
  {0x83, "Shadow BIOS failed"},
  {0x84, "CMOS failed"},
  {0x85, "DMA controller failed"},
  {0x86, "Interrupt controller failed"},
  {0x87, "Timer refresh failed"},
  {0x88, "Programmable interval timer error"},
  {0x89, "Parity error"},
  {0x8A, "SIO failed"},
  {0x8B, "Keyboard controller failed"},
  {0x8C, "System management interrupt initialization failed"},
  {0xC0, "BIOS shutdown test failed"},
  {0xC1, "BIOS POST memory test failed"},
  {0xC2, "Dell remote access controller configuration failed"},
  {0xC3, "CPU configuration failed"},
  {0xC4, "Incorrect memory configuration"},
  {0xFE, "POST failure"}
};