| /* |
| * |
| * Copyright (c) 2021 Project CHIP Authors |
| * All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <app/clusters/ota-requestor/OTADownloader.h> |
| #include <app/clusters/ota-requestor/OTARequestorInterface.h> |
| #include <lib/support/logging/CHIPLogging.h> |
| |
| #include <platform/Ameba/AmebaOTAImageProcessor.h> |
| |
| #if defined(CONFIG_PLATFORM_8710C) |
| static flash_t flash_ota; |
| #endif |
| |
| namespace chip { |
| |
| CHIP_ERROR AmebaOTAImageProcessor::PrepareDownload() |
| { |
| ChipLogProgress(SoftwareUpdate, "Prepare download"); |
| |
| DeviceLayer::PlatformMgr().ScheduleWork(HandlePrepareDownload, reinterpret_cast<intptr_t>(this)); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR AmebaOTAImageProcessor::Finalize() |
| { |
| ChipLogProgress(SoftwareUpdate, "Finalize"); |
| |
| DeviceLayer::PlatformMgr().ScheduleWork(HandleFinalize, reinterpret_cast<intptr_t>(this)); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR AmebaOTAImageProcessor::Apply() |
| { |
| ChipLogProgress(SoftwareUpdate, "Apply"); |
| |
| DeviceLayer::PlatformMgr().ScheduleWork(HandleApply, reinterpret_cast<intptr_t>(this)); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR AmebaOTAImageProcessor::Abort() |
| { |
| ChipLogProgress(SoftwareUpdate, "Abort"); |
| |
| DeviceLayer::PlatformMgr().ScheduleWork(HandleAbort, reinterpret_cast<intptr_t>(this)); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR AmebaOTAImageProcessor::ProcessBlock(ByteSpan & block) |
| { |
| ChipLogProgress(SoftwareUpdate, "Process Block"); |
| |
| if ((block.data() == nullptr) || block.empty()) |
| { |
| return CHIP_ERROR_INVALID_ARGUMENT; |
| } |
| CHIP_ERROR err = SetBlock(block); |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(SoftwareUpdate, "Cannot set block data: %" CHIP_ERROR_FORMAT, err.Format()); |
| return err; |
| } |
| |
| DeviceLayer::PlatformMgr().ScheduleWork(HandleProcessBlock, reinterpret_cast<intptr_t>(this)); |
| return CHIP_NO_ERROR; |
| } |
| |
| bool AmebaOTAImageProcessor::IsFirstImageRun() |
| { |
| OTARequestorInterface * requestor = chip::GetRequestorInstance(); |
| if (requestor == nullptr) |
| { |
| return false; |
| } |
| |
| return requestor->GetCurrentUpdateState() == OTARequestorInterface::OTAUpdateStateEnum::kApplying; |
| } |
| |
| CHIP_ERROR AmebaOTAImageProcessor::ConfirmCurrentImage() |
| { |
| OTARequestorInterface * requestor = chip::GetRequestorInstance(); |
| if (requestor == nullptr) |
| { |
| return CHIP_ERROR_INTERNAL; |
| } |
| |
| uint32_t currentVersion; |
| uint32_t targetVersion = requestor->GetTargetVersion(); |
| ReturnErrorOnFailure(DeviceLayer::ConfigurationMgr().GetSoftwareVersion(currentVersion)); |
| if (currentVersion != targetVersion) |
| { |
| ChipLogError(SoftwareUpdate, "Current software version = %" PRIu32 ", expected software version = %" PRIu32, currentVersion, |
| targetVersion); |
| return CHIP_ERROR_INCORRECT_STATE; |
| } |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| void AmebaOTAImageProcessor::HandlePrepareDownload(intptr_t context) |
| { |
| auto * imageProcessor = reinterpret_cast<AmebaOTAImageProcessor *>(context); |
| if (imageProcessor == nullptr) |
| { |
| ChipLogError(SoftwareUpdate, "ImageProcessor context is null"); |
| return; |
| } |
| else if (imageProcessor->mDownloader == nullptr) |
| { |
| ChipLogError(SoftwareUpdate, "mDownloader is null"); |
| return; |
| } |
| |
| imageProcessor->mHeaderParser.Init(); |
| |
| // Get OTA update partition |
| #if defined(CONFIG_PLATFORM_8721D) |
| if (ota_get_cur_index() == OTA_INDEX_1) |
| imageProcessor->ota_target_index = OTA_INDEX_2; |
| else if (ota_get_cur_index() == OTA_INDEX_2) |
| imageProcessor->ota_target_index = OTA_INDEX_1; |
| ChipLogProgress(SoftwareUpdate, "OTA%d address space will be upgraded", imageProcessor->ota_target_index + 1); |
| #elif defined(CONFIG_PLATFORM_8710C) |
| imageProcessor->flash_addr = sys_update_ota_prepare_addr(); |
| ChipLogProgress(SoftwareUpdate, "New Flash Address: 0x%X", imageProcessor->flash_addr); |
| #endif |
| |
| imageProcessor->mDownloader->OnPreparedForDownload(CHIP_NO_ERROR); |
| } |
| |
| void AmebaOTAImageProcessor::HandleFinalize(intptr_t context) |
| { |
| auto * imageProcessor = reinterpret_cast<AmebaOTAImageProcessor *>(context); |
| if (imageProcessor == nullptr) |
| { |
| ChipLogError(SoftwareUpdate, "ImageProcessor context is null"); |
| return; |
| } |
| |
| // Verify checksum |
| #if defined(CONFIG_PLATFORM_8721D) |
| if (verify_ota_checksum(imageProcessor->pOtaTgtHdr) != 1) |
| { |
| ota_update_free(imageProcessor->pOtaTgtHdr); |
| ChipLogError(SoftwareUpdate, "OTA checksum verification failed"); |
| return; |
| } |
| #endif |
| |
| imageProcessor->ReleaseBlock(); |
| |
| ChipLogProgress(SoftwareUpdate, "OTA image downloaded and written to flash"); |
| } |
| |
| void AmebaOTAImageProcessor::HandleAbort(intptr_t context) |
| { |
| auto * imageProcessor = reinterpret_cast<AmebaOTAImageProcessor *>(context); |
| if (imageProcessor == nullptr) |
| { |
| ChipLogError(SoftwareUpdate, "ImageProcessor context is null"); |
| return; |
| } |
| |
| // Abort OTA procedure |
| #if defined(CONFIG_PLATFORM_8721D) |
| ChipLogProgress(SoftwareUpdate, "Erasing target partition..."); |
| erase_ota_target_flash(imageProcessor->pOtaTgtHdr->FileImgHdr[0].FlashAddr, imageProcessor->pOtaTgtHdr->FileImgHdr[0].ImgLen); |
| ChipLogProgress(SoftwareUpdate, "Erased partition OTA%d", imageProcessor->ota_target_index + 1); |
| #elif defined(CONFIG_PLATFORM_8710C) |
| ChipLogProgress(SoftwareUpdate, "Erasing partition"); |
| imageProcessor->NewFWBlkSize = ((0x1AC000 - 1) / 4096) + 1; // Use a fixed image length of 0x1AC000, change in the future |
| ChipLogProgress(SoftwareUpdate, "Erasing %d sectors", imageProcessor->NewFWBlkSize); |
| device_mutex_lock(RT_DEV_LOCK_FLASH); |
| for (int i = 0; i < imageProcessor->NewFWBlkSize; i++) |
| flash_erase_sector(&flash_ota, imageProcessor->flash_addr + i * 4096); |
| device_mutex_unlock(RT_DEV_LOCK_FLASH); |
| #endif |
| |
| #if defined(CONFIG_PLATFORM_8721D) |
| ota_update_free(imageProcessor->pOtaTgtHdr); |
| #endif |
| |
| imageProcessor->ReleaseBlock(); |
| } |
| |
| void AmebaOTAImageProcessor::HandleProcessBlock(intptr_t context) |
| { |
| auto * imageProcessor = reinterpret_cast<AmebaOTAImageProcessor *>(context); |
| if (imageProcessor == nullptr) |
| { |
| ChipLogError(SoftwareUpdate, "ImageProcessor context is null"); |
| return; |
| } |
| else if (imageProcessor->mDownloader == nullptr) |
| { |
| ChipLogError(SoftwareUpdate, "mDownloader is null"); |
| return; |
| } |
| |
| ByteSpan block = imageProcessor->mBlock; |
| CHIP_ERROR error = imageProcessor->ProcessHeader(block); |
| uint8_t HeaderOffset = 32 - imageProcessor->RemainHeader; |
| |
| #if defined(CONFIG_PLATFORM_8721D) |
| if (imageProcessor->RemainHeader != 0) // Still not yet received full ameba header |
| { |
| if (block.size() >= imageProcessor->RemainHeader) |
| { |
| memcpy(imageProcessor->AmebaHeader + HeaderOffset, block.data(), imageProcessor->RemainHeader); |
| imageProcessor->pOtaTgtHdr = (update_ota_target_hdr *) ota_update_malloc(sizeof(update_ota_target_hdr)); |
| |
| memcpy(imageProcessor->pOtaTgtHdr, imageProcessor->AmebaHeader, 8); // Store FwVer, HdrNum |
| memcpy(&(imageProcessor->pOtaTgtHdr->FileImgHdr[0].ImgId), imageProcessor->AmebaHeader + 8, 4); // Store OTA id |
| memcpy(&(imageProcessor->pOtaTgtHdr->FileImgHdr[0].ImgHdrLen), imageProcessor->AmebaHeader + 12, |
| 16); // Store ImgHdrLen, Checksum, ImgLen, Offset |
| |
| if (imageProcessor->ota_target_index == OTA_INDEX_1) |
| imageProcessor->pOtaTgtHdr->FileImgHdr[0].FlashAddr = LS_IMG2_OTA1_ADDR; |
| else if (imageProcessor->ota_target_index == OTA_INDEX_2) |
| imageProcessor->pOtaTgtHdr->FileImgHdr[0].FlashAddr = LS_IMG2_OTA2_ADDR; |
| |
| imageProcessor->pOtaTgtHdr->ValidImgCnt = 1; |
| |
| if (strncmp("OTA", (const char *) &(imageProcessor->pOtaTgtHdr->FileImgHdr[0].ImgId), 3) != 0) |
| { |
| ota_update_free(imageProcessor->pOtaTgtHdr); |
| ChipLogError(SoftwareUpdate, "Wrong Image ID for OTA"); |
| return; |
| } |
| |
| ChipLogProgress(SoftwareUpdate, "Correct OTA Image ID, get firmware header success"); |
| ChipLogProgress(SoftwareUpdate, "FwVer: 0x%X", imageProcessor->pOtaTgtHdr->FileHdr.FwVer); |
| ChipLogProgress(SoftwareUpdate, "HdrNum: 0x%X", imageProcessor->pOtaTgtHdr->FileHdr.HdrNum); |
| ChipLogProgress(SoftwareUpdate, "ImgHdrLen: 0x%X", imageProcessor->pOtaTgtHdr->FileImgHdr[0].ImgHdrLen); |
| ChipLogProgress(SoftwareUpdate, "Checksum: 0x%X", imageProcessor->pOtaTgtHdr->FileImgHdr[0].Checksum); |
| ChipLogProgress(SoftwareUpdate, "ImgLen: 0x%X", imageProcessor->pOtaTgtHdr->FileImgHdr[0].ImgLen); |
| ChipLogProgress(SoftwareUpdate, "Offset: 0x%X", imageProcessor->pOtaTgtHdr->FileImgHdr[0].Offset); |
| ChipLogProgress(SoftwareUpdate, "FlashAddr: 0x%X", imageProcessor->pOtaTgtHdr->FileImgHdr[0].FlashAddr); |
| |
| // Erase update partition |
| ChipLogProgress(SoftwareUpdate, "Erasing target partition..."); |
| erase_ota_target_flash(imageProcessor->pOtaTgtHdr->FileImgHdr[0].FlashAddr, |
| imageProcessor->pOtaTgtHdr->FileImgHdr[0].ImgLen); |
| ChipLogProgress(SoftwareUpdate, "Erased partition OTA%d", imageProcessor->ota_target_index + 1); |
| |
| // Set RemainBytes to image length, excluding 8bytes of signature |
| imageProcessor->RemainBytes = imageProcessor->pOtaTgtHdr->FileImgHdr[0].ImgLen - 8; |
| |
| // Set flash address, incremented by 8bytes to account for signature |
| imageProcessor->flash_addr = imageProcessor->pOtaTgtHdr->FileImgHdr[0].FlashAddr - SPI_FLASH_BASE + 8; |
| |
| // Set signature to point to pOtaTgtHdr->Sign |
| imageProcessor->signature = &(imageProcessor->pOtaTgtHdr->Sign[0][0]); |
| |
| // Store the signature temporarily |
| uint8_t * tempbufptr = const_cast<uint8_t *>(block.data() + imageProcessor->pOtaTgtHdr->FileImgHdr[0].Offset); |
| memcpy(imageProcessor->signature, tempbufptr, 8); |
| tempbufptr += 8; |
| |
| // Write remaining downloaded bytes to flash_addr |
| uint32_t tempsize = block.size() - imageProcessor->pOtaTgtHdr->FileImgHdr[0].Offset - 8; |
| device_mutex_lock(RT_DEV_LOCK_FLASH); |
| if (ota_writestream_user(imageProcessor->flash_addr + imageProcessor->size, tempsize, tempbufptr) < 0) |
| { |
| ChipLogError(SoftwareUpdate, "Write to flash failed"); |
| device_mutex_unlock(RT_DEV_LOCK_FLASH); |
| imageProcessor->mDownloader->EndDownload(CHIP_ERROR_WRITE_FAILED); |
| return; |
| } |
| device_mutex_unlock(RT_DEV_LOCK_FLASH); |
| |
| imageProcessor->RemainHeader = 0; |
| imageProcessor->size += tempsize; |
| imageProcessor->RemainBytes -= tempsize; |
| } |
| else // block.size < imageProcessor->RemainHeader |
| { |
| memcpy(imageProcessor->AmebaHeader + HeaderOffset, block.data(), block.size()); |
| imageProcessor->RemainHeader -= block.size(); |
| } |
| } |
| else // received subsequent blocks |
| { |
| device_mutex_lock(RT_DEV_LOCK_FLASH); |
| if (ota_writestream_user(imageProcessor->flash_addr + imageProcessor->size, block.size(), block.data()) < 0) |
| { |
| ChipLogError(SoftwareUpdate, "Write to flash failed"); |
| device_mutex_unlock(RT_DEV_LOCK_FLASH); |
| imageProcessor->mDownloader->EndDownload(CHIP_ERROR_WRITE_FAILED); |
| return; |
| } |
| device_mutex_unlock(RT_DEV_LOCK_FLASH); |
| |
| imageProcessor->size += block.size(); |
| imageProcessor->RemainBytes -= block.size(); |
| } |
| #elif defined(CONFIG_PLATFORM_8710C) |
| if (imageProcessor->RemainHeader != 0) // Still not yet received full ameba header |
| { |
| if (block.size() >= imageProcessor->RemainHeader) |
| { |
| // Store signature temporarily |
| memcpy(imageProcessor->signature + HeaderOffset, block.data(), imageProcessor->RemainHeader); |
| |
| imageProcessor->block_len = block.size() - 32; // minus 32 to account for signature |
| |
| // Erase target partition |
| ChipLogProgress(SoftwareUpdate, "Erasing partition"); |
| imageProcessor->NewFWBlkSize = |
| ((0x1AC000 - 1) / 4096) + 1; // Use a fixed image length of 0x1AC000, change in the future |
| ChipLogProgress(SoftwareUpdate, "Erasing %d sectors", imageProcessor->NewFWBlkSize); |
| device_mutex_lock(RT_DEV_LOCK_FLASH); |
| for (int i = 0; i < imageProcessor->NewFWBlkSize; i++) |
| flash_erase_sector(&flash_ota, imageProcessor->flash_addr + i * 4096); |
| device_mutex_unlock(RT_DEV_LOCK_FLASH); |
| |
| // Write first block to target flash |
| if (imageProcessor->block_len > 0) |
| { |
| device_mutex_lock(RT_DEV_LOCK_FLASH); |
| if (flash_burst_write(&flash_ota, imageProcessor->flash_addr + 32, imageProcessor->block_len, block.data() + 32) < |
| 0) |
| { |
| device_mutex_unlock(RT_DEV_LOCK_FLASH); |
| ChipLogError(SoftwareUpdate, "Write to flash failed"); |
| imageProcessor->mDownloader->EndDownload(CHIP_ERROR_WRITE_FAILED); |
| return; |
| } |
| else |
| { |
| imageProcessor->size += imageProcessor->block_len; |
| device_mutex_unlock(RT_DEV_LOCK_FLASH); |
| } |
| } |
| else |
| { |
| ChipLogError(SoftwareUpdate, "Invalid size"); |
| imageProcessor->mDownloader->EndDownload(CHIP_ERROR_WRITE_FAILED); |
| return; |
| } |
| |
| imageProcessor->RemainHeader = 0; |
| } |
| else // block.size() < imageProcessor->RemainHeader |
| { |
| memcpy(imageProcessor->AmebaHeader + HeaderOffset, block.data(), block.size()); |
| imageProcessor->RemainHeader -= block.size(); |
| } |
| } |
| else // received subsequent blocks |
| { |
| imageProcessor->block_len = block.size(); |
| |
| if (imageProcessor->block_len > 0) |
| { |
| device_mutex_lock(RT_DEV_LOCK_FLASH); |
| if (flash_burst_write(&flash_ota, imageProcessor->flash_addr + 32 + imageProcessor->size, imageProcessor->block_len, |
| block.data()) < 0) |
| { |
| device_mutex_unlock(RT_DEV_LOCK_FLASH); |
| ChipLogError(SoftwareUpdate, "Write to flash failed"); |
| imageProcessor->mDownloader->EndDownload(CHIP_ERROR_WRITE_FAILED); |
| return; |
| } |
| else |
| { |
| imageProcessor->size += imageProcessor->block_len; |
| device_mutex_unlock(RT_DEV_LOCK_FLASH); |
| } |
| } |
| else |
| { |
| ChipLogError(SoftwareUpdate, "Invalid size"); |
| imageProcessor->mDownloader->EndDownload(CHIP_ERROR_WRITE_FAILED); |
| return; |
| } |
| } |
| #endif |
| imageProcessor->mParams.downloadedBytes += block.size(); |
| imageProcessor->mDownloader->FetchNextData(); |
| } |
| |
| void AmebaOTAImageProcessor::HandleApply(intptr_t context) |
| { |
| auto * imageProcessor = reinterpret_cast<AmebaOTAImageProcessor *>(context); |
| if (imageProcessor == nullptr) |
| { |
| ChipLogError(SoftwareUpdate, "ImageProcessor context is null"); |
| return; |
| } |
| |
| // Update signature |
| #if defined(CONFIG_PLATFORM_8721D) |
| if (change_ota_signature(imageProcessor->pOtaTgtHdr, imageProcessor->ota_target_index) != 1) |
| { |
| ota_update_free(imageProcessor->pOtaTgtHdr); |
| ChipLogError(SoftwareUpdate, "OTA update signature failed"); |
| return; |
| } |
| #elif defined(CONFIG_PLATFORM_8710C) |
| if (update_ota_signature(imageProcessor->signature, imageProcessor->flash_addr) < 0) |
| { |
| ChipLogError(SoftwareUpdate, "OTA update signature failed"); |
| return; |
| } |
| #endif |
| |
| #if defined(CONFIG_PLATFORM_8721D) |
| ota_update_free(imageProcessor->pOtaTgtHdr); |
| #endif |
| |
| ChipLogProgress(SoftwareUpdate, "Rebooting in 10 seconds..."); |
| |
| // Delay action time before calling HandleRestart |
| chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Milliseconds32(10 * 1000), HandleRestart, nullptr); |
| } |
| |
| void AmebaOTAImageProcessor::HandleRestart(chip::System::Layer * systemLayer, void * appState) |
| { |
| ota_platform_reset(); |
| } |
| |
| CHIP_ERROR AmebaOTAImageProcessor::ProcessHeader(ByteSpan & block) |
| { |
| ChipLogProgress(SoftwareUpdate, "ProcessHeader"); |
| if (mHeaderParser.IsInitialized()) |
| { |
| OTAImageHeader header; |
| CHIP_ERROR error = mHeaderParser.AccumulateAndDecode(block, header); |
| |
| // Needs more data to decode the header |
| ReturnErrorCodeIf(error == CHIP_ERROR_BUFFER_TOO_SMALL, CHIP_NO_ERROR); |
| ReturnErrorOnFailure(error); |
| |
| mParams.totalFileBytes = header.mPayloadSize; |
| mHeaderParser.Clear(); |
| } |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR AmebaOTAImageProcessor::SetBlock(ByteSpan & block) |
| { |
| if (!IsSpanUsable(block)) |
| { |
| ReleaseBlock(); |
| return CHIP_NO_ERROR; |
| } |
| |
| if (mBlock.size() < block.size()) |
| { |
| if (!mBlock.empty()) |
| { |
| ReleaseBlock(); |
| } |
| uint8_t * mBlock_ptr = static_cast<uint8_t *>(chip::Platform::MemoryAlloc(block.size())); |
| if (mBlock_ptr == nullptr) |
| { |
| return CHIP_ERROR_NO_MEMORY; |
| } |
| mBlock = MutableByteSpan(mBlock_ptr, block.size()); |
| } |
| |
| if (mBlock.size() < block.size()) |
| { |
| if (!mBlock.empty()) |
| { |
| ReleaseBlock(); |
| } |
| |
| uint8_t * mBlock_ptr = static_cast<uint8_t *>(chip::Platform::MemoryAlloc(block.size())); |
| |
| if (mBlock_ptr == nullptr) |
| { |
| return CHIP_ERROR_NO_MEMORY; |
| } |
| mBlock = MutableByteSpan(mBlock_ptr, block.size()); |
| } |
| |
| CHIP_ERROR err = CopySpanToMutableSpan(block, mBlock); |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(SoftwareUpdate, "Cannot copy block data: %" CHIP_ERROR_FORMAT, err.Format()); |
| return err; |
| } |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR AmebaOTAImageProcessor::ReleaseBlock() |
| { |
| if (mBlock.data() != nullptr) |
| { |
| chip::Platform::MemoryFree(mBlock.data()); |
| } |
| |
| mBlock = MutableByteSpan(); |
| return CHIP_NO_ERROR; |
| } |
| } // namespace chip |
