Imported Upstream version 2.9.3upstream/2.9.3

1 files changed, 934 insertions, 0 deletions

diff --git a/hpiutil/hpisel.c b/hpiutil/hpisel.c
new file mode 100644
index 0000000..e922b81
--- /dev/null
+++ b/hpiutil/hpisel.c
@@ -0,0 +1,934 @@
+/*
+ * hpisel.c
+ *
+ * Author:  Andy Cress  arcress at users.sourceforge.net
+ * Copyright (c) 2003-2005 Intel Corporation.
+ *
+ * 04/28/03 Andy Cress - created
+ * 04/30/03 Andy Cress  v0.6 first good run with common use cases
+ * 05/06/03 Andy Cress  v0.7 added -c option to clear it
+ * 05/29/03 Andy Cress  v0.8 fixed pstr warnings
+ * 06/13/03 Andy Cress  v0.9 fixed strcpy bug, 
+ *                          workaround for SensorEvent.data3
+ * 06/19/03 Andy Cress  0.91 added low SEL free space warning
+ * 06/25/03 Andy Cress  v1.0 rework event data logic 
+ * 07/23/03 Andy Cress  workaround for OpenHPI BUGGY stuff
+ * 11/12/03 Andy Cress  v1.1 check for CAPABILITY_SEL
+ * 03/03/04 Andy Cress  v1.2 use better free space logic now
+ * 10/14/04 Andy Cress  v1.3 added HPI_A/HPI_B logic
+ * 02/11/05 Andy Cress  v1.4 added decode routines from showsel.c
+ * 03/30/05 Dave Howell v1.5 added support to enable displaying domain 
+ *                           event log for HPI_B
+ * 04/07/05 Andy Cress  v1.6 fix domain resourceid & HPI_A/B flags,
+ *                           add logic to clear domain event log.
+ * 
+ * Note that hpiutil 1.0.0 did not return all event data fields, so event
+ * types other than 'user' did not have all bytes filled in as they
+ * would have from IPMI alone.  A patch to the Intel HPI library in
+ * version 1.0.1 resolved this.
+ */
+/*M*
+Copyright (c) 2003-2005, Intel Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+  a.. Redistributions of source code must retain the above copyright notice, 
+      this list of conditions and the following disclaimer. 
+  b.. 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. 
+  c.. Neither the name of Intel Corporation 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.
+ *M*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <string.h>
+#include <time.h>
+#include "SaHpi.h"
+
+#ifdef HPI_A
+/* HPI A (1.0) spec */
+char progver[] = "1.6 HPI-A";
+#else
+/* HPI B name changes */
+#define SaHpiSelEntryT    SaHpiEventLogEntryT
+#define SaHpiSelEntryIdT  SaHpiEventLogEntryIdT
+#define SaHpiSelInfoT     SaHpiEventLogInfoT
+#define SAHPI_CAPABILITY_SEL SAHPI_CAPABILITY_EVENT_LOG  /*0x00000004*/
+#define SAHPI_EC_USER     SAHPI_EC_SENSOR_SPECIFIC       /*0x7E*/
+char progver[] = "1.6 HPI-B";
+#endif
+int fdebug  = 0;
+int fclear  = 0;
+int fdomain = 0;
+
+#ifdef HPI_A
+#define NEVTYPES  5
+char *evtypes[NEVTYPES] = {"sensor","hotswap","watchdog","oem   ","user  "};
+#else
+#define NEVTYPES  9
+char *evtypes[NEVTYPES] = {"resource","domain","sensor","sens_enable",
+			  "hotswap","watchdog","HPI sw", "oem   ","user  "};
+#endif
+
+#define NECODES  27
+struct { int code; char *str;
+} ecodes[NECODES] = { 
+ {  0,    "Success" },
+ { -1001, "HPI unspecified error" },
+ { -1002, "HPI unsupported function" },
+ { -1003, "HPI busy" },
+ { -1004, "HPI request invalid" },
+ { -1005, "HPI command invalid" },
+ { -1006, "HPI timeout" },
+ { -1007, "HPI out of space" },
+ { -1008, "HPI data truncated" },
+#ifdef HPI_A
+ { -1009, "HPI data length invalid" },
+#else
+ { -1009, "HPI invalid parameter" },
+#endif
+ { -1010, "HPI data exceeds limits" },
+ { -1011, "HPI invalid params" },
+ { -1012, "HPI invalid data" },
+ { -1013, "HPI not present" },
+ { -1014, "HPI invalid data field" },
+ { -1015, "HPI invalid sensor command" },
+ { -1016, "HPI no response" },
+ { -1017, "HPI duplicate request" },
+ { -1018, "HPI updating" },
+ { -1019, "HPI initializing" },
+ { -1020, "HPI unknown error" },
+ { -1021, "HPI invalid session" },
+ { -1022, "HPI invalid domain" },
+ { -1023, "HPI invalid resource id" },
+ { -1024, "HPI invalid request" },
+ { -1025, "HPI entity not present" },
+ { -1026, "HPI uninitialized" }
+};
+char def_estr[15] = "HPI error %d   ";
+
+#define NUM_EC  14
+struct { int val; char *str;
+} eventcats[NUM_EC] = {
+{ /*0x00*/ SAHPI_EC_UNSPECIFIED,  "unspecified"},
+{ /*0x01*/ SAHPI_EC_THRESHOLD, 	  "Threshold"},
+{ /*0x02*/ SAHPI_EC_USAGE, 	  "Usage    "},
+{ /*0x03*/ SAHPI_EC_STATE, 	  "State    "},
+{ /*0x04*/ SAHPI_EC_PRED_FAIL, 	  "Predictive"},
+{ /*0x05*/ SAHPI_EC_LIMIT, 	  "Limit    "},
+{ /*0x06*/ SAHPI_EC_PERFORMANCE,  "Performnc"},
+{ /*0x07*/ SAHPI_EC_SEVERITY, 	  "Severity "},
+{ /*0x08*/ SAHPI_EC_PRESENCE, 	  "DevPresen"},
+{ /*0x09*/ SAHPI_EC_ENABLE, 	  "DevEnable"},
+{ /*0x0a*/ SAHPI_EC_AVAILABILITY, "Availabil"},
+{ /*0x0b*/ SAHPI_EC_REDUNDANCY,   "Redundanc"},
+{ /*0x7e*/ SAHPI_EC_USER,         "SensorSpc"},  /*UserDefin*/
+{ /*0x7f*/ SAHPI_EC_GENERIC,      "OemDefin " }};
+
+#define NUM_ES  6
+struct { int val; char *str; } eventstates[NUM_ES] = {
+{ SAHPI_ES_LOWER_MINOR , "lo-min" },
+{ SAHPI_ES_LOWER_MAJOR , "lo-maj" },
+{ SAHPI_ES_LOWER_CRIT  , "lo-crt" },
+{ SAHPI_ES_UPPER_MINOR , "hi-min" },
+{ SAHPI_ES_UPPER_MAJOR , "hi-maj" },
+{ SAHPI_ES_UPPER_CRIT  , "hi-crt" } };
+
+#define uchar   unsigned char
+#define ushort  unsigned short
+#define uint    unsigned int
+#define ulong   unsigned long
+typedef struct
+{
+        short              record_id;
+        uchar              record_type;
+        uint               timestamp;
+        short              generator_id;    /*slave_addr/channel*/
+        uchar              evm_rev;         //event message revision
+        uchar              sensor_type;
+        uchar              sensor_number;
+        uchar              event_trigger;
+        uchar              event_data1;
+        uchar              event_data2;
+        uchar              event_data3;
+}       SEL_RECORD;
+
+/* sensor_types: See IPMI 1.5 Table 36-3, IPMI 2.0 Table 42-3 */
+#define NSTYPES   0x2D
+static char *sensor_types[NSTYPES] = {  
+/* 00h */ "reserved",
+/* 01h */ "Temperature",
+/* 02h */ "Voltage",
+/* 03h */ "Current",
+/* 04h */ "Fan",
+/* 05h */ "Platform Chassis Intrusion",
+/* 06h */ "Security Violation",
+/* 07h */ "Processor",
+/* 08h */ "Power Supply",
+/* 09h */ "Power Unit",
+/* 0Ah */ "Cooling Device",
+/* 0Bh */ "FRU Sensor",
+/* 0Ch */ "Memory",
+/* 0Dh */ "Drive Slot",
+/* 0Eh */ "POST Memory Resize",
+/* 0Fh */ "System Firmware",    /*incl POST code errors*/
+/* 10h */ "SEL Disabled",
+/* 11h */ "Watchdog 1",
+/* 12h */ "System Event",          /* offset 0,1,2 */
+/* 13h */ "Critical Interrupt",        /* offset 0,1,2 */
+/* 14h */ "Button",                /* offset 0,1,2 */
+/* 15h */ "Board",
+/* 16h */ "Microcontroller",
+/* 17h */ "Add-in Card",
+/* 18h */ "Chassis",
+/* 19h */ "Chip Set",
+/* 1Ah */ "Other FRU",
+/* 1Bh */ "Cable/Interconnect",
+/* 1Ch */ "Terminator",
+/* 1Dh */ "System Boot Initiated",
+/* 1Eh */ "Boot Error",
+/* 1Fh */ "OS Boot",
+/* 20h */ "OS Critical Stop",
+/* 21h */ "Slot/Connector",
+/* 22h */ "ACPI Power State",
+/* 23h */ "Watchdog 2",
+/* 24h */ "Platform Alert",
+/* 25h */ "Entity Presence",
+/* 26h */ "Monitor ASIC",
+/* 27h */ "LAN",
+/* 28h */ "Management Subsystem Health",
+/* 29h */ "Battery",
+/* 2Ah */ "Session Audit",
+/* 2Bh */ "Version Change",
+/* 2Ch */ "FRU State"
+};
+
+#define NFWERRS  15
+static struct {    /* See Table 36-3, type 0Fh, offset 00h */
+  int code; char *msg; 
+  } fwerrs[NFWERRS] = {
+ { 0x00, "Unspecified"},
+ { 0x01, "No system memory"},
+ { 0x02, "No usable memory"},
+ { 0x03, "Unrecovered Hard Disk"},
+ { 0x04, "Unrecovered System Board"},
+ { 0x05, "Unrecovered Diskette"},
+ { 0x06, "Unrecovered Hard Disk Ctlr"},
+ { 0x07, "Unrecovered PS2 USB"},
+ { 0x08, "Boot media not found"},
+ { 0x09, "Unrecovered video controller"},
+ { 0x0A, "No video device"},
+ { 0x0B, "Firmware ROM corruption"},
+ { 0x0C, "CPU voltage mismatch"},
+ { 0x0D, "CPU speed mismatch"},
+ { 0x0E, "Reserved" }
+};
+
+#define NFWSTAT  27
+static struct {    /* See Table 36-3, type 0Fh, offset 01h & 02h */
+  int code; char *msg; 
+  } fwstat[NFWSTAT] = {
+ { 0x00, "Unspecified"},
+ { 0x01, "Memory init"},
+ { 0x02, "Hard disk init"},
+ { 0x03, "Secondary processor"},
+ { 0x04, "User authentication"},
+ { 0x05, "User-init sys setup"},
+ { 0x06, "USB configuration"},
+ { 0x07, "PCI configuration"},
+ { 0x08, "Option ROM init"},
+ { 0x09, "Video init"},
+ { 0x0a, "Cache init"},
+ { 0x0b, "SM Bus init"},
+ { 0x0c, "Keyboard init"},
+ { 0x0d, "Mgt controller"},
+ { 0x0e, "Docking attach"},
+ { 0x0f, "Enabling docking"},
+ { 0x10, "Docking eject"},
+ { 0x11, "Disabling docking"},
+ { 0x12, "OS wake-up"},
+ { 0x13, "Starting OS boot"},
+ { 0x14, "Baseboard init"},
+ { 0x15, "reserved"},
+ { 0x16, "Floppy init"},
+ { 0x17, "Keyboard test"},
+ { 0x18, "Mouse test"},
+ { 0x19, "Primary processor"},
+ { 0x1A, "Reserved"}
+};
+
+#define NGDESC   7
+struct {
+ ushort g_id;
+ char desc[10];
+} gen_desc[NGDESC] = {  /*empirical, format defined in IPMI 1.5 Table 23-5 */
+ { 0x0000, "IPMB"},
+ { 0x0001, "EFI "},
+ { 0x0003, "BIOS"},
+ { 0x0020, "BMC "},
+ { 0x0021, "SMI "},
+ { 0x0028, "CHAS"},    /* Chassis Bridge Controller */
+/*{0x0031, "SMI/IPMB"}, * ia64/mBMC POST errors   (rqSa/rqLun)  */
+/*{0x0033, "MemCtlr"},  * ia64 memory controller? (rqSa/rqLun) */
+ { 0x00c0, "HSC "}     /* SAF-TE Hot-Swap Controller*/
+};
+
+#define NCRITS  10
+char * crit_int_str[NCRITS] = {  /* Critical Interrupt descriptions */
+ /*00*/ "FP NMI  ",  /* Front Panel NMI */
+ /*01*/ "Bus Timout",
+ /*02*/ "IOch NMI ", /* IO channel check NMI */
+ /*03*/ "Soft NMI ",
+ /*04*/ "PCI PERR ",
+ /*05*/ "PCI SERR ",
+ /*06*/ "EISA Timout",
+ /*07*/ "Bus Warn ",  /* Bus Correctable Error */
+ /*08*/ "Bus Error",  /* Bus Uncorrectable Error */
+ /*09*/ "Fatal NMI" };
+
+#define NSLOTC  9
+char * slot_str[NSLOTC] = {  /* Slot/Connector descriptions */
+ /*00*/ "Fault   ", 
+ /*01*/ "Identify",
+ /*02*/ "Inserted",
+ /*03*/ "InsReady",
+ /*04*/ "RemReady",
+ /*05*/ "PowerOff",
+ /*06*/ "RemRequest",
+ /*07*/ "Interlock",
+ /*08*/ "Disabled" }; 
+
+#define NSDESC   47
+struct {
+ ushort genid;  /*generator id: BIOS, BMC, etc. (slave_addr/channel)*/
+ uchar s_typ;   /*1=temp,2=voltage,4=fan,... */
+ uchar s_num;
+ uchar evtrg;   /*event trigger/type, see IPMI 1.5 table 36.1 & 36.2 */
+ uchar data1;
+ uchar data2;
+ uchar data3;
+ char desc[40];
+} sens_desc[NSDESC] = {
+{0xffff,0x05, 0x05, 0x6f, 0x44, 0xff, 0xff, "LAN unplugged"},   /*chassis*/
+{0xffff,0x05, 0x05, 0xef, 0x44, 0xff, 0xff, "LAN restored "},   /*chassis*/
+{0xffff,0x06, 0xff, 0xff, 0x45, 0xff, 0xff, "Password"},        /*security*/
+{0xffff,0x07, 0xff, 0xff, 0x41, 0xff, 0xff, "Thermal trip"},    /*processor*/
+{0xffff,0x08, 0xff, 0x6f, 0x40, 0xff, 0xff, "Presence detected"},/*PowerSupply*/
+{0xffff,0x08, 0xff, 0x6f, 0x41, 0xff, 0xff, "Failure detected"},/*power supply*/
+{0xffff,0x08, 0xff, 0x6f, 0x42, 0xff, 0xff, "Predictive failure"},
+{0xffff,0x08, 0xff, 0x6f, 0x43, 0xff, 0xff, "AC Lost"},
+{0xffff,0x08, 0xff, 0xef, 0x40, 0xff, 0xff, "not present"},     /*power supply*/
+{0xffff,0x08, 0xff, 0xef, 0x41, 0xff, 0xff, "is OK  "},         /*power supply*/
+{0xffff,0x08, 0xff, 0xef, 0x42, 0xff, 0xff, "Predictive OK"},
+{0xffff,0x08, 0xff, 0xef, 0x43, 0xff, 0xff, "AC Regained"},     /*power supply*/
+{0xffff,0x09, 0xff, 0xff, 0x40, 0xff, 0xff, "Redundancy OK  "}, /*power unit*/
+{0xffff,0x09, 0xff, 0xff, 0x41, 0xff, 0xff, "Redundancy Lost"},
+{0xffff,0x09, 0xff, 0xff, 0x44, 0xff, 0xff, "AC Lost"},
+{0xffff,0x09, 0xff, 0xff, 0x46, 0xff, 0xff, "Failure detected"},
+{0xffff,0x09, 0xff, 0xff, 0x47, 0xff, 0xff, "Predictive failure"},/*power unit*/
+{0xffff,0x0c, 0xff, 0xff, 0x00, 0xff, 0xff, "Correctable ECC"},  /*memory*/
+{0xffff,0x0f, 0x06, 0xff, 0xff, 0xff, 0xff, "POST Code"},
+{0xffff,0x10, 0x09, 0xff, 0x42, 0x0f, 0xff, "Log Cleared"},
+{0xffff,0x10, 0x09, 0xff, 0xc0, 0x03, 0xff, "ECC Memory Errors"},
+     /*  Often see these 3 Boot records with reboot:
+      * 12 83 6f 05 00 ff = System/SEL Time Sync 1 (going down)
+      * 12 83 6f 05 80 ff = System/SEL Time Sync 2 (coming up)
+      * 12 83 6f 01 ff ff = OEM System Boot Event  (Completed POST) */
+{0xffff,0x12, 0x83, 0xff, 0x05, 0x00, 0xff, "Boot: ClockSync 1"},   
+{0xffff,0x12, 0x83, 0xff, 0x05, 0x80, 0xff, "Boot: ClockSync 2"},   
+{0xffff,0x12, 0x83, 0xff, 0x01, 0xff, 0xff, "OEM System Booted"},   
+{0xffff,0x12, 0x08, 0xff, 0x01, 0xff, 0xff, "OEM System Booted"},    /*ia64*/
+{0xffff,0x12, 0x00, 0x6f, 0xff, 0xff, 0xff, "PEF Action"},           /*ia64*/
+{0xffff,0x12, 0x83, 0x6f, 0x80, 0xff, 0xff, "System Reconfigured"},  /*BMC*/
+{0x00c0,0x0d, 0xff, 0x08, 0x00, 0xff, 0xff, "Device Removed"},    /*HSC*/
+{0x00c0,0x0d, 0xff, 0x08, 0x01, 0xff, 0xff, "Device Inserted"},   /*HSC*/
+{0xffff,0x14, 0xff, 0xff, 0x42, 0xff, 0xff, "Reset Button pressed"},
+{0xffff,0x14, 0xff, 0xff, 0x40, 0xff, 0xff, "Power Button pressed"},
+{0xffff,0x14, 0xff, 0xff, 0x01, 0xff, 0xff, "ID Button pressed"},
+{0xffff,0x23, 0xff, 0xff, 0x40, 0xff, 0xff, "Expired, no action"},/*watchdog2*/
+{0xffff,0x23, 0xff, 0xff, 0x41, 0xff, 0xff, "Hard Reset action"}, /*watchdog2*/
+{0xffff,0x23, 0xff, 0xff, 0x42, 0xff, 0xff, "Power down action"}, /*watchdog2*/
+{0xffff,0x23, 0xff, 0xff, 0x43, 0xff, 0xff, "Power cycle action"},/*watchdog2*/
+{0xffff,0x23, 0xff, 0xff, 0x48, 0xff, 0xff, "Timer interrupt"},   /*watchdog2*/
+{0xffff,0xf3, 0x85, 0xff, 0x41, 0xff, 0xff, "State is now OK"},
+{0xffff,0x20, 0x00, 0xff, 0xff, 0xff, 0xff, "OS Kernel Panic"},
+{0xffff,0xff, 0xff, 0x01, 0x57, 0xff, 0xff, "Hi Noncrit thresh"},
+{0xffff,0xff, 0xff, 0x01, 0x59, 0xff, 0xff, "Hi Crit thresh"},
+{0xffff,0xff, 0xff, 0x01, 0x50, 0xff, 0xff, "Lo Noncrit thresh"},
+{0xffff,0xff, 0xff, 0x01, 0x52, 0xff, 0xff, "Lo Crit thresh"},
+{0xffff,0xff, 0xff, 0x81, 0x57, 0xff, 0xff, "HiN thresh OK now"},
+{0xffff,0xff, 0xff, 0x81, 0x59, 0xff, 0xff, "HiC thresh OK now"},
+{0xffff,0xff, 0xff, 0x81, 0x50, 0xff, 0xff, "LoN thresh OK now"},
+{0xffff,0xff, 0xff, 0x81, 0x52, 0xff, 0xff, "LoC thresh OK now"}
+	/*Thresholds apply to sensor types 1=temp, 2=voltage, 4=fan */
+	/*Note that last 2 bytes usu show actual & threshold values*/
+	/*evtrg: 0x01=thresh, 0x81=restored */
+};
+
+/*------------------------------------------------------------------------ 
+ * get_misc_desc
+ * Uses the sens_desc array to decode misc entries not otherwise handled.
+ * Called by decode_sel_entry
+ *------------------------------------------------------------------------*/
+char * get_misc_desc(uchar type, uchar num, ushort genid, uchar trig,
+		 uchar data1, uchar data2, uchar data3);
+char *
+get_misc_desc(uchar type, uchar num, ushort genid, uchar trig,
+		 uchar data1, uchar data2, uchar data3)
+{
+	int i;
+	char *pstr = NULL; 
+
+	/* Use sens_desc array for other misc descriptions */
+	data1 &= 0x0f;  /*ignore top half of sensor offset for matching */
+	for (i = 0; i < NSDESC; i++) {
+	     if ((sens_desc[i].s_typ == 0xff) || 
+		     (sens_desc[i].s_typ == type)) {
+	      if (sens_desc[i].s_num != 0xff &&
+	         sens_desc[i].s_num != num)
+			    continue;
+	      if (sens_desc[i].genid != 0xffff &&
+	         sens_desc[i].genid != genid)
+			    continue;
+	      if (sens_desc[i].evtrg != 0xff &&
+	         sens_desc[i].evtrg != trig)
+				    continue;
+	      if (sens_desc[i].data1 != 0xff && 
+      	          (sens_desc[i].data1 & 0x0f) != data1)
+				    continue;
+	      if (sens_desc[i].data2 != 0xff && 
+      	          sens_desc[i].data2 != data2)
+				    continue;
+	      if (sens_desc[i].data3 != 0xff && 
+      	          sens_desc[i].data3 != data3)
+				    continue;
+	      /* have a match, use description */
+	      pstr = (char *)sens_desc[i].desc; 
+	      break;
+ 	   }
+	} /*end for*/
+	return(pstr);
+}  /* end get_misc_desc() */
+
+void decode_sensor_event(uchar sensor_type, uchar sensor_number, ushort gen_id,
+		uchar event_trigger, uchar data1, uchar data2, uchar data3,
+		char *outbuf);
+void
+decode_sensor_event(uchar sensor_type, uchar sensor_number,  ushort gen_id,
+		uchar event_trigger, uchar data1, uchar data2, uchar data3,
+		char *outbuf)
+{
+	char mystr[26] = "(123)";  /*for panic string*/
+	char poststr[24] = "OEM Post Code = %x%x";
+	char genstr[10] = "03  ";
+	char *gstr;
+	char *pstr;
+	uchar dtype;
+	int i;
+
+	 /* set dtype, used as array index below */
+	if (sensor_type >= NSTYPES) dtype = 0;
+	else dtype = sensor_type;
+	switch(sensor_type) {
+		     case 0x20:   /*OS Crit Stop*/
+		        /* Show first 3 chars of panic string */
+		        mystr[0] = '(';
+		        mystr[1] = sensor_number & 0x7f;
+		        mystr[2] = data2 & 0x7f;
+		        mystr[3] = data3 & 0x7f;
+			mystr[4] = ')';
+			mystr[5] = 0;
+			pstr = mystr;
+			if (sensor_number & 0x80) strcat(mystr,"Oops!");
+			if (data2 & 0x80) strcat(mystr,"Int!");
+			if (data3 & 0x80) strcat(mystr,"NullPtr!");
+		        break;
+		     case 0x0f:    /*Post Errs*/
+			switch (data1)
+			{ 
+			   case 0x00:  /* System firmware errors */
+				i = data2;
+				if (i >= NFWERRS) i = NFWERRS - 1;
+        		        pstr = fwerrs[i].msg;
+				break;
+			   case 0x01:  /* System firmware hang  */
+				i = data2;
+				if (i >= NFWSTAT) i = NFWSTAT - 1;
+				sprintf(poststr,"hang, %s",fwstat[i].msg);
+				pstr = poststr;
+				break;
+			   case 0x02:  /* System firmware progress */
+				i = data2;
+				if (i >= NFWSTAT) i = NFWSTAT - 1;
+				sprintf(poststr,"prog, %s",fwstat[i].msg);
+				pstr = poststr;
+				break;
+			   case 0xa0:  /* OEM post codes */
+				/* OEM post codes in bytes 2 & 3 (lo-hi) */
+				sprintf(poststr,"POST Code %02x%02x",
+					data3,data2);
+				pstr = poststr;
+				break;
+			   default:  
+				pstr = "POST Error";  /*default string*/
+			}  /*end switch(data1)*/
+		        break;
+		     case 0x13:   /*Crit Int*/
+			i = data1 & 0x0f;
+			if (i >= NCRITS) i = NCRITS - 1;
+			pstr = crit_int_str[i];
+		        break;
+		     case 0x21:   /*Slot/Con*/
+			i = data1 & 0x0f;
+			if (i >= NSLOTC) i = NSLOTC - 1;
+			sprintf(mystr,"%s",slot_str[i]);
+			/* could also decode data2/data3 here if valid */
+			pstr = mystr;
+		        break;
+		     default:   /* all other sensor types, see sens_desc */
+			pstr = get_misc_desc( sensor_type,
+			     sensor_number, gen_id,
+			     event_trigger, data1, data2, data3);
+			if (pstr == NULL) {
+			   mystr[0] = '-'; mystr[1] = 0;
+			   pstr = mystr;
+			}
+		    
+	}  /*end switch(sensor_type)*/
+
+	/* show the Generator ID */
+	sprintf(genstr,"%04x",gen_id);
+	gstr = genstr;  /* default */
+	for (i = 0; i < NGDESC; i++)
+		    {
+			if (gen_desc[i].g_id == gen_id)
+			   gstr = (char *)gen_desc[i].desc;  
+		    }
+
+	/*firmware timestamp is #seconds since 1/1/1970 localtime*/
+	/* timestamp handled by caller in HPI */
+		    
+	if ((event_trigger == 0x01) || /*threshold*/
+	    (event_trigger == 0x81)) { /*threshold ok*/
+		    sprintf(outbuf,
+			"%s %02x %s act=%02x thr=%02x",
+			sensor_types[dtype], sensor_number, pstr,
+			data2,    /*actual reading*/
+			data3 );  /*threshold value*/
+		    } else {
+		    sprintf(outbuf,
+			"%s %02x %s %02x [%02x %02x %02x]",
+			sensor_types[dtype] , sensor_number, pstr,
+			event_trigger, data1, data2, data3 );
+		    }
+}
+
+/*------------------------------------------------------------------------ 
+ * decode_ipmi_event
+ * Parse and decode the SEL record into readable format.
+ * This routine is constructed so that it could be used as a library
+ * function.
+ * Input:   psel, a pointer to the IPMI SEL record
+ * Output:  outbuf, a description of the event, max 80 chars.
+ * Called by ReadSEL
+ *------------------------------------------------------------------------*/
+void decode_ipmi_event( SEL_RECORD *psel, char *outbuf);
+void decode_ipmi_event( SEL_RECORD *psel, char *outbuf)
+{
+	char genstr[10] = "03  ";
+	int i, j;
+
+	if (psel->record_type >= 0xe0) { /*OEM Record 26.3*/
+		   char *pc;
+		   pc = (char *)&psel->timestamp;  /*bytes 4:16*/
+		   sprintf(outbuf," OEM Event %02x %02x ", pc[0], pc[1]);
+		   j = strlen(outbuf);
+		   for (i = 2; i < 13; i++) {  /* 4:16 = 13 bytes data */
+		      if (psel->record_type == 0xf0) { 
+		        /* panic string will be type 0xf0 */
+			if (pc[i] == 0) break;
+			outbuf[j++] = pc[i];
+		      } else {
+			sprintf(&outbuf[j],"%02x ",pc[i]);
+			j += 3;
+		      }
+		   }
+		   outbuf[j++] = '\n';
+		   outbuf[j++] = 0;
+	} else if (psel->record_type == 0x02) {
+		  /* most records are record type 2 */
+		  decode_sensor_event(psel->sensor_type, 
+			psel->sensor_number, psel->generator_id, 
+			psel->event_trigger, psel->event_data1, 
+			psel->event_data2, psel->event_data3, outbuf);
+
+	}  /*endif type 2 */
+	else {  /* other misc record type */
+		   uchar *pc;
+		   pc = (uchar *)&psel->record_type; 
+		   sprintf(outbuf," Type%02x ", pc[0]);
+		   j = strlen(outbuf);
+		   for (i = 1; i < 14; i++) {
+			sprintf(genstr,"%02x ",pc[i]);
+			strcat(outbuf,genstr);
+		   }
+	}  /*endif misc type*/
+	return;
+}  /*end decode_ipmi_event()*/
+
+#define IF_IPMI    0 	/* other interfaces, like H8, have diff numbers */
+			/*Note that OpenHPI 2.0.0 does not yet fill this in*/
+
+/*------------------------------------------------------------------------ 
+ * decode_hpi_event
+ * Parse and decode the SensorEvent record into readable format.
+ * Input:   pevent, a pointer to the HPI SensorEvent record
+ * Output:  outbuf, a description of the event, max 80 chars.
+ * Called by ReadSEL
+ *------------------------------------------------------------------------*/
+void decode_hpi_event( SaHpiSensorEventT *pevent, char *outbuf);
+void decode_hpi_event( SaHpiSensorEventT *pevent, char *outbuf)
+{
+   int ec, eci; 
+   int es, esi; 
+   int styp; 
+   uchar data1, data2, data3, if_type;
+   uchar etrig;
+   ushort genid;
+   char estag[8];
+   char sbuf[80];
+   char *ecstr;
+   // char *pstr;
+
+   /* decode event category */
+   ec = pevent->EventCategory;
+   for (eci = 0; eci < NUM_EC; eci++) 
+	if (eventcats[eci].val == ec) break; 
+   if (eci >= NUM_EC) eci = 0;
+   ecstr = eventcats[eci].str;
+   genid = 0x0020;   /* default to BMC */
+   etrig = 0x6f;     /* default to sensor-specific*/
+   /* decode event state */
+   es = pevent->EventState;
+   if (ec == SAHPI_EC_USER) {  /*OpenHPI usu returns this (0x7e)*/
+        sprintf(estag,"%02x",es);
+   } else if (eci == SAHPI_EC_THRESHOLD ) {  /*0x01*/
+	for (esi = 0; esi < NUM_ES; esi++) 
+		if (eventstates[esi].val == es) break; 
+	if (esi >= NUM_ES) esi = 0;
+	strcpy(estag,eventstates[esi].str);
+        if (pevent->Assertion) etrig = 0x01;
+        else etrig = 0x81;
+   } else {
+	sprintf(estag,"%02x:%02x",ec,es);
+   }
+
+   /* decode sensor type */
+   styp = pevent->SensorType;
+   if (styp >= NSTYPES) { styp = 0; }
+
+   /* get if_type from SensorSpecific h.o. byte */
+   if_type = (pevent->SensorSpecific & 0xff000000) >> 24;
+   data3 = (pevent->SensorSpecific & 0x00ff0000) >> 16;
+   data2 = (pevent->SensorSpecific & 0x0000ff00) >> 8;
+   data1 = (pevent->SensorSpecific & 0x000000ff);
+   if (if_type == IF_IPMI) { /* handle IPMI SensorSpecific stuff */
+	/* fortunately, HPI & IPMI have the same sensor_type values */
+	decode_sensor_event(styp, pevent->SensorNum, genid,
+			etrig, data1, data2, data3, sbuf);
+        sprintf(outbuf,"%s %s", estag, sbuf); 
+   } 
+   else {
+      sprintf(outbuf,"%s, %s %s %x [%02x %02x %02x]", 
+	   sensor_types[styp], ecstr, estag, 
+	   pevent->SensorNum, data1, data2, data3);
+   }
+
+   return;
+}
+
+static
+char *decode_error(SaErrorT code)
+{
+   int i;
+   char *str = NULL;
+   for (i = 0; i < NECODES; i++) {
+	if (code == ecodes[i].code) { str = ecodes[i].str; break; }
+   }
+   if (str == NULL) { 
+	sprintf(&def_estr[10],"%d",code);
+	str = &def_estr[0];
+   }
+   return(str);
+}
+
+void ShowSel( SaHpiSelEntryT  *sel, SaHpiRdrT *rdr, SaHpiRptEntryT *rptentry);
+void ShowSel( SaHpiSelEntryT  *sel, SaHpiRdrT *rdr, 
+		SaHpiRptEntryT *rptentry )
+{
+  unsigned char evtype;
+  char timestr[40];
+  time_t tt1;
+  char *srctag;
+  char *rdrtag;
+  char *pstr;
+  unsigned char *pd;
+  int outlen;
+  char outbuf[132];
+  int styp; 
+  unsigned char data3;
+
+  /*format & print the EventLog entry*/
+  if (sel->Event.Timestamp > SAHPI_TIME_MAX_RELATIVE) { /*absolute time*/
+     tt1 = sel->Event.Timestamp / 1000000000;
+     strftime(timestr,sizeof(timestr),"%x %H:%M:%S", localtime(&tt1));
+  } else if (sel->Event.Timestamp > SAHPI_TIME_UNSPECIFIED) { /*invalid time*/
+     strcpy(timestr,"invalid time     ");
+  } else {   /*relative time*/
+     tt1 = sel->Event.Timestamp / 1000000000;
+     sprintf(timestr,"rel(%lx)", (unsigned long)tt1);  
+  }
+  if (rptentry->ResourceId == sel->Event.Source) 
+	srctag = rptentry->ResourceTag.Data;
+  else  srctag = "unspec ";  /* SAHPI_UNSPECIFIED_RESOURCE_ID */
+  evtype = sel->Event.EventType;
+  if (evtype > NEVTYPES) evtype = NEVTYPES - 1;
+  if (rdr->RdrType == SAHPI_NO_RECORD) rdrtag = "rdr-unkn"; 
+  else {
+	rdr->IdString.Data[rdr->IdString.DataLength] = 0; 
+	rdrtag = &rdr->IdString.Data[0];
+  }
+  sprintf(outbuf,"%04x %s %s ", sel->EntryId, timestr, evtypes[evtype] );
+  outlen = strlen(outbuf);
+  pstr = "";
+#ifdef HPI_A
+  pd = &sel->Event.EventDataUnion.UserEvent.UserEventData[0];
+#else
+  pd = &sel->Event.EventDataUnion.UserEvent.UserEventData.Data[0];
+#endif
+
+  switch(evtype)
+  {
+     case SAHPI_ET_SENSOR:   /*Sensor*/
+	pd = (void *)&(sel->Event.EventDataUnion.SensorEvent);
+        decode_hpi_event((void *)pd,&outbuf[outlen]);
+	break;
+     case SAHPI_ET_USER:   /*User, usu 16-byte IPMI SEL record */
+        decode_ipmi_event((void *)pd,&outbuf[outlen]);
+	break;
+     default:
+        // decode_ipmi_event((void *)pd,&outbuf[outlen]);
+	styp = pd[10];
+	data3 = pd[15];
+	   /* *sel->Event.EventDataUnion.SensorEvent.SensorSpecific+1 */
+	if (styp >= NSTYPES) { 
+		if (fdebug) printf("sensor type %d >= max %d\n",styp,NSTYPES);
+		styp = 0; 
+	}
+	pstr = (char *)sensor_types[styp];
+        sprintf(&outbuf[outlen], "%s, %x %x, %02x %02x %02x [%02x %02x %02x/%02x]",
+			pstr, pd[0], pd[7], pd[10], pd[11], pd[12], 
+				pd[13], pd[14], pd[15], data3);
+	break;
+   }
+   printf("%s\n",outbuf);
+}
+
+static SaErrorT
+DoEventLogForResource(SaHpiSessionIdT	sessionid,
+		      SaHpiResourceIdT	resourceid,
+		      char		*tagname)
+{
+    SaErrorT		rv;
+    SaHpiSelInfoT	info;
+    int			free = 50;
+    SaHpiSelEntryIdT	entryid;
+    SaHpiSelEntryIdT	nextentryid;
+    SaHpiSelEntryIdT	preventryid;
+    SaHpiSelEntryT	sel;
+    SaHpiRdrT		rdr;
+    SaHpiRptEntryT	rptentry;
+
+    printf("rptentry[%d] tag: %s\n", resourceid, tagname);
+
+    rv = saHpiEventLogInfoGet(sessionid, resourceid, &info);
+    if (fdebug)
+	printf("saHpiEventLogInfoGet %s\n", decode_error(rv));
+    if (rv == SA_OK) {
+   	free = info.Size - info.Entries;
+	printf("EventLog entries=%d, size=%d, enabled=%d, free=%d\n",
+			info.Entries, info.Size, info.Enabled, free);
+    } 
+
+    entryid = SAHPI_OLDEST_ENTRY;
+    while ((rv == SA_OK) && (entryid != SAHPI_NO_MORE_ENTRIES))
+    {
+	/* rv = saHpiEventLogEntryGet(sessionid,SAHPI_DOMAIN_CONTROLLER_ID,entryid, */
+	rv = saHpiEventLogEntryGet(sessionid, resourceid, entryid,
+			&preventryid, &nextentryid, &sel, &rdr, &rptentry);
+	if (fdebug)
+	    printf("saHpiEventLogEntryGet[%x] %s, next=%x\n",
+			entryid, decode_error(rv), nextentryid);
+	if (rv == SA_OK) {
+	    ShowSel(&sel, &rdr, &rptentry);
+	    if (entryid == nextentryid)
+		break;
+	    preventryid = entryid;
+	    entryid = nextentryid;
+	}
+    }
+
+    if (free < 6) {
+	/* 
+	 * This test could be more generic if the log info fields above 
+	 * were accurate.  IPMI SEL logs have a fixed size of 0x10000 
+	 * bytes.  New log records are thrown away when it gets full.
+	 * (OLDEST = 0, NO_MORE = fffffffe , so these are ok.)
+	 */
+	/* free = (0x10000 - 20) - preventryid; */ 
+	printf(	"WARNING: Log free space is very low (%d records)\n"
+		"         Clear log with hpisel -c\n", free);
+    }
+
+    return SA_OK;
+}
+
+int
+main(int argc, char **argv)
+{
+  int c;
+  SaErrorT rv;
+  SaHpiSessionIdT sessionid;
+#ifdef HPI_A
+  SaHpiVersionT hpiVer;
+  SaHpiRptInfoT rptinfo;
+#endif
+  SaHpiRptEntryT rptentry;
+  SaHpiEntryIdT rptentryid;
+  SaHpiEntryIdT nextrptentryid;
+  SaHpiResourceIdT resourceid;
+
+  printf("%s: version %s\n",argv[0],progver); 
+
+#ifdef HPI_A
+#define ARGSTR		"cx?"
+#else
+#define ARGSTR		"cdx?"
+#endif
+
+  while ( (c = getopt( argc, argv, ARGSTR)) != EOF )
+  switch(c) {
+        case 'c': fclear  = 1;  break;
+#ifndef HPI_A
+	case 'd': fdomain = 1; break;
+#endif
+        case 'x': fdebug  = 1;  break;
+        default:
+                printf("Usage %s [-cx]\n",argv[0]);
+                printf("where -c clears the event log\n");
+#ifndef HPI_A
+		printf("      -d displays the domain event log\n");
+#endif
+                printf("      -x displays eXtra debug messages\n");
+                exit(1);
+  }
+#ifdef HPI_A
+  rv = saHpiInitialize(&hpiVer);
+  if (rv != SA_OK) {
+	printf("saHpiInitialize: %s\n",decode_error(rv));
+	exit(-1);
+	}
+  rv = saHpiSessionOpen(SAHPI_DEFAULT_DOMAIN_ID,&sessionid,NULL);
+  if (rv != SA_OK) {
+	if (rv == SA_ERR_HPI_ERROR) 
+	   printf("saHpiSessionOpen: error %d, SpiLibd not running\n",rv);
+	else
+	   printf("saHpiSessionOpen: %s\n",decode_error(rv));
+	exit(-1);
+	}
+  rv = saHpiResourcesDiscover(sessionid);
+  if (fdebug) printf("saHpiResourcesDiscover %s\n",decode_error(rv));
+  rv = saHpiRptInfoGet(sessionid,&rptinfo);
+  if (fdebug) printf("saHpiRptInfoGet %s\n",decode_error(rv));
+  printf("RptInfo: UpdateCount = %x, UpdateTime = %lx\n",
+         rptinfo.UpdateCount, (unsigned long)rptinfo.UpdateTimestamp);
+#else
+  rv = saHpiSessionOpen(SAHPI_UNSPECIFIED_DOMAIN_ID,&sessionid,NULL);
+  if (rv != SA_OK) {
+	printf("saHpiSessionOpen: %s\n",decode_error(rv));
+	exit(-1);
+	}
+  rv = saHpiDiscover(sessionid);
+  if (fdebug) printf("saHpiDiscover %s\n",decode_error(rv));
+#endif
+
+#ifndef HPI_A
+  if (fdomain != 0)		/* saw option for domain event log */
+  {
+    /* resourceid = 1; * oh_get_default_domain_id() */
+    resourceid = SAHPI_UNSPECIFIED_DOMAIN_ID;
+    if (fclear) {
+	rv = saHpiEventLogClear(sessionid,resourceid);
+	if (rv == SA_OK) printf("Domain EventLog successfully cleared\n");
+	else printf("Domain EventLog clear, error = %d\n",rv);
+    } else {
+	rv = DoEventLogForResource(sessionid, resourceid, "Domain Event Log");
+    }
+  }
+  else				/* walk the RPT list */
+#endif
+  {
+    rptentryid = SAHPI_OLDEST_ENTRY;
+    while ((rv == SA_OK) && (rptentryid != SAHPI_LAST_ENTRY))
+    {
+      rv = saHpiRptEntryGet(sessionid,rptentryid,&nextrptentryid,&rptentry);
+      if (fdebug) 
+	printf("saHpiRptEntryGet[%d] %s\n",rptentryid,decode_error(rv));
+      if (rv != SA_OK)
+	goto skip_to_next;
+      resourceid = rptentry.ResourceId;
+      if (fdebug) printf("RPT %x capabilities = %x\n", resourceid,
+				rptentry.ResourceCapabilities);
+      if ((rptentry.ResourceCapabilities & SAHPI_CAPABILITY_SEL) == 0)
+	goto skip_to_next;
+      if (fclear) {
+	rv = saHpiEventLogClear(sessionid,resourceid);
+	if (rv == SA_OK) printf("EventLog successfully cleared\n");
+	else printf("EventLog clear, error = %d\n",rv);
+	break;
+      }
+      // rptentry.ResourceTag.Data[rptentry.ResourceTag.DataLength] = 0; 
+
+      rv = DoEventLogForResource(sessionid, resourceid, 
+      					    rptentry.ResourceTag.Data);
+    skip_to_next:
+      rptentryid = nextrptentryid;
+    }
+  }
+ 
+  rv = saHpiSessionClose(sessionid);
+#ifdef HPI_A
+  rv = saHpiFinalize();
+#endif
+
+  exit(0);
+}
+ 
+/* end hpisel.c */