1 #include "bios_integer_attribute.hpp" 2 3 #include "common/utils.hpp" 4 5 namespace pldm 6 { 7 namespace responder 8 { 9 namespace bios 10 { 11 12 BIOSIntegerAttribute::BIOSIntegerAttribute(const Json& entry, 13 DBusHandler* const dbusHandler) : 14 BIOSAttribute(entry, dbusHandler) 15 { 16 std::string attr = entry.at("attribute_name"); 17 18 integerInfo.lowerBound = entry.at("lower_bound"); 19 integerInfo.upperBound = entry.at("upper_bound"); 20 integerInfo.scalarIncrement = entry.at("scalar_increment"); 21 integerInfo.defaultValue = entry.at("default_value"); 22 pldm_bios_table_attr_entry_integer_info info = { 23 0, 24 readOnly, 25 integerInfo.lowerBound, 26 integerInfo.upperBound, 27 integerInfo.scalarIncrement, 28 integerInfo.defaultValue, 29 }; 30 const char* errmsg = nullptr; 31 auto rc = pldm_bios_table_attr_entry_integer_info_check(&info, &errmsg); 32 if (rc != PLDM_SUCCESS) 33 { 34 std::cerr << "Wrong filed for integer attribute, ATTRIBUTE_NAME=" 35 << attr.c_str() << " ERRMSG=" << errmsg 36 << " LOWER_BOUND=" << integerInfo.lowerBound 37 << " UPPER_BOUND=" << integerInfo.upperBound 38 << " DEFAULT_VALUE=" << integerInfo.defaultValue 39 << " SCALAR_INCREMENT=" << integerInfo.scalarIncrement 40 << "\n"; 41 throw std::invalid_argument("Wrong field for integer attribute"); 42 } 43 } 44 45 void BIOSIntegerAttribute::setAttrValueOnDbus( 46 const pldm_bios_attr_val_table_entry* attrValueEntry, 47 const pldm_bios_attr_table_entry*, const BIOSStringTable&) 48 { 49 if (readOnly || !dBusMap.has_value()) 50 { 51 return; 52 } 53 auto currentValue = 54 table::attribute_value::decodeIntegerEntry(attrValueEntry); 55 56 if (dBusMap->propertyType == "uint8_t") 57 { 58 return dbusHandler->setDbusProperty(*dBusMap, 59 static_cast<uint8_t>(currentValue)); 60 } 61 else if (dBusMap->propertyType == "uint16_t") 62 { 63 return dbusHandler->setDbusProperty( 64 *dBusMap, static_cast<uint16_t>(currentValue)); 65 } 66 else if (dBusMap->propertyType == "int16_t") 67 { 68 return dbusHandler->setDbusProperty(*dBusMap, 69 static_cast<int16_t>(currentValue)); 70 } 71 else if (dBusMap->propertyType == "uint32_t") 72 { 73 return dbusHandler->setDbusProperty( 74 *dBusMap, static_cast<uint32_t>(currentValue)); 75 } 76 else if (dBusMap->propertyType == "int32_t") 77 { 78 return dbusHandler->setDbusProperty(*dBusMap, 79 static_cast<int32_t>(currentValue)); 80 } 81 else if (dBusMap->propertyType == "uint64_t") 82 { 83 return dbusHandler->setDbusProperty(*dBusMap, currentValue); 84 } 85 else if (dBusMap->propertyType == "int64_t") 86 { 87 return dbusHandler->setDbusProperty(*dBusMap, 88 static_cast<int64_t>(currentValue)); 89 } 90 else if (dBusMap->propertyType == "double") 91 { 92 return dbusHandler->setDbusProperty(*dBusMap, 93 static_cast<double>(currentValue)); 94 } 95 96 std::cerr << "Unsupported property type on dbus: " << dBusMap->propertyType 97 << std::endl; 98 throw std::invalid_argument("dbus type error"); 99 } 100 101 void BIOSIntegerAttribute::constructEntry(const BIOSStringTable& stringTable, 102 Table& attrTable, 103 Table& attrValueTable) 104 { 105 106 pldm_bios_table_attr_entry_integer_info info = { 107 stringTable.findHandle(name), readOnly, 108 integerInfo.lowerBound, integerInfo.upperBound, 109 integerInfo.scalarIncrement, integerInfo.defaultValue, 110 }; 111 112 auto attrTableEntry = 113 table::attribute::constructIntegerEntry(attrTable, &info); 114 115 auto [attrHandle, attrType, _] = 116 table::attribute::decodeHeader(attrTableEntry); 117 118 auto currentValue = getAttrValue(); 119 table::attribute_value::constructIntegerEntry(attrValueTable, attrHandle, 120 attrType, currentValue); 121 } 122 123 uint64_t BIOSIntegerAttribute::getAttrValue(const PropertyValue& propertyValue) 124 { 125 uint64_t value = 0; 126 if (dBusMap->propertyType == "uint8_t") 127 { 128 value = std::get<uint8_t>(propertyValue); 129 } 130 else if (dBusMap->propertyType == "uint16_t") 131 { 132 value = std::get<uint16_t>(propertyValue); 133 } 134 else if (dBusMap->propertyType == "int16_t") 135 { 136 value = std::get<int16_t>(propertyValue); 137 } 138 else if (dBusMap->propertyType == "uint32_t") 139 { 140 value = std::get<uint32_t>(propertyValue); 141 } 142 else if (dBusMap->propertyType == "int32_t") 143 { 144 value = std::get<int32_t>(propertyValue); 145 } 146 else if (dBusMap->propertyType == "uint64_t") 147 { 148 value = std::get<uint64_t>(propertyValue); 149 } 150 else if (dBusMap->propertyType == "int64_t") 151 { 152 value = std::get<int64_t>(propertyValue); 153 } 154 else if (dBusMap->propertyType == "double") 155 { 156 value = std::get<double>(propertyValue); 157 } 158 else 159 { 160 std::cerr << "Unsupported property type for getAttrValue: " 161 << dBusMap->propertyType << std::endl; 162 throw std::invalid_argument("dbus type error"); 163 } 164 return value; 165 } 166 167 uint64_t BIOSIntegerAttribute::getAttrValue() 168 { 169 if (readOnly || !dBusMap.has_value()) 170 { 171 return integerInfo.defaultValue; 172 } 173 174 try 175 { 176 auto propertyValue = dbusHandler->getDbusPropertyVariant( 177 dBusMap->objectPath.c_str(), dBusMap->propertyName.c_str(), 178 dBusMap->interface.c_str()); 179 180 return getAttrValue(propertyValue); 181 } 182 catch (const std::exception& e) 183 { 184 std::cerr << "Get Integer Attribute Value Error: AttributeName = " 185 << name << std::endl; 186 return integerInfo.defaultValue; 187 } 188 } 189 190 int BIOSIntegerAttribute::updateAttrVal(Table& newValue, uint16_t attrHdl, 191 uint8_t attrType, 192 const PropertyValue& newPropVal) 193 { 194 auto newVal = getAttrValue(newPropVal); 195 table::attribute_value::constructIntegerEntry(newValue, attrHdl, attrType, 196 newVal); 197 return PLDM_SUCCESS; 198 } 199 200 void BIOSIntegerAttribute::generateAttributeEntry( 201 const std::variant<int64_t, std::string>& attributevalue, 202 Table& attrValueEntry) 203 { 204 attrValueEntry.resize(sizeof(pldm_bios_attr_val_table_entry) + 205 sizeof(int64_t) - 1); 206 207 auto entry = reinterpret_cast<pldm_bios_attr_val_table_entry*>( 208 attrValueEntry.data()); 209 210 int64_t value = std::get<int64_t>(attributevalue); 211 entry->attr_type = 3; 212 memcpy(entry->value, &value, sizeof(int64_t)); 213 } 214 215 } // namespace bios 216 } // namespace responder 217 } // namespace pldm 218