xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Lcfc/LfcPkg/EcFlashSmm/Shell/EcFlashShell.c

1718 lines
36 KiB
C
Raw Blame History

//*****************************************************************************
//
//
// Copyright (c) 2012 - 2015, Hefei LCFC Information Technology Co.Ltd.
// And/or its affiliates. All rights reserved.
// Hefei LCFC Information Technology Co.Ltd. PROPRIETARY/CONFIDENTIAL.
// Use is subject to license terms.
//
//******************************************************************************
#include "EcFlashShell.h"
UINT8 OldSstDevID;
UINT8 OldDevID;
UINT8 SPIDeviceID[4];
EFI_STATUS
MyAsciiToUnicodeStr (
IN CHAR8 *AsciiString,
IN CHAR16 *UnicodeString
)
/*++
Routine Description:
Function to convert ASCII string to Unicode
Arguments:
Returns:
--*/
{
UINT8 Index;
Index = 0;
while (AsciiString[Index] != 0) {
UnicodeString[Index] = (CHAR16)AsciiString[Index];
Index++;
}
UnicodeString[Index] = 0;
return EFI_SUCCESS;
}
VOID
Usage(
VOID
)
{
Print (L"Usage: (Using 0x62/0x66 Port)\n");
//Print (L"Usage: (Using 0x68/0x6C Port)\n");
Print (L" EcFlash -r|w -b:EcRomSize(Unit: KByte) FileName\n");
Print (L" Example:\n");
Print (L" Reading EC ROM to file with 128K Bytes:\n");
Print (L" EcFlash.efi -r -b:128 EC.ROM\n");
Print (L" Written the EC ROM from the file:\n");
Print (L" EcFlash.efi -w EC.ROM\n");
return;
}
VOID
Stall (
UINTN ms
)
{
gBS->Stall (ms);
}
VOID
ShowSSTID (
VOID
)
{
Print (L"SPI Vendor : SST \n");
}
VOID
ShowWinbondID (
VOID
)
{
Print(L"SPI Vendor : Winbond \n");
}
VOID
ShowAtmelID (
VOID
)
{
Print (L"SPI Vendor : Atmel \n");
}
VOID
ShowSTID (
VOID
)
{
Print(L"SPI Vendor : ST \n");
}
VOID
ShowSpansionID (
VOID
)
{
Print (L"SPI Vendor : Spansion \n");
}
VOID
ShowMXICID (
VOID
)
{
Print (L"SPI Vendor : MXIC \n");
}
VOID
ShowAMICID (
VOID
)
{
Print (L"SPI Vendor : AMIC \n");
}
VOID
ShowEONID (
VOID
)
{
Print (L"SPI Vendor : EON \n");
}
VOID
ShowESMTID (
VOID
)
{
Print (L"SPI Vendor : ESMT \n");
}
VOID
ShowIteID (
VOID
)
{
Print (L"SPI Vendor : ITE \n");
}
FLASH_DEV_VENDOR SpiVendor[]= {
{ SSTID, ShowSSTID },
{ WINBOND_ID, ShowWinbondID },
{ ATMEL_ID, ShowAtmelID },
{ ST_ID, ShowSTID },
{ SPANSION_ID, ShowSpansionID },
{ MXIC_ID, ShowMXICID },
{ AMIC_ID, ShowAMICID },
{ EON_ID, ShowEONID },
{ ESMT_ID, ShowESMTID },
{ ITE_ID, ShowIteID },
};
//------------------------------------
// wait EC output buffer full
//------------------------------------
VOID
WaitEcObf (
VOID
)
{
while (!(IoRead8(EC_STATUS_PORT) & EC_OBF));
}
//------------------------------------
// wait EC input buffer empty
//------------------------------------
VOID
WaitEcIbe (
VOID
)
{
while (IoRead8(EC_STATUS_PORT) & EC_IBF);
}
VOID
SendEcCmd (
UINT8 EcCmd
)
{
WaitEcIbe ();
IoWrite8 (EC_CMD_PORT, EcCmd);
WaitEcIbe ();
}
//------------------------------------
// send EC data
//------------------------------------
VOID
SendEcData (
UINT8 EcData
)
{
WaitEcIbe ();
IoWrite8 (EC_DATA_PORT, EcData);
WaitEcIbe ();
}
UINT8
ReadEcData (
VOID
)
{
WaitEcObf ();
return IoRead8(EC_DATA_PORT);
}
//------------------------------------
// wait KB output buffer full
//------------------------------------
VOID
WaitKbObf (
VOID
)
{
while (!(IoRead8(KB_STATUS_PORT) & KB_OBF));
}
VOID
WaitKbObe (
VOID
)
{
while (IoRead8 (KB_STATUS_PORT) & KB_OBF) {
IoRead8 (KB_DATA_PORT);
}
}
//------------------------------------
// wait KB input buffer empty
//------------------------------------
VOID
WaitKbIbe (
VOID
)
{
while (IoRead8(KB_STATUS_PORT) & KB_IBF);
}
VOID
SendKbCmd (
UINT8 KBCmd
)
{
WaitKbObe ();
WaitKbIbe ();
IoWrite8 (KB_CMD_PORT, KBCmd);
WaitKbIbe ();
}
//------------------------------------
// send KB data
//------------------------------------
VOID
SendKbData (
UINT8 KBData
)
{
WaitKbObe ();
WaitKbIbe ();
IoWrite8 (KB_DATA_PORT, KBData);
WaitKbIbe ();
}
UINT8
ReadKbData (
VOID
)
{
WaitKbObf ();
return IoRead8(0x62);
}
VOID
EnterFollowMode (
VOID
)
{
SendEcCmd (0x01);
}
VOID
ExitFollowMode (
VOID
)
{
SendEcCmd (0x05);
}
VOID
SendSPICommand (
UINT8 Cmd
)
{
SendEcCmd (0x02);
SendEcCmd (Cmd);
}
VOID
SendSPIByte (
UINT8 Index
)
{
SendEcCmd (0x03);
SendEcCmd (Index);
}
UINT8
BReadByteFromSPI (
VOID
)
{
SendEcCmd (0x04);
return ReadEcData();
}
VOID
WaitSPIFree (
VOID
)
{
EnterFollowMode ();
SendSPICommand (SPICMD_READ_STATUS);
while (1) {
if((BReadByteFromSPI ()&0x01) == 0x00) {
break;
}
}
ExitFollowMode();
}
VOID
WaitWriteEnable (
VOID
)
{
EnterFollowMode ();
SendSPICommand (SPICMD_READ_STATUS);
while (1) {
if((BReadByteFromSPI ()&0x03) == 0x02) {
break;
}
}
}
VOID
ShowVersion (
VOID
)
{
// Clear Screen
gST->ConOut->ClearScreen (gST->ConOut);
gST->ConOut->SetMode (gST->ConOut, 0);
gST->ConOut->EnableCursor (gST->ConOut, FALSE);
gST->ConOut->SetCursorPosition (gST->ConOut, 0, 0);
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR(EFI_WHITE, EFI_BACKGROUND_BLACK));
Print (L"******************************************************************************\n");
Print (L" LCFC EC ROM Flash Utility Version : %s\n", ECFLASH_VERSION);
Print (L" Company: Hefei LCFC Information Technology Co.Ltd.\n");
Print (L"******************************************************************************\n");
}
VOID
ShowDeviceID (
VOID
)
{
Print(L"Device ID : %x %x %x %x\n", SPIDeviceID[0], SPIDeviceID[1], SPIDeviceID[2], SPIDeviceID[3]);
}
VOID
ShowVendorID (
VOID
)
{
UINT8 Index;
for(Index = 0x00; Index < (sizeof (SpiVendor) / sizeof (FLASH_DEV_VENDOR)); Index++){
if(SPIDeviceID[0] == SpiVendor[Index].Muid) {
(SpiVendor[Index].ShowId)();
}
}
}
VOID
ReadSPIDeviceIDCmdAB (
VOID
)
{
UINT8 Index;
WaitSPIFree ();
EnterFollowMode ();
SendSPICommand (SPICMD_RDID);
SendSPIByte (0x00);
SendSPIByte (0x00);
SendSPIByte (0x00);
for(Index = 0x00; Index < 4; Index++) {
SPIDeviceID[Index] = BReadByteFromSPI();
}
if(SPIDeviceID[0] == SSTID) {
OldSstDevID = 1;
OldDevID = 0;
} else {
OldSstDevID = 0;
OldDevID = 1;
}
ExitFollowMode();
}
VOID
ReadSPIDeviceID (
VOID
)
{
UINT8 Index;
SPIDeviceID[0] = 0x00;
WaitSPIFree ();
EnterFollowMode ();
SendSPICommand (SPICMD__DEVICE_ID);
for(Index=0x00; Index < 4; Index++) {
SPIDeviceID[Index] = BReadByteFromSPI ();
}
if (SPIDeviceID[0] == 0x00) {
ReadSPIDeviceIDCmdAB ();
}
ExitFollowMode ();
}
VOID
SpiWriteDisable (
VOID
)
{
WaitSPIFree ();
EnterFollowMode ();
SendSPICommand (SPICMD_WRDI);
EnterFollowMode ();
SendSPICommand (SPICMD_READ_STATUS);
while(1) {
if((BReadByteFromSPI()&0x02 )== 0x00){
break;
}
}
ExitFollowMode ();
}
VOID
SPIUnlockAll (
VOID
)
{
WaitSPIFree ();
EnterFollowMode ();
SendSPICommand (SPICMD_WREN);
EnterFollowMode ();
SendSPICommand (SPICMD_READ_STATUS);
while(1) {
if((BReadByteFromSPI ()&0x02) != 0x00){
break;
}
}
if(SPIDeviceID[0] == SSTID) {
EnterFollowMode ();
SendSPICommand (SPICMD_EWSR);
}
EnterFollowMode ();
SendSPICommand (SPICMD_WRSR);
SendSPIByte (0x00);
WaitSPIFree ();
}
VOID
SpiWriteEnable (
VOID
)
{
WaitSPIFree ();
EnterFollowMode ();
SendSPICommand (SPICMD_WREN);
if(SPIDeviceID[0] == SSTID) {
EnterFollowMode ();
SendSPICommand (SPICMD_EWSR);
}
EnterFollowMode ();
SendSPICommand (SPICMD_READ_STATUS);
while (1) {
if((BReadByteFromSPI ()&0x03 ) == 0x02) {
break;
}
}
ExitFollowMode ();
}
UINT8
SpiVerifyErase64KByte (
UINT8 BlockNum
)
{
UINT32 AddrInBlock = 0;
UINT32 Index = 0;
AddrInBlock = BlockNum * BLOCK_SIZE_64K;
SpiWriteDisable ();
WaitSPIFree ();
EnterFollowMode ();
SendSPICommand (SPICMD_HIGH_SPEED_READ);
SendSPIByte ((UINT8)(((AddrInBlock>>16)&0xFF))); //Addr2
SendSPIByte ((UINT8)(((AddrInBlock>>8)&0xFF))); //Addr1
SendSPIByte ((UINT8)(((AddrInBlock)&0xFF))); // fast read dummy byte
SendSPIByte (0x00);
Print (L"Erase Verify... : ");
for (Index = 0; Index < BLOCK_SIZE_64K; Index++) {
if(BReadByteFromSPI () != 0xFF) {
WaitSPIFree ();
Print (L" -- Verify Fail. \n");
return 0;
}
}
WaitSPIFree ();
Print (L" -- Verify OK. \n");
return 1;
}
UINT8
SpiVerifyErase1KByte (
UINT8 BlockNum
)
{
UINT32 AddrInBlock = 0;
UINT32 Index = 0;
AddrInBlock = BlockNum * BLOCK_SIZE_1K;
SpiWriteDisable ();
WaitSPIFree ();
EnterFollowMode ();
SendSPICommand (SPICMD_HIGH_SPEED_READ);
SendSPIByte ((UINT8)(((AddrInBlock>>16)&0xFF))); //Addr2
SendSPIByte ((UINT8)(((AddrInBlock>>8)&0xFF))); //Addr1
SendSPIByte ((UINT8)(((AddrInBlock)&0xFF))); // fast read dummy byte
SendSPIByte (0x00);
for (Index = 0; Index < BLOCK_SIZE_1K; Index++) {
if(BReadByteFromSPI () != 0xFF) {
WaitSPIFree ();
return 0;
}
}
WaitSPIFree ();
return 1;
}
VOID
SpiBlockErase64KByte (
UINT8 BlockNum
)
{
UINT8 Counter;
//SpiWriteEnable();
SpiWriteEnable ();
EnterFollowMode ();
SendSPICommand (SPICMD_64K_BYTE_BE);
WaitSPIFree ();
if( OldDevID == 0x01 ) {
SpiWriteEnable ();
EnterFollowMode ();
SendSPICommand (SPICMD_64K_BYTE_BE);
ExitFollowMode ();
WaitSPIFree ();
}
//ExitFollowMode();
Print (L"Eraseing... : ");
for(Counter=0x00; Counter < 22; Counter++){
Print (L"%c", 0xDB);
}
Print (L" -- Erase OK. \n");
}
VOID
SpiBlockErase1KByte (
UINT8 BlockNum
)
{
UINT32 AddrInBlock = 0;
AddrInBlock = BlockNum * BLOCK_SIZE_1K;
SpiWriteEnable ();
EnterFollowMode ();
SendSPICommand (SPICMD_1K_BYTE_BE);
SendSPIByte ((UINT8)((AddrInBlock>>16)&0xFF));
SendSPIByte ((UINT8)((AddrInBlock>>8)&0xFF));
SendSPIByte ((UINT8)((AddrInBlock)&0xFF));
WaitSPIFree ();
}
VOID
ByteProgram64KByte (
UINT8 BlockNum,
UINT8* FileBuf
)
{
UINT8 Addr0,Addr1;
UINT32 AddrInBlock = 0;
Print(L"Programing... : ");
for (Addr1=0x00; Addr1 < 0x100; Addr1++){
SpiWriteEnable ();
EnterFollowMode();
SendSPICommand (SPICMD_BYTE_PROG);
SendSPIByte (BlockNum); //Addr2
SendSPIByte (Addr1); //Addr1
SendSPIByte (0x00); //Addr0
for(Addr0=0x00; Addr0 < 0x100; Addr0++) {
SendSPIByte (FileBuf[AddrInBlock]);
AddrInBlock++;
}
WaitSPIFree ();
//SpiWriteDisable();
}
SpiWriteDisable ();
Print (L" -- Programing OK. \n");
}
VOID
AAIWordProgram64KByte (
UINT8 BlockNum,
UINT8* FileBuf
)
{
UINT8 Index;
UINT32 Counter, AddrInBlock = 0;
AddrInBlock = BlockNum * BLOCK_SIZE_64K;
Index = 0;
SpiWriteEnable();
EnterFollowMode();
SendSPICommand (SPICMD_AAI_WORD_PROG);
SendSPIByte ((UINT8)((AddrInBlock>>16)&0xFF));
SendSPIByte ((UINT8)((AddrInBlock>>8)&0xFF));
SendSPIByte ((UINT8)((AddrInBlock)&0xFF));
Print (L"Programing... : ");
for(Counter = 0; Counter < BLOCK_SIZE_64K; Counter++){
SendSPIByte (FileBuf[AddrInBlock+Counter]);
Index++;
if(Index == 0x02) {
Index = 0x00;
WaitSPIFree ();
EnterFollowMode ();
SendSPICommand (SPICMD_AAI_WORD_PROG);
}
}
SpiWriteDisable ();
WaitSPIFree ();
Print(L" -- Programing 64K bytes OK. \n");
}
VOID
AAIWordProgram1KByte (
UINT8 BlockNum,
UINT8* FileBuf
)
{
UINT8 Index;
UINT32 Counter, AddrInBlock = 0;
AddrInBlock = BlockNum * BLOCK_SIZE_1K;
Index = 0;
SpiWriteEnable();
EnterFollowMode();
SendSPICommand (SPICMD_AAI_WORD_PROG);
SendSPIByte ((UINT8)((AddrInBlock>>16)&0xFF));
SendSPIByte ((UINT8)((AddrInBlock>>8)&0xFF));
SendSPIByte ((UINT8)((AddrInBlock)&0xFF));
for(Counter = 0; Counter < BLOCK_SIZE_1K; Counter++){
SendSPIByte (FileBuf[AddrInBlock + Counter]);
Index++;
if(Index == 0x02) {
Index = 0x00;
WaitSPIFree ();
EnterFollowMode ();
SendSPICommand (SPICMD_AAI_WORD_PROG);
}
}
SpiWriteDisable ();
WaitSPIFree ();
}
BOOLEAN
SpiVerify64KByte (
UINT8 BlockNum,
UINT8* FileBuf
)
{
UINT8 Index;
UINT32 Counter, AddrInBlock = 0;
AddrInBlock = BlockNum*BLOCK_SIZE_64K;
Index = 0;
SpiWriteDisable();
WaitSPIFree();
EnterFollowMode();
SendSPICommand (SPICMD_HIGH_SPEED_READ);
SendSPIByte ((UINT8)((AddrInBlock>>16)&0xFF));
SendSPIByte ((UINT8)((AddrInBlock>>8)&0xFF));
SendSPIByte ((UINT8)((AddrInBlock)&0xFF));
SendSPIByte (0x00); // fast read dummy byte
Print (L"Verify... : ");
for(Counter = 0; Counter < BLOCK_SIZE_64K; Counter++){
if (FileBuf[AddrInBlock + Counter]!=BReadByteFromSPI()){
WaitSPIFree ();
Print (L" -- Verify Fail. \n");
return 0;
}
}
WaitSPIFree ();
Print (L" -- Verify OK. \n");
return 1;
}
BOOLEAN
SpiVerify1KByte (
UINT8 BlockNum,
UINT8* FileBuf
)
{
UINT8 Index;
UINT32 Counter, AddrInBlock = 0;
AddrInBlock = BlockNum*BLOCK_SIZE_1K;
Index = 0;
SpiWriteDisable();
WaitSPIFree();
EnterFollowMode();
SendSPICommand (SPICMD_HIGH_SPEED_READ);
SendSPIByte ((UINT8)((AddrInBlock>>16)&0xFF));
SendSPIByte ((UINT8)((AddrInBlock>>8)&0xFF));
SendSPIByte ((UINT8)((AddrInBlock)&0xFF));
SendSPIByte (0x00); // fast read dummy byte
for(Counter = 0; Counter < BLOCK_SIZE_1K; Counter++){
if (FileBuf[AddrInBlock + Counter]!=BReadByteFromSPI()){
WaitSPIFree ();
return 0;
}
}
WaitSPIFree ();
return 1;
}
VOID
SpiRead64KByte (
UINT8 BlockNum,
UINT8* ReadBuf
)
{
UINT32 AddrInBlock = 0;
SpiWriteDisable ();
WaitSPIFree ();
EnterFollowMode ();
SendSPICommand (SPICMD_HIGH_SPEED_READ);
SendSPIByte (BlockNum); //Addr2
SendSPIByte (0x00); //Addr1
SendSPIByte (0x00); //Addr0
SendSPIByte (0x00); // fast read dummy byte
for (AddrInBlock = 0x00; AddrInBlock < BLOCK_SIZE_64K; AddrInBlock++){
ReadBuf[AddrInBlock] = BReadByteFromSPI();
if((AddrInBlock % (1024 * 8)) == 0x00){
Print (L".");
}
}
WaitSPIFree ();
}
VOID
SpiRead1KByte (
UINT8 BlockNum,
UINT8* ReadBuf
)
{
UINT32 AddrInBlock = 0;
UINT32 BlockAddr = 0;
BlockAddr = BlockNum * BLOCK_SIZE_1K;
SpiWriteDisable ();
WaitSPIFree ();
EnterFollowMode ();
SendSPICommand (SPICMD_HIGH_SPEED_READ);
SendSPIByte ((UINT8)(((BlockAddr>>16)&0xFF))); //Addr2
SendSPIByte ((UINT8)(((BlockAddr>>8)&0xFF))); //Addr1
SendSPIByte ((UINT8)(((BlockAddr)&0xFF))); // fast read dummy byte
SendSPIByte (0x00);
for (AddrInBlock = 0x00; AddrInBlock < BLOCK_SIZE_1K; AddrInBlock++){
ReadBuf[AddrInBlock] = BReadByteFromSPI();
}
ExitFollowMode ();
WaitSPIFree ();
}
EFI_STATUS
OpHelp (
VOID
)
{
Usage ();
return EFI_SUCCESS;
}
EFI_STATUS
OpIdentify (
VOID
)
{
ReadSPIDeviceID ();
ShowDeviceID ();
//ShowVendorID ();
return EFI_SUCCESS;
}
EFI_STATUS
OpRead64K (
UINT8 *ReadBuf,
UINTN BlockCount
)
{
UINT8 BlockNum = 0;
for (BlockNum = 0; BlockNum < BlockCount; BlockNum++){
Print (L"\nBlock Number : %d \n",BlockNum);
SpiRead64KByte (BlockNum, (ReadBuf + (BlockNum * BLOCK_SIZE_64K)));
}
return EFI_SUCCESS;
}
// Showing progress bar.
EFI_STATUS
ShowProgressBar (
UINTN Col,
UINTN Row,
UINTN MaxCount
)
{
UINTN Index;
// Checking input parameter.
if (MaxCount == 0) {
Print (L"MaxCount can't equal to 0\n");
return EFI_INVALID_PARAMETER;
}
// Output the progress bar in the screen.
gST->ConOut->SetCursorPosition(gST->ConOut, Col, Row);
gST->ConOut->SetAttribute (gST->ConOut, EFI_BLUE);
for (Index = 0; Index < PROGRESS_BAR_LEN; Index++){
Print (L"%c", BLOCKELEMENT_FULL_BLOCK);
}
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR(EFI_WHITE, EFI_BACKGROUND_BLACK));
return EFI_SUCCESS;
}
// Setting the progress bar item.
EFI_STATUS
SetProgressBarItem (
UINTN Col,
UINTN Row,
UINTN MaxCount,
UINTN CurValue
)
{
UINTN PrintUnit;
// Checking input parameter.
if (MaxCount == 0 || CurValue >= MaxCount) {
Print (L"MaxCount can't equal to 0\n");
return EFI_INVALID_PARAMETER;
}
// Output current value in the progress bar.
PrintUnit = ((PROGRESS_BAR_LEN - 1) * CurValue) / (MaxCount - 1);
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR(EFI_WHITE, EFI_BACKGROUND_BLACK));
gST->ConOut->SetCursorPosition(gST->ConOut, Col + PrintUnit, Row);
Print (L"%c", BLOCKELEMENT_FULL_BLOCK);
gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR(EFI_WHITE, EFI_BACKGROUND_BLACK));
return EFI_SUCCESS;
}
EFI_STATUS
OpRead1K (
UINT8 *ReadBuf,
UINTN BlockCount
)
{
UINT8 BlockNum = 0;
UINTN Col = 0;
UINTN Row = 0;
UINTN ProgBarOffset = PROGRESS_BAR_OFFSET;
Col = 9;
Row = 7;
ShowProgressBar (Col + ProgBarOffset, Row, BlockCount);
gST->ConOut->SetCursorPosition(gST->ConOut, Col + ProgBarOffset + PROGRESS_BAR_LEN, Row);
Print (L"]");
for (BlockNum = 0; BlockNum < BlockCount; BlockNum++){
gST->ConOut->SetCursorPosition(gST->ConOut, Col, Row);
Print (L"Reading EC ROM [Bank: %3d] [", BlockNum + 1);
SpiRead1KByte (BlockNum, (ReadBuf + (BlockNum * BLOCK_SIZE_1K)));
// Output message onto the screen.
SetProgressBarItem (Col + ProgBarOffset, Row, BlockCount, BlockNum);
}
Row += 2;
gST->ConOut->SetCursorPosition(gST->ConOut, 0, Row);
return EFI_SUCCESS;
}
VOID
SpiChipEraseEflash (
VOID
)
{
Print (L"\nEraseing... : ");
SpiWriteEnable ();
EnterFollowMode ();
SendSPICommand (SPICMD_CHIP_ERASE);
ExitFollowMode ();
WaitSPIFree ();
Print (L" -- Erase full EC ROM OK. \n");
}
EFI_STATUS
OpWrite64K (
UINT8* FileBuf,
UINTN BlockCount
)
{
UINT8 BlockNum = 0;
EFI_STATUS Status = EFI_SUCCESS;
SPIUnlockAll ();
SpiChipEraseEflash ();
for(BlockNum = 0; BlockNum < BlockCount; BlockNum++) {
Print (L"\nBlock Number : %d \n",BlockNum);
if(!SpiVerifyErase64KByte (BlockNum)){
Print (L" Erase Verify Fail \n");
Status = EFI_DEVICE_ERROR;
break;
}
AAIWordProgram64KByte (BlockNum,FileBuf);
if(!SpiVerify64KByte (BlockNum,FileBuf)){
Print (L" Program Verify Fail \n");
Status = EFI_DEVICE_ERROR;
break;
}
}
if(EFI_ERROR(Status)){
Print(L" \nProgram Fail \n");
gBS->Stall (10 * 1000 * 1000);
SendEcCmd (0xFC); // return to shell
} else {
Print (L" \nProgram OK \n");
gBS->Stall (10 * 1000 * 1000);
SendEcCmd (0xFE); // Watch dog reset EC
}
return Status;
}
// This API only run in BIOS post life phase.
EFI_STATUS
OpWrite1KRunBios (
UINT8* FileBuf,
UINTN BlockCount
)
{
EFI_STATUS Status = EFI_SUCCESS;
UINT8 BlockNum = 0;
UINTN Col = 0;
UINTN Row = 0;
UINTN RowIndex = 0;
UINTN ProgBarOffset = PROGRESS_BAR_OFFSET;
SPIUnlockAll ();
// Set the initialization coordinates for the programming window
Col = 9;
Row = 9;
// Clear the programming window
gST->ConOut->SetCursorPosition (gST->ConOut, 0, Row);
for (RowIndex = 0; RowIndex < 11; RowIndex++) {
Print(L" ");
}
gST->ConOut->SetCursorPosition (gST->ConOut, Col, Row);
// Erase EC ROM based on unit 1K byte.
ShowProgressBar (Col + ProgBarOffset, Row, BlockCount);
gST->ConOut->SetCursorPosition(gST->ConOut, Col + ProgBarOffset + PROGRESS_BAR_LEN, Row);
Print (L"]");
for(BlockNum = 0; BlockNum < BlockCount; BlockNum++) {
gST->ConOut->SetCursorPosition(gST->ConOut, Col, Row);
Print (L"Erase EC ROM [Bank: %3d] [", BlockNum + 1);
// Erase 1K block.
SpiBlockErase1KByte (BlockNum);
// Output message onto the screen.
SetProgressBarItem (Col + ProgBarOffset, Row, BlockCount, BlockNum);
}
// Verify the erased EC ROM based on unit 1K byte.
Row += 2;
ShowProgressBar (Col + ProgBarOffset, Row, BlockCount);
gST->ConOut->SetCursorPosition(gST->ConOut, Col + ProgBarOffset + PROGRESS_BAR_LEN, Row);
Print (L"]");
for(BlockNum = 0; BlockNum < BlockCount; BlockNum++) {
gST->ConOut->SetCursorPosition(gST->ConOut, Col, Row);
Print (L"Verify EC ROM [Bank: %3d] [", BlockNum + 1);
// Verify the erased 1K block.
if(!SpiVerifyErase1KByte (BlockNum)){
gST->ConOut->SetCursorPosition(gST->ConOut, Col, Row + 1);
Print (L" Erase Verify Failure!\n");
Status = EFI_DEVICE_ERROR;
return Status;
}
// Output message onto the screen.
SetProgressBarItem (Col + ProgBarOffset, Row, BlockCount, BlockNum);
}
// Program the erased EC ROM based on unit 1K byte.
Row += 2;
ShowProgressBar (Col + ProgBarOffset, Row, BlockCount);
gST->ConOut->SetCursorPosition(gST->ConOut, Col + ProgBarOffset + PROGRESS_BAR_LEN, Row);
Print (L"]");
for(BlockNum = 0; BlockNum < BlockCount; BlockNum++) {
gST->ConOut->SetCursorPosition(gST->ConOut, Col, Row);
Print (L"Program EC ROM [Bank: %3d] [", BlockNum + 1);
// Programming 1K block.
AAIWordProgram1KByte (BlockNum, FileBuf);
// Output message onto the screen.
SetProgressBarItem (Col + ProgBarOffset, Row, BlockCount, BlockNum);
}
// Verify the programmed EC ROM based on unit 1K byte.
Row += 2;
ShowProgressBar (Col + ProgBarOffset, Row, BlockCount);
gST->ConOut->SetCursorPosition(gST->ConOut, Col + ProgBarOffset + PROGRESS_BAR_LEN, Row);
Print (L"]");
for(BlockNum = 0; BlockNum < BlockCount; BlockNum++) {
gST->ConOut->SetCursorPosition(gST->ConOut, Col, Row);
Print (L"Verify EC ROM [Bank: %3d] [", BlockNum + 1);
// Verify the programmed 1K block.
if(!SpiVerify1KByte (BlockNum ,FileBuf)){
gST->ConOut->SetCursorPosition(gST->ConOut, Col, Row + 1);
Print (L" Program Verify Failure! \n");
Status = EFI_DEVICE_ERROR;
return Status;
}
// Output message onto the screen.
SetProgressBarItem (Col + ProgBarOffset, Row, BlockCount, BlockNum);
}
Row ++;
gST->ConOut->SetCursorPosition(gST->ConOut, Col, Row);
return Status;
}
// 64K Unit
/**
UEFI application entry point which has an interface similar to a
standard C main function.
The ShellCEntryLib library instance wrappers the actual UEFI application
entry point and calls this ShellAppMain function.
@param ImageHandle The image handle of the UEFI Application.
@param SystemTable A pointer to the EFI System Table.
@retval 0 The application exited normally.
@retval Other An error occurred.
**/
INTN
EFIAPI
ShellAppMain64K (
IN UINTN Argc,
IN CHAR16 **Argv
)
{
EFI_STATUS Status = EFI_SUCCESS;
UINT8 *FileBuf = NULL;
UINTN BufSize = 0;
OPERATION_EC Operation = OP_HELP;
SHELL_FILE_HANDLE FileHandle = NULL;
BOOLEAN EcAd = FALSE;
UINT64 IteSign;
UINT64 FileSize;
UINTN BlockCount;
CHAR16 *ParamPtr = NULL;
EFI_FILE_INFO *FileInfo = NULL;
// Showing Copyright
ShowVersion ();
// Checking input parameters.
if (Argc < 3) {
Status = OpHelp();
goto Exit;
}
if (((StrCmp(Argv[1], L"-r") == 0) || (StrCmp(Argv[1], L"-R") == 0))
&& (Argc == 4)) {
// Reading EC Binary from EC ROM
// Getting the block count for this EC ROM.
ParamPtr = Argv[2];
// Checking the bank count.
if ((ParamPtr[0] == L'-') &&
((ParamPtr[1] ==L'b' ) ||(ParamPtr[1] ==L'B' )) &&
(ParamPtr[2] == L':')
) {
BlockCount = StrDecimalToUintn(ParamPtr + 3);
if (BlockCount == 0) {
Print (L"It's not one valid bank number! [%s]\n", ParamPtr + 3);
goto Exit;
}
} else {
Print (L"It's not one valid bank count parameter! [%s]\n", Argv[2]);
goto Exit;
}
Status = ShellOpenFileByName (
Argv[3],
&FileHandle,
(EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE),
0
);
if (EFI_ERROR (Status)) {
Print (L"Create file is failed!\n");
goto Exit;
}
// Getting file information
FileInfo = ShellGetFileInfo (FileHandle);
if (FileInfo->FileSize != 0) {
ShellDeleteFile (&FileHandle);
Status = ShellOpenFileByName (
Argv[3],
&FileHandle,
(EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE),
0
);
if (EFI_ERROR (Status)) {
Print (L"Create file is failed!\n");
goto Exit;
}
}
// Allocating the file buffer.
BufSize = BlockCount * BLOCK_SIZE_64K;
Status = gBS->AllocatePages (
AllocateAnyPages,
EfiBootServicesData,
EFI_SIZE_TO_PAGES(BufSize),
(EFI_PHYSICAL_ADDRESS *) (&FileBuf)
);
if(EFI_ERROR(Status)){
Print (L"\n Allocate Memory Error %r\n", Status);
goto Exit;
}
Operation = OP_DUMP;
} else if (((StrCmp(Argv[1], L"-w") == 0) || (StrCmp(Argv[1], L"-W") == 0))
&& (Argc == 3)) {
// Written EC Binary to EC ROM
Operation = OP_PROG;
Status = ShellOpenFileByName(
Argv[2],
&FileHandle,
(EFI_FILE_MODE_READ),
0
);
if (EFI_ERROR (Status)) {
Print (L"Open file is failed!\n");
goto Exit;
}
// Getting the file size.
Status = ShellGetFileSize (FileHandle, &FileSize);
if (EFI_ERROR (Status)) {
Print (L"Can't get the file size!\n");
goto Exit;
}
if (FileSize == 0 ) {
Print (L"Invalid the file size!\n");
goto Exit;
}
//Print (L"File Size = %d Bytes\n", FileSize);
// Get the block number with the file.
BlockCount = FileSize / BLOCK_SIZE_64K;
if ( (FileSize % BLOCK_SIZE_64K) != 0) {
BlockCount++;
}
//Print (L"Total Blocks = %d (UNIT: 64K Byte)\n", BlockCount);
// Allocating file buffer.
BufSize = BlockCount * BLOCK_SIZE_64K;
Status = gBS->AllocatePages (
AllocateAnyPages,
EfiBootServicesData,
EFI_SIZE_TO_PAGES(BufSize),
(EFI_PHYSICAL_ADDRESS *) (&FileBuf)
);
if(EFI_ERROR(Status)){
Print(L"\n Allocate Memory Error %r\n", Status);
goto Exit;
}
// Using 0xFF to fill the file buffer.
SetMem (FileBuf, BufSize, 0xFF);
Status = ShellReadFile (FileHandle, &BufSize, FileBuf);
if (EFI_ERROR(Status)) {
Print (L"Reading EC File Error %r\n",Status);
goto Exit;
}
IteSign = *(UINT64 *)(UINTN)(FileBuf + ITE_8386_ID_OFFSET);
Print (L"EC ROM SIGNATURE = %lxH\n", IteSign);
if (IteSign != ITE_8386_ID) {
Print (L"It's not one valid EC ROM file!\n");
goto Exit;
}
} else {
// Incorrectly input parameters.
Status = OpHelp();
goto Exit;
}
// Disabled Keyboard
SendKbCmd (0xAD);
EcAd = TRUE;
// Checking EC status
SendEcCmd (0xDC);
if(ReadEcData () == 0x33) {
Print (L"EC ACK is OK.\n");
} else {
Print (L"EC ACK is Fail.\n");
Status = EFI_DEVICE_ERROR;
goto Exit;
}
// Getting EC ID
OpIdentify ();
switch (Operation) {
// Dump EC ROM
case OP_DUMP:
Status = OpRead64K (FileBuf, BlockCount);
if (EFI_ERROR (Status)) {
Print (L"Reading EC ROM Error %r\n", Status);
goto Exit;
}
Status = ShellWriteFile (FileHandle, &BufSize, FileBuf);
if (EFI_ERROR(Status)) {
Print (L"Written File Error %r\n", Status);
goto Exit;
}
ShellCloseFile (&FileHandle);
if(FileBuf != NULL) {
gBS->FreePages ((EFI_PHYSICAL_ADDRESS)(UINTN)FileBuf, EFI_SIZE_TO_PAGES(BufSize));
}
Print (L" \nReading EC ROM onto [%s] successfully!\n", Argv[3]);
break;
// Program EC ROM
case OP_PROG:
Status = OpWrite64K (FileBuf, BlockCount);
if (EFI_ERROR(Status)) {
Print (L"Program EC ROM Error %r\n",Status);
goto Exit;
}
break;
// Helpping Message
case OP_HELP:
default:
Status = OpHelp();
break;
}
Exit:
if(EcAd) {
SendKbCmd (0xAE);
gBS->Stall (10 * 1000 * 1000);
SendEcCmd (0xFE); // return to shell
}
if(FileBuf != NULL) {
gBS->FreePages ((EFI_PHYSICAL_ADDRESS)(UINTN)FileBuf, EFI_SIZE_TO_PAGES(BufSize));
}
if(FileHandle != NULL) {
ShellCloseFile (&FileHandle);
}
gST->ConOut->EnableCursor (gST->ConOut, TRUE);
return Status;
}
// 1K Unit
/**
UEFI application entry point which has an interface similar to a
standard C main function.
The ShellCEntryLib library instance wrappers the actual UEFI application
entry point and calls this ShellAppMain function.
@param ImageHandle The image handle of the UEFI Application.
@param SystemTable A pointer to the EFI System Table.
@retval 0 The application exited normally.
@retval Other An error occurred.
**/
INTN
EFIAPI
ShellAppMain (
IN UINTN Argc,
IN CHAR16 **Argv
)
{
EFI_STATUS Status = EFI_SUCCESS;
UINT8 *FileBuf = NULL;
UINTN BufSize = 0;
OPERATION_EC Operation = OP_HELP;
SHELL_FILE_HANDLE FileHandle = NULL;
BOOLEAN EcAd = FALSE;
UINT64 IteSign;
UINT64 FileSize;
UINTN BlockCount;
CHAR16 *ParamPtr = NULL;
EFI_FILE_INFO *FileInfo = NULL;
UINTN ProgRomRetryCount = 3;
// Showing Copyright
ShowVersion ();
// Checking input parameters.
if (Argc < 3) {
Status = OpHelp();
goto Exit;
}
if (((StrCmp(Argv[1], L"-r") == 0) || (StrCmp(Argv[1], L"-R") == 0))
&& (Argc == 4)) {
// Reading EC Binary from EC ROM
// Getting the block count for this EC ROM.
ParamPtr = Argv[2];
// Checking the bank count.
if ((ParamPtr[0] == L'-') &&
((ParamPtr[1] ==L'b' ) ||(ParamPtr[1] ==L'B' )) &&
(ParamPtr[2] == L':')
) {
BlockCount = StrDecimalToUintn(ParamPtr + 3);
if (BlockCount == 0) {
Print (L"It's not one valid EC ROM size! [%s]\n", ParamPtr + 3);
goto Exit;
}
} else {
Print (L"It's not one valid EC ROM size parameter! [%s]\n", Argv[2]);
goto Exit;
}
Status = ShellOpenFileByName (
Argv[3],
&FileHandle,
(EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE),
0
);
if (EFI_ERROR (Status)) {
Print (L"Create file is failed!\n");
goto Exit;
}
// Getting file information
FileInfo = ShellGetFileInfo (FileHandle);
if (FileInfo->FileSize != 0) {
ShellDeleteFile (&FileHandle);
Status = ShellOpenFileByName (
Argv[3],
&FileHandle,
(EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE),
0
);
if (EFI_ERROR (Status)) {
Print (L"Create file is failed!\n");
goto Exit;
}
}
// Allocating the file buffer.
BufSize = BlockCount * BLOCK_SIZE_1K;
Status = gBS->AllocatePages (
AllocateAnyPages,
EfiBootServicesData,
EFI_SIZE_TO_PAGES(BufSize),
(EFI_PHYSICAL_ADDRESS *) (&FileBuf)
);
if(EFI_ERROR(Status)){
Print (L"\n Allocate Memory Error %r\n", Status);
goto Exit;
}
Operation = OP_DUMP;
} else if (((StrCmp(Argv[1], L"-w") == 0) || (StrCmp(Argv[1], L"-W") == 0))
&& (Argc == 3)) {
// Written EC Binary to EC ROM
Operation = OP_PROG;
Status = ShellOpenFileByName(
Argv[2],
&FileHandle,
(EFI_FILE_MODE_READ),
0
);
if (EFI_ERROR (Status)) {
Print (L"Open file is failed!\n");
goto Exit;
}
// Getting the file size.
Status = ShellGetFileSize (FileHandle, &FileSize);
if (EFI_ERROR (Status)) {
Print (L"Can't get the file size!\n");
goto Exit;
}
if (FileSize == 0 ) {
Print (L"Invalid the file size, it must be integer times of 1K bytes.\n");
goto Exit;
}
//Print (L"File Size = %d Bytes\n", FileSize);
// Get the block number with the file.
BlockCount = FileSize / BLOCK_SIZE_1K;
if ( (FileSize % BLOCK_SIZE_1K) != 0) {
Print (L"Invalid the file size, it must be integer times of 1K bytes.\n");
goto Exit;
}
//Print (L"Total Blocks = %d (UNIT: 1K Byte)\n", BlockCount);
// Allocating file buffer.
BufSize = BlockCount * BLOCK_SIZE_1K;
Status = gBS->AllocatePages (
AllocateAnyPages,
EfiBootServicesData,
EFI_SIZE_TO_PAGES(BufSize),
(EFI_PHYSICAL_ADDRESS *) (&FileBuf)
);
if(EFI_ERROR(Status)){
Print(L"\n Allocate Memory Error %r\n", Status);
goto Exit;
}
// Using 0xFF to fill the file buffer.
SetMem (FileBuf, BufSize, 0xFF);
Status = ShellReadFile (FileHandle, &BufSize, FileBuf);
if (EFI_ERROR(Status)) {
Print (L"Reading EC File Error %r\n",Status);
goto Exit;
}
IteSign = *(UINT64 *)(UINTN)(FileBuf + ITE_8386_ID_OFFSET);
if (IteSign != ITE_8386_ID) {
IteSign = *(UINT64 *)(UINTN)(FileBuf + ITE_8586_ID_OFFSET);
if (IteSign != ITE_8586_ID) {
Print (L"EC ROM SIGNATURE = %lxH\n", IteSign);
Print (L"It's not one valid EC ROM file!\n");
goto Exit;
}
else {
Print (L"EC ROM SIGNATURE = %lxH\n", IteSign);
}
}
else {
Print (L"EC ROM SIGNATURE = %lxH\n", IteSign);
}
} else {
// Incorrectly input parameters.
Status = OpHelp();
goto Exit;
}
// Disabled Keyboard
SendKbCmd (0xAD);
EcAd = TRUE;
// Checking EC status
SendEcCmd (0xDC);
if(ReadEcData () == 0x33) {
Print (L"EC ACK is OK.\n");
} else {
Print (L"EC ACK is Fail.\n");
Status = EFI_DEVICE_ERROR;
goto Exit;
}
// Getting EC ID
OpIdentify ();
switch (Operation) {
// Dump EC ROM
case OP_DUMP:
Status = OpRead1K (FileBuf, BlockCount);
if (EFI_ERROR (Status)) {
Print (L"Reading EC ROM Error %r\n", Status);
goto Exit;
}
Status = ShellWriteFile (FileHandle, &BufSize, FileBuf);
if (EFI_ERROR(Status)) {
Print (L"Written File Error %r\n", Status);
goto Exit;
}
ShellCloseFile (&FileHandle);
if(FileBuf != NULL) {
gBS->FreePages ((EFI_PHYSICAL_ADDRESS)(UINTN)FileBuf, EFI_SIZE_TO_PAGES(BufSize));
}
Print (L"Reading EC ROM onto [%s] successfully!\n", Argv[3]);
break;
// Program EC ROM
case OP_PROG:
// Try to program EC ROM within retry count times. The default retry count time is 3.
ProgRomRetryCount = PROG_ROM_RETRY_COUNT;
do {
//Program
Status = OpWrite1KRunBios (FileBuf, BlockCount);
if (!EFI_ERROR(Status)) {
Print (L" \nProgram EC ROM OK \n");
gBS->Stall(10 * 1000 * 1000);
SendEcCmd (0xFE); // Watch dog reset EC
break;
}
Print(L" \nProgram EC ROM Failure \n ");
ProgRomRetryCount--;
}while (ProgRomRetryCount != 0);
// Stopping the machine when program EC ROM failed.
if (ProgRomRetryCount == 0) {
while (1);
}
break;
// Helpping Message
case OP_HELP:
default:
Status = OpHelp();
break;
}
Exit:
if(EcAd) {
SendKbCmd (0xAE);
gBS->Stall (10 * 1000 * 1000);
SendEcCmd (0xFE); // return to shell
}
if(FileBuf != NULL) {
gBS->FreePages ((EFI_PHYSICAL_ADDRESS)(UINTN)FileBuf, EFI_SIZE_TO_PAGES(BufSize));
}
if(FileHandle != NULL) {
ShellCloseFile (&FileHandle);
}
gST->ConOut->EnableCursor (gST->ConOut, TRUE);
return Status;
}
Reference in New Issue View Git Blame Copy Permalink