1 #pragma once
2 
3 #include "common/types.hpp"
4 #include "common/utils.hpp"
5 #include "libpldmresponder/pdr_utils.hpp"
6 #include "pldmd/handler.hpp"
7 
8 namespace pldm
9 {
10 namespace responder
11 {
12 namespace oem_platform
13 {
14 class Handler : public CmdHandler
15 {
16   public:
17     Handler(const pldm::utils::DBusHandler* dBusIntf) : dBusIntf(dBusIntf) {}
18 
19     /** @brief Interface to get the state sensor readings requested by pldm
20      *  requester for OEM types. Each specific type should implement a handler
21      *  of it's own
22      *
23      *  @param[in] entityType - entity type corresponding to the sensor
24      *  @param[in] entityInstance - entity instance number
25      *  @param[in] stateSetId - state set id
26      *  @param[in] compSensorCnt - composite sensor count
27      *  @param[out] stateField - The state field data for each of the states,
28      *                           equal to composite sensor count in number
29      *
30      *  @return - Success or failure in getting the states. Returns failure in
31      *            terms of PLDM completion codes if fetching at least one state
32      *            fails
33      */
34     virtual int getOemStateSensorReadingsHandler(
35         pldm::pdr::EntityType entityType,
36         pldm::pdr::EntityInstance entityInstance,
37         pldm::pdr::StateSetId stateSetId,
38         pldm::pdr::CompositeCount compSensorCnt,
39         std::vector<get_sensor_state_field>& stateField) = 0;
40 
41     /** @brief Interface to set the effecter requested by pldm requester
42      *         for OEM types. Each individual oem type should implement
43      *         it's own handler.
44      *
45      *  @param[in] entityType - entity type corresponding to the effecter id
46      *  @param[in] entityInstance - entity instance
47      *  @param[in] stateSetId - state set id
48      *  @param[in] compEffecterCnt - composite effecter count
49      *  @param[in] stateField - The state field data for each of the states,
50      *                         equal to compEffecterCnt in number
51      *  @param[in] effecterId - Effecter id
52      *
53      *  @return - Success or failure in setting the states.Returns failure in
54      *            terms of PLDM completion codes if at least one state fails to
55      *            be set
56      */
57     virtual int oemSetStateEffecterStatesHandler(
58         uint16_t entityType, uint16_t entityInstance, uint16_t stateSetId,
59         uint8_t compEffecterCnt,
60         std::vector<set_effecter_state_field>& stateField,
61         uint16_t effecterId) = 0;
62 
63     /** @brief Interface to generate the OEM PDRs
64      *
65      * @param[in] repo - instance of concrete implementation of Repo
66      */
67     virtual void buildOEMPDR(pldm::responder::pdr_utils::Repo& repo) = 0;
68 
69     /** @brief Interface to check if setEventReceiver is sent to host already.
70      *         If sent then then disableWatchDogTimer() would be called to
71      *         disable the watchdog timer */
72     virtual void checkAndDisableWatchDog() = 0;
73 
74     /** @brief Interface to check if the watchdog timer is running
75      *
76      * @return - true if watchdog is running, false otherwise
77      * */
78     virtual bool watchDogRunning() = 0;
79 
80     /** @brief Interface to reset the watchdog timer */
81     virtual void resetWatchDogTimer() = 0;
82 
83     /** @brief Interface to disable the watchdog timer */
84     virtual void disableWatchDogTimer() = 0;
85 
86     /** @brief Interface to keep track of how many times setEventReceiver
87      *         is sent to host */
88     virtual void countSetEventReceiver() = 0;
89 
90     /** @brief Interface to check the BMC state */
91     virtual int checkBMCState() = 0;
92 
93     /** @brief update the dbus object paths */
94     virtual void updateOemDbusPaths(std::string& dbusPath) = 0;
95 
96     /** @brief Interface to fetch the last BMC record from the PDR repository
97      *
98      *  @param[in] repo - pointer to BMC's primary PDR repo
99      *
100      *  @return the last BMC record from the repo
101      */
102     virtual const pldm_pdr_record* fetchLastBMCRecord(const pldm_pdr* repo) = 0;
103 
104     /** @brief Interface to check if the record handle passed is in remote PDR
105      *         record handle range
106      *
107      *  @param[in] record_handle - record handle of the PDR
108      *
109      *  @return true if record handle passed is in host PDR record handle range
110      */
111     virtual bool checkRecordHandleInRange(const uint32_t& record_handle) = 0;
112 
113     /** @brief Interface to the process setEventReceiver*/
114     virtual void processSetEventReceiver() = 0;
115 
116     /** @brief Interface to monitor the surveillance pings from remote terminus
117      *
118      * @param[in] tid - TID of the remote terminus
119      * @param[in] value - true or false, to indicate if the timer is
120      *                   running or not
121      * */
122     virtual void setSurvTimer(uint8_t tid, bool value) = 0;
123 
124     virtual ~Handler() = default;
125 
126   protected:
127     const pldm::utils::DBusHandler* dBusIntf;
128 };
129 
130 } // namespace oem_platform
131 
132 namespace oem_fru
133 {
134 
135 class Handler : public CmdHandler
136 {
137   public:
138     Handler() {}
139 
140     /** @brief Process OEM FRU record
141      *
142      * @param[in] fruData - the data of the fru
143      *
144      * @return success or failure
145      */
146     virtual int processOEMFRUTable(const std::vector<uint8_t>& fruData) = 0;
147 
148     virtual ~Handler() = default;
149 };
150 
151 } // namespace oem_fru
152 
153 namespace oem_utils
154 {
155 using namespace pldm::utils;
156 
157 class Handler : public CmdHandler
158 {
159   public:
160     Handler(const pldm::utils::DBusHandler* dBusIntf) : dBusIntf(dBusIntf) {}
161 
162     /** @brief Collecting core count data and setting to Dbus properties
163      *
164      *  @param[in] associations - the data of entity association
165      *  @param[in] entityMaps - the mapping of entity to DBus string
166      *
167      */
168     virtual int setCoreCount(const EntityAssociations& associations,
169                              const EntityMaps entityMaps) = 0;
170 
171     virtual ~Handler() = default;
172 
173   protected:
174     const pldm::utils::DBusHandler* dBusIntf;
175 };
176 
177 } // namespace oem_utils
178 
179 } // namespace responder
180 
181 } // namespace pldm
182