1 /* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later */ 2 #ifndef BASE_H 3 #define BASE_H 4 5 #ifdef __cplusplus 6 extern "C" { 7 #endif 8 9 #include <libpldm/compiler.h> 10 #include <libpldm/pldm_types.h> 11 #include <libpldm/utils.h> 12 13 #include <asm/byteorder.h> 14 #include <stdalign.h> 15 #include <stdbool.h> 16 #include <stddef.h> 17 #include <stdint.h> 18 19 typedef uint8_t pldm_tid_t; 20 21 /** @brief PLDM Types 22 */ 23 enum pldm_supported_types { 24 PLDM_BASE = 0x00, 25 PLDM_SMBIOS = 0x01, 26 PLDM_PLATFORM = 0x02, 27 PLDM_BIOS = 0x03, 28 PLDM_FRU = 0x04, 29 PLDM_FWUP = 0x05, 30 PLDM_RDE = 0x06, 31 PLDM_FILE = 0x07, 32 PLDM_OEM = 0x3f, 33 }; 34 35 /** @brief PLDM Commands 36 */ 37 enum pldm_supported_commands { 38 PLDM_SET_TID = 0x1, 39 PLDM_GET_TID = 0x2, 40 PLDM_GET_PLDM_VERSION = 0x3, 41 PLDM_GET_PLDM_TYPES = 0x4, 42 PLDM_GET_PLDM_COMMANDS = 0x5, 43 PLDM_SELECT_PLDM_VERSION = 0x6, 44 PLDM_NEGOTIATE_TRANSFER_PARAMETERS = 0x7, 45 PLDM_MULTIPART_SEND = 0x8, 46 PLDM_MULTIPART_RECEIVE = 0x9, 47 PLDM_GET_MULTIPART_TRANSFER_SUPPORT = 0xa, 48 }; 49 50 /** @brief PLDM base codes 51 */ 52 enum pldm_completion_codes { 53 PLDM_SUCCESS = 0x00, 54 PLDM_ERROR = 0x01, 55 PLDM_ERROR_INVALID_DATA = 0x02, 56 PLDM_ERROR_INVALID_LENGTH = 0x03, 57 PLDM_ERROR_NOT_READY = 0x04, 58 PLDM_ERROR_UNSUPPORTED_PLDM_CMD = 0x05, 59 PLDM_ERROR_INVALID_PLDM_TYPE = 0x20, 60 PLDM_INVALID_TRANSFER_OPERATION_FLAG = 0x21 61 }; 62 63 enum transfer_op_flag { 64 PLDM_GET_NEXTPART = 0, 65 PLDM_GET_FIRSTPART = 1, 66 PLDM_ACKNOWLEDGEMENT_ONLY = 2, 67 }; 68 69 enum transfer_multipart_op_flag { 70 PLDM_XFER_FIRST_PART = 0, 71 PLDM_XFER_NEXT_PART = 1, 72 PLDM_XFER_ABORT = 2, 73 PLDM_XFER_COMPLETE = 3, 74 PLDM_XFER_CURRENT_PART = 4, 75 }; 76 77 enum pldm_base_multipart_receive_transfer_flag { 78 PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_START = 0x01, 79 PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_MIDDLE = 0x02, 80 PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_END = 0x04, 81 PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_START_AND_END = 0x05, 82 PLDM_BASE_MULTIPART_RECEIVE_TRANSFER_FLAG_ACK_COMPLETION = 0x08, 83 }; 84 85 enum transfer_resp_flag { 86 PLDM_START = 0x01, 87 PLDM_MIDDLE = 0x02, 88 PLDM_END = 0x04, 89 PLDM_START_AND_END = 0x05, 90 }; 91 92 /** @brief PLDM transport protocol type 93 */ 94 enum pldm_transport_protocol_type { 95 PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP = 0x00, 96 PLDM_TRANSPORT_PROTOCOL_TYPE_OEM = 0xff, 97 }; 98 99 /** @enum MessageType 100 * 101 * The different message types supported by the PLDM specification. 102 */ 103 typedef enum { 104 PLDM_RESPONSE, //!< PLDM response 105 PLDM_REQUEST, //!< PLDM request 106 PLDM_RESERVED, //!< Reserved 107 PLDM_ASYNC_REQUEST_NOTIFY, //!< Unacknowledged PLDM request messages 108 } MessageType; 109 110 #define PLDM_INSTANCE_MAX 31 111 #define PLDM_MAX_TYPES 64 112 #define PLDM_MAX_CMDS_PER_TYPE 256 113 #define PLDM_MAX_TIDS 256 114 #define PLDM_TID_UNASSIGNED 0x00 115 #define PLDM_TID_RESERVED 0xff 116 117 /* Message payload lengths */ 118 #define PLDM_GET_COMMANDS_REQ_BYTES 5 119 #define PLDM_GET_VERSION_REQ_BYTES 6 120 121 /* Response lengths are inclusive of completion code */ 122 #define PLDM_GET_TYPES_REQ_BYTES 0 123 #define PLDM_GET_TYPES_RESP_BYTES 9 124 #define PLDM_GET_TID_REQ_BYTES 0 125 #define PLDM_GET_TID_RESP_BYTES 2 126 #define PLDM_SET_TID_REQ_BYTES 1 127 #define PLDM_SET_TID_RESP_BYTES 1 128 #define PLDM_GET_COMMANDS_RESP_BYTES 33 129 /* Response data has only one version and does not contain the checksum */ 130 #define PLDM_GET_VERSION_RESP_BYTES 10 131 #define PLDM_MULTIPART_RECEIVE_REQ_BYTES 18 132 #define PLDM_BASE_MULTIPART_RECEIVE_RESP_MIN_BYTES 10 133 134 #define PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_REQ_BYTES 10 135 #define PLDM_BASE_NEGOTIATE_TRANSFER_PARAMETERS_RESP_BYTES 11 136 137 #define PLDM_VERSION_0 0 138 #define PLDM_CURRENT_VERSION PLDM_VERSION_0 139 140 #define PLDM_TIMESTAMP104_SIZE 13 141 142 /** @brief Minimum length of response for a optional PLDM command 143 * 144 * For a optional PLDM command, the command handler might not be 145 * implemented in a device's firmware, a response contains only CC 146 * might come in, such as ERROR_UNSUPPORTED_PLDM_CMD. 147 * 148 * The description can be found in DSP0240: 149 * > For an unsupported PLDM command, the ERROR_UNSUPPORTED_PLDM_CMD 150 * > completion code shall be returned unless the responder is in a 151 * > transient state (not ready), in which it cannot process the PLDM 152 * > command. If the responder is in a transient state, it may return 153 * > the ERROR_NOT_READY completion code. 154 */ 155 #define PLDM_OPTIONAL_COMMAND_RESP_MIN_LEN 1 156 157 /** @struct pldm_msg_hdr 158 * 159 * Structure representing PLDM message header fields 160 */ 161 struct pldm_msg_hdr { 162 #if defined(__LITTLE_ENDIAN_BITFIELD) 163 uint8_t instance_id : 5; //!< Instance ID 164 uint8_t reserved : 1; //!< Reserved 165 uint8_t datagram : 1; //!< Datagram bit 166 uint8_t request : 1; //!< Request bit 167 #elif defined(__BIG_ENDIAN_BITFIELD) 168 uint8_t request : 1; //!< Request bit 169 uint8_t datagram : 1; //!< Datagram bit 170 uint8_t reserved : 1; //!< Reserved 171 uint8_t instance_id : 5; //!< Instance ID 172 #endif 173 174 #if defined(__LITTLE_ENDIAN_BITFIELD) 175 uint8_t type : 6; //!< PLDM type 176 uint8_t header_ver : 2; //!< Header version 177 #elif defined(__BIG_ENDIAN_BITFIELD) 178 uint8_t header_ver : 2; //!< Header version 179 uint8_t type : 6; //!< PLDM type 180 #endif 181 uint8_t command; //!< PLDM command code 182 } __attribute__((packed)); 183 184 // Macros for byte-swapping variables in-place 185 #define HTOLE32(X) ((X) = htole32(X)) 186 #define HTOLE16(X) ((X) = htole16(X)) 187 #define LE32TOH(X) ((X) = le32toh(X)) 188 #define LE16TOH(X) ((X) = le16toh(X)) 189 190 /** @struct pldm_msg 191 * 192 * Structure representing PLDM message 193 */ 194 struct pldm_msg { 195 struct pldm_msg_hdr hdr; //!< PLDM message header 196 uint8_t payload[1]; //!< &payload[0] is the beginning of the payload 197 } __attribute__((packed)); 198 199 /** @brief Determine the underlying object size for a @struct pldm_msg 200 * 201 * @pre @p size must be a constant expression 202 * 203 * @note Providing an expression for @p size that is not an integer constant 204 * expression will force a compilation failure. 205 * 206 * @param size The desired size of the @struct pldm_msg payload 207 */ 208 #define PLDM_MSG_SIZE(size) \ 209 (sizeof(char[(__builtin_constant_p(size)) ? 1 : -1])) * \ 210 (sizeof(struct pldm_msg) - \ 211 sizeof(((struct pldm_msg *)NULL)->payload) + (size)) 212 213 /** @brief Stack-allocate a buffer to hold a @struct pldm_msg 214 * 215 * Allocate an appropriately aligned array named @p name of type unsigned char 216 * with the necessary length to hold a payload of the requested size. 217 * 218 * @param name - The variable name used to define the buffer 219 * @param size - The desired payload length for the intended @struct pldm_msg 220 */ 221 #define PLDM_MSG_BUFFER(name, size) \ 222 alignas(struct pldm_msg) unsigned char(name)[PLDM_MSG_SIZE(size)] 223 224 /** @brief Create a pointer to a stack-allocated @struct pldm_msg 225 * 226 * Define a pointer named @p name of type @struct pldm_msg to an object on the 227 * stack of appropriate alignment and length to hold a @struct pldm_msg with a 228 * payload of @p size. 229 * 230 * @param name - The variable name for pointer 231 * @param size - The desired payload length for the underlying @struct pldm_msg 232 * buffer 233 */ 234 #ifdef __cplusplus 235 #define PLDM_MSG_DEFINE_P(name, size) \ 236 PLDM_MSG_BUFFER(name##_buf, size); \ 237 auto *(name) = new (name##_buf) pldm_msg 238 #endif 239 240 /** 241 * @brief Compare the headers from two PLDM messages to determine if the latter 242 * is a message representing a response to the former, where the former must be 243 * a request. 244 * 245 * @param[in] req - A pointer to a PLDM header object, which must represent a 246 * request 247 * @param[in] resp - A pointer to a PLDM header object, which may represent a 248 * response to the provided request. 249 * 250 * @return true if the header pointed to by resp represents a message that is a 251 * response to the header pointed to by req, otherwise false. 252 */ 253 bool pldm_msg_hdr_correlate_response(const struct pldm_msg_hdr *req, 254 const struct pldm_msg_hdr *resp); 255 256 /** @struct pldm_header_info 257 * 258 * The information needed to prepare PLDM header and this is passed to the 259 * pack_pldm_header and unpack_pldm_header API. 260 */ 261 struct pldm_header_info { 262 MessageType msg_type; //!< PLDM message type 263 uint8_t instance; //!< PLDM instance id 264 uint8_t pldm_type; //!< PLDM type 265 uint8_t command; //!< PLDM command code 266 uint8_t completion_code; //!< PLDM completion code, applies for response 267 }; 268 269 /** @struct pldm_get_types_resp 270 * 271 * Structure representing PLDM get types response. 272 */ 273 struct pldm_get_types_resp { 274 uint8_t completion_code; //!< completion code 275 bitfield8_t types[8]; //!< each bit represents whether a given PLDM Type 276 //!< is supported 277 } __attribute__((packed)); 278 279 /** @struct pldm_get_commands_req 280 * 281 * Structure representing PLDM get commands request. 282 */ 283 struct pldm_get_commands_req { 284 uint8_t type; //!< PLDM Type for which command support information is 285 //!< being requested 286 ver32_t version; //!< version for the specified PLDM Type 287 } __attribute__((packed)); 288 289 /** @struct pldm_get_commands_resp 290 * 291 * Structure representing PLDM get commands response. 292 */ 293 struct pldm_get_commands_resp { 294 uint8_t completion_code; //!< completion code 295 bitfield8_t commands[32]; //!< each bit represents whether a given PLDM 296 //!< command is supported 297 } __attribute__((packed)); 298 299 /** @struct pldm_get_version_req 300 * 301 * Structure representing PLDM get version request. 302 */ 303 struct pldm_get_version_req { 304 uint32_t transfer_handle; //!< handle to identify PLDM version data transfer 305 uint8_t transfer_opflag; //!< PLDM GetVersion operation flag 306 uint8_t type; //!< PLDM Type for which version information is being requested 307 } __attribute__((packed)); 308 309 /** @struct pldm_get_version_resp 310 * 311 * Structure representing PLDM get version response. 312 */ 313 314 struct pldm_get_version_resp { 315 uint8_t completion_code; //!< completion code 316 uint32_t next_transfer_handle; //!< next portion of PLDM version data 317 //!< transfer 318 uint8_t transfer_flag; //!< PLDM GetVersion transfer flag 319 uint8_t version_data[1]; //!< PLDM GetVersion version field 320 } __attribute__((packed)); 321 322 /** @struct pldm_set_tid_req 323 * 324 * Structure representing PLDM set tid request. 325 */ 326 327 struct pldm_set_tid_req { 328 uint8_t tid; //!< PLDM SetTID TID field 329 } __attribute__((packed)); 330 331 /** @struct pldm_get_tid_resp 332 * 333 * Structure representing PLDM get tid response. 334 */ 335 336 struct pldm_get_tid_resp { 337 uint8_t completion_code; //!< completion code 338 uint8_t tid; //!< PLDM GetTID TID field 339 } __attribute__((packed)); 340 341 /** @struct pldm_multipart_receive_req 342 * 343 * Structure representing PLDM multipart receive request. 344 */ 345 struct pldm_multipart_receive_req { 346 uint8_t pldm_type; //!< PLDM Type for the MultipartReceive 347 //!< command. 348 uint8_t transfer_opflag; //!< PLDM MultipartReceive operation flag. 349 uint32_t transfer_ctx; //!< Protocol-specifc context for this 350 //!< transfer. 351 uint32_t transfer_handle; //!< handle to identify the part of data to be 352 //!< received. 353 uint32_t section_offset; //!< The start offset for the requested 354 //!< section. 355 uint32_t section_length; //!< The length (in bytes) of the section 356 //!< requested. 357 } __attribute__((packed)); 358 359 /** @struct pldm_multipart_receive_resp 360 * 361 * Structure representing PLDM multipart receive request. 362 */ 363 struct pldm_multipart_receive_resp { 364 uint8_t completion_code; //!< Completion code of the command. 365 uint8_t transfer_flag; //!< PLDM MultipartReceive transfer flag. 366 uint32_t next_transfer_handle; //!< The handle for the next part of 367 //!< data for this section transfer. 368 struct variable_field data; 369 }; 370 371 /** @struct pldm_base_negotiate_transfer_params_req 372 * 373 * Structure representing PLDM Negotiate Transfer Parameters request 374 */ 375 struct pldm_base_negotiate_transfer_params_req { 376 uint16_t requester_part_size; 377 bitfield8_t requester_protocol_support[8]; 378 }; 379 380 /** @struct pldm_base_negotiate_transfer_params_resp 381 * 382 * Structure representing PLDM Negotiate Transfer Parameters response 383 */ 384 struct pldm_base_negotiate_transfer_params_resp { 385 uint8_t completion_code; 386 uint16_t responder_part_size; 387 bitfield8_t responder_protocol_support[8]; 388 }; 389 390 /** 391 * @brief Populate the PLDM message with the PLDM header.The caller of this API 392 * allocates buffer for the PLDM header when forming the PLDM message. 393 * The buffer is passed to this API to pack the PLDM header. 394 * 395 * @param[in] hdr - Pointer to the PLDM header information 396 * @param[out] msg - Pointer to PLDM message header 397 * 398 * @return 0 on success, otherwise PLDM error codes. 399 * @note Caller is responsible for alloc and dealloc of msg 400 * and hdr params 401 */ 402 uint8_t pack_pldm_header(const struct pldm_header_info *hdr, 403 struct pldm_msg_hdr *msg); 404 405 /** 406 * @brief Unpack the PLDM header from the PLDM message. 407 * 408 * @param[in] msg - Pointer to the PLDM message header 409 * @param[out] hdr - Pointer to the PLDM header information 410 * 411 * @return 0 on success, otherwise PLDM error codes. 412 * @note Caller is responsible for alloc and dealloc of msg 413 * and hdr params 414 */ 415 uint8_t unpack_pldm_header(const struct pldm_msg_hdr *msg, 416 struct pldm_header_info *hdr); 417 418 /* Requester */ 419 420 /* GetPLDMTypes */ 421 422 /** @brief Create a PLDM request message for GetPLDMTypes 423 * 424 * @param[in] instance_id - Message's instance id 425 * @param[in,out] msg - Message will be written to this 426 * @return pldm_completion_codes 427 * @note Caller is responsible for memory alloc and dealloc of param 428 * 'msg.payload' 429 */ 430 int encode_get_types_req(uint8_t instance_id, struct pldm_msg *msg); 431 432 /** @brief Decode a GetPLDMTypes response message 433 * 434 * Note: 435 * * If the return value is not PLDM_SUCCESS, it represents a 436 * transport layer error. 437 * * If the completion_code value is not PLDM_SUCCESS, it represents a 438 * protocol layer error and all the out-parameters are invalid. 439 * 440 * @param[in] msg - Response message 441 * @param[in] payload_length - Length of response message payload 442 * @param[out] completion_code - Pointer to response msg's PLDM completion code 443 * @param[out] types - pointer to array bitfield8_t[8] containing supported 444 * types (MAX_TYPES/8) = 8), as per DSP0240 445 * @return pldm_completion_codes 446 */ 447 int decode_get_types_resp(const struct pldm_msg *msg, size_t payload_length, 448 uint8_t *completion_code, bitfield8_t *types); 449 450 /* GetPLDMCommands */ 451 452 /** @brief Create a PLDM request message for GetPLDMCommands 453 * 454 * @param[in] instance_id - Message's instance id 455 * @param[in] type - PLDM Type 456 * @param[in] version - Version for PLDM Type 457 * @param[in,out] msg - Message will be written to this 458 * @return pldm_completion_codes 459 * @note Caller is responsible for memory alloc and dealloc of param 460 * 'msg.payload' 461 */ 462 int encode_get_commands_req(uint8_t instance_id, uint8_t type, ver32_t version, 463 struct pldm_msg *msg); 464 465 /** @brief Decode a GetPLDMCommands response message 466 * 467 * Note: 468 * * If the return value is not PLDM_SUCCESS, it represents a 469 * transport layer error. 470 * * If the completion_code value is not PLDM_SUCCESS, it represents a 471 * protocol layer error and all the out-parameters are invalid. 472 * 473 * @param[in] msg - Response message 474 * @param[in] payload_length - Length of response message payload 475 * @param[out] completion_code - Pointer to response msg's PLDM completion code 476 * @param[in] commands - pointer to array bitfield8_t[32] containing supported 477 * commands (PLDM_MAX_CMDS_PER_TYPE/8) = 32), as per DSP0240 478 * @return pldm_completion_codes 479 */ 480 int decode_get_commands_resp(const struct pldm_msg *msg, size_t payload_length, 481 uint8_t *completion_code, bitfield8_t *commands); 482 483 /* GetPLDMVersion */ 484 485 /** @brief Create a PLDM request for GetPLDMVersion 486 * 487 * @param[in] instance_id - Message's instance id 488 * @param[in] transfer_handle - Handle to identify PLDM version data transfer. 489 * This handle is ignored by the responder when the 490 * transferop_flag is set to getFirstPart. 491 * @param[in] transfer_opflag - flag to indicate whether it is start of 492 * transfer 493 * @param[in] type - PLDM Type for which version is requested 494 * @param[in,out] msg - Message will be written to this 495 * @return pldm_completion_codes 496 * @note Caller is responsible for memory alloc and dealloc of param 497 * 'msg.payload' 498 */ 499 int encode_get_version_req(uint8_t instance_id, uint32_t transfer_handle, 500 uint8_t transfer_opflag, uint8_t type, 501 struct pldm_msg *msg); 502 503 /** @brief Decode a GetPLDMVersion response message 504 * 505 * Note: 506 * * If the return value is not PLDM_SUCCESS, it represents a 507 * transport layer error. 508 * * If the completion_code value is not PLDM_SUCCESS, it represents a 509 * protocol layer error and all the out-parameters are invalid. 510 * 511 * @param[in] msg - Response message 512 * @param[in] payload_length - Length of response message payload 513 * @param[out] completion_code - Pointer to response msg's PLDM completion code 514 * @param[out] next_transfer_handle - the next handle for the next part of data 515 * @param[out] transfer_flag - flag to indicate the part of data 516 * @return pldm_completion_codes 517 */ 518 int decode_get_version_resp(const struct pldm_msg *msg, size_t payload_length, 519 uint8_t *completion_code, 520 uint32_t *next_transfer_handle, 521 uint8_t *transfer_flag, ver32_t *version); 522 523 /* GetTID */ 524 525 /** @brief Decode a GetTID response message 526 * 527 * Note: 528 * * If the return value is not PLDM_SUCCESS, it represents a 529 * transport layer error. 530 * * If the completion_code value is not PLDM_SUCCESS, it represents a 531 * protocol layer error and all the out-parameters are invalid. 532 * 533 * @param[in] msg - Response message 534 * @param[in] payload_length - Length of response message payload 535 * @param[out] completion_code - Pointer to response msg's PLDM completion code 536 * @param[out] tid - Pointer to the terminus id 537 * @return pldm_completion_codes 538 */ 539 int decode_get_tid_resp(const struct pldm_msg *msg, size_t payload_length, 540 uint8_t *completion_code, uint8_t *tid); 541 542 /* Responder */ 543 544 /* GetPLDMTypes */ 545 546 /** @brief Create a PLDM response message for GetPLDMTypes 547 * 548 * @param[in] instance_id - Message's instance id 549 * @param[in] completion_code - PLDM completion code 550 * @param[in] types - pointer to array bitfield8_t[8] containing supported 551 * types (MAX_TYPES/8) = 8), as per DSP0240 552 * @param[in,out] msg - Message will be written to this 553 * @return pldm_completion_codes 554 * @note Caller is responsible for memory alloc and dealloc of param 555 * 'msg.payload' 556 */ 557 int encode_get_types_resp(uint8_t instance_id, uint8_t completion_code, 558 const bitfield8_t *types, struct pldm_msg *msg); 559 560 /* GetPLDMCommands */ 561 562 /** @brief Decode GetPLDMCommands' request data 563 * 564 * @param[in] msg - Request message 565 * @param[in] payload_length - Length of request message payload 566 * @param[out] type - PLDM Type 567 * @param[out] version - Version for PLDM Type 568 * @return pldm_completion_codes 569 */ 570 int decode_get_commands_req(const struct pldm_msg *msg, size_t payload_length, 571 uint8_t *type, ver32_t *version); 572 573 /** @brief Create a PLDM response message for GetPLDMCommands 574 * 575 * @param[in] instance_id - Message's instance id 576 * @param[in] completion_code - PLDM completion code 577 * @param[in] commands - pointer to array bitfield8_t[32] containing supported 578 * commands (PLDM_MAX_CMDS_PER_TYPE/8) = 32), as per DSP0240 579 * @param[in,out] msg - Message will be written to this 580 * @return pldm_completion_codes 581 * @note Caller is responsible for memory alloc and dealloc of param 582 * 'msg.payload' 583 */ 584 int encode_get_commands_resp(uint8_t instance_id, uint8_t completion_code, 585 const bitfield8_t *commands, struct pldm_msg *msg); 586 587 /* GetPLDMVersion */ 588 589 /** @brief Create a PLDM response for GetPLDMVersion 590 * 591 * @param[in] instance_id - Message's instance id 592 * @param[in] completion_code - PLDM completion code 593 * @param[in] next_transfer_handle - Handle to identify next portion of 594 * data transfer 595 * @param[in] transfer_flag - Represents the part of transfer 596 * @param[in] version_data - the version data 597 * @param[in] version_size - size of version data 598 * @param[in,out] msg - Message will be written to this 599 * @return pldm_completion_codes 600 * @note Caller is responsible for memory alloc and dealloc of param 601 * 'msg.payload' 602 */ 603 int encode_get_version_resp(uint8_t instance_id, uint8_t completion_code, 604 uint32_t next_transfer_handle, 605 uint8_t transfer_flag, const ver32_t *version_data, 606 size_t version_size, struct pldm_msg *msg); 607 608 /** @brief Decode a GetPLDMVersion request message 609 * 610 * @param[in] msg - Request message 611 * @param[in] payload_length - length of request message payload 612 * @param[out] transfer_handle - the handle of data 613 * @param[out] transfer_opflag - Transfer Flag 614 * @param[out] type - PLDM type for which version is requested 615 * @return pldm_completion_codes 616 */ 617 int decode_get_version_req(const struct pldm_msg *msg, size_t payload_length, 618 uint32_t *transfer_handle, uint8_t *transfer_opflag, 619 uint8_t *type); 620 621 /* Requester */ 622 623 /* GetTID */ 624 625 /** @brief Create a PLDM request message for GetTID 626 * 627 * @param[in] instance_id - Message's instance id 628 * @param[in,out] msg - Message will be written to this 629 * @return pldm_completion_codes 630 * @note Caller is responsible for memory alloc and dealloc of param 631 * 'msg.payload' 632 */ 633 int encode_get_tid_req(uint8_t instance_id, struct pldm_msg *msg); 634 635 /** @brief Create a PLDM response message for GetTID 636 * 637 * @param[in] instance_id - Message's instance id 638 * @param[in] completion_code - PLDM completion code 639 * @param[in] tid - Terminus ID 640 * @param[in,out] msg - Message will be written to this 641 * @return pldm_completion_codes 642 * @note Caller is responsible for memory alloc and dealloc of param 643 * 'msg.payload' 644 */ 645 int encode_get_tid_resp(uint8_t instance_id, uint8_t completion_code, 646 uint8_t tid, struct pldm_msg *msg); 647 648 /** @brief Create a PLDM request message for SetTID 649 * 650 * @param[in] instance_id - Message's instance id 651 * @param[in] tid - Terminus ID 652 * @param[in,out] msg - Message will be written to this 653 * @return pldm_completion_codes 654 * @note Caller is responsible for memory alloc and dealloc of param 655 * 'msg.payload' 656 */ 657 int encode_set_tid_req(uint8_t instance_id, uint8_t tid, struct pldm_msg *msg); 658 659 /* Responder */ 660 661 /* MultipartRecieve */ 662 663 /** @brief Decode a PLDM MultipartReceive request message 664 * 665 * @param[in] msg - Request message 666 * @param[in] payload_length - length of request message payload 667 * @param[out] pldm_type - PLDM type for which version is requested 668 * @param[out] transfer_opflag - Transfer Flag 669 * @param[out] transfer_ctx - The context of the packet 670 * @param[out] transfer_handle - The handle of data 671 * @param[out] section_offset - The start of the requested section 672 * @param[out] section_length - The length of the requested section 673 * @return pldm_completion_codes 674 */ 675 int decode_multipart_receive_req(const struct pldm_msg *msg, 676 size_t payload_length, uint8_t *pldm_type, 677 uint8_t *transfer_opflag, 678 uint32_t *transfer_ctx, 679 uint32_t *transfer_handle, 680 uint32_t *section_offset, 681 uint32_t *section_length); 682 683 /** @brief Encode a PLDM MultipartReceive request message 684 * 685 * @param[in] instance_id - Message's instance id 686 * @param[in] req - The pointer to the request message to be encoded 687 * @param[in,out] msg - Message will be written to this 688 * @param[in] payload_length - length of request message payload 689 * @return 0 on success 690 * -EINVAL if the input parameters' memory are not allocated, 691 * or message type or instance in request header is invalid 692 * -ENOMSG if the PLDM type in the request header is invalid 693 * -EOVERFLOW if the input message length is invalid 694 */ 695 int encode_base_multipart_receive_req( 696 uint8_t instance_id, const struct pldm_multipart_receive_req *req, 697 struct pldm_msg *msg, size_t payload_length); 698 699 /** @brief Decode a PLDM MultipartReceive response message 700 * 701 * @param[in] msg - Response message 702 * @param[in] payload_length - length of request message payload 703 * @param[out] resp - pointer to the decoded response message, 704 * excluding the data integrity checksum 705 * @param[out] data_integrity_checksum - The checksum of data field 706 * of the decoded response message 707 * @return 0 on success 708 * -EINVAL if the input parameters' memory are not allocated 709 * -EOVERFLOW if the input message buffer is too short for the output 710 * response struct 711 * -EBADMSG if the input message buffer is too large for the output 712 * response struct 713 * @note Caller is responsible for memory alloc and dealloc of param 714 * 'msg.payload' 715 */ 716 int decode_base_multipart_receive_resp(const struct pldm_msg *msg, 717 size_t payload_length, 718 struct pldm_multipart_receive_resp *resp, 719 uint32_t *data_integrity_checksum); 720 721 /** @brief Create a PLDM response message containing only cc 722 * 723 * @param[in] instance_id - Message's instance id 724 * @param[in] type - PLDM Type 725 * @param[in] command - PLDM Command 726 * @param[in] cc - PLDM Completion Code 727 * @param[out] msg - Message will be written to this 728 * @return pldm_completion_codes 729 */ 730 int encode_cc_only_resp(uint8_t instance_id, uint8_t type, uint8_t command, 731 uint8_t cc, struct pldm_msg *msg); 732 733 /** @brief Create a PLDM message only with the header 734 * 735 * @param[in] msg_type - PLDM message type 736 * @param[in] instance_id - Message's instance id 737 * @param[in] pldm_type - PLDM Type 738 * @param[in] command - PLDM Command 739 * @param[out] msg - Message will be written to this 740 * 741 * @return pldm_completion_codes 742 */ 743 int encode_pldm_header_only(uint8_t msg_type, uint8_t instance_id, 744 uint8_t pldm_type, uint8_t command, 745 struct pldm_msg *msg); 746 747 /** @brief Encode a PLDM Negotiate Transfer Parameters request message 748 * 749 * @param[in] instance_id - Message's instance id 750 * @param[in] req - The pointer to the request message to be encoded 751 * @param[in,out] msg - Message will be written to this 752 * @param[in] payload_length - length of request message payload 753 * @return 0 on success 754 * -EINVAL if the input parameters' memory are not allocated, 755 * or message type or instance in request header is invalid 756 * -ENOMSG if the PLDM type in the request header is invalid 757 * -EOVERFLOW if the input message length is invalid 758 */ 759 int encode_pldm_base_negotiate_transfer_params_req( 760 uint8_t instance_id, 761 const struct pldm_base_negotiate_transfer_params_req *req, 762 struct pldm_msg *msg, size_t payload_length); 763 764 /** @brief Decode a PLDM Negotiate Transfer Parameters response message 765 * 766 * @param[in] msg - Response message 767 * @param[in] payload_length - length of request message payload 768 * @param[out] resp - pointer to the decoded response message, 769 * excluding the data integrity checksum 770 * @return 0 on success 771 * -EINVAL if the input parameters' memory are not allocated 772 * -EOVERFLOW if the input message buffer is too short for the output 773 * response struct 774 * -EBADMSG if the input message buffer is too large for the output 775 * response struct 776 * @note Caller is responsible for memory alloc and dealloc of param 777 * 'msg.payload' 778 */ 779 int decode_pldm_base_negotiate_transfer_params_resp( 780 const struct pldm_msg *msg, size_t payload_length, 781 struct pldm_base_negotiate_transfer_params_resp *resp); 782 783 #ifdef __cplusplus 784 } 785 #endif 786 787 #endif /* BASE_H */ 788