Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 1 | #include <stdio.h> |
| 2 | #include <string.h> |
| 3 | #include <stdint.h> |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 4 | #include <malloc.h> |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 5 | |
| 6 | |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 7 | extern uint8_t find_sensor(uint8_t); |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 8 | extern int set_sensor_dbus_state_v(uint8_t , const char *, char *); |
| 9 | |
| 10 | |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 11 | struct sensorRES_t { |
| 12 | uint8_t sensor_number; |
| 13 | uint8_t operation; |
| 14 | uint8_t sensor_reading; |
| 15 | uint8_t assert_state7_0; |
| 16 | uint8_t assert_state14_8; |
| 17 | uint8_t deassert_state7_0; |
| 18 | uint8_t deassert_state14_8; |
| 19 | uint8_t event_data1; |
| 20 | uint8_t event_data2; |
| 21 | uint8_t event_data3; |
| 22 | } __attribute__ ((packed)); |
| 23 | |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 24 | #define ISBITSET(x,y) (((x)>>(y))&0x01) |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 25 | #define ASSERTINDEX 0 |
| 26 | #define DEASSERTINDEX 1 |
| 27 | |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 28 | // Sensor Type, Offset, function handler, Dbus Method, Assert value, Deassert value |
| 29 | struct lookup_t { |
| 30 | uint8_t sensor_type; |
| 31 | uint8_t offset; |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 32 | int (*func)(const sensorRES_t *, const lookup_t *, const char *); |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 33 | char method[16]; |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 34 | char assertion[64]; |
| 35 | char deassertion[64]; |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 36 | }; |
| 37 | |
| 38 | |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 39 | extern int updateDbusInterface(uint8_t , const char *, const char *) ; |
| 40 | extern int set_sensor_dbus_state(uint8_t ,const char *, const char *); |
| 41 | |
| 42 | |
| 43 | int set_sensor_dbus_state_simple(const sensorRES_t *pRec, const lookup_t *pTable, const char *value) { |
| 44 | |
| 45 | return set_sensor_dbus_state(pRec->sensor_number, pTable->method, value); |
| 46 | } |
| 47 | |
| 48 | struct event_data_t { |
| 49 | uint8_t data; |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 50 | char text[64]; |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 51 | }; |
| 52 | |
| 53 | event_data_t g_fwprogress02h[] = { |
| 54 | {0x00, "Unspecified"}, |
| 55 | {0x01, "Memory Init"}, |
| 56 | {0x02, "HD Init"}, |
| 57 | {0x03, "Secondary Proc Init"}, |
| 58 | {0x04, "User Authentication"}, |
| 59 | {0x05, "User init system setup"}, |
| 60 | {0x06, "USB configuration"}, |
| 61 | {0x07, "PCI configuration"}, |
| 62 | {0x08, "Option ROM Init"}, |
| 63 | {0x09, "Video Init"}, |
| 64 | {0x0A, "Cache Init"}, |
| 65 | {0x0B, "SM Bus init"}, |
| 66 | {0x0C, "Keyboard Init"}, |
| 67 | {0x0D, "Embedded ctrl init"}, |
| 68 | {0x0E, "Docking station attachment"}, |
| 69 | {0x0F, "Enable docking station"}, |
| 70 | {0x10, "Docking station ejection"}, |
| 71 | {0x11, "Disabling docking station"}, |
| 72 | {0x12, "Calling OS Wakeup"}, |
| 73 | {0x13, "Starting OS"}, |
| 74 | {0x14, "Baseboard Init"}, |
| 75 | {0x15, ""}, |
| 76 | {0x16, "Floppy Init"}, |
| 77 | {0x17, "Keyboard Test"}, |
| 78 | {0x18, "Pointing Device Test"}, |
| 79 | {0x19, "Primary Proc Init"}, |
| 80 | {0xFF, "Unknown"} |
| 81 | }; |
| 82 | |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 83 | event_data_t g_fwprogress00h[] = { |
| 84 | {0x00, "Unspecified."}, |
| 85 | {0x01, "No system memory detected"}, |
| 86 | {0x02, "No usable system memory"}, |
| 87 | {0x03, "Unrecoverable hard-disk/ATAPI/IDE"}, |
| 88 | {0x04, "Unrecoverable system-board"}, |
| 89 | {0x05, "Unrecoverable diskette"}, |
| 90 | {0x06, "Unrecoverable hard-disk controller"}, |
| 91 | {0x07, "Unrecoverable PS/2 or USB keyboard"}, |
| 92 | {0x08, "Removable boot media not found"}, |
| 93 | {0x09, "Unrecoverable video controller"}, |
| 94 | {0x0A, "No video device detected"}, |
| 95 | {0x0B, "Firmware ROM corruption detected"}, |
| 96 | {0x0C, "CPU voltage mismatch"}, |
| 97 | {0x0D, "CPU speed matching"}, |
| 98 | {0xFF, "unknown"}, |
| 99 | }; |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 100 | |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 101 | |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 102 | char *event_data_lookup(event_data_t *p, uint8_t b) { |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 103 | |
Chris Austen | 5a9f0b4 | 2015-10-21 20:32:19 -0500 | [diff] [blame] | 104 | while(p->data != 0xFF) { |
| 105 | if (p->data == b) { |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 106 | break; |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 107 | } |
Chris Austen | 5a9f0b4 | 2015-10-21 20:32:19 -0500 | [diff] [blame] | 108 | p++; |
| 109 | } |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 110 | |
Chris Austen | 5a9f0b4 | 2015-10-21 20:32:19 -0500 | [diff] [blame] | 111 | return p->text; |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 112 | } |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 113 | |
| 114 | |
| 115 | |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 116 | // The fw progress sensor contains some additional information that needs to be processed |
| 117 | // prior to calling the dbus code. |
| 118 | int set_sensor_dbus_state_fwprogress(const sensorRES_t *pRec, const lookup_t *pTable, const char *value) { |
| 119 | |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 120 | char valuestring[128]; |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 121 | char* p = valuestring; |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 122 | |
| 123 | switch (pTable->offset) { |
| 124 | |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 125 | case 0x00 : snprintf(p, sizeof(valuestring), "POST Error, %s", event_data_lookup(g_fwprogress00h, pRec->event_data2)); |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 126 | break; |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 127 | case 0x01 : /* Using g_fwprogress02h for 0x01 because thats what the ipmi spec says to do */ |
| 128 | snprintf(p, sizeof(valuestring), "FW Hang, %s", event_data_lookup(g_fwprogress02h, pRec->event_data2)); |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 129 | break; |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 130 | case 0x02 : snprintf(p, sizeof(valuestring), "FW Progress, %s", event_data_lookup(g_fwprogress02h, pRec->event_data2)); |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 131 | break; |
Chris Austen | 800ba71 | 2015-12-03 15:31:00 -0600 | [diff] [blame] | 132 | default : snprintf(p, sizeof(valuestring), "Internal warning, fw_progres offset unknown (0x%02x)", pTable->offset); |
| 133 | break; |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 134 | } |
| 135 | |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 136 | return set_sensor_dbus_state_v(pRec->sensor_number, pTable->method, p); |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 137 | } |
| 138 | |
Chris Austen | 0a4e247 | 2015-10-18 12:19:40 -0500 | [diff] [blame] | 139 | // Handling this special OEM sensor by coping what is in byte 4. I also think that is odd |
| 140 | // considering byte 3 is for sensor reading. This seems like a misuse of the IPMI spec |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 141 | int set_sensor_dbus_state_osbootcount(const sensorRES_t *pRec, const lookup_t *pTable, const char *value) { |
Chris Austen | 0a4e247 | 2015-10-18 12:19:40 -0500 | [diff] [blame] | 142 | char valuestring[32]; |
| 143 | char* pStr = valuestring; |
| 144 | |
| 145 | sprintf(valuestring, "%d", pRec->assert_state7_0); |
| 146 | |
| 147 | return set_sensor_dbus_state_v(pRec->sensor_number, pTable->method, pStr); |
| 148 | } |
| 149 | |
Chris Austen | 800ba71 | 2015-12-03 15:31:00 -0600 | [diff] [blame] | 150 | int set_sensor_dbus_state_system_event(const sensorRES_t *pRec, const lookup_t *pTable, const char *value) { |
| 151 | char valuestring[128]; |
| 152 | char* p = valuestring; |
| 153 | |
| 154 | switch (pTable->offset) { |
| 155 | |
| 156 | case 0x00 : snprintf(p, sizeof(valuestring), "System Reconfigured"); |
| 157 | break; |
| 158 | case 0x01 : snprintf(p, sizeof(valuestring), "OEM Boot Event"); |
| 159 | break; |
| 160 | case 0x02 : snprintf(p, sizeof(valuestring), "Undetermine System Hardware Failure"); |
| 161 | break; |
| 162 | case 0x03 : snprintf(p, sizeof(valuestring), "System Failure see error log for more details (0x%02x)", pRec->event_data2); |
| 163 | break; |
| 164 | case 0x04 : snprintf(p, sizeof(valuestring), "System Failure see PEF error log for more details (0x%02x)", pRec->event_data2); |
| 165 | break; |
| 166 | default : snprintf(p, sizeof(valuestring), "Internal warning, system_event offset unknown (0x%02x)", pTable->offset); |
| 167 | break; |
| 168 | } |
| 169 | |
| 170 | return set_sensor_dbus_state_v(pRec->sensor_number, pTable->method, p); |
| 171 | } |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 172 | |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 173 | |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 174 | // This table lists only senors we care about telling dbus about. |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 175 | // Offset definition cab be found in section 42.2 of the IPMI 2.0 |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 176 | // spec. Add more if/when there are more items of interest. |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 177 | lookup_t g_ipmidbuslookup[] = { |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 178 | |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 179 | {0xe9, 0x00, set_sensor_dbus_state_simple, "setValue", "Disabled", ""}, // OCC Inactive 0 |
| 180 | {0xe9, 0x01, set_sensor_dbus_state_simple, "setValue", "Enabled", ""}, // OCC Active 1 |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 181 | {0x07, 0x07, set_sensor_dbus_state_simple, "setPresent", "True", "False"}, |
Chris Austen | 800ba71 | 2015-12-03 15:31:00 -0600 | [diff] [blame] | 182 | {0x07, 0x08, set_sensor_dbus_state_simple, "setFault", "True", "False"}, |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 183 | {0x0C, 0x06, set_sensor_dbus_state_simple, "setPresent", "True", "False"}, |
Chris Austen | 800ba71 | 2015-12-03 15:31:00 -0600 | [diff] [blame] | 184 | {0x0C, 0x04, set_sensor_dbus_state_simple, "setFault", "True", "False"}, |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 185 | {0x0F, 0x02, set_sensor_dbus_state_fwprogress, "setValue", "True", "False"}, |
| 186 | {0x0F, 0x01, set_sensor_dbus_state_fwprogress, "setValue", "True", "False"}, |
| 187 | {0x0F, 0x00, set_sensor_dbus_state_fwprogress, "setValue", "True", "False"}, |
Chris Austen | 800ba71 | 2015-12-03 15:31:00 -0600 | [diff] [blame] | 188 | {0xC7, 0x01, set_sensor_dbus_state_simple, "setFault", "True", "False"}, |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 189 | {0xc3, 0x00, set_sensor_dbus_state_osbootcount, "setValue", "" ,""}, |
| 190 | {0x1F, 0x00, set_sensor_dbus_state_simple, "setValue", "Boot completed (00)", ""}, |
| 191 | {0x1F, 0x01, set_sensor_dbus_state_simple, "setValue", "Boot completed (01)", ""}, |
| 192 | {0x1F, 0x02, set_sensor_dbus_state_simple, "setValue", "PXE boot completed", ""}, |
| 193 | {0x1F, 0x03, set_sensor_dbus_state_simple, "setValue", "Diagnostic boot completed", ""}, |
| 194 | {0x1F, 0x04, set_sensor_dbus_state_simple, "setValue", "CD-ROM boot completed", ""}, |
| 195 | {0x1F, 0x05, set_sensor_dbus_state_simple, "setValue", "ROM boot completed", ""}, |
| 196 | {0x1F, 0x06, set_sensor_dbus_state_simple, "setValue", "Boot completed (06)", ""}, |
Chris Austen | 800ba71 | 2015-12-03 15:31:00 -0600 | [diff] [blame] | 197 | {0x12, 0x00, set_sensor_dbus_state_system_event, "setValue", "", ""}, |
| 198 | {0x12, 0x01, set_sensor_dbus_state_system_event, "setValue", "", ""}, |
| 199 | {0x12, 0x02, set_sensor_dbus_state_system_event, "setValue", "", ""}, |
| 200 | {0x12, 0x03, set_sensor_dbus_state_system_event, "setValue", "", ""}, |
| 201 | {0x12, 0x04, set_sensor_dbus_state_system_event, "setValue", "", ""}, |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 202 | |
| 203 | {0xFF, 0xFF, NULL, "", "", ""} |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 204 | }; |
| 205 | |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 206 | |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 207 | void reportSensorEventAssert(sensorRES_t *pRec, int index) { |
| 208 | lookup_t *pTable = &g_ipmidbuslookup[index]; |
| 209 | (*pTable->func)(pRec, pTable, pTable->assertion); |
| 210 | } |
| 211 | void reportSensorEventDeassert(sensorRES_t *pRec, int index) { |
| 212 | lookup_t *pTable = &g_ipmidbuslookup[index]; |
| 213 | (*pTable->func)(pRec, pTable, pTable->deassertion); |
| 214 | } |
| 215 | |
| 216 | |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 217 | int findindex(const uint8_t sensor_type, int offset, int *index) { |
| 218 | |
| 219 | int i=0, rc=0; |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 220 | lookup_t *pTable = g_ipmidbuslookup; |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 221 | |
| 222 | do { |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 223 | if ( ((pTable+i)->sensor_type == sensor_type) && |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 224 | ((pTable+i)->offset == offset) ) { |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 225 | rc = 1; |
| 226 | *index = i; |
| 227 | break; |
| 228 | } |
| 229 | i++; |
| 230 | } while ((pTable+i)->sensor_type != 0xFF); |
| 231 | |
| 232 | return rc; |
| 233 | } |
| 234 | |
Chris Austen | 0a4e247 | 2015-10-18 12:19:40 -0500 | [diff] [blame] | 235 | void debug_print_ok_to_dont_care(uint8_t stype, int offset) |
| 236 | { |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 237 | printf("LOOKATME: Sensor should not be reported: Type 0x%02x, Offset 0x%02x\n", |
Chris Austen | 0a4e247 | 2015-10-18 12:19:40 -0500 | [diff] [blame] | 238 | stype, offset); |
| 239 | } |
| 240 | |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 241 | bool shouldReport(uint8_t sensorType, int offset, int *index) { |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 242 | |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 243 | bool rc = false; |
Chris Austen | 0a4e247 | 2015-10-18 12:19:40 -0500 | [diff] [blame] | 244 | |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 245 | if (findindex(sensorType, offset, index)) { rc = true; } |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 246 | |
Chris Austen | 0a4e247 | 2015-10-18 12:19:40 -0500 | [diff] [blame] | 247 | if (rc==false) { debug_print_ok_to_dont_care(sensorType, offset); } |
| 248 | |
Chris Austen | 0130d6e | 2015-10-15 22:32:36 -0500 | [diff] [blame] | 249 | return rc; |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 250 | } |
| 251 | |
| 252 | |
| 253 | int updateSensorRecordFromSSRAESC(const void *record) { |
| 254 | |
| 255 | sensorRES_t *pRec = (sensorRES_t *) record; |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 256 | uint8_t stype; |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 257 | int index, i=0; |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 258 | |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 259 | stype = find_sensor(pRec->sensor_number); |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 260 | |
| 261 | // 0xC3 types use the assertion7_0 for the value to be set |
| 262 | // so skip the reseach and call the correct event reporting |
| 263 | // function |
| 264 | if (stype == 0xC3) { |
| 265 | |
| 266 | shouldReport(stype, 0x00, &index); |
| 267 | reportSensorEventAssert(pRec, index); |
| 268 | |
| 269 | } else { |
| 270 | // Scroll through each bit position . Determine |
| 271 | // if any bit is either asserted or Deasserted. |
| 272 | for(i=0;i<8;i++) { |
Chris Austen | d7cf0e4 | 2015-11-07 14:27:12 -0600 | [diff] [blame] | 273 | |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 274 | if ((ISBITSET(pRec->assert_state7_0,i)) && |
| 275 | (shouldReport(stype, i, &index))) |
| 276 | { |
| 277 | reportSensorEventAssert(pRec, index); |
| 278 | } |
| 279 | if ((ISBITSET(pRec->assert_state14_8,i)) && |
| 280 | (shouldReport(stype, i+8, &index))) |
| 281 | { |
| 282 | reportSensorEventAssert(pRec, index); |
| 283 | } |
| 284 | if ((ISBITSET(pRec->deassert_state7_0,i)) && |
| 285 | (shouldReport(stype, i, &index))) |
| 286 | { |
| 287 | reportSensorEventDeassert(pRec, index); |
| 288 | } |
| 289 | if ((ISBITSET(pRec->deassert_state14_8,i)) && |
| 290 | (shouldReport(stype, i+8, &index))) |
| 291 | { |
| 292 | reportSensorEventDeassert(pRec, index); |
| 293 | } |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 294 | } |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 295 | |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 296 | } |
| 297 | |
Chris Austen | 0012e9b | 2015-10-22 01:37:46 -0500 | [diff] [blame] | 298 | |
Chris Austen | 8a45e7c | 2015-10-15 00:31:46 -0500 | [diff] [blame] | 299 | return 0; |
| 300 | } |