blob: 87802351b54fe25fb94b47064d95f5a206a69986 [file] [log] [blame]
Patrick Venture46470a32018-09-07 19:26:25 -07001#pragma once
Chris Austenac4604a2015-10-13 12:43:27 -05002
Patrick Venture0b02be92018-08-31 11:55:55 -07003#include <stdint.h>
4
Brandon Kim9cf85622019-06-19 12:05:08 -07005#include <exception>
Vernon Mauerye08fbff2019-04-03 09:19:34 -07006#include <ipmid/api.hpp>
Vernon Mauery33250242019-03-12 16:49:26 -07007#include <ipmid/types.hpp>
8
Chris Austenac4604a2015-10-13 12:43:27 -05009// IPMI commands for net functions.
10enum ipmi_netfn_sen_cmds
11{
Jia, Chunhui3342a8e2018-12-29 13:32:26 +080012 IPMI_CMD_PLATFORM_EVENT = 0x2,
Tom Joseph5ca50952018-02-22 00:33:38 +053013 IPMI_CMD_GET_DEVICE_SDR_INFO = 0x20,
Patrick Venture0b02be92018-08-31 11:55:55 -070014 IPMI_CMD_GET_DEVICE_SDR = 0x21,
15 IPMI_CMD_RESERVE_DEVICE_SDR_REPO = 0x22,
Chris Austen10ccc0f2015-12-10 18:27:04 -060016 IPMI_CMD_GET_SENSOR_READING = 0x2D,
Patrick Venture0b02be92018-08-31 11:55:55 -070017 IPMI_CMD_GET_SENSOR_TYPE = 0x2F,
18 IPMI_CMD_SET_SENSOR = 0x30,
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -060019 IPMI_CMD_GET_SENSOR_THRESHOLDS = 0x27,
Chris Austenac4604a2015-10-13 12:43:27 -050020};
21
Ratan Guptae0cc8552018-01-22 14:23:04 +053022/**
23 * @enum device_type
24 * IPMI FRU device types
25 */
26enum device_type
27{
28 IPMI_PHYSICAL_FRU = 0x00,
29 IPMI_LOGICAL_FRU = 0x80,
30};
31
Emily Shaffer1fabf222017-04-05 08:53:21 -070032// Discrete sensor types.
33enum ipmi_sensor_types
34{
Patrick Venture0b02be92018-08-31 11:55:55 -070035 IPMI_SENSOR_TEMP = 0x01,
Emily Shaffer1fabf222017-04-05 08:53:21 -070036 IPMI_SENSOR_VOLTAGE = 0x02,
37 IPMI_SENSOR_CURRENT = 0x03,
Patrick Venture0b02be92018-08-31 11:55:55 -070038 IPMI_SENSOR_FAN = 0x04,
39 IPMI_SENSOR_TPM = 0xCC,
Emily Shaffer1fabf222017-04-05 08:53:21 -070040};
41
Brandon Kim9cf85622019-06-19 12:05:08 -070042/** @brief Custom exception for reading sensors that are not funcitonal.
43 */
44struct SensorFunctionalError : public std::exception
45{
46 const char* what() const noexcept
47 {
48 return "Sensor not functional";
49 }
50};
51
Chris Austen0012e9b2015-10-22 01:37:46 -050052#define MAX_DBUS_PATH 128
Patrick Venture0b02be92018-08-31 11:55:55 -070053struct dbus_interface_t
54{
55 uint8_t sensornumber;
56 uint8_t sensortype;
Chris Austen0012e9b2015-10-22 01:37:46 -050057
Patrick Venture0b02be92018-08-31 11:55:55 -070058 char bus[MAX_DBUS_PATH];
59 char path[MAX_DBUS_PATH];
60 char interface[MAX_DBUS_PATH];
Chris Austen0012e9b2015-10-22 01:37:46 -050061};
Tomd700e762016-09-20 18:24:13 +053062
Jia, Chunhui3342a8e2018-12-29 13:32:26 +080063struct PlatformEventRequest
64{
65 uint8_t eventMessageRevision;
66 uint8_t sensorType;
67 uint8_t sensorNumber;
68 uint8_t eventDirectionType;
69 uint8_t data[3];
70};
71
72static constexpr char const* ipmiSELPath = "/xyz/openbmc_project/Logging/IPMI";
73static constexpr char const* ipmiSELAddInterface =
74 "xyz.openbmc_project.Logging.IPMI";
75static const std::string ipmiSELAddMessage = "SEL Entry";
76
77static constexpr int selSystemEventSizeWith3Bytes = 8;
78static constexpr int selSystemEventSizeWith2Bytes = 7;
79static constexpr int selSystemEventSizeWith1Bytes = 6;
80static constexpr int selIPMBEventSize = 7;
81static constexpr uint8_t directionMask = 0x80;
82static constexpr uint8_t byte3EnableMask = 0x30;
83static constexpr uint8_t byte2EnableMask = 0xC0;
84
Patrick Venture0b02be92018-08-31 11:55:55 -070085int set_sensor_dbus_state_s(uint8_t, const char*, const char*);
86int set_sensor_dbus_state_y(uint8_t, const char*, const uint8_t);
87int find_openbmc_path(uint8_t, dbus_interface_t*);
Tom05732372016-09-06 17:21:23 +053088
Tom Joseph5ca50952018-02-22 00:33:38 +053089ipmi_ret_t ipmi_sen_get_sdr(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
90 ipmi_request_t request, ipmi_response_t response,
91 ipmi_data_len_t data_len, ipmi_context_t context);
92
jayaprakash Mutyalad9578232019-05-13 20:22:50 +000093ipmi::RspType<uint16_t> ipmiSensorReserveSdr();
Tom Joseph5ca50952018-02-22 00:33:38 +053094
Ratan Guptae0cc8552018-01-22 14:23:04 +053095static const uint16_t FRU_RECORD_ID_START = 256;
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -080096static const uint16_t ENTITY_RECORD_ID_START = 512;
Ratan Guptae0cc8552018-01-22 14:23:04 +053097static const uint8_t SDR_VERSION = 0x51;
98static const uint16_t END_OF_RECORD = 0xFFFF;
99static const uint8_t LENGTH_MASK = 0x1F;
100
Tom Josephbe703f72017-03-09 12:34:35 +0530101/**
Emily Shafferd06e0e72017-04-05 09:08:57 -0700102 * Get SDR Info
103 */
104
105namespace get_sdr_info
106{
107namespace request
108{
109// Note: for some reason the ipmi_request_t appears to be the
110// raw value for this call.
111inline bool get_count(void* req)
112{
Patrick Venture0b02be92018-08-31 11:55:55 -0700113 return (bool)((uint64_t)(req)&1);
Emily Shafferd06e0e72017-04-05 09:08:57 -0700114}
115} // namespace request
Emily Shafferd06e0e72017-04-05 09:08:57 -0700116} // namespace get_sdr_info
Emily Shafferbbef71c2017-05-08 16:36:17 -0700117
118/**
119 * Get SDR
120 */
121namespace get_sdr
122{
123
124struct GetSdrReq
125{
126 uint8_t reservation_id_lsb;
127 uint8_t reservation_id_msb;
128 uint8_t record_id_lsb;
129 uint8_t record_id_msb;
130 uint8_t offset;
131 uint8_t bytes_to_read;
132} __attribute__((packed));
133
134namespace request
135{
136
Emily Shaffere5c9d2f2019-06-25 14:26:45 -0700137inline uint16_t get_reservation_id(GetSdrReq* req)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700138{
139 return (req->reservation_id_lsb + (req->reservation_id_msb << 8));
140};
141
Ratan Guptae0cc8552018-01-22 14:23:04 +0530142inline uint16_t get_record_id(GetSdrReq* req)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700143{
144 return (req->record_id_lsb + (req->record_id_msb << 8));
145};
146
147} // namespace request
148
149// Response
150struct GetSdrResp
151{
152 uint8_t next_record_id_lsb;
153 uint8_t next_record_id_msb;
154 uint8_t record_data[64];
155} __attribute__((packed));
156
157namespace response
158{
159
Ratan Guptae0cc8552018-01-22 14:23:04 +0530160inline void set_next_record_id(uint16_t next, GetSdrResp* resp)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700161{
162 resp->next_record_id_lsb = next & 0xff;
163 resp->next_record_id_msb = (next >> 8) & 0xff;
164};
165
166} // namespace response
167
168// Record header
169struct SensorDataRecordHeader
170{
171 uint8_t record_id_lsb;
172 uint8_t record_id_msb;
173 uint8_t sdr_version;
174 uint8_t record_type;
175 uint8_t record_length; // Length not counting the header
176} __attribute__((packed));
177
178namespace header
179{
180
181inline void set_record_id(int id, SensorDataRecordHeader* hdr)
182{
183 hdr->record_id_lsb = (id & 0xFF);
184 hdr->record_id_msb = (id >> 8) & 0xFF;
185};
186
187} // namespace header
188
189enum SensorDataRecordType
190{
Ratan Guptae0cc8552018-01-22 14:23:04 +0530191 SENSOR_DATA_FULL_RECORD = 0x1,
192 SENSOR_DATA_FRU_RECORD = 0x11,
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800193 SENSOR_DATA_ENTITY_RECORD = 0x8,
Emily Shafferbbef71c2017-05-08 16:36:17 -0700194};
195
196// Record key
197struct SensorDataRecordKey
198{
199 uint8_t owner_id;
200 uint8_t owner_lun;
201 uint8_t sensor_number;
202} __attribute__((packed));
203
Ratan Guptae0cc8552018-01-22 14:23:04 +0530204/** @struct SensorDataFruRecordKey
205 *
206 * FRU Device Locator Record(key) - SDR Type 11
207 */
208struct SensorDataFruRecordKey
209{
210 uint8_t deviceAddress;
211 uint8_t fruID;
212 uint8_t accessLun;
213 uint8_t channelNumber;
214} __attribute__((packed));
215
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800216/** @struct SensorDataEntityRecordKey
217 *
218 * Entity Association Record(key) - SDR Type 8
219 */
220struct SensorDataEntityRecordKey
221{
222 uint8_t containerEntityId;
223 uint8_t containerEntityInstance;
224 uint8_t flags;
225 uint8_t entityId1;
226 uint8_t entityInstance1;
227} __attribute__((packed));
228
Emily Shafferbbef71c2017-05-08 16:36:17 -0700229namespace key
230{
231
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800232static constexpr uint8_t listOrRangeBit = 7;
233static constexpr uint8_t linkedBit = 6;
234
Emily Shafferbbef71c2017-05-08 16:36:17 -0700235inline void set_owner_id_ipmb(SensorDataRecordKey* key)
236{
237 key->owner_id &= ~0x01;
238};
239
240inline void set_owner_id_system_sw(SensorDataRecordKey* key)
241{
242 key->owner_id |= 0x01;
243};
244
Tom Joseph96423912018-01-25 00:14:34 +0530245inline void set_owner_id_bmc(SensorDataRecordKey* key)
246{
247 key->owner_id |= 0x20;
248};
249
Emily Shafferbbef71c2017-05-08 16:36:17 -0700250inline void set_owner_id_address(uint8_t addr, SensorDataRecordKey* key)
251{
252 key->owner_id &= 0x01;
Patrick Venture0b02be92018-08-31 11:55:55 -0700253 key->owner_id |= addr << 1;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700254};
255
256inline void set_owner_lun(uint8_t lun, SensorDataRecordKey* key)
257{
258 key->owner_lun &= ~0x03;
Patrick Venture0b02be92018-08-31 11:55:55 -0700259 key->owner_lun |= (lun & 0x03);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700260};
261
262inline void set_owner_lun_channel(uint8_t channel, SensorDataRecordKey* key)
263{
264 key->owner_lun &= 0x0f;
Patrick Venture0b02be92018-08-31 11:55:55 -0700265 key->owner_lun |= ((channel & 0xf) << 4);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700266};
267
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800268inline void set_flags(bool isList, bool isLinked,
269 SensorDataEntityRecordKey* key)
270{
271 key->flags = 0x00;
272 if (!isList)
273 key->flags |= 1 << listOrRangeBit;
274
275 if (isLinked)
276 key->flags |= 1 << linkedBit;
277};
278
Emily Shafferbbef71c2017-05-08 16:36:17 -0700279} // namespace key
280
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600281/** @struct GetSensorThresholdsResponse
282 *
283 * Response structure for Get Sensor Thresholds command
284 */
285struct GetSensorThresholdsResponse
286{
Patrick Venture0b02be92018-08-31 11:55:55 -0700287 uint8_t validMask; //!< valid mask
288 uint8_t lowerNonCritical; //!< lower non-critical threshold
289 uint8_t lowerCritical; //!< lower critical threshold
290 uint8_t lowerNonRecoverable; //!< lower non-recoverable threshold
291 uint8_t upperNonCritical; //!< upper non-critical threshold
292 uint8_t upperCritical; //!< upper critical threshold
293 uint8_t upperNonRecoverable; //!< upper non-recoverable threshold
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600294} __attribute__((packed));
295
Emily Shafferbbef71c2017-05-08 16:36:17 -0700296// Body - full record
297#define FULL_RECORD_ID_STR_MAX_LENGTH 16
Ratan Guptae0cc8552018-01-22 14:23:04 +0530298
299static const int FRU_RECORD_DEVICE_ID_MAX_LENGTH = 16;
300
Emily Shafferbbef71c2017-05-08 16:36:17 -0700301struct SensorDataFullRecordBody
302{
303 uint8_t entity_id;
304 uint8_t entity_instance;
305 uint8_t sensor_initialization;
306 uint8_t sensor_capabilities; // no macro support
307 uint8_t sensor_type;
308 uint8_t event_reading_type;
Patrick Venture0b02be92018-08-31 11:55:55 -0700309 uint8_t supported_assertions[2]; // no macro support
310 uint8_t supported_deassertions[2]; // no macro support
Emily Shafferbbef71c2017-05-08 16:36:17 -0700311 uint8_t discrete_reading_setting_mask[2]; // no macro support
312 uint8_t sensor_units_1;
313 uint8_t sensor_units_2_base;
314 uint8_t sensor_units_3_modifier;
315 uint8_t linearization;
316 uint8_t m_lsb;
317 uint8_t m_msb_and_tolerance;
318 uint8_t b_lsb;
319 uint8_t b_msb_and_accuracy_lsb;
320 uint8_t accuracy_and_sensor_direction;
321 uint8_t r_b_exponents;
Patrick Venture0b02be92018-08-31 11:55:55 -0700322 uint8_t analog_characteristic_flags; // no macro support
Emily Shafferbbef71c2017-05-08 16:36:17 -0700323 uint8_t nominal_reading;
324 uint8_t normal_max;
325 uint8_t normal_min;
326 uint8_t sensor_max;
327 uint8_t sensor_min;
328 uint8_t upper_nonrecoverable_threshold;
329 uint8_t upper_critical_threshold;
330 uint8_t upper_noncritical_threshold;
331 uint8_t lower_nonrecoverable_threshold;
332 uint8_t lower_critical_threshold;
333 uint8_t lower_noncritical_threshold;
334 uint8_t positive_threshold_hysteresis;
335 uint8_t negative_threshold_hysteresis;
336 uint16_t reserved;
337 uint8_t oem_reserved;
338 uint8_t id_string_info;
Emily Shaffer10f49592017-05-10 12:01:10 -0700339 char id_string[FULL_RECORD_ID_STR_MAX_LENGTH];
Emily Shafferbbef71c2017-05-08 16:36:17 -0700340} __attribute__((packed));
341
Ratan Guptae0cc8552018-01-22 14:23:04 +0530342/** @struct SensorDataFruRecordBody
343 *
344 * FRU Device Locator Record(body) - SDR Type 11
345 */
346struct SensorDataFruRecordBody
347{
348 uint8_t reserved;
349 uint8_t deviceType;
350 uint8_t deviceTypeModifier;
351 uint8_t entityID;
352 uint8_t entityInstance;
353 uint8_t oem;
354 uint8_t deviceIDLen;
355 char deviceID[FRU_RECORD_DEVICE_ID_MAX_LENGTH];
356} __attribute__((packed));
357
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800358/** @struct SensorDataEntityRecordBody
359 *
360 * Entity Association Record(body) - SDR Type 8
361 */
362struct SensorDataEntityRecordBody
363{
364 uint8_t entityId2;
365 uint8_t entityInstance2;
366 uint8_t entityId3;
367 uint8_t entityInstance3;
368 uint8_t entityId4;
369 uint8_t entityInstance4;
370} __attribute__((packed));
371
Emily Shafferbbef71c2017-05-08 16:36:17 -0700372namespace body
373{
374
375inline void set_entity_instance_number(uint8_t n,
376 SensorDataFullRecordBody* body)
377{
Patrick Venture0b02be92018-08-31 11:55:55 -0700378 body->entity_instance &= 1 << 7;
379 body->entity_instance |= (n & ~(1 << 7));
Emily Shafferbbef71c2017-05-08 16:36:17 -0700380};
381inline void set_entity_physical_entity(SensorDataFullRecordBody* body)
382{
Patrick Venture0b02be92018-08-31 11:55:55 -0700383 body->entity_instance &= ~(1 << 7);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700384};
385inline void set_entity_logical_container(SensorDataFullRecordBody* body)
386{
Patrick Venture0b02be92018-08-31 11:55:55 -0700387 body->entity_instance |= 1 << 7;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700388};
389
Patrick Venture0b02be92018-08-31 11:55:55 -0700390inline void sensor_scanning_state(bool enabled, SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700391{
392 if (enabled)
393 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700394 body->sensor_initialization |= 1 << 0;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700395 }
396 else
397 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700398 body->sensor_initialization &= ~(1 << 0);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700399 };
400};
Patrick Venture0b02be92018-08-31 11:55:55 -0700401inline void event_generation_state(bool enabled, SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700402{
403 if (enabled)
404 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700405 body->sensor_initialization |= 1 << 1;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700406 }
407 else
408 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700409 body->sensor_initialization &= ~(1 << 1);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700410 }
411};
Patrick Venture0b02be92018-08-31 11:55:55 -0700412inline void init_types_state(bool enabled, SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700413{
414 if (enabled)
415 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700416 body->sensor_initialization |= 1 << 2;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700417 }
418 else
419 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700420 body->sensor_initialization &= ~(1 << 2);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700421 }
422};
Patrick Venture0b02be92018-08-31 11:55:55 -0700423inline void init_hyst_state(bool enabled, SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700424{
425 if (enabled)
426 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700427 body->sensor_initialization |= 1 << 3;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700428 }
429 else
430 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700431 body->sensor_initialization &= ~(1 << 3);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700432 }
433};
Patrick Venture0b02be92018-08-31 11:55:55 -0700434inline void init_thresh_state(bool enabled, SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700435{
436 if (enabled)
437 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700438 body->sensor_initialization |= 1 << 4;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700439 }
440 else
441 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700442 body->sensor_initialization &= ~(1 << 4);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700443 }
444};
Patrick Venture0b02be92018-08-31 11:55:55 -0700445inline void init_events_state(bool enabled, SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700446{
447 if (enabled)
448 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700449 body->sensor_initialization |= 1 << 5;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700450 }
451 else
452 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700453 body->sensor_initialization &= ~(1 << 5);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700454 }
455};
Patrick Venture0b02be92018-08-31 11:55:55 -0700456inline void init_scanning_state(bool enabled, SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700457{
458 if (enabled)
459 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700460 body->sensor_initialization |= 1 << 6;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700461 }
462 else
463 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700464 body->sensor_initialization &= ~(1 << 6);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700465 }
466};
Patrick Venture0b02be92018-08-31 11:55:55 -0700467inline void init_settable_state(bool enabled, SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700468{
469 if (enabled)
470 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700471 body->sensor_initialization |= 1 << 7;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700472 }
473 else
474 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700475 body->sensor_initialization &= ~(1 << 7);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700476 }
477};
478
479inline void set_percentage(SensorDataFullRecordBody* body)
480{
Patrick Venture0b02be92018-08-31 11:55:55 -0700481 body->sensor_units_1 |= 1 << 0;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700482};
483inline void unset_percentage(SensorDataFullRecordBody* body)
484{
Patrick Venture0b02be92018-08-31 11:55:55 -0700485 body->sensor_units_1 &= ~(1 << 0);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700486};
487inline void set_modifier_operation(uint8_t op, SensorDataFullRecordBody* body)
488{
Patrick Venture0b02be92018-08-31 11:55:55 -0700489 body->sensor_units_1 &= ~(3 << 1);
490 body->sensor_units_1 |= (op & 0x3) << 1;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700491};
492inline void set_rate_unit(uint8_t unit, SensorDataFullRecordBody* body)
493{
Patrick Venture0b02be92018-08-31 11:55:55 -0700494 body->sensor_units_1 &= ~(7 << 3);
495 body->sensor_units_1 |= (unit & 0x7) << 3;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700496};
497inline void set_analog_data_format(uint8_t format,
498 SensorDataFullRecordBody* body)
499{
Patrick Venture0b02be92018-08-31 11:55:55 -0700500 body->sensor_units_1 &= ~(3 << 6);
501 body->sensor_units_1 |= (format & 0x3) << 6;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700502};
503
Emily Shaffer7cad3fc2017-08-30 17:50:37 -0700504inline void set_m(uint16_t m, SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700505{
506 body->m_lsb = m & 0xff;
Patrick Venture0b02be92018-08-31 11:55:55 -0700507 body->m_msb_and_tolerance &= ~(3 << 6);
508 body->m_msb_and_tolerance |= ((m & (3 << 8)) >> 2);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700509};
510inline void set_tolerance(uint8_t tol, SensorDataFullRecordBody* body)
511{
512 body->m_msb_and_tolerance &= ~0x3f;
513 body->m_msb_and_tolerance |= tol & 0x3f;
514};
515
Emily Shaffer7cad3fc2017-08-30 17:50:37 -0700516inline void set_b(uint16_t b, SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700517{
518 body->b_lsb = b & 0xff;
Patrick Venture0b02be92018-08-31 11:55:55 -0700519 body->b_msb_and_accuracy_lsb &= ~(3 << 6);
520 body->b_msb_and_accuracy_lsb |= ((b & (3 << 8)) >> 2);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700521};
Emily Shaffer7cad3fc2017-08-30 17:50:37 -0700522inline void set_accuracy(uint16_t acc, SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700523{
Emily Shaffer7cad3fc2017-08-30 17:50:37 -0700524 // bottom 6 bits
Emily Shafferbbef71c2017-05-08 16:36:17 -0700525 body->b_msb_and_accuracy_lsb &= ~0x3f;
526 body->b_msb_and_accuracy_lsb |= acc & 0x3f;
Emily Shaffer7cad3fc2017-08-30 17:50:37 -0700527 // top 4 bits
Emily Shafferbbef71c2017-05-08 16:36:17 -0700528 body->accuracy_and_sensor_direction &= 0x0f;
Emily Shaffer7cad3fc2017-08-30 17:50:37 -0700529 body->accuracy_and_sensor_direction |= ((acc >> 6) & 0xf) << 4;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700530};
531inline void set_accuracy_exp(uint8_t exp, SensorDataFullRecordBody* body)
532{
Patrick Venture0b02be92018-08-31 11:55:55 -0700533 body->accuracy_and_sensor_direction &= ~(3 << 2);
534 body->accuracy_and_sensor_direction |= (exp & 3) << 2;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700535};
536inline void set_sensor_dir(uint8_t dir, SensorDataFullRecordBody* body)
537{
Patrick Venture0b02be92018-08-31 11:55:55 -0700538 body->accuracy_and_sensor_direction &= ~(3 << 0);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700539 body->accuracy_and_sensor_direction |= (dir & 3);
540};
541
542inline void set_b_exp(uint8_t exp, SensorDataFullRecordBody* body)
543{
544 body->r_b_exponents &= 0xf0;
545 body->r_b_exponents |= exp & 0x0f;
546};
547inline void set_r_exp(uint8_t exp, SensorDataFullRecordBody* body)
548{
549 body->r_b_exponents &= 0x0f;
Patrick Venture0b02be92018-08-31 11:55:55 -0700550 body->r_b_exponents |= (exp & 0x0f) << 4;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700551};
552
553inline void set_id_strlen(uint8_t len, SensorDataFullRecordBody* body)
554{
555 body->id_string_info &= ~(0x1f);
556 body->id_string_info |= len & 0x1f;
557};
Patrick Venture0b02be92018-08-31 11:55:55 -0700558inline uint8_t get_id_strlen(SensorDataFullRecordBody* body)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700559{
560 return body->id_string_info & 0x1f;
561};
562inline void set_id_type(uint8_t type, SensorDataFullRecordBody* body)
563{
Patrick Venture0b02be92018-08-31 11:55:55 -0700564 body->id_string_info &= ~(3 << 6);
565 body->id_string_info |= (type & 0x3) << 6;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700566};
567
Ratan Guptae0cc8552018-01-22 14:23:04 +0530568inline void set_device_id_strlen(uint8_t len, SensorDataFruRecordBody* body)
569{
570 body->deviceIDLen &= ~(LENGTH_MASK);
571 body->deviceIDLen |= len & LENGTH_MASK;
572};
573
574inline uint8_t get_device_id_strlen(SensorDataFruRecordBody* body)
575{
576 return body->deviceIDLen & LENGTH_MASK;
577};
578
Tom Josephdc212b22018-02-16 09:59:57 +0530579inline void set_readable_mask(uint8_t mask, SensorDataFullRecordBody* body)
580{
581 body->discrete_reading_setting_mask[1] = mask & 0x3F;
582}
583
Emily Shafferbbef71c2017-05-08 16:36:17 -0700584} // namespace body
585
586// More types contained in section 43.17 Sensor Unit Type Codes,
587// IPMI spec v2 rev 1.1
588enum SensorUnitTypeCodes
589{
590 SENSOR_UNIT_UNSPECIFIED = 0,
591 SENSOR_UNIT_DEGREES_C = 1,
592 SENSOR_UNIT_VOLTS = 4,
593 SENSOR_UNIT_AMPERES = 5,
Tom Josephdc212b22018-02-16 09:59:57 +0530594 SENSOR_UNIT_WATTS = 6,
Emily Shafferbbef71c2017-05-08 16:36:17 -0700595 SENSOR_UNIT_JOULES = 7,
Kirill Pakhomov812e44c2018-10-22 16:25:35 +0300596 SENSOR_UNIT_RPM = 18,
Emily Shafferbbef71c2017-05-08 16:36:17 -0700597 SENSOR_UNIT_METERS = 34,
598 SENSOR_UNIT_REVOLUTIONS = 41,
599};
600
601struct SensorDataFullRecord
602{
603 SensorDataRecordHeader header;
604 SensorDataRecordKey key;
605 SensorDataFullRecordBody body;
606} __attribute__((packed));
607
Ratan Guptae0cc8552018-01-22 14:23:04 +0530608/** @struct SensorDataFruRecord
609 *
610 * FRU Device Locator Record - SDR Type 11
611 */
612struct SensorDataFruRecord
613{
614 SensorDataRecordHeader header;
615 SensorDataFruRecordKey key;
616 SensorDataFruRecordBody body;
617} __attribute__((packed));
618
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800619/** @struct SensorDataEntityRecord
620 *
621 * Entity Association Record - SDR Type 8
622 */
623struct SensorDataEntityRecord
624{
625 SensorDataRecordHeader header;
626 SensorDataEntityRecordKey key;
627 SensorDataEntityRecordBody body;
628} __attribute__((packed));
629
Patrick Venture0b02be92018-08-31 11:55:55 -0700630} // namespace get_sdr
Tom Joseph816e92b2017-09-06 19:23:00 +0530631
632namespace ipmi
633{
634
635namespace sensor
636{
637
638/**
639 * @brief Map offset to the corresponding bit in the assertion byte.
640 *
Gunnar Mills8991dd62017-10-25 17:11:29 -0500641 * The discrete sensors support up to 14 states. 0-7 offsets are stored in one
Tom Joseph816e92b2017-09-06 19:23:00 +0530642 * byte and offsets 8-14 in the second byte.
643 *
644 * @param[in] offset - offset number.
645 * @param[in/out] resp - get sensor reading response.
646 */
Sui Chen4cc42552019-09-11 10:28:35 -0700647inline void setOffset(uint8_t offset, ipmi::sensor::GetSensorResponse* resp)
Tom Joseph816e92b2017-09-06 19:23:00 +0530648{
649 if (offset > 7)
650 {
Sui Chen4cc42552019-09-11 10:28:35 -0700651 resp->discreteReadingSensorStates |= 1 << (offset - 8);
Tom Joseph816e92b2017-09-06 19:23:00 +0530652 }
653 else
654 {
Sui Chen4cc42552019-09-11 10:28:35 -0700655 resp->thresholdLevelsStates |= 1 << offset;
Tom Joseph816e92b2017-09-06 19:23:00 +0530656 }
657}
658
Tom Josephe4014fc2017-09-06 23:57:36 +0530659/**
660 * @brief Set the reading field in the response.
661 *
662 * @param[in] offset - offset number.
663 * @param[in/out] resp - get sensor reading response.
664 */
Sui Chen4cc42552019-09-11 10:28:35 -0700665inline void setReading(uint8_t value, ipmi::sensor::GetSensorResponse* resp)
Tom Josephe4014fc2017-09-06 23:57:36 +0530666{
667 resp->reading = value;
668}
669
Tom Joseph295f17e2017-09-07 00:09:46 +0530670/**
671 * @brief Map the value to the assertion bytes. The assertion states are stored
672 * in 2 bytes.
673 *
674 * @param[in] value - value to mapped to the assertion byte.
675 * @param[in/out] resp - get sensor reading response.
676 */
677inline void setAssertionBytes(uint16_t value,
Sui Chen4cc42552019-09-11 10:28:35 -0700678 ipmi::sensor::GetSensorResponse* resp)
Tom Joseph295f17e2017-09-07 00:09:46 +0530679{
Sui Chen4cc42552019-09-11 10:28:35 -0700680 resp->thresholdLevelsStates = static_cast<uint8_t>(value & 0x00FF);
681 resp->discreteReadingSensorStates = static_cast<uint8_t>(value >> 8);
Tom Joseph295f17e2017-09-07 00:09:46 +0530682}
683
Tom Josephe05b2922017-09-07 00:43:16 +0530684/**
685 * @brief Set the scanning enabled bit in the response.
686 *
687 * @param[in/out] resp - get sensor reading response.
688 */
Sui Chen4cc42552019-09-11 10:28:35 -0700689inline void enableScanning(ipmi::sensor::GetSensorResponse* resp)
Tom Josephe05b2922017-09-07 00:43:16 +0530690{
Sui Chen4cc42552019-09-11 10:28:35 -0700691 resp->readingOrStateUnavailable = false;
692 resp->scanningEnabled = true;
693 resp->allEventMessagesEnabled = false;
Tom Josephe05b2922017-09-07 00:43:16 +0530694}
695
Tom Joseph816e92b2017-09-06 19:23:00 +0530696} // namespace sensor
697
698} // namespace ipmi