-
Notifications
You must be signed in to change notification settings - Fork 461
/
KcsCommon.c
577 lines (498 loc) · 19.9 KB
/
KcsCommon.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
/** @file
KCS instance of Manageability Transport Library
Copyright (C) 2023 Advanced Micro Devices, Inc. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include <Uefi.h>
#include <IndustryStandard/IpmiKcs.h>
#include <Library/BaseMemoryLib.h>
#include <Library/IoLib.h>
#include <Library/DebugLib.h>
#include <Library/ManageabilityTransportHelperLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/TimerLib.h>
#include "ManageabilityTransportKcs.h"
extern MANAGEABILITY_TRANSPORT_KCS_HARDWARE_INFO mKcsHardwareInfo;
/**
This function waits for parameter Flag to set.
Checks status flag in every 1ms internal till 5 seconds elapses.
@param[in] Flag KCS Flag to test.
@retval EFI_SUCCESS The KCS flag under test is set.
@retval EFI_TIMEOUT The KCS flag didn't set in 5 second windows.
**/
EFI_STATUS
WaitStatusSet (
IN UINT8 Flag
)
{
UINT64 Timeout = 0;
while (!(KcsRegisterRead8 (KCS_REG_STATUS) & Flag)) {
MicroSecondDelay (IPMI_KCS_TIMEOUT_1MS);
Timeout = Timeout + IPMI_KCS_TIMEOUT_1MS;
if (Timeout >= IPMI_KCS_TIMEOUT_5_SEC) {
return EFI_TIMEOUT;
}
}
return EFI_SUCCESS;
}
/**
This function waits for parameter Flag to get cleared.
Checks status flag in every 1ms internal till 5 seconds elapses.
@param[in] Flag KCS Flag to test.
@retval EFI_SUCCESS The KCS flag under test is clear.
@retval EFI_TIMEOUT The KCS flag didn't cleared in 5 second windows.
**/
EFI_STATUS
WaitStatusClear (
IN UINT8 Flag
)
{
UINT64 Timeout = 0;
while (KcsRegisterRead8 (KCS_REG_STATUS) & Flag) {
MicroSecondDelay (IPMI_KCS_TIMEOUT_1MS);
Timeout = Timeout + IPMI_KCS_TIMEOUT_1MS;
if (Timeout >= IPMI_KCS_TIMEOUT_5_SEC) {
return EFI_TIMEOUT;
}
}
return EFI_SUCCESS;
}
/**
This function validates KCS OBF bit.
Checks whether OBF bit is set or not.
@retval EFI_SUCCESS OBF bit is set.
@retval EFI_NOT_READY OBF bit is not set.
**/
EFI_STATUS
ClearOBF (
VOID
)
{
if (KcsRegisterRead8 (KCS_REG_STATUS) & IPMI_KCS_OBF) {
KcsRegisterRead8 (KCS_REG_DATA_IN); // read the data to clear the OBF
if (KcsRegisterRead8 (KCS_REG_STATUS) & IPMI_KCS_OBF) {
return EFI_NOT_READY;
}
}
return EFI_SUCCESS;
}
/**
This function writes/sends data to the KCS port.
Algorithm is based on flow chart provided in IPMI spec 2.0
Figure 9-6, KCS Interface BMC to SMS Write Transfer Flow Chart
@param[in] TransmitHeader KCS packet header.
@param[in] TransmitHeaderSize KCS packet header size in byte.
@param[in] TransmitTrailer KCS packet trailer.
@param[in] TransmitTrailerSize KCS packet trailer size in byte.
@param[in] RequestData Command Request Data, could be NULL.
RequestDataSize must be zero, if RequestData
is NULL.
@param[in] RequestDataSize Size of Command Request Data.
@retval EFI_SUCCESS The command byte stream was successfully
submit to the device and a response was
successfully received.
@retval EFI_NOT_FOUND The command was not successfully sent to the
device or a response was not successfully
received from the device.
@retval EFI_NOT_READY Ipmi Device is not ready for Ipmi command
access.
@retval EFI_DEVICE_ERROR Ipmi Device hardware error.
@retval EFI_TIMEOUT The command time out.
@retval EFI_UNSUPPORTED The command was not successfully sent to
the device.
@retval EFI_OUT_OF_RESOURCES The resource allocation is out of resource or
data size error.
**/
EFI_STATUS
KcsTransportWrite (
IN MANAGEABILITY_TRANSPORT_HEADER TransmitHeader,
IN UINT16 TransmitHeaderSize,
IN MANAGEABILITY_TRANSPORT_TRAILER TransmitTrailer OPTIONAL,
IN UINT16 TransmitTrailerSize,
IN UINT8 *RequestData OPTIONAL,
IN UINT32 RequestDataSize
)
{
EFI_STATUS Status;
UINT32 Length;
UINT8 *Buffer;
UINT8 *BufferPtr;
// Validation on RequestData and RequestDataSize.
if (((RequestData == NULL) && (RequestDataSize != 0)) ||
((RequestData != NULL) && (RequestDataSize == 0))
)
{
DEBUG ((DEBUG_ERROR, "%a: Mismatched values of RequestData or RequestDataSize.\n", __func__));
return EFI_INVALID_PARAMETER;
}
// Validation on TransmitHeader and TransmitHeaderSize.
if (((TransmitHeader == NULL) && (TransmitHeaderSize != 0)) ||
((TransmitHeader != NULL) && (TransmitHeaderSize == 0))
)
{
DEBUG ((DEBUG_ERROR, "%a: Mismatched values of TransmitHeader or TransmitHeaderSize.\n", __func__));
return EFI_INVALID_PARAMETER;
}
// Validation on TransmitHeader and TransmitHeaderSize.
if (((TransmitTrailer == NULL) && (TransmitTrailerSize != 0)) ||
((TransmitTrailer != NULL) && (TransmitTrailerSize == 0))
)
{
DEBUG ((DEBUG_ERROR, "%a: Mismatched values of TransmitTrailer or TransmitTrailerSize.\n", __func__));
return EFI_INVALID_PARAMETER;
}
Length = TransmitHeaderSize;
if (RequestData != NULL) {
Length = Length + RequestDataSize;
}
if ((TransmitTrailer != NULL) && (TransmitTrailerSize != 0)) {
Length += TransmitTrailerSize;
}
Buffer = AllocateZeroPool (Length);
if (Buffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// Buffer[0..(TransmitHeaderSize - 1)] = TransmitHeader
// Buffer [TransmitHeader..(TransmitHeader + RequestDataSize - 1)] = RequestData
// Buffer [(TransmitHeader + RequestDataSize)..(TransmitHeader + RequestDataSize + TransmitTrailerSize - 1)] = TransmitTrailer
//
BufferPtr = Buffer;
CopyMem ((VOID *)BufferPtr, (VOID *)TransmitHeader, TransmitHeaderSize);
BufferPtr += TransmitHeaderSize;
if (RequestData != NULL) {
CopyMem (BufferPtr, RequestData, RequestDataSize);
}
BufferPtr += RequestDataSize;
if (TransmitTrailer != NULL) {
CopyMem (BufferPtr, (VOID *)TransmitTrailer, TransmitTrailerSize);
}
BufferPtr = Buffer;
// Step 1. wait for IBF to get clear
Status = WaitStatusClear (IPMI_KCS_IBF);
if (EFI_ERROR (Status)) {
FreePool (Buffer);
return Status;
}
// Step 2. clear OBF
if (EFI_ERROR (ClearOBF ())) {
FreePool (Buffer);
return EFI_NOT_READY;
}
// Step 3. WR_START to CMD, phase=wr_start
KcsRegisterWrite8 (KCS_REG_COMMAND, IPMI_KCS_CONTROL_CODE_WRITE_START);
// Step 4. wait for IBF to get clear
Status = WaitStatusClear (IPMI_KCS_IBF);
if (EFI_ERROR (Status)) {
FreePool (Buffer);
return Status;
}
// Step 5. check state it should be WRITE_STATE, else exit with error
if (IPMI_KCS_GET_STATE (KcsRegisterRead8 (KCS_REG_STATUS)) != IpmiKcsWriteState) {
FreePool (Buffer);
return EFI_NOT_READY;
}
// Step 6, Clear OBF
if (EFI_ERROR (ClearOBF ())) {
FreePool (Buffer);
return EFI_NOT_READY;
}
while (Length > 1) {
// Step 7, phase wr_data, write one byte of Data
KcsRegisterWrite8 (KCS_REG_DATA_OUT, *BufferPtr);
Length--;
BufferPtr++;
// Step 8. wait for IBF clear
Status = WaitStatusClear (IPMI_KCS_IBF);
if (EFI_ERROR (Status)) {
FreePool (Buffer);
return Status;
}
// Step 9. check state it should be WRITE_STATE, else exit with error
if (IPMI_KCS_GET_STATE (KcsRegisterRead8 (KCS_REG_STATUS)) != IpmiKcsWriteState) {
FreePool (Buffer);
return EFI_NOT_READY;
}
// Step 10
if (EFI_ERROR (ClearOBF ())) {
FreePool (Buffer);
return EFI_NOT_READY;
}
//
// Step 11, check for DATA completion if more than one byte;
// if still need to be transferred then go to step 7 and repeat
//
}
// Step 12, WR_END to CMD
KcsRegisterWrite8 (KCS_REG_COMMAND, IPMI_KCS_CONTROL_CODE_WRITE_END);
// Step 13. wait for IBF to get clear
Status = WaitStatusClear (IPMI_KCS_IBF);
if (EFI_ERROR (Status)) {
FreePool (Buffer);
return Status;
}
// Step 14. check state it should be WRITE_STATE, else exit with error
if (IPMI_KCS_GET_STATE (KcsRegisterRead8 (KCS_REG_STATUS)) != IpmiKcsWriteState) {
FreePool (Buffer);
return EFI_NOT_READY;
}
// Step 15
if (EFI_ERROR (ClearOBF ())) {
FreePool (Buffer);
return EFI_NOT_READY;
}
// Step 16, write the last byte
KcsRegisterWrite8 (KCS_REG_DATA_OUT, *BufferPtr);
FreePool (Buffer);
return EFI_SUCCESS;
}
/**
This function sends/receives data from KCS port.
Algorithm is based on flow chart provided in IPMI spec 2.0
Figure 9-7, KCS Interface BMC to SMS Read Transfer Flow Chart
@param [in] DataBytes Buffer to hold the read Data.
@param [in, out] Length Number of Bytes read from KCS port.
@retval EFI_SUCCESS The command byte stream was
successfully submit to the device and
a response was successfully received.
@retval EFI_NOT_FOUND The command was not successfully sent
to the device or a response was not
successfully received from the
device.
@retval EFI_NOT_READY Ipmi Device is not ready for Ipmi
command access.
@retval EFI_DEVICE_ERROR Ipmi Device hardware error.
@retval EFI_TIMEOUT The command time out.
@retval EFI_UNSUPPORTED The command was not successfully set
to the device.
@retval EFI_OUT_OF_RESOURCES The resource allocation is out of
resource or data size error.
**/
EFI_STATUS
KcsTransportRead (
OUT UINT8 *DataByte,
IN OUT UINT32 *Length
)
{
EFI_STATUS Status;
UINT32 ReadLength;
if ((DataByte == NULL) || (*Length == 0)) {
DEBUG ((DEBUG_ERROR, "%a: Either DataByte is NULL or Length is 0.\n", __func__));
return EFI_INVALID_PARAMETER;
}
ReadLength = 0;
while (ReadLength < *Length) {
// Step 1. wait for IBF to get clear
Status = WaitStatusClear (IPMI_KCS_IBF);
if (EFI_ERROR (Status)) {
*Length = ReadLength;
return Status;
}
// Step 2. check state it should be READ_STATE, else exit with error
if (IPMI_KCS_GET_STATE (KcsRegisterRead8 (KCS_REG_STATUS)) == IpmiKcsReadState) {
// Step 2.1.1 check of OBF to get clear
Status = WaitStatusSet (IPMI_KCS_OBF);
if (EFI_ERROR (Status)) {
*Length = ReadLength;
return Status;
}
// Step 2.1.2 read data from data out
DataByte[ReadLength++] = KcsRegisterRead8 (KCS_REG_DATA_IN);
Status = WaitStatusClear (IPMI_KCS_IBF);
if (EFI_ERROR (Status)) {
*Length = ReadLength;
return Status;
}
// Step 2.1.3 Write READ byte to data in register.
KcsRegisterWrite8 (KCS_REG_DATA_OUT, IPMI_KCS_CONTROL_CODE_READ);
} else if (IPMI_KCS_GET_STATE (KcsRegisterRead8 (KCS_REG_STATUS)) == IpmiKcsIdleState) {
// Step 2.2.1
Status = WaitStatusSet (IPMI_KCS_OBF);
if (EFI_ERROR (Status)) {
*Length = ReadLength;
return Status;
}
// Step 2.2.2 read dummy data
KcsRegisterRead8 (KCS_REG_DATA_IN); // Dummy read as per IPMI spec
*Length = ReadLength;
return EFI_SUCCESS;
} else {
*Length = ReadLength;
return EFI_DEVICE_ERROR;
}
}
*Length = ReadLength;
return EFI_SUCCESS;
}
/**
This service communicates with BMC using KCS protocol.
@param[in] TransmitHeader KCS packet header.
@param[in] TransmitHeaderSize KCS packet header size in byte.
@param[in] TransmitTrailer KCS packet trailer.
@param[in] TransmitTrailerSize KCS packet trailer size in byte.
@param[in] RequestData Command Request Data.
@param[in] RequestDataSize Size of Command Request Data.
@param[out] ResponseData Command Response Data. The completion
code is the first byte of response
data.
@param[in, out] ResponseDataSize Size of Command Response Data.
@param[out] AdditionalStatus Additional status of this transaction.
@retval EFI_SUCCESS The command byte stream was
successfully submit to the device and a
response was successfully received.
@retval EFI_NOT_FOUND The command was not successfully sent
to the device or a response was not
successfully received from the device.
@retval EFI_NOT_READY Ipmi Device is not ready for Ipmi
command access.
@retval EFI_DEVICE_ERROR Ipmi Device hardware error.
@retval EFI_TIMEOUT The command time out.
@retval EFI_UNSUPPORTED The command was not successfully sent to
the device.
@retval EFI_OUT_OF_RESOURCES The resource allocation is out of
resource or data size error.
**/
EFI_STATUS
EFIAPI
KcsTransportSendCommand (
IN MANAGEABILITY_TRANSPORT_HEADER TransmitHeader OPTIONAL,
IN UINT16 TransmitHeaderSize,
IN MANAGEABILITY_TRANSPORT_TRAILER TransmitTrailer OPTIONAL,
IN UINT16 TransmitTrailerSize,
IN UINT8 *RequestData OPTIONAL,
IN UINT32 RequestDataSize,
OUT UINT8 *ResponseData OPTIONAL,
IN OUT UINT32 *ResponseDataSize OPTIONAL,
OUT MANAGEABILITY_TRANSPORT_ADDITIONAL_STATUS *AdditionalStatus
)
{
EFI_STATUS Status;
UINT32 RspHeaderSize;
IPMI_KCS_RESPONSE_HEADER RspHeader;
UINT32 ExpectedResponseDataSize;
CHAR16 *CompletionCodeStr;
if ((RequestData != NULL) && (RequestDataSize == 0)) {
DEBUG ((DEBUG_ERROR, "%a: Mismatched values of RequestData and RequestDataSize\n", __func__));
return EFI_INVALID_PARAMETER;
}
if ((ResponseData != NULL) && ((ResponseDataSize != NULL) && (*ResponseDataSize == 0))) {
DEBUG ((DEBUG_ERROR, "%a: Mismatched values of ResponseData and ResponseDataSize\n", __func__));
return EFI_INVALID_PARAMETER;
}
if (AdditionalStatus == NULL) {
DEBUG ((DEBUG_ERROR, "%a: AdditionalStatus is NULL.\n", __func__));
return EFI_INVALID_PARAMETER;
}
// Print out the request payloads.
if ((TransmitHeader != NULL) && (TransmitHeaderSize != 0)) {
HelperManageabilityDebugPrint ((VOID *)TransmitHeader, (UINT32)TransmitHeaderSize, "KCS Transmit Header:\n");
}
if (RequestData != NULL) {
HelperManageabilityDebugPrint ((VOID *)RequestData, RequestDataSize, "KCS Request Data:\n");
}
if ((TransmitTrailer != NULL) && (TransmitTrailerSize != 0)) {
HelperManageabilityDebugPrint ((VOID *)TransmitTrailer, (UINT32)TransmitTrailerSize, "KCS Transmit Trailer:\n");
}
if ((TransmitHeader != NULL) || (RequestData != NULL)) {
Status = KcsTransportWrite (
TransmitHeader,
TransmitHeaderSize,
TransmitTrailer,
TransmitTrailerSize,
RequestData,
RequestDataSize
);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "KCS Write Failed with Status(%r)", Status));
return Status;
}
//
// Read the response header
RspHeaderSize = sizeof (IPMI_KCS_RESPONSE_HEADER);
Status = KcsTransportRead ((UINT8 *)&RspHeader, &RspHeaderSize);
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");
}
if ((ResponseData != NULL) && (ResponseDataSize != NULL) && (*ResponseDataSize != 0)) {
ExpectedResponseDataSize = *ResponseDataSize;
Status = KcsTransportRead ((UINT8 *)ResponseData, ResponseDataSize);
if (EFI_ERROR (Status)) {
DEBUG ((DEBUG_ERROR, "KCS response read Failed with Status(%r)", 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;
}
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)));
}
} else {
DEBUG ((DEBUG_ERROR, "No response, can't determine Completion Code.\n"));
}
} else {
*ResponseDataSize = 0;
}
return Status;
}
/**
This function reads 8-bit value from register address.
@param[in] Address This represents either 16-bit IO address
or 32-bit memory mapped address.
@retval UINT8 8-bit value.
**/
UINT8
KcsRegisterRead8 (
MANAGEABILITY_TRANSPORT_HARDWARE_IO Address
)
{
UINT8 Value;
if (mKcsHardwareInfo.MemoryMap == MANAGEABILITY_TRANSPORT_KCS_MEMORY_MAP_IO) {
// Read 8-bit value from 32-bit Memory mapped address.
Value = MmioRead8 ((UINTN)Address.IoAddress32);
} else {
// Read 8-bit value from 16-bit I/O address
Value = IoRead8 ((UINTN)Address.IoAddress16);
}
return Value;
}
/**
This function writes 8-bit value to register address.
@param[in] Address This represents either 16-bit IO address
or 32-bit memory mapped address.
@param[in] Value 8-bit value write to register address
**/
VOID
KcsRegisterWrite8 (
MANAGEABILITY_TRANSPORT_HARDWARE_IO Address,
UINT8 Value
)
{
if (mKcsHardwareInfo.MemoryMap == MANAGEABILITY_TRANSPORT_KCS_MEMORY_MAP_IO) {
// Write 8-bit value to 32-bit Memory mapped address.
MmioWrite8 ((UINTN)Address.IoAddress32, Value);
} else {
// Write 8-bit value to 16-bit I/O address
IoWrite8 ((UINTN)Address.IoAddress16, Value);
}
}