cpld/lattice/lattice_xo3_cpld.cpp - openbmc/phosphor-bmc-code-mgmt - Gitiles

 #include "lattice_xo3_cpld.hpp"

 #include <phosphor-logging/lg2.hpp>

 #include <fstream>
 #include <vector>

 namespace phosphor::software::cpld
 {

 sdbusplus::async::task<bool> LatticeXO3CPLD::readDeviceId()
 {
     std::vector<uint8_t> request = {commandReadDeviceId, 0x0, 0x0, 0x0};
     std::vector<uint8_t> response = {0, 0, 0, 0};

     if (!i2cInterface.sendReceive(request, response))
     {
         lg2::error(
             "Fail to read device Id. Please check the I2C bus and address.");
         co_return false;
     }

     auto chipWantToUpdate = std::find_if(
         supportedDeviceMap.begin(), supportedDeviceMap.end(),
         [this](const auto& pair) {
             auto chipModel =
                 getLatticeChipStr(pair.first, latticeStringType::modelString);
             return chipModel == this->chip;
         });

     if (chipWantToUpdate != supportedDeviceMap.end() &&
         chipWantToUpdate->second.deviceId == response)
     {
         if (chip.rfind("LCMXO3D", 0) == 0)
         {
             isLCMXO3D = true;
             if (!target.empty() && target != "CFG0" && target != "CFG1")
             {
                 lg2::error("Unknown target. Only CFG0 and CFG1 are supported.");
                 co_return false;
             }
         }

         lg2::debug("Device ID match with chip. Chip name: {CHIPNAME}",
                    "CHIPNAME", chip);
         co_return true;
     }

     lg2::error("The device id doesn't match with chip.");
     co_return false;
 }

 sdbusplus::async::task<bool> LatticeXO3CPLD::eraseFlash()
 {
     std::vector<uint8_t> request;
     std::vector<uint8_t> response;

     if (isLCMXO3D)
     {
         /*
         Erase the different internal
         memories. The bit in YYY defines
         which memory is erased in Flash
         access mode.
         Bit 1=Enable
         8 Erase CFG0
         9 Erase CFG1
         10 Erase UFM0
         11 Erase UFM1
         12 Erase UFM2
         13 Erase UFM3
         14 Erase CSEC
         15 Erase USEC
         16 Erase PUBKEY
         17 Erase AESKEY
         18 Erase FEA
         19 Reserved
         commandEraseFlash = 0x0E, 0Y YY 00
         */
         if (target.empty() || target == "CFG0")
         {
             request = {commandEraseFlash, 0x00, 0x01, 0x00};
         }
         else if (target == "CFG1")
         {
             request = {commandEraseFlash, 0x00, 0x02, 0x00};
         }
         else
         {
             lg2::error("Error: unknown target.");
             co_return false;
         }
     }
     else
     {
         request = {commandEraseFlash, 0xC, 0x0, 0x0};
     }

     if (!i2cInterface.sendReceive(request, response))
     {
         lg2::error("Failed to send erase flash request.");
         co_return false;
     }

     if (!(co_await waitBusyAndVerify()))
     {
         lg2::error("Wait busy and verify fail");
         co_return false;
     }
     co_await sdbusplus::async::sleep_for(ctx, waitBusyTime);
     co_return true;
 }

 sdbusplus::async::task<bool> LatticeXO3CPLD::writeProgramPage()
 {
     /*
     Program one NVCM/Flash page. Can be
     used to program the NVCM0/CFG or
     NVCM1/UFM.
     */
     size_t iterSize = 16;

     for (size_t i = 0; (i * iterSize) < fwInfo.cfgData.size(); i++)
     {
         size_t byteOffset = i * iterSize;
         double progressRate =
             ((double(byteOffset) / double(fwInfo.cfgData.size())) * 100);
         std::cout << "Update :" << std::fixed << std::dec
                   << std::setprecision(2) << progressRate << "% \r";

         uint8_t len = ((byteOffset + iterSize) < fwInfo.cfgData.size())
                           ? iterSize
                           : (fwInfo.cfgData.size() - byteOffset);
         auto pageData = std::vector<uint8_t>(
             fwInfo.cfgData.begin() + static_cast<std::ptrdiff_t>(byteOffset),
             fwInfo.cfgData.begin() +
                 static_cast<std::ptrdiff_t>(byteOffset + len));

         size_t retry = 0;
         const size_t maxWriteRetry = 10;
         while (retry < maxWriteRetry)
         {
             if (!(co_await programSinglePage(i, pageData)))
             {
                 retry++;
                 continue;
             }

             if (!(co_await verifySinglePage(i, pageData)))
             {
                 retry++;
                 continue;
             }

             break;
         }

         if (retry >= maxWriteRetry)
         {
             lg2::error("Program and verify page failed");
             co_return false;
         }
     }

     if (!(co_await waitBusyAndVerify()))
     {
         lg2::error("Wait busy and verify fail");
         co_return false;
     }

     co_return true;
 }

 sdbusplus::async::task<bool> LatticeXO3CPLD::readUserCode(uint32_t& userCode)
 {
     constexpr size_t resSize = 4;
     std::vector<uint8_t> request = {commandReadFwVersion, 0x0, 0x0, 0x0};
     std::vector<uint8_t> response(resSize, 0);

     if (!i2cInterface.sendReceive(request, response))
     {
         lg2::error("Failed to send read user code request.");
         co_return false;
     }

     for (size_t i = 0; i < resSize; i++)
     {
         userCode |= response.at(i) << ((3 - i) * 8);
     }
     co_return true;
 }

 sdbusplus::async::task<bool> LatticeXO3CPLD::programUserCode()
 {
     std::vector<uint8_t> request = {commandProgramUserCode, 0x0, 0x0, 0x0};
     std::vector<uint8_t> response;
     for (int i = 3; i >= 0; i--)
     {
         request.push_back((fwInfo.version >> (i * 8)) & 0xFF);
     }

     if (!i2cInterface.sendReceive(request, response))
     {
         lg2::error("Failed to send program user code request.");
         co_return false;
     }
     if (!(co_await waitBusyAndVerify()))
     {
         lg2::error("Wait busy and verify fail");
         co_return false;
     }

     co_return true;
 }

 sdbusplus::async::task<bool> LatticeXO3CPLD::prepareUpdate(const uint8_t* image,
                                                            size_t imageSize)
 {
     if (!(co_await readDeviceId()))
     {
         co_return false;
     }

     if (!jedFileParser(image, imageSize))
     {
         lg2::error("JED file parsing failed");
         co_return false;
     }
     lg2::debug("JED file parsing success");

     if (!verifyChecksum())
     {
         lg2::error("Checksum verification failed");
         co_return false;
     }

     if (!isLCMXO3D)
     {
         lg2::error("is not LCMXO3D");
     }

     co_return true;
 }

 sdbusplus::async::task<bool> LatticeXO3CPLD::doUpdate()
 {
     co_await waitBusyAndVerify();

     if (!(co_await enableProgramMode()))
     {
         lg2::error("Enable program mode failed.");
         co_return false;
     }

     if (!(co_await eraseFlash()))
     {
         lg2::error("Erase flash failed.");
         co_return false;
     }

     if (!(co_await resetConfigFlash()))
     {
         lg2::error("Reset config flash failed.");
         co_return false;
     }

     if (!(co_await writeProgramPage()))
     {
         lg2::error("Write program page failed.");
         co_return false;
     }

     if (!(co_await programUserCode()))
     {
         lg2::error("Program user code failed.");
         co_return false;
     }

     if (!(co_await programDone()))
     {
         lg2::error("Program not done.");
         co_return false;
     }

     co_return true;
 }

 sdbusplus::async::task<bool> LatticeXO3CPLD::finishUpdate()
 {
     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Branch)
     if (!(co_await disableConfigInterface()))
     {
         lg2::error("Disable Config Interface failed.");
         co_return false;
     }

     co_return true;
 }

 sdbusplus::async::task<bool> LatticeXO3CPLD::programSinglePage(
     uint16_t pageOffset, std::span<const uint8_t> pageData)
 {
     // Set Page Offset
     std::vector<uint8_t> emptyResp(0);
     std::vector<uint8_t> setPageAddrCmd = {
         commandSetPageAddress, 0x0, 0x0, 0x0, 0x00, 0x00, 0x00, 0x00};
     setPageAddrCmd[6] = static_cast<uint8_t>(pageOffset >> 8); // high byte
     setPageAddrCmd[7] = static_cast<uint8_t>(pageOffset);      // low byte

     // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Branch)
     bool success = co_await i2cInterface.sendReceive(
         setPageAddrCmd.data(), setPageAddrCmd.size(), nullptr, 0);
     if (!success)
     {
         lg2::error("Write page address failed");
         co_return false;
     }

     // Write Page Data
     constexpr uint8_t pageCount = 1;
     std::vector<uint8_t> writeCmd = {commandProgramPage, 0x0, 0x0, pageCount};
     writeCmd.insert(writeCmd.end(), pageData.begin(), pageData.end());

     success = co_await i2cInterface.sendReceive(writeCmd.data(),
                                                 writeCmd.size(), nullptr, 0);
     if (!success)
     {
         lg2::error("Write page data failed");
         co_return false;
     }

     co_await sdbusplus::async::sleep_for(ctx, std::chrono::microseconds(200));

     if (!(co_await waitBusyAndVerify()))
     {
         lg2::error("Wait busy and verify fail");
         co_return false;
     }

     co_return true;
 }

 sdbusplus::async::task<bool> LatticeXO3CPLD::verifySinglePage(
     uint16_t pageOffset, std::span<const uint8_t> pageData)
 {
     // Set Page Offset
     std::vector<uint8_t> emptyResp(0);
     std::vector<uint8_t> setPageAddrCmd = {
         commandSetPageAddress, 0x0, 0x0, 0x0, 0x00, 0x00, 0x00, 0x00};
     setPageAddrCmd[6] = static_cast<uint8_t>(pageOffset >> 8); // high byte
     setPageAddrCmd[7] = static_cast<uint8_t>(pageOffset);      // low byte

     if (!i2cInterface.sendReceive(setPageAddrCmd, emptyResp))
     {
         lg2::error("Write page address failed");
         co_return false;
     }

     // Read Page Data
     constexpr uint8_t pageCount = 1;
     std::vector<uint8_t> readData(pageData.size());
     std::vector<uint8_t> readCmd = {commandReadPage, 0x0, 0x0, pageCount};

     if (!i2cInterface.sendReceive(readCmd, readData))
     {
         lg2::error("Read page data failed");
         co_return false;
     }

     constexpr size_t pageSize = 16;
     auto mismatch_pair =
         std::mismatch(pageData.begin(), pageData.end(), readData.begin());
     if (mismatch_pair.first != pageData.end())
     {
         size_t idx = std::distance(pageData.begin(), mismatch_pair.first);
         lg2::error("Verify failed at {INDEX}", "INDEX",
                    ((static_cast<size_t>(pageSize * pageOffset)) + idx));
         co_return false;
     }

     co_return true;
 }

 } // namespace phosphor::software::cpld
	#include "lattice_xo3_cpld.hpp"

	#include <phosphor-logging/lg2.hpp>

	#include <fstream>
	#include <vector>

	namespace phosphor::software::cpld
	{

	sdbusplus::async::task<bool> LatticeXO3CPLD::readDeviceId()
	{
	std::vector<uint8_t> request = {commandReadDeviceId, 0x0, 0x0, 0x0};
	std::vector<uint8_t> response = {0, 0, 0, 0};

	if (!i2cInterface.sendReceive(request, response))
	{
	lg2::error(
	"Fail to read device Id. Please check the I2C bus and address.");
	co_return false;
	}

	auto chipWantToUpdate = std::find_if(
	supportedDeviceMap.begin(), supportedDeviceMap.end(),
	[this](const auto& pair) {
	auto chipModel =
	getLatticeChipStr(pair.first, latticeStringType::modelString);
	return chipModel == this->chip;
	});

	if (chipWantToUpdate != supportedDeviceMap.end() &&
	chipWantToUpdate->second.deviceId == response)
	{
	if (chip.rfind("LCMXO3D", 0) == 0)
	{
	isLCMXO3D = true;
	if (!target.empty() && target != "CFG0" && target != "CFG1")
	{
	lg2::error("Unknown target. Only CFG0 and CFG1 are supported.");
	co_return false;
	}
	}

	lg2::debug("Device ID match with chip. Chip name: {CHIPNAME}",
	"CHIPNAME", chip);
	co_return true;
	}

	lg2::error("The device id doesn't match with chip.");
	co_return false;
	}

	sdbusplus::async::task<bool> LatticeXO3CPLD::eraseFlash()
	{
	std::vector<uint8_t> request;
	std::vector<uint8_t> response;

	if (isLCMXO3D)
	{
	/*
	Erase the different internal
	memories. The bit in YYY defines
	which memory is erased in Flash
	access mode.
	Bit 1=Enable
	8 Erase CFG0
	9 Erase CFG1
	10 Erase UFM0
	11 Erase UFM1
	12 Erase UFM2
	13 Erase UFM3
	14 Erase CSEC
	15 Erase USEC
	16 Erase PUBKEY
	17 Erase AESKEY
	18 Erase FEA
	19 Reserved
	commandEraseFlash = 0x0E, 0Y YY 00
	*/
	if (target.empty() \|\| target == "CFG0")
	{
	request = {commandEraseFlash, 0x00, 0x01, 0x00};
	}
	else if (target == "CFG1")
	{
	request = {commandEraseFlash, 0x00, 0x02, 0x00};
	}
	else
	{
	lg2::error("Error: unknown target.");
	co_return false;
	}
	}
	else
	{
	request = {commandEraseFlash, 0xC, 0x0, 0x0};
	}

	if (!i2cInterface.sendReceive(request, response))
	{
	lg2::error("Failed to send erase flash request.");
	co_return false;
	}

	if (!(co_await waitBusyAndVerify()))
	{
	lg2::error("Wait busy and verify fail");
	co_return false;
	}
	co_await sdbusplus::async::sleep_for(ctx, waitBusyTime);
	co_return true;
	}

	sdbusplus::async::task<bool> LatticeXO3CPLD::writeProgramPage()
	{
	/*
	Program one NVCM/Flash page. Can be
	used to program the NVCM0/CFG or
	NVCM1/UFM.
	*/
	size_t iterSize = 16;

	for (size_t i = 0; (i * iterSize) < fwInfo.cfgData.size(); i++)
	{
	size_t byteOffset = i * iterSize;
	double progressRate =
	((double(byteOffset) / double(fwInfo.cfgData.size())) * 100);
	std::cout << "Update :" << std::fixed << std::dec
	<< std::setprecision(2) << progressRate << "% \r";

	uint8_t len = ((byteOffset + iterSize) < fwInfo.cfgData.size())
	? iterSize
	: (fwInfo.cfgData.size() - byteOffset);
	auto pageData = std::vector<uint8_t>(
	fwInfo.cfgData.begin() + static_cast<std::ptrdiff_t>(byteOffset),
	fwInfo.cfgData.begin() +
	static_cast<std::ptrdiff_t>(byteOffset + len));

	size_t retry = 0;
	const size_t maxWriteRetry = 10;
	while (retry < maxWriteRetry)
	{
	if (!(co_await programSinglePage(i, pageData)))
	{
	retry++;
	continue;
	}

	if (!(co_await verifySinglePage(i, pageData)))
	{
	retry++;
	continue;
	}

	break;
	}

	if (retry >= maxWriteRetry)
	{
	lg2::error("Program and verify page failed");
	co_return false;
	}
	}

	if (!(co_await waitBusyAndVerify()))
	{
	lg2::error("Wait busy and verify fail");
	co_return false;
	}

	co_return true;
	}

	sdbusplus::async::task<bool> LatticeXO3CPLD::readUserCode(uint32_t& userCode)
	{
	constexpr size_t resSize = 4;
	std::vector<uint8_t> request = {commandReadFwVersion, 0x0, 0x0, 0x0};
	std::vector<uint8_t> response(resSize, 0);

	if (!i2cInterface.sendReceive(request, response))
	{
	lg2::error("Failed to send read user code request.");
	co_return false;
	}

	for (size_t i = 0; i < resSize; i++)
	{
	userCode \|= response.at(i) << ((3 - i) * 8);
	}
	co_return true;
	}

	sdbusplus::async::task<bool> LatticeXO3CPLD::programUserCode()
	{
	std::vector<uint8_t> request = {commandProgramUserCode, 0x0, 0x0, 0x0};
	std::vector<uint8_t> response;
	for (int i = 3; i >= 0; i--)
	{
	request.push_back((fwInfo.version >> (i * 8)) & 0xFF);
	}

	if (!i2cInterface.sendReceive(request, response))
	{
	lg2::error("Failed to send program user code request.");
	co_return false;
	}
	if (!(co_await waitBusyAndVerify()))
	{
	lg2::error("Wait busy and verify fail");
	co_return false;
	}

	co_return true;
	}

	sdbusplus::async::task<bool> LatticeXO3CPLD::prepareUpdate(const uint8_t* image,
	size_t imageSize)
	{
	if (!(co_await readDeviceId()))
	{
	co_return false;
	}

	if (!jedFileParser(image, imageSize))
	{
	lg2::error("JED file parsing failed");
	co_return false;
	}
	lg2::debug("JED file parsing success");

	if (!verifyChecksum())
	{
	lg2::error("Checksum verification failed");
	co_return false;
	}

	if (!isLCMXO3D)
	{
	lg2::error("is not LCMXO3D");
	}

	co_return true;
	}

	sdbusplus::async::task<bool> LatticeXO3CPLD::doUpdate()
	{
	co_await waitBusyAndVerify();

	if (!(co_await enableProgramMode()))
	{
	lg2::error("Enable program mode failed.");
	co_return false;
	}

	if (!(co_await eraseFlash()))
	{
	lg2::error("Erase flash failed.");
	co_return false;
	}

	if (!(co_await resetConfigFlash()))
	{
	lg2::error("Reset config flash failed.");
	co_return false;
	}

	if (!(co_await writeProgramPage()))
	{
	lg2::error("Write program page failed.");
	co_return false;
	}

	if (!(co_await programUserCode()))
	{
	lg2::error("Program user code failed.");
	co_return false;
	}

	if (!(co_await programDone()))
	{
	lg2::error("Program not done.");
	co_return false;
	}

	co_return true;
	}

	sdbusplus::async::task<bool> LatticeXO3CPLD::finishUpdate()
	{
	// NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Branch)
	if (!(co_await disableConfigInterface()))
	{
	lg2::error("Disable Config Interface failed.");
	co_return false;
	}

	co_return true;
	}

	sdbusplus::async::task<bool> LatticeXO3CPLD::programSinglePage(
	uint16_t pageOffset, std::span<const uint8_t> pageData)
	{
	// Set Page Offset
	std::vector<uint8_t> emptyResp(0);
	std::vector<uint8_t> setPageAddrCmd = {
	commandSetPageAddress, 0x0, 0x0, 0x0, 0x00, 0x00, 0x00, 0x00};
	setPageAddrCmd[6] = static_cast<uint8_t>(pageOffset >> 8); // high byte
	setPageAddrCmd[7] = static_cast<uint8_t>(pageOffset); // low byte

	// NOLINTNEXTLINE(clang-analyzer-core.uninitialized.Branch)
	bool success = co_await i2cInterface.sendReceive(
	setPageAddrCmd.data(), setPageAddrCmd.size(), nullptr, 0);
	if (!success)
	{
	lg2::error("Write page address failed");
	co_return false;
	}

	// Write Page Data
	constexpr uint8_t pageCount = 1;
	std::vector<uint8_t> writeCmd = {commandProgramPage, 0x0, 0x0, pageCount};
	writeCmd.insert(writeCmd.end(), pageData.begin(), pageData.end());

	success = co_await i2cInterface.sendReceive(writeCmd.data(),
	writeCmd.size(), nullptr, 0);
	if (!success)
	{
	lg2::error("Write page data failed");
	co_return false;
	}

	co_await sdbusplus::async::sleep_for(ctx, std::chrono::microseconds(200));

	if (!(co_await waitBusyAndVerify()))
	{
	lg2::error("Wait busy and verify fail");
	co_return false;
	}

	co_return true;
	}

	sdbusplus::async::task<bool> LatticeXO3CPLD::verifySinglePage(
	uint16_t pageOffset, std::span<const uint8_t> pageData)
	{
	// Set Page Offset
	std::vector<uint8_t> emptyResp(0);
	std::vector<uint8_t> setPageAddrCmd = {
	commandSetPageAddress, 0x0, 0x0, 0x0, 0x00, 0x00, 0x00, 0x00};
	setPageAddrCmd[6] = static_cast<uint8_t>(pageOffset >> 8); // high byte
	setPageAddrCmd[7] = static_cast<uint8_t>(pageOffset); // low byte

	if (!i2cInterface.sendReceive(setPageAddrCmd, emptyResp))
	{
	lg2::error("Write page address failed");
	co_return false;
	}

	// Read Page Data
	constexpr uint8_t pageCount = 1;
	std::vector<uint8_t> readData(pageData.size());
	std::vector<uint8_t> readCmd = {commandReadPage, 0x0, 0x0, pageCount};

	if (!i2cInterface.sendReceive(readCmd, readData))
	{
	lg2::error("Read page data failed");
	co_return false;
	}

	constexpr size_t pageSize = 16;
	auto mismatch_pair =
	std::mismatch(pageData.begin(), pageData.end(), readData.begin());
	if (mismatch_pair.first != pageData.end())
	{
	size_t idx = std::distance(pageData.begin(), mismatch_pair.first);
	lg2::error("Verify failed at {INDEX}", "INDEX",
	((static_cast<size_t>(pageSize * pageOffset)) + idx));
	co_return false;
	}

	co_return true;
	}

	} // namespace phosphor::software::cpld