| /* |
| * |
| * 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 "OTAImageProcessorImpl.h" |
| #include <app/clusters/ota-requestor/OTADownloader.h> |
| |
| extern "C" { |
| #include "platform/bootloader/api/btl_interface.h" |
| } |
| |
| /// No error, operation OK |
| #define SL_BOOTLOADER_OK 0L |
| |
| namespace chip { |
| |
| // Define static memebers |
| uint8_t OTAImageProcessorImpl::mSlotId; |
| uint32_t OTAImageProcessorImpl::mWriteOffset; |
| |
| CHIP_ERROR OTAImageProcessorImpl::PrepareDownload() |
| { |
| if (mParams.imageFile.empty()) |
| { |
| ChipLogError(SoftwareUpdate, "Invalid output image file supplied"); |
| return CHIP_ERROR_INTERNAL; |
| } |
| |
| DeviceLayer::PlatformMgr().ScheduleWork(HandlePrepareDownload, reinterpret_cast<intptr_t>(this)); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR OTAImageProcessorImpl::Finalize() |
| { |
| DeviceLayer::PlatformMgr().ScheduleWork(HandleFinalize, reinterpret_cast<intptr_t>(this)); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR OTAImageProcessorImpl::Apply() |
| { |
| uint32_t err = SL_BOOTLOADER_OK; |
| |
| ChipLogError(SoftwareUpdate, "OTAImageProcessorImpl::Apply()"); |
| |
| // Assuming that bootloader_verifyImage() call is not too expensive and |
| // doesn't need to be offloaded to a different task. Revisit if necessary. |
| err = bootloader_verifyImage(mSlotId, NULL); |
| if (err != SL_BOOTLOADER_OK) |
| { |
| ChipLogError(SoftwareUpdate, "bootloader_verifyImage error %ld", err); |
| return CHIP_ERROR_INTERNAL; |
| } |
| |
| err = bootloader_setImageToBootload(mSlotId); |
| if (err != SL_BOOTLOADER_OK) |
| { |
| ChipLogError(SoftwareUpdate, "setImageToBootload error %ld", err); |
| return CHIP_ERROR_INTERNAL; |
| } |
| |
| // This reboots the device |
| bootloader_rebootAndInstall(); |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR OTAImageProcessorImpl::Abort() |
| { |
| if (mParams.imageFile.empty()) |
| { |
| ChipLogError(SoftwareUpdate, "Invalid output image file supplied"); |
| return CHIP_ERROR_INTERNAL; |
| } |
| |
| DeviceLayer::PlatformMgr().ScheduleWork(HandleAbort, reinterpret_cast<intptr_t>(this)); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR OTAImageProcessorImpl::ProcessBlock(ByteSpan & block) |
| { |
| if ((block.data() == nullptr) || block.empty()) |
| { |
| return CHIP_ERROR_INVALID_ARGUMENT; |
| } |
| |
| // Store block data for HandleProcessBlock to access |
| CHIP_ERROR err = SetBlock(block); |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(SoftwareUpdate, "Cannot set block data: %" CHIP_ERROR_FORMAT, err.Format()); |
| } |
| |
| DeviceLayer::PlatformMgr().ScheduleWork(HandleProcessBlock, reinterpret_cast<intptr_t>(this)); |
| return CHIP_NO_ERROR; |
| } |
| |
| void OTAImageProcessorImpl::HandlePrepareDownload(intptr_t context) |
| { |
| int32_t err = SL_BOOTLOADER_OK; |
| auto * imageProcessor = reinterpret_cast<OTAImageProcessorImpl *>(context); |
| |
| if (imageProcessor == nullptr) |
| { |
| ChipLogError(SoftwareUpdate, "ImageProcessor context is null"); |
| return; |
| } |
| else if (imageProcessor->mDownloader == nullptr) |
| { |
| ChipLogError(SoftwareUpdate, "mDownloader is null"); |
| return; |
| } |
| |
| bootloader_init(); |
| mSlotId = 0; // Single slot until we support multiple images |
| mWriteOffset = 0; |
| |
| // Not calling bootloader_eraseStorageSlot(mSlotId) here because we erase during each write |
| |
| imageProcessor->mDownloader->OnPreparedForDownload(err == SL_BOOTLOADER_OK ? CHIP_NO_ERROR : CHIP_ERROR_INTERNAL); |
| } |
| |
| void OTAImageProcessorImpl::HandleFinalize(intptr_t context) |
| { |
| auto * imageProcessor = reinterpret_cast<OTAImageProcessorImpl *>(context); |
| if (imageProcessor == nullptr) |
| { |
| return; |
| } |
| |
| imageProcessor->ReleaseBlock(); |
| |
| ChipLogProgress(SoftwareUpdate, "OTA image downloaded to %s", imageProcessor->mParams.imageFile.data()); |
| } |
| |
| void OTAImageProcessorImpl::HandleAbort(intptr_t context) |
| { |
| auto * imageProcessor = reinterpret_cast<OTAImageProcessorImpl *>(context); |
| if (imageProcessor == nullptr) |
| { |
| return; |
| } |
| |
| // Not clearing the image storage area as it is done during each write |
| imageProcessor->ReleaseBlock(); |
| } |
| |
| void OTAImageProcessorImpl::HandleProcessBlock(intptr_t context) |
| { |
| uint32_t err = SL_BOOTLOADER_OK; |
| auto * imageProcessor = reinterpret_cast<OTAImageProcessorImpl *>(context); |
| if (imageProcessor == nullptr) |
| { |
| ChipLogError(SoftwareUpdate, "ImageProcessor context is null"); |
| return; |
| } |
| else if (imageProcessor->mDownloader == nullptr) |
| { |
| ChipLogError(SoftwareUpdate, "mDownloader is null"); |
| return; |
| } |
| |
| // TODO: Process block header if any |
| |
| err = bootloader_eraseWriteStorage(mSlotId, mWriteOffset, reinterpret_cast<uint8_t *>(imageProcessor->mBlock.data()), |
| imageProcessor->mBlock.size()); |
| |
| if (err) |
| { |
| ChipLogError(SoftwareUpdate, "bootloader_eraseWriteStorage err %ld", err); |
| |
| imageProcessor->mDownloader->EndDownload(CHIP_ERROR_WRITE_FAILED); |
| return; |
| } |
| |
| mWriteOffset += imageProcessor->mBlock.size(); // Keep our own track of how far we've written |
| imageProcessor->mParams.downloadedBytes += imageProcessor->mBlock.size(); |
| imageProcessor->mDownloader->FetchNextData(); |
| } |
| |
| // Store block data for HandleProcessBlock to access |
| CHIP_ERROR OTAImageProcessorImpl::SetBlock(ByteSpan & block) |
| { |
| if ((block.data() == nullptr) || block.empty()) |
| { |
| return CHIP_NO_ERROR; |
| } |
| |
| // Allocate memory for block data if we don't have enough already |
| if (mBlock.size() < block.size()) |
| { |
| ReleaseBlock(); |
| |
| mBlock = MutableByteSpan(static_cast<uint8_t *>(chip::Platform::MemoryAlloc(block.size())), block.size()); |
| if (mBlock.data() == nullptr) |
| { |
| return CHIP_ERROR_NO_MEMORY; |
| } |
| } |
| |
| // Store the actual block data |
| 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 OTAImageProcessorImpl::ReleaseBlock() |
| { |
| if (mBlock.data() != nullptr) |
| { |
| chip::Platform::MemoryFree(mBlock.data()); |
| } |
| |
| mBlock = MutableByteSpan(); |
| return CHIP_NO_ERROR; |
| } |
| |
| } // namespace chip |