1 #pragma once
2 
3 #include "common/types.hpp"
4 #include "common/utils.hpp"
5 
6 #include <libpldm/pdr.h>
7 #include <stdint.h>
8 
9 #include <nlohmann/json.hpp>
10 #include <phosphor-logging/lg2.hpp>
11 #include <xyz/openbmc_project/Common/error.hpp>
12 
13 #include <filesystem>
14 #include <fstream>
15 #include <functional>
16 #include <iostream>
17 #include <string>
18 
19 PHOSPHOR_LOG2_USING;
20 
21 using InternalFailure =
22     sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
23 
24 namespace fs = std::filesystem;
25 
26 namespace pldm
27 {
28 namespace responder
29 {
30 namespace pdr_utils
31 {
32 /** @struct Type ID associated with pdr
33  *
34  */
35 enum class TypeId
36 {
37     PLDM_EFFECTER_ID,
38     PLDM_SENSOR_ID
39 };
40 
41 struct FruTLV
42 {
43     uint8_t fruFieldType;
44     uint8_t fruFieldLen;
45     std::vector<uint8_t> fruFieldValue;
46 };
47 
48 struct FruRecordDataFormat
49 {
50     uint16_t fruRSI;
51     uint8_t fruRecType;
52     uint8_t fruNum;
53     uint8_t fruEncodeType;
54     std::vector<FruTLV> fruTLV;
55 };
56 
57 /** @struct PdrEntry
58  *  PDR entry structure that acts as a PDR record structure in the PDR
59  *  repository to handle PDR APIs.
60  */
61 struct PdrEntry
62 {
63     uint8_t* data;
64     uint32_t size;
65     union
66     {
67         uint32_t recordHandle;
68         uint32_t nextRecordHandle;
69     } handle;
70 };
71 using Type = uint8_t;
72 using Json = nlohmann::json;
73 using RecordHandle = uint32_t;
74 using State = uint8_t;
75 using PossibleValues = std::vector<uint8_t>;
76 
77 /** @brief Map of DBus property State to attribute value
78  */
79 using StatestoDbusVal = std::map<State, pldm::utils::PropertyValue>;
80 using DbusMappings = std::vector<pldm::utils::DBusMapping>;
81 using DbusValMaps = std::vector<StatestoDbusVal>;
82 
83 /** @brief Parse PDR JSON file and output Json object
84  *
85  *  @param[in] path - path of PDR JSON file
86  *
87  *  @return Json - Json object
88  */
89 inline Json readJson(const std::string& path)
90 {
91     fs::path dir(path);
92     if (!fs::exists(dir) || fs::is_empty(dir))
93     {
94         throw InternalFailure();
95     }
96 
97     std::ifstream jsonFile(path);
98     if (!jsonFile.is_open())
99     {
100         error("Error opening PDR JSON file, PATH={JSON_PATH}", "JSON_PATH",
101               path);
102         return {};
103     }
104 
105     return Json::parse(jsonFile);
106 }
107 
108 /** @brief Populate the mapping between D-Bus property stateId and attribute
109  *          value for the effecter PDR enumeration attribute.
110  *
111  *  @param[in] type - type of the D-Bus property
112  *  @param[in] dBusValues - json array of D-Bus property values
113  *  @param[in] pv - Possible values for the effecter PDR enumeration attribute
114  *
115  *  @return StatestoDbusVal - Map of D-Bus property stateId to attribute value
116  */
117 StatestoDbusVal populateMapping(const std::string& type, const Json& dBusValues,
118                                 const PossibleValues& pv);
119 
120 /**
121  *  @class RepoInterface
122  *
123  *  @brief Abstract class describing the interface API to the PDR repository,
124  *         this class wraps operations used to handle the new PDR APIs.
125  */
126 class RepoInterface
127 {
128   public:
129     RepoInterface(pldm_pdr* repo) : repo(repo) {}
130 
131     virtual ~RepoInterface() = default;
132 
133     /** @brief Get an opaque pldm_pdr structure
134      *
135      *  @return pldm_pdr - pldm_pdr structure
136      */
137     virtual pldm_pdr* getPdr() const = 0;
138 
139     /** @brief Add a PDR record to a PDR repository
140      *
141      *  @param[in] pdrEntry - PDR records entry(data, size, recordHandle)
142      *
143      *  @return uint32_t - record handle assigned to PDR record
144      */
145     virtual RecordHandle addRecord(const PdrEntry& pdrEntry) = 0;
146 
147     /** @brief Get the first PDR record from a PDR repository
148      *
149      *  @param[in] pdrEntry - PDR records entry(data, size, nextRecordHandle)
150      *
151      *  @return opaque pointer acting as PDR record handle, will be NULL if
152      *          record was not found
153      */
154     virtual const pldm_pdr_record* getFirstRecord(PdrEntry& pdrEntry) = 0;
155 
156     /** @brief Get the next PDR record from a PDR repository
157      *
158      *  @param[in] currRecord - opaque pointer acting as a PDR record handle
159      *  @param[in] pdrEntry - PDR records entry(data, size, nextRecordHandle)
160      *
161      *  @return opaque pointer acting as PDR record handle, will be NULL if
162      *          record was not found
163      */
164     virtual const pldm_pdr_record*
165         getNextRecord(const pldm_pdr_record* currRecord,
166                       PdrEntry& pdrEntry) = 0;
167 
168     /** @brief Get record handle of a PDR record
169      *
170      *  @param[in] record - opaque pointer acting as a PDR record handle
171      *
172      *  @return uint32_t - record handle assigned to PDR record; 0 if record is
173      *                     not found
174      */
175     virtual uint32_t getRecordHandle(const pldm_pdr_record* record) const = 0;
176 
177     /** @brief Get number of records in a PDR repository
178      *
179      *  @return uint32_t - number of records
180      */
181     virtual uint32_t getRecordCount() = 0;
182 
183     /** @brief Determine if records are empty in a PDR repository
184      *
185      *  @return bool - true means empty and false means not empty
186      */
187     virtual bool empty() = 0;
188 
189   protected:
190     pldm_pdr* repo;
191 };
192 
193 /**
194  *  @class Repo
195  *
196  *  Wrapper class to handle the PDR APIs
197  *
198  *  This class wraps operations used to handle PDR APIs.
199  */
200 class Repo : public RepoInterface
201 {
202   public:
203     Repo(pldm_pdr* repo) : RepoInterface(repo) {}
204 
205     pldm_pdr* getPdr() const override;
206 
207     RecordHandle addRecord(const PdrEntry& pdrEntry) override;
208 
209     const pldm_pdr_record* getFirstRecord(PdrEntry& pdrEntry) override;
210 
211     const pldm_pdr_record* getNextRecord(const pldm_pdr_record* currRecord,
212                                          PdrEntry& pdrEntry) override;
213 
214     uint32_t getRecordHandle(const pldm_pdr_record* record) const override;
215 
216     uint32_t getRecordCount() override;
217 
218     bool empty() override;
219 };
220 
221 /** @brief Parse the State Sensor PDR and return the parsed sensor info which
222  *         will be used to lookup the sensor info in the PlatformEventMessage
223  *         command of sensorEvent type.
224  *
225  *  @param[in] stateSensorPdr - state sensor PDR
226  *
227  *  @return terminus handle, sensor ID and parsed sensor info
228  */
229 std::tuple<pldm::pdr::TerminusHandle, pldm::pdr::SensorID,
230            pldm::pdr::SensorInfo>
231     parseStateSensorPDR(const std::vector<uint8_t>& stateSensorPdr);
232 
233 /** @brief Parse FRU record table and return the vector of the FRU record data
234  *         format structure
235  *
236  *  @param[in] fruData - fru data
237  *  @param[in] fruLen  - fru len
238  *
239  *  @return std::vector<FruRecordDataFormat> - the vector of the FRU record data
240  *          format structure
241  */
242 std::vector<FruRecordDataFormat> parseFruRecordTable(const uint8_t* fruData,
243                                                      size_t fruLen);
244 
245 /** @brief Return the size of data type based on the effecterDataSize enum value
246  *
247  *  @param[in] effecterDataSize - Bitwidth and format of setting effecter value
248  *  @return[out] Map the effecterDataSize enum value to datatype and return the
249  *               size of dataType
250  */
251 size_t getEffecterDataSize(uint8_t effecterDataSize);
252 
253 } // namespace pdr_utils
254 } // namespace responder
255 } // namespace pldm
256