src/main/drivers/flash.c

   1 /*
   2  * This file is part of iNav.
   3  *
   4  * iNav is free software. You can redistribute
   5  * this software 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 it
  11  * will be 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 "build/debug.h"
  28
  29 #ifdef USE_FLASHFS
  30
  31 #include "flash.h"
  32 #include "flash_m25p16.h"
  33
  34 #include "common/time.h"
  35
  36 #include "drivers/bus_spi.h"
  37 #include "drivers/io.h"
  38 #include "drivers/time.h"
  39
  40 static flashPartitionTable_t flashPartitionTable;
  41 static int flashPartitions = 0;
  42
  43
  44 #ifdef USE_SPI
  45 static bool flashSpiInit(void)
  46 {
  47 #ifdef USE_FLASH_M25P16
  48     return m25p16_init(0);
  49 #endif
  50     return false;
  51 }
  52 #endif // USE_SPI
  53
  54 bool flashDeviceInit(void)
  55 {
  56 #ifdef USE_SPI
  57     return flashSpiInit();
  58 #endif
  59
  60     return false;
  61 }
  62
  63 bool flashIsReady(void)
  64 {
  65 #ifdef USE_FLASH_M25P16
  66     return m25p16_isReady();
  67 #endif
  68     return false;
  69 }
  70
  71 bool flashWaitForReady(timeMs_t timeoutMillis)
  72 {
  73 #ifdef USE_FLASH_M25P16
  74     return m25p16_waitForReady(timeoutMillis);
  75 #endif
  76     return false;
  77 }
  78
  79 void flashEraseSector(uint32_t address)
  80 {
  81 #ifdef USE_FLASH_M25P16
  82     return m25p16_eraseSector(address);
  83 #endif
  84 }
  85
  86 void flashEraseCompletely(void)
  87 {
  88 #ifdef USE_FLASH_M25P16
  89     return m25p16_eraseCompletely();
  90 #endif
  91 }
  92
  93 #if 0
  94 void flashPageProgramBegin(uint32_t address)
  95 {
  96 #ifdef USE_FLASH_M25P16
  97     return m25p16_pageProgramBegin(address);
  98 #endif
  99 }
 100
 101 void flashPageProgramContinue(const uint8_t *data, int length)
 102 {
 103 #ifdef USE_FLASH_M25P16
 104     return m25p16_pageProgramContinue(data, length);
 105 #endif
 106 }
 107
 108 void flashPageProgramFinish(void)
 109 {
 110 #ifdef USE_FLASH_M25P16
 111     return m25p16_pageProgramFinish();
 112 #endif
 113 }
 114 #endif
 115
 116 uint32_t flashPageProgram(uint32_t address, const uint8_t *data, int length)
 117 {
 118 #ifdef USE_FLASH_M25P16
 119     return m25p16_pageProgram(address, data, length);
 120 #endif
 121 }
 122
 123 int flashReadBytes(uint32_t address, uint8_t *buffer, int length)
 124 {
 125 #ifdef USE_FLASH_M25P16
 126     return m25p16_readBytes(address, buffer, length);
 127 #endif
 128     return 0;
 129 }
 130
 131 void flashFlush(void)
 132 {
 133 }
 134
 135 const flashGeometry_t *flashGetGeometry(void)
 136 {
 137 #ifdef USE_FLASH_M25P16
 138     return m25p16_getGeometry();
 139 #endif
 140
 141     return NULL;
 142 }
 143
 144 /*
 145  * Flash partitioning
 146  *
 147  * Partition table is not currently stored on the flash, in-memory only.
 148  *
 149  * Partitions are required so that Badblock management (inc spare blocks), FlashFS (Blackbox Logging), Configuration and Firmware can be kept separate and tracked.
 150  *
 151  * XXX FIXME
 152  * XXX Note that Flash FS must start at sector 0.
 153  * XXX There is existing blackbox/flash FS code the relies on this!!!
 154  * XXX This restriction can and will be fixed by creating a set of flash operation functions that take partition as an additional parameter.
 155  */
 156
 157 static __attribute__((unused)) void createPartition(flashPartitionType_e type, uint32_t size, flashSector_t *endSector)
 158 {
 159     const flashGeometry_t *flashGeometry = flashGetGeometry();
 160     flashSector_t partitionSectors = (size / flashGeometry->sectorSize);
 161
 162     if (size % flashGeometry->sectorSize > 0) {
 163         partitionSectors++; // needs a portion of a sector.
 164     }
 165
 166     flashSector_t startSector = (*endSector + 1) - partitionSectors; // + 1 for inclusive
 167
 168     flashPartitionSet(type, startSector, *endSector);
 169
 170     *endSector = startSector - 1;
 171 }
 172
 173 static void flashConfigurePartitions(void)
 174 {
 175     const flashGeometry_t *flashGeometry = flashGetGeometry();
 176     if (flashGeometry->totalSize == 0) {
 177         return;
 178     }
 179
 180     flashSector_t startSector = 0;
 181     flashSector_t endSector = flashGeometry->sectors - 1; // 0 based index
 182
 183     const flashPartition_t *badBlockPartition = flashPartitionFindByType(FLASH_PARTITION_TYPE_BADBLOCK_MANAGEMENT);
 184     if (badBlockPartition) {
 185         endSector = badBlockPartition->startSector - 1;
 186     }
 187
 188 #if defined(FIRMWARE_SIZE)
 189     createPartition(FLASH_PARTITION_TYPE_FIRMWARE, FIRMWARE_SIZE * 1024, &endSector);
 190 #endif
 191
 192 #if defined(MSP_FIRMWARE_UPDATE)
 193     createPartition(FLASH_PARTITION_TYPE_FIRMWARE_UPDATE_META, flashGeometry->sectorSize, &endSector);
 194     createPartition(FLASH_PARTITION_TYPE_UPDATE_FIRMWARE, MCU_FLASH_SIZE * 1024, &endSector);
 195     createPartition(FLASH_PARTITION_TYPE_FULL_BACKUP, MCU_FLASH_SIZE * 1024, &endSector);
 196 #endif
 197
 198 #if defined(CONFIG_IN_EXTERNAL_FLASH)
 199     uint32_t configSize = EEPROM_SIZE;
 200     flashSector_t configSectors = (configSize / flashGeometry->sectorSize);
 201
 202     if (configSize % flashGeometry->sectorSize > 0) {
 203         configSectors++; // needs a portion of a sector.
 204     }
 205     configSize = configSectors * flashGeometry->sectorSize;
 206
 207     createPartition(FLASH_PARTITION_TYPE_CONFIG, configSize, &endSector);
 208 #endif
 209
 210 #ifdef USE_FLASHFS
 211     flashPartitionSet(FLASH_PARTITION_TYPE_FLASHFS, startSector, endSector);
 212 #endif
 213 }
 214
 215 flashPartition_t *flashPartitionFindByType(uint8_t type)
 216 {
 217     for (int index = 0; index < FLASH_MAX_PARTITIONS; index++) {
 218         flashPartition_t *candidate = &flashPartitionTable.partitions[index];
 219         if (candidate->type == type) {
 220             return candidate;
 221         }
 222     }
 223
 224     return NULL;
 225 }
 226
 227 const flashPartition_t *flashPartitionFindByIndex(uint8_t index)
 228 {
 229     if (index >= flashPartitions) {
 230         return NULL;
 231     }
 232
 233     return &flashPartitionTable.partitions[index];
 234 }
 235
 236 void flashPartitionSet(uint8_t type, uint32_t startSector, uint32_t endSector)
 237 {
 238     flashPartition_t *entry = flashPartitionFindByType(type);
 239
 240     if (!entry) {
 241         if (flashPartitions == FLASH_MAX_PARTITIONS - 1) {
 242             return;
 243         }
 244         entry = &flashPartitionTable.partitions[flashPartitions++];
 245     }
 246
 247     entry->type = type;
 248     entry->startSector = startSector;
 249     entry->endSector = endSector;
 250 }
 251
 252 // Must be in sync with FLASH_PARTITION_TYPE
 253 static const char *flashPartitionNames[] = {
 254     "UNKNOWN  ",
 255     "PARTITION",
 256     "FLASHFS  ",
 257     "BBMGMT   ",
 258     "FIRMWARE ",
 259     "CONFIG   ",
 260     "FW UPDT  ",
 261 };
 262
 263 const char *flashPartitionGetTypeName(flashPartitionType_e type)
 264 {
 265     if (type < ARRAYLEN(flashPartitionNames)) {
 266         return flashPartitionNames[type];
 267     }
 268
 269     return NULL;
 270 }
 271
 272 bool flashInit(void)
 273 {
 274     memset(&flashPartitionTable, 0x00, sizeof(flashPartitionTable));
 275
 276     bool haveFlash = flashDeviceInit();
 277
 278     flashConfigurePartitions();
 279
 280     return haveFlash;
 281 }
 282
 283 int flashPartitionCount(void)
 284 {
 285     return flashPartitions;
 286 }
 287
 288 uint32_t flashPartitionSize(flashPartition_t *partition)
 289 {
 290     const flashGeometry_t * const geometry = flashGetGeometry();
 291     return (partition->endSector - partition->startSector + 1) * geometry->sectorSize;
 292 }
 293
 294 void flashPartitionErase(flashPartition_t *partition)
 295 {
 296     const flashGeometry_t * const geometry = flashGetGeometry();
 297
 298     // if there's a single FLASHFS partition and it uses the entire flash then do a full erase
 299     const bool doFullErase = (flashPartitionCount() == 1) && (FLASH_PARTITION_SECTOR_COUNT(partition) == geometry->sectors);
 300     if (doFullErase) {
 301         flashEraseCompletely();
 302         return;
 303     }
 304
 305     for (unsigned i = partition->startSector; i <= partition->endSector; i++) {
 306         uint32_t flashAddress = geometry->sectorSize * i;
 307         flashEraseSector(flashAddress);
 308         flashWaitForReady(0);
 309     }
 310 }
 311 #endif // USE_FLASH_CHIP