src/main/fc/firmware_update.c

   1 /*
   2  * This file is part of INAV.
   3  *
   4  * INAV is free software. You can redistribute this software
   5  * and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * INAV is distributed in the hope that they will be
  11  * useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24
  25 #include "platform.h"
  26
  27 #include "common/crc.h"
  28
  29 #include "drivers/flash.h"
  30 #include "drivers/light_led.h"
  31 #include "drivers/persistent.h"
  32 #include "drivers/system.h"
  33
  34 #include "fc/firmware_update.h"
  35 #include "fc/firmware_update_common.h"
  36 #include "fc/runtime_config.h"
  37
  38 #include "io/asyncfatfs/asyncfatfs.h"
  39
  40
  41 #ifdef MSP_FIRMWARE_UPDATE
  42
  43 #if !(defined(USE_FLASHFS) || defined(USE_SDCARD))
  44 #error No storage backend available
  45 #endif
  46
  47 static firmwareUpdateMetadata_t updateMetadata;
  48 static uint8_t updateFirmwareCalcCRC = 0;
  49 static uint32_t receivedSize = 0;
  50 static bool rollbackPrepared = false;
  51
  52 #if defined(USE_SDCARD)
  53 static uint32_t firmwareSize;
  54 static afatfsFilePtr_t updateFile = NULL;
  55 static afatfsFilePtr_t backupFile = NULL;
  56
  57 static void updateFileOpenCallback(afatfsFilePtr_t file)
  58 {
  59     updateFile = file;
  60 }
  61
  62 static void backupFileOpenCallback(afatfsFilePtr_t file)
  63 {
  64     backupFile = file;
  65 }
  66
  67 #elif defined(USE_FLASHFS)
  68 static uint32_t flashStartAddress, flashOverflowAddress;
  69
  70 #endif
  71
  72 static bool fullBackup(void)
  73 {
  74     const uint8_t *const backupSrcEnd = (const uint8_t*)FLASH_END;
  75     uint8_t *backupSrcPtr = (uint8_t*)&__firmware_start;
  76     uint32_t counter = 0;
  77     updateMetadata.backupCRC = 0;
  78
  79     LED0_OFF;
  80     LED1_OFF;
  81
  82 #if defined(USE_SDCARD)
  83     if ((afatfs_getFilesystemState() != AFATFS_FILESYSTEM_STATE_READY) || !afatfs_fopen(FIRMWARE_UPDATE_BACKUP_FILENAME, "w+", backupFileOpenCallback)) return false;
  84
  85     while (backupSrcPtr < backupSrcEnd) {
  86
  87         const uint16_t writeBlockSize = 512;
  88         uint32_t justWritten = afatfs_fwriteSync(backupFile, backupSrcPtr, writeBlockSize);
  89         updateMetadata.backupCRC = crc8_dvb_s2_update(updateMetadata.backupCRC, backupSrcPtr, justWritten);
  90
  91         afatfs_poll();
  92         backupSrcPtr += justWritten;
  93
  94         if (++counter % (50*1024/512) == 0) {
  95             LED0_TOGGLE;
  96             LED1_TOGGLE;
  97         }
  98
  99     }
 100
 101     afatfs_fcloseSync(backupFile);
 102
 103 #elif defined(USE_FLASHFS)
 104     flashPartition_t *flashPartition = flashPartitionFindByType(FLASH_PARTITION_TYPE_FULL_BACKUP);
 105     if (!flashPartition) return false;
 106
 107     const flashGeometry_t *flashGeometry = flashGetGeometry();
 108     const uint32_t flashSectorSize = flashGeometry->sectorSize;
 109     const uint32_t flashPartitionSize = (flashPartition->endSector - flashPartition->startSector + 1) * flashSectorSize;
 110     const uint32_t backupSize = AVAILABLE_FIRMWARE_SPACE;
 111     if (backupSize > flashPartitionSize) return false;
 112
 113     uint32_t flashAddress = flashPartition->startSector * flashSectorSize;
 114
 115     const uint32_t flashPageSize = flashGeometry->pageSize;
 116     while (backupSrcPtr < backupSrcEnd) {
 117
 118         if (flashAddress % flashSectorSize == 0) {
 119             flashEraseSector(flashAddress);
 120             flashWaitForReady(1000);
 121         }
 122
 123         flashPageProgram(flashAddress, backupSrcPtr, flashPageSize);
 124         updateMetadata.backupCRC = crc8_dvb_s2_update(updateMetadata.backupCRC, backupSrcPtr, flashPageSize);
 125
 126         flashAddress += flashPageSize;
 127         backupSrcPtr += flashPageSize;
 128
 129         if (++counter % (10*1024/256) == 0) {
 130             LED0_TOGGLE;
 131             LED1_TOGGLE;
 132         }
 133
 134     }
 135
 136 #endif
 137
 138     return true;
 139 }
 140
 141 static bool backupIsValid(void)
 142 {
 143     if (!firmwareUpdateMetadataRead(&updateMetadata) || (updateMetadata.magic != FIRMWARE_UPDATE_METADATA_MAGIC)) {
 144         return false;
 145     }
 146
 147     LED0_OFF;
 148     LED1_OFF;
 149
 150     uint32_t counter = 0;
 151     uint8_t calcCRC = 0;
 152
 153 #if defined(USE_SDCARD)
 154 #define SD_BACKUP_FILE_BLOCK_READ_SIZE 512
 155     if ((afatfs_getFilesystemState() != AFATFS_FILESYSTEM_STATE_READY) || !afatfs_fopen(FIRMWARE_UPDATE_BACKUP_FILENAME, "w+", backupFileOpenCallback)) return false;
 156
 157     uint32_t totalRead = 0;
 158
 159     uint8_t buffer[SD_BACKUP_FILE_BLOCK_READ_SIZE];
 160     while (!afatfs_feof(backupFile)) {
 161
 162         uint32_t readBytes = afatfs_freadSync(backupFile, buffer, SD_BACKUP_FILE_BLOCK_READ_SIZE);
 163         calcCRC = crc8_dvb_s2_update(calcCRC, buffer, readBytes);
 164
 165         totalRead += readBytes;
 166
 167         if (++counter % (50*1024/SD_BACKUP_FILE_BLOCK_READ_SIZE) == 0) {
 168             LED0_TOGGLE;
 169             LED1_TOGGLE;
 170         }
 171
 172     }
 173
 174     afatfs_fcloseSync(backupFile);
 175
 176 #elif defined(USE_FLASHFS)
 177     flashPartition_t *flashPartition = flashPartitionFindByType(FLASH_PARTITION_TYPE_FULL_BACKUP);
 178     if (!flashPartition) return false;
 179
 180     const flashGeometry_t *flashGeometry = flashGetGeometry();
 181     const uint32_t flashSectorSize = flashGeometry->sectorSize;
 182     const uint32_t flashPartitionSize = (flashPartition->endSector - flashPartition->startSector + 1) * flashSectorSize;
 183     const uint32_t backupSize = FLASH_END - (uint32_t)&__firmware_start;
 184     if (backupSize > flashPartitionSize) return false;
 185
 186     uint32_t flashAddress = flashPartition->startSector * flashSectorSize;
 187     const uint32_t flashEndAddress = flashAddress + backupSize;
 188
 189     uint8_t buffer[256];
 190     while (flashAddress < flashEndAddress) {
 191
 192         flashReadBytes(flashAddress, buffer, sizeof(buffer));
 193         calcCRC = crc8_dvb_s2_update(calcCRC, buffer, sizeof(buffer));
 194
 195         flashAddress += sizeof(buffer);
 196
 197         if (++counter % (10*1024/256) == 0) {
 198             LED0_TOGGLE;
 199             LED1_TOGGLE;
 200         }
 201
 202     }
 203
 204 #endif
 205
 206     return (calcCRC == updateMetadata.backupCRC);
 207 }
 208
 209 bool firmwareUpdatePrepare(uint32_t updateSize)
 210 {
 211     if (ARMING_FLAG(ARMED) || (updateSize > AVAILABLE_FIRMWARE_SPACE)) return false;
 212
 213 #if defined(USE_SDCARD)
 214     if ((afatfs_getFilesystemState() != AFATFS_FILESYSTEM_STATE_READY) || !afatfs_fopen(FIRMWARE_UPDATE_FIRMWARE_FILENAME, "w+", updateFileOpenCallback)) return false;
 215
 216     firmwareSize = updateSize;
 217
 218 #elif defined(USE_FLASHFS)
 219     flashPartition_t *flashUpdatePartition = flashPartitionFindByType(FLASH_PARTITION_TYPE_UPDATE_FIRMWARE);
 220     if (!flashUpdatePartition) return false;
 221
 222     const flashGeometry_t *flashGeometry = flashGetGeometry();
 223
 224     flashStartAddress = flashUpdatePartition->startSector * flashGeometry->sectorSize;
 225     flashOverflowAddress = ((flashUpdatePartition->endSector + 1) * flashGeometry->sectorSize);
 226     receivedSize = 0;
 227
 228     uint32_t partitionSize = (flashUpdatePartition->endSector - flashUpdatePartition->startSector + 1) * (flashGeometry->sectorSize * flashGeometry->pageSize);
 229
 230     if (updateSize > partitionSize) {
 231         return false;
 232     }
 233
 234     updateMetadata.firmwareSize = updateSize;
 235
 236 #endif
 237
 238     updateFirmwareCalcCRC = 0;
 239
 240     return true;
 241 }
 242
 243 bool firmwareUpdateStore(uint8_t *data, uint16_t length)
 244 {
 245     if (ARMING_FLAG(ARMED)) {
 246         return false;
 247     }
 248
 249 #if defined(USE_SDCARD)
 250
 251     if (!updateFile || !firmwareSize || (receivedSize + length > firmwareSize)
 252             || (afatfs_fwriteSync(updateFile, data, length) != length)) {
 253         return false;
 254     }
 255
 256 #elif defined(USE_FLASHFS)
 257     if  (!updateMetadata.firmwareSize || (receivedSize + length > updateMetadata.firmwareSize)) return false;
 258
 259     const uint32_t flashAddress = flashStartAddress + receivedSize;
 260
 261     if ((flashAddress + length > flashOverflowAddress) || (receivedSize + length > updateMetadata.firmwareSize)) {
 262         updateMetadata.firmwareSize = 0;
 263         return false;
 264     }
 265
 266     const flashGeometry_t *flashGeometry = flashGetGeometry();
 267     const uint32_t flashSectorSize = flashGeometry->sectorSize;
 268
 269     if (flashAddress % flashSectorSize == 0) {
 270         flashEraseSector(flashAddress);
 271         flashWaitForReady(1000);
 272     }
 273
 274     flashPageProgram(flashAddress, data, length);
 275
 276 #endif
 277
 278     updateFirmwareCalcCRC = crc8_dvb_s2_update(updateFirmwareCalcCRC, data, length);
 279     receivedSize += length;
 280
 281     return true;
 282 }
 283
 284 void firmwareUpdateExec(uint8_t expectCRC)
 285 {
 286     if (ARMING_FLAG(ARMED)) return;
 287
 288 #if defined(USE_SDCARD)
 289     if (!afatfs_fclose(updateFile, NULL)) return;
 290     if (firmwareSize && (receivedSize == firmwareSize) &&
 291             (updateFirmwareCalcCRC == expectCRC) && fullBackup() && firmwareUpdateMetadataWrite(&updateMetadata)) {
 292         systemResetRequest(RESET_BOOTLOADER_FIRMWARE_UPDATE);
 293     }
 294 #elif defined(USE_FLASHFS)
 295     if (updateMetadata.firmwareSize && (receivedSize == updateMetadata.firmwareSize) &&
 296             (updateFirmwareCalcCRC == expectCRC) && fullBackup() && firmwareUpdateMetadataWrite(&updateMetadata)) {
 297         systemResetRequest(RESET_BOOTLOADER_FIRMWARE_UPDATE);
 298     }
 299 #endif
 300
 301 }
 302
 303 bool firmwareUpdateRollbackPrepare(void)
 304 {
 305     if (ARMING_FLAG(ARMED) || !(rollbackPrepared || backupIsValid())) return false;
 306
 307     rollbackPrepared = true;
 308     return true;
 309 }
 310
 311 void firmwareUpdateRollbackExec(void)
 312 {
 313     if (ARMING_FLAG(ARMED) || !firmwareUpdateRollbackPrepare()) return;
 314
 315     systemResetRequest(RESET_BOOTLOADER_FIRMWARE_ROLLBACK);
 316 }
 317
 318 #endif