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