1 /* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later */
2 #include <libpldm/base.h>
3 #include <libpldm/bios.h>
4 #include <libpldm/utils.h>
5
6 #include <endian.h>
7 #include <string.h>
8
9 LIBPLDM_ABI_STABLE
encode_get_date_time_req(uint8_t instance_id,struct pldm_msg * msg)10 int encode_get_date_time_req(uint8_t instance_id, struct pldm_msg *msg)
11 {
12 if (msg == NULL) {
13 return PLDM_ERROR_INVALID_DATA;
14 }
15
16 struct pldm_header_info header = { 0 };
17 header.msg_type = PLDM_REQUEST;
18 header.instance = instance_id;
19 header.pldm_type = PLDM_BIOS;
20 header.command = PLDM_GET_DATE_TIME;
21 return pack_pldm_header(&header, &(msg->hdr));
22 }
23
24 LIBPLDM_ABI_STABLE
encode_get_date_time_resp(uint8_t instance_id,uint8_t completion_code,uint8_t seconds,uint8_t minutes,uint8_t hours,uint8_t day,uint8_t month,uint16_t year,struct pldm_msg * msg)25 int encode_get_date_time_resp(uint8_t instance_id, uint8_t completion_code,
26 uint8_t seconds, uint8_t minutes, uint8_t hours,
27 uint8_t day, uint8_t month, uint16_t year,
28 struct pldm_msg *msg)
29 {
30 if (msg == NULL) {
31 return PLDM_ERROR_INVALID_DATA;
32 }
33
34 struct pldm_header_info header = { 0 };
35 header.msg_type = PLDM_RESPONSE;
36 header.instance = instance_id;
37 header.pldm_type = PLDM_BIOS;
38 header.command = PLDM_GET_DATE_TIME;
39
40 uint8_t rc = pack_pldm_header(&header, &(msg->hdr));
41 if (rc != PLDM_SUCCESS) {
42 return rc;
43 }
44
45 struct pldm_get_date_time_resp *response =
46 (struct pldm_get_date_time_resp *)msg->payload;
47 response->completion_code = completion_code;
48 if (response->completion_code == PLDM_SUCCESS) {
49 response->completion_code = completion_code;
50 response->seconds = seconds;
51 response->minutes = minutes;
52 response->hours = hours;
53 response->day = day;
54 response->month = month;
55 response->year = htole16(year);
56 }
57 return PLDM_SUCCESS;
58 }
59
60 LIBPLDM_ABI_STABLE
decode_get_date_time_resp(const struct pldm_msg * msg,size_t payload_length,uint8_t * completion_code,uint8_t * seconds,uint8_t * minutes,uint8_t * hours,uint8_t * day,uint8_t * month,uint16_t * year)61 int decode_get_date_time_resp(const struct pldm_msg *msg, size_t payload_length,
62 uint8_t *completion_code, uint8_t *seconds,
63 uint8_t *minutes, uint8_t *hours, uint8_t *day,
64 uint8_t *month, uint16_t *year)
65 {
66 if (msg == NULL || seconds == NULL || minutes == NULL ||
67 hours == NULL || day == NULL || month == NULL || year == NULL ||
68 completion_code == NULL) {
69 return PLDM_ERROR_INVALID_DATA;
70 }
71
72 *completion_code = msg->payload[0];
73 if (PLDM_SUCCESS != *completion_code) {
74 return PLDM_SUCCESS;
75 }
76
77 if (payload_length != PLDM_GET_DATE_TIME_RESP_BYTES) {
78 return PLDM_ERROR_INVALID_LENGTH;
79 }
80
81 struct pldm_get_date_time_resp *response =
82 (struct pldm_get_date_time_resp *)msg->payload;
83
84 *seconds = response->seconds;
85 *minutes = response->minutes;
86 *hours = response->hours;
87 *day = response->day;
88 *month = response->month;
89 *year = le16toh(response->year);
90
91 return PLDM_SUCCESS;
92 }
93
94 LIBPLDM_ABI_STABLE
encode_set_date_time_req(uint8_t instance_id,uint8_t seconds,uint8_t minutes,uint8_t hours,uint8_t day,uint8_t month,uint16_t year,struct pldm_msg * msg,size_t payload_length)95 int encode_set_date_time_req(uint8_t instance_id, uint8_t seconds,
96 uint8_t minutes, uint8_t hours, uint8_t day,
97 uint8_t month, uint16_t year, struct pldm_msg *msg,
98 size_t payload_length)
99 {
100 if (msg == NULL) {
101 return PLDM_ERROR_INVALID_DATA;
102 }
103 if (payload_length != sizeof(struct pldm_set_date_time_req)) {
104 return PLDM_ERROR_INVALID_LENGTH;
105 }
106
107 if (!is_time_legal(seconds, minutes, hours, day, month, year)) {
108 return PLDM_ERROR_INVALID_DATA;
109 }
110
111 struct pldm_header_info header = { 0 };
112 header.instance = instance_id;
113 header.msg_type = PLDM_REQUEST;
114 header.pldm_type = PLDM_BIOS;
115 header.command = PLDM_SET_DATE_TIME;
116
117 uint8_t rc = pack_pldm_header(&header, &msg->hdr);
118 if (rc != PLDM_SUCCESS) {
119 return rc;
120 }
121
122 struct pldm_set_date_time_req *request =
123 (struct pldm_set_date_time_req *)msg->payload;
124 request->seconds = dec2bcd8(seconds);
125 request->minutes = dec2bcd8(minutes);
126 request->hours = dec2bcd8(hours);
127 request->day = dec2bcd8(day);
128 request->month = dec2bcd8(month);
129 request->year = htole16(dec2bcd16(year));
130
131 return PLDM_SUCCESS;
132 }
133
134 LIBPLDM_ABI_STABLE
decode_set_date_time_req(const struct pldm_msg * msg,size_t payload_length,uint8_t * seconds,uint8_t * minutes,uint8_t * hours,uint8_t * day,uint8_t * month,uint16_t * year)135 int decode_set_date_time_req(const struct pldm_msg *msg, size_t payload_length,
136 uint8_t *seconds, uint8_t *minutes, uint8_t *hours,
137 uint8_t *day, uint8_t *month, uint16_t *year)
138 {
139 if (msg == NULL || seconds == NULL || minutes == NULL ||
140 hours == NULL || day == NULL || month == NULL || year == NULL) {
141 return PLDM_ERROR_INVALID_DATA;
142 }
143 if (payload_length != sizeof(struct pldm_set_date_time_req)) {
144 return PLDM_ERROR_INVALID_LENGTH;
145 }
146
147 const struct pldm_set_date_time_req *request =
148 (struct pldm_set_date_time_req *)msg->payload;
149
150 *seconds = bcd2dec8(request->seconds);
151 *minutes = bcd2dec8(request->minutes);
152 *hours = bcd2dec8(request->hours);
153 *day = bcd2dec8(request->day);
154 *month = bcd2dec8(request->month);
155 *year = bcd2dec16(le16toh(request->year));
156
157 if (!is_time_legal(*seconds, *minutes, *hours, *day, *month, *year)) {
158 return PLDM_ERROR_INVALID_DATA;
159 }
160
161 return PLDM_SUCCESS;
162 }
163
164 LIBPLDM_ABI_STABLE
encode_set_date_time_resp(uint8_t instance_id,uint8_t completion_code,struct pldm_msg * msg,size_t payload_length)165 int encode_set_date_time_resp(uint8_t instance_id, uint8_t completion_code,
166 struct pldm_msg *msg, size_t payload_length)
167 {
168 if (msg == NULL) {
169 return PLDM_ERROR_INVALID_DATA;
170 }
171 if (payload_length != sizeof(struct pldm_only_cc_resp)) {
172 return PLDM_ERROR_INVALID_LENGTH;
173 }
174
175 struct pldm_header_info header = { 0 };
176 header.instance = instance_id;
177 header.msg_type = PLDM_RESPONSE;
178 header.pldm_type = PLDM_BIOS;
179 header.command = PLDM_SET_DATE_TIME;
180
181 uint8_t rc = pack_pldm_header(&header, &msg->hdr);
182 if (rc != PLDM_SUCCESS) {
183 return rc;
184 }
185
186 struct pldm_only_cc_resp *response =
187 (struct pldm_only_cc_resp *)msg->payload;
188 response->completion_code = completion_code;
189
190 return PLDM_SUCCESS;
191 }
192
193 LIBPLDM_ABI_STABLE
decode_set_date_time_resp(const struct pldm_msg * msg,size_t payload_length,uint8_t * completion_code)194 int decode_set_date_time_resp(const struct pldm_msg *msg, size_t payload_length,
195 uint8_t *completion_code)
196 {
197 if (msg == NULL || completion_code == NULL) {
198 return PLDM_ERROR_INVALID_DATA;
199 }
200
201 *completion_code = msg->payload[0];
202 if (PLDM_SUCCESS != *completion_code) {
203 return PLDM_SUCCESS;
204 }
205
206 if (payload_length != sizeof(struct pldm_only_cc_resp)) {
207 return PLDM_ERROR_INVALID_LENGTH;
208 }
209
210 return PLDM_SUCCESS;
211 }
212
213 LIBPLDM_ABI_STABLE
encode_get_bios_table_resp(uint8_t instance_id,uint8_t completion_code,uint32_t next_transfer_handle,uint8_t transfer_flag,uint8_t * table_data,size_t payload_length,struct pldm_msg * msg)214 int encode_get_bios_table_resp(uint8_t instance_id, uint8_t completion_code,
215 uint32_t next_transfer_handle,
216 uint8_t transfer_flag, uint8_t *table_data,
217 size_t payload_length, struct pldm_msg *msg)
218 {
219 if (msg == NULL) {
220 return PLDM_ERROR_INVALID_DATA;
221 }
222
223 struct pldm_header_info header = { 0 };
224 header.msg_type = PLDM_RESPONSE;
225 header.instance = instance_id;
226 header.pldm_type = PLDM_BIOS;
227 header.command = PLDM_GET_BIOS_TABLE;
228
229 uint8_t rc = pack_pldm_header(&header, &(msg->hdr));
230 if (rc != PLDM_SUCCESS) {
231 return rc;
232 }
233
234 struct pldm_get_bios_table_resp *response =
235 (struct pldm_get_bios_table_resp *)msg->payload;
236 response->completion_code = completion_code;
237 if (response->completion_code == PLDM_SUCCESS) {
238 response->next_transfer_handle = htole32(next_transfer_handle);
239 response->transfer_flag = transfer_flag;
240 if (table_data != NULL &&
241 payload_length > (sizeof(struct pldm_msg_hdr) +
242 PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES)) {
243 memcpy(response->table_data, table_data,
244 payload_length -
245 (sizeof(struct pldm_msg_hdr) +
246 PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES));
247 }
248 }
249 return PLDM_SUCCESS;
250 }
251
252 LIBPLDM_ABI_STABLE
encode_get_bios_table_req(uint8_t instance_id,uint32_t transfer_handle,uint8_t transfer_op_flag,uint8_t table_type,struct pldm_msg * msg)253 int encode_get_bios_table_req(uint8_t instance_id, uint32_t transfer_handle,
254 uint8_t transfer_op_flag, uint8_t table_type,
255 struct pldm_msg *msg)
256 {
257 if (msg == NULL) {
258 return PLDM_ERROR_INVALID_DATA;
259 }
260
261 struct pldm_header_info header = { 0 };
262 header.msg_type = PLDM_REQUEST;
263 header.instance = instance_id;
264 header.pldm_type = PLDM_BIOS;
265 header.command = PLDM_GET_BIOS_TABLE;
266
267 uint8_t rc = pack_pldm_header(&header, &(msg->hdr));
268 if (rc != PLDM_SUCCESS) {
269 return rc;
270 }
271
272 struct pldm_get_bios_table_req *request =
273 (struct pldm_get_bios_table_req *)msg->payload;
274
275 request->transfer_handle = htole32(transfer_handle);
276 request->transfer_op_flag = transfer_op_flag;
277 request->table_type = table_type;
278 return PLDM_SUCCESS;
279 }
280
281 LIBPLDM_ABI_STABLE
decode_get_bios_table_req(const struct pldm_msg * msg,size_t payload_length,uint32_t * transfer_handle,uint8_t * transfer_op_flag,uint8_t * table_type)282 int decode_get_bios_table_req(const struct pldm_msg *msg, size_t payload_length,
283 uint32_t *transfer_handle,
284 uint8_t *transfer_op_flag, uint8_t *table_type)
285 {
286 if (msg == NULL || transfer_op_flag == NULL || table_type == NULL ||
287 transfer_handle == NULL) {
288 return PLDM_ERROR_INVALID_DATA;
289 }
290
291 if (payload_length != PLDM_GET_BIOS_TABLE_REQ_BYTES) {
292 return PLDM_ERROR_INVALID_LENGTH;
293 }
294
295 struct pldm_get_bios_table_req *request =
296 (struct pldm_get_bios_table_req *)msg->payload;
297 *transfer_handle = le32toh(request->transfer_handle);
298 *transfer_op_flag = request->transfer_op_flag;
299 *table_type = request->table_type;
300
301 return PLDM_SUCCESS;
302 }
303
304 LIBPLDM_ABI_STABLE
decode_get_bios_table_resp(const struct pldm_msg * msg,size_t payload_length,uint8_t * completion_code,uint32_t * next_transfer_handle,uint8_t * transfer_flag,size_t * bios_table_offset)305 int decode_get_bios_table_resp(const struct pldm_msg *msg,
306 size_t payload_length, uint8_t *completion_code,
307 uint32_t *next_transfer_handle,
308 uint8_t *transfer_flag,
309 size_t *bios_table_offset)
310
311 {
312 if (msg == NULL || transfer_flag == NULL ||
313 next_transfer_handle == NULL || completion_code == NULL) {
314 return PLDM_ERROR_INVALID_DATA;
315 }
316 if (payload_length <= PLDM_GET_BIOS_TABLE_MIN_RESP_BYTES) {
317 return PLDM_ERROR_INVALID_LENGTH;
318 }
319
320 struct pldm_get_bios_table_resp *response =
321 (struct pldm_get_bios_table_resp *)msg->payload;
322
323 *completion_code = response->completion_code;
324
325 if (PLDM_SUCCESS != *completion_code) {
326 return PLDM_SUCCESS;
327 }
328
329 *next_transfer_handle = le32toh(response->next_transfer_handle);
330 *transfer_flag = response->transfer_flag;
331
332 *bios_table_offset = sizeof(*completion_code) +
333 sizeof(*next_transfer_handle) +
334 sizeof(*transfer_flag);
335
336 return PLDM_SUCCESS;
337 }
338
339 LIBPLDM_ABI_STABLE
encode_get_bios_attribute_current_value_by_handle_req(uint8_t instance_id,uint32_t transfer_handle,uint8_t transfer_op_flag,uint16_t attribute_handle,struct pldm_msg * msg)340 int encode_get_bios_attribute_current_value_by_handle_req(
341 uint8_t instance_id, uint32_t transfer_handle, uint8_t transfer_op_flag,
342 uint16_t attribute_handle, struct pldm_msg *msg)
343 {
344 if (msg == NULL) {
345 return PLDM_ERROR_INVALID_DATA;
346 }
347
348 struct pldm_header_info header = { 0 };
349 header.msg_type = PLDM_REQUEST;
350 header.instance = instance_id;
351 header.pldm_type = PLDM_BIOS;
352 header.command = PLDM_GET_BIOS_ATTRIBUTE_CURRENT_VALUE_BY_HANDLE;
353
354 uint8_t rc = pack_pldm_header(&header, &(msg->hdr));
355 if (rc != PLDM_SUCCESS) {
356 return rc;
357 }
358
359 struct pldm_get_bios_attribute_current_value_by_handle_req *request =
360 (struct pldm_get_bios_attribute_current_value_by_handle_req *)
361 msg->payload;
362
363 request->transfer_handle = htole32(transfer_handle);
364 request->transfer_op_flag = transfer_op_flag;
365 request->attribute_handle = htole16(attribute_handle);
366 return PLDM_SUCCESS;
367 }
368
369 LIBPLDM_ABI_STABLE
decode_get_bios_attribute_current_value_by_handle_resp(const struct pldm_msg * msg,size_t payload_length,uint8_t * completion_code,uint32_t * next_transfer_handle,uint8_t * transfer_flag,struct variable_field * attribute_data)370 int decode_get_bios_attribute_current_value_by_handle_resp(
371 const struct pldm_msg *msg, size_t payload_length,
372 uint8_t *completion_code, uint32_t *next_transfer_handle,
373 uint8_t *transfer_flag, struct variable_field *attribute_data)
374 {
375 if (msg == NULL || transfer_flag == NULL ||
376 next_transfer_handle == NULL || completion_code == NULL) {
377 return PLDM_ERROR_INVALID_DATA;
378 }
379
380 struct pldm_get_bios_attribute_current_value_by_handle_resp *response =
381 (struct pldm_get_bios_attribute_current_value_by_handle_resp *)
382 msg->payload;
383
384 *completion_code = response->completion_code;
385
386 if (PLDM_SUCCESS != *completion_code) {
387 return PLDM_SUCCESS;
388 }
389
390 if (payload_length <=
391 PLDM_GET_BIOS_ATTR_CURR_VAL_BY_HANDLE_MIN_RESP_BYTES) {
392 return PLDM_ERROR_INVALID_LENGTH;
393 }
394
395 *next_transfer_handle = le32toh(response->next_transfer_handle);
396 *transfer_flag = response->transfer_flag;
397
398 attribute_data->ptr = response->attribute_data;
399 attribute_data->length = payload_length - sizeof(*response) + 1;
400
401 return PLDM_SUCCESS;
402 }
403
404 LIBPLDM_ABI_STABLE
decode_get_bios_attribute_current_value_by_handle_req(const struct pldm_msg * msg,size_t payload_length,uint32_t * transfer_handle,uint8_t * transfer_op_flag,uint16_t * attribute_handle)405 int decode_get_bios_attribute_current_value_by_handle_req(
406 const struct pldm_msg *msg, size_t payload_length,
407 uint32_t *transfer_handle, uint8_t *transfer_op_flag,
408 uint16_t *attribute_handle)
409 {
410 if (msg == NULL || transfer_handle == NULL ||
411 transfer_op_flag == NULL || attribute_handle == NULL) {
412 return PLDM_ERROR_INVALID_DATA;
413 }
414
415 if (payload_length != PLDM_GET_BIOS_ATTR_CURR_VAL_BY_HANDLE_REQ_BYTES) {
416 return PLDM_ERROR_INVALID_LENGTH;
417 }
418
419 struct pldm_get_bios_attribute_current_value_by_handle_req *request =
420 (struct pldm_get_bios_attribute_current_value_by_handle_req *)
421 msg->payload;
422 *transfer_handle = le32toh(request->transfer_handle);
423 *transfer_op_flag = request->transfer_op_flag;
424 *attribute_handle = le16toh(request->attribute_handle);
425
426 return PLDM_SUCCESS;
427 }
428
429 LIBPLDM_ABI_STABLE
encode_get_bios_current_value_by_handle_resp(uint8_t instance_id,uint8_t completion_code,uint32_t next_transfer_handle,uint8_t transfer_flag,const uint8_t * attribute_data,size_t attribute_length,struct pldm_msg * msg)430 int encode_get_bios_current_value_by_handle_resp(uint8_t instance_id,
431 uint8_t completion_code,
432 uint32_t next_transfer_handle,
433 uint8_t transfer_flag,
434 const uint8_t *attribute_data,
435 size_t attribute_length,
436 struct pldm_msg *msg)
437 {
438 if (msg == NULL || attribute_data == NULL) {
439 return PLDM_ERROR_INVALID_DATA;
440 }
441
442 struct pldm_header_info header = { 0 };
443 header.msg_type = PLDM_RESPONSE;
444 header.instance = instance_id;
445 header.pldm_type = PLDM_BIOS;
446 header.command = PLDM_GET_BIOS_ATTRIBUTE_CURRENT_VALUE_BY_HANDLE;
447
448 uint8_t rc = pack_pldm_header(&header, &(msg->hdr));
449 if (rc != PLDM_SUCCESS) {
450 return rc;
451 }
452
453 struct pldm_get_bios_attribute_current_value_by_handle_resp *response =
454 (struct pldm_get_bios_attribute_current_value_by_handle_resp *)
455 msg->payload;
456 response->completion_code = completion_code;
457 if (response->completion_code == PLDM_SUCCESS) {
458 response->next_transfer_handle = htole32(next_transfer_handle);
459 response->transfer_flag = transfer_flag;
460 if (attribute_data != NULL) {
461 memcpy(response->attribute_data, attribute_data,
462 attribute_length);
463 }
464 }
465 return PLDM_SUCCESS;
466 }
467
468 LIBPLDM_ABI_STABLE
encode_set_bios_attribute_current_value_req(uint8_t instance_id,uint32_t transfer_handle,uint8_t transfer_flag,const uint8_t * attribute_data,size_t attribute_length,struct pldm_msg * msg,size_t payload_length)469 int encode_set_bios_attribute_current_value_req(
470 uint8_t instance_id, uint32_t transfer_handle, uint8_t transfer_flag,
471 const uint8_t *attribute_data, size_t attribute_length,
472 struct pldm_msg *msg, size_t payload_length)
473 {
474 if (msg == NULL || attribute_data == NULL) {
475 return PLDM_ERROR_INVALID_DATA;
476 }
477 if (PLDM_SET_BIOS_ATTR_CURR_VAL_MIN_REQ_BYTES + attribute_length !=
478 payload_length) {
479 return PLDM_ERROR_INVALID_LENGTH;
480 }
481 struct pldm_header_info header = { 0 };
482 header.instance = instance_id;
483 header.msg_type = PLDM_REQUEST;
484 header.pldm_type = PLDM_BIOS;
485 header.command = PLDM_SET_BIOS_ATTRIBUTE_CURRENT_VALUE;
486
487 uint8_t rc = pack_pldm_header(&header, &msg->hdr);
488 if (rc != PLDM_SUCCESS) {
489 return rc;
490 }
491
492 struct pldm_set_bios_attribute_current_value_req *request =
493 (struct pldm_set_bios_attribute_current_value_req *)msg->payload;
494 request->transfer_handle = htole32(transfer_handle);
495 request->transfer_flag = transfer_flag;
496 memcpy(request->attribute_data, attribute_data, attribute_length);
497
498 return PLDM_SUCCESS;
499 }
500
501 LIBPLDM_ABI_STABLE
decode_set_bios_attribute_current_value_resp(const struct pldm_msg * msg,size_t payload_length,uint8_t * completion_code,uint32_t * next_transfer_handle)502 int decode_set_bios_attribute_current_value_resp(const struct pldm_msg *msg,
503 size_t payload_length,
504 uint8_t *completion_code,
505 uint32_t *next_transfer_handle)
506 {
507 if (msg == NULL || completion_code == NULL ||
508 next_transfer_handle == NULL) {
509 return PLDM_ERROR_INVALID_DATA;
510 }
511
512 *completion_code = msg->payload[0];
513 if (PLDM_SUCCESS != *completion_code) {
514 return PLDM_SUCCESS;
515 }
516
517 if (payload_length != PLDM_SET_BIOS_ATTR_CURR_VAL_RESP_BYTES) {
518 return PLDM_ERROR_INVALID_LENGTH;
519 }
520
521 struct pldm_set_bios_attribute_current_value_resp *response =
522 (struct pldm_set_bios_attribute_current_value_resp *)
523 msg->payload;
524
525 *next_transfer_handle = le32toh(response->next_transfer_handle);
526
527 return PLDM_SUCCESS;
528 }
529
530 LIBPLDM_ABI_STABLE
decode_set_bios_attribute_current_value_req(const struct pldm_msg * msg,size_t payload_length,uint32_t * transfer_handle,uint8_t * transfer_flag,struct variable_field * attribute)531 int decode_set_bios_attribute_current_value_req(
532 const struct pldm_msg *msg, size_t payload_length,
533 uint32_t *transfer_handle, uint8_t *transfer_flag,
534 struct variable_field *attribute)
535 {
536 if (msg == NULL || transfer_handle == NULL || transfer_flag == NULL ||
537 attribute == NULL) {
538 return PLDM_ERROR_INVALID_DATA;
539 }
540 if (payload_length < PLDM_SET_BIOS_ATTR_CURR_VAL_MIN_REQ_BYTES) {
541 return PLDM_ERROR_INVALID_LENGTH;
542 }
543
544 struct pldm_set_bios_attribute_current_value_req *request =
545 (struct pldm_set_bios_attribute_current_value_req *)msg->payload;
546 *transfer_handle = le32toh(request->transfer_handle);
547 *transfer_flag = request->transfer_flag;
548 attribute->length =
549 payload_length - PLDM_SET_BIOS_ATTR_CURR_VAL_MIN_REQ_BYTES;
550 attribute->ptr = request->attribute_data;
551 return PLDM_SUCCESS;
552 }
553
554 LIBPLDM_ABI_STABLE
encode_set_bios_attribute_current_value_resp(uint8_t instance_id,uint8_t completion_code,uint32_t next_transfer_handle,struct pldm_msg * msg)555 int encode_set_bios_attribute_current_value_resp(uint8_t instance_id,
556 uint8_t completion_code,
557 uint32_t next_transfer_handle,
558 struct pldm_msg *msg)
559 {
560 if (msg == NULL) {
561 return PLDM_ERROR_INVALID_DATA;
562 }
563 struct pldm_header_info header = { 0 };
564 header.instance = instance_id;
565 header.msg_type = PLDM_RESPONSE;
566 header.pldm_type = PLDM_BIOS;
567 header.command = PLDM_SET_BIOS_ATTRIBUTE_CURRENT_VALUE;
568
569 uint8_t rc = pack_pldm_header(&header, &msg->hdr);
570 if (rc != PLDM_SUCCESS) {
571 return rc;
572 }
573
574 struct pldm_set_bios_attribute_current_value_resp *response =
575 (struct pldm_set_bios_attribute_current_value_resp *)
576 msg->payload;
577 response->completion_code = completion_code;
578 response->next_transfer_handle = htole32(next_transfer_handle);
579
580 return PLDM_SUCCESS;
581 }
582
583 LIBPLDM_ABI_STABLE
encode_set_bios_table_req(uint8_t instance_id,uint32_t transfer_handle,uint8_t transfer_flag,uint8_t table_type,const uint8_t * table_data,size_t table_length,struct pldm_msg * msg,size_t payload_length)584 int encode_set_bios_table_req(uint8_t instance_id, uint32_t transfer_handle,
585 uint8_t transfer_flag, uint8_t table_type,
586 const uint8_t *table_data, size_t table_length,
587 struct pldm_msg *msg, size_t payload_length)
588 {
589 if (msg == NULL || table_data == NULL) {
590 return PLDM_ERROR_INVALID_DATA;
591 }
592
593 if (PLDM_SET_BIOS_TABLE_MIN_REQ_BYTES + table_length !=
594 payload_length) {
595 return PLDM_ERROR_INVALID_LENGTH;
596 }
597
598 struct pldm_header_info header = { 0 };
599 header.instance = instance_id;
600 header.msg_type = PLDM_REQUEST;
601 header.pldm_type = PLDM_BIOS;
602 header.command = PLDM_SET_BIOS_TABLE;
603
604 uint8_t rc = pack_pldm_header(&header, &(msg->hdr));
605 if (rc != PLDM_SUCCESS) {
606 return rc;
607 }
608
609 struct pldm_set_bios_table_req *request =
610 (struct pldm_set_bios_table_req *)msg->payload;
611 request->transfer_handle = htole32(transfer_handle);
612 request->transfer_flag = transfer_flag;
613 request->table_type = table_type;
614 memcpy(request->table_data, table_data, table_length);
615
616 return PLDM_SUCCESS;
617 }
618
619 LIBPLDM_ABI_STABLE
decode_set_bios_table_resp(const struct pldm_msg * msg,size_t payload_length,uint8_t * completion_code,uint32_t * next_transfer_handle)620 int decode_set_bios_table_resp(const struct pldm_msg *msg,
621 size_t payload_length, uint8_t *completion_code,
622 uint32_t *next_transfer_handle)
623 {
624 if (msg == NULL || completion_code == NULL ||
625 next_transfer_handle == NULL) {
626 return PLDM_ERROR_INVALID_DATA;
627 }
628
629 *completion_code = msg->payload[0];
630 if (PLDM_SUCCESS != *completion_code) {
631 return PLDM_SUCCESS;
632 }
633
634 if (payload_length != PLDM_SET_BIOS_TABLE_RESP_BYTES) {
635 return PLDM_ERROR_INVALID_LENGTH;
636 }
637
638 struct pldm_set_bios_table_resp *response =
639 (struct pldm_set_bios_table_resp *)msg->payload;
640
641 *next_transfer_handle = le32toh(response->next_transfer_handle);
642
643 return PLDM_SUCCESS;
644 }
645
646 LIBPLDM_ABI_STABLE
encode_set_bios_table_resp(uint8_t instance_id,uint8_t completion_code,uint32_t next_transfer_handle,struct pldm_msg * msg)647 int encode_set_bios_table_resp(uint8_t instance_id, uint8_t completion_code,
648 uint32_t next_transfer_handle,
649 struct pldm_msg *msg)
650 {
651 if (msg == NULL) {
652 return PLDM_ERROR_INVALID_DATA;
653 }
654
655 struct pldm_header_info header = { 0 };
656 header.instance = instance_id;
657 header.msg_type = PLDM_RESPONSE;
658 header.pldm_type = PLDM_BIOS;
659 header.command = PLDM_SET_BIOS_TABLE;
660
661 uint8_t rc = pack_pldm_header(&header, &(msg->hdr));
662 if (rc != PLDM_SUCCESS) {
663 return rc;
664 }
665
666 struct pldm_set_bios_table_resp *response =
667 (struct pldm_set_bios_table_resp *)msg->payload;
668 response->completion_code = completion_code;
669 response->next_transfer_handle = htole32(next_transfer_handle);
670
671 return PLDM_SUCCESS;
672 }
673
674 LIBPLDM_ABI_STABLE
decode_set_bios_table_req(const struct pldm_msg * msg,size_t payload_length,uint32_t * transfer_handle,uint8_t * transfer_flag,uint8_t * table_type,struct variable_field * table)675 int decode_set_bios_table_req(const struct pldm_msg *msg, size_t payload_length,
676 uint32_t *transfer_handle, uint8_t *transfer_flag,
677 uint8_t *table_type, struct variable_field *table)
678 {
679 if (msg == NULL || transfer_handle == NULL || transfer_flag == NULL ||
680 table_type == NULL || table == NULL) {
681 return PLDM_ERROR_INVALID_DATA;
682 }
683
684 if (payload_length < PLDM_SET_BIOS_TABLE_MIN_REQ_BYTES) {
685 return PLDM_ERROR_INVALID_LENGTH;
686 }
687
688 struct pldm_set_bios_table_req *request =
689 (struct pldm_set_bios_table_req *)msg->payload;
690 *transfer_handle = le32toh(request->transfer_handle);
691 *transfer_flag = request->transfer_flag;
692 *table_type = request->table_type;
693 table->length = payload_length - PLDM_SET_BIOS_TABLE_MIN_REQ_BYTES;
694 table->ptr = request->table_data;
695
696 return PLDM_SUCCESS;
697 }
698