The Manageability KCS transport library needs to support requests both
from MCTP and IPMI transports. Currently the code only handles IPMI
case correctly.
In the MCTP case the communication should be based on the MCTP-over-KCS
specification (DSP0254). This specification defines a special KCS
binding header and trailer structures that need to be present in every
MCTP message.
The header structure contains a length field, therefore response packet
size is not needed to be known beforehand.
The trailer structure contains a PEC checksum that can be used to check
itegrity of the response message.
Modify Manageability KCS transport library code to check which message
is processed (IPMI or MCTP) and handle each case correctly based on its
own specification.
Tested:
- The IPMI KCS communication is tested by Abner Chang,
- The MCTP KCS communication is tested by Konstantin Aladyshev on the
AMD EthanolX CRB.
Signed-off-by: Konstantin Aladyshev <aladyshe...@gmail.com>
Signed-off-by: Abner Chang <abner.ch...@amd.com>
---
.../Common/KcsCommon.c | 284 +++++++++++++++---
.../MctpProtocol/Common/MctpProtocolCommon.c | 14 +-
2 files changed, 260 insertions(+), 38 deletions(-)
diff --git
a/Features/ManageabilityPkg/Library/ManageabilityTransportKcsLib/Common/KcsCommon.c
b/Features/ManageabilityPkg/Library/ManageabilityTransportKcsLib/Common/KcsCommon.c
index d5b54c04be..4f7e7d450f 100644
---
a/Features/ManageabilityPkg/Library/ManageabilityTransportKcsLib/Common/KcsCommon.c
+++
b/Features/ManageabilityPkg/Library/ManageabilityTransportKcsLib/Common/KcsCommon.c
@@ -8,16 +8,19 @@
**/
#include <Uefi.h>
#include <IndustryStandard/IpmiKcs.h>
+#include <IndustryStandard/Mctp.h>
#include <Library/BaseMemoryLib.h>
#include <Library/IoLib.h>
#include <Library/DebugLib.h>
#include <Library/ManageabilityTransportHelperLib.h>
+#include <Library/ManageabilityTransportMctpLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/TimerLib.h>
#include "ManageabilityTransportKcs.h"
extern MANAGEABILITY_TRANSPORT_KCS_HARDWARE_INFO mKcsHardwareInfo;
+extern MANAGEABILITY_TRANSPORT_KCS *mSingleSessionToken;
/**
This function waits for parameter Flag to set.
@@ -379,6 +382,218 @@ KcsTransportRead (
return EFI_SUCCESS;
}
+/**
+ This funciton checks the KCS response data according to
+ manageability protocol.
+
+ @param[in] ResponseData Pointer to response data.
+ @param[in] ResponseDataSize Size of response data.
+ @param[out] AdditionalStatus Pointer to receive the additional status.
+
+ @retval EFI_SUCCESS KCS response header is checked without
error
+ @retval EFI_DEVICE_ERROR KCS response header has problem.
+**/
+EFI_STATUS
+KcsCheckResponseData (
+ IN UINT8 *ResponseData,
+ IN UINT32 ResponseDataSize,
+ OUT MANAGEABILITY_TRANSPORT_ADDITIONAL_STATUS *AdditionalStatus
+ )
+{
+ EFI_STATUS Status;
+ MANAGEABILITY_MCTP_KCS_TRAILER MctpKcsPec;
+ UINT32 PecSize;
+ UINT8 CalculatedPec;
+ CHAR16 *CompletionCodeStr;
+
+ Status = EFI_SUCCESS;
+ *AdditionalStatus = MANAGEABILITY_TRANSPORT_ADDITIONAL_STATUS_NO_ERRORS;
+ if (CompareGuid (&gManageabilityProtocolMctpGuid,
mSingleSessionToken->Token.ManageabilityProtocolSpecification)) {
+ //
+ // For MCTP over KCS, check PEC
+ //
+ PecSize = sizeof (MANAGEABILITY_MCTP_KCS_TRAILER) + 1; // +1 to read last
dummy byte that finishes KCS transfer
+ Status = KcsTransportRead (&MctpKcsPec.Pec, &PecSize);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((
+ DEBUG_ERROR,
+ "%a: Error! Failed to read PEC with Status(%r)\n",
+ __func__,
+ Status
+ ));
+ *AdditionalStatus = MANAGEABILITY_TRANSPORT_ADDITIONAL_STATUS_ERROR;
+ return Status;
+ }
+
+ if (PecSize != sizeof (MctpKcsPec)) {
+ DEBUG ((
+ DEBUG_ERROR,
+ "%a: Error! Received PEC size is %d instead of %d\n",
+ __func__,
+ PecSize,
+ sizeof (MctpKcsPec)
+ ));
+ *AdditionalStatus = MANAGEABILITY_TRANSPORT_ADDITIONAL_STATUS_ERROR;
+ return EFI_DEVICE_ERROR;
+ }
+
+ HelperManageabilityDebugPrint ((VOID *)&MctpKcsPec.Pec, PecSize - 1, "MCTP
over KCS Response PEC:\n");
+ CalculatedPec = HelperManageabilityGenerateCrc8
(MCTP_KCS_PACKET_ERROR_CODE_POLY, 0, ResponseData, ResponseDataSize);
+ if (CalculatedPec != MctpKcsPec.Pec) {
+ DEBUG ((
+ DEBUG_ERROR,
+ "%a: Error! Received PEC is 0x%02x instead of 0x%02x\n",
+ __func__,
+ MctpKcsPec.Pec,
+ CalculatedPec
+ ));
+ Status = EFI_DEVICE_ERROR;
+ }
+ } else if (CompareGuid (&gManageabilityProtocolIpmiGuid,
mSingleSessionToken->Token.ManageabilityProtocolSpecification)) {
+ //
+ // For IPMI over KCS
+ // Check and print Completion Code
+ //
+ Status = IpmiHelperCheckCompletionCode (*ResponseData, &CompletionCodeStr,
AdditionalStatus);
+ if (!EFI_ERROR (Status)) {
+ DEBUG ((DEBUG_MANAGEABILITY_INFO, "Cc: %02x %s.\n", *((UINT8
*)ResponseData), CompletionCodeStr));
+ } else if (Status == EFI_NOT_FOUND) {
+ DEBUG ((DEBUG_ERROR, "Cc: %02x not defined in IpmiCompletionCodeMapping
or invalid.\n", *((UINT8 *)ResponseData)));
+ }
+ }
+
+ return Status;
+}
+
+/**
+ This funciton reads the KCS response header according to
+ manageability protocol. Caller has to free the memory
+ allocated for response header.
+
+ @param[in] ResponseHeader Pointer to receive the response
header.
+ @param[out] AdditionalStatus Pointer to receive the additional
status.
+
+ @retval EFI_SUCCESS KCS response header is checked and
returned
+ to caller.
+ @retval EFI_INVALID_PARAMETER One of the given parameter is
incorrect.
+ @retval EFI_OUT_OF_RESOURCE Memory allocation is failed for
ResponseHeader.
+ @retval EFI_DEVICE_ERROR Incorrect response header.
+**/
+EFI_STATUS
+KcsReadResponseHeader (
+ IN UINT8 **ResponseHeader,
+ OUT MANAGEABILITY_TRANSPORT_ADDITIONAL_STATUS *AdditionalStatus
+ )
+{
+ EFI_STATUS Status;
+ UINT32 RspHeaderSize;
+ UINT32 ExpectedHeaderSize;
+ UINT8 *RspHeader;
+
+ if ((ResponseHeader == NULL) || (AdditionalStatus == NULL)) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ *ResponseHeader = NULL;
+ if (CompareGuid (&gManageabilityProtocolMctpGuid,
mSingleSessionToken->Token.ManageabilityProtocolSpecification)) {
+
+ // For MCTP over KCS
+ ExpectedHeaderSize = sizeof (MANAGEABILITY_MCTP_KCS_HEADER);
+ DEBUG ((
+ DEBUG_MANAGEABILITY_INFO,
+ "%a: Reading MCTP over KCS response header.\n",
+ __func__
+ ));
+ } else if (CompareGuid (&gManageabilityProtocolIpmiGuid,
mSingleSessionToken->Token.ManageabilityProtocolSpecification)) {
+ // For IPMI over KCS
+
+ ExpectedHeaderSize = sizeof (IPMI_KCS_RESPONSE_HEADER);
+ DEBUG ((
+ DEBUG_MANAGEABILITY_INFO,
+ "%a: Reading IPMI over KCS response header.\n",
+ __func__
+ ));
+ } else {
+ DEBUG ((
+ DEBUG_ERROR,
+ "%a: Error! Unsupportted manageability protocol over KCS: %g.\n",
+ __func__,
+ mSingleSessionToken->Token.ManageabilityProtocolSpecification
+ ));
+ return EFI_INVALID_PARAMETER;
+ }
+
+ RspHeader = (UINT8 *)AllocateZeroPool (ExpectedHeaderSize);
+ if (RspHeader == NULL) {
+ DEBUG ((DEBUG_ERROR, "Memory allocation failed for KCS response
header!\n"));
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ RspHeaderSize = ExpectedHeaderSize;
+ Status = KcsTransportRead (RspHeader, &RspHeaderSize);
+ if (EFI_ERROR (Status)) {
+ DEBUG ((
+ DEBUG_ERROR,
+ "%a: Error! Failed to read KCS response header Status(%r)\n",
+ __func__,
+ Status
+ ));
+ FreePool (RspHeader);
+ *AdditionalStatus = MANAGEABILITY_TRANSPORT_ADDITIONAL_STATUS_ERROR;
+ return Status;
+ }
+
+ if (RspHeaderSize != 0) {
+ HelperManageabilityDebugPrint ((VOID *)RspHeader, RspHeaderSize, "KCS
Response Header:\n");
+ }
+
+ if (ExpectedHeaderSize != RspHeaderSize) {
+ DEBUG ((
+ DEBUG_ERROR,
+ "The size (%d bytes) of returned resposne header is not the same as
expection (%d bytes)!\n",
+ RspHeaderSize,
+ ExpectedHeaderSize
+ ));
+ FreePool (RspHeader);
+ return EFI_DEVICE_ERROR;
+ }
+
+ if (CompareGuid (&gManageabilityProtocolMctpGuid,
mSingleSessionToken->Token.ManageabilityProtocolSpecification)) {
+ //
+ // MCTP over KCS
+ //
+ if (((MANAGEABILITY_MCTP_KCS_HEADER *)RspHeader)->NetFunc !=
MCTP_KCS_NETFN_LUN) {
+ DEBUG ((
+ DEBUG_ERROR,
+ "%a: Error! MANAGEABILITY_MCTP_KCS_HEADER.NetFunc is equal 0x%02x
instead of 0x%02x\n",
+ __func__,
+ ((MANAGEABILITY_MCTP_KCS_HEADER *)RspHeader)->NetFunc,
+ MCTP_KCS_NETFN_LUN
+ ));
+ FreePool (RspHeader);
+ *AdditionalStatus = MANAGEABILITY_TRANSPORT_ADDITIONAL_STATUS_ERROR;
+ return EFI_DEVICE_ERROR;
+ }
+
+ if (((MANAGEABILITY_MCTP_KCS_HEADER *)RspHeader)->DefiningBody !=
DEFINING_BODY_DMTF_PRE_OS_WORKING_GROUP) {
+ DEBUG ((
+ DEBUG_ERROR,
+ "%a: Error! MANAGEABILITY_MCTP_KCS_HEADER.DefiningBody is equal 0x%02x
instead of 0x%02x\n",
+ __func__,
+ ((MANAGEABILITY_MCTP_KCS_HEADER *)RspHeader)->DefiningBody,
+ DEFINING_BODY_DMTF_PRE_OS_WORKING_GROUP
+ ));
+ FreePool (RspHeader);
+ *AdditionalStatus = MANAGEABILITY_TRANSPORT_ADDITIONAL_STATUS_ERROR;
+ return EFI_DEVICE_ERROR;
+ }
+ }
+
+ *ResponseHeader = RspHeader;
+ *AdditionalStatus = MANAGEABILITY_TRANSPORT_ADDITIONAL_STATUS_NO_ERRORS;
+ return EFI_SUCCESS;
+}
+
/**
This service communicates with BMC using KCS protocol.
@@ -423,11 +638,9 @@ KcsTransportSendCommand (
OUT MANAGEABILITY_TRANSPORT_ADDITIONAL_STATUS *AdditionalStatus
)
{
- EFI_STATUS Status;
- UINT32 RspHeaderSize;
- IPMI_KCS_RESPONSE_HEADER RspHeader;
- UINT32 ExpectedResponseDataSize;
- CHAR16 *CompletionCodeStr;
+ EFI_STATUS Status;
+ UINT8 *RspHeader;
+ UINT32 ExpectedResponseDataSize;
if ((RequestData != NULL) && (RequestDataSize == 0)) {
DEBUG ((DEBUG_ERROR, "%a: Mismatched values of RequestData and
RequestDataSize\n", __func__));
@@ -467,56 +680,59 @@ KcsTransportSendCommand (
RequestDataSize
);
if (EFI_ERROR (Status)) {
- DEBUG ((DEBUG_ERROR, "KCS Write Failed with Status(%r)", Status));
+ DEBUG ((DEBUG_ERROR, "KCS Write Failed with Status(%r)\n", Status));
return Status;
}
+ }
+ if ((ResponseData != NULL) && (ResponseDataSize != NULL) &&
(*ResponseDataSize != 0)) {
//
// Read the response header
- RspHeaderSize = sizeof (IPMI_KCS_RESPONSE_HEADER);
- Status = KcsTransportRead ((UINT8 *)&RspHeader, &RspHeaderSize);
+ //
+ Status = KcsReadResponseHeader (&RspHeader, AdditionalStatus);
if (EFI_ERROR (Status)) {
- DEBUG ((
- DEBUG_ERROR,
- "KCS read response header failed Status(%r), " \
- "RspNetFunctionLun = 0x%x, " \
- "Comamnd = 0x%x \n",
- Status,
- RspHeader.NetFunc,
- RspHeader.Command
- ));
return (Status);
}
//
- // Print out the response payloads.
- HelperManageabilityDebugPrint ((VOID *)&RspHeader, RspHeaderSize, "KCS
Response Header:\n");
- }
+ // Override ResposeDataSize if the manageability protocol is MCTP.
+ //
+ if (CompareGuid (&gManageabilityProtocolMctpGuid,
mSingleSessionToken->Token.ManageabilityProtocolSpecification)) {
+ if (*ResponseDataSize < ((MANAGEABILITY_MCTP_KCS_HEADER
*)RspHeader)->ByteCount) {
+ DEBUG ((
+ DEBUG_ERROR,
+ "%a: Error! MANAGEABILITY_MCTP_KCS_HEADER.ByteCount (0x%02x) is
bigger than provided buffer (0x%02x)\n",
+ __func__,
+ ((MANAGEABILITY_MCTP_KCS_HEADER *)RspHeader)->ByteCount,
+ *ResponseDataSize
+ ));
+ return EFI_INVALID_PARAMETER;
+ }
+
+ *ResponseDataSize = ((MANAGEABILITY_MCTP_KCS_HEADER
*)RspHeader)->ByteCount;
+ }
+ FreePool (RspHeader);
- if ((ResponseData != NULL) && (ResponseDataSize != NULL) &&
(*ResponseDataSize != 0)) {
ExpectedResponseDataSize = *ResponseDataSize;
- Status = KcsTransportRead ((UINT8 *)ResponseData,
ResponseDataSize);
+ Status = KcsTransportRead (ResponseData,
ResponseDataSize);
if (EFI_ERROR (Status)) {
- DEBUG ((DEBUG_ERROR, "KCS response read Failed with Status(%r)",
Status));
+ DEBUG ((DEBUG_ERROR, "KCS response read Failed with Status(%r)\n",
Status));
}
- //
// Print out the response payloads.
if (*ResponseDataSize != 0) {
if (ExpectedResponseDataSize != *ResponseDataSize) {
- DEBUG ((DEBUG_ERROR, "Expected KCS response size : %d is not matched
to returned size : %d.\n", ExpectedResponseDataSize, *ResponseDataSize));
- Status = EFI_DEVICE_ERROR;
+ DEBUG ((
+ DEBUG_ERROR,
+ "Expected KCS response size : %d is not matched to returned size :
%d.\n",
+ ExpectedResponseDataSize,
+ *ResponseDataSize
+ ));
+ return EFI_DEVICE_ERROR;
}
HelperManageabilityDebugPrint ((VOID *)ResponseData,
(UINT32)*ResponseDataSize, "KCS Response Data:\n");
-
- // Print Completion Code
- Status = IpmiHelperCheckCompletionCode (*((UINT8 *)ResponseData),
&CompletionCodeStr, AdditionalStatus);
- if (!EFI_ERROR (Status)) {
- DEBUG ((DEBUG_MANAGEABILITY_INFO, "Cc: %02x %s.\n", *((UINT8
*)ResponseData), CompletionCodeStr));
- } else if (Status == EFI_NOT_FOUND) {
- DEBUG ((DEBUG_MANAGEABILITY_INFO, "Cc: %02x not defined in
IpmiCompletionCodeMapping or invalid.\n", *((UINT8 *)ResponseData)));
- }
+ Status = KcsCheckResponseData (ResponseData, *ResponseDataSize,
AdditionalStatus);
} else {
DEBUG ((DEBUG_ERROR, "No response, can't determine Completion Code.\n"));
}
diff --git
a/Features/ManageabilityPkg/Universal/MctpProtocol/Common/MctpProtocolCommon.c
b/Features/ManageabilityPkg/Universal/MctpProtocol/Common/MctpProtocolCommon.c
index 7576007f77..e560c638d5 100644
---
a/Features/ManageabilityPkg/Universal/MctpProtocol/Common/MctpProtocolCommon.c
+++
b/Features/ManageabilityPkg/Universal/MctpProtocol/Common/MctpProtocolCommon.c
@@ -267,6 +267,9 @@ CommonMctpSubmitMessage (
MANAGEABILITY_TRANSPORT_TRAILER MctpTransportTrailer;
MANAGEABILITY_TRANSMISSION_MULTI_PACKAGES *MultiPackages;
MANAGEABILITY_TRANSMISSION_PACKAGE_ATTR *ThisPackage;
+ UINT8 *ResponseBuffer;
+ MCTP_TRANSPORT_HEADER *MctpTransportResponseHeader;
+ MCTP_MESSAGE_HEADER *MctpMessageResponseHeader;
if (TransportToken == NULL) {
DEBUG ((DEBUG_ERROR, "%a: No transport toke for MCTP\n", __func__));
@@ -435,11 +438,12 @@ CommonMctpSubmitMessage (
ThisPackage++;
}
+ ResponseBuffer = (UINT8 *)AllocatePool (*ResponseDataSize + sizeof
(MCTP_TRANSPORT_HEADER) + sizeof (MCTP_MESSAGE_HEADER));
// Receive packet.
TransferToken.TransmitPackage.TransmitPayload = NULL;
TransferToken.TransmitPackage.TransmitSizeInByte = 0;
- TransferToken.ReceivePackage.ReceiveBuffer = ResponseData;
- TransferToken.ReceivePackage.ReceiveSizeInByte =
*ResponseDataSize;
+ TransferToken.ReceivePackage.ReceiveBuffer = ResponseBuffer;
+ TransferToken.ReceivePackage.ReceiveSizeInByte =
*ResponseDataSize + sizeof (MCTP_TRANSPORT_HEADER) + sizeof
(MCTP_MESSAGE_HEADER);
TransferToken.TransmitHeader = NULL;
TransferToken.TransmitHeaderSize = 0;
TransferToken.TransmitTrailer = NULL;
@@ -461,8 +465,10 @@ CommonMctpSubmitMessage (
// Return transfer status.
//
*AdditionalTransferError = TransferToken.TransportAdditionalStatus;
- *ResponseDataSize = TransferToken.ReceivePackage.ReceiveSizeInByte;
- Status = TransferToken.TransferStatus;
+ *ResponseDataSize = TransferToken.ReceivePackage.ReceiveSizeInByte -
sizeof (MCTP_TRANSPORT_HEADER) - sizeof (MCTP_MESSAGE_HEADER);
+ CopyMem (ResponseData, ResponseBuffer + sizeof (MCTP_TRANSPORT_HEADER) +
sizeof (MCTP_MESSAGE_HEADER), *ResponseDataSize);
+ FreePool (ResponseBuffer);
+ Status = TransferToken.TransferStatus;
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "%a: Failed to send MCTP command over %s: %r\n",
__func__, mTransportName, Status));
return Status;
--
2.34.1
-=-=-=-=-=-=-=-=-=-=-=-
Groups.io Links: You receive all messages sent to this group.
View/Reply Online (#109853): https://edk2.groups.io/g/devel/message/109853
Mute This Topic: https://groups.io/mt/102080230/21656
Group Owner: devel+ow...@edk2.groups.io
Unsubscribe: https://edk2.groups.io/g/devel/unsub [arch...@mail-archive.com]
-=-=-=-=-=-=-=-=-=-=-=-
