blob: 4a23ace1f514ed3dfb4e21d641800092118942cd [file] [log] [blame]
John Wang95e6b3c2020-02-13 09:43:24 +08001#include "bios_integer_attribute.hpp"
2
Deepak Kodihallid130e1a2020-06-17 05:55:32 -05003#include "common/utils.hpp"
John Wang95e6b3c2020-02-13 09:43:24 +08004
5namespace pldm
6{
7namespace responder
8{
9namespace bios
10{
11
12BIOSIntegerAttribute::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
45void BIOSIntegerAttribute::setAttrValueOnDbus(
46 const pldm_bios_attr_val_table_entry* attrValueEntry,
47 const pldm_bios_attr_table_entry*, const BIOSStringTable&)
48{
George Liudaa69232020-09-02 17:22:09 +080049 if (readOnly || !dBusMap.has_value())
John Wang95e6b3c2020-02-13 09:43:24 +080050 {
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 }
George Liuaca897b2020-08-18 14:47:17 +080090 else if (dBusMap->propertyType == "double")
91 {
92 return dbusHandler->setDbusProperty(*dBusMap,
93 static_cast<double>(currentValue));
94 }
John Wang95e6b3c2020-02-13 09:43:24 +080095
96 std::cerr << "Unsupported property type on dbus: " << dBusMap->propertyType
97 << std::endl;
98 throw std::invalid_argument("dbus type error");
99}
100
101void 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
Sampa Misra46ece062020-03-18 07:17:44 -0500123uint64_t BIOSIntegerAttribute::getAttrValue(const PropertyValue& propertyValue)
John Wang95e6b3c2020-02-13 09:43:24 +0800124{
Andrew Geissler081d03b2020-12-14 18:53:33 -0600125 uint64_t value = 0;
John Wang95e6b3c2020-02-13 09:43:24 +0800126 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 }
George Liuaca897b2020-08-18 14:47:17 +0800154 else if (dBusMap->propertyType == "double")
155 {
156 value = std::get<double>(propertyValue);
157 }
Andrew Geissler081d03b2020-12-14 18:53:33 -0600158 else
159 {
160 std::cerr << "Unsupported property type for getAttrValue: "
161 << dBusMap->propertyType << std::endl;
162 throw std::invalid_argument("dbus type error");
163 }
John Wang95e6b3c2020-02-13 09:43:24 +0800164 return value;
165}
166
167uint64_t BIOSIntegerAttribute::getAttrValue()
168{
George Liudaa69232020-09-02 17:22:09 +0800169 if (readOnly || !dBusMap.has_value())
John Wang95e6b3c2020-02-13 09:43:24 +0800170 {
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
Sampa Misra46ece062020-03-18 07:17:44 -0500190int 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
George Liu1244acf2020-08-14 09:11:11 +0800200void 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
John Wang95e6b3c2020-02-13 09:43:24 +0800215} // namespace bios
216} // namespace responder
Sampa Misra46ece062020-03-18 07:17:44 -0500217} // namespace pldm