Merge branch 'sk/quectel-delta-fwu' into 'delta-radio-fwu'

Quectel Delta Radio Firmware Upgrade support - libmts-io implementation

See merge request !26

1 files changed, 502 insertions, 18 deletions

diff --git a/src/MTS_IO_QuectelRadio.cpp b/src/MTS_IO_QuectelRadio.cpp
index 5c2c352..7aeed96 100644
--- a/src/MTS_IO_QuectelRadio.cpp
+++ b/src/MTS_IO_QuectelRadio.cpp
@@ -25,9 +25,19 @@
 #include <mts/MTS_Logger.h>
 #include <mts/MTS_Thread.h>
 #include <mts/MTS_Text.h>
+#include <mts/MTS_Timer.h>
+
+#include <unistd.h>
 
 using namespace MTS::IO;
 
+const size_t QuectelRadio::FILE_CHUNK_SIZE = 1024;
+const std::string QuectelRadio::CMD_ABORT_UPLOAD = "+++";
+
+// It is strongly recommended to use DOS 8.3 file name format for <filename>.
+const std::string QuectelRadio::VALUE_MTS_DELTA_NAME = "mtsdelta.zip";
+const std::string QuectelRadio::VALUE_MTS_DELTA_PATH =  "/data/ufs/" + QuectelRadio::VALUE_MTS_DELTA_NAME;
+
 QuectelRadio::QuectelRadio(const std::string& sName, const std::string& sRadioPort)
 : CellularRadio (sName, sRadioPort)
 {
@@ -466,9 +476,7 @@ ICellularRadio::CODE QuectelRadio::startOmaDm(ICellularRadio::UpdateCb& stepCb)
         eCode = sendBasicCommand(sCmdOdmStart, iTimeoutOk);
         if (eCode != SUCCESS) {
             printError("%s| OMA DM procedure can not be started", getName().c_str());
-            if (stepCb) {
-                stepCb(Json::Value("OMA DM Error: OMA DM can not be started"));
-            }
+            callNextStep(stepCb, "OMA DM Error: OMA DM can not be started");
             break;
         }
 
@@ -479,18 +487,14 @@ ICellularRadio::CODE QuectelRadio::startOmaDm(ICellularRadio::UpdateCb& stepCb)
         // Received something unexpected or nothing at all?
         if (sResponse.find(sOdmStarted) == std::string::npos) {
             printError("%s| OMA DM procedure failed due to timeout", getName().c_str());
-            if (stepCb) {
-                stepCb(Json::Value("OMA DM Error: OMA DM failed due to timeout"));
-            }
+            callNextStep(stepCb, "OMA DM Error: OMA DM failed due to timeout");
             eCode = FAILURE;
             break;
         }
 
         // Got "DM Started" message from the radio
         printTrace("%s| OMA DM started", getName().c_str());
-        if (stepCb) {
-            stepCb(Json::Value("OMA DM Info: OMA DM started"));
-        }
+        callNextStep(stepCb, "OMA DM Info: OMA DM started");
 
         // Wait for the "End" or "Abnormal" response
         sResponse = sendCommand("", vOdmFinishedStrings, iTimeoutEnd, 0x00);
@@ -499,9 +503,8 @@ ICellularRadio::CODE QuectelRadio::startOmaDm(ICellularRadio::UpdateCb& stepCb)
         // Received "Abnormal"?
         if (sResponse.find(sOdmAbnormal) != std::string::npos) {
             printError("%s| OMA DM procedure failed due to internal error: [%s]", getName().c_str(), sResponse.c_str());
-            if (stepCb) {
-                stepCb(Json::Value("OMA DM Error: OMA DM failed due to internal error"));
-            }
+            callNextStep(stepCb, "OMA DM Error: OMA DM failed due to internal error");
+
             eCode = FAILURE;
             break;
         }
@@ -509,9 +512,8 @@ ICellularRadio::CODE QuectelRadio::startOmaDm(ICellularRadio::UpdateCb& stepCb)
         // Received something unexpected or nothing at all?
         if (sResponse.find(sOdmFinished) == std::string::npos) {
             printError("%s| OMA DM procedure failed due to timeout", getName().c_str());
-            if (stepCb) {
-                stepCb(Json::Value("OMA DM Error: OMA DM failed due to timeout"));
-            }
+            callNextStep(stepCb, "OMA DM Error: OMA DM failed due to timeout");
+
             sendBasicCommand(sCmdOdmAbort, iTimeoutAbort);  // abort the procedure
             eCode = FAILURE;
             break;
@@ -519,9 +521,7 @@ ICellularRadio::CODE QuectelRadio::startOmaDm(ICellularRadio::UpdateCb& stepCb)
 
         // Got "DM End" message from the radio
         printTrace("%s| OMA DM finished", getName().c_str());
-        if (stepCb) {
-            stepCb(Json::Value("OMA DM Info: OMA DM finished"));
-        }
+        callNextStep(stepCb, "OMA DM Info: OMA DM finished");
 
         eCode = SUCCESS;
 
@@ -530,6 +530,143 @@ ICellularRadio::CODE QuectelRadio::startOmaDm(ICellularRadio::UpdateCb& stepCb)
     return eCode;
 }
 
+ICellularRadio::CODE QuectelRadio::updateFumoLocal(int fd, ICellularRadio::UpdateCb& stepCb) {
+    CODE rc;
+
+    rc = fumoLocalInject(fd, stepCb);
+    if (rc != SUCCESS) {
+        return rc;
+    }
+
+    rc = fumoLocalApply(stepCb);
+    (void)fumoLocalCleanup();  // try to cleanup the injected file but cleanup errors are not fatal
+
+    return rc;
+}
+
+ICellularRadio::CODE QuectelRadio::fumoLocalInject(int fd, ICellularRadio::UpdateCb& stepCb) {
+    CODE rc = FAILURE;
+    bool bIsFilePresent = false;
+
+    do {
+        callNextStep(stepCb, "FUMO Info: downloading the firmware");
+
+        rc = checkFile(bIsFilePresent, VALUE_MTS_DELTA_NAME);
+        if (rc != SUCCESS) {
+            printError("Failed to check if the delta file was already download.");
+            callNextStep(stepCb, "FUMO Error: failed to download the firmware file");
+            break;
+        }
+
+        if (bIsFilePresent) {
+            rc = fumoLocalCleanup();
+        }
+
+        if (rc != SUCCESS) {
+            printError("Failed to remove the previous delta file.");
+            callNextStep(stepCb, "FUMO Error: failed to download the firmware file");
+            break;
+        }
+
+        rc = uploadFile(fd, VALUE_MTS_DELTA_NAME, stepCb);
+        if (rc != SUCCESS) {
+            printError("Failed to inject the delta file.");
+            callNextStep(stepCb, "FUMO Error: failed to download the firmware file");
+            break;
+        }
+
+        callNextStep(stepCb, "FUMO Info: firmware downloaded successfully");
+
+    } while (false);
+
+    return rc;
+}
+
+ICellularRadio::CODE QuectelRadio::fumoLocalCleanup() {
+    printTrace("Removing the delta upgrade file: %s", VALUE_MTS_DELTA_NAME.c_str());
+    return removeFile(VALUE_MTS_DELTA_NAME);
+}
+
+ICellularRadio::CODE QuectelRadio::fumoLocalApply(ICellularRadio::UpdateCb& stepCb) {
+    ICellularRadio::CODE rc;
+    std::string sCmd;
+
+    rc = getQuectelFirmware(m_sQuectelFirmware);
+    if (rc != SUCCESS) {
+        callNextStep(stepCb, "FUMO Error: Failed to obtain current firmware version");
+        return rc;
+    }
+    printInfo("Current firmware version: %s", m_sQuectelFirmware.c_str());
+
+    // Send "AT+QFOTADL" command to start the upgrade. OK response follows shortly.
+    sCmd  = "AT+QFOTADL=\"";
+    sCmd += VALUE_MTS_DELTA_PATH;
+    sCmd += "\"";
+
+    rc = sendBasicCommand(sCmd, 1000);
+
+    if (rc != SUCCESS) {
+        printError("FUMO failed, OK not received from the radio");
+        callNextStep(stepCb, "FUMO Error: failed to apply the firmware");
+        return rc;
+    }
+
+    const uint32_t duDetachTimeout = 10000;  // wait for 10 seconds for the radio to detach
+    const uint32_t duAttachTimeout = 30000;  // wait for 30 seconds for the radio to attach
+    const int dMaxAttempts = 5;  // the radio makes 5 attempts to update the firmware
+
+    for (int i = 0; i < dMaxAttempts; i++) {
+
+        printInfo("Waiting for the radio to enter recovery mode");
+        callNextStep(stepCb, "FUMO Info: waiting for the radio to enter recovery mode");
+
+        // Wait for the radio to detach from the USB bus
+        MTS::Thread::sleep(duDetachTimeout);
+
+        // It's now detached. Try to reconnect
+        if (!resetConnection(duAttachTimeout)) {
+            printError("Can't connect to the radio in %d ms", (duAttachTimeout));
+            callNextStep(stepCb, "FUMO Error: unable to obtain radio after reset");
+            break;
+        }
+
+        // It's now back on the bus. Wait for the URC messages.
+        printInfo("Applying the radio firmware");
+        callNextStep(stepCb, "FUMO Info: applying the radio firmware");
+        rc = fumoWaitUpgradeFinished(stepCb);
+
+        if (rc == ERROR) {
+            // unrecoverable error
+            callNextStep(stepCb, "FUMO Error: failed to apply the firmware, consider radio reset");
+            break;
+        }
+
+        if (rc != SUCCESS) {
+            // attempt failed, radio reboots and starts its next attempt
+            printError("Failed to apply the firmware, attempts left: %d", (dMaxAttempts - i - 1));
+            callNextStep(stepCb, "FUMO Error: failed to apply the firmware");
+            continue;
+        }
+
+        // Wait for the radio to finish update and reboot
+        printTrace("Waiting for the radio to come up");
+        callNextStep(stepCb, "FUMO Info: waiting for the radio to enter normal mode");
+
+        rc = fumoWaitNewFirmware(stepCb);
+        break;
+    }
+
+    if (rc == SUCCESS) {
+        printInfo("Radio firmware applied successfully");
+        callNextStep(stepCb, "FUMO Done: radio firmware applied successfully");
+    } else {
+        printError("Radio firmware has not been updated");
+        callNextStep(stepCb, "FUMO Error: radio firmware has not been updated");
+    }
+
+    return rc;
+}
+
 ICellularRadio::CODE QuectelRadio::getServiceDomain(ICellularRadio::SERVICEDOMAIN& sd) {
     printTrace("%s| Get Service Domain", getName().c_str());
 
@@ -694,3 +831,350 @@ ICellularRadio::CODE QuectelRadio::setCellularMode(CELLULAR_MODES networks) {
     }
     return SUCCESS;
 }
+
+ICellularRadio::CODE QuectelRadio::uploadFile(int fd, const std::string& sTargetFilename, ICellularRadio::UpdateCb& stepCb) {
+    size_t dPayloadLenght;
+    size_t nChunks;
+    CODE rc;
+
+    rc = getFileSize(fd, dPayloadLenght, nChunks);
+    if (rc != SUCCESS) {
+        return rc;
+    }
+    printTrace("File size: %d bytes and %d chunks", dPayloadLenght, nChunks);
+    printTrace("Starting file upload...");
+
+    rc = startFileUpload(sTargetFilename, dPayloadLenght);
+    if (rc != SUCCESS) {
+        return rc;
+    }
+
+    printTrace("File upload started.");
+    callNextStep(stepCb, "FILE Info: Started file upload for " + sTargetFilename);
+
+    uint16_t dChecksum = 0;
+    size_t nChunksPerCent = (nChunks / 100) + 1;
+    size_t nFragmentLenght = 0;
+    std::array<char, FILE_CHUNK_SIZE> vBuffer;
+
+    for (size_t iChunk = 1; iChunk < (nChunks + 1); iChunk++) {
+
+        rc = readChunk(fd, vBuffer.data(), vBuffer.size(), nFragmentLenght);
+        if (rc != SUCCESS) {
+            break;
+        }
+
+        // we got our fragment, calculate checksum and flush the data
+        uint16_t dFragmentChecksum = getQuectelChecksum(vBuffer.data(), nFragmentLenght);
+        updateQuectelChecksum(dChecksum, dFragmentChecksum);
+
+        rc = sendData(vBuffer.data(), nFragmentLenght);
+        if (rc != SUCCESS) {
+            break;
+        }
+
+        if (stepCb && ((iChunk % nChunksPerCent) == 0)) {
+            size_t dPercentsCompleted = iChunk / nChunksPerCent;
+            callNextStep(stepCb, "FILE Info: Uploaded " + MTS::Text::format(dPercentsCompleted) + "%");
+        }
+
+    }
+
+    if (rc != SUCCESS) {
+        // cancel upload and terminate
+        callNextStep(stepCb, "FILE Error: Upload failed due to internal error");
+        abortFileUpload();
+        return rc;
+    }
+
+    printTrace("Waiting for acknoledge from the radio");
+    std::string sExpectedResult = "+QFUPL: ";
+    sExpectedResult += MTS::Text::format(dPayloadLenght);
+    sExpectedResult += ",";
+    sExpectedResult += MTS::Text::toLowerCase(MTS::Text::formatHex(dChecksum));
+
+    // "send" empty string to read acknoledge string
+    std::string sResult = sendCommand("", DEFAULT_BAIL_STRINGS, 3000, 0x00);
+
+    if (sResult.find(sExpectedResult) != std::string::npos) {
+        printDebug("Radio returned: [%s]", sResult.c_str());
+        printTrace("Upload finished, checksum matched");
+    } else {
+        printError("Upload failed: checksum mismatch. Expected: [%s], Actual: [%s]", sExpectedResult.c_str(), sResult.c_str());
+        abortFileUpload();
+        rc = FAILURE;
+    }
+
+    if (rc == SUCCESS) {
+        callNextStep(stepCb, "FILE Info: Upload finished successfully");
+    } else {
+        callNextStep(stepCb, "FILE Error: Upload failed due to internal error");
+    }
+
+    return rc;
+}
+
+ICellularRadio::CODE QuectelRadio::removeFile(const std::string& sTargetFilename) {
+    printTrace("Removing file [%s] from the radio memory", sTargetFilename.c_str());
+
+    const int dTimeout = 1000; //ms
+    const std::string sCmd = "AT+QFDEL=\"" + sTargetFilename + "\"";
+
+    std::string sResult = sendCommand(sCmd, ICellularRadio::DEFAULT_BAIL_STRINGS, dTimeout);
+    if (sResult.find(ICellularRadio::RSP_OK) == std::string::npos) {
+        printError("Failed to remove file [%s]: [%s]", sTargetFilename.c_str(), sResult.c_str());
+        return FAILURE;
+    }
+
+    printTrace("File [%s] removed", sTargetFilename.c_str());
+    return SUCCESS;
+}
+
+ICellularRadio::CODE QuectelRadio::checkFile(bool& bIsFilePresent, const std::string& sTargetFilename) {
+    printTrace("Checking status of the [%s] file", sTargetFilename.c_str());
+
+    const int dTimeout = 1000; //ms
+    const std::string sCmd = "AT+QFLST";  // list all files in the UFS memory
+
+    std::string sResult = sendCommand(sCmd, ICellularRadio::DEFAULT_BAIL_STRINGS, dTimeout);
+    if (sResult.rfind(ICellularRadio::RSP_OK) == std::string::npos) {
+        printError("Unable to list files from the radio memory: [%s]", sResult.c_str());
+        return FAILURE;
+    }
+
+    const std::string sExpected = "+QFLST: \"UFS:" + sTargetFilename + "\"";
+    bIsFilePresent = (sResult.find(sExpected) != std::string::npos);
+
+    return SUCCESS;
+}
+
+ICellularRadio::CODE QuectelRadio::getQuectelFirmware(std::string& sFirmware) {
+    printTrace("%s| Get Quectel-specific firmware version", getName().c_str());
+    sFirmware = ICellularRadio::VALUE_NOT_SUPPORTED;
+    std::string sCmd("AT+QGMR");
+    std::string sResult = sendCommand(sCmd);
+    size_t pos = sResult.find(ICellularRadio::RSP_OK);
+    if (pos == std::string::npos) {
+        printWarning("%s| Unable to get firmware from radio using command [%s]", getName().c_str(), sCmd.c_str());
+        return FAILURE;
+    }
+
+    sFirmware = MTS::Text::trim(sResult.substr(0, pos));
+    if(sFirmware.size() == 0) {
+        printWarning("%s| Unable to get firmware from radio using command [%s]", getName().c_str(), sCmd.c_str());
+        return FAILURE;
+    }
+
+    return SUCCESS;
+}
+
+uint16_t QuectelRadio::getQuectelChecksum(const void* data, size_t nBytes) {
+    auto castData = static_cast<const uint8_t*>(data);
+    uint16_t iChecksum = 0;
+
+    for (size_t i = 0; i < nBytes; i += 2) {
+        // If the number of the characters is odd, set the last character as the high 8 bit, and the low 8 bit as 0,
+        // and then use an XOR operator to calculate the checksum.
+        uint8_t high = castData[i];
+        uint8_t low = (i < nBytes) ? (castData[i+1]) : (0);
+
+        uint16_t iFragment = bytesToUint16(high, low);
+        updateQuectelChecksum(iChecksum, iFragment);
+    }
+
+    return iChecksum;
+}
+
+ICellularRadio::CODE QuectelRadio::getFileSize(int fd, size_t& nBytes, size_t& nChunks) {
+    CODE rc = FAILURE;
+
+    do {
+        ssize_t dScrollPos;
+        dScrollPos = lseek(fd, 0, SEEK_SET);
+        if (dScrollPos < 0) {
+            printError("Failed to seek to the start of the file: %d", errno);
+            break;
+        }
+
+        dScrollPos = lseek(fd, 0, SEEK_END);
+        if (dScrollPos < 0) {
+            printError("Failed to determine the file size: %d", errno);
+            break;
+        }
+
+        nBytes = static_cast<size_t>(dScrollPos);
+        nChunks = (nBytes + FILE_CHUNK_SIZE - 1) / FILE_CHUNK_SIZE;  // round up
+
+        rc = SUCCESS;
+
+    } while (false);
+
+    lseek(fd, 0, SEEK_SET);
+    return rc;
+}
+
+ICellularRadio::CODE QuectelRadio::readChunk(int fd, char* pChunk, size_t dChunkSize, size_t& nReadBytes) {
+    size_t nUsedBuffer = 0;
+    CODE rc = FAILURE;
+
+    while (true) {
+
+        if (nUsedBuffer > dChunkSize) {
+            printError("Internal pointer error, abort upload: %d", nUsedBuffer);
+            rc = ERROR;
+            break;
+        }
+
+        if (nUsedBuffer == dChunkSize) {
+            // full chunk received
+            rc = SUCCESS;
+            nReadBytes = dChunkSize;
+            break;
+        }
+
+        char* pData = pChunk + nUsedBuffer;
+        size_t nFreeBuffer = dChunkSize - nUsedBuffer;
+
+        ssize_t dReadCount = read(fd, pData, nFreeBuffer);
+        if (dReadCount < 0) {
+            printError("Failed to read from the source file: %d", errno);
+            rc = ERROR;
+            break;
+        }
+
+        size_t duReadCount = static_cast<size_t>(dReadCount);
+        if (duReadCount == 0) {
+            // EOF. Return what was already read
+            nReadBytes = nUsedBuffer;
+            rc = SUCCESS;
+            break;
+        }
+
+        nUsedBuffer += duReadCount;
+
+    }
+
+    return rc;
+}
+
+ICellularRadio::CODE QuectelRadio::fumoWaitUpgradeFinished(ICellularRadio::UpdateCb& stepCb) {
+    const uint32_t duUrcTimeout = 4 * 60 * 1000;  // wait for 4 minutes for the next URC message
+    const std::string sFotaUrcPrefix = "+QIND: \"FOTA\"";  // prefix for the URC notification messages
+    const std::string sFotaUrcStart = "\"START\"";
+    const std::string sFotaUrcProgress = "\"UPDATING\"";
+    const std::string sFotaUrcEnd = "\"END\"";
+    const std::vector<std::string> vFotaBailStrings{ sFotaUrcPrefix };
+
+    CODE rc = FAILURE;
+    std::string sResponse;
+
+    while (true) {  // breaks on "FOTA","END"
+        sResponse = sendCommand("", vFotaBailStrings, duUrcTimeout, 0x00);
+        printTrace("Radio response: [%s]", sResponse.c_str());
+
+        if (sResponse.find(sFotaUrcPrefix) == std::string::npos) {
+            printError("No URC messages from the radio in %d ms", duUrcTimeout);
+            callNextStep(stepCb, "FUMO error: timeout, radio is not responding");
+            rc = ERROR;
+            break;
+        }
+
+        const auto vParts = MTS::Text::split(MTS::Text::trim(sResponse), ',', 3);
+        const std::string& sStage = vParts[1];
+        if (sStage == sFotaUrcEnd) {
+            // FOTA finished
+            printTrace("Got FOTA END message");
+            const std::string& sCode = vParts[2];
+
+            if (sCode == "0") {
+                // finished successfully
+                rc = SUCCESS;
+                break;
+            }
+            // attempt failed, the radio attempts to recover
+            callNextStep(stepCb, "FUMO Error: radio returned error code " + sCode);
+            break;
+        } else if (sStage == sFotaUrcStart) {
+            printTrace("Got FOTA START message");
+        } else if (sStage == sFotaUrcProgress) {
+            printTrace("Got FOTA progress message");
+            const std::string& sPercents = vParts[2];
+            printInfo("FOTA progress: [%s]", sPercents.c_str());
+            callNextStep(stepCb, "FUMO Info: firmware apply progress " + sPercents);
+        } else {
+            printInfo("FOTA unexpected URC code: [%s]", sStage.c_str());
+        }
+    }
+
+    return rc;
+}
+
+ICellularRadio::CODE QuectelRadio::fumoWaitNewFirmware(ICellularRadio::UpdateCb& stepCb) {
+    MTS::Timer oTimer;
+    oTimer.start();
+    std::string sQuectelFirmware;
+    CODE rc = ERROR;
+
+    while (oTimer.getSeconds() < (5 * 60)) { // 5 minutes
+
+        MTS::Thread::sleep(10000);
+
+        if (getQuectelFirmware(sQuectelFirmware) != SUCCESS) {
+            // The radio is probably unavailable
+            resetConnection(100);
+            continue;
+        }
+
+        printInfo("Firmware version before the upgrade: %s", m_sQuectelFirmware.c_str());
+        printInfo("Current firmware version: %s", sQuectelFirmware.c_str());
+
+        if (sQuectelFirmware == m_sQuectelFirmware) {
+            // Radio will not reset anymore, firmware version left the same, not updated
+            printError("Radio firmware version not changed after upgrade");
+            rc = FAILURE;
+            break;
+        }
+
+        // The firmware numbers have changed
+        rc = SUCCESS;
+        break;
+    }
+    oTimer.stop();
+
+    if (rc == ERROR) {
+        printError("Radio is not responding");
+        callNextStep(stepCb, "FUMO Error: unable to obtain radio after reset");
+    }
+
+    return rc;
+}
+
+ICellularRadio::CODE QuectelRadio::startFileUpload(const std::string& sTargetFilename, size_t nBytes) {
+    const std::vector<std::string> vBailStrings{ ICellularRadio::RSP_CONNECT, ICellularRadio::RSP_ERROR };
+    const int dTimeout = 1000; //ms
+    std::string sCommand, sResult;
+
+    sCommand = "AT+QFUPL=\"";
+    sCommand += sTargetFilename;
+    sCommand += "\",";
+    sCommand += MTS::Text::format(nBytes);
+
+    sResult = sendCommand(sCommand, vBailStrings, dTimeout);
+    if (sResult.find(ICellularRadio::RSP_CONNECT) == std::string::npos) {
+        printError("Radio is not ready to accept the file: [%s]", sResult.c_str());
+        return FAILURE;
+    }
+
+    return SUCCESS;
+}
+
+ICellularRadio::CODE QuectelRadio::abortFileUpload() {
+    /*
+     * To prevent the “+++” from being mistaken for data, the following sequence should be followed:
+     * 1) Do not input any character within 1s or longer before inputting “+++”.
+     * 2) Input “+++” within 1s, and no other characters can be inputted during the time.
+     * 3) Do not input any character within 1s after “+++” has been inputted.
+     */
+    sleep(1);
+    return sendBasicCommand(CMD_ABORT_UPLOAD, 2000);
+}