Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 1 | #include "bios.hpp" |
| 2 | |
George Liu | 8340957 | 2019-12-24 18:42:54 +0800 | [diff] [blame] | 3 | #include "utils.hpp" |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 4 | #include "xyz/openbmc_project/Common/error.hpp" |
| 5 | |
Xiaochao Ma | 60227a0 | 2019-12-04 09:00:12 +0800 | [diff] [blame] | 6 | #include <time.h> |
| 7 | |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 8 | #include <array> |
Sampa Misra | b37be31 | 2019-07-03 02:26:41 -0500 | [diff] [blame] | 9 | #include <boost/crc.hpp> |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 10 | #include <chrono> |
| 11 | #include <ctime> |
Deepak Kodihalli | d9fb152 | 2019-11-28 10:06:34 -0600 | [diff] [blame] | 12 | #include <filesystem> |
Sampa Misra | aa8ae72 | 2019-12-12 03:20:40 -0600 | [diff] [blame] | 13 | #include <iostream> |
John Wang | 0270040 | 2019-10-06 16:34:29 +0800 | [diff] [blame] | 14 | #include <memory> |
Sampa Misra | b37be31 | 2019-07-03 02:26:41 -0500 | [diff] [blame] | 15 | #include <numeric> |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 16 | #include <stdexcept> |
| 17 | #include <string> |
| 18 | #include <variant> |
| 19 | #include <vector> |
| 20 | |
| 21 | namespace pldm |
| 22 | { |
| 23 | |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 24 | namespace responder |
| 25 | { |
| 26 | |
| 27 | namespace utils |
| 28 | { |
| 29 | |
| 30 | void epochToBCDTime(uint64_t timeSec, uint8_t& seconds, uint8_t& minutes, |
| 31 | uint8_t& hours, uint8_t& day, uint8_t& month, |
| 32 | uint16_t& year) |
| 33 | { |
| 34 | auto t = time_t(timeSec); |
| 35 | auto time = localtime(&t); |
| 36 | |
George Liu | 8340957 | 2019-12-24 18:42:54 +0800 | [diff] [blame] | 37 | seconds = pldm::utils::decimalToBcd(time->tm_sec); |
| 38 | minutes = pldm::utils::decimalToBcd(time->tm_min); |
| 39 | hours = pldm::utils::decimalToBcd(time->tm_hour); |
| 40 | day = pldm::utils::decimalToBcd(time->tm_mday); |
| 41 | month = pldm::utils::decimalToBcd(time->tm_mon + |
| 42 | 1); // The number of months in the range |
| 43 | // 0 to 11.PLDM expects range 1 to 12 |
| 44 | year = pldm::utils::decimalToBcd(time->tm_year + |
| 45 | 1900); // The number of years since 1900 |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 46 | } |
| 47 | |
Xiaochao Ma | 60227a0 | 2019-12-04 09:00:12 +0800 | [diff] [blame] | 48 | std::time_t timeToEpoch(uint8_t seconds, uint8_t minutes, uint8_t hours, |
| 49 | uint8_t day, uint8_t month, uint16_t year) |
| 50 | { |
| 51 | struct std::tm stm; |
| 52 | |
| 53 | stm.tm_year = year - 1900; |
| 54 | stm.tm_mon = month - 1; |
| 55 | stm.tm_mday = day; |
| 56 | stm.tm_hour = hours; |
| 57 | stm.tm_min = minutes; |
| 58 | stm.tm_sec = seconds; |
| 59 | stm.tm_isdst = -1; |
| 60 | |
| 61 | // It will get the time in seconds since |
| 62 | // Epoch, 1970.1.1 00:00:00 +0000,UTC. |
| 63 | return timegm(&stm); |
| 64 | } |
| 65 | |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 66 | } // namespace utils |
| 67 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 68 | namespace bios |
| 69 | { |
| 70 | |
John Wang | 6080aae | 2020-02-14 09:34:25 +0800 | [diff] [blame] | 71 | using EpochTimeUS = uint64_t; |
| 72 | |
| 73 | DBusHandler dbusHandler; |
| 74 | |
| 75 | Handler::Handler() : biosConfig(BIOS_JSONS_DIR, BIOS_TABLES_DIR, &dbusHandler) |
Deepak Kodihalli | d9fb152 | 2019-11-28 10:06:34 -0600 | [diff] [blame] | 76 | { |
John Wang | 6080aae | 2020-02-14 09:34:25 +0800 | [diff] [blame] | 77 | biosConfig.removeTables(); |
| 78 | biosConfig.buildTables(); |
| 79 | |
Xiaochao Ma | 60227a0 | 2019-12-04 09:00:12 +0800 | [diff] [blame] | 80 | handlers.emplace(PLDM_SET_DATE_TIME, |
| 81 | [this](const pldm_msg* request, size_t payloadLength) { |
| 82 | return this->setDateTime(request, payloadLength); |
| 83 | }); |
Deepak Kodihalli | d9fb152 | 2019-11-28 10:06:34 -0600 | [diff] [blame] | 84 | handlers.emplace(PLDM_GET_DATE_TIME, |
| 85 | [this](const pldm_msg* request, size_t payloadLength) { |
| 86 | return this->getDateTime(request, payloadLength); |
| 87 | }); |
| 88 | handlers.emplace(PLDM_GET_BIOS_TABLE, |
| 89 | [this](const pldm_msg* request, size_t payloadLength) { |
| 90 | return this->getBIOSTable(request, payloadLength); |
| 91 | }); |
John Wang | 8721ed6 | 2019-12-05 14:44:43 +0800 | [diff] [blame] | 92 | handlers.emplace(PLDM_GET_BIOS_ATTRIBUTE_CURRENT_VALUE_BY_HANDLE, |
| 93 | [this](const pldm_msg* request, size_t payloadLength) { |
| 94 | return this->getBIOSAttributeCurrentValueByHandle( |
| 95 | request, payloadLength); |
| 96 | }); |
John Wang | 4217488 | 2019-12-20 14:56:59 +0800 | [diff] [blame] | 97 | handlers.emplace(PLDM_SET_BIOS_ATTRIBUTE_CURRENT_VALUE, |
| 98 | [this](const pldm_msg* request, size_t payloadLength) { |
| 99 | return this->setBIOSAttributeCurrentValue( |
| 100 | request, payloadLength); |
| 101 | }); |
Deepak Kodihalli | d9fb152 | 2019-11-28 10:06:34 -0600 | [diff] [blame] | 102 | } |
| 103 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 104 | Response Handler::getDateTime(const pldm_msg* request, size_t /*payloadLength*/) |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 105 | { |
| 106 | uint8_t seconds = 0; |
| 107 | uint8_t minutes = 0; |
| 108 | uint8_t hours = 0; |
| 109 | uint8_t day = 0; |
| 110 | uint8_t month = 0; |
| 111 | uint16_t year = 0; |
| 112 | |
| 113 | constexpr auto timeInterface = "xyz.openbmc_project.Time.EpochTime"; |
George Liu | 408c3c4 | 2019-10-16 16:49:15 +0800 | [diff] [blame] | 114 | constexpr auto hostTimePath = "/xyz/openbmc_project/time/host"; |
vkaverap | a6575b8 | 2019-04-03 05:33:52 -0500 | [diff] [blame] | 115 | Response response(sizeof(pldm_msg_hdr) + PLDM_GET_DATE_TIME_RESP_BYTES, 0); |
| 116 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
George Liu | 782d37f | 2020-01-24 09:02:17 +0800 | [diff] [blame] | 117 | EpochTimeUS timeUsec; |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 118 | |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 119 | try |
| 120 | { |
George Liu | 782d37f | 2020-01-24 09:02:17 +0800 | [diff] [blame] | 121 | timeUsec = pldm::utils::DBusHandler().getDbusProperty<EpochTimeUS>( |
| 122 | hostTimePath, "Elapsed", timeInterface); |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 123 | } |
George Liu | 0e02c32 | 2020-01-01 09:41:51 +0800 | [diff] [blame] | 124 | catch (const sdbusplus::exception::SdBusError& e) |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 125 | { |
Sampa Misra | aa8ae72 | 2019-12-12 03:20:40 -0600 | [diff] [blame] | 126 | std::cerr << "Error getting time, PATH=" << hostTimePath |
| 127 | << " TIME INTERACE=" << timeInterface << "\n"; |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 128 | |
George Liu | fb8611d | 2019-12-06 10:14:15 +0800 | [diff] [blame] | 129 | return CmdHandler::ccOnlyResponse(request, PLDM_ERROR); |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 130 | } |
| 131 | |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 132 | uint64_t timeSec = std::chrono::duration_cast<std::chrono::seconds>( |
| 133 | std::chrono::microseconds(timeUsec)) |
| 134 | .count(); |
| 135 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 136 | pldm::responder::utils::epochToBCDTime(timeSec, seconds, minutes, hours, |
| 137 | day, month, year); |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 138 | |
George Liu | fb8611d | 2019-12-06 10:14:15 +0800 | [diff] [blame] | 139 | auto rc = encode_get_date_time_resp(request->hdr.instance_id, PLDM_SUCCESS, |
| 140 | seconds, minutes, hours, day, month, |
| 141 | year, responsePtr); |
| 142 | if (rc != PLDM_SUCCESS) |
| 143 | { |
| 144 | return ccOnlyResponse(request, rc); |
| 145 | } |
| 146 | |
vkaverap | a6575b8 | 2019-04-03 05:33:52 -0500 | [diff] [blame] | 147 | return response; |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 148 | } |
| 149 | |
Xiaochao Ma | 60227a0 | 2019-12-04 09:00:12 +0800 | [diff] [blame] | 150 | Response Handler::setDateTime(const pldm_msg* request, size_t payloadLength) |
| 151 | { |
| 152 | uint8_t seconds = 0; |
| 153 | uint8_t minutes = 0; |
| 154 | uint8_t hours = 0; |
| 155 | uint8_t day = 0; |
| 156 | uint8_t month = 0; |
| 157 | uint16_t year = 0; |
| 158 | std::time_t timeSec; |
| 159 | |
| 160 | constexpr auto setTimeInterface = "xyz.openbmc_project.Time.EpochTime"; |
| 161 | constexpr auto setTimePath = "/xyz/openbmc_project/time/host"; |
| 162 | constexpr auto timeSetPro = "Elapsed"; |
| 163 | |
| 164 | auto rc = decode_set_date_time_req(request, payloadLength, &seconds, |
| 165 | &minutes, &hours, &day, &month, &year); |
| 166 | if (rc != PLDM_SUCCESS) |
| 167 | { |
| 168 | return ccOnlyResponse(request, rc); |
| 169 | } |
| 170 | timeSec = pldm::responder::utils::timeToEpoch(seconds, minutes, hours, day, |
| 171 | month, year); |
| 172 | uint64_t timeUsec = std::chrono::duration_cast<std::chrono::microseconds>( |
| 173 | std::chrono::seconds(timeSec)) |
| 174 | .count(); |
George Liu | 1e44c73 | 2020-02-28 20:20:06 +0800 | [diff] [blame] | 175 | PropertyValue value{timeUsec}; |
Xiaochao Ma | 60227a0 | 2019-12-04 09:00:12 +0800 | [diff] [blame] | 176 | try |
| 177 | { |
George Liu | 1e44c73 | 2020-02-28 20:20:06 +0800 | [diff] [blame] | 178 | DBusMapping dbusMapping{setTimePath, setTimeInterface, timeSetPro, |
| 179 | "uint64_t"}; |
| 180 | pldm::utils::DBusHandler().setDbusProperty(dbusMapping, value); |
Xiaochao Ma | 60227a0 | 2019-12-04 09:00:12 +0800 | [diff] [blame] | 181 | } |
| 182 | catch (std::exception& e) |
| 183 | { |
| 184 | |
| 185 | std::cerr << "Error Setting time,PATH=" << setTimePath |
| 186 | << "TIME INTERFACE=" << setTimeInterface |
| 187 | << "ERROR=" << e.what() << "\n"; |
| 188 | |
| 189 | return ccOnlyResponse(request, PLDM_ERROR); |
| 190 | } |
| 191 | |
| 192 | return ccOnlyResponse(request, PLDM_SUCCESS); |
| 193 | } |
| 194 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 195 | Response Handler::getBIOSTable(const pldm_msg* request, size_t payloadLength) |
Sampa Misra | b37be31 | 2019-07-03 02:26:41 -0500 | [diff] [blame] | 196 | { |
John Wang | 6080aae | 2020-02-14 09:34:25 +0800 | [diff] [blame] | 197 | uint32_t transferHandle{}; |
| 198 | uint8_t transferOpFlag{}; |
| 199 | uint8_t tableType{}; |
| 200 | |
| 201 | auto rc = decode_get_bios_table_req(request, payloadLength, &transferHandle, |
| 202 | &transferOpFlag, &tableType); |
| 203 | if (rc != PLDM_SUCCESS) |
| 204 | { |
| 205 | return ccOnlyResponse(request, rc); |
| 206 | } |
| 207 | |
| 208 | auto table = |
| 209 | biosConfig.getBIOSTable(static_cast<pldm_bios_table_types>(tableType)); |
| 210 | if (!table) |
| 211 | { |
| 212 | return ccOnlyResponse(request, PLDM_BIOS_TABLE_UNAVAILABLE); |
| 213 | } |
| 214 | |
| 215 | Response response(sizeof(pldm_msg_hdr) + |
| 216 | PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES + table->size()); |
| 217 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
| 218 | |
| 219 | rc = encode_get_bios_table_resp( |
| 220 | request->hdr.instance_id, PLDM_SUCCESS, 0 /* nxtTransferHandle */, |
| 221 | PLDM_START_AND_END, table->data(), response.size(), responsePtr); |
| 222 | if (rc != PLDM_SUCCESS) |
| 223 | { |
| 224 | return ccOnlyResponse(request, rc); |
| 225 | } |
Sampa Misra | b37be31 | 2019-07-03 02:26:41 -0500 | [diff] [blame] | 226 | |
| 227 | return response; |
| 228 | } |
| 229 | |
John Wang | 8721ed6 | 2019-12-05 14:44:43 +0800 | [diff] [blame] | 230 | Response Handler::getBIOSAttributeCurrentValueByHandle(const pldm_msg* request, |
| 231 | size_t payloadLength) |
| 232 | { |
| 233 | uint32_t transferHandle; |
| 234 | uint8_t transferOpFlag; |
| 235 | uint16_t attributeHandle; |
| 236 | |
| 237 | auto rc = decode_get_bios_attribute_current_value_by_handle_req( |
| 238 | request, payloadLength, &transferHandle, &transferOpFlag, |
| 239 | &attributeHandle); |
| 240 | if (rc != PLDM_SUCCESS) |
| 241 | { |
| 242 | return ccOnlyResponse(request, rc); |
| 243 | } |
| 244 | |
John Wang | 6080aae | 2020-02-14 09:34:25 +0800 | [diff] [blame] | 245 | auto table = biosConfig.getBIOSTable(PLDM_BIOS_ATTR_VAL_TABLE); |
| 246 | if (!table) |
Deepak Kodihalli | 4976a68 | 2020-01-07 05:48:29 -0600 | [diff] [blame] | 247 | { |
| 248 | return ccOnlyResponse(request, PLDM_BIOS_TABLE_UNAVAILABLE); |
| 249 | } |
| 250 | |
John Wang | 8721ed6 | 2019-12-05 14:44:43 +0800 | [diff] [blame] | 251 | auto entry = pldm_bios_table_attr_value_find_by_handle( |
John Wang | 6080aae | 2020-02-14 09:34:25 +0800 | [diff] [blame] | 252 | table->data(), table->size(), attributeHandle); |
John Wang | 8721ed6 | 2019-12-05 14:44:43 +0800 | [diff] [blame] | 253 | if (entry == nullptr) |
| 254 | { |
| 255 | return ccOnlyResponse(request, PLDM_INVALID_BIOS_ATTR_HANDLE); |
| 256 | } |
| 257 | |
John Wang | 8e877e0 | 2020-02-03 16:06:55 +0800 | [diff] [blame] | 258 | auto entryLength = pldm_bios_table_attr_value_entry_length(entry); |
John Wang | 8721ed6 | 2019-12-05 14:44:43 +0800 | [diff] [blame] | 259 | Response response(sizeof(pldm_msg_hdr) + |
| 260 | PLDM_GET_BIOS_ATTR_CURR_VAL_BY_HANDLE_MIN_RESP_BYTES + |
John Wang | 8e877e0 | 2020-02-03 16:06:55 +0800 | [diff] [blame] | 261 | entryLength, |
John Wang | 8721ed6 | 2019-12-05 14:44:43 +0800 | [diff] [blame] | 262 | 0); |
| 263 | auto responsePtr = reinterpret_cast<pldm_msg*>(response.data()); |
George Liu | fb8611d | 2019-12-06 10:14:15 +0800 | [diff] [blame] | 264 | rc = encode_get_bios_current_value_by_handle_resp( |
John Wang | 8e877e0 | 2020-02-03 16:06:55 +0800 | [diff] [blame] | 265 | request->hdr.instance_id, PLDM_SUCCESS, 0, PLDM_START_AND_END, |
| 266 | reinterpret_cast<const uint8_t*>(entry), entryLength, responsePtr); |
George Liu | fb8611d | 2019-12-06 10:14:15 +0800 | [diff] [blame] | 267 | if (rc != PLDM_SUCCESS) |
| 268 | { |
| 269 | return ccOnlyResponse(request, rc); |
| 270 | } |
John Wang | 8721ed6 | 2019-12-05 14:44:43 +0800 | [diff] [blame] | 271 | |
| 272 | return response; |
| 273 | } |
| 274 | |
John Wang | 4217488 | 2019-12-20 14:56:59 +0800 | [diff] [blame] | 275 | Response Handler::setBIOSAttributeCurrentValue(const pldm_msg* request, |
| 276 | size_t payloadLength) |
| 277 | { |
| 278 | uint32_t transferHandle; |
| 279 | uint8_t transferOpFlag; |
| 280 | variable_field attributeField; |
| 281 | |
| 282 | auto rc = decode_set_bios_attribute_current_value_req( |
| 283 | request, payloadLength, &transferHandle, &transferOpFlag, |
| 284 | &attributeField); |
| 285 | if (rc != PLDM_SUCCESS) |
| 286 | { |
| 287 | return ccOnlyResponse(request, rc); |
| 288 | } |
| 289 | |
John Wang | 6080aae | 2020-02-14 09:34:25 +0800 | [diff] [blame] | 290 | rc = biosConfig.setAttrValue(attributeField.ptr, attributeField.length); |
John Wang | 4217488 | 2019-12-20 14:56:59 +0800 | [diff] [blame] | 291 | |
John Wang | 6080aae | 2020-02-14 09:34:25 +0800 | [diff] [blame] | 292 | return ccOnlyResponse(request, rc); |
John Wang | 4217488 | 2019-12-20 14:56:59 +0800 | [diff] [blame] | 293 | } |
| 294 | |
John Wang | f719f3b | 2020-01-17 08:46:22 +0800 | [diff] [blame] | 295 | } // namespace bios |
Sampa Misra | 032bd50 | 2019-03-06 05:03:22 -0600 | [diff] [blame] | 296 | } // namespace responder |
| 297 | } // namespace pldm |