blob: 5a629a820d5d7cf61413f3e40dc39901e6584505 [file] [log] [blame]
Patrick Venture46470a32018-09-07 19:26:25 -07001#include "sensorhandler.hpp"
2
Patrick Venture0b02be92018-08-31 11:55:55 -07003#include <malloc.h>
Patrick Venture0b02be92018-08-31 11:55:55 -07004
Emily Shaffer391f3302017-04-03 10:27:08 -07005extern uint8_t find_type_for_sensor_number(uint8_t);
Chris Austen0130d6e2015-10-15 22:32:36 -05006
Patrick Venture0b02be92018-08-31 11:55:55 -07007struct sensorRES_t
8{
9 uint8_t sensor_number;
10 uint8_t operation;
11 uint8_t sensor_reading;
12 uint8_t assert_state7_0;
13 uint8_t assert_state14_8;
14 uint8_t deassert_state7_0;
15 uint8_t deassert_state14_8;
16 uint8_t event_data1;
17 uint8_t event_data2;
18 uint8_t event_data3;
19} __attribute__((packed));
Chris Austen0130d6e2015-10-15 22:32:36 -050020
Patrick Venture0b02be92018-08-31 11:55:55 -070021#define ISBITSET(x, y) (((x) >> (y)) & 0x01)
Chris Austen8a45e7c2015-10-15 00:31:46 -050022#define ASSERTINDEX 0
23#define DEASSERTINDEX 1
24
Patrick Venture0b02be92018-08-31 11:55:55 -070025// Sensor Type, Offset, function handler, Dbus Method, Assert value, Deassert
26// value
27struct lookup_t
28{
29 uint8_t sensor_type;
30 uint8_t offset;
31 int (*func)(const sensorRES_t*, const lookup_t*, const char*);
32 char member[16];
33 char assertion[64];
34 char deassertion[64];
Chris Austen8a45e7c2015-10-15 00:31:46 -050035};
36
Patrick Venture0b02be92018-08-31 11:55:55 -070037extern int updateDbusInterface(uint8_t, const char*, const char*);
Chris Austen0130d6e2015-10-15 22:32:36 -050038
Patrick Venture0b02be92018-08-31 11:55:55 -070039int set_sensor_dbus_state_simple(const sensorRES_t* pRec,
40 const lookup_t* pTable, const char* value)
41{
Chris Austen0130d6e2015-10-15 22:32:36 -050042
Patrick Venture0b02be92018-08-31 11:55:55 -070043 return set_sensor_dbus_state_s(pRec->sensor_number, pTable->member, value);
Chris Austen0130d6e2015-10-15 22:32:36 -050044}
45
Patrick Venture0b02be92018-08-31 11:55:55 -070046struct event_data_t
47{
48 uint8_t data;
49 char text[64];
Chris Austen0130d6e2015-10-15 22:32:36 -050050};
51
Patrick Venture0b02be92018-08-31 11:55:55 -070052event_data_t g_fwprogress02h[] = {{0x00, "Unspecified"},
53 {0x01, "Memory Init"},
54 {0x02, "HD Init"},
55 {0x03, "Secondary Proc Init"},
56 {0x04, "User Authentication"},
57 {0x05, "User init system setup"},
58 {0x06, "USB configuration"},
59 {0x07, "PCI configuration"},
60 {0x08, "Option ROM Init"},
61 {0x09, "Video Init"},
62 {0x0A, "Cache Init"},
63 {0x0B, "SM Bus init"},
64 {0x0C, "Keyboard Init"},
65 {0x0D, "Embedded ctrl init"},
66 {0x0E, "Docking station attachment"},
67 {0x0F, "Enable docking station"},
68 {0x10, "Docking station ejection"},
69 {0x11, "Disabling docking station"},
70 {0x12, "Calling OS Wakeup"},
71 {0x13, "Starting OS"},
72 {0x14, "Baseboard Init"},
73 {0x15, ""},
74 {0x16, "Floppy Init"},
75 {0x17, "Keyboard Test"},
76 {0x18, "Pointing Device Test"},
77 {0x19, "Primary Proc Init"},
78 {0xFF, "Unknown"}};
Chris Austen0130d6e2015-10-15 22:32:36 -050079
Chris Austend7cf0e42015-11-07 14:27:12 -060080event_data_t g_fwprogress00h[] = {
Patrick Venture0b02be92018-08-31 11:55:55 -070081 {0x00, "Unspecified."},
82 {0x01, "No system memory detected"},
83 {0x02, "No usable system memory"},
84 {0x03, "Unrecoverable hard-disk/ATAPI/IDE"},
85 {0x04, "Unrecoverable system-board"},
86 {0x05, "Unrecoverable diskette"},
87 {0x06, "Unrecoverable hard-disk controller"},
88 {0x07, "Unrecoverable PS/2 or USB keyboard"},
89 {0x08, "Removable boot media not found"},
90 {0x09, "Unrecoverable video controller"},
91 {0x0A, "No video device detected"},
92 {0x0B, "Firmware ROM corruption detected"},
93 {0x0C, "CPU voltage mismatch"},
94 {0x0D, "CPU speed matching"},
95 {0xFF, "unknown"},
Chris Austend7cf0e42015-11-07 14:27:12 -060096};
Chris Austen0130d6e2015-10-15 22:32:36 -050097
Patrick Venture0b02be92018-08-31 11:55:55 -070098char* event_data_lookup(event_data_t* p, uint8_t b)
99{
Chris Austen0130d6e2015-10-15 22:32:36 -0500100
Patrick Venture0b02be92018-08-31 11:55:55 -0700101 while (p->data != 0xFF)
102 {
103 if (p->data == b)
104 {
105 break;
106 }
107 p++;
108 }
Chris Austen0130d6e2015-10-15 22:32:36 -0500109
Patrick Venture0b02be92018-08-31 11:55:55 -0700110 return p->text;
Chris Austen0130d6e2015-10-15 22:32:36 -0500111}
Chris Austend7cf0e42015-11-07 14:27:12 -0600112
Patrick Venture0b02be92018-08-31 11:55:55 -0700113// The fw progress sensor contains some additional information that needs to be
114// processed prior to calling the dbus code.
115int set_sensor_dbus_state_fwprogress(const sensorRES_t* pRec,
116 const lookup_t* pTable, const char* value)
117{
Chris Austend7cf0e42015-11-07 14:27:12 -0600118
Patrick Venture0b02be92018-08-31 11:55:55 -0700119 char valuestring[128];
120 char* p = valuestring;
Chris Austend7cf0e42015-11-07 14:27:12 -0600121
Patrick Venture0b02be92018-08-31 11:55:55 -0700122 switch (pTable->offset)
123 {
Chris Austen0130d6e2015-10-15 22:32:36 -0500124
Patrick Venture0b02be92018-08-31 11:55:55 -0700125 case 0x00:
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700126 std::snprintf(
127 p, sizeof(valuestring), "POST Error, %s",
128 event_data_lookup(g_fwprogress00h, pRec->event_data2));
Patrick Venture0b02be92018-08-31 11:55:55 -0700129 break;
130 case 0x01: /* Using g_fwprogress02h for 0x01 because that's what the
131 ipmi spec says to do */
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700132 std::snprintf(
133 p, sizeof(valuestring), "FW Hang, %s",
134 event_data_lookup(g_fwprogress02h, pRec->event_data2));
Patrick Venture0b02be92018-08-31 11:55:55 -0700135 break;
136 case 0x02:
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700137 std::snprintf(
138 p, sizeof(valuestring), "FW Progress, %s",
139 event_data_lookup(g_fwprogress02h, pRec->event_data2));
Patrick Venture0b02be92018-08-31 11:55:55 -0700140 break;
141 default:
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700142 std::snprintf(
143 p, sizeof(valuestring),
144 "Internal warning, fw_progres offset unknown (0x%02x)",
145 pTable->offset);
Patrick Venture0b02be92018-08-31 11:55:55 -0700146 break;
147 }
Chris Austen0130d6e2015-10-15 22:32:36 -0500148
Patrick Venture0b02be92018-08-31 11:55:55 -0700149 return set_sensor_dbus_state_s(pRec->sensor_number, pTable->member, p);
Chris Austen0130d6e2015-10-15 22:32:36 -0500150}
151
Patrick Venture0b02be92018-08-31 11:55:55 -0700152// Handling this special OEM sensor by coping what is in byte 4. I also think
153// that is odd considering byte 3 is for sensor reading. This seems like a
154// misuse of the IPMI spec
155int set_sensor_dbus_state_osbootcount(const sensorRES_t* pRec,
156 const lookup_t* pTable, const char* value)
157{
158 return set_sensor_dbus_state_y(pRec->sensor_number, "setValue",
Chris Austen10ccc0f2015-12-10 18:27:04 -0600159 pRec->assert_state7_0);
Chris Austen0a4e2472015-10-18 12:19:40 -0500160}
161
Patrick Venture0b02be92018-08-31 11:55:55 -0700162int set_sensor_dbus_state_system_event(const sensorRES_t* pRec,
163 const lookup_t* pTable,
164 const char* value)
165{
166 char valuestring[128];
167 char* p = valuestring;
Chris Austen800ba712015-12-03 15:31:00 -0600168
Patrick Venture0b02be92018-08-31 11:55:55 -0700169 switch (pTable->offset)
170 {
Chris Austen800ba712015-12-03 15:31:00 -0600171
Patrick Venture0b02be92018-08-31 11:55:55 -0700172 case 0x00:
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700173 std::snprintf(p, sizeof(valuestring), "System Reconfigured");
Patrick Venture0b02be92018-08-31 11:55:55 -0700174 break;
175 case 0x01:
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700176 std::snprintf(p, sizeof(valuestring), "OEM Boot Event");
Patrick Venture0b02be92018-08-31 11:55:55 -0700177 break;
178 case 0x02:
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700179 std::snprintf(p, sizeof(valuestring),
180 "Undetermined System Hardware Failure");
Patrick Venture0b02be92018-08-31 11:55:55 -0700181 break;
182 case 0x03:
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700183 std::snprintf(
184 p, sizeof(valuestring),
185 "System Failure see error log for more details (0x%02x)",
186 pRec->event_data2);
Patrick Venture0b02be92018-08-31 11:55:55 -0700187 break;
188 case 0x04:
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700189 std::snprintf(
Patrick Venture0b02be92018-08-31 11:55:55 -0700190 p, sizeof(valuestring),
191 "System Failure see PEF error log for more details (0x%02x)",
192 pRec->event_data2);
193 break;
194 default:
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700195 std::snprintf(
196 p, sizeof(valuestring),
197 "Internal warning, system_event offset unknown (0x%02x)",
198 pTable->offset);
Patrick Venture0b02be92018-08-31 11:55:55 -0700199 break;
200 }
Chris Austen800ba712015-12-03 15:31:00 -0600201
Patrick Venture0b02be92018-08-31 11:55:55 -0700202 return set_sensor_dbus_state_s(pRec->sensor_number, pTable->member, p);
Chris Austen800ba712015-12-03 15:31:00 -0600203}
Chris Austen0130d6e2015-10-15 22:32:36 -0500204
Chris Austen8a45e7c2015-10-15 00:31:46 -0500205// This table lists only senors we care about telling dbus about.
Chris Austen0012e9b2015-10-22 01:37:46 -0500206// Offset definition cab be found in section 42.2 of the IPMI 2.0
Chris Austen8a45e7c2015-10-15 00:31:46 -0500207// spec. Add more if/when there are more items of interest.
Chris Austen0130d6e2015-10-15 22:32:36 -0500208lookup_t g_ipmidbuslookup[] = {
Chris Austen8a45e7c2015-10-15 00:31:46 -0500209
Patrick Venture0b02be92018-08-31 11:55:55 -0700210 {0xe9, 0x00, set_sensor_dbus_state_simple, "setValue", "Disabled",
211 ""}, // OCC Inactive 0
212 {0xe9, 0x01, set_sensor_dbus_state_simple, "setValue", "Enabled",
213 ""}, // OCC Active 1
214 // Turbo Allowed
215 {0xda, 0x00, set_sensor_dbus_state_simple, "setValue", "True", "False"},
216 // Power Supply Derating
217 {0xb4, 0x00, set_sensor_dbus_state_simple, "setValue", "", ""},
218 // Power Cap
219 {0xC2, 0x00, set_sensor_dbus_state_simple, "setValue", "", ""},
220 {0x07, 0x07, set_sensor_dbus_state_simple, "setPresent", "True", "False"},
221 {0x07, 0x08, set_sensor_dbus_state_simple, "setFault", "True", "False"},
222 {0x0C, 0x06, set_sensor_dbus_state_simple, "setPresent", "True", "False"},
223 {0x0C, 0x04, set_sensor_dbus_state_simple, "setFault", "True", "False"},
224 {0x0F, 0x02, set_sensor_dbus_state_fwprogress, "setValue", "True", "False"},
225 {0x0F, 0x01, set_sensor_dbus_state_fwprogress, "setValue", "True", "False"},
226 {0x0F, 0x00, set_sensor_dbus_state_fwprogress, "setValue", "True", "False"},
227 {0xC7, 0x01, set_sensor_dbus_state_simple, "setFault", "True", "False"},
228 {0xc3, 0x00, set_sensor_dbus_state_osbootcount, "setValue", "", ""},
229 {0x1F, 0x00, set_sensor_dbus_state_simple, "setValue",
230 "Boot completed (00)", ""},
231 {0x1F, 0x01, set_sensor_dbus_state_simple, "setValue",
232 "Boot completed (01)", ""},
233 {0x1F, 0x02, set_sensor_dbus_state_simple, "setValue", "PXE boot completed",
234 ""},
235 {0x1F, 0x03, set_sensor_dbus_state_simple, "setValue",
236 "Diagnostic boot completed", ""},
237 {0x1F, 0x04, set_sensor_dbus_state_simple, "setValue",
238 "CD-ROM boot completed", ""},
239 {0x1F, 0x05, set_sensor_dbus_state_simple, "setValue", "ROM boot completed",
240 ""},
241 {0x1F, 0x06, set_sensor_dbus_state_simple, "setValue",
242 "Boot completed (06)", ""},
243 {0x12, 0x00, set_sensor_dbus_state_system_event, "setValue", "", ""},
244 {0x12, 0x01, set_sensor_dbus_state_system_event, "setValue", "", ""},
245 {0x12, 0x02, set_sensor_dbus_state_system_event, "setValue", "", ""},
246 {0x12, 0x03, set_sensor_dbus_state_system_event, "setValue", "", ""},
247 {0x12, 0x04, set_sensor_dbus_state_system_event, "setValue", "", ""},
248 {0xCA, 0x00, set_sensor_dbus_state_simple, "setValue", "Disabled", ""},
249 {0xCA, 0x01, set_sensor_dbus_state_simple, "setValue", "Enabled", ""},
250 {0xFF, 0xFF, NULL, "", "", ""}};
Chris Austen8a45e7c2015-10-15 00:31:46 -0500251
Patrick Ventured99148b2018-10-13 10:06:13 -0700252void reportSensorEventAssert(const sensorRES_t* pRec, int index)
Patrick Venture0b02be92018-08-31 11:55:55 -0700253{
254 lookup_t* pTable = &g_ipmidbuslookup[index];
255 (*pTable->func)(pRec, pTable, pTable->assertion);
Chris Austen0130d6e2015-10-15 22:32:36 -0500256}
Patrick Ventured99148b2018-10-13 10:06:13 -0700257void reportSensorEventDeassert(const sensorRES_t* pRec, int index)
Patrick Venture0b02be92018-08-31 11:55:55 -0700258{
259 lookup_t* pTable = &g_ipmidbuslookup[index];
260 (*pTable->func)(pRec, pTable, pTable->deassertion);
Chris Austen0130d6e2015-10-15 22:32:36 -0500261}
262
Patrick Venture0b02be92018-08-31 11:55:55 -0700263int findindex(const uint8_t sensor_type, int offset, int* index)
264{
Chris Austen0130d6e2015-10-15 22:32:36 -0500265
Patrick Venture0b02be92018-08-31 11:55:55 -0700266 int i = 0, rc = 0;
267 lookup_t* pTable = g_ipmidbuslookup;
Gunnar Millsd8249ee2018-04-12 16:33:53 -0500268
Patrick Venture0b02be92018-08-31 11:55:55 -0700269 do
270 {
271 if (((pTable + i)->sensor_type == sensor_type) &&
272 ((pTable + i)->offset == offset))
273 {
274 rc = 1;
275 *index = i;
276 break;
277 }
278 i++;
279 } while ((pTable + i)->sensor_type != 0xFF);
Chris Austen8a45e7c2015-10-15 00:31:46 -0500280
Patrick Venture0b02be92018-08-31 11:55:55 -0700281 return rc;
Chris Austen8a45e7c2015-10-15 00:31:46 -0500282}
283
Patrick Venture0b02be92018-08-31 11:55:55 -0700284bool shouldReport(uint8_t sensorType, int offset, int* index)
285{
Chris Austen8a45e7c2015-10-15 00:31:46 -0500286
Patrick Venture0b02be92018-08-31 11:55:55 -0700287 bool rc = false;
Chris Austen0a4e2472015-10-18 12:19:40 -0500288
Patrick Venture0b02be92018-08-31 11:55:55 -0700289 if (findindex(sensorType, offset, index))
290 {
291 rc = true;
292 }
293 if (rc == false)
294 {
Aditya Saripalli5fb14602017-11-09 14:46:27 +0530295#ifdef __IPMI_DEBUG__
296 log<level::DEBUG>("LOOKATME: Sensor should not be reported",
Patrick Venture0b02be92018-08-31 11:55:55 -0700297 entry("SENSORTYPE=0x%02x", sensorType),
298 entry("OFFSET=0x%02x", offset));
Aditya Saripalli5fb14602017-11-09 14:46:27 +0530299#endif
Patrick Venture0b02be92018-08-31 11:55:55 -0700300 }
Chris Austen0a4e2472015-10-18 12:19:40 -0500301
Patrick Venture0b02be92018-08-31 11:55:55 -0700302 return rc;
Chris Austen8a45e7c2015-10-15 00:31:46 -0500303}
304
Patrick Venture0b02be92018-08-31 11:55:55 -0700305int updateSensorRecordFromSSRAESC(const void* record)
306{
Chris Austen8a45e7c2015-10-15 00:31:46 -0500307
Patrick Ventured99148b2018-10-13 10:06:13 -0700308 auto pRec = static_cast<const sensorRES_t*>(record);
Patrick Venture0b02be92018-08-31 11:55:55 -0700309 uint8_t stype;
310 int index, i = 0;
Chris Austen8a45e7c2015-10-15 00:31:46 -0500311
Patrick Venture0b02be92018-08-31 11:55:55 -0700312 stype = find_type_for_sensor_number(pRec->sensor_number);
Chris Austen8a45e7c2015-10-15 00:31:46 -0500313
Patrick Venture0b02be92018-08-31 11:55:55 -0700314 // 0xC3 types use the assertion7_0 for the value to be set
315 // so skip the reseach and call the correct event reporting
316 // function
317 if (stype == 0xC3)
318 {
Chris Austen0012e9b2015-10-22 01:37:46 -0500319
Patrick Venture0b02be92018-08-31 11:55:55 -0700320 shouldReport(stype, 0x00, &index);
321 reportSensorEventAssert(pRec, index);
322 }
323 else
324 {
325 // Scroll through each bit position . Determine
326 // if any bit is either asserted or Deasserted.
327 for (i = 0; i < 8; i++)
328 {
Chris Austen0012e9b2015-10-22 01:37:46 -0500329
Patrick Venture0b02be92018-08-31 11:55:55 -0700330 if ((ISBITSET(pRec->assert_state7_0, i)) &&
331 (shouldReport(stype, i, &index)))
332 {
333 reportSensorEventAssert(pRec, index);
334 }
335 if ((ISBITSET(pRec->assert_state14_8, i)) &&
336 (shouldReport(stype, i + 8, &index)))
337 {
338 reportSensorEventAssert(pRec, index);
339 }
340 if ((ISBITSET(pRec->deassert_state7_0, i)) &&
341 (shouldReport(stype, i, &index)))
342 {
343 reportSensorEventDeassert(pRec, index);
344 }
345 if ((ISBITSET(pRec->deassert_state14_8, i)) &&
346 (shouldReport(stype, i + 8, &index)))
347 {
348 reportSensorEventDeassert(pRec, index);
349 }
350 }
351 }
Chris Austen0012e9b2015-10-22 01:37:46 -0500352
Patrick Venture0b02be92018-08-31 11:55:55 -0700353 return 0;
Chris Austen8a45e7c2015-10-15 00:31:46 -0500354}